diff --git a/go.mod b/go.mod
index 944cf70c..3f89a9d6 100644
--- a/go.mod
+++ b/go.mod
@@ -9,8 +9,8 @@ require (
github.com/csi-addons/spec v0.2.0
github.com/go-logr/logr v1.4.3
github.com/kubernetes-csi/csi-lib-utils v0.22.0
- github.com/onsi/ginkgo/v2 v2.23.4
- github.com/onsi/gomega v1.38.0
+ github.com/onsi/ginkgo/v2 v2.26.0
+ github.com/onsi/gomega v1.38.2
github.com/stretchr/testify v1.10.0
go.uber.org/zap v1.27.0
google.golang.org/grpc v1.74.2
@@ -21,6 +21,7 @@ require (
)
require (
+ github.com/Masterminds/semver/v3 v3.4.0 // indirect
github.com/beorn7/perks v1.0.1 // indirect
github.com/blang/semver/v4 v4.0.0 // indirect
github.com/cespare/xxhash/v2 v2.3.0 // indirect
@@ -64,17 +65,19 @@ require (
go.opentelemetry.io/otel/trace v1.36.0 // indirect
go.uber.org/automaxprocs v1.6.0 // indirect
go.uber.org/multierr v1.11.0 // indirect
- golang.org/x/net v0.41.0 // indirect
+ go.yaml.in/yaml/v3 v3.0.4 // indirect
+ golang.org/x/mod v0.27.0 // indirect
+ golang.org/x/net v0.43.0 // indirect
golang.org/x/oauth2 v0.30.0 // indirect
- golang.org/x/sync v0.15.0 // indirect
- golang.org/x/sys v0.33.0 // indirect
- golang.org/x/term v0.32.0 // indirect
- golang.org/x/text v0.26.0 // indirect
+ golang.org/x/sync v0.16.0 // indirect
+ golang.org/x/sys v0.35.0 // indirect
+ golang.org/x/term v0.34.0 // indirect
+ golang.org/x/text v0.28.0 // indirect
golang.org/x/time v0.9.0 // indirect
- golang.org/x/tools v0.33.0 // indirect
+ golang.org/x/tools v0.36.0 // indirect
gomodules.xyz/jsonpatch/v2 v2.4.0 // indirect
google.golang.org/genproto/googleapis/rpc v0.0.0-20250528174236-200df99c418a // indirect
- google.golang.org/protobuf v1.36.6 // indirect
+ google.golang.org/protobuf v1.36.7 // indirect
gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect
gopkg.in/inf.v0 v0.9.1 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
diff --git a/go.sum b/go.sum
index f9ed6a38..1388cb53 100644
--- a/go.sum
+++ b/go.sum
@@ -1,5 +1,7 @@
github.com/IBM/csi-volume-group-operator v0.9.2 h1:ZOYaUR5xdHN2bvwguvs03EjFjtwMp+v1qzT+DnUS6VU=
github.com/IBM/csi-volume-group-operator v0.9.2/go.mod h1:nEZf/HwMnkXk4Z4/M9+o9qJohyK3zIZDRiGJV7rBnxQ=
+github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
+github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
github.com/blang/semver/v4 v4.0.0 h1:1PFHFE6yCCTv8C1TeyNNarDzntLi7wMI5i/pzqYIsAM=
@@ -24,6 +26,12 @@ github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nos
github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
github.com/fxamacker/cbor/v2 v2.7.0 h1:iM5WgngdRBanHcxugY4JySA0nk1wZorNOpTgCMedv5E=
github.com/fxamacker/cbor/v2 v2.7.0/go.mod h1:pxXPTn3joSm21Gbwsv0w9OSA2y1HFR9qXEeXQVeNoDQ=
+github.com/gkampitakis/ciinfo v0.3.2 h1:JcuOPk8ZU7nZQjdUhctuhQofk7BGHuIy0c9Ez8BNhXs=
+github.com/gkampitakis/ciinfo v0.3.2/go.mod h1:1NIwaOcFChN4fa/B0hEBdAb6npDlFL8Bwx4dfRLRqAo=
+github.com/gkampitakis/go-diff v1.3.2 h1:Qyn0J9XJSDTgnsgHRdz9Zp24RaJeKMUHg2+PDZZdC4M=
+github.com/gkampitakis/go-diff v1.3.2/go.mod h1:LLgOrpqleQe26cte8s36HTWcTmMEur6OPYerdAAS9tk=
+github.com/gkampitakis/go-snaps v0.5.14 h1:3fAqdB6BCPKHDMHAKRwtPUwYexKtGrNuw8HX/T/4neo=
+github.com/gkampitakis/go-snaps v0.5.14/go.mod h1:HNpx/9GoKisdhw9AFOBT1N7DBs9DiHo/hGheFGBZ+mc=
github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
@@ -39,6 +47,8 @@ github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+Gr
github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ=
github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1vB6EwHI=
github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8=
+github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
+github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
@@ -59,6 +69,8 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY=
github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y=
+github.com/joshdk/go-junit v1.0.0 h1:S86cUKIdwBHWwA6xCmFlf3RTLfVXYQfvanM5Uh+K6GE=
+github.com/joshdk/go-junit v1.0.0/go.mod h1:TiiV0PqkaNfFXjEiyjWM3XXrhVyCa1K4Zfga6W52ung=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
@@ -75,6 +87,10 @@ github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0
github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
github.com/mailru/easyjson v0.9.0 h1:PrnmzHw7262yW8sTBwxi1PdJA3Iw/EKBa8psRf7d9a4=
github.com/mailru/easyjson v0.9.0/go.mod h1:1+xMtQp2MRNVL/V1bOzuP3aP8VNwRW55fQUto+XFtTU=
+github.com/maruel/natural v1.1.1 h1:Hja7XhhmvEFhcByqDoHz9QZbkWey+COd9xWfCfn1ioo=
+github.com/maruel/natural v1.1.1/go.mod h1:v+Rfd79xlw1AgVBjbO0BEQmptqb5HvL/k9GRHB7ZKEg=
+github.com/mfridman/tparse v0.18.0 h1:wh6dzOKaIwkUGyKgOntDW4liXSo37qg5AXbIhkMV3vE=
+github.com/mfridman/tparse v0.18.0/go.mod h1:gEvqZTuCgEhPbYk/2lS3Kcxg1GmTxxU7kTC8DvP0i/A=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -82,10 +98,10 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
-github.com/onsi/ginkgo/v2 v2.23.4 h1:ktYTpKJAVZnDT4VjxSbiBenUjmlL/5QkBEocaWXiQus=
-github.com/onsi/ginkgo/v2 v2.23.4/go.mod h1:Bt66ApGPBFzHyR+JO10Zbt0Gsp4uWxu5mIOTusL46e8=
-github.com/onsi/gomega v1.38.0 h1:c/WX+w8SLAinvuKKQFh77WEucCnPk4j2OTUr7lt7BeY=
-github.com/onsi/gomega v1.38.0/go.mod h1:OcXcwId0b9QsE7Y49u+BTrL4IdKOBOKnD6VQNTJEB6o=
+github.com/onsi/ginkgo/v2 v2.26.0 h1:1J4Wut1IlYZNEAWIV3ALrT9NfiaGW2cDCJQSFQMs/gE=
+github.com/onsi/ginkgo/v2 v2.26.0/go.mod h1:qhEywmzWTBUY88kfO0BRvX4py7scov9yR+Az2oavUzw=
+github.com/onsi/gomega v1.38.2 h1:eZCjf2xjZAqe+LeWvKb5weQ+NcPwX84kqJ0cZNxok2A=
+github.com/onsi/gomega v1.38.2/go.mod h1:W2MJcYxRGV63b418Ai34Ud0hEdTVXq9NW9+Sx6uXf3k=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
@@ -111,6 +127,14 @@ github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/tidwall/gjson v1.18.0 h1:FIDeeyB800efLX89e5a8Y0BNH+LOngJyGrIWxG2FKQY=
+github.com/tidwall/gjson v1.18.0/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk=
+github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA=
+github.com/tidwall/match v1.1.1/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM=
+github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
+github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/tidwall/sjson v1.2.5 h1:kLy8mja+1c9jlljvWTlSazM7cKDRfJuR/bOJhcY5NcY=
+github.com/tidwall/sjson v1.2.5/go.mod h1:Fvgq9kS/6ociJEDnK0Fk1cpYF4FIW6ZF7LAe+6jwd28=
github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -137,43 +161,47 @@ go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8=
go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E=
+go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
+go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
+golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
-golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=
golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/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.15.0 h1:KWH3jNZsfyT6xfAfKiz6MRNmd46ByHDYaZ7KSkCtdW8=
-golang.org/x/sync v0.15.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
-golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4=
+golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.26.0 h1:P42AVeLghgTYr4+xUnTRKDMqpar+PtX7KWuNQL21L8M=
-golang.org/x/text v0.26.0/go.mod h1:QK15LZJUUQVJxhz7wXgxSy/CJaTFjd0G+YLonydOVQA=
+golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
+golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
golang.org/x/time v0.9.0 h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY=
golang.org/x/time v0.9.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc=
-golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=
+golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=
+golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -184,8 +212,8 @@ google.golang.org/genproto/googleapis/rpc v0.0.0-20250528174236-200df99c418a h1:
google.golang.org/genproto/googleapis/rpc v0.0.0-20250528174236-200df99c418a/go.mod h1:qQ0YXyHHx3XkvlzUtpXDkS29lDSafHMZBAZDc03LQ3A=
google.golang.org/grpc v1.74.2 h1:WoosgB65DlWVC9FqI82dGsZhWFNBSLjQ84bjROOpMu4=
google.golang.org/grpc v1.74.2/go.mod h1:CtQ+BGjaAIXHs/5YS3i473GqwBBa1zGQNevxdeBEXrM=
-google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
-google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+google.golang.org/protobuf v1.36.7 h1:IgrO7UwFQGJdRNXH/sQux4R1Dj1WAKcLElzeeRaXV2A=
+google.golang.org/protobuf v1.36.7/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
diff --git a/vendor/github.com/Masterminds/semver/v3/.gitignore b/vendor/github.com/Masterminds/semver/v3/.gitignore
new file mode 100644
index 00000000..6b061e61
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/v3/.gitignore
@@ -0,0 +1 @@
+_fuzz/
\ No newline at end of file
diff --git a/vendor/github.com/Masterminds/semver/v3/.golangci.yml b/vendor/github.com/Masterminds/semver/v3/.golangci.yml
new file mode 100644
index 00000000..fbc63325
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/v3/.golangci.yml
@@ -0,0 +1,27 @@
+run:
+ deadline: 2m
+
+linters:
+ disable-all: true
+ enable:
+ - misspell
+ - govet
+ - staticcheck
+ - errcheck
+ - unparam
+ - ineffassign
+ - nakedret
+ - gocyclo
+ - dupl
+ - goimports
+ - revive
+ - gosec
+ - gosimple
+ - typecheck
+ - unused
+
+linters-settings:
+ gofmt:
+ simplify: true
+ dupl:
+ threshold: 600
diff --git a/vendor/github.com/Masterminds/semver/v3/CHANGELOG.md b/vendor/github.com/Masterminds/semver/v3/CHANGELOG.md
new file mode 100644
index 00000000..fabe5e43
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/v3/CHANGELOG.md
@@ -0,0 +1,268 @@
+# Changelog
+
+## 3.4.0 (2025-06-27)
+
+### Added
+
+- #268: Added property to Constraints to include prereleases for Check and Validate
+
+### Changed
+
+- #263: Updated Go testing for 1.24, 1.23, and 1.22
+- #269: Updated the error message handling for message case and wrapping errors
+- #266: Restore the ability to have leading 0's when parsing with NewVersion.
+ Opt-out of this by setting CoerceNewVersion to false.
+
+### Fixed
+
+- #257: Fixed the CodeQL link (thanks @dmitris)
+- #262: Restored detailed errors when failed to parse with NewVersion. Opt-out
+ of this by setting DetailedNewVersionErrors to false for faster performance.
+- #267: Handle pre-releases for an "and" group if one constraint includes them
+
+## 3.3.1 (2024-11-19)
+
+### Fixed
+
+- #253: Fix for allowing some version that were invalid
+
+## 3.3.0 (2024-08-27)
+
+### Added
+
+- #238: Add LessThanEqual and GreaterThanEqual functions (thanks @grosser)
+- #213: nil version equality checking (thanks @KnutZuidema)
+
+### Changed
+
+- #241: Simplify StrictNewVersion parsing (thanks @grosser)
+- Testing support up through Go 1.23
+- Minimum version set to 1.21 as this is what's tested now
+- Fuzz testing now supports caching
+
+## 3.2.1 (2023-04-10)
+
+### Changed
+
+- #198: Improved testing around pre-release names
+- #200: Improved code scanning with addition of CodeQL
+- #201: Testing now includes Go 1.20. Go 1.17 has been dropped
+- #202: Migrated Fuzz testing to Go built-in Fuzzing. CI runs daily
+- #203: Docs updated for security details
+
+### Fixed
+
+- #199: Fixed issue with range transformations
+
+## 3.2.0 (2022-11-28)
+
+### Added
+
+- #190: Added text marshaling and unmarshaling
+- #167: Added JSON marshalling for constraints (thanks @SimonTheLeg)
+- #173: Implement encoding.TextMarshaler and encoding.TextUnmarshaler on Version (thanks @MarkRosemaker)
+- #179: Added New() version constructor (thanks @kazhuravlev)
+
+### Changed
+
+- #182/#183: Updated CI testing setup
+
+### Fixed
+
+- #186: Fixing issue where validation of constraint section gave false positives
+- #176: Fix constraints check with *-0 (thanks @mtt0)
+- #181: Fixed Caret operator (^) gives unexpected results when the minor version in constraint is 0 (thanks @arshchimni)
+- #161: Fixed godoc (thanks @afirth)
+
+## 3.1.1 (2020-11-23)
+
+### Fixed
+
+- #158: Fixed issue with generated regex operation order that could cause problem
+
+## 3.1.0 (2020-04-15)
+
+### Added
+
+- #131: Add support for serializing/deserializing SQL (thanks @ryancurrah)
+
+### Changed
+
+- #148: More accurate validation messages on constraints
+
+## 3.0.3 (2019-12-13)
+
+### Fixed
+
+- #141: Fixed issue with <= comparison
+
+## 3.0.2 (2019-11-14)
+
+### Fixed
+
+- #134: Fixed broken constraint checking with ^0.0 (thanks @krmichelos)
+
+## 3.0.1 (2019-09-13)
+
+### Fixed
+
+- #125: Fixes issue with module path for v3
+
+## 3.0.0 (2019-09-12)
+
+This is a major release of the semver package which includes API changes. The Go
+API is compatible with ^1. The Go API was not changed because many people are using
+`go get` without Go modules for their applications and API breaking changes cause
+errors which we have or would need to support.
+
+The changes in this release are the handling based on the data passed into the
+functions. These are described in the added and changed sections below.
+
+### Added
+
+- StrictNewVersion function. This is similar to NewVersion but will return an
+ error if the version passed in is not a strict semantic version. For example,
+ 1.2.3 would pass but v1.2.3 or 1.2 would fail because they are not strictly
+ speaking semantic versions. This function is faster, performs fewer operations,
+ and uses fewer allocations than NewVersion.
+- Fuzzing has been performed on NewVersion, StrictNewVersion, and NewConstraint.
+ The Makefile contains the operations used. For more information on you can start
+ on Wikipedia at https://en.wikipedia.org/wiki/Fuzzing
+- Now using Go modules
+
+### Changed
+
+- NewVersion has proper prerelease and metadata validation with error messages
+ to signal an issue with either of them
+- ^ now operates using a similar set of rules to npm/js and Rust/Cargo. If the
+ version is >=1 the ^ ranges works the same as v1. For major versions of 0 the
+ rules have changed. The minor version is treated as the stable version unless
+ a patch is specified and then it is equivalent to =. One difference from npm/js
+ is that prereleases there are only to a specific version (e.g. 1.2.3).
+ Prereleases here look over multiple versions and follow semantic version
+ ordering rules. This pattern now follows along with the expected and requested
+ handling of this packaged by numerous users.
+
+## 1.5.0 (2019-09-11)
+
+### Added
+
+- #103: Add basic fuzzing for `NewVersion()` (thanks @jesse-c)
+
+### Changed
+
+- #82: Clarify wildcard meaning in range constraints and update tests for it (thanks @greysteil)
+- #83: Clarify caret operator range for pre-1.0.0 dependencies (thanks @greysteil)
+- #72: Adding docs comment pointing to vert for a cli
+- #71: Update the docs on pre-release comparator handling
+- #89: Test with new go versions (thanks @thedevsaddam)
+- #87: Added $ to ValidPrerelease for better validation (thanks @jeremycarroll)
+
+### Fixed
+
+- #78: Fix unchecked error in example code (thanks @ravron)
+- #70: Fix the handling of pre-releases and the 0.0.0 release edge case
+- #97: Fixed copyright file for proper display on GitHub
+- #107: Fix handling prerelease when sorting alphanum and num
+- #109: Fixed where Validate sometimes returns wrong message on error
+
+## 1.4.2 (2018-04-10)
+
+### Changed
+
+- #72: Updated the docs to point to vert for a console appliaction
+- #71: Update the docs on pre-release comparator handling
+
+### Fixed
+
+- #70: Fix the handling of pre-releases and the 0.0.0 release edge case
+
+## 1.4.1 (2018-04-02)
+
+### Fixed
+
+- Fixed #64: Fix pre-release precedence issue (thanks @uudashr)
+
+## 1.4.0 (2017-10-04)
+
+### Changed
+
+- #61: Update NewVersion to parse ints with a 64bit int size (thanks @zknill)
+
+## 1.3.1 (2017-07-10)
+
+### Fixed
+
+- Fixed #57: number comparisons in prerelease sometimes inaccurate
+
+## 1.3.0 (2017-05-02)
+
+### Added
+
+- #45: Added json (un)marshaling support (thanks @mh-cbon)
+- Stability marker. See https://masterminds.github.io/stability/
+
+### Fixed
+
+- #51: Fix handling of single digit tilde constraint (thanks @dgodd)
+
+### Changed
+
+- #55: The godoc icon moved from png to svg
+
+## 1.2.3 (2017-04-03)
+
+### Fixed
+
+- #46: Fixed 0.x.x and 0.0.x in constraints being treated as *
+
+## Release 1.2.2 (2016-12-13)
+
+### Fixed
+
+- #34: Fixed issue where hyphen range was not working with pre-release parsing.
+
+## Release 1.2.1 (2016-11-28)
+
+### Fixed
+
+- #24: Fixed edge case issue where constraint "> 0" does not handle "0.0.1-alpha"
+ properly.
+
+## Release 1.2.0 (2016-11-04)
+
+### Added
+
+- #20: Added MustParse function for versions (thanks @adamreese)
+- #15: Added increment methods on versions (thanks @mh-cbon)
+
+### Fixed
+
+- Issue #21: Per the SemVer spec (section 9) a pre-release is unstable and
+ might not satisfy the intended compatibility. The change here ignores pre-releases
+ on constraint checks (e.g., ~ or ^) when a pre-release is not part of the
+ constraint. For example, `^1.2.3` will ignore pre-releases while
+ `^1.2.3-alpha` will include them.
+
+## Release 1.1.1 (2016-06-30)
+
+### Changed
+
+- Issue #9: Speed up version comparison performance (thanks @sdboyer)
+- Issue #8: Added benchmarks (thanks @sdboyer)
+- Updated Go Report Card URL to new location
+- Updated Readme to add code snippet formatting (thanks @mh-cbon)
+- Updating tagging to v[SemVer] structure for compatibility with other tools.
+
+## Release 1.1.0 (2016-03-11)
+
+- Issue #2: Implemented validation to provide reasons a versions failed a
+ constraint.
+
+## Release 1.0.1 (2015-12-31)
+
+- Fixed #1: * constraint failing on valid versions.
+
+## Release 1.0.0 (2015-10-20)
+
+- Initial release
diff --git a/vendor/github.com/Masterminds/semver/v3/LICENSE.txt b/vendor/github.com/Masterminds/semver/v3/LICENSE.txt
new file mode 100644
index 00000000..9ff7da9c
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/v3/LICENSE.txt
@@ -0,0 +1,19 @@
+Copyright (C) 2014-2019, Matt Butcher and Matt Farina
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/Masterminds/semver/v3/Makefile b/vendor/github.com/Masterminds/semver/v3/Makefile
new file mode 100644
index 00000000..9ca87a2c
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/v3/Makefile
@@ -0,0 +1,31 @@
+GOPATH=$(shell go env GOPATH)
+GOLANGCI_LINT=$(GOPATH)/bin/golangci-lint
+
+.PHONY: lint
+lint: $(GOLANGCI_LINT)
+ @echo "==> Linting codebase"
+ @$(GOLANGCI_LINT) run
+
+.PHONY: test
+test:
+ @echo "==> Running tests"
+ GO111MODULE=on go test -v
+
+.PHONY: test-cover
+test-cover:
+ @echo "==> Running Tests with coverage"
+ GO111MODULE=on go test -cover .
+
+.PHONY: fuzz
+fuzz:
+ @echo "==> Running Fuzz Tests"
+ go env GOCACHE
+ go test -fuzz=FuzzNewVersion -fuzztime=15s .
+ go test -fuzz=FuzzStrictNewVersion -fuzztime=15s .
+ go test -fuzz=FuzzNewConstraint -fuzztime=15s .
+
+$(GOLANGCI_LINT):
+ # Install golangci-lint. The configuration for it is in the .golangci.yml
+ # file in the root of the repository
+ echo ${GOPATH}
+ curl -sfL https://install.goreleaser.com/github.com/golangci/golangci-lint.sh | sh -s -- -b $(GOPATH)/bin v1.56.2
diff --git a/vendor/github.com/Masterminds/semver/v3/README.md b/vendor/github.com/Masterminds/semver/v3/README.md
new file mode 100644
index 00000000..2f56c676
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/v3/README.md
@@ -0,0 +1,274 @@
+# SemVer
+
+The `semver` package provides the ability to work with [Semantic Versions](http://semver.org) in Go. Specifically it provides the ability to:
+
+* Parse semantic versions
+* Sort semantic versions
+* Check if a semantic version fits within a set of constraints
+* Optionally work with a `v` prefix
+
+[](https://masterminds.github.io/stability/active.html)
+[](https://github.com/Masterminds/semver/actions)
+[](https://pkg.go.dev/github.com/Masterminds/semver/v3)
+[](https://goreportcard.com/report/github.com/Masterminds/semver)
+
+## Package Versions
+
+Note, import `github.com/Masterminds/semver/v3` to use the latest version.
+
+There are three major versions fo the `semver` package.
+
+* 3.x.x is the stable and active version. This version is focused on constraint
+ compatibility for range handling in other tools from other languages. It has
+ a similar API to the v1 releases. The development of this version is on the master
+ branch. The documentation for this version is below.
+* 2.x was developed primarily for [dep](https://github.com/golang/dep). There are
+ no tagged releases and the development was performed by [@sdboyer](https://github.com/sdboyer).
+ There are API breaking changes from v1. This version lives on the [2.x branch](https://github.com/Masterminds/semver/tree/2.x).
+* 1.x.x is the original release. It is no longer maintained. You should use the
+ v3 release instead. You can read the documentation for the 1.x.x release
+ [here](https://github.com/Masterminds/semver/blob/release-1/README.md).
+
+## Parsing Semantic Versions
+
+There are two functions that can parse semantic versions. The `StrictNewVersion`
+function only parses valid version 2 semantic versions as outlined in the
+specification. The `NewVersion` function attempts to coerce a version into a
+semantic version and parse it. For example, if there is a leading v or a version
+listed without all 3 parts (e.g. `v1.2`) it will attempt to coerce it into a valid
+semantic version (e.g., 1.2.0). In both cases a `Version` object is returned
+that can be sorted, compared, and used in constraints.
+
+When parsing a version an error is returned if there is an issue parsing the
+version. For example,
+
+ v, err := semver.NewVersion("1.2.3-beta.1+build345")
+
+The version object has methods to get the parts of the version, compare it to
+other versions, convert the version back into a string, and get the original
+string. Getting the original string is useful if the semantic version was coerced
+into a valid form.
+
+There are package level variables that affect how `NewVersion` handles parsing.
+
+- `CoerceNewVersion` is `true` by default. When set to `true` it coerces non-compliant
+ versions into SemVer. For example, allowing a leading 0 in a major, minor, or patch
+ part. This enables the use of CalVer in versions even when not compliant with SemVer.
+ When set to `false` less coercion work is done.
+- `DetailedNewVersionErrors` provides more detailed errors. It only has an affect when
+ `CoerceNewVersion` is set to `false`. When `DetailedNewVersionErrors` is set to `true`
+ it can provide some more insight into why a version is invalid. Setting
+ `DetailedNewVersionErrors` to `false` is faster on performance but provides less
+ detailed error messages if a version fails to parse.
+
+## Sorting Semantic Versions
+
+A set of versions can be sorted using the `sort` package from the standard library.
+For example,
+
+```go
+raw := []string{"1.2.3", "1.0", "1.3", "2", "0.4.2",}
+vs := make([]*semver.Version, len(raw))
+for i, r := range raw {
+ v, err := semver.NewVersion(r)
+ if err != nil {
+ t.Errorf("Error parsing version: %s", err)
+ }
+
+ vs[i] = v
+}
+
+sort.Sort(semver.Collection(vs))
+```
+
+## Checking Version Constraints
+
+There are two methods for comparing versions. One uses comparison methods on
+`Version` instances and the other uses `Constraints`. There are some important
+differences to notes between these two methods of comparison.
+
+1. When two versions are compared using functions such as `Compare`, `LessThan`,
+ and others it will follow the specification and always include pre-releases
+ within the comparison. It will provide an answer that is valid with the
+ comparison section of the spec at https://semver.org/#spec-item-11
+2. When constraint checking is used for checks or validation it will follow a
+ different set of rules that are common for ranges with tools like npm/js
+ and Rust/Cargo. This includes considering pre-releases to be invalid if the
+ ranges does not include one. If you want to have it include pre-releases a
+ simple solution is to include `-0` in your range.
+3. Constraint ranges can have some complex rules including the shorthand use of
+ ~ and ^. For more details on those see the options below.
+
+There are differences between the two methods or checking versions because the
+comparison methods on `Version` follow the specification while comparison ranges
+are not part of the specification. Different packages and tools have taken it
+upon themselves to come up with range rules. This has resulted in differences.
+For example, npm/js and Cargo/Rust follow similar patterns while PHP has a
+different pattern for ^. The comparison features in this package follow the
+npm/js and Cargo/Rust lead because applications using it have followed similar
+patters with their versions.
+
+Checking a version against version constraints is one of the most featureful
+parts of the package.
+
+```go
+c, err := semver.NewConstraint(">= 1.2.3")
+if err != nil {
+ // Handle constraint not being parsable.
+}
+
+v, err := semver.NewVersion("1.3")
+if err != nil {
+ // Handle version not being parsable.
+}
+// Check if the version meets the constraints. The variable a will be true.
+a := c.Check(v)
+```
+
+### Basic Comparisons
+
+There are two elements to the comparisons. First, a comparison string is a list
+of space or comma separated AND comparisons. These are then separated by || (OR)
+comparisons. For example, `">= 1.2 < 3.0.0 || >= 4.2.3"` is looking for a
+comparison that's greater than or equal to 1.2 and less than 3.0.0 or is
+greater than or equal to 4.2.3.
+
+The basic comparisons are:
+
+* `=`: equal (aliased to no operator)
+* `!=`: not equal
+* `>`: greater than
+* `<`: less than
+* `>=`: greater than or equal to
+* `<=`: less than or equal to
+
+### Working With Prerelease Versions
+
+Pre-releases, for those not familiar with them, are used for software releases
+prior to stable or generally available releases. Examples of pre-releases include
+development, alpha, beta, and release candidate releases. A pre-release may be
+a version such as `1.2.3-beta.1` while the stable release would be `1.2.3`. In the
+order of precedence, pre-releases come before their associated releases. In this
+example `1.2.3-beta.1 < 1.2.3`.
+
+According to the Semantic Version specification, pre-releases may not be
+API compliant with their release counterpart. It says,
+
+> A pre-release version indicates that the version is unstable and might not satisfy the intended compatibility requirements as denoted by its associated normal version.
+
+SemVer's comparisons using constraints without a pre-release comparator will skip
+pre-release versions. For example, `>=1.2.3` will skip pre-releases when looking
+at a list of releases while `>=1.2.3-0` will evaluate and find pre-releases.
+
+The reason for the `0` as a pre-release version in the example comparison is
+because pre-releases can only contain ASCII alphanumerics and hyphens (along with
+`.` separators), per the spec. Sorting happens in ASCII sort order, again per the
+spec. The lowest character is a `0` in ASCII sort order
+(see an [ASCII Table](http://www.asciitable.com/))
+
+Understanding ASCII sort ordering is important because A-Z comes before a-z. That
+means `>=1.2.3-BETA` will return `1.2.3-alpha`. What you might expect from case
+sensitivity doesn't apply here. This is due to ASCII sort ordering which is what
+the spec specifies.
+
+The `Constraints` instance returned from `semver.NewConstraint()` has a property
+`IncludePrerelease` that, when set to true, will return prerelease versions when calls
+to `Check()` and `Validate()` are made.
+
+### Hyphen Range Comparisons
+
+There are multiple methods to handle ranges and the first is hyphens ranges.
+These look like:
+
+* `1.2 - 1.4.5` which is equivalent to `>= 1.2 <= 1.4.5`
+* `2.3.4 - 4.5` which is equivalent to `>= 2.3.4 <= 4.5`
+
+Note that `1.2-1.4.5` without whitespace is parsed completely differently; it's
+parsed as a single constraint `1.2.0` with _prerelease_ `1.4.5`.
+
+### Wildcards In Comparisons
+
+The `x`, `X`, and `*` characters can be used as a wildcard character. This works
+for all comparison operators. When used on the `=` operator it falls
+back to the patch level comparison (see tilde below). For example,
+
+* `1.2.x` is equivalent to `>= 1.2.0, < 1.3.0`
+* `>= 1.2.x` is equivalent to `>= 1.2.0`
+* `<= 2.x` is equivalent to `< 3`
+* `*` is equivalent to `>= 0.0.0`
+
+### Tilde Range Comparisons (Patch)
+
+The tilde (`~`) comparison operator is for patch level ranges when a minor
+version is specified and major level changes when the minor number is missing.
+For example,
+
+* `~1.2.3` is equivalent to `>= 1.2.3, < 1.3.0`
+* `~1` is equivalent to `>= 1, < 2`
+* `~2.3` is equivalent to `>= 2.3, < 2.4`
+* `~1.2.x` is equivalent to `>= 1.2.0, < 1.3.0`
+* `~1.x` is equivalent to `>= 1, < 2`
+
+### Caret Range Comparisons (Major)
+
+The caret (`^`) comparison operator is for major level changes once a stable
+(1.0.0) release has occurred. Prior to a 1.0.0 release the minor versions acts
+as the API stability level. This is useful when comparisons of API versions as a
+major change is API breaking. For example,
+
+* `^1.2.3` is equivalent to `>= 1.2.3, < 2.0.0`
+* `^1.2.x` is equivalent to `>= 1.2.0, < 2.0.0`
+* `^2.3` is equivalent to `>= 2.3, < 3`
+* `^2.x` is equivalent to `>= 2.0.0, < 3`
+* `^0.2.3` is equivalent to `>=0.2.3 <0.3.0`
+* `^0.2` is equivalent to `>=0.2.0 <0.3.0`
+* `^0.0.3` is equivalent to `>=0.0.3 <0.0.4`
+* `^0.0` is equivalent to `>=0.0.0 <0.1.0`
+* `^0` is equivalent to `>=0.0.0 <1.0.0`
+
+## Validation
+
+In addition to testing a version against a constraint, a version can be validated
+against a constraint. When validation fails a slice of errors containing why a
+version didn't meet the constraint is returned. For example,
+
+```go
+c, err := semver.NewConstraint("<= 1.2.3, >= 1.4")
+if err != nil {
+ // Handle constraint not being parseable.
+}
+
+v, err := semver.NewVersion("1.3")
+if err != nil {
+ // Handle version not being parseable.
+}
+
+// Validate a version against a constraint.
+a, msgs := c.Validate(v)
+// a is false
+for _, m := range msgs {
+ fmt.Println(m)
+
+ // Loops over the errors which would read
+ // "1.3 is greater than 1.2.3"
+ // "1.3 is less than 1.4"
+}
+```
+
+## Contribute
+
+If you find an issue or want to contribute please file an [issue](https://github.com/Masterminds/semver/issues)
+or [create a pull request](https://github.com/Masterminds/semver/pulls).
+
+## Security
+
+Security is an important consideration for this project. The project currently
+uses the following tools to help discover security issues:
+
+* [CodeQL](https://codeql.github.com)
+* [gosec](https://github.com/securego/gosec)
+* Daily Fuzz testing
+
+If you believe you have found a security vulnerability you can privately disclose
+it through the [GitHub security page](https://github.com/Masterminds/semver/security).
diff --git a/vendor/github.com/Masterminds/semver/v3/SECURITY.md b/vendor/github.com/Masterminds/semver/v3/SECURITY.md
new file mode 100644
index 00000000..a30a66b1
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/v3/SECURITY.md
@@ -0,0 +1,19 @@
+# Security Policy
+
+## Supported Versions
+
+The following versions of semver are currently supported:
+
+| Version | Supported |
+| ------- | ------------------ |
+| 3.x | :white_check_mark: |
+| 2.x | :x: |
+| 1.x | :x: |
+
+Fixes are only released for the latest minor version in the form of a patch release.
+
+## Reporting a Vulnerability
+
+You can privately disclose a vulnerability through GitHubs
+[private vulnerability reporting](https://github.com/Masterminds/semver/security/advisories)
+mechanism.
diff --git a/vendor/github.com/Masterminds/semver/v3/collection.go b/vendor/github.com/Masterminds/semver/v3/collection.go
new file mode 100644
index 00000000..a7823589
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/v3/collection.go
@@ -0,0 +1,24 @@
+package semver
+
+// Collection is a collection of Version instances and implements the sort
+// interface. See the sort package for more details.
+// https://golang.org/pkg/sort/
+type Collection []*Version
+
+// Len returns the length of a collection. The number of Version instances
+// on the slice.
+func (c Collection) Len() int {
+ return len(c)
+}
+
+// Less is needed for the sort interface to compare two Version objects on the
+// slice. If checks if one is less than the other.
+func (c Collection) Less(i, j int) bool {
+ return c[i].LessThan(c[j])
+}
+
+// Swap is needed for the sort interface to replace the Version objects
+// at two different positions in the slice.
+func (c Collection) Swap(i, j int) {
+ c[i], c[j] = c[j], c[i]
+}
diff --git a/vendor/github.com/Masterminds/semver/v3/constraints.go b/vendor/github.com/Masterminds/semver/v3/constraints.go
new file mode 100644
index 00000000..8b7a10f8
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/v3/constraints.go
@@ -0,0 +1,601 @@
+package semver
+
+import (
+ "bytes"
+ "errors"
+ "fmt"
+ "regexp"
+ "strings"
+)
+
+// Constraints is one or more constraint that a semantic version can be
+// checked against.
+type Constraints struct {
+ constraints [][]*constraint
+ containsPre []bool
+
+ // IncludePrerelease specifies if pre-releases should be included in
+ // the results. Note, if a constraint range has a prerelease than
+ // prereleases will be included for that AND group even if this is
+ // set to false.
+ IncludePrerelease bool
+}
+
+// NewConstraint returns a Constraints instance that a Version instance can
+// be checked against. If there is a parse error it will be returned.
+func NewConstraint(c string) (*Constraints, error) {
+
+ // Rewrite - ranges into a comparison operation.
+ c = rewriteRange(c)
+
+ ors := strings.Split(c, "||")
+ lenors := len(ors)
+ or := make([][]*constraint, lenors)
+ hasPre := make([]bool, lenors)
+ for k, v := range ors {
+ // Validate the segment
+ if !validConstraintRegex.MatchString(v) {
+ return nil, fmt.Errorf("improper constraint: %s", v)
+ }
+
+ cs := findConstraintRegex.FindAllString(v, -1)
+ if cs == nil {
+ cs = append(cs, v)
+ }
+ result := make([]*constraint, len(cs))
+ for i, s := range cs {
+ pc, err := parseConstraint(s)
+ if err != nil {
+ return nil, err
+ }
+
+ // If one of the constraints has a prerelease record this.
+ // This information is used when checking all in an "and"
+ // group to ensure they all check for prereleases.
+ if pc.con.pre != "" {
+ hasPre[k] = true
+ }
+
+ result[i] = pc
+ }
+ or[k] = result
+ }
+
+ o := &Constraints{
+ constraints: or,
+ containsPre: hasPre,
+ }
+ return o, nil
+}
+
+// Check tests if a version satisfies the constraints.
+func (cs Constraints) Check(v *Version) bool {
+ // TODO(mattfarina): For v4 of this library consolidate the Check and Validate
+ // functions as the underlying functions make that possible now.
+ // loop over the ORs and check the inner ANDs
+ for i, o := range cs.constraints {
+ joy := true
+ for _, c := range o {
+ if check, _ := c.check(v, (cs.IncludePrerelease || cs.containsPre[i])); !check {
+ joy = false
+ break
+ }
+ }
+
+ if joy {
+ return true
+ }
+ }
+
+ return false
+}
+
+// Validate checks if a version satisfies a constraint. If not a slice of
+// reasons for the failure are returned in addition to a bool.
+func (cs Constraints) Validate(v *Version) (bool, []error) {
+ // loop over the ORs and check the inner ANDs
+ var e []error
+
+ // Capture the prerelease message only once. When it happens the first time
+ // this var is marked
+ var prerelesase bool
+ for i, o := range cs.constraints {
+ joy := true
+ for _, c := range o {
+ // Before running the check handle the case there the version is
+ // a prerelease and the check is not searching for prereleases.
+ if !(cs.IncludePrerelease || cs.containsPre[i]) && v.pre != "" {
+ if !prerelesase {
+ em := fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
+ e = append(e, em)
+ prerelesase = true
+ }
+ joy = false
+
+ } else {
+
+ if _, err := c.check(v, (cs.IncludePrerelease || cs.containsPre[i])); err != nil {
+ e = append(e, err)
+ joy = false
+ }
+ }
+ }
+
+ if joy {
+ return true, []error{}
+ }
+ }
+
+ return false, e
+}
+
+func (cs Constraints) String() string {
+ buf := make([]string, len(cs.constraints))
+ var tmp bytes.Buffer
+
+ for k, v := range cs.constraints {
+ tmp.Reset()
+ vlen := len(v)
+ for kk, c := range v {
+ tmp.WriteString(c.string())
+
+ // Space separate the AND conditions
+ if vlen > 1 && kk < vlen-1 {
+ tmp.WriteString(" ")
+ }
+ }
+ buf[k] = tmp.String()
+ }
+
+ return strings.Join(buf, " || ")
+}
+
+// UnmarshalText implements the encoding.TextUnmarshaler interface.
+func (cs *Constraints) UnmarshalText(text []byte) error {
+ temp, err := NewConstraint(string(text))
+ if err != nil {
+ return err
+ }
+
+ *cs = *temp
+
+ return nil
+}
+
+// MarshalText implements the encoding.TextMarshaler interface.
+func (cs Constraints) MarshalText() ([]byte, error) {
+ return []byte(cs.String()), nil
+}
+
+var constraintOps map[string]cfunc
+var constraintRegex *regexp.Regexp
+var constraintRangeRegex *regexp.Regexp
+
+// Used to find individual constraints within a multi-constraint string
+var findConstraintRegex *regexp.Regexp
+
+// Used to validate an segment of ANDs is valid
+var validConstraintRegex *regexp.Regexp
+
+const cvRegex string = `v?([0-9|x|X|\*]+)(\.[0-9|x|X|\*]+)?(\.[0-9|x|X|\*]+)?` +
+ `(-([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?` +
+ `(\+([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?`
+
+func init() {
+ constraintOps = map[string]cfunc{
+ "": constraintTildeOrEqual,
+ "=": constraintTildeOrEqual,
+ "!=": constraintNotEqual,
+ ">": constraintGreaterThan,
+ "<": constraintLessThan,
+ ">=": constraintGreaterThanEqual,
+ "=>": constraintGreaterThanEqual,
+ "<=": constraintLessThanEqual,
+ "=<": constraintLessThanEqual,
+ "~": constraintTilde,
+ "~>": constraintTilde,
+ "^": constraintCaret,
+ }
+
+ ops := `=||!=|>|<|>=|=>|<=|=<|~|~>|\^`
+
+ constraintRegex = regexp.MustCompile(fmt.Sprintf(
+ `^\s*(%s)\s*(%s)\s*$`,
+ ops,
+ cvRegex))
+
+ constraintRangeRegex = regexp.MustCompile(fmt.Sprintf(
+ `\s*(%s)\s+-\s+(%s)\s*`,
+ cvRegex, cvRegex))
+
+ findConstraintRegex = regexp.MustCompile(fmt.Sprintf(
+ `(%s)\s*(%s)`,
+ ops,
+ cvRegex))
+
+ // The first time a constraint shows up will look slightly different from
+ // future times it shows up due to a leading space or comma in a given
+ // string.
+ validConstraintRegex = regexp.MustCompile(fmt.Sprintf(
+ `^(\s*(%s)\s*(%s)\s*)((?:\s+|,\s*)(%s)\s*(%s)\s*)*$`,
+ ops,
+ cvRegex,
+ ops,
+ cvRegex))
+}
+
+// An individual constraint
+type constraint struct {
+ // The version used in the constraint check. For example, if a constraint
+ // is '<= 2.0.0' the con a version instance representing 2.0.0.
+ con *Version
+
+ // The original parsed version (e.g., 4.x from != 4.x)
+ orig string
+
+ // The original operator for the constraint
+ origfunc string
+
+ // When an x is used as part of the version (e.g., 1.x)
+ minorDirty bool
+ dirty bool
+ patchDirty bool
+}
+
+// Check if a version meets the constraint
+func (c *constraint) check(v *Version, includePre bool) (bool, error) {
+ return constraintOps[c.origfunc](v, c, includePre)
+}
+
+// String prints an individual constraint into a string
+func (c *constraint) string() string {
+ return c.origfunc + c.orig
+}
+
+type cfunc func(v *Version, c *constraint, includePre bool) (bool, error)
+
+func parseConstraint(c string) (*constraint, error) {
+ if len(c) > 0 {
+ m := constraintRegex.FindStringSubmatch(c)
+ if m == nil {
+ return nil, fmt.Errorf("improper constraint: %s", c)
+ }
+
+ cs := &constraint{
+ orig: m[2],
+ origfunc: m[1],
+ }
+
+ ver := m[2]
+ minorDirty := false
+ patchDirty := false
+ dirty := false
+ if isX(m[3]) || m[3] == "" {
+ ver = fmt.Sprintf("0.0.0%s", m[6])
+ dirty = true
+ } else if isX(strings.TrimPrefix(m[4], ".")) || m[4] == "" {
+ minorDirty = true
+ dirty = true
+ ver = fmt.Sprintf("%s.0.0%s", m[3], m[6])
+ } else if isX(strings.TrimPrefix(m[5], ".")) || m[5] == "" {
+ dirty = true
+ patchDirty = true
+ ver = fmt.Sprintf("%s%s.0%s", m[3], m[4], m[6])
+ }
+
+ con, err := NewVersion(ver)
+ if err != nil {
+
+ // The constraintRegex should catch any regex parsing errors. So,
+ // we should never get here.
+ return nil, errors.New("constraint parser error")
+ }
+
+ cs.con = con
+ cs.minorDirty = minorDirty
+ cs.patchDirty = patchDirty
+ cs.dirty = dirty
+
+ return cs, nil
+ }
+
+ // The rest is the special case where an empty string was passed in which
+ // is equivalent to * or >=0.0.0
+ con, err := StrictNewVersion("0.0.0")
+ if err != nil {
+
+ // The constraintRegex should catch any regex parsing errors. So,
+ // we should never get here.
+ return nil, errors.New("constraint parser error")
+ }
+
+ cs := &constraint{
+ con: con,
+ orig: c,
+ origfunc: "",
+ minorDirty: false,
+ patchDirty: false,
+ dirty: true,
+ }
+ return cs, nil
+}
+
+// Constraint functions
+func constraintNotEqual(v *Version, c *constraint, includePre bool) (bool, error) {
+ // The existence of prereleases is checked at the group level and passed in.
+ // Exit early if the version has a prerelease but those are to be ignored.
+ if v.Prerelease() != "" && !includePre {
+ return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
+ }
+
+ if c.dirty {
+ if c.con.Major() != v.Major() {
+ return true, nil
+ }
+ if c.con.Minor() != v.Minor() && !c.minorDirty {
+ return true, nil
+ } else if c.minorDirty {
+ return false, fmt.Errorf("%s is equal to %s", v, c.orig)
+ } else if c.con.Patch() != v.Patch() && !c.patchDirty {
+ return true, nil
+ } else if c.patchDirty {
+ // Need to handle prereleases if present
+ if v.Prerelease() != "" || c.con.Prerelease() != "" {
+ eq := comparePrerelease(v.Prerelease(), c.con.Prerelease()) != 0
+ if eq {
+ return true, nil
+ }
+ return false, fmt.Errorf("%s is equal to %s", v, c.orig)
+ }
+ return false, fmt.Errorf("%s is equal to %s", v, c.orig)
+ }
+ }
+
+ eq := v.Equal(c.con)
+ if eq {
+ return false, fmt.Errorf("%s is equal to %s", v, c.orig)
+ }
+
+ return true, nil
+}
+
+func constraintGreaterThan(v *Version, c *constraint, includePre bool) (bool, error) {
+
+ // The existence of prereleases is checked at the group level and passed in.
+ // Exit early if the version has a prerelease but those are to be ignored.
+ if v.Prerelease() != "" && !includePre {
+ return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
+ }
+
+ var eq bool
+
+ if !c.dirty {
+ eq = v.Compare(c.con) == 1
+ if eq {
+ return true, nil
+ }
+ return false, fmt.Errorf("%s is less than or equal to %s", v, c.orig)
+ }
+
+ if v.Major() > c.con.Major() {
+ return true, nil
+ } else if v.Major() < c.con.Major() {
+ return false, fmt.Errorf("%s is less than or equal to %s", v, c.orig)
+ } else if c.minorDirty {
+ // This is a range case such as >11. When the version is something like
+ // 11.1.0 is it not > 11. For that we would need 12 or higher
+ return false, fmt.Errorf("%s is less than or equal to %s", v, c.orig)
+ } else if c.patchDirty {
+ // This is for ranges such as >11.1. A version of 11.1.1 is not greater
+ // which one of 11.2.1 is greater
+ eq = v.Minor() > c.con.Minor()
+ if eq {
+ return true, nil
+ }
+ return false, fmt.Errorf("%s is less than or equal to %s", v, c.orig)
+ }
+
+ // If we have gotten here we are not comparing pre-preleases and can use the
+ // Compare function to accomplish that.
+ eq = v.Compare(c.con) == 1
+ if eq {
+ return true, nil
+ }
+ return false, fmt.Errorf("%s is less than or equal to %s", v, c.orig)
+}
+
+func constraintLessThan(v *Version, c *constraint, includePre bool) (bool, error) {
+ // The existence of prereleases is checked at the group level and passed in.
+ // Exit early if the version has a prerelease but those are to be ignored.
+ if v.Prerelease() != "" && !includePre {
+ return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
+ }
+
+ eq := v.Compare(c.con) < 0
+ if eq {
+ return true, nil
+ }
+ return false, fmt.Errorf("%s is greater than or equal to %s", v, c.orig)
+}
+
+func constraintGreaterThanEqual(v *Version, c *constraint, includePre bool) (bool, error) {
+
+ // The existence of prereleases is checked at the group level and passed in.
+ // Exit early if the version has a prerelease but those are to be ignored.
+ if v.Prerelease() != "" && !includePre {
+ return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
+ }
+
+ eq := v.Compare(c.con) >= 0
+ if eq {
+ return true, nil
+ }
+ return false, fmt.Errorf("%s is less than %s", v, c.orig)
+}
+
+func constraintLessThanEqual(v *Version, c *constraint, includePre bool) (bool, error) {
+ // The existence of prereleases is checked at the group level and passed in.
+ // Exit early if the version has a prerelease but those are to be ignored.
+ if v.Prerelease() != "" && !includePre {
+ return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
+ }
+
+ var eq bool
+
+ if !c.dirty {
+ eq = v.Compare(c.con) <= 0
+ if eq {
+ return true, nil
+ }
+ return false, fmt.Errorf("%s is greater than %s", v, c.orig)
+ }
+
+ if v.Major() > c.con.Major() {
+ return false, fmt.Errorf("%s is greater than %s", v, c.orig)
+ } else if v.Major() == c.con.Major() && v.Minor() > c.con.Minor() && !c.minorDirty {
+ return false, fmt.Errorf("%s is greater than %s", v, c.orig)
+ }
+
+ return true, nil
+}
+
+// ~*, ~>* --> >= 0.0.0 (any)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0, <3.0.0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0, <2.1.0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0, <1.3.0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3, <1.3.0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0, <1.3.0
+func constraintTilde(v *Version, c *constraint, includePre bool) (bool, error) {
+ // The existence of prereleases is checked at the group level and passed in.
+ // Exit early if the version has a prerelease but those are to be ignored.
+ if v.Prerelease() != "" && !includePre {
+ return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
+ }
+
+ if v.LessThan(c.con) {
+ return false, fmt.Errorf("%s is less than %s", v, c.orig)
+ }
+
+ // ~0.0.0 is a special case where all constraints are accepted. It's
+ // equivalent to >= 0.0.0.
+ if c.con.Major() == 0 && c.con.Minor() == 0 && c.con.Patch() == 0 &&
+ !c.minorDirty && !c.patchDirty {
+ return true, nil
+ }
+
+ if v.Major() != c.con.Major() {
+ return false, fmt.Errorf("%s does not have same major version as %s", v, c.orig)
+ }
+
+ if v.Minor() != c.con.Minor() && !c.minorDirty {
+ return false, fmt.Errorf("%s does not have same major and minor version as %s", v, c.orig)
+ }
+
+ return true, nil
+}
+
+// When there is a .x (dirty) status it automatically opts in to ~. Otherwise
+// it's a straight =
+func constraintTildeOrEqual(v *Version, c *constraint, includePre bool) (bool, error) {
+ // The existence of prereleases is checked at the group level and passed in.
+ // Exit early if the version has a prerelease but those are to be ignored.
+ if v.Prerelease() != "" && !includePre {
+ return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
+ }
+
+ if c.dirty {
+ return constraintTilde(v, c, includePre)
+ }
+
+ eq := v.Equal(c.con)
+ if eq {
+ return true, nil
+ }
+
+ return false, fmt.Errorf("%s is not equal to %s", v, c.orig)
+}
+
+// ^* --> (any)
+// ^1.2.3 --> >=1.2.3 <2.0.0
+// ^1.2 --> >=1.2.0 <2.0.0
+// ^1 --> >=1.0.0 <2.0.0
+// ^0.2.3 --> >=0.2.3 <0.3.0
+// ^0.2 --> >=0.2.0 <0.3.0
+// ^0.0.3 --> >=0.0.3 <0.0.4
+// ^0.0 --> >=0.0.0 <0.1.0
+// ^0 --> >=0.0.0 <1.0.0
+func constraintCaret(v *Version, c *constraint, includePre bool) (bool, error) {
+ // The existence of prereleases is checked at the group level and passed in.
+ // Exit early if the version has a prerelease but those are to be ignored.
+ if v.Prerelease() != "" && !includePre {
+ return false, fmt.Errorf("%s is a prerelease version and the constraint is only looking for release versions", v)
+ }
+
+ // This less than handles prereleases
+ if v.LessThan(c.con) {
+ return false, fmt.Errorf("%s is less than %s", v, c.orig)
+ }
+
+ var eq bool
+
+ // ^ when the major > 0 is >=x.y.z < x+1
+ if c.con.Major() > 0 || c.minorDirty {
+
+ // ^ has to be within a major range for > 0. Everything less than was
+ // filtered out with the LessThan call above. This filters out those
+ // that greater but not within the same major range.
+ eq = v.Major() == c.con.Major()
+ if eq {
+ return true, nil
+ }
+ return false, fmt.Errorf("%s does not have same major version as %s", v, c.orig)
+ }
+
+ // ^ when the major is 0 and minor > 0 is >=0.y.z < 0.y+1
+ if c.con.Major() == 0 && v.Major() > 0 {
+ return false, fmt.Errorf("%s does not have same major version as %s", v, c.orig)
+ }
+ // If the con Minor is > 0 it is not dirty
+ if c.con.Minor() > 0 || c.patchDirty {
+ eq = v.Minor() == c.con.Minor()
+ if eq {
+ return true, nil
+ }
+ return false, fmt.Errorf("%s does not have same minor version as %s. Expected minor versions to match when constraint major version is 0", v, c.orig)
+ }
+ // ^ when the minor is 0 and minor > 0 is =0.0.z
+ if c.con.Minor() == 0 && v.Minor() > 0 {
+ return false, fmt.Errorf("%s does not have same minor version as %s", v, c.orig)
+ }
+
+ // At this point the major is 0 and the minor is 0 and not dirty. The patch
+ // is not dirty so we need to check if they are equal. If they are not equal
+ eq = c.con.Patch() == v.Patch()
+ if eq {
+ return true, nil
+ }
+ return false, fmt.Errorf("%s does not equal %s. Expect version and constraint to equal when major and minor versions are 0", v, c.orig)
+}
+
+func isX(x string) bool {
+ switch x {
+ case "x", "*", "X":
+ return true
+ default:
+ return false
+ }
+}
+
+func rewriteRange(i string) string {
+ m := constraintRangeRegex.FindAllStringSubmatch(i, -1)
+ if m == nil {
+ return i
+ }
+ o := i
+ for _, v := range m {
+ t := fmt.Sprintf(">= %s, <= %s ", v[1], v[11])
+ o = strings.Replace(o, v[0], t, 1)
+ }
+
+ return o
+}
diff --git a/vendor/github.com/Masterminds/semver/v3/doc.go b/vendor/github.com/Masterminds/semver/v3/doc.go
new file mode 100644
index 00000000..74f97caa
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/v3/doc.go
@@ -0,0 +1,184 @@
+/*
+Package semver provides the ability to work with Semantic Versions (http://semver.org) in Go.
+
+Specifically it provides the ability to:
+
+ - Parse semantic versions
+ - Sort semantic versions
+ - Check if a semantic version fits within a set of constraints
+ - Optionally work with a `v` prefix
+
+# Parsing Semantic Versions
+
+There are two functions that can parse semantic versions. The `StrictNewVersion`
+function only parses valid version 2 semantic versions as outlined in the
+specification. The `NewVersion` function attempts to coerce a version into a
+semantic version and parse it. For example, if there is a leading v or a version
+listed without all 3 parts (e.g. 1.2) it will attempt to coerce it into a valid
+semantic version (e.g., 1.2.0). In both cases a `Version` object is returned
+that can be sorted, compared, and used in constraints.
+
+When parsing a version an optional error can be returned if there is an issue
+parsing the version. For example,
+
+ v, err := semver.NewVersion("1.2.3-beta.1+b345")
+
+The version object has methods to get the parts of the version, compare it to
+other versions, convert the version back into a string, and get the original
+string. For more details please see the documentation
+at https://godoc.org/github.com/Masterminds/semver.
+
+# Sorting Semantic Versions
+
+A set of versions can be sorted using the `sort` package from the standard library.
+For example,
+
+ raw := []string{"1.2.3", "1.0", "1.3", "2", "0.4.2",}
+ vs := make([]*semver.Version, len(raw))
+ for i, r := range raw {
+ v, err := semver.NewVersion(r)
+ if err != nil {
+ t.Errorf("Error parsing version: %s", err)
+ }
+
+ vs[i] = v
+ }
+
+ sort.Sort(semver.Collection(vs))
+
+# Checking Version Constraints and Comparing Versions
+
+There are two methods for comparing versions. One uses comparison methods on
+`Version` instances and the other is using Constraints. There are some important
+differences to notes between these two methods of comparison.
+
+ 1. When two versions are compared using functions such as `Compare`, `LessThan`,
+ and others it will follow the specification and always include prereleases
+ within the comparison. It will provide an answer valid with the comparison
+ spec section at https://semver.org/#spec-item-11
+ 2. When constraint checking is used for checks or validation it will follow a
+ different set of rules that are common for ranges with tools like npm/js
+ and Rust/Cargo. This includes considering prereleases to be invalid if the
+ ranges does not include on. If you want to have it include pre-releases a
+ simple solution is to include `-0` in your range.
+ 3. Constraint ranges can have some complex rules including the shorthard use of
+ ~ and ^. For more details on those see the options below.
+
+There are differences between the two methods or checking versions because the
+comparison methods on `Version` follow the specification while comparison ranges
+are not part of the specification. Different packages and tools have taken it
+upon themselves to come up with range rules. This has resulted in differences.
+For example, npm/js and Cargo/Rust follow similar patterns which PHP has a
+different pattern for ^. The comparison features in this package follow the
+npm/js and Cargo/Rust lead because applications using it have followed similar
+patters with their versions.
+
+Checking a version against version constraints is one of the most featureful
+parts of the package.
+
+ c, err := semver.NewConstraint(">= 1.2.3")
+ if err != nil {
+ // Handle constraint not being parsable.
+ }
+
+ v, err := semver.NewVersion("1.3")
+ if err != nil {
+ // Handle version not being parsable.
+ }
+ // Check if the version meets the constraints. The a variable will be true.
+ a := c.Check(v)
+
+# Basic Comparisons
+
+There are two elements to the comparisons. First, a comparison string is a list
+of comma or space separated AND comparisons. These are then separated by || (OR)
+comparisons. For example, `">= 1.2 < 3.0.0 || >= 4.2.3"` is looking for a
+comparison that's greater than or equal to 1.2 and less than 3.0.0 or is
+greater than or equal to 4.2.3. This can also be written as
+`">= 1.2, < 3.0.0 || >= 4.2.3"`
+
+The basic comparisons are:
+
+ - `=`: equal (aliased to no operator)
+ - `!=`: not equal
+ - `>`: greater than
+ - `<`: less than
+ - `>=`: greater than or equal to
+ - `<=`: less than or equal to
+
+# Hyphen Range Comparisons
+
+There are multiple methods to handle ranges and the first is hyphens ranges.
+These look like:
+
+ - `1.2 - 1.4.5` which is equivalent to `>= 1.2, <= 1.4.5`
+ - `2.3.4 - 4.5` which is equivalent to `>= 2.3.4 <= 4.5`
+
+# Wildcards In Comparisons
+
+The `x`, `X`, and `*` characters can be used as a wildcard character. This works
+for all comparison operators. When used on the `=` operator it falls
+back to the tilde operation. For example,
+
+ - `1.2.x` is equivalent to `>= 1.2.0 < 1.3.0`
+ - `>= 1.2.x` is equivalent to `>= 1.2.0`
+ - `<= 2.x` is equivalent to `<= 3`
+ - `*` is equivalent to `>= 0.0.0`
+
+Tilde Range Comparisons (Patch)
+
+The tilde (`~`) comparison operator is for patch level ranges when a minor
+version is specified and major level changes when the minor number is missing.
+For example,
+
+ - `~1.2.3` is equivalent to `>= 1.2.3 < 1.3.0`
+ - `~1` is equivalent to `>= 1, < 2`
+ - `~2.3` is equivalent to `>= 2.3 < 2.4`
+ - `~1.2.x` is equivalent to `>= 1.2.0 < 1.3.0`
+ - `~1.x` is equivalent to `>= 1 < 2`
+
+Caret Range Comparisons (Major)
+
+The caret (`^`) comparison operator is for major level changes once a stable
+(1.0.0) release has occurred. Prior to a 1.0.0 release the minor versions acts
+as the API stability level. This is useful when comparisons of API versions as a
+major change is API breaking. For example,
+
+ - `^1.2.3` is equivalent to `>= 1.2.3, < 2.0.0`
+ - `^1.2.x` is equivalent to `>= 1.2.0, < 2.0.0`
+ - `^2.3` is equivalent to `>= 2.3, < 3`
+ - `^2.x` is equivalent to `>= 2.0.0, < 3`
+ - `^0.2.3` is equivalent to `>=0.2.3 <0.3.0`
+ - `^0.2` is equivalent to `>=0.2.0 <0.3.0`
+ - `^0.0.3` is equivalent to `>=0.0.3 <0.0.4`
+ - `^0.0` is equivalent to `>=0.0.0 <0.1.0`
+ - `^0` is equivalent to `>=0.0.0 <1.0.0`
+
+# Validation
+
+In addition to testing a version against a constraint, a version can be validated
+against a constraint. When validation fails a slice of errors containing why a
+version didn't meet the constraint is returned. For example,
+
+ c, err := semver.NewConstraint("<= 1.2.3, >= 1.4")
+ if err != nil {
+ // Handle constraint not being parseable.
+ }
+
+ v, _ := semver.NewVersion("1.3")
+ if err != nil {
+ // Handle version not being parseable.
+ }
+
+ // Validate a version against a constraint.
+ a, msgs := c.Validate(v)
+ // a is false
+ for _, m := range msgs {
+ fmt.Println(m)
+
+ // Loops over the errors which would read
+ // "1.3 is greater than 1.2.3"
+ // "1.3 is less than 1.4"
+ }
+*/
+package semver
diff --git a/vendor/github.com/Masterminds/semver/v3/version.go b/vendor/github.com/Masterminds/semver/v3/version.go
new file mode 100644
index 00000000..7a3ba738
--- /dev/null
+++ b/vendor/github.com/Masterminds/semver/v3/version.go
@@ -0,0 +1,788 @@
+package semver
+
+import (
+ "bytes"
+ "database/sql/driver"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "regexp"
+ "strconv"
+ "strings"
+)
+
+// The compiled version of the regex created at init() is cached here so it
+// only needs to be created once.
+var versionRegex *regexp.Regexp
+var looseVersionRegex *regexp.Regexp
+
+// CoerceNewVersion sets if leading 0's are allowd in the version part. Leading 0's are
+// not allowed in a valid semantic version. When set to true, NewVersion will coerce
+// leading 0's into a valid version.
+var CoerceNewVersion = true
+
+// DetailedNewVersionErrors specifies if detailed errors are returned from the NewVersion
+// function. This is used when CoerceNewVersion is set to false. If set to false
+// ErrInvalidSemVer is returned for an invalid version. This does not apply to
+// StrictNewVersion. Setting this function to false returns errors more quickly.
+var DetailedNewVersionErrors = true
+
+var (
+ // ErrInvalidSemVer is returned a version is found to be invalid when
+ // being parsed.
+ ErrInvalidSemVer = errors.New("invalid semantic version")
+
+ // ErrEmptyString is returned when an empty string is passed in for parsing.
+ ErrEmptyString = errors.New("version string empty")
+
+ // ErrInvalidCharacters is returned when invalid characters are found as
+ // part of a version
+ ErrInvalidCharacters = errors.New("invalid characters in version")
+
+ // ErrSegmentStartsZero is returned when a version segment starts with 0.
+ // This is invalid in SemVer.
+ ErrSegmentStartsZero = errors.New("version segment starts with 0")
+
+ // ErrInvalidMetadata is returned when the metadata is an invalid format
+ ErrInvalidMetadata = errors.New("invalid metadata string")
+
+ // ErrInvalidPrerelease is returned when the pre-release is an invalid format
+ ErrInvalidPrerelease = errors.New("invalid prerelease string")
+)
+
+// semVerRegex is the regular expression used to parse a semantic version.
+// This is not the official regex from the semver spec. It has been modified to allow for loose handling
+// where versions like 2.1 are detected.
+const semVerRegex string = `v?(0|[1-9]\d*)(?:\.(0|[1-9]\d*))?(?:\.(0|[1-9]\d*))?` +
+ `(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?` +
+ `(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?`
+
+// looseSemVerRegex is a regular expression that lets invalid semver expressions through
+// with enough detail that certain errors can be checked for.
+const looseSemVerRegex string = `v?([0-9]+)(\.[0-9]+)?(\.[0-9]+)?` +
+ `(-([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?` +
+ `(\+([0-9A-Za-z\-]+(\.[0-9A-Za-z\-]+)*))?`
+
+// Version represents a single semantic version.
+type Version struct {
+ major, minor, patch uint64
+ pre string
+ metadata string
+ original string
+}
+
+func init() {
+ versionRegex = regexp.MustCompile("^" + semVerRegex + "$")
+ looseVersionRegex = regexp.MustCompile("^" + looseSemVerRegex + "$")
+}
+
+const (
+ num string = "0123456789"
+ allowed string = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-" + num
+)
+
+// StrictNewVersion parses a given version and returns an instance of Version or
+// an error if unable to parse the version. Only parses valid semantic versions.
+// Performs checking that can find errors within the version.
+// If you want to coerce a version such as 1 or 1.2 and parse it as the 1.x
+// releases of semver did, use the NewVersion() function.
+func StrictNewVersion(v string) (*Version, error) {
+ // Parsing here does not use RegEx in order to increase performance and reduce
+ // allocations.
+
+ if len(v) == 0 {
+ return nil, ErrEmptyString
+ }
+
+ // Split the parts into [0]major, [1]minor, and [2]patch,prerelease,build
+ parts := strings.SplitN(v, ".", 3)
+ if len(parts) != 3 {
+ return nil, ErrInvalidSemVer
+ }
+
+ sv := &Version{
+ original: v,
+ }
+
+ // Extract build metadata
+ if strings.Contains(parts[2], "+") {
+ extra := strings.SplitN(parts[2], "+", 2)
+ sv.metadata = extra[1]
+ parts[2] = extra[0]
+ if err := validateMetadata(sv.metadata); err != nil {
+ return nil, err
+ }
+ }
+
+ // Extract build prerelease
+ if strings.Contains(parts[2], "-") {
+ extra := strings.SplitN(parts[2], "-", 2)
+ sv.pre = extra[1]
+ parts[2] = extra[0]
+ if err := validatePrerelease(sv.pre); err != nil {
+ return nil, err
+ }
+ }
+
+ // Validate the number segments are valid. This includes only having positive
+ // numbers and no leading 0's.
+ for _, p := range parts {
+ if !containsOnly(p, num) {
+ return nil, ErrInvalidCharacters
+ }
+
+ if len(p) > 1 && p[0] == '0' {
+ return nil, ErrSegmentStartsZero
+ }
+ }
+
+ // Extract major, minor, and patch
+ var err error
+ sv.major, err = strconv.ParseUint(parts[0], 10, 64)
+ if err != nil {
+ return nil, err
+ }
+
+ sv.minor, err = strconv.ParseUint(parts[1], 10, 64)
+ if err != nil {
+ return nil, err
+ }
+
+ sv.patch, err = strconv.ParseUint(parts[2], 10, 64)
+ if err != nil {
+ return nil, err
+ }
+
+ return sv, nil
+}
+
+// NewVersion parses a given version and returns an instance of Version or
+// an error if unable to parse the version. If the version is SemVer-ish it
+// attempts to convert it to SemVer. If you want to validate it was a strict
+// semantic version at parse time see StrictNewVersion().
+func NewVersion(v string) (*Version, error) {
+ if CoerceNewVersion {
+ return coerceNewVersion(v)
+ }
+ m := versionRegex.FindStringSubmatch(v)
+ if m == nil {
+
+ // Disabling detailed errors is first so that it is in the fast path.
+ if !DetailedNewVersionErrors {
+ return nil, ErrInvalidSemVer
+ }
+
+ // Check for specific errors with the semver string and return a more detailed
+ // error.
+ m = looseVersionRegex.FindStringSubmatch(v)
+ if m == nil {
+ return nil, ErrInvalidSemVer
+ }
+ err := validateVersion(m)
+ if err != nil {
+ return nil, err
+ }
+ return nil, ErrInvalidSemVer
+ }
+
+ sv := &Version{
+ metadata: m[5],
+ pre: m[4],
+ original: v,
+ }
+
+ var err error
+ sv.major, err = strconv.ParseUint(m[1], 10, 64)
+ if err != nil {
+ return nil, fmt.Errorf("error parsing version segment: %w", err)
+ }
+
+ if m[2] != "" {
+ sv.minor, err = strconv.ParseUint(m[2], 10, 64)
+ if err != nil {
+ return nil, fmt.Errorf("error parsing version segment: %w", err)
+ }
+ } else {
+ sv.minor = 0
+ }
+
+ if m[3] != "" {
+ sv.patch, err = strconv.ParseUint(m[3], 10, 64)
+ if err != nil {
+ return nil, fmt.Errorf("error parsing version segment: %w", err)
+ }
+ } else {
+ sv.patch = 0
+ }
+
+ // Perform some basic due diligence on the extra parts to ensure they are
+ // valid.
+
+ if sv.pre != "" {
+ if err = validatePrerelease(sv.pre); err != nil {
+ return nil, err
+ }
+ }
+
+ if sv.metadata != "" {
+ if err = validateMetadata(sv.metadata); err != nil {
+ return nil, err
+ }
+ }
+
+ return sv, nil
+}
+
+func coerceNewVersion(v string) (*Version, error) {
+ m := looseVersionRegex.FindStringSubmatch(v)
+ if m == nil {
+ return nil, ErrInvalidSemVer
+ }
+
+ sv := &Version{
+ metadata: m[8],
+ pre: m[5],
+ original: v,
+ }
+
+ var err error
+ sv.major, err = strconv.ParseUint(m[1], 10, 64)
+ if err != nil {
+ return nil, fmt.Errorf("error parsing version segment: %w", err)
+ }
+
+ if m[2] != "" {
+ sv.minor, err = strconv.ParseUint(strings.TrimPrefix(m[2], "."), 10, 64)
+ if err != nil {
+ return nil, fmt.Errorf("error parsing version segment: %w", err)
+ }
+ } else {
+ sv.minor = 0
+ }
+
+ if m[3] != "" {
+ sv.patch, err = strconv.ParseUint(strings.TrimPrefix(m[3], "."), 10, 64)
+ if err != nil {
+ return nil, fmt.Errorf("error parsing version segment: %w", err)
+ }
+ } else {
+ sv.patch = 0
+ }
+
+ // Perform some basic due diligence on the extra parts to ensure they are
+ // valid.
+
+ if sv.pre != "" {
+ if err = validatePrerelease(sv.pre); err != nil {
+ return nil, err
+ }
+ }
+
+ if sv.metadata != "" {
+ if err = validateMetadata(sv.metadata); err != nil {
+ return nil, err
+ }
+ }
+
+ return sv, nil
+}
+
+// New creates a new instance of Version with each of the parts passed in as
+// arguments instead of parsing a version string.
+func New(major, minor, patch uint64, pre, metadata string) *Version {
+ v := Version{
+ major: major,
+ minor: minor,
+ patch: patch,
+ pre: pre,
+ metadata: metadata,
+ original: "",
+ }
+
+ v.original = v.String()
+
+ return &v
+}
+
+// MustParse parses a given version and panics on error.
+func MustParse(v string) *Version {
+ sv, err := NewVersion(v)
+ if err != nil {
+ panic(err)
+ }
+ return sv
+}
+
+// String converts a Version object to a string.
+// Note, if the original version contained a leading v this version will not.
+// See the Original() method to retrieve the original value. Semantic Versions
+// don't contain a leading v per the spec. Instead it's optional on
+// implementation.
+func (v Version) String() string {
+ var buf bytes.Buffer
+
+ fmt.Fprintf(&buf, "%d.%d.%d", v.major, v.minor, v.patch)
+ if v.pre != "" {
+ fmt.Fprintf(&buf, "-%s", v.pre)
+ }
+ if v.metadata != "" {
+ fmt.Fprintf(&buf, "+%s", v.metadata)
+ }
+
+ return buf.String()
+}
+
+// Original returns the original value passed in to be parsed.
+func (v *Version) Original() string {
+ return v.original
+}
+
+// Major returns the major version.
+func (v Version) Major() uint64 {
+ return v.major
+}
+
+// Minor returns the minor version.
+func (v Version) Minor() uint64 {
+ return v.minor
+}
+
+// Patch returns the patch version.
+func (v Version) Patch() uint64 {
+ return v.patch
+}
+
+// Prerelease returns the pre-release version.
+func (v Version) Prerelease() string {
+ return v.pre
+}
+
+// Metadata returns the metadata on the version.
+func (v Version) Metadata() string {
+ return v.metadata
+}
+
+// originalVPrefix returns the original 'v' prefix if any.
+func (v Version) originalVPrefix() string {
+ // Note, only lowercase v is supported as a prefix by the parser.
+ if v.original != "" && v.original[:1] == "v" {
+ return v.original[:1]
+ }
+ return ""
+}
+
+// IncPatch produces the next patch version.
+// If the current version does not have prerelease/metadata information,
+// it unsets metadata and prerelease values, increments patch number.
+// If the current version has any of prerelease or metadata information,
+// it unsets both values and keeps current patch value
+func (v Version) IncPatch() Version {
+ vNext := v
+ // according to http://semver.org/#spec-item-9
+ // Pre-release versions have a lower precedence than the associated normal version.
+ // according to http://semver.org/#spec-item-10
+ // Build metadata SHOULD be ignored when determining version precedence.
+ if v.pre != "" {
+ vNext.metadata = ""
+ vNext.pre = ""
+ } else {
+ vNext.metadata = ""
+ vNext.pre = ""
+ vNext.patch = v.patch + 1
+ }
+ vNext.original = v.originalVPrefix() + "" + vNext.String()
+ return vNext
+}
+
+// IncMinor produces the next minor version.
+// Sets patch to 0.
+// Increments minor number.
+// Unsets metadata.
+// Unsets prerelease status.
+func (v Version) IncMinor() Version {
+ vNext := v
+ vNext.metadata = ""
+ vNext.pre = ""
+ vNext.patch = 0
+ vNext.minor = v.minor + 1
+ vNext.original = v.originalVPrefix() + "" + vNext.String()
+ return vNext
+}
+
+// IncMajor produces the next major version.
+// Sets patch to 0.
+// Sets minor to 0.
+// Increments major number.
+// Unsets metadata.
+// Unsets prerelease status.
+func (v Version) IncMajor() Version {
+ vNext := v
+ vNext.metadata = ""
+ vNext.pre = ""
+ vNext.patch = 0
+ vNext.minor = 0
+ vNext.major = v.major + 1
+ vNext.original = v.originalVPrefix() + "" + vNext.String()
+ return vNext
+}
+
+// SetPrerelease defines the prerelease value.
+// Value must not include the required 'hyphen' prefix.
+func (v Version) SetPrerelease(prerelease string) (Version, error) {
+ vNext := v
+ if len(prerelease) > 0 {
+ if err := validatePrerelease(prerelease); err != nil {
+ return vNext, err
+ }
+ }
+ vNext.pre = prerelease
+ vNext.original = v.originalVPrefix() + "" + vNext.String()
+ return vNext, nil
+}
+
+// SetMetadata defines metadata value.
+// Value must not include the required 'plus' prefix.
+func (v Version) SetMetadata(metadata string) (Version, error) {
+ vNext := v
+ if len(metadata) > 0 {
+ if err := validateMetadata(metadata); err != nil {
+ return vNext, err
+ }
+ }
+ vNext.metadata = metadata
+ vNext.original = v.originalVPrefix() + "" + vNext.String()
+ return vNext, nil
+}
+
+// LessThan tests if one version is less than another one.
+func (v *Version) LessThan(o *Version) bool {
+ return v.Compare(o) < 0
+}
+
+// LessThanEqual tests if one version is less or equal than another one.
+func (v *Version) LessThanEqual(o *Version) bool {
+ return v.Compare(o) <= 0
+}
+
+// GreaterThan tests if one version is greater than another one.
+func (v *Version) GreaterThan(o *Version) bool {
+ return v.Compare(o) > 0
+}
+
+// GreaterThanEqual tests if one version is greater or equal than another one.
+func (v *Version) GreaterThanEqual(o *Version) bool {
+ return v.Compare(o) >= 0
+}
+
+// Equal tests if two versions are equal to each other.
+// Note, versions can be equal with different metadata since metadata
+// is not considered part of the comparable version.
+func (v *Version) Equal(o *Version) bool {
+ if v == o {
+ return true
+ }
+ if v == nil || o == nil {
+ return false
+ }
+ return v.Compare(o) == 0
+}
+
+// Compare compares this version to another one. It returns -1, 0, or 1 if
+// the version smaller, equal, or larger than the other version.
+//
+// Versions are compared by X.Y.Z. Build metadata is ignored. Prerelease is
+// lower than the version without a prerelease. Compare always takes into account
+// prereleases. If you want to work with ranges using typical range syntaxes that
+// skip prereleases if the range is not looking for them use constraints.
+func (v *Version) Compare(o *Version) int {
+ // Compare the major, minor, and patch version for differences. If a
+ // difference is found return the comparison.
+ if d := compareSegment(v.Major(), o.Major()); d != 0 {
+ return d
+ }
+ if d := compareSegment(v.Minor(), o.Minor()); d != 0 {
+ return d
+ }
+ if d := compareSegment(v.Patch(), o.Patch()); d != 0 {
+ return d
+ }
+
+ // At this point the major, minor, and patch versions are the same.
+ ps := v.pre
+ po := o.Prerelease()
+
+ if ps == "" && po == "" {
+ return 0
+ }
+ if ps == "" {
+ return 1
+ }
+ if po == "" {
+ return -1
+ }
+
+ return comparePrerelease(ps, po)
+}
+
+// UnmarshalJSON implements JSON.Unmarshaler interface.
+func (v *Version) UnmarshalJSON(b []byte) error {
+ var s string
+ if err := json.Unmarshal(b, &s); err != nil {
+ return err
+ }
+ temp, err := NewVersion(s)
+ if err != nil {
+ return err
+ }
+ v.major = temp.major
+ v.minor = temp.minor
+ v.patch = temp.patch
+ v.pre = temp.pre
+ v.metadata = temp.metadata
+ v.original = temp.original
+ return nil
+}
+
+// MarshalJSON implements JSON.Marshaler interface.
+func (v Version) MarshalJSON() ([]byte, error) {
+ return json.Marshal(v.String())
+}
+
+// UnmarshalText implements the encoding.TextUnmarshaler interface.
+func (v *Version) UnmarshalText(text []byte) error {
+ temp, err := NewVersion(string(text))
+ if err != nil {
+ return err
+ }
+
+ *v = *temp
+
+ return nil
+}
+
+// MarshalText implements the encoding.TextMarshaler interface.
+func (v Version) MarshalText() ([]byte, error) {
+ return []byte(v.String()), nil
+}
+
+// Scan implements the SQL.Scanner interface.
+func (v *Version) Scan(value interface{}) error {
+ var s string
+ s, _ = value.(string)
+ temp, err := NewVersion(s)
+ if err != nil {
+ return err
+ }
+ v.major = temp.major
+ v.minor = temp.minor
+ v.patch = temp.patch
+ v.pre = temp.pre
+ v.metadata = temp.metadata
+ v.original = temp.original
+ return nil
+}
+
+// Value implements the Driver.Valuer interface.
+func (v Version) Value() (driver.Value, error) {
+ return v.String(), nil
+}
+
+func compareSegment(v, o uint64) int {
+ if v < o {
+ return -1
+ }
+ if v > o {
+ return 1
+ }
+
+ return 0
+}
+
+func comparePrerelease(v, o string) int {
+ // split the prelease versions by their part. The separator, per the spec,
+ // is a .
+ sparts := strings.Split(v, ".")
+ oparts := strings.Split(o, ".")
+
+ // Find the longer length of the parts to know how many loop iterations to
+ // go through.
+ slen := len(sparts)
+ olen := len(oparts)
+
+ l := slen
+ if olen > slen {
+ l = olen
+ }
+
+ // Iterate over each part of the prereleases to compare the differences.
+ for i := 0; i < l; i++ {
+ // Since the lentgh of the parts can be different we need to create
+ // a placeholder. This is to avoid out of bounds issues.
+ stemp := ""
+ if i < slen {
+ stemp = sparts[i]
+ }
+
+ otemp := ""
+ if i < olen {
+ otemp = oparts[i]
+ }
+
+ d := comparePrePart(stemp, otemp)
+ if d != 0 {
+ return d
+ }
+ }
+
+ // Reaching here means two versions are of equal value but have different
+ // metadata (the part following a +). They are not identical in string form
+ // but the version comparison finds them to be equal.
+ return 0
+}
+
+func comparePrePart(s, o string) int {
+ // Fastpath if they are equal
+ if s == o {
+ return 0
+ }
+
+ // When s or o are empty we can use the other in an attempt to determine
+ // the response.
+ if s == "" {
+ if o != "" {
+ return -1
+ }
+ return 1
+ }
+
+ if o == "" {
+ if s != "" {
+ return 1
+ }
+ return -1
+ }
+
+ // When comparing strings "99" is greater than "103". To handle
+ // cases like this we need to detect numbers and compare them. According
+ // to the semver spec, numbers are always positive. If there is a - at the
+ // start like -99 this is to be evaluated as an alphanum. numbers always
+ // have precedence over alphanum. Parsing as Uints because negative numbers
+ // are ignored.
+
+ oi, n1 := strconv.ParseUint(o, 10, 64)
+ si, n2 := strconv.ParseUint(s, 10, 64)
+
+ // The case where both are strings compare the strings
+ if n1 != nil && n2 != nil {
+ if s > o {
+ return 1
+ }
+ return -1
+ } else if n1 != nil {
+ // o is a string and s is a number
+ return -1
+ } else if n2 != nil {
+ // s is a string and o is a number
+ return 1
+ }
+ // Both are numbers
+ if si > oi {
+ return 1
+ }
+ return -1
+}
+
+// Like strings.ContainsAny but does an only instead of any.
+func containsOnly(s string, comp string) bool {
+ return strings.IndexFunc(s, func(r rune) bool {
+ return !strings.ContainsRune(comp, r)
+ }) == -1
+}
+
+// From the spec, "Identifiers MUST comprise only
+// ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty.
+// Numeric identifiers MUST NOT include leading zeroes.". These segments can
+// be dot separated.
+func validatePrerelease(p string) error {
+ eparts := strings.Split(p, ".")
+ for _, p := range eparts {
+ if p == "" {
+ return ErrInvalidPrerelease
+ } else if containsOnly(p, num) {
+ if len(p) > 1 && p[0] == '0' {
+ return ErrSegmentStartsZero
+ }
+ } else if !containsOnly(p, allowed) {
+ return ErrInvalidPrerelease
+ }
+ }
+
+ return nil
+}
+
+// From the spec, "Build metadata MAY be denoted by
+// appending a plus sign and a series of dot separated identifiers immediately
+// following the patch or pre-release version. Identifiers MUST comprise only
+// ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty."
+func validateMetadata(m string) error {
+ eparts := strings.Split(m, ".")
+ for _, p := range eparts {
+ if p == "" {
+ return ErrInvalidMetadata
+ } else if !containsOnly(p, allowed) {
+ return ErrInvalidMetadata
+ }
+ }
+ return nil
+}
+
+// validateVersion checks for common validation issues but may not catch all errors
+func validateVersion(m []string) error {
+ var err error
+ var v string
+ if m[1] != "" {
+ if len(m[1]) > 1 && m[1][0] == '0' {
+ return ErrSegmentStartsZero
+ }
+ _, err = strconv.ParseUint(m[1], 10, 64)
+ if err != nil {
+ return fmt.Errorf("error parsing version segment: %w", err)
+ }
+ }
+
+ if m[2] != "" {
+ v = strings.TrimPrefix(m[2], ".")
+ if len(v) > 1 && v[0] == '0' {
+ return ErrSegmentStartsZero
+ }
+ _, err = strconv.ParseUint(v, 10, 64)
+ if err != nil {
+ return fmt.Errorf("error parsing version segment: %w", err)
+ }
+ }
+
+ if m[3] != "" {
+ v = strings.TrimPrefix(m[3], ".")
+ if len(v) > 1 && v[0] == '0' {
+ return ErrSegmentStartsZero
+ }
+ _, err = strconv.ParseUint(v, 10, 64)
+ if err != nil {
+ return fmt.Errorf("error parsing version segment: %w", err)
+ }
+ }
+
+ if m[5] != "" {
+ if err = validatePrerelease(m[5]); err != nil {
+ return err
+ }
+ }
+
+ if m[8] != "" {
+ if err = validateMetadata(m[8]); err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
diff --git a/vendor/github.com/onsi/ginkgo/v2/CHANGELOG.md b/vendor/github.com/onsi/ginkgo/v2/CHANGELOG.md
index 69b15d18..9db38835 100644
--- a/vendor/github.com/onsi/ginkgo/v2/CHANGELOG.md
+++ b/vendor/github.com/onsi/ginkgo/v2/CHANGELOG.md
@@ -1,3 +1,69 @@
+## 2.26.0
+
+### Features
+
+Ginkgo can now generate json-formatted reports that are compatible with the `go test` json format. Use `ginkgo --gojson-report=report.go.json`. This is not intended to be a replacement for Ginkgo's native json format which is more information rich and better models Ginkgo's test structure semantics.
+
+## 2.25.3
+
+### Fixes
+
+- emit --github-output group only for progress report itself [f01aed1]
+
+## 2.25.2
+
+### Fixes
+Add github output group for progress report content
+
+### Maintenance
+Bump Gomega
+
+## 2.25.1
+
+### Fixes
+- fix(types): ignore nameless nodes on FullText() [10866d3]
+- chore: fix some CodeQL warnings [2e42cff]
+
+## 2.25.0
+
+### `AroundNode`
+
+This release introduces a new decorator to support more complex spec setup usecases.
+
+`AroundNode` registers a function that runs before each individual node. This is considered a more advanced decorator.
+
+Please read the [docs](https://onsi.github.io/ginkgo/#advanced-around-node) for more information and some examples.
+
+Allowed signatures:
+
+- `AroundNode(func())` - `func` will be called before the node is run.
+- `AroundNode(func(ctx context.Context) context.Context)` - `func` can wrap the passed in context and return a new one which will be passed on to the node.
+- `AroundNode(func(ctx context.Context, body func(ctx context.Context)))` - `ctx` is the context for the node and `body` is a function that must be called to run the node. This gives you complete control over what runs before and after the node.
+
+Multiple `AroundNode` decorators can be applied to a single node and they will run in the order they are applied.
+
+Unlike setup nodes like `BeforeEach` and `DeferCleanup`, `AroundNode` is guaranteed to run in the same goroutine as the decorated node. This is necessary when working with lower-level libraries that must run on a single thread (you can call `runtime.LockOSThread()` in the `AroundNode` to ensure that the node runs on a single thread).
+
+Since `AroundNode` allows you to modify the context you can also use `AroundNode` to implement shared setup that attaches values to the context.
+
+If applied to a container, `AroundNode` will run before every node in the container. Including setup nodes like `BeforeEach` and `DeferCleanup`.
+
+`AroundNode` can also be applied to `RunSpecs` to run before every node in the suite. This opens up new mechanisms for instrumenting individual nodes across an entire suite.
+
+## 2.24.0
+
+### Features
+
+Specs can now be decorated with (e.g.) `SemVerConstraint("2.1.0")` and `ginkgo --sem-ver-filter="2.1.1"` will only run constrained specs that match the requested version. Learn more in the docs [here](https://onsi.github.io/ginkgo/#spec-semantic-version-filtering)! Thanks to @Icarus9913 for the PR.
+
+### Fixes
+
+- remove -o from run command [3f5d379]. fixes [#1582](https://github.com/onsi/ginkgo/issues/1582)
+
+### Maintenance
+
+Numerous dependency bumps and documentation fixes
+
## 2.23.4
Prior to this release Ginkgo would compute the incorrect number of available CPUs when running with `-p` in a linux container. Thanks to @emirot for the fix!
diff --git a/vendor/github.com/onsi/ginkgo/v2/README.md b/vendor/github.com/onsi/ginkgo/v2/README.md
index e3d0c13c..7b7ab9e3 100644
--- a/vendor/github.com/onsi/ginkgo/v2/README.md
+++ b/vendor/github.com/onsi/ginkgo/v2/README.md
@@ -113,3 +113,13 @@ Ginkgo is MIT-Licensed
## Contributing
See [CONTRIBUTING.md](CONTRIBUTING.md)
+
+## Sponsors
+
+Sponsors commit to a [sponsorship](https://github.com/sponsors/onsi) for a year. If you're an organization that makes use of Ginkgo please consider becoming a sponsor!
+
+Browser testing via
+
+ 
+
+
diff --git a/vendor/github.com/onsi/ginkgo/v2/core_dsl.go b/vendor/github.com/onsi/ginkgo/v2/core_dsl.go
index d027bdff..ec41e883 100644
--- a/vendor/github.com/onsi/ginkgo/v2/core_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/core_dsl.go
@@ -186,6 +186,20 @@ func GinkgoLabelFilter() string {
return suiteConfig.LabelFilter
}
+/*
+GinkgoSemVerFilter() returns the semantic version filter configured for this suite via `--sem-ver-filter`.
+
+You can use this to manually check if a set of semantic version constraints would satisfy the filter via:
+
+ if (SemVerConstraint("> 2.6.0", "< 2.8.0").MatchesSemVerFilter(GinkgoSemVerFilter())) {
+ //...
+ }
+*/
+func GinkgoSemVerFilter() string {
+ suiteConfig, _ := GinkgoConfiguration()
+ return suiteConfig.SemVerFilter
+}
+
/*
PauseOutputInterception() pauses Ginkgo's output interception. This is only relevant
when running in parallel and output to stdout/stderr is being intercepted. You generally
@@ -254,7 +268,7 @@ func RunSpecs(t GinkgoTestingT, description string, args ...any) bool {
}
defer global.PopClone()
- suiteLabels := extractSuiteConfiguration(args)
+ suiteLabels, suiteSemVerConstraints, suiteAroundNodes := extractSuiteConfiguration(args)
var reporter reporters.Reporter
if suiteConfig.ParallelTotal == 1 {
@@ -297,7 +311,7 @@ func RunSpecs(t GinkgoTestingT, description string, args ...any) bool {
suitePath, err = filepath.Abs(suitePath)
exitIfErr(err)
- passed, hasFocusedTests := global.Suite.Run(description, suiteLabels, suitePath, global.Failer, reporter, writer, outputInterceptor, interrupt_handler.NewInterruptHandler(client), client, internal.RegisterForProgressSignal, suiteConfig)
+ passed, hasFocusedTests := global.Suite.Run(description, suiteLabels, suiteSemVerConstraints, suiteAroundNodes, suitePath, global.Failer, reporter, writer, outputInterceptor, interrupt_handler.NewInterruptHandler(client), client, internal.RegisterForProgressSignal, suiteConfig)
outputInterceptor.Shutdown()
flagSet.ValidateDeprecations(deprecationTracker)
@@ -316,8 +330,10 @@ func RunSpecs(t GinkgoTestingT, description string, args ...any) bool {
return passed
}
-func extractSuiteConfiguration(args []any) Labels {
+func extractSuiteConfiguration(args []any) (Labels, SemVerConstraints, types.AroundNodes) {
suiteLabels := Labels{}
+ suiteSemVerConstraints := SemVerConstraints{}
+ aroundNodes := types.AroundNodes{}
configErrors := []error{}
for _, arg := range args {
switch arg := arg.(type) {
@@ -327,6 +343,10 @@ func extractSuiteConfiguration(args []any) Labels {
reporterConfig = arg
case Labels:
suiteLabels = append(suiteLabels, arg...)
+ case SemVerConstraints:
+ suiteSemVerConstraints = append(suiteSemVerConstraints, arg...)
+ case types.AroundNodeDecorator:
+ aroundNodes = append(aroundNodes, arg)
default:
configErrors = append(configErrors, types.GinkgoErrors.UnknownTypePassedToRunSpecs(arg))
}
@@ -342,7 +362,7 @@ func extractSuiteConfiguration(args []any) Labels {
os.Exit(1)
}
- return suiteLabels
+ return suiteLabels, suiteSemVerConstraints, aroundNodes
}
func getwd() (string, error) {
@@ -365,7 +385,7 @@ func PreviewSpecs(description string, args ...any) Report {
}
defer global.PopClone()
- suiteLabels := extractSuiteConfiguration(args)
+ suiteLabels, suiteSemVerConstraints, suiteAroundNodes := extractSuiteConfiguration(args)
priorDryRun, priorParallelTotal, priorParallelProcess := suiteConfig.DryRun, suiteConfig.ParallelTotal, suiteConfig.ParallelProcess
suiteConfig.DryRun, suiteConfig.ParallelTotal, suiteConfig.ParallelProcess = true, 1, 1
defer func() {
@@ -383,7 +403,7 @@ func PreviewSpecs(description string, args ...any) Report {
suitePath, err = filepath.Abs(suitePath)
exitIfErr(err)
- global.Suite.Run(description, suiteLabels, suitePath, global.Failer, reporter, writer, outputInterceptor, interrupt_handler.NewInterruptHandler(client), client, internal.RegisterForProgressSignal, suiteConfig)
+ global.Suite.Run(description, suiteLabels, suiteSemVerConstraints, suiteAroundNodes, suitePath, global.Failer, reporter, writer, outputInterceptor, interrupt_handler.NewInterruptHandler(client), client, internal.RegisterForProgressSignal, suiteConfig)
return global.Suite.GetPreviewReport()
}
diff --git a/vendor/github.com/onsi/ginkgo/v2/decorator_dsl.go b/vendor/github.com/onsi/ginkgo/v2/decorator_dsl.go
index c65af4ce..8bee5ace 100644
--- a/vendor/github.com/onsi/ginkgo/v2/decorator_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/decorator_dsl.go
@@ -2,6 +2,7 @@ package ginkgo
import (
"github.com/onsi/ginkgo/v2/internal"
+ "github.com/onsi/ginkgo/v2/types"
)
/*
@@ -99,6 +100,23 @@ You can learn more here: https://onsi.github.io/ginkgo/#spec-labels
*/
type Labels = internal.Labels
+/*
+SemVerConstraint decorates specs with SemVerConstraints. Multiple semantic version constraints can be passed to SemVerConstraint and these strings must follow the semantic version constraint rules.
+SemVerConstraints can be applied to container and subject nodes, but not setup nodes. You can provide multiple SemVerConstraints to a given node and a spec's semantic version constraints is the union of all semantic version constraints in its node hierarchy.
+
+You can learn more here: https://onsi.github.io/ginkgo/#spec-semantic-version-filtering
+You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
+*/
+func SemVerConstraint(semVerConstraints ...string) SemVerConstraints {
+ return SemVerConstraints(semVerConstraints)
+}
+
+/*
+SemVerConstraints are the type for spec SemVerConstraint decorators. Use SemVerConstraint(...) to construct SemVerConstraints.
+You can learn more here: https://onsi.github.io/ginkgo/#spec-semantic-version-filtering
+*/
+type SemVerConstraints = internal.SemVerConstraints
+
/*
PollProgressAfter allows you to override the configured value for --poll-progress-after for a particular node.
@@ -141,3 +159,28 @@ SuppressProgressReporting is a decorator that allows you to disable progress rep
if you have a `ReportAfterEach` node that is running for every skipped spec and is generating lots of progress reports.
*/
const SuppressProgressReporting = internal.SuppressProgressReporting
+
+/*
+AroundNode registers a function that runs before each individual node. This is considered a more advanced decorator.
+
+Please read the [docs](https://onsi.github.io/ginkgo/#advanced-around-node) for more information.
+
+Allowed signatures:
+
+- AroundNode(func()) - func will be called before the node is run.
+- AroundNode(func(ctx context.Context) context.Context) - func can wrap the passed in context and return a new one which will be passed on to the node.
+- AroundNode(func(ctx context.Context, body func(ctx context.Context))) - ctx is the context for the node and body is a function that must be called to run the node. This gives you complete control over what runs before and after the node.
+
+Multiple AroundNode decorators can be applied to a single node and they will run in the order they are applied.
+
+Unlike setup nodes like BeforeEach and DeferCleanup, AroundNode is guaranteed to run in the same goroutine as the decorated node. This is necessary when working with lower-level libraries that must run on a single thread (you can call runtime.LockOSThread() in the AroundNode to ensure that the node runs on a single thread).
+
+Since AroundNode allows you to modify the context you can also use AroundNode to implement shared setup that attaches values to the context. You must return a context that inherits from the passed in context.
+
+If applied to a container, AroundNode will run before every node in the container. Including setup nodes like BeforeEach and DeferCleanup.
+
+AroundNode can also be applied to RunSpecs to run before every node in the suite.
+*/
+func AroundNode[F types.AroundNodeAllowedFuncs](f F) types.AroundNodeDecorator {
+ return types.AroundNode(f, types.NewCodeLocation(1))
+}
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo/build/build_command.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo/build/build_command.go
index 2b36b2fe..3021dfec 100644
--- a/vendor/github.com/onsi/ginkgo/v2/ginkgo/build/build_command.go
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo/build/build_command.go
@@ -29,7 +29,6 @@ func BuildBuildCommand() command.Command {
var errors []error
cliConfig, goFlagsConfig, errors = types.VetAndInitializeCLIAndGoConfig(cliConfig, goFlagsConfig)
command.AbortIfErrors("Ginkgo detected configuration issues:", errors)
-
buildSpecs(args, cliConfig, goFlagsConfig)
},
}
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/profiles_and_reports.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/profiles_and_reports.go
index 8e16d2bb..f3439a3f 100644
--- a/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/profiles_and_reports.go
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/profiles_and_reports.go
@@ -90,6 +90,9 @@ func FinalizeProfilesAndReportsForSuites(suites TestSuites, cliConfig types.CLIC
if reporterConfig.JSONReport != "" {
reportFormats = append(reportFormats, reportFormat{ReportName: reporterConfig.JSONReport, GenerateFunc: reporters.GenerateJSONReport, MergeFunc: reporters.MergeAndCleanupJSONReports})
}
+ if reporterConfig.GoJSONReport != "" {
+ reportFormats = append(reportFormats, reportFormat{ReportName: reporterConfig.GoJSONReport, GenerateFunc: reporters.GenerateGoTestJSONReport, MergeFunc: reporters.MergeAndCleanupGoTestJSONReports})
+ }
if reporterConfig.JUnitReport != "" {
reportFormats = append(reportFormats, reportFormat{ReportName: reporterConfig.JUnitReport, GenerateFunc: reporters.GenerateJUnitReport, MergeFunc: reporters.MergeAndCleanupJUnitReports})
}
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/run.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/run.go
index 41052ea1..30d8096c 100644
--- a/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/run.go
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo/internal/run.go
@@ -107,6 +107,9 @@ func runSerial(suite TestSuite, ginkgoConfig types.SuiteConfig, reporterConfig t
if reporterConfig.JSONReport != "" {
reporterConfig.JSONReport = AbsPathForGeneratedAsset(reporterConfig.JSONReport, suite, cliConfig, 0)
}
+ if reporterConfig.GoJSONReport != "" {
+ reporterConfig.GoJSONReport = AbsPathForGeneratedAsset(reporterConfig.GoJSONReport, suite, cliConfig, 0)
+ }
if reporterConfig.JUnitReport != "" {
reporterConfig.JUnitReport = AbsPathForGeneratedAsset(reporterConfig.JUnitReport, suite, cliConfig, 0)
}
@@ -179,6 +182,9 @@ func runParallel(suite TestSuite, ginkgoConfig types.SuiteConfig, reporterConfig
if reporterConfig.JSONReport != "" {
reporterConfig.JSONReport = AbsPathForGeneratedAsset(reporterConfig.JSONReport, suite, cliConfig, 0)
}
+ if reporterConfig.GoJSONReport != "" {
+ reporterConfig.GoJSONReport = AbsPathForGeneratedAsset(reporterConfig.GoJSONReport, suite, cliConfig, 0)
+ }
if reporterConfig.JUnitReport != "" {
reporterConfig.JUnitReport = AbsPathForGeneratedAsset(reporterConfig.JUnitReport, suite, cliConfig, 0)
}
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo/main.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo/main.go
index bd6b8fbf..419589b4 100644
--- a/vendor/github.com/onsi/ginkgo/v2/ginkgo/main.go
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo/main.go
@@ -3,7 +3,6 @@ package main
import (
"fmt"
"os"
- _ "go.uber.org/automaxprocs"
"github.com/onsi/ginkgo/v2/ginkgo/build"
"github.com/onsi/ginkgo/v2/ginkgo/command"
"github.com/onsi/ginkgo/v2/ginkgo/generators"
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo/maxprocs.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo/maxprocs.go
new file mode 100644
index 00000000..a7d2b37d
--- /dev/null
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo/maxprocs.go
@@ -0,0 +1,8 @@
+//go:build !go1.25
+// +build !go1.25
+
+package main
+
+import (
+ _ "go.uber.org/automaxprocs"
+)
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo/watch/dependencies.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo/watch/dependencies.go
index a34d9435..75cbdb49 100644
--- a/vendor/github.com/onsi/ginkgo/v2/ginkgo/watch/dependencies.go
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo/watch/dependencies.go
@@ -2,12 +2,9 @@ package watch
import (
"go/build"
- "regexp"
+ "strings"
)
-var ginkgoAndGomegaFilter = regexp.MustCompile(`github\.com/onsi/ginkgo|github\.com/onsi/gomega`)
-var ginkgoIntegrationTestFilter = regexp.MustCompile(`github\.com/onsi/ginkgo/integration`) //allow us to integration test this thing
-
type Dependencies struct {
deps map[string]int
}
@@ -78,7 +75,7 @@ func (d Dependencies) resolveAndAdd(deps []string, depth int) {
if err != nil {
continue
}
- if !pkg.Goroot && (!ginkgoAndGomegaFilter.MatchString(pkg.Dir) || ginkgoIntegrationTestFilter.MatchString(pkg.Dir)) {
+ if !pkg.Goroot && (!matchesGinkgoOrGomega(pkg.Dir) || matchesGinkgoIntegration(pkg.Dir)) {
d.addDepIfNotPresent(pkg.Dir, depth)
}
}
@@ -90,3 +87,11 @@ func (d Dependencies) addDepIfNotPresent(dep string, depth int) {
d.deps[dep] = depth
}
}
+
+func matchesGinkgoOrGomega(s string) bool {
+ return strings.Contains(s, "github.com/onsi/ginkgo") || strings.Contains(s, "github.com/onsi/gomega")
+}
+
+func matchesGinkgoIntegration(s string) bool {
+ return strings.Contains(s, "github.com/onsi/ginkgo/integration") // allow us to integration test this thing
+}
diff --git a/vendor/github.com/onsi/ginkgo/v2/ginkgo_t_dsl.go b/vendor/github.com/onsi/ginkgo/v2/ginkgo_t_dsl.go
index 993279de..cabf2814 100644
--- a/vendor/github.com/onsi/ginkgo/v2/ginkgo_t_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/ginkgo_t_dsl.go
@@ -2,6 +2,7 @@ package ginkgo
import (
"context"
+ "io"
"testing"
"github.com/onsi/ginkgo/v2/internal/testingtproxy"
@@ -69,6 +70,8 @@ type GinkgoTInterface interface {
Skipf(format string, args ...any)
Skipped() bool
TempDir() string
+ Attr(key, value string)
+ Output() io.Writer
}
/*
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/around_node.go b/vendor/github.com/onsi/ginkgo/v2/internal/around_node.go
new file mode 100644
index 00000000..c9657102
--- /dev/null
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/around_node.go
@@ -0,0 +1,34 @@
+package internal
+
+import (
+ "github.com/onsi/ginkgo/v2/types"
+)
+
+func ComputeAroundNodes(specs Specs) Specs {
+ out := Specs{}
+ for _, spec := range specs {
+ nodes := Nodes{}
+ currentNestingLevel := 0
+ aroundNodes := types.AroundNodes{}
+ nestingLevelIndices := []int{}
+ for _, node := range spec.Nodes {
+ switch node.NodeType {
+ case types.NodeTypeContainer:
+ currentNestingLevel = node.NestingLevel + 1
+ nestingLevelIndices = append(nestingLevelIndices, len(aroundNodes))
+ aroundNodes = aroundNodes.Append(node.AroundNodes...)
+ nodes = append(nodes, node)
+ default:
+ if currentNestingLevel > node.NestingLevel {
+ currentNestingLevel = node.NestingLevel
+ aroundNodes = aroundNodes[:nestingLevelIndices[currentNestingLevel]]
+ }
+ node.AroundNodes = types.AroundNodes{}.Append(aroundNodes...).Append(node.AroundNodes...)
+ nodes = append(nodes, node)
+ }
+ }
+ spec.Nodes = nodes
+ out = append(out, spec)
+ }
+ return out
+}
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/focus.go b/vendor/github.com/onsi/ginkgo/v2/internal/focus.go
index e3da7d14..a39daf5a 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/focus.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/focus.go
@@ -56,7 +56,7 @@ This function sets the `Skip` property on specs by applying Ginkgo's focus polic
*Note:* specs with pending nodes are Skipped when created by NewSpec.
*/
-func ApplyFocusToSpecs(specs Specs, description string, suiteLabels Labels, suiteConfig types.SuiteConfig) (Specs, bool) {
+func ApplyFocusToSpecs(specs Specs, description string, suiteLabels Labels, suiteSemVerConstraints SemVerConstraints, suiteConfig types.SuiteConfig) (Specs, bool) {
focusString := strings.Join(suiteConfig.FocusStrings, "|")
skipString := strings.Join(suiteConfig.SkipStrings, "|")
@@ -84,6 +84,13 @@ func ApplyFocusToSpecs(specs Specs, description string, suiteLabels Labels, suit
})
}
+ if suiteConfig.SemVerFilter != "" {
+ semVerFilter, _ := types.ParseSemVerFilter(suiteConfig.SemVerFilter)
+ skipChecks = append(skipChecks, func(spec Spec) bool {
+ return !semVerFilter(UnionOfSemVerConstraints(suiteSemVerConstraints, spec.Nodes.UnionOfSemVerConstraints()))
+ })
+ }
+
if len(suiteConfig.FocusFiles) > 0 {
focusFilters, _ := types.ParseFileFilters(suiteConfig.FocusFiles)
skipChecks = append(skipChecks, func(spec Spec) bool { return !focusFilters.Matches(spec.Nodes.CodeLocations()) })
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/group.go b/vendor/github.com/onsi/ginkgo/v2/internal/group.go
index 02c9fe4f..b88fe206 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/group.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/group.go
@@ -112,19 +112,21 @@ func newGroup(suite *Suite) *group {
func (g *group) initialReportForSpec(spec Spec) types.SpecReport {
return types.SpecReport{
- ContainerHierarchyTexts: spec.Nodes.WithType(types.NodeTypeContainer).Texts(),
- ContainerHierarchyLocations: spec.Nodes.WithType(types.NodeTypeContainer).CodeLocations(),
- ContainerHierarchyLabels: spec.Nodes.WithType(types.NodeTypeContainer).Labels(),
- LeafNodeLocation: spec.FirstNodeWithType(types.NodeTypeIt).CodeLocation,
- LeafNodeType: types.NodeTypeIt,
- LeafNodeText: spec.FirstNodeWithType(types.NodeTypeIt).Text,
- LeafNodeLabels: []string(spec.FirstNodeWithType(types.NodeTypeIt).Labels),
- ParallelProcess: g.suite.config.ParallelProcess,
- RunningInParallel: g.suite.isRunningInParallel(),
- IsSerial: spec.Nodes.HasNodeMarkedSerial(),
- IsInOrderedContainer: !spec.Nodes.FirstNodeMarkedOrdered().IsZero(),
- MaxFlakeAttempts: spec.Nodes.GetMaxFlakeAttempts(),
- MaxMustPassRepeatedly: spec.Nodes.GetMaxMustPassRepeatedly(),
+ ContainerHierarchyTexts: spec.Nodes.WithType(types.NodeTypeContainer).Texts(),
+ ContainerHierarchyLocations: spec.Nodes.WithType(types.NodeTypeContainer).CodeLocations(),
+ ContainerHierarchyLabels: spec.Nodes.WithType(types.NodeTypeContainer).Labels(),
+ ContainerHierarchySemVerConstraints: spec.Nodes.WithType(types.NodeTypeContainer).SemVerConstraints(),
+ LeafNodeLocation: spec.FirstNodeWithType(types.NodeTypeIt).CodeLocation,
+ LeafNodeType: types.NodeTypeIt,
+ LeafNodeText: spec.FirstNodeWithType(types.NodeTypeIt).Text,
+ LeafNodeLabels: []string(spec.FirstNodeWithType(types.NodeTypeIt).Labels),
+ LeafNodeSemVerConstraints: []string(spec.FirstNodeWithType(types.NodeTypeIt).SemVerConstraints),
+ ParallelProcess: g.suite.config.ParallelProcess,
+ RunningInParallel: g.suite.isRunningInParallel(),
+ IsSerial: spec.Nodes.HasNodeMarkedSerial(),
+ IsInOrderedContainer: !spec.Nodes.FirstNodeMarkedOrdered().IsZero(),
+ MaxFlakeAttempts: spec.Nodes.GetMaxFlakeAttempts(),
+ MaxMustPassRepeatedly: spec.Nodes.GetMaxMustPassRepeatedly(),
}
}
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/node.go b/vendor/github.com/onsi/ginkgo/v2/internal/node.go
index 8096950b..647368fe 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/node.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/node.go
@@ -55,11 +55,13 @@ type Node struct {
FlakeAttempts int
MustPassRepeatedly int
Labels Labels
+ SemVerConstraints SemVerConstraints
PollProgressAfter time.Duration
PollProgressInterval time.Duration
NodeTimeout time.Duration
SpecTimeout time.Duration
GracePeriod time.Duration
+ AroundNodes types.AroundNodes
NodeIDWhereCleanupWasGenerated uint
}
@@ -85,31 +87,46 @@ type FlakeAttempts uint
type MustPassRepeatedly uint
type Offset uint
type Done chan<- any // Deprecated Done Channel for asynchronous testing
-type Labels []string
type PollProgressInterval time.Duration
type PollProgressAfter time.Duration
type NodeTimeout time.Duration
type SpecTimeout time.Duration
type GracePeriod time.Duration
+type Labels []string
+
func (l Labels) MatchesLabelFilter(query string) bool {
return types.MustParseLabelFilter(query)(l)
}
-func UnionOfLabels(labels ...Labels) Labels {
- out := Labels{}
- seen := map[string]bool{}
- for _, labelSet := range labels {
- for _, label := range labelSet {
- if !seen[label] {
- seen[label] = true
- out = append(out, label)
+type SemVerConstraints []string
+
+func (svc SemVerConstraints) MatchesSemVerFilter(version string) bool {
+ return types.MustParseSemVerFilter(version)(svc)
+}
+
+func unionOf[S ~[]E, E comparable](slices ...S) S {
+ out := S{}
+ seen := map[E]bool{}
+ for _, slice := range slices {
+ for _, item := range slice {
+ if !seen[item] {
+ seen[item] = true
+ out = append(out, item)
}
}
}
return out
}
+func UnionOfLabels(labels ...Labels) Labels {
+ return unionOf(labels...)
+}
+
+func UnionOfSemVerConstraints(semVerConstraints ...SemVerConstraints) SemVerConstraints {
+ return unionOf(semVerConstraints...)
+}
+
func PartitionDecorations(args ...any) ([]any, []any) {
decorations := []any{}
remainingArgs := []any{}
@@ -151,6 +168,8 @@ func isDecoration(arg any) bool {
return true
case t == reflect.TypeOf(Labels{}):
return true
+ case t == reflect.TypeOf(SemVerConstraints{}):
+ return true
case t == reflect.TypeOf(PollProgressInterval(0)):
return true
case t == reflect.TypeOf(PollProgressAfter(0)):
@@ -161,6 +180,8 @@ func isDecoration(arg any) bool {
return true
case t == reflect.TypeOf(GracePeriod(0)):
return true
+ case t == reflect.TypeOf(types.AroundNodeDecorator{}):
+ return true
case t.Kind() == reflect.Slice && isSliceOfDecorations(arg):
return true
default:
@@ -191,6 +212,7 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
NodeType: nodeType,
Text: text,
Labels: Labels{},
+ SemVerConstraints: SemVerConstraints{},
CodeLocation: types.NewCodeLocation(baseOffset),
NestingLevel: -1,
PollProgressAfter: -1,
@@ -221,6 +243,7 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
}
labelsSeen := map[string]bool{}
+ semVerConstraintsSeen := map[string]bool{}
trackedFunctionError := false
args = remainingArgs
remainingArgs = []any{}
@@ -299,6 +322,8 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
if nodeType.Is(types.NodeTypeContainer) {
appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "GracePeriod"))
}
+ case t == reflect.TypeOf(types.AroundNodeDecorator{}):
+ node.AroundNodes = append(node.AroundNodes, arg.(types.AroundNodeDecorator))
case t == reflect.TypeOf(Labels{}):
if !nodeType.Is(types.NodeTypesForContainerAndIt) {
appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "Label"))
@@ -311,6 +336,18 @@ func NewNode(deprecationTracker *types.DeprecationTracker, nodeType types.NodeTy
appendError(err)
}
}
+ case t == reflect.TypeOf(SemVerConstraints{}):
+ if !nodeType.Is(types.NodeTypesForContainerAndIt) {
+ appendError(types.GinkgoErrors.InvalidDecoratorForNodeType(node.CodeLocation, nodeType, "SemVerConstraint"))
+ }
+ for _, semVerConstraint := range arg.(SemVerConstraints) {
+ if !semVerConstraintsSeen[semVerConstraint] {
+ semVerConstraintsSeen[semVerConstraint] = true
+ semVerConstraint, err := types.ValidateAndCleanupSemVerConstraint(semVerConstraint, node.CodeLocation)
+ node.SemVerConstraints = append(node.SemVerConstraints, semVerConstraint)
+ appendError(err)
+ }
+ }
case t.Kind() == reflect.Func:
if nodeType.Is(types.NodeTypeContainer) {
if node.Body != nil {
@@ -824,6 +861,32 @@ func (n Nodes) UnionOfLabels() []string {
return out
}
+func (n Nodes) SemVerConstraints() [][]string {
+ out := make([][]string, len(n))
+ for i := range n {
+ if n[i].SemVerConstraints == nil {
+ out[i] = []string{}
+ } else {
+ out[i] = []string(n[i].SemVerConstraints)
+ }
+ }
+ return out
+}
+
+func (n Nodes) UnionOfSemVerConstraints() []string {
+ out := []string{}
+ seen := map[string]bool{}
+ for i := range n {
+ for _, constraint := range n[i].SemVerConstraints {
+ if !seen[constraint] {
+ seen[constraint] = true
+ out = append(out, constraint)
+ }
+ }
+ }
+ return out
+}
+
func (n Nodes) CodeLocations() []types.CodeLocation {
out := make([]types.CodeLocation, len(n))
for i := range n {
@@ -928,7 +991,7 @@ func unrollInterfaceSlice(args any) []any {
out := []any{}
for i := 0; i < v.Len(); i++ {
el := reflect.ValueOf(v.Index(i).Interface())
- if el.Kind() == reflect.Slice && el.Type() != reflect.TypeOf(Labels{}) {
+ if el.Kind() == reflect.Slice && el.Type() != reflect.TypeOf(Labels{}) && el.Type() != reflect.TypeOf(SemVerConstraints{}) {
out = append(out, unrollInterfaceSlice(el.Interface())...)
} else {
out = append(out, v.Index(i).Interface())
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/progress_report.go b/vendor/github.com/onsi/ginkgo/v2/internal/progress_report.go
index 11269cf1..165cbc4b 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/progress_report.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/progress_report.go
@@ -236,7 +236,7 @@ func extractRunningGoroutines() ([]types.Goroutine, error) {
}
functionCall.Filename = line[:delimiterIdx]
line = strings.Split(line[delimiterIdx+1:], " ")[0]
- lineNumber, err := strconv.ParseInt(line, 10, 64)
+ lineNumber, err := strconv.ParseInt(line, 10, 32)
functionCall.Line = int(lineNumber)
if err != nil {
return nil, types.GinkgoErrors.FailedToParseStackTrace(fmt.Sprintf("Invalid function call line number: %s\n%s", line, err.Error()))
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/reporters/gojson.go b/vendor/github.com/onsi/ginkgo/v2/internal/reporters/gojson.go
new file mode 100644
index 00000000..8b7a9cea
--- /dev/null
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/reporters/gojson.go
@@ -0,0 +1,158 @@
+package reporters
+
+import (
+ "errors"
+ "fmt"
+ "strings"
+ "time"
+
+ "github.com/onsi/ginkgo/v2/types"
+ "golang.org/x/tools/go/packages"
+)
+
+func ptr[T any](in T) *T {
+ return &in
+}
+
+type encoder interface {
+ Encode(v any) error
+}
+
+// gojsonEvent matches the format from go internals
+// https://github.com/golang/go/blob/master/src/cmd/internal/test2json/test2json.go#L31-L41
+// https://pkg.go.dev/cmd/test2json
+type gojsonEvent struct {
+ Time *time.Time `json:",omitempty"`
+ Action GoJSONAction
+ Package string `json:",omitempty"`
+ Test string `json:",omitempty"`
+ Elapsed *float64 `json:",omitempty"`
+ Output *string `json:",omitempty"`
+ FailedBuild string `json:",omitempty"`
+}
+
+type GoJSONAction string
+
+const (
+ // start - the test binary is about to be executed
+ GoJSONStart GoJSONAction = "start"
+ // run - the test has started running
+ GoJSONRun GoJSONAction = "run"
+ // pause - the test has been paused
+ GoJSONPause GoJSONAction = "pause"
+ // cont - the test has continued running
+ GoJSONCont GoJSONAction = "cont"
+ // pass - the test passed
+ GoJSONPass GoJSONAction = "pass"
+ // bench - the benchmark printed log output but did not fail
+ GoJSONBench GoJSONAction = "bench"
+ // fail - the test or benchmark failed
+ GoJSONFail GoJSONAction = "fail"
+ // output - the test printed output
+ GoJSONOutput GoJSONAction = "output"
+ // skip - the test was skipped or the package contained no tests
+ GoJSONSkip GoJSONAction = "skip"
+)
+
+func goJSONActionFromSpecState(state types.SpecState) GoJSONAction {
+ switch state {
+ case types.SpecStateInvalid:
+ return GoJSONFail
+ case types.SpecStatePending:
+ return GoJSONSkip
+ case types.SpecStateSkipped:
+ return GoJSONSkip
+ case types.SpecStatePassed:
+ return GoJSONPass
+ case types.SpecStateFailed:
+ return GoJSONFail
+ case types.SpecStateAborted:
+ return GoJSONFail
+ case types.SpecStatePanicked:
+ return GoJSONFail
+ case types.SpecStateInterrupted:
+ return GoJSONFail
+ case types.SpecStateTimedout:
+ return GoJSONFail
+ default:
+ panic("unexpected state should not happen")
+ }
+}
+
+// gojsonReport wraps types.Report and calcualtes extra fields requires by gojson
+type gojsonReport struct {
+ o types.Report
+ // Extra calculated fields
+ goPkg string
+ elapsed float64
+}
+
+func newReport(in types.Report) *gojsonReport {
+ return &gojsonReport{
+ o: in,
+ }
+}
+
+func (r *gojsonReport) Fill() error {
+ // NOTE: could the types.Report include the go package name?
+ goPkg, err := suitePathToPkg(r.o.SuitePath)
+ if err != nil {
+ return err
+ }
+ r.goPkg = goPkg
+ r.elapsed = r.o.RunTime.Seconds()
+ return nil
+}
+
+// gojsonSpecReport wraps types.SpecReport and calculates extra fields required by gojson
+type gojsonSpecReport struct {
+ o types.SpecReport
+ // extra calculated fields
+ testName string
+ elapsed float64
+ action GoJSONAction
+}
+
+func newSpecReport(in types.SpecReport) *gojsonSpecReport {
+ return &gojsonSpecReport{
+ o: in,
+ }
+}
+
+func (sr *gojsonSpecReport) Fill() error {
+ sr.elapsed = sr.o.RunTime.Seconds()
+ sr.testName = createTestName(sr.o)
+ sr.action = goJSONActionFromSpecState(sr.o.State)
+ return nil
+}
+
+func suitePathToPkg(dir string) (string, error) {
+ cfg := &packages.Config{
+ Mode: packages.NeedFiles | packages.NeedSyntax,
+ }
+ pkgs, err := packages.Load(cfg, dir)
+ if err != nil {
+ return "", err
+ }
+ if len(pkgs) != 1 {
+ return "", errors.New("error")
+ }
+ return pkgs[0].ID, nil
+}
+
+func createTestName(spec types.SpecReport) string {
+ name := fmt.Sprintf("[%s]", spec.LeafNodeType)
+ if spec.FullText() != "" {
+ name = name + " " + spec.FullText()
+ }
+ labels := spec.Labels()
+ if len(labels) > 0 {
+ name = name + " [" + strings.Join(labels, ", ") + "]"
+ }
+ semVerConstraints := spec.SemVerConstraints()
+ if len(semVerConstraints) > 0 {
+ name = name + " [" + strings.Join(semVerConstraints, ", ") + "]"
+ }
+ name = strings.TrimSpace(name)
+ return name
+}
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/reporters/gojson_event_writer.go b/vendor/github.com/onsi/ginkgo/v2/internal/reporters/gojson_event_writer.go
new file mode 100644
index 00000000..ec5311d0
--- /dev/null
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/reporters/gojson_event_writer.go
@@ -0,0 +1,111 @@
+package reporters
+
+type GoJSONEventWriter struct {
+ enc encoder
+ specSystemErrFn specSystemExtractFn
+ specSystemOutFn specSystemExtractFn
+}
+
+func NewGoJSONEventWriter(enc encoder, errFn specSystemExtractFn, outFn specSystemExtractFn) *GoJSONEventWriter {
+ return &GoJSONEventWriter{
+ enc: enc,
+ specSystemErrFn: errFn,
+ specSystemOutFn: outFn,
+ }
+}
+
+func (r *GoJSONEventWriter) writeEvent(e *gojsonEvent) error {
+ return r.enc.Encode(e)
+}
+
+func (r *GoJSONEventWriter) WriteSuiteStart(report *gojsonReport) error {
+ e := &gojsonEvent{
+ Time: &report.o.StartTime,
+ Action: GoJSONStart,
+ Package: report.goPkg,
+ Output: nil,
+ FailedBuild: "",
+ }
+ return r.writeEvent(e)
+}
+
+func (r *GoJSONEventWriter) WriteSuiteResult(report *gojsonReport) error {
+ var action GoJSONAction
+ switch {
+ case report.o.PreRunStats.SpecsThatWillRun == 0:
+ action = GoJSONSkip
+ case report.o.SuiteSucceeded:
+ action = GoJSONPass
+ default:
+ action = GoJSONFail
+ }
+ e := &gojsonEvent{
+ Time: &report.o.EndTime,
+ Action: action,
+ Package: report.goPkg,
+ Output: nil,
+ FailedBuild: "",
+ Elapsed: ptr(report.elapsed),
+ }
+ return r.writeEvent(e)
+}
+
+func (r *GoJSONEventWriter) WriteSpecStart(report *gojsonReport, specReport *gojsonSpecReport) error {
+ e := &gojsonEvent{
+ Time: &specReport.o.StartTime,
+ Action: GoJSONRun,
+ Test: specReport.testName,
+ Package: report.goPkg,
+ Output: nil,
+ FailedBuild: "",
+ }
+ return r.writeEvent(e)
+}
+
+func (r *GoJSONEventWriter) WriteSpecOut(report *gojsonReport, specReport *gojsonSpecReport) error {
+ events := []*gojsonEvent{}
+
+ stdErr := r.specSystemErrFn(specReport.o)
+ if stdErr != "" {
+ events = append(events, &gojsonEvent{
+ Time: &specReport.o.EndTime,
+ Action: GoJSONOutput,
+ Test: specReport.testName,
+ Package: report.goPkg,
+ Output: ptr(stdErr),
+ FailedBuild: "",
+ })
+ }
+ stdOut := r.specSystemOutFn(specReport.o)
+ if stdOut != "" {
+ events = append(events, &gojsonEvent{
+ Time: &specReport.o.EndTime,
+ Action: GoJSONOutput,
+ Test: specReport.testName,
+ Package: report.goPkg,
+ Output: ptr(stdOut),
+ FailedBuild: "",
+ })
+ }
+
+ for _, ev := range events {
+ err := r.writeEvent(ev)
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (r *GoJSONEventWriter) WriteSpecResult(report *gojsonReport, specReport *gojsonSpecReport) error {
+ e := &gojsonEvent{
+ Time: &specReport.o.EndTime,
+ Action: specReport.action,
+ Test: specReport.testName,
+ Package: report.goPkg,
+ Elapsed: ptr(specReport.elapsed),
+ Output: nil,
+ FailedBuild: "",
+ }
+ return r.writeEvent(e)
+}
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/reporters/gojson_reporter.go b/vendor/github.com/onsi/ginkgo/v2/internal/reporters/gojson_reporter.go
new file mode 100644
index 00000000..633e49b8
--- /dev/null
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/reporters/gojson_reporter.go
@@ -0,0 +1,45 @@
+package reporters
+
+import (
+ "github.com/onsi/ginkgo/v2/types"
+)
+
+type GoJSONReporter struct {
+ ev *GoJSONEventWriter
+}
+
+type specSystemExtractFn func (spec types.SpecReport) string
+
+func NewGoJSONReporter(enc encoder, errFn specSystemExtractFn, outFn specSystemExtractFn) *GoJSONReporter {
+ return &GoJSONReporter{
+ ev: NewGoJSONEventWriter(enc, errFn, outFn),
+ }
+}
+
+func (r *GoJSONReporter) Write(originalReport types.Report) error {
+ // suite start events
+ report := newReport(originalReport)
+ err := report.Fill()
+ if err != nil {
+ return err
+ }
+ r.ev.WriteSuiteStart(report)
+ for _, originalSpecReport := range originalReport.SpecReports {
+ specReport := newSpecReport(originalSpecReport)
+ err := specReport.Fill()
+ if err != nil {
+ return err
+ }
+ if specReport.o.LeafNodeType == types.NodeTypeIt {
+ // handle any It leaf node as a spec
+ r.ev.WriteSpecStart(report, specReport)
+ r.ev.WriteSpecOut(report, specReport)
+ r.ev.WriteSpecResult(report, specReport)
+ } else {
+ // handle any other leaf node as generic output
+ r.ev.WriteSpecOut(report, specReport)
+ }
+ }
+ r.ev.WriteSuiteResult(report)
+ return nil
+}
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/spec_context.go b/vendor/github.com/onsi/ginkgo/v2/internal/spec_context.go
index 2d2ea2fc..99c9c5f5 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/spec_context.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/spec_context.go
@@ -2,6 +2,7 @@ package internal
import (
"context"
+ "reflect"
"github.com/onsi/ginkgo/v2/types"
)
@@ -11,6 +12,7 @@ type SpecContext interface {
SpecReport() types.SpecReport
AttachProgressReporter(func() string) func()
+ WrappedContext() context.Context
}
type specContext struct {
@@ -45,3 +47,28 @@ func NewSpecContext(suite *Suite) *specContext {
func (sc *specContext) SpecReport() types.SpecReport {
return sc.suite.CurrentSpecReport()
}
+
+func (sc *specContext) WrappedContext() context.Context {
+ return sc.Context
+}
+
+/*
+The user is allowed to wrap `SpecContext` in a new context.Context when using AroundNodes. But body functions expect SpecContext.
+We support this by taking their context.Context and returning a SpecContext that wraps it.
+*/
+func wrapContextChain(ctx context.Context) SpecContext {
+ if ctx == nil {
+ return nil
+ }
+ if reflect.TypeOf(ctx) == reflect.TypeOf(&specContext{}) {
+ return ctx.(*specContext)
+ } else if sc, ok := ctx.Value("GINKGO_SPEC_CONTEXT").(*specContext); ok {
+ return &specContext{
+ Context: ctx,
+ ProgressReporterManager: sc.ProgressReporterManager,
+ cancel: sc.cancel,
+ suite: sc.suite,
+ }
+ }
+ return nil
+}
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/suite.go b/vendor/github.com/onsi/ginkgo/v2/internal/suite.go
index 3edf5077..14a0688f 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/suite.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/suite.go
@@ -32,6 +32,7 @@ type Suite struct {
suiteNodes Nodes
cleanupNodes Nodes
+ aroundNodes types.AroundNodes
failer *Failer
reporter reporters.Reporter
@@ -87,6 +88,7 @@ func (suite *Suite) Clone() (*Suite, error) {
ProgressReporterManager: NewProgressReporterManager(),
topLevelContainers: suite.topLevelContainers.Clone(),
suiteNodes: suite.suiteNodes.Clone(),
+ aroundNodes: suite.aroundNodes.Clone(),
selectiveLock: &sync.Mutex{},
}, nil
}
@@ -104,13 +106,14 @@ func (suite *Suite) BuildTree() error {
return nil
}
-func (suite *Suite) Run(description string, suiteLabels Labels, suitePath string, failer *Failer, reporter reporters.Reporter, writer WriterInterface, outputInterceptor OutputInterceptor, interruptHandler interrupt_handler.InterruptHandlerInterface, client parallel_support.Client, progressSignalRegistrar ProgressSignalRegistrar, suiteConfig types.SuiteConfig) (bool, bool) {
+func (suite *Suite) Run(description string, suiteLabels Labels, suiteSemVerConstraints SemVerConstraints, suiteAroundNodes types.AroundNodes, suitePath string, failer *Failer, reporter reporters.Reporter, writer WriterInterface, outputInterceptor OutputInterceptor, interruptHandler interrupt_handler.InterruptHandlerInterface, client parallel_support.Client, progressSignalRegistrar ProgressSignalRegistrar, suiteConfig types.SuiteConfig) (bool, bool) {
if suite.phase != PhaseBuildTree {
panic("cannot run before building the tree = call suite.BuildTree() first")
}
ApplyNestedFocusPolicyToTree(suite.tree)
specs := GenerateSpecsFromTreeRoot(suite.tree)
- specs, hasProgrammaticFocus := ApplyFocusToSpecs(specs, description, suiteLabels, suiteConfig)
+ specs, hasProgrammaticFocus := ApplyFocusToSpecs(specs, description, suiteLabels, suiteSemVerConstraints, suiteConfig)
+ specs = ComputeAroundNodes(specs)
suite.phase = PhaseRun
suite.client = client
@@ -120,6 +123,7 @@ func (suite *Suite) Run(description string, suiteLabels Labels, suitePath string
suite.outputInterceptor = outputInterceptor
suite.interruptHandler = interruptHandler
suite.config = suiteConfig
+ suite.aroundNodes = suiteAroundNodes
if suite.config.Timeout > 0 {
suite.deadline = time.Now().Add(suite.config.Timeout)
@@ -127,7 +131,7 @@ func (suite *Suite) Run(description string, suiteLabels Labels, suitePath string
cancelProgressHandler := progressSignalRegistrar(suite.handleProgressSignal)
- success := suite.runSpecs(description, suiteLabels, suitePath, hasProgrammaticFocus, specs)
+ success := suite.runSpecs(description, suiteLabels, suiteSemVerConstraints, suitePath, hasProgrammaticFocus, specs)
cancelProgressHandler()
@@ -259,6 +263,7 @@ func (suite *Suite) pushCleanupNode(node Node) error {
node.NodeIDWhereCleanupWasGenerated = suite.currentNode.ID
node.NestingLevel = suite.currentNode.NestingLevel
+ node.AroundNodes = types.AroundNodes{}.Append(suite.currentNode.AroundNodes...).Append(node.AroundNodes...)
suite.selectiveLock.Lock()
suite.cleanupNodes = append(suite.cleanupNodes, node)
suite.selectiveLock.Unlock()
@@ -428,13 +433,14 @@ func (suite *Suite) processCurrentSpecReport() {
}
}
-func (suite *Suite) runSpecs(description string, suiteLabels Labels, suitePath string, hasProgrammaticFocus bool, specs Specs) bool {
+func (suite *Suite) runSpecs(description string, suiteLabels Labels, suiteSemVerConstraints SemVerConstraints, suitePath string, hasProgrammaticFocus bool, specs Specs) bool {
numSpecsThatWillBeRun := specs.CountWithoutSkip()
suite.report = types.Report{
SuitePath: suitePath,
SuiteDescription: description,
SuiteLabels: suiteLabels,
+ SuiteSemVerConstraints: suiteSemVerConstraints,
SuiteConfig: suite.config,
SuiteHasProgrammaticFocus: hasProgrammaticFocus,
PreRunStats: types.PreRunStats{
@@ -891,7 +897,30 @@ func (suite *Suite) runNode(node Node, specDeadline time.Time, text string) (typ
failureC <- failureFromRun
}()
- node.Body(sc)
+ aroundNodes := types.AroundNodes{}.Append(suite.aroundNodes...).Append(node.AroundNodes...)
+ if len(aroundNodes) > 0 {
+ i := 0
+ var f func(context.Context)
+ f = func(c context.Context) {
+ sc := wrapContextChain(c)
+ if sc == nil {
+ suite.failer.Fail("An AroundNode failed to pass a valid Ginkgo SpecContext in. You must always pass in a context derived from the context passed to you.", aroundNodes[i].CodeLocation)
+ return
+ }
+ i++
+ if i < len(aroundNodes) {
+ aroundNodes[i].Body(sc, f)
+ } else {
+ node.Body(sc)
+ }
+ }
+ aroundNodes[0].Body(sc, f)
+ if i != len(aroundNodes) {
+ suite.failer.Fail("An AroundNode failed to call the passed in function.", aroundNodes[i].CodeLocation)
+ }
+ } else {
+ node.Body(sc)
+ }
finished = true
}()
diff --git a/vendor/github.com/onsi/ginkgo/v2/internal/testingtproxy/testing_t_proxy.go b/vendor/github.com/onsi/ginkgo/v2/internal/testingtproxy/testing_t_proxy.go
index b4ecc7cb..9806e315 100644
--- a/vendor/github.com/onsi/ginkgo/v2/internal/testingtproxy/testing_t_proxy.go
+++ b/vendor/github.com/onsi/ginkgo/v2/internal/testingtproxy/testing_t_proxy.go
@@ -229,3 +229,9 @@ func (t *ginkgoTestingTProxy) ParallelTotal() int {
func (t *ginkgoTestingTProxy) AttachProgressReporter(f func() string) func() {
return t.attachProgressReporter(f)
}
+func (t *ginkgoTestingTProxy) Output() io.Writer {
+ return t.writer
+}
+func (t *ginkgoTestingTProxy) Attr(key, value string) {
+ t.addReportEntry(key, value, internal.Offset(1), types.ReportEntryVisibilityFailureOrVerbose)
+}
diff --git a/vendor/github.com/onsi/ginkgo/v2/reporters/default_reporter.go b/vendor/github.com/onsi/ginkgo/v2/reporters/default_reporter.go
index 74ad0768..8c3714b8 100644
--- a/vendor/github.com/onsi/ginkgo/v2/reporters/default_reporter.go
+++ b/vendor/github.com/onsi/ginkgo/v2/reporters/default_reporter.go
@@ -72,6 +72,9 @@ func (r *DefaultReporter) SuiteWillBegin(report types.Report) {
if len(report.SuiteLabels) > 0 {
r.emit(r.f("{{coral}}[%s]{{/}} ", strings.Join(report.SuiteLabels, ", ")))
}
+ if len(report.SuiteSemVerConstraints) > 0 {
+ r.emit(r.f("{{coral}}[%s]{{/}} ", strings.Join(report.SuiteSemVerConstraints, ", ")))
+ }
r.emit(r.f("- %d/%d specs ", report.PreRunStats.SpecsThatWillRun, report.PreRunStats.TotalSpecs))
if report.SuiteConfig.ParallelTotal > 1 {
r.emit(r.f("- %d procs ", report.SuiteConfig.ParallelTotal))
@@ -87,6 +90,13 @@ func (r *DefaultReporter) SuiteWillBegin(report types.Report) {
bannerWidth = len(labels) + 2
}
}
+ if len(report.SuiteSemVerConstraints) > 0 {
+ semVerConstraints := strings.Join(report.SuiteSemVerConstraints, ", ")
+ r.emitBlock(r.f("{{coral}}[%s]{{/}} ", semVerConstraints))
+ if len(semVerConstraints)+2 > bannerWidth {
+ bannerWidth = len(semVerConstraints) + 2
+ }
+ }
r.emitBlock(strings.Repeat("=", bannerWidth))
out := r.f("Random Seed: {{bold}}%d{{/}}", report.SuiteConfig.RandomSeed)
@@ -394,7 +404,7 @@ func (r *DefaultReporter) emitTimeline(indent uint, report types.SpecReport, tim
case types.ReportEntry:
r.emitReportEntry(indent, x)
case types.ProgressReport:
- r.emitProgressReport(indent, false, x)
+ r.emitProgressReport(indent, false, false, x)
case types.SpecEvent:
if isVeryVerbose || !x.IsOnlyVisibleAtVeryVerbose() || r.conf.ShowNodeEvents {
r.emitSpecEvent(indent, x, isVeryVerbose)
@@ -448,7 +458,7 @@ func (r *DefaultReporter) emitFailure(indent uint, state types.SpecState, failur
if !failure.ProgressReport.IsZero() {
r.emitBlock("\n")
- r.emitProgressReport(indent, false, failure.ProgressReport)
+ r.emitProgressReport(indent, false, false, failure.ProgressReport)
}
if failure.AdditionalFailure != nil && includeAdditionalFailure {
@@ -464,11 +474,11 @@ func (r *DefaultReporter) EmitProgressReport(report types.ProgressReport) {
r.emit(r.fi(1, "{{coral}}Progress Report for Ginkgo Process #{{bold}}%d{{/}}\n", report.ParallelProcess))
}
shouldEmitGW := report.RunningInParallel || r.conf.Verbosity().LT(types.VerbosityLevelVerbose)
- r.emitProgressReport(1, shouldEmitGW, report)
+ r.emitProgressReport(1, shouldEmitGW, true, report)
r.emitDelimiter(1)
}
-func (r *DefaultReporter) emitProgressReport(indent uint, emitGinkgoWriterOutput bool, report types.ProgressReport) {
+func (r *DefaultReporter) emitProgressReport(indent uint, emitGinkgoWriterOutput, emitGroup bool, report types.ProgressReport) {
if report.Message != "" {
r.emitBlock(r.fi(indent, report.Message+"\n"))
indent += 1
@@ -504,6 +514,10 @@ func (r *DefaultReporter) emitProgressReport(indent uint, emitGinkgoWriterOutput
indent -= 1
}
+ if r.conf.GithubOutput && emitGroup {
+ r.emitBlock(r.fi(indent, "::group::Progress Report"))
+ }
+
if emitGinkgoWriterOutput && report.CapturedGinkgoWriterOutput != "" {
r.emit("\n")
r.emitBlock(r.fi(indent, "{{gray}}Begin Captured GinkgoWriter Output >>{{/}}"))
@@ -550,6 +564,10 @@ func (r *DefaultReporter) emitProgressReport(indent uint, emitGinkgoWriterOutput
r.emit(r.fi(indent, "{{gray}}{{bold}}{{underline}}Other Goroutines{{/}}\n"))
r.emitGoroutines(indent, otherGoroutines...)
}
+
+ if r.conf.GithubOutput && emitGroup {
+ r.emitBlock(r.fi(indent, "::endgroup::"))
+ }
}
func (r *DefaultReporter) EmitReportEntry(entry types.ReportEntry) {
@@ -698,8 +716,8 @@ func (r *DefaultReporter) cycleJoin(elements []string, joiner string) string {
}
func (r *DefaultReporter) codeLocationBlock(report types.SpecReport, highlightColor string, veryVerbose bool, usePreciseFailureLocation bool) string {
- texts, locations, labels := []string{}, []types.CodeLocation{}, [][]string{}
- texts, locations, labels = append(texts, report.ContainerHierarchyTexts...), append(locations, report.ContainerHierarchyLocations...), append(labels, report.ContainerHierarchyLabels...)
+ texts, locations, labels, semVerConstraints := []string{}, []types.CodeLocation{}, [][]string{}, [][]string{}
+ texts, locations, labels, semVerConstraints = append(texts, report.ContainerHierarchyTexts...), append(locations, report.ContainerHierarchyLocations...), append(labels, report.ContainerHierarchyLabels...), append(semVerConstraints, report.ContainerHierarchySemVerConstraints...)
if report.LeafNodeType.Is(types.NodeTypesForSuiteLevelNodes) {
texts = append(texts, r.f("[%s] %s", report.LeafNodeType, report.LeafNodeText))
@@ -707,6 +725,7 @@ func (r *DefaultReporter) codeLocationBlock(report types.SpecReport, highlightCo
texts = append(texts, r.f(report.LeafNodeText))
}
labels = append(labels, report.LeafNodeLabels)
+ semVerConstraints = append(semVerConstraints, report.LeafNodeSemVerConstraints)
locations = append(locations, report.LeafNodeLocation)
failureLocation := report.Failure.FailureNodeLocation
@@ -720,6 +739,7 @@ func (r *DefaultReporter) codeLocationBlock(report types.SpecReport, highlightCo
texts = append([]string{fmt.Sprintf("TOP-LEVEL [%s]", report.Failure.FailureNodeType)}, texts...)
locations = append([]types.CodeLocation{failureLocation}, locations...)
labels = append([][]string{{}}, labels...)
+ semVerConstraints = append([][]string{{}}, semVerConstraints...)
highlightIndex = 0
case types.FailureNodeInContainer:
i := report.Failure.FailureNodeContainerIndex
@@ -747,6 +767,9 @@ func (r *DefaultReporter) codeLocationBlock(report types.SpecReport, highlightCo
if len(labels[i]) > 0 {
out += r.f(" {{coral}}[%s]{{/}}", strings.Join(labels[i], ", "))
}
+ if len(semVerConstraints[i]) > 0 {
+ out += r.f(" {{coral}}[%s]{{/}}", strings.Join(semVerConstraints[i], ", "))
+ }
out += "\n"
out += r.fi(uint(i), "{{gray}}%s{{/}}\n", locations[i])
}
@@ -770,6 +793,10 @@ func (r *DefaultReporter) codeLocationBlock(report types.SpecReport, highlightCo
if len(flattenedLabels) > 0 {
out += r.f(" {{coral}}[%s]{{/}}", strings.Join(flattenedLabels, ", "))
}
+ flattenedSemVerConstraints := report.SemVerConstraints()
+ if len(flattenedSemVerConstraints) > 0 {
+ out += r.f(" {{coral}}[%s]{{/}}", strings.Join(flattenedSemVerConstraints, ", "))
+ }
out += "\n"
if usePreciseFailureLocation {
out += r.f("{{gray}}%s{{/}}", failureLocation)
diff --git a/vendor/github.com/onsi/ginkgo/v2/reporters/gojson_report.go b/vendor/github.com/onsi/ginkgo/v2/reporters/gojson_report.go
new file mode 100644
index 00000000..d02fb7a1
--- /dev/null
+++ b/vendor/github.com/onsi/ginkgo/v2/reporters/gojson_report.go
@@ -0,0 +1,61 @@
+package reporters
+
+import (
+ "encoding/json"
+ "fmt"
+ "os"
+ "path"
+
+ "github.com/onsi/ginkgo/v2/internal/reporters"
+ "github.com/onsi/ginkgo/v2/types"
+)
+
+// GenerateGoTestJSONReport produces a JSON-formatted in the test2json format used by `go test -json`
+func GenerateGoTestJSONReport(report types.Report, destination string) error {
+ // walk report and generate test2json-compatible objects
+ // JSON-encode the objects into filename
+ if err := os.MkdirAll(path.Dir(destination), 0770); err != nil {
+ return err
+ }
+ f, err := os.Create(destination)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+ enc := json.NewEncoder(f)
+ r := reporters.NewGoJSONReporter(
+ enc,
+ systemErrForUnstructuredReporters,
+ systemOutForUnstructuredReporters,
+ )
+ return r.Write(report)
+}
+
+// MergeJSONReports produces a single JSON-formatted report at the passed in destination by merging the JSON-formatted reports provided in sources
+// It skips over reports that fail to decode but reports on them via the returned messages []string
+func MergeAndCleanupGoTestJSONReports(sources []string, destination string) ([]string, error) {
+ messages := []string{}
+ if err := os.MkdirAll(path.Dir(destination), 0770); err != nil {
+ return messages, err
+ }
+ f, err := os.Create(destination)
+ if err != nil {
+ return messages, err
+ }
+ defer f.Close()
+
+ for _, source := range sources {
+ data, err := os.ReadFile(source)
+ if err != nil {
+ messages = append(messages, fmt.Sprintf("Could not open %s:\n%s", source, err.Error()))
+ continue
+ }
+ _, err = f.Write(data)
+ if err != nil {
+ messages = append(messages, fmt.Sprintf("Could not write to %s:\n%s", destination, err.Error()))
+ continue
+ }
+ os.Remove(source)
+ }
+ return messages, nil
+}
diff --git a/vendor/github.com/onsi/ginkgo/v2/reporters/junit_report.go b/vendor/github.com/onsi/ginkgo/v2/reporters/junit_report.go
index 562e0f62..828f893f 100644
--- a/vendor/github.com/onsi/ginkgo/v2/reporters/junit_report.go
+++ b/vendor/github.com/onsi/ginkgo/v2/reporters/junit_report.go
@@ -36,6 +36,9 @@ type JunitReportConfig struct {
// Enable OmitSpecLabels to prevent labels from appearing in the spec name
OmitSpecLabels bool
+ // Enable OmitSpecSemVerConstraints to prevent semantic version constraints from appearing in the spec name
+ OmitSpecSemVerConstraints bool
+
// Enable OmitLeafNodeType to prevent the spec leaf node type from appearing in the spec name
OmitLeafNodeType bool
@@ -169,9 +172,11 @@ func GenerateJUnitReportWithConfig(report types.Report, dst string, config Junit
{"SuiteHasProgrammaticFocus", fmt.Sprintf("%t", report.SuiteHasProgrammaticFocus)},
{"SpecialSuiteFailureReason", strings.Join(report.SpecialSuiteFailureReasons, ",")},
{"SuiteLabels", fmt.Sprintf("[%s]", strings.Join(report.SuiteLabels, ","))},
+ {"SuiteSemVerConstraints", fmt.Sprintf("[%s]", strings.Join(report.SuiteSemVerConstraints, ","))},
{"RandomSeed", fmt.Sprintf("%d", report.SuiteConfig.RandomSeed)},
{"RandomizeAllSpecs", fmt.Sprintf("%t", report.SuiteConfig.RandomizeAllSpecs)},
{"LabelFilter", report.SuiteConfig.LabelFilter},
+ {"SemVerFilter", report.SuiteConfig.SemVerFilter},
{"FocusStrings", strings.Join(report.SuiteConfig.FocusStrings, ",")},
{"SkipStrings", strings.Join(report.SuiteConfig.SkipStrings, ",")},
{"FocusFiles", strings.Join(report.SuiteConfig.FocusFiles, ";")},
@@ -207,6 +212,10 @@ func GenerateJUnitReportWithConfig(report types.Report, dst string, config Junit
owner = matches[1]
}
}
+ semVerConstraints := spec.SemVerConstraints()
+ if len(semVerConstraints) > 0 && !config.OmitSpecSemVerConstraints {
+ name = name + " [" + strings.Join(semVerConstraints, ", ") + "]"
+ }
name = strings.TrimSpace(name)
test := JUnitTestCase{
diff --git a/vendor/github.com/onsi/ginkgo/v2/reporters/teamcity_report.go b/vendor/github.com/onsi/ginkgo/v2/reporters/teamcity_report.go
index e990ad82..55e1d1f4 100644
--- a/vendor/github.com/onsi/ginkgo/v2/reporters/teamcity_report.go
+++ b/vendor/github.com/onsi/ginkgo/v2/reporters/teamcity_report.go
@@ -38,9 +38,13 @@ func GenerateTeamcityReport(report types.Report, dst string) error {
name := report.SuiteDescription
labels := report.SuiteLabels
+ semVerConstraints := report.SuiteSemVerConstraints
if len(labels) > 0 {
name = name + " [" + strings.Join(labels, ", ") + "]"
}
+ if len(semVerConstraints) > 0 {
+ name = name + " [" + strings.Join(semVerConstraints, ", ") + "]"
+ }
fmt.Fprintf(f, "##teamcity[testSuiteStarted name='%s']\n", tcEscape(name))
for _, spec := range report.SpecReports {
name := fmt.Sprintf("[%s]", spec.LeafNodeType)
@@ -51,6 +55,10 @@ func GenerateTeamcityReport(report types.Report, dst string) error {
if len(labels) > 0 {
name = name + " [" + strings.Join(labels, ", ") + "]"
}
+ semVerConstraints := spec.SemVerConstraints()
+ if len(semVerConstraints) > 0 {
+ name = name + " [" + strings.Join(semVerConstraints, ", ") + "]"
+ }
name = tcEscape(name)
fmt.Fprintf(f, "##teamcity[testStarted name='%s']\n", name)
diff --git a/vendor/github.com/onsi/ginkgo/v2/reporting_dsl.go b/vendor/github.com/onsi/ginkgo/v2/reporting_dsl.go
index 5bf2e62e..dd135054 100644
--- a/vendor/github.com/onsi/ginkgo/v2/reporting_dsl.go
+++ b/vendor/github.com/onsi/ginkgo/v2/reporting_dsl.go
@@ -165,7 +165,7 @@ ReportAfterSuite nodes must be created at the top-level (i.e. not nested in a Co
When running in parallel, Ginkgo ensures that only one of the parallel nodes runs the ReportAfterSuite and that it is passed a report that is aggregated across
all parallel nodes
-In addition to using ReportAfterSuite to programmatically generate suite reports, you can also generate JSON, JUnit, and Teamcity formatted reports using the --json-report, --junit-report, and --teamcity-report ginkgo CLI flags.
+In addition to using ReportAfterSuite to programmatically generate suite reports, you can also generate JSON, GoJSON, JUnit, and Teamcity formatted reports using the --json-report, --gojson-report, --junit-report, and --teamcity-report ginkgo CLI flags.
You cannot nest any other Ginkgo nodes within a ReportAfterSuite node's closure.
You can learn more about ReportAfterSuite here: https://onsi.github.io/ginkgo/#generating-reports-programmatically
@@ -188,6 +188,12 @@ func registerReportAfterSuiteNodeForAutogeneratedReports(reporterConfig types.Re
Fail(fmt.Sprintf("Failed to generate JSON report:\n%s", err.Error()))
}
}
+ if reporterConfig.GoJSONReport != "" {
+ err := reporters.GenerateGoTestJSONReport(report, reporterConfig.GoJSONReport)
+ if err != nil {
+ Fail(fmt.Sprintf("Failed to generate Go JSON report:\n%s", err.Error()))
+ }
+ }
if reporterConfig.JUnitReport != "" {
err := reporters.GenerateJUnitReport(report, reporterConfig.JUnitReport)
if err != nil {
@@ -206,6 +212,9 @@ func registerReportAfterSuiteNodeForAutogeneratedReports(reporterConfig types.Re
if reporterConfig.JSONReport != "" {
flags = append(flags, "--json-report")
}
+ if reporterConfig.GoJSONReport != "" {
+ flags = append(flags, "--gojson-report")
+ }
if reporterConfig.JUnitReport != "" {
flags = append(flags, "--junit-report")
}
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/around_node.go b/vendor/github.com/onsi/ginkgo/v2/types/around_node.go
new file mode 100644
index 00000000..a069e062
--- /dev/null
+++ b/vendor/github.com/onsi/ginkgo/v2/types/around_node.go
@@ -0,0 +1,56 @@
+package types
+
+import (
+ "context"
+)
+
+type AroundNodeAllowedFuncs interface {
+ ~func(context.Context, func(context.Context)) | ~func(context.Context) context.Context | ~func()
+}
+type AroundNodeFunc func(ctx context.Context, body func(ctx context.Context))
+
+func AroundNode[F AroundNodeAllowedFuncs](f F, cl CodeLocation) AroundNodeDecorator {
+ if f == nil {
+ panic("BuildAroundNode cannot be called with a nil function.")
+ }
+ var aroundNodeFunc func(context.Context, func(context.Context))
+ switch x := any(f).(type) {
+ case func(context.Context, func(context.Context)):
+ aroundNodeFunc = x
+ case func(context.Context) context.Context:
+ aroundNodeFunc = func(ctx context.Context, body func(context.Context)) {
+ ctx = x(ctx)
+ body(ctx)
+ }
+ case func():
+ aroundNodeFunc = func(ctx context.Context, body func(context.Context)) {
+ x()
+ body(ctx)
+ }
+ }
+
+ return AroundNodeDecorator{
+ Body: aroundNodeFunc,
+ CodeLocation: cl,
+ }
+}
+
+type AroundNodeDecorator struct {
+ Body AroundNodeFunc
+ CodeLocation CodeLocation
+}
+
+type AroundNodes []AroundNodeDecorator
+
+func (an AroundNodes) Clone() AroundNodes {
+ out := make(AroundNodes, len(an))
+ copy(out, an)
+ return out
+}
+
+func (an AroundNodes) Append(other ...AroundNodeDecorator) AroundNodes {
+ out := make(AroundNodes, len(an)+len(other))
+ copy(out, an)
+ copy(out[len(an):], other)
+ return out
+}
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/config.go b/vendor/github.com/onsi/ginkgo/v2/types/config.go
index 2e827efe..f8470360 100644
--- a/vendor/github.com/onsi/ginkgo/v2/types/config.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/config.go
@@ -24,6 +24,7 @@ type SuiteConfig struct {
FocusFiles []string
SkipFiles []string
LabelFilter string
+ SemVerFilter string
FailOnPending bool
FailOnEmpty bool
FailFast bool
@@ -95,6 +96,7 @@ type ReporterConfig struct {
ForceNewlines bool
JSONReport string
+ GoJSONReport string
JUnitReport string
TeamcityReport string
}
@@ -111,7 +113,7 @@ func (rc ReporterConfig) Verbosity() VerbosityLevel {
}
func (rc ReporterConfig) WillGenerateReport() bool {
- return rc.JSONReport != "" || rc.JUnitReport != "" || rc.TeamcityReport != ""
+ return rc.JSONReport != "" || rc.GoJSONReport != "" || rc.JUnitReport != "" || rc.TeamcityReport != ""
}
func NewDefaultReporterConfig() ReporterConfig {
@@ -308,6 +310,8 @@ var SuiteConfigFlags = GinkgoFlags{
{KeyPath: "S.LabelFilter", Name: "label-filter", SectionKey: "filter", UsageArgument: "expression",
Usage: "If set, ginkgo will only run specs with labels that match the label-filter. The passed-in expression can include boolean operations (!, &&, ||, ','), groupings via '()', and regular expressions '/regexp/'. e.g. '(cat || dog) && !fruit'"},
+ {KeyPath: "S.SemVerFilter", Name: "sem-ver-filter", SectionKey: "filter", UsageArgument: "version",
+ Usage: "If set, ginkgo will only run specs with semantic version constraints that are satisfied by the provided version. e.g. '2.1.0'"},
{KeyPath: "S.FocusStrings", Name: "focus", SectionKey: "filter",
Usage: "If set, ginkgo will only run specs that match this regular expression. Can be specified multiple times, values are ORed."},
{KeyPath: "S.SkipStrings", Name: "skip", SectionKey: "filter",
@@ -356,6 +360,8 @@ var ReporterConfigFlags = GinkgoFlags{
{KeyPath: "R.JSONReport", Name: "json-report", UsageArgument: "filename.json", SectionKey: "output",
Usage: "If set, Ginkgo will generate a JSON-formatted test report at the specified location."},
+ {KeyPath: "R.GoJSONReport", Name: "gojson-report", UsageArgument: "filename.json", SectionKey: "output",
+ Usage: "If set, Ginkgo will generate a Go JSON-formatted test report at the specified location."},
{KeyPath: "R.JUnitReport", Name: "junit-report", UsageArgument: "filename.xml", SectionKey: "output", DeprecatedName: "reportFile", DeprecatedDocLink: "improved-reporting-infrastructure",
Usage: "If set, Ginkgo will generate a conformant junit test report in the specified file."},
{KeyPath: "R.TeamcityReport", Name: "teamcity-report", UsageArgument: "filename", SectionKey: "output",
@@ -443,6 +449,13 @@ func VetConfig(flagSet GinkgoFlagSet, suiteConfig SuiteConfig, reporterConfig Re
}
}
+ if suiteConfig.SemVerFilter != "" {
+ _, err := ParseSemVerFilter(suiteConfig.SemVerFilter)
+ if err != nil {
+ errors = append(errors, err)
+ }
+ }
+
switch strings.ToLower(suiteConfig.OutputInterceptorMode) {
case "", "dup", "swap", "none":
default:
@@ -573,6 +586,9 @@ var GoBuildFlags = GinkgoFlags{
Usage: "print the name of the temporary work directory and do not delete it when exiting."},
{KeyPath: "Go.X", Name: "x", SectionKey: "go-build",
Usage: "print the commands."},
+}
+
+var GoBuildOFlags = GinkgoFlags{
{KeyPath: "Go.O", Name: "o", SectionKey: "go-build",
Usage: "output binary path (including name)."},
}
@@ -673,7 +689,7 @@ func GenerateGoTestCompileArgs(goFlagsConfig GoFlagsConfig, packageToBuild strin
args := []string{"test", "-c", packageToBuild}
goArgs, err := GenerateFlagArgs(
- GoBuildFlags,
+ GoBuildFlags.CopyAppend(GoBuildOFlags...),
map[string]any{
"Go": &goFlagsConfig,
},
@@ -763,6 +779,7 @@ func BuildWatchCommandFlagSet(suiteConfig *SuiteConfig, reporterConfig *Reporter
func BuildBuildCommandFlagSet(cliConfig *CLIConfig, goFlagsConfig *GoFlagsConfig) (GinkgoFlagSet, error) {
flags := GinkgoCLISharedFlags
flags = flags.CopyAppend(GoBuildFlags...)
+ flags = flags.CopyAppend(GoBuildOFlags...)
bindings := map[string]any{
"C": cliConfig,
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/errors.go b/vendor/github.com/onsi/ginkgo/v2/types/errors.go
index c2796b54..59313238 100644
--- a/vendor/github.com/onsi/ginkgo/v2/types/errors.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/errors.go
@@ -432,6 +432,24 @@ func (g ginkgoErrors) InvalidEmptyLabel(cl CodeLocation) error {
}
}
+func (g ginkgoErrors) InvalidSemVerConstraint(semVerConstraint, errMsg string, cl CodeLocation) error {
+ return GinkgoError{
+ Heading: "Invalid SemVerConstraint",
+ Message: fmt.Sprintf("'%s' is an invalid SemVerConstraint: %s", semVerConstraint, errMsg),
+ CodeLocation: cl,
+ DocLink: "spec-semantic-version-filtering",
+ }
+}
+
+func (g ginkgoErrors) InvalidEmptySemVerConstraint(cl CodeLocation) error {
+ return GinkgoError{
+ Heading: "Invalid Empty SemVerConstraint",
+ Message: "SemVerConstraint cannot be empty",
+ CodeLocation: cl,
+ DocLink: "spec-semantic-version-filtering",
+ }
+}
+
/* Table errors */
func (g ginkgoErrors) MultipleEntryBodyFunctionsForTable(cl CodeLocation) error {
return GinkgoError{
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/semver_filter.go b/vendor/github.com/onsi/ginkgo/v2/types/semver_filter.go
new file mode 100644
index 00000000..3fc2ed14
--- /dev/null
+++ b/vendor/github.com/onsi/ginkgo/v2/types/semver_filter.go
@@ -0,0 +1,60 @@
+package types
+
+import (
+ "fmt"
+
+ "github.com/Masterminds/semver/v3"
+)
+
+type SemVerFilter func([]string) bool
+
+func MustParseSemVerFilter(input string) SemVerFilter {
+ filter, err := ParseSemVerFilter(input)
+ if err != nil {
+ panic(err)
+ }
+ return filter
+}
+
+func ParseSemVerFilter(filterVersion string) (SemVerFilter, error) {
+ if filterVersion == "" {
+ return func(_ []string) bool { return true }, nil
+ }
+
+ targetVersion, err := semver.NewVersion(filterVersion)
+ if err != nil {
+ return nil, fmt.Errorf("invalid filter version: %w", err)
+ }
+
+ return func(constraints []string) bool {
+ // unconstrained specs always run
+ if len(constraints) == 0 {
+ return true
+ }
+
+ for _, constraintStr := range constraints {
+ constraint, err := semver.NewConstraint(constraintStr)
+ if err != nil {
+ return false
+ }
+
+ if !constraint.Check(targetVersion) {
+ return false
+ }
+ }
+
+ return true
+ }, nil
+}
+
+func ValidateAndCleanupSemVerConstraint(semVerConstraint string, cl CodeLocation) (string, error) {
+ if len(semVerConstraint) == 0 {
+ return "", GinkgoErrors.InvalidEmptySemVerConstraint(cl)
+ }
+ _, err := semver.NewConstraint(semVerConstraint)
+ if err != nil {
+ return "", GinkgoErrors.InvalidSemVerConstraint(semVerConstraint, err.Error(), cl)
+ }
+
+ return semVerConstraint, nil
+}
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/types.go b/vendor/github.com/onsi/ginkgo/v2/types/types.go
index ddcbec1b..b8e864a5 100644
--- a/vendor/github.com/onsi/ginkgo/v2/types/types.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/types.go
@@ -4,6 +4,7 @@ import (
"encoding/json"
"fmt"
"os"
+ "slices"
"sort"
"strings"
"time"
@@ -30,6 +31,9 @@ type Report struct {
//SuiteLabels captures any labels attached to the suite by the DSL's RunSpecs() function
SuiteLabels []string
+ //SuiteSemVerConstraints captures any semVerConstraints attached to the suite by the DSL's RunSpecs() function
+ SuiteSemVerConstraints []string
+
//SuiteSucceeded captures the success or failure status of the test run
//If true, the test run is considered successful.
//If false, the test run is considered unsuccessful
@@ -129,13 +133,18 @@ type SpecReport struct {
// all Describe/Context/When containers in this spec's hierarchy
ContainerHierarchyLabels [][]string
- // LeafNodeType, LeadNodeLocation, LeafNodeLabels and LeafNodeText capture the NodeType, CodeLocation, and text
+ // ContainerHierarchySemVerConstraints is a slice containing the semVerConstraints of
+ // all Describe/Context/When containers in this spec's hierarchy
+ ContainerHierarchySemVerConstraints [][]string
+
+ // LeafNodeType, LeafNodeLocation, LeafNodeLabels, LeafNodeSemVerConstraints and LeafNodeText capture the NodeType, CodeLocation, and text
// of the Ginkgo node being tested (typically an NodeTypeIt node, though this can also be
// one of the NodeTypesForSuiteLevelNodes node types)
- LeafNodeType NodeType
- LeafNodeLocation CodeLocation
- LeafNodeLabels []string
- LeafNodeText string
+ LeafNodeType NodeType
+ LeafNodeLocation CodeLocation
+ LeafNodeLabels []string
+ LeafNodeSemVerConstraints []string
+ LeafNodeText string
// State captures whether the spec has passed, failed, etc.
State SpecState
@@ -198,48 +207,52 @@ type SpecReport struct {
func (report SpecReport) MarshalJSON() ([]byte, error) {
//All this to avoid emitting an empty Failure struct in the JSON
out := struct {
- ContainerHierarchyTexts []string
- ContainerHierarchyLocations []CodeLocation
- ContainerHierarchyLabels [][]string
- LeafNodeType NodeType
- LeafNodeLocation CodeLocation
- LeafNodeLabels []string
- LeafNodeText string
- State SpecState
- StartTime time.Time
- EndTime time.Time
- RunTime time.Duration
- ParallelProcess int
- Failure *Failure `json:",omitempty"`
- NumAttempts int
- MaxFlakeAttempts int
- MaxMustPassRepeatedly int
- CapturedGinkgoWriterOutput string `json:",omitempty"`
- CapturedStdOutErr string `json:",omitempty"`
- ReportEntries ReportEntries `json:",omitempty"`
- ProgressReports []ProgressReport `json:",omitempty"`
- AdditionalFailures []AdditionalFailure `json:",omitempty"`
- SpecEvents SpecEvents `json:",omitempty"`
+ ContainerHierarchyTexts []string
+ ContainerHierarchyLocations []CodeLocation
+ ContainerHierarchyLabels [][]string
+ ContainerHierarchySemVerConstraints [][]string
+ LeafNodeType NodeType
+ LeafNodeLocation CodeLocation
+ LeafNodeLabels []string
+ LeafNodeSemVerConstraints []string
+ LeafNodeText string
+ State SpecState
+ StartTime time.Time
+ EndTime time.Time
+ RunTime time.Duration
+ ParallelProcess int
+ Failure *Failure `json:",omitempty"`
+ NumAttempts int
+ MaxFlakeAttempts int
+ MaxMustPassRepeatedly int
+ CapturedGinkgoWriterOutput string `json:",omitempty"`
+ CapturedStdOutErr string `json:",omitempty"`
+ ReportEntries ReportEntries `json:",omitempty"`
+ ProgressReports []ProgressReport `json:",omitempty"`
+ AdditionalFailures []AdditionalFailure `json:",omitempty"`
+ SpecEvents SpecEvents `json:",omitempty"`
}{
- ContainerHierarchyTexts: report.ContainerHierarchyTexts,
- ContainerHierarchyLocations: report.ContainerHierarchyLocations,
- ContainerHierarchyLabels: report.ContainerHierarchyLabels,
- LeafNodeType: report.LeafNodeType,
- LeafNodeLocation: report.LeafNodeLocation,
- LeafNodeLabels: report.LeafNodeLabels,
- LeafNodeText: report.LeafNodeText,
- State: report.State,
- StartTime: report.StartTime,
- EndTime: report.EndTime,
- RunTime: report.RunTime,
- ParallelProcess: report.ParallelProcess,
- Failure: nil,
- ReportEntries: nil,
- NumAttempts: report.NumAttempts,
- MaxFlakeAttempts: report.MaxFlakeAttempts,
- MaxMustPassRepeatedly: report.MaxMustPassRepeatedly,
- CapturedGinkgoWriterOutput: report.CapturedGinkgoWriterOutput,
- CapturedStdOutErr: report.CapturedStdOutErr,
+ ContainerHierarchyTexts: report.ContainerHierarchyTexts,
+ ContainerHierarchyLocations: report.ContainerHierarchyLocations,
+ ContainerHierarchyLabels: report.ContainerHierarchyLabels,
+ ContainerHierarchySemVerConstraints: report.ContainerHierarchySemVerConstraints,
+ LeafNodeType: report.LeafNodeType,
+ LeafNodeLocation: report.LeafNodeLocation,
+ LeafNodeLabels: report.LeafNodeLabels,
+ LeafNodeSemVerConstraints: report.LeafNodeSemVerConstraints,
+ LeafNodeText: report.LeafNodeText,
+ State: report.State,
+ StartTime: report.StartTime,
+ EndTime: report.EndTime,
+ RunTime: report.RunTime,
+ ParallelProcess: report.ParallelProcess,
+ Failure: nil,
+ ReportEntries: nil,
+ NumAttempts: report.NumAttempts,
+ MaxFlakeAttempts: report.MaxFlakeAttempts,
+ MaxMustPassRepeatedly: report.MaxMustPassRepeatedly,
+ CapturedGinkgoWriterOutput: report.CapturedGinkgoWriterOutput,
+ CapturedStdOutErr: report.CapturedStdOutErr,
}
if !report.Failure.IsZero() {
@@ -287,6 +300,9 @@ func (report SpecReport) FullText() string {
if report.LeafNodeText != "" {
texts = append(texts, report.LeafNodeText)
}
+ texts = slices.DeleteFunc(texts, func(t string) bool {
+ return t == ""
+ })
return strings.Join(texts, " ")
}
@@ -312,6 +328,28 @@ func (report SpecReport) Labels() []string {
return out
}
+// SemVerConstraints returns a deduped set of all the spec's SemVerConstraints.
+func (report SpecReport) SemVerConstraints() []string {
+ out := []string{}
+ seen := map[string]bool{}
+ for _, semVerConstraints := range report.ContainerHierarchySemVerConstraints {
+ for _, semVerConstraint := range semVerConstraints {
+ if !seen[semVerConstraint] {
+ seen[semVerConstraint] = true
+ out = append(out, semVerConstraint)
+ }
+ }
+ }
+ for _, semVerConstraint := range report.LeafNodeSemVerConstraints {
+ if !seen[semVerConstraint] {
+ seen[semVerConstraint] = true
+ out = append(out, semVerConstraint)
+ }
+ }
+
+ return out
+}
+
// MatchesLabelFilter returns true if the spec satisfies the passed in label filter query
func (report SpecReport) MatchesLabelFilter(query string) (bool, error) {
filter, err := ParseLabelFilter(query)
@@ -321,6 +359,15 @@ func (report SpecReport) MatchesLabelFilter(query string) (bool, error) {
return filter(report.Labels()), nil
}
+// MatchesSemVerFilter returns true if the spec satisfies the passed in label filter query
+func (report SpecReport) MatchesSemVerFilter(version string) (bool, error) {
+ filter, err := ParseSemVerFilter(version)
+ if err != nil {
+ return false, err
+ }
+ return filter(report.SemVerConstraints()), nil
+}
+
// FileName() returns the name of the file containing the spec
func (report SpecReport) FileName() string {
return report.LeafNodeLocation.FileName
diff --git a/vendor/github.com/onsi/ginkgo/v2/types/version.go b/vendor/github.com/onsi/ginkgo/v2/types/version.go
index 158ac2fd..a30e68be 100644
--- a/vendor/github.com/onsi/ginkgo/v2/types/version.go
+++ b/vendor/github.com/onsi/ginkgo/v2/types/version.go
@@ -1,3 +1,3 @@
package types
-const VERSION = "2.23.4"
+const VERSION = "2.26.0"
diff --git a/vendor/github.com/onsi/gomega/CHANGELOG.md b/vendor/github.com/onsi/gomega/CHANGELOG.md
index de9c957c..b7d7309f 100644
--- a/vendor/github.com/onsi/gomega/CHANGELOG.md
+++ b/vendor/github.com/onsi/gomega/CHANGELOG.md
@@ -1,3 +1,13 @@
+## 1.38.2
+
+- roll back to go 1.23.0 [c404969]
+
+## 1.38.1
+
+### Fixes
+
+Numerous minor fixes and dependency bumps
+
## 1.38.0
### Features
diff --git a/vendor/github.com/onsi/gomega/gomega_dsl.go b/vendor/github.com/onsi/gomega/gomega_dsl.go
index 1f03e1f2..fdba34ee 100644
--- a/vendor/github.com/onsi/gomega/gomega_dsl.go
+++ b/vendor/github.com/onsi/gomega/gomega_dsl.go
@@ -22,7 +22,7 @@ import (
"github.com/onsi/gomega/types"
)
-const GOMEGA_VERSION = "1.38.0"
+const GOMEGA_VERSION = "1.38.2"
const nilGomegaPanic = `You are trying to make an assertion, but haven't registered Gomega's fail handler.
If you're using Ginkgo then you probably forgot to put your assertion in an It().
diff --git a/vendor/github.com/onsi/gomega/internal/async_assertion.go b/vendor/github.com/onsi/gomega/internal/async_assertion.go
index a3a646e4..4121505b 100644
--- a/vendor/github.com/onsi/gomega/internal/async_assertion.go
+++ b/vendor/github.com/onsi/gomega/internal/async_assertion.go
@@ -452,7 +452,7 @@ func (assertion *AsyncAssertion) match(matcher types.GomegaMatcher, desiredMatch
}
} else {
var fgErr formattedGomegaError
- if errors.As(actualErr, &fgErr) {
+ if errors.As(matcherErr, &fgErr) {
message += fgErr.FormattedGomegaError() + "\n"
} else {
message += renderError(fmt.Sprintf("The matcher passed to %s returned the following error:", assertion.asyncType), matcherErr)
diff --git a/vendor/github.com/onsi/gomega/matchers/be_comparable_to_matcher.go b/vendor/github.com/onsi/gomega/matchers/be_comparable_to_matcher.go
index 532fc374..ce74eee4 100644
--- a/vendor/github.com/onsi/gomega/matchers/be_comparable_to_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/be_comparable_to_matcher.go
@@ -2,6 +2,7 @@ package matchers
import (
"bytes"
+ "errors"
"fmt"
"github.com/google/go-cmp/cmp"
@@ -32,7 +33,7 @@ func (matcher *BeComparableToMatcher) Match(actual any) (success bool, matchErr
if err, ok := r.(error); ok {
matchErr = err
} else if errMsg, ok := r.(string); ok {
- matchErr = fmt.Errorf(errMsg)
+ matchErr = errors.New(errMsg)
}
}
}()
diff --git a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
index 95057c26..c3da9bd4 100644
--- a/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
+++ b/vendor/github.com/onsi/gomega/matchers/match_yaml_matcher.go
@@ -5,7 +5,7 @@ import (
"strings"
"github.com/onsi/gomega/format"
- "gopkg.in/yaml.v3"
+ "go.yaml.in/yaml/v3"
)
type MatchYAMLMatcher struct {
diff --git a/vendor/go.yaml.in/yaml/v3/LICENSE b/vendor/go.yaml.in/yaml/v3/LICENSE
new file mode 100644
index 00000000..2683e4bb
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/LICENSE
@@ -0,0 +1,50 @@
+
+This project is covered by two different licenses: MIT and Apache.
+
+#### MIT License ####
+
+The following files were ported to Go from C files of libyaml, and thus
+are still covered by their original MIT license, with the additional
+copyright staring in 2011 when the project was ported over:
+
+ apic.go emitterc.go parserc.go readerc.go scannerc.go
+ writerc.go yamlh.go yamlprivateh.go
+
+Copyright (c) 2006-2010 Kirill Simonov
+Copyright (c) 2006-2011 Kirill Simonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+### Apache License ###
+
+All the remaining project files are covered by the Apache license:
+
+Copyright (c) 2011-2019 Canonical Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/vendor/go.yaml.in/yaml/v3/NOTICE b/vendor/go.yaml.in/yaml/v3/NOTICE
new file mode 100644
index 00000000..866d74a7
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/NOTICE
@@ -0,0 +1,13 @@
+Copyright 2011-2016 Canonical Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/vendor/go.yaml.in/yaml/v3/README.md b/vendor/go.yaml.in/yaml/v3/README.md
new file mode 100644
index 00000000..15a85a63
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/README.md
@@ -0,0 +1,171 @@
+go.yaml.in/yaml
+===============
+
+YAML Support for the Go Language
+
+
+## Introduction
+
+The `yaml` package enables [Go](https://go.dev/) programs to comfortably encode
+and decode [YAML](https://yaml.org/) values.
+
+It was originally developed within [Canonical](https://www.canonical.com) as
+part of the [juju](https://juju.ubuntu.com) project, and is based on a pure Go
+port of the well-known [libyaml](http://pyyaml.org/wiki/LibYAML) C library to
+parse and generate YAML data quickly and reliably.
+
+
+## Project Status
+
+This project started as a fork of the extremely popular [go-yaml](
+https://github.com/go-yaml/yaml/)
+project, and is being maintained by the official [YAML organization](
+https://github.com/yaml/).
+
+The YAML team took over ongoing maintenance and development of the project after
+discussion with go-yaml's author, @niemeyer, following his decision to
+[label the project repository as "unmaintained"](
+https://github.com/go-yaml/yaml/blob/944c86a7d2/README.md) in April 2025.
+
+We have put together a team of dedicated maintainers including representatives
+of go-yaml's most important downstream projects.
+
+We will strive to earn the trust of the various go-yaml forks to switch back to
+this repository as their upstream.
+
+Please [contact us](https://cloud-native.slack.com/archives/C08PPAT8PS7) if you
+would like to contribute or be involved.
+
+
+## Compatibility
+
+The `yaml` package supports most of YAML 1.2, but preserves some behavior from
+1.1 for backwards compatibility.
+
+Specifically, v3 of the `yaml` package:
+
+* Supports YAML 1.1 bools (`yes`/`no`, `on`/`off`) as long as they are being
+ decoded into a typed bool value.
+ Otherwise they behave as a string.
+ Booleans in YAML 1.2 are `true`/`false` only.
+* Supports octals encoded and decoded as `0777` per YAML 1.1, rather than
+ `0o777` as specified in YAML 1.2, because most parsers still use the old
+ format.
+ Octals in the `0o777` format are supported though, so new files work.
+* Does not support base-60 floats.
+ These are gone from YAML 1.2, and were actually never supported by this
+ package as it's clearly a poor choice.
+
+
+## Installation and Usage
+
+The import path for the package is *go.yaml.in/yaml/v3*.
+
+To install it, run:
+
+```bash
+go get go.yaml.in/yaml/v3
+```
+
+
+## API Documentation
+
+See:
+
+
+## API Stability
+
+The package API for yaml v3 will remain stable as described in [gopkg.in](
+https://gopkg.in).
+
+
+## Example
+
+```go
+package main
+
+import (
+ "fmt"
+ "log"
+
+ "go.yaml.in/yaml/v3"
+)
+
+var data = `
+a: Easy!
+b:
+ c: 2
+ d: [3, 4]
+`
+
+// Note: struct fields must be public in order for unmarshal to
+// correctly populate the data.
+type T struct {
+ A string
+ B struct {
+ RenamedC int `yaml:"c"`
+ D []int `yaml:",flow"`
+ }
+}
+
+func main() {
+ t := T{}
+
+ err := yaml.Unmarshal([]byte(data), &t)
+ if err != nil {
+ log.Fatalf("error: %v", err)
+ }
+ fmt.Printf("--- t:\n%v\n\n", t)
+
+ d, err := yaml.Marshal(&t)
+ if err != nil {
+ log.Fatalf("error: %v", err)
+ }
+ fmt.Printf("--- t dump:\n%s\n\n", string(d))
+
+ m := make(map[interface{}]interface{})
+
+ err = yaml.Unmarshal([]byte(data), &m)
+ if err != nil {
+ log.Fatalf("error: %v", err)
+ }
+ fmt.Printf("--- m:\n%v\n\n", m)
+
+ d, err = yaml.Marshal(&m)
+ if err != nil {
+ log.Fatalf("error: %v", err)
+ }
+ fmt.Printf("--- m dump:\n%s\n\n", string(d))
+}
+```
+
+This example will generate the following output:
+
+```
+--- t:
+{Easy! {2 [3 4]}}
+
+--- t dump:
+a: Easy!
+b:
+ c: 2
+ d: [3, 4]
+
+
+--- m:
+map[a:Easy! b:map[c:2 d:[3 4]]]
+
+--- m dump:
+a: Easy!
+b:
+ c: 2
+ d:
+ - 3
+ - 4
+```
+
+
+## License
+
+The yaml package is licensed under the MIT and Apache License 2.0 licenses.
+Please see the LICENSE file for details.
diff --git a/vendor/go.yaml.in/yaml/v3/apic.go b/vendor/go.yaml.in/yaml/v3/apic.go
new file mode 100644
index 00000000..05fd305d
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/apic.go
@@ -0,0 +1,747 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+// Copyright (c) 2006-2010 Kirill Simonov
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+// of the Software, and to permit persons to whom the Software is furnished to do
+// so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package yaml
+
+import (
+ "io"
+)
+
+func yaml_insert_token(parser *yaml_parser_t, pos int, token *yaml_token_t) {
+ //fmt.Println("yaml_insert_token", "pos:", pos, "typ:", token.typ, "head:", parser.tokens_head, "len:", len(parser.tokens))
+
+ // Check if we can move the queue at the beginning of the buffer.
+ if parser.tokens_head > 0 && len(parser.tokens) == cap(parser.tokens) {
+ if parser.tokens_head != len(parser.tokens) {
+ copy(parser.tokens, parser.tokens[parser.tokens_head:])
+ }
+ parser.tokens = parser.tokens[:len(parser.tokens)-parser.tokens_head]
+ parser.tokens_head = 0
+ }
+ parser.tokens = append(parser.tokens, *token)
+ if pos < 0 {
+ return
+ }
+ copy(parser.tokens[parser.tokens_head+pos+1:], parser.tokens[parser.tokens_head+pos:])
+ parser.tokens[parser.tokens_head+pos] = *token
+}
+
+// Create a new parser object.
+func yaml_parser_initialize(parser *yaml_parser_t) bool {
+ *parser = yaml_parser_t{
+ raw_buffer: make([]byte, 0, input_raw_buffer_size),
+ buffer: make([]byte, 0, input_buffer_size),
+ }
+ return true
+}
+
+// Destroy a parser object.
+func yaml_parser_delete(parser *yaml_parser_t) {
+ *parser = yaml_parser_t{}
+}
+
+// String read handler.
+func yaml_string_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
+ if parser.input_pos == len(parser.input) {
+ return 0, io.EOF
+ }
+ n = copy(buffer, parser.input[parser.input_pos:])
+ parser.input_pos += n
+ return n, nil
+}
+
+// Reader read handler.
+func yaml_reader_read_handler(parser *yaml_parser_t, buffer []byte) (n int, err error) {
+ return parser.input_reader.Read(buffer)
+}
+
+// Set a string input.
+func yaml_parser_set_input_string(parser *yaml_parser_t, input []byte) {
+ if parser.read_handler != nil {
+ panic("must set the input source only once")
+ }
+ parser.read_handler = yaml_string_read_handler
+ parser.input = input
+ parser.input_pos = 0
+}
+
+// Set a file input.
+func yaml_parser_set_input_reader(parser *yaml_parser_t, r io.Reader) {
+ if parser.read_handler != nil {
+ panic("must set the input source only once")
+ }
+ parser.read_handler = yaml_reader_read_handler
+ parser.input_reader = r
+}
+
+// Set the source encoding.
+func yaml_parser_set_encoding(parser *yaml_parser_t, encoding yaml_encoding_t) {
+ if parser.encoding != yaml_ANY_ENCODING {
+ panic("must set the encoding only once")
+ }
+ parser.encoding = encoding
+}
+
+// Create a new emitter object.
+func yaml_emitter_initialize(emitter *yaml_emitter_t) {
+ *emitter = yaml_emitter_t{
+ buffer: make([]byte, output_buffer_size),
+ raw_buffer: make([]byte, 0, output_raw_buffer_size),
+ states: make([]yaml_emitter_state_t, 0, initial_stack_size),
+ events: make([]yaml_event_t, 0, initial_queue_size),
+ best_width: -1,
+ }
+}
+
+// Destroy an emitter object.
+func yaml_emitter_delete(emitter *yaml_emitter_t) {
+ *emitter = yaml_emitter_t{}
+}
+
+// String write handler.
+func yaml_string_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
+ *emitter.output_buffer = append(*emitter.output_buffer, buffer...)
+ return nil
+}
+
+// yaml_writer_write_handler uses emitter.output_writer to write the
+// emitted text.
+func yaml_writer_write_handler(emitter *yaml_emitter_t, buffer []byte) error {
+ _, err := emitter.output_writer.Write(buffer)
+ return err
+}
+
+// Set a string output.
+func yaml_emitter_set_output_string(emitter *yaml_emitter_t, output_buffer *[]byte) {
+ if emitter.write_handler != nil {
+ panic("must set the output target only once")
+ }
+ emitter.write_handler = yaml_string_write_handler
+ emitter.output_buffer = output_buffer
+}
+
+// Set a file output.
+func yaml_emitter_set_output_writer(emitter *yaml_emitter_t, w io.Writer) {
+ if emitter.write_handler != nil {
+ panic("must set the output target only once")
+ }
+ emitter.write_handler = yaml_writer_write_handler
+ emitter.output_writer = w
+}
+
+// Set the output encoding.
+func yaml_emitter_set_encoding(emitter *yaml_emitter_t, encoding yaml_encoding_t) {
+ if emitter.encoding != yaml_ANY_ENCODING {
+ panic("must set the output encoding only once")
+ }
+ emitter.encoding = encoding
+}
+
+// Set the canonical output style.
+func yaml_emitter_set_canonical(emitter *yaml_emitter_t, canonical bool) {
+ emitter.canonical = canonical
+}
+
+// Set the indentation increment.
+func yaml_emitter_set_indent(emitter *yaml_emitter_t, indent int) {
+ if indent < 2 || indent > 9 {
+ indent = 2
+ }
+ emitter.best_indent = indent
+}
+
+// Set the preferred line width.
+func yaml_emitter_set_width(emitter *yaml_emitter_t, width int) {
+ if width < 0 {
+ width = -1
+ }
+ emitter.best_width = width
+}
+
+// Set if unescaped non-ASCII characters are allowed.
+func yaml_emitter_set_unicode(emitter *yaml_emitter_t, unicode bool) {
+ emitter.unicode = unicode
+}
+
+// Set the preferred line break character.
+func yaml_emitter_set_break(emitter *yaml_emitter_t, line_break yaml_break_t) {
+ emitter.line_break = line_break
+}
+
+///*
+// * Destroy a token object.
+// */
+//
+//YAML_DECLARE(void)
+//yaml_token_delete(yaml_token_t *token)
+//{
+// assert(token); // Non-NULL token object expected.
+//
+// switch (token.type)
+// {
+// case YAML_TAG_DIRECTIVE_TOKEN:
+// yaml_free(token.data.tag_directive.handle);
+// yaml_free(token.data.tag_directive.prefix);
+// break;
+//
+// case YAML_ALIAS_TOKEN:
+// yaml_free(token.data.alias.value);
+// break;
+//
+// case YAML_ANCHOR_TOKEN:
+// yaml_free(token.data.anchor.value);
+// break;
+//
+// case YAML_TAG_TOKEN:
+// yaml_free(token.data.tag.handle);
+// yaml_free(token.data.tag.suffix);
+// break;
+//
+// case YAML_SCALAR_TOKEN:
+// yaml_free(token.data.scalar.value);
+// break;
+//
+// default:
+// break;
+// }
+//
+// memset(token, 0, sizeof(yaml_token_t));
+//}
+//
+///*
+// * Check if a string is a valid UTF-8 sequence.
+// *
+// * Check 'reader.c' for more details on UTF-8 encoding.
+// */
+//
+//static int
+//yaml_check_utf8(yaml_char_t *start, size_t length)
+//{
+// yaml_char_t *end = start+length;
+// yaml_char_t *pointer = start;
+//
+// while (pointer < end) {
+// unsigned char octet;
+// unsigned int width;
+// unsigned int value;
+// size_t k;
+//
+// octet = pointer[0];
+// width = (octet & 0x80) == 0x00 ? 1 :
+// (octet & 0xE0) == 0xC0 ? 2 :
+// (octet & 0xF0) == 0xE0 ? 3 :
+// (octet & 0xF8) == 0xF0 ? 4 : 0;
+// value = (octet & 0x80) == 0x00 ? octet & 0x7F :
+// (octet & 0xE0) == 0xC0 ? octet & 0x1F :
+// (octet & 0xF0) == 0xE0 ? octet & 0x0F :
+// (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
+// if (!width) return 0;
+// if (pointer+width > end) return 0;
+// for (k = 1; k < width; k ++) {
+// octet = pointer[k];
+// if ((octet & 0xC0) != 0x80) return 0;
+// value = (value << 6) + (octet & 0x3F);
+// }
+// if (!((width == 1) ||
+// (width == 2 && value >= 0x80) ||
+// (width == 3 && value >= 0x800) ||
+// (width == 4 && value >= 0x10000))) return 0;
+//
+// pointer += width;
+// }
+//
+// return 1;
+//}
+//
+
+// Create STREAM-START.
+func yaml_stream_start_event_initialize(event *yaml_event_t, encoding yaml_encoding_t) {
+ *event = yaml_event_t{
+ typ: yaml_STREAM_START_EVENT,
+ encoding: encoding,
+ }
+}
+
+// Create STREAM-END.
+func yaml_stream_end_event_initialize(event *yaml_event_t) {
+ *event = yaml_event_t{
+ typ: yaml_STREAM_END_EVENT,
+ }
+}
+
+// Create DOCUMENT-START.
+func yaml_document_start_event_initialize(
+ event *yaml_event_t,
+ version_directive *yaml_version_directive_t,
+ tag_directives []yaml_tag_directive_t,
+ implicit bool,
+) {
+ *event = yaml_event_t{
+ typ: yaml_DOCUMENT_START_EVENT,
+ version_directive: version_directive,
+ tag_directives: tag_directives,
+ implicit: implicit,
+ }
+}
+
+// Create DOCUMENT-END.
+func yaml_document_end_event_initialize(event *yaml_event_t, implicit bool) {
+ *event = yaml_event_t{
+ typ: yaml_DOCUMENT_END_EVENT,
+ implicit: implicit,
+ }
+}
+
+// Create ALIAS.
+func yaml_alias_event_initialize(event *yaml_event_t, anchor []byte) bool {
+ *event = yaml_event_t{
+ typ: yaml_ALIAS_EVENT,
+ anchor: anchor,
+ }
+ return true
+}
+
+// Create SCALAR.
+func yaml_scalar_event_initialize(event *yaml_event_t, anchor, tag, value []byte, plain_implicit, quoted_implicit bool, style yaml_scalar_style_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_SCALAR_EVENT,
+ anchor: anchor,
+ tag: tag,
+ value: value,
+ implicit: plain_implicit,
+ quoted_implicit: quoted_implicit,
+ style: yaml_style_t(style),
+ }
+ return true
+}
+
+// Create SEQUENCE-START.
+func yaml_sequence_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_sequence_style_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_START_EVENT,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(style),
+ }
+ return true
+}
+
+// Create SEQUENCE-END.
+func yaml_sequence_end_event_initialize(event *yaml_event_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_END_EVENT,
+ }
+ return true
+}
+
+// Create MAPPING-START.
+func yaml_mapping_start_event_initialize(event *yaml_event_t, anchor, tag []byte, implicit bool, style yaml_mapping_style_t) {
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_START_EVENT,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(style),
+ }
+}
+
+// Create MAPPING-END.
+func yaml_mapping_end_event_initialize(event *yaml_event_t) {
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_END_EVENT,
+ }
+}
+
+// Destroy an event object.
+func yaml_event_delete(event *yaml_event_t) {
+ *event = yaml_event_t{}
+}
+
+///*
+// * Create a document object.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_initialize(document *yaml_document_t,
+// version_directive *yaml_version_directive_t,
+// tag_directives_start *yaml_tag_directive_t,
+// tag_directives_end *yaml_tag_directive_t,
+// start_implicit int, end_implicit int)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// struct {
+// start *yaml_node_t
+// end *yaml_node_t
+// top *yaml_node_t
+// } nodes = { NULL, NULL, NULL }
+// version_directive_copy *yaml_version_directive_t = NULL
+// struct {
+// start *yaml_tag_directive_t
+// end *yaml_tag_directive_t
+// top *yaml_tag_directive_t
+// } tag_directives_copy = { NULL, NULL, NULL }
+// value yaml_tag_directive_t = { NULL, NULL }
+// mark yaml_mark_t = { 0, 0, 0 }
+//
+// assert(document) // Non-NULL document object is expected.
+// assert((tag_directives_start && tag_directives_end) ||
+// (tag_directives_start == tag_directives_end))
+// // Valid tag directives are expected.
+//
+// if (!STACK_INIT(&context, nodes, INITIAL_STACK_SIZE)) goto error
+//
+// if (version_directive) {
+// version_directive_copy = yaml_malloc(sizeof(yaml_version_directive_t))
+// if (!version_directive_copy) goto error
+// version_directive_copy.major = version_directive.major
+// version_directive_copy.minor = version_directive.minor
+// }
+//
+// if (tag_directives_start != tag_directives_end) {
+// tag_directive *yaml_tag_directive_t
+// if (!STACK_INIT(&context, tag_directives_copy, INITIAL_STACK_SIZE))
+// goto error
+// for (tag_directive = tag_directives_start
+// tag_directive != tag_directives_end; tag_directive ++) {
+// assert(tag_directive.handle)
+// assert(tag_directive.prefix)
+// if (!yaml_check_utf8(tag_directive.handle,
+// strlen((char *)tag_directive.handle)))
+// goto error
+// if (!yaml_check_utf8(tag_directive.prefix,
+// strlen((char *)tag_directive.prefix)))
+// goto error
+// value.handle = yaml_strdup(tag_directive.handle)
+// value.prefix = yaml_strdup(tag_directive.prefix)
+// if (!value.handle || !value.prefix) goto error
+// if (!PUSH(&context, tag_directives_copy, value))
+// goto error
+// value.handle = NULL
+// value.prefix = NULL
+// }
+// }
+//
+// DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
+// tag_directives_copy.start, tag_directives_copy.top,
+// start_implicit, end_implicit, mark, mark)
+//
+// return 1
+//
+//error:
+// STACK_DEL(&context, nodes)
+// yaml_free(version_directive_copy)
+// while (!STACK_EMPTY(&context, tag_directives_copy)) {
+// value yaml_tag_directive_t = POP(&context, tag_directives_copy)
+// yaml_free(value.handle)
+// yaml_free(value.prefix)
+// }
+// STACK_DEL(&context, tag_directives_copy)
+// yaml_free(value.handle)
+// yaml_free(value.prefix)
+//
+// return 0
+//}
+//
+///*
+// * Destroy a document object.
+// */
+//
+//YAML_DECLARE(void)
+//yaml_document_delete(document *yaml_document_t)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// tag_directive *yaml_tag_directive_t
+//
+// context.error = YAML_NO_ERROR // Eliminate a compiler warning.
+//
+// assert(document) // Non-NULL document object is expected.
+//
+// while (!STACK_EMPTY(&context, document.nodes)) {
+// node yaml_node_t = POP(&context, document.nodes)
+// yaml_free(node.tag)
+// switch (node.type) {
+// case YAML_SCALAR_NODE:
+// yaml_free(node.data.scalar.value)
+// break
+// case YAML_SEQUENCE_NODE:
+// STACK_DEL(&context, node.data.sequence.items)
+// break
+// case YAML_MAPPING_NODE:
+// STACK_DEL(&context, node.data.mapping.pairs)
+// break
+// default:
+// assert(0) // Should not happen.
+// }
+// }
+// STACK_DEL(&context, document.nodes)
+//
+// yaml_free(document.version_directive)
+// for (tag_directive = document.tag_directives.start
+// tag_directive != document.tag_directives.end
+// tag_directive++) {
+// yaml_free(tag_directive.handle)
+// yaml_free(tag_directive.prefix)
+// }
+// yaml_free(document.tag_directives.start)
+//
+// memset(document, 0, sizeof(yaml_document_t))
+//}
+//
+///**
+// * Get a document node.
+// */
+//
+//YAML_DECLARE(yaml_node_t *)
+//yaml_document_get_node(document *yaml_document_t, index int)
+//{
+// assert(document) // Non-NULL document object is expected.
+//
+// if (index > 0 && document.nodes.start + index <= document.nodes.top) {
+// return document.nodes.start + index - 1
+// }
+// return NULL
+//}
+//
+///**
+// * Get the root object.
+// */
+//
+//YAML_DECLARE(yaml_node_t *)
+//yaml_document_get_root_node(document *yaml_document_t)
+//{
+// assert(document) // Non-NULL document object is expected.
+//
+// if (document.nodes.top != document.nodes.start) {
+// return document.nodes.start
+// }
+// return NULL
+//}
+//
+///*
+// * Add a scalar node to a document.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_add_scalar(document *yaml_document_t,
+// tag *yaml_char_t, value *yaml_char_t, length int,
+// style yaml_scalar_style_t)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// mark yaml_mark_t = { 0, 0, 0 }
+// tag_copy *yaml_char_t = NULL
+// value_copy *yaml_char_t = NULL
+// node yaml_node_t
+//
+// assert(document) // Non-NULL document object is expected.
+// assert(value) // Non-NULL value is expected.
+//
+// if (!tag) {
+// tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG
+// }
+//
+// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
+// tag_copy = yaml_strdup(tag)
+// if (!tag_copy) goto error
+//
+// if (length < 0) {
+// length = strlen((char *)value)
+// }
+//
+// if (!yaml_check_utf8(value, length)) goto error
+// value_copy = yaml_malloc(length+1)
+// if (!value_copy) goto error
+// memcpy(value_copy, value, length)
+// value_copy[length] = '\0'
+//
+// SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark)
+// if (!PUSH(&context, document.nodes, node)) goto error
+//
+// return document.nodes.top - document.nodes.start
+//
+//error:
+// yaml_free(tag_copy)
+// yaml_free(value_copy)
+//
+// return 0
+//}
+//
+///*
+// * Add a sequence node to a document.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_add_sequence(document *yaml_document_t,
+// tag *yaml_char_t, style yaml_sequence_style_t)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// mark yaml_mark_t = { 0, 0, 0 }
+// tag_copy *yaml_char_t = NULL
+// struct {
+// start *yaml_node_item_t
+// end *yaml_node_item_t
+// top *yaml_node_item_t
+// } items = { NULL, NULL, NULL }
+// node yaml_node_t
+//
+// assert(document) // Non-NULL document object is expected.
+//
+// if (!tag) {
+// tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG
+// }
+//
+// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
+// tag_copy = yaml_strdup(tag)
+// if (!tag_copy) goto error
+//
+// if (!STACK_INIT(&context, items, INITIAL_STACK_SIZE)) goto error
+//
+// SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
+// style, mark, mark)
+// if (!PUSH(&context, document.nodes, node)) goto error
+//
+// return document.nodes.top - document.nodes.start
+//
+//error:
+// STACK_DEL(&context, items)
+// yaml_free(tag_copy)
+//
+// return 0
+//}
+//
+///*
+// * Add a mapping node to a document.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_add_mapping(document *yaml_document_t,
+// tag *yaml_char_t, style yaml_mapping_style_t)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+// mark yaml_mark_t = { 0, 0, 0 }
+// tag_copy *yaml_char_t = NULL
+// struct {
+// start *yaml_node_pair_t
+// end *yaml_node_pair_t
+// top *yaml_node_pair_t
+// } pairs = { NULL, NULL, NULL }
+// node yaml_node_t
+//
+// assert(document) // Non-NULL document object is expected.
+//
+// if (!tag) {
+// tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG
+// }
+//
+// if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error
+// tag_copy = yaml_strdup(tag)
+// if (!tag_copy) goto error
+//
+// if (!STACK_INIT(&context, pairs, INITIAL_STACK_SIZE)) goto error
+//
+// MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
+// style, mark, mark)
+// if (!PUSH(&context, document.nodes, node)) goto error
+//
+// return document.nodes.top - document.nodes.start
+//
+//error:
+// STACK_DEL(&context, pairs)
+// yaml_free(tag_copy)
+//
+// return 0
+//}
+//
+///*
+// * Append an item to a sequence node.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_append_sequence_item(document *yaml_document_t,
+// sequence int, item int)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+//
+// assert(document) // Non-NULL document is required.
+// assert(sequence > 0
+// && document.nodes.start + sequence <= document.nodes.top)
+// // Valid sequence id is required.
+// assert(document.nodes.start[sequence-1].type == YAML_SEQUENCE_NODE)
+// // A sequence node is required.
+// assert(item > 0 && document.nodes.start + item <= document.nodes.top)
+// // Valid item id is required.
+//
+// if (!PUSH(&context,
+// document.nodes.start[sequence-1].data.sequence.items, item))
+// return 0
+//
+// return 1
+//}
+//
+///*
+// * Append a pair of a key and a value to a mapping node.
+// */
+//
+//YAML_DECLARE(int)
+//yaml_document_append_mapping_pair(document *yaml_document_t,
+// mapping int, key int, value int)
+//{
+// struct {
+// error yaml_error_type_t
+// } context
+//
+// pair yaml_node_pair_t
+//
+// assert(document) // Non-NULL document is required.
+// assert(mapping > 0
+// && document.nodes.start + mapping <= document.nodes.top)
+// // Valid mapping id is required.
+// assert(document.nodes.start[mapping-1].type == YAML_MAPPING_NODE)
+// // A mapping node is required.
+// assert(key > 0 && document.nodes.start + key <= document.nodes.top)
+// // Valid key id is required.
+// assert(value > 0 && document.nodes.start + value <= document.nodes.top)
+// // Valid value id is required.
+//
+// pair.key = key
+// pair.value = value
+//
+// if (!PUSH(&context,
+// document.nodes.start[mapping-1].data.mapping.pairs, pair))
+// return 0
+//
+// return 1
+//}
+//
+//
diff --git a/vendor/go.yaml.in/yaml/v3/decode.go b/vendor/go.yaml.in/yaml/v3/decode.go
new file mode 100644
index 00000000..02e2b17b
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/decode.go
@@ -0,0 +1,1018 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package yaml
+
+import (
+ "encoding"
+ "encoding/base64"
+ "fmt"
+ "io"
+ "math"
+ "reflect"
+ "strconv"
+ "time"
+)
+
+// ----------------------------------------------------------------------------
+// Parser, produces a node tree out of a libyaml event stream.
+
+type parser struct {
+ parser yaml_parser_t
+ event yaml_event_t
+ doc *Node
+ anchors map[string]*Node
+ doneInit bool
+ textless bool
+}
+
+func newParser(b []byte) *parser {
+ p := parser{}
+ if !yaml_parser_initialize(&p.parser) {
+ panic("failed to initialize YAML emitter")
+ }
+ if len(b) == 0 {
+ b = []byte{'\n'}
+ }
+ yaml_parser_set_input_string(&p.parser, b)
+ return &p
+}
+
+func newParserFromReader(r io.Reader) *parser {
+ p := parser{}
+ if !yaml_parser_initialize(&p.parser) {
+ panic("failed to initialize YAML emitter")
+ }
+ yaml_parser_set_input_reader(&p.parser, r)
+ return &p
+}
+
+func (p *parser) init() {
+ if p.doneInit {
+ return
+ }
+ p.anchors = make(map[string]*Node)
+ p.expect(yaml_STREAM_START_EVENT)
+ p.doneInit = true
+}
+
+func (p *parser) destroy() {
+ if p.event.typ != yaml_NO_EVENT {
+ yaml_event_delete(&p.event)
+ }
+ yaml_parser_delete(&p.parser)
+}
+
+// expect consumes an event from the event stream and
+// checks that it's of the expected type.
+func (p *parser) expect(e yaml_event_type_t) {
+ if p.event.typ == yaml_NO_EVENT {
+ if !yaml_parser_parse(&p.parser, &p.event) {
+ p.fail()
+ }
+ }
+ if p.event.typ == yaml_STREAM_END_EVENT {
+ failf("attempted to go past the end of stream; corrupted value?")
+ }
+ if p.event.typ != e {
+ p.parser.problem = fmt.Sprintf("expected %s event but got %s", e, p.event.typ)
+ p.fail()
+ }
+ yaml_event_delete(&p.event)
+ p.event.typ = yaml_NO_EVENT
+}
+
+// peek peeks at the next event in the event stream,
+// puts the results into p.event and returns the event type.
+func (p *parser) peek() yaml_event_type_t {
+ if p.event.typ != yaml_NO_EVENT {
+ return p.event.typ
+ }
+ // It's curious choice from the underlying API to generally return a
+ // positive result on success, but on this case return true in an error
+ // scenario. This was the source of bugs in the past (issue #666).
+ if !yaml_parser_parse(&p.parser, &p.event) || p.parser.error != yaml_NO_ERROR {
+ p.fail()
+ }
+ return p.event.typ
+}
+
+func (p *parser) fail() {
+ var where string
+ var line int
+ if p.parser.context_mark.line != 0 {
+ line = p.parser.context_mark.line
+ // Scanner errors don't iterate line before returning error
+ if p.parser.error == yaml_SCANNER_ERROR {
+ line++
+ }
+ } else if p.parser.problem_mark.line != 0 {
+ line = p.parser.problem_mark.line
+ // Scanner errors don't iterate line before returning error
+ if p.parser.error == yaml_SCANNER_ERROR {
+ line++
+ }
+ }
+ if line != 0 {
+ where = "line " + strconv.Itoa(line) + ": "
+ }
+ var msg string
+ if len(p.parser.problem) > 0 {
+ msg = p.parser.problem
+ } else {
+ msg = "unknown problem parsing YAML content"
+ }
+ failf("%s%s", where, msg)
+}
+
+func (p *parser) anchor(n *Node, anchor []byte) {
+ if anchor != nil {
+ n.Anchor = string(anchor)
+ p.anchors[n.Anchor] = n
+ }
+}
+
+func (p *parser) parse() *Node {
+ p.init()
+ switch p.peek() {
+ case yaml_SCALAR_EVENT:
+ return p.scalar()
+ case yaml_ALIAS_EVENT:
+ return p.alias()
+ case yaml_MAPPING_START_EVENT:
+ return p.mapping()
+ case yaml_SEQUENCE_START_EVENT:
+ return p.sequence()
+ case yaml_DOCUMENT_START_EVENT:
+ return p.document()
+ case yaml_STREAM_END_EVENT:
+ // Happens when attempting to decode an empty buffer.
+ return nil
+ case yaml_TAIL_COMMENT_EVENT:
+ panic("internal error: unexpected tail comment event (please report)")
+ default:
+ panic("internal error: attempted to parse unknown event (please report): " + p.event.typ.String())
+ }
+}
+
+func (p *parser) node(kind Kind, defaultTag, tag, value string) *Node {
+ var style Style
+ if tag != "" && tag != "!" {
+ tag = shortTag(tag)
+ style = TaggedStyle
+ } else if defaultTag != "" {
+ tag = defaultTag
+ } else if kind == ScalarNode {
+ tag, _ = resolve("", value)
+ }
+ n := &Node{
+ Kind: kind,
+ Tag: tag,
+ Value: value,
+ Style: style,
+ }
+ if !p.textless {
+ n.Line = p.event.start_mark.line + 1
+ n.Column = p.event.start_mark.column + 1
+ n.HeadComment = string(p.event.head_comment)
+ n.LineComment = string(p.event.line_comment)
+ n.FootComment = string(p.event.foot_comment)
+ }
+ return n
+}
+
+func (p *parser) parseChild(parent *Node) *Node {
+ child := p.parse()
+ parent.Content = append(parent.Content, child)
+ return child
+}
+
+func (p *parser) document() *Node {
+ n := p.node(DocumentNode, "", "", "")
+ p.doc = n
+ p.expect(yaml_DOCUMENT_START_EVENT)
+ p.parseChild(n)
+ if p.peek() == yaml_DOCUMENT_END_EVENT {
+ n.FootComment = string(p.event.foot_comment)
+ }
+ p.expect(yaml_DOCUMENT_END_EVENT)
+ return n
+}
+
+func (p *parser) alias() *Node {
+ n := p.node(AliasNode, "", "", string(p.event.anchor))
+ n.Alias = p.anchors[n.Value]
+ if n.Alias == nil {
+ failf("unknown anchor '%s' referenced", n.Value)
+ }
+ p.expect(yaml_ALIAS_EVENT)
+ return n
+}
+
+func (p *parser) scalar() *Node {
+ var parsedStyle = p.event.scalar_style()
+ var nodeStyle Style
+ switch {
+ case parsedStyle&yaml_DOUBLE_QUOTED_SCALAR_STYLE != 0:
+ nodeStyle = DoubleQuotedStyle
+ case parsedStyle&yaml_SINGLE_QUOTED_SCALAR_STYLE != 0:
+ nodeStyle = SingleQuotedStyle
+ case parsedStyle&yaml_LITERAL_SCALAR_STYLE != 0:
+ nodeStyle = LiteralStyle
+ case parsedStyle&yaml_FOLDED_SCALAR_STYLE != 0:
+ nodeStyle = FoldedStyle
+ }
+ var nodeValue = string(p.event.value)
+ var nodeTag = string(p.event.tag)
+ var defaultTag string
+ if nodeStyle == 0 {
+ if nodeValue == "<<" {
+ defaultTag = mergeTag
+ }
+ } else {
+ defaultTag = strTag
+ }
+ n := p.node(ScalarNode, defaultTag, nodeTag, nodeValue)
+ n.Style |= nodeStyle
+ p.anchor(n, p.event.anchor)
+ p.expect(yaml_SCALAR_EVENT)
+ return n
+}
+
+func (p *parser) sequence() *Node {
+ n := p.node(SequenceNode, seqTag, string(p.event.tag), "")
+ if p.event.sequence_style()&yaml_FLOW_SEQUENCE_STYLE != 0 {
+ n.Style |= FlowStyle
+ }
+ p.anchor(n, p.event.anchor)
+ p.expect(yaml_SEQUENCE_START_EVENT)
+ for p.peek() != yaml_SEQUENCE_END_EVENT {
+ p.parseChild(n)
+ }
+ n.LineComment = string(p.event.line_comment)
+ n.FootComment = string(p.event.foot_comment)
+ p.expect(yaml_SEQUENCE_END_EVENT)
+ return n
+}
+
+func (p *parser) mapping() *Node {
+ n := p.node(MappingNode, mapTag, string(p.event.tag), "")
+ block := true
+ if p.event.mapping_style()&yaml_FLOW_MAPPING_STYLE != 0 {
+ block = false
+ n.Style |= FlowStyle
+ }
+ p.anchor(n, p.event.anchor)
+ p.expect(yaml_MAPPING_START_EVENT)
+ for p.peek() != yaml_MAPPING_END_EVENT {
+ k := p.parseChild(n)
+ if block && k.FootComment != "" {
+ // Must be a foot comment for the prior value when being dedented.
+ if len(n.Content) > 2 {
+ n.Content[len(n.Content)-3].FootComment = k.FootComment
+ k.FootComment = ""
+ }
+ }
+ v := p.parseChild(n)
+ if k.FootComment == "" && v.FootComment != "" {
+ k.FootComment = v.FootComment
+ v.FootComment = ""
+ }
+ if p.peek() == yaml_TAIL_COMMENT_EVENT {
+ if k.FootComment == "" {
+ k.FootComment = string(p.event.foot_comment)
+ }
+ p.expect(yaml_TAIL_COMMENT_EVENT)
+ }
+ }
+ n.LineComment = string(p.event.line_comment)
+ n.FootComment = string(p.event.foot_comment)
+ if n.Style&FlowStyle == 0 && n.FootComment != "" && len(n.Content) > 1 {
+ n.Content[len(n.Content)-2].FootComment = n.FootComment
+ n.FootComment = ""
+ }
+ p.expect(yaml_MAPPING_END_EVENT)
+ return n
+}
+
+// ----------------------------------------------------------------------------
+// Decoder, unmarshals a node into a provided value.
+
+type decoder struct {
+ doc *Node
+ aliases map[*Node]bool
+ terrors []string
+
+ stringMapType reflect.Type
+ generalMapType reflect.Type
+
+ knownFields bool
+ uniqueKeys bool
+ decodeCount int
+ aliasCount int
+ aliasDepth int
+
+ mergedFields map[interface{}]bool
+}
+
+var (
+ nodeType = reflect.TypeOf(Node{})
+ durationType = reflect.TypeOf(time.Duration(0))
+ stringMapType = reflect.TypeOf(map[string]interface{}{})
+ generalMapType = reflect.TypeOf(map[interface{}]interface{}{})
+ ifaceType = generalMapType.Elem()
+ timeType = reflect.TypeOf(time.Time{})
+ ptrTimeType = reflect.TypeOf(&time.Time{})
+)
+
+func newDecoder() *decoder {
+ d := &decoder{
+ stringMapType: stringMapType,
+ generalMapType: generalMapType,
+ uniqueKeys: true,
+ }
+ d.aliases = make(map[*Node]bool)
+ return d
+}
+
+func (d *decoder) terror(n *Node, tag string, out reflect.Value) {
+ if n.Tag != "" {
+ tag = n.Tag
+ }
+ value := n.Value
+ if tag != seqTag && tag != mapTag {
+ if len(value) > 10 {
+ value = " `" + value[:7] + "...`"
+ } else {
+ value = " `" + value + "`"
+ }
+ }
+ d.terrors = append(d.terrors, fmt.Sprintf("line %d: cannot unmarshal %s%s into %s", n.Line, shortTag(tag), value, out.Type()))
+}
+
+func (d *decoder) callUnmarshaler(n *Node, u Unmarshaler) (good bool) {
+ err := u.UnmarshalYAML(n)
+ if e, ok := err.(*TypeError); ok {
+ d.terrors = append(d.terrors, e.Errors...)
+ return false
+ }
+ if err != nil {
+ fail(err)
+ }
+ return true
+}
+
+func (d *decoder) callObsoleteUnmarshaler(n *Node, u obsoleteUnmarshaler) (good bool) {
+ terrlen := len(d.terrors)
+ err := u.UnmarshalYAML(func(v interface{}) (err error) {
+ defer handleErr(&err)
+ d.unmarshal(n, reflect.ValueOf(v))
+ if len(d.terrors) > terrlen {
+ issues := d.terrors[terrlen:]
+ d.terrors = d.terrors[:terrlen]
+ return &TypeError{issues}
+ }
+ return nil
+ })
+ if e, ok := err.(*TypeError); ok {
+ d.terrors = append(d.terrors, e.Errors...)
+ return false
+ }
+ if err != nil {
+ fail(err)
+ }
+ return true
+}
+
+// d.prepare initializes and dereferences pointers and calls UnmarshalYAML
+// if a value is found to implement it.
+// It returns the initialized and dereferenced out value, whether
+// unmarshalling was already done by UnmarshalYAML, and if so whether
+// its types unmarshalled appropriately.
+//
+// If n holds a null value, prepare returns before doing anything.
+func (d *decoder) prepare(n *Node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) {
+ if n.ShortTag() == nullTag {
+ return out, false, false
+ }
+ again := true
+ for again {
+ again = false
+ if out.Kind() == reflect.Ptr {
+ if out.IsNil() {
+ out.Set(reflect.New(out.Type().Elem()))
+ }
+ out = out.Elem()
+ again = true
+ }
+ if out.CanAddr() {
+ outi := out.Addr().Interface()
+ if u, ok := outi.(Unmarshaler); ok {
+ good = d.callUnmarshaler(n, u)
+ return out, true, good
+ }
+ if u, ok := outi.(obsoleteUnmarshaler); ok {
+ good = d.callObsoleteUnmarshaler(n, u)
+ return out, true, good
+ }
+ }
+ }
+ return out, false, false
+}
+
+func (d *decoder) fieldByIndex(n *Node, v reflect.Value, index []int) (field reflect.Value) {
+ if n.ShortTag() == nullTag {
+ return reflect.Value{}
+ }
+ for _, num := range index {
+ for {
+ if v.Kind() == reflect.Ptr {
+ if v.IsNil() {
+ v.Set(reflect.New(v.Type().Elem()))
+ }
+ v = v.Elem()
+ continue
+ }
+ break
+ }
+ v = v.Field(num)
+ }
+ return v
+}
+
+const (
+ // 400,000 decode operations is ~500kb of dense object declarations, or
+ // ~5kb of dense object declarations with 10000% alias expansion
+ alias_ratio_range_low = 400000
+
+ // 4,000,000 decode operations is ~5MB of dense object declarations, or
+ // ~4.5MB of dense object declarations with 10% alias expansion
+ alias_ratio_range_high = 4000000
+
+ // alias_ratio_range is the range over which we scale allowed alias ratios
+ alias_ratio_range = float64(alias_ratio_range_high - alias_ratio_range_low)
+)
+
+func allowedAliasRatio(decodeCount int) float64 {
+ switch {
+ case decodeCount <= alias_ratio_range_low:
+ // allow 99% to come from alias expansion for small-to-medium documents
+ return 0.99
+ case decodeCount >= alias_ratio_range_high:
+ // allow 10% to come from alias expansion for very large documents
+ return 0.10
+ default:
+ // scale smoothly from 99% down to 10% over the range.
+ // this maps to 396,000 - 400,000 allowed alias-driven decodes over the range.
+ // 400,000 decode operations is ~100MB of allocations in worst-case scenarios (single-item maps).
+ return 0.99 - 0.89*(float64(decodeCount-alias_ratio_range_low)/alias_ratio_range)
+ }
+}
+
+func (d *decoder) unmarshal(n *Node, out reflect.Value) (good bool) {
+ d.decodeCount++
+ if d.aliasDepth > 0 {
+ d.aliasCount++
+ }
+ if d.aliasCount > 100 && d.decodeCount > 1000 && float64(d.aliasCount)/float64(d.decodeCount) > allowedAliasRatio(d.decodeCount) {
+ failf("document contains excessive aliasing")
+ }
+ if out.Type() == nodeType {
+ out.Set(reflect.ValueOf(n).Elem())
+ return true
+ }
+ switch n.Kind {
+ case DocumentNode:
+ return d.document(n, out)
+ case AliasNode:
+ return d.alias(n, out)
+ }
+ out, unmarshaled, good := d.prepare(n, out)
+ if unmarshaled {
+ return good
+ }
+ switch n.Kind {
+ case ScalarNode:
+ good = d.scalar(n, out)
+ case MappingNode:
+ good = d.mapping(n, out)
+ case SequenceNode:
+ good = d.sequence(n, out)
+ case 0:
+ if n.IsZero() {
+ return d.null(out)
+ }
+ fallthrough
+ default:
+ failf("cannot decode node with unknown kind %d", n.Kind)
+ }
+ return good
+}
+
+func (d *decoder) document(n *Node, out reflect.Value) (good bool) {
+ if len(n.Content) == 1 {
+ d.doc = n
+ d.unmarshal(n.Content[0], out)
+ return true
+ }
+ return false
+}
+
+func (d *decoder) alias(n *Node, out reflect.Value) (good bool) {
+ if d.aliases[n] {
+ // TODO this could actually be allowed in some circumstances.
+ failf("anchor '%s' value contains itself", n.Value)
+ }
+ d.aliases[n] = true
+ d.aliasDepth++
+ good = d.unmarshal(n.Alias, out)
+ d.aliasDepth--
+ delete(d.aliases, n)
+ return good
+}
+
+var zeroValue reflect.Value
+
+func resetMap(out reflect.Value) {
+ for _, k := range out.MapKeys() {
+ out.SetMapIndex(k, zeroValue)
+ }
+}
+
+func (d *decoder) null(out reflect.Value) bool {
+ if out.CanAddr() {
+ switch out.Kind() {
+ case reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
+ out.Set(reflect.Zero(out.Type()))
+ return true
+ }
+ }
+ return false
+}
+
+func (d *decoder) scalar(n *Node, out reflect.Value) bool {
+ var tag string
+ var resolved interface{}
+ if n.indicatedString() {
+ tag = strTag
+ resolved = n.Value
+ } else {
+ tag, resolved = resolve(n.Tag, n.Value)
+ if tag == binaryTag {
+ data, err := base64.StdEncoding.DecodeString(resolved.(string))
+ if err != nil {
+ failf("!!binary value contains invalid base64 data")
+ }
+ resolved = string(data)
+ }
+ }
+ if resolved == nil {
+ return d.null(out)
+ }
+ if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
+ // We've resolved to exactly the type we want, so use that.
+ out.Set(resolvedv)
+ return true
+ }
+ // Perhaps we can use the value as a TextUnmarshaler to
+ // set its value.
+ if out.CanAddr() {
+ u, ok := out.Addr().Interface().(encoding.TextUnmarshaler)
+ if ok {
+ var text []byte
+ if tag == binaryTag {
+ text = []byte(resolved.(string))
+ } else {
+ // We let any value be unmarshaled into TextUnmarshaler.
+ // That might be more lax than we'd like, but the
+ // TextUnmarshaler itself should bowl out any dubious values.
+ text = []byte(n.Value)
+ }
+ err := u.UnmarshalText(text)
+ if err != nil {
+ fail(err)
+ }
+ return true
+ }
+ }
+ switch out.Kind() {
+ case reflect.String:
+ if tag == binaryTag {
+ out.SetString(resolved.(string))
+ return true
+ }
+ out.SetString(n.Value)
+ return true
+ case reflect.Interface:
+ out.Set(reflect.ValueOf(resolved))
+ return true
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ // This used to work in v2, but it's very unfriendly.
+ isDuration := out.Type() == durationType
+
+ switch resolved := resolved.(type) {
+ case int:
+ if !isDuration && !out.OverflowInt(int64(resolved)) {
+ out.SetInt(int64(resolved))
+ return true
+ }
+ case int64:
+ if !isDuration && !out.OverflowInt(resolved) {
+ out.SetInt(resolved)
+ return true
+ }
+ case uint64:
+ if !isDuration && resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
+ out.SetInt(int64(resolved))
+ return true
+ }
+ case float64:
+ if !isDuration && resolved <= math.MaxInt64 && !out.OverflowInt(int64(resolved)) {
+ out.SetInt(int64(resolved))
+ return true
+ }
+ case string:
+ if out.Type() == durationType {
+ d, err := time.ParseDuration(resolved)
+ if err == nil {
+ out.SetInt(int64(d))
+ return true
+ }
+ }
+ }
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ switch resolved := resolved.(type) {
+ case int:
+ if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
+ out.SetUint(uint64(resolved))
+ return true
+ }
+ case int64:
+ if resolved >= 0 && !out.OverflowUint(uint64(resolved)) {
+ out.SetUint(uint64(resolved))
+ return true
+ }
+ case uint64:
+ if !out.OverflowUint(uint64(resolved)) {
+ out.SetUint(uint64(resolved))
+ return true
+ }
+ case float64:
+ if resolved <= math.MaxUint64 && !out.OverflowUint(uint64(resolved)) {
+ out.SetUint(uint64(resolved))
+ return true
+ }
+ }
+ case reflect.Bool:
+ switch resolved := resolved.(type) {
+ case bool:
+ out.SetBool(resolved)
+ return true
+ case string:
+ // This offers some compatibility with the 1.1 spec (https://yaml.org/type/bool.html).
+ // It only works if explicitly attempting to unmarshal into a typed bool value.
+ switch resolved {
+ case "y", "Y", "yes", "Yes", "YES", "on", "On", "ON":
+ out.SetBool(true)
+ return true
+ case "n", "N", "no", "No", "NO", "off", "Off", "OFF":
+ out.SetBool(false)
+ return true
+ }
+ }
+ case reflect.Float32, reflect.Float64:
+ switch resolved := resolved.(type) {
+ case int:
+ out.SetFloat(float64(resolved))
+ return true
+ case int64:
+ out.SetFloat(float64(resolved))
+ return true
+ case uint64:
+ out.SetFloat(float64(resolved))
+ return true
+ case float64:
+ out.SetFloat(resolved)
+ return true
+ }
+ case reflect.Struct:
+ if resolvedv := reflect.ValueOf(resolved); out.Type() == resolvedv.Type() {
+ out.Set(resolvedv)
+ return true
+ }
+ case reflect.Ptr:
+ panic("yaml internal error: please report the issue")
+ }
+ d.terror(n, tag, out)
+ return false
+}
+
+func settableValueOf(i interface{}) reflect.Value {
+ v := reflect.ValueOf(i)
+ sv := reflect.New(v.Type()).Elem()
+ sv.Set(v)
+ return sv
+}
+
+func (d *decoder) sequence(n *Node, out reflect.Value) (good bool) {
+ l := len(n.Content)
+
+ var iface reflect.Value
+ switch out.Kind() {
+ case reflect.Slice:
+ out.Set(reflect.MakeSlice(out.Type(), l, l))
+ case reflect.Array:
+ if l != out.Len() {
+ failf("invalid array: want %d elements but got %d", out.Len(), l)
+ }
+ case reflect.Interface:
+ // No type hints. Will have to use a generic sequence.
+ iface = out
+ out = settableValueOf(make([]interface{}, l))
+ default:
+ d.terror(n, seqTag, out)
+ return false
+ }
+ et := out.Type().Elem()
+
+ j := 0
+ for i := 0; i < l; i++ {
+ e := reflect.New(et).Elem()
+ if ok := d.unmarshal(n.Content[i], e); ok {
+ out.Index(j).Set(e)
+ j++
+ }
+ }
+ if out.Kind() != reflect.Array {
+ out.Set(out.Slice(0, j))
+ }
+ if iface.IsValid() {
+ iface.Set(out)
+ }
+ return true
+}
+
+func (d *decoder) mapping(n *Node, out reflect.Value) (good bool) {
+ l := len(n.Content)
+ if d.uniqueKeys {
+ nerrs := len(d.terrors)
+ for i := 0; i < l; i += 2 {
+ ni := n.Content[i]
+ for j := i + 2; j < l; j += 2 {
+ nj := n.Content[j]
+ if ni.Kind == nj.Kind && ni.Value == nj.Value {
+ d.terrors = append(d.terrors, fmt.Sprintf("line %d: mapping key %#v already defined at line %d", nj.Line, nj.Value, ni.Line))
+ }
+ }
+ }
+ if len(d.terrors) > nerrs {
+ return false
+ }
+ }
+ switch out.Kind() {
+ case reflect.Struct:
+ return d.mappingStruct(n, out)
+ case reflect.Map:
+ // okay
+ case reflect.Interface:
+ iface := out
+ if isStringMap(n) {
+ out = reflect.MakeMap(d.stringMapType)
+ } else {
+ out = reflect.MakeMap(d.generalMapType)
+ }
+ iface.Set(out)
+ default:
+ d.terror(n, mapTag, out)
+ return false
+ }
+
+ outt := out.Type()
+ kt := outt.Key()
+ et := outt.Elem()
+
+ stringMapType := d.stringMapType
+ generalMapType := d.generalMapType
+ if outt.Elem() == ifaceType {
+ if outt.Key().Kind() == reflect.String {
+ d.stringMapType = outt
+ } else if outt.Key() == ifaceType {
+ d.generalMapType = outt
+ }
+ }
+
+ mergedFields := d.mergedFields
+ d.mergedFields = nil
+
+ var mergeNode *Node
+
+ mapIsNew := false
+ if out.IsNil() {
+ out.Set(reflect.MakeMap(outt))
+ mapIsNew = true
+ }
+ for i := 0; i < l; i += 2 {
+ if isMerge(n.Content[i]) {
+ mergeNode = n.Content[i+1]
+ continue
+ }
+ k := reflect.New(kt).Elem()
+ if d.unmarshal(n.Content[i], k) {
+ if mergedFields != nil {
+ ki := k.Interface()
+ if d.getPossiblyUnhashableKey(mergedFields, ki) {
+ continue
+ }
+ d.setPossiblyUnhashableKey(mergedFields, ki, true)
+ }
+ kkind := k.Kind()
+ if kkind == reflect.Interface {
+ kkind = k.Elem().Kind()
+ }
+ if kkind == reflect.Map || kkind == reflect.Slice {
+ failf("invalid map key: %#v", k.Interface())
+ }
+ e := reflect.New(et).Elem()
+ if d.unmarshal(n.Content[i+1], e) || n.Content[i+1].ShortTag() == nullTag && (mapIsNew || !out.MapIndex(k).IsValid()) {
+ out.SetMapIndex(k, e)
+ }
+ }
+ }
+
+ d.mergedFields = mergedFields
+ if mergeNode != nil {
+ d.merge(n, mergeNode, out)
+ }
+
+ d.stringMapType = stringMapType
+ d.generalMapType = generalMapType
+ return true
+}
+
+func isStringMap(n *Node) bool {
+ if n.Kind != MappingNode {
+ return false
+ }
+ l := len(n.Content)
+ for i := 0; i < l; i += 2 {
+ shortTag := n.Content[i].ShortTag()
+ if shortTag != strTag && shortTag != mergeTag {
+ return false
+ }
+ }
+ return true
+}
+
+func (d *decoder) mappingStruct(n *Node, out reflect.Value) (good bool) {
+ sinfo, err := getStructInfo(out.Type())
+ if err != nil {
+ panic(err)
+ }
+
+ var inlineMap reflect.Value
+ var elemType reflect.Type
+ if sinfo.InlineMap != -1 {
+ inlineMap = out.Field(sinfo.InlineMap)
+ elemType = inlineMap.Type().Elem()
+ }
+
+ for _, index := range sinfo.InlineUnmarshalers {
+ field := d.fieldByIndex(n, out, index)
+ d.prepare(n, field)
+ }
+
+ mergedFields := d.mergedFields
+ d.mergedFields = nil
+ var mergeNode *Node
+ var doneFields []bool
+ if d.uniqueKeys {
+ doneFields = make([]bool, len(sinfo.FieldsList))
+ }
+ name := settableValueOf("")
+ l := len(n.Content)
+ for i := 0; i < l; i += 2 {
+ ni := n.Content[i]
+ if isMerge(ni) {
+ mergeNode = n.Content[i+1]
+ continue
+ }
+ if !d.unmarshal(ni, name) {
+ continue
+ }
+ sname := name.String()
+ if mergedFields != nil {
+ if mergedFields[sname] {
+ continue
+ }
+ mergedFields[sname] = true
+ }
+ if info, ok := sinfo.FieldsMap[sname]; ok {
+ if d.uniqueKeys {
+ if doneFields[info.Id] {
+ d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s already set in type %s", ni.Line, name.String(), out.Type()))
+ continue
+ }
+ doneFields[info.Id] = true
+ }
+ var field reflect.Value
+ if info.Inline == nil {
+ field = out.Field(info.Num)
+ } else {
+ field = d.fieldByIndex(n, out, info.Inline)
+ }
+ d.unmarshal(n.Content[i+1], field)
+ } else if sinfo.InlineMap != -1 {
+ if inlineMap.IsNil() {
+ inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
+ }
+ value := reflect.New(elemType).Elem()
+ d.unmarshal(n.Content[i+1], value)
+ inlineMap.SetMapIndex(name, value)
+ } else if d.knownFields {
+ d.terrors = append(d.terrors, fmt.Sprintf("line %d: field %s not found in type %s", ni.Line, name.String(), out.Type()))
+ }
+ }
+
+ d.mergedFields = mergedFields
+ if mergeNode != nil {
+ d.merge(n, mergeNode, out)
+ }
+ return true
+}
+
+func failWantMap() {
+ failf("map merge requires map or sequence of maps as the value")
+}
+
+func (d *decoder) setPossiblyUnhashableKey(m map[interface{}]bool, key interface{}, value bool) {
+ defer func() {
+ if err := recover(); err != nil {
+ failf("%v", err)
+ }
+ }()
+ m[key] = value
+}
+
+func (d *decoder) getPossiblyUnhashableKey(m map[interface{}]bool, key interface{}) bool {
+ defer func() {
+ if err := recover(); err != nil {
+ failf("%v", err)
+ }
+ }()
+ return m[key]
+}
+
+func (d *decoder) merge(parent *Node, merge *Node, out reflect.Value) {
+ mergedFields := d.mergedFields
+ if mergedFields == nil {
+ d.mergedFields = make(map[interface{}]bool)
+ for i := 0; i < len(parent.Content); i += 2 {
+ k := reflect.New(ifaceType).Elem()
+ if d.unmarshal(parent.Content[i], k) {
+ d.setPossiblyUnhashableKey(d.mergedFields, k.Interface(), true)
+ }
+ }
+ }
+
+ switch merge.Kind {
+ case MappingNode:
+ d.unmarshal(merge, out)
+ case AliasNode:
+ if merge.Alias != nil && merge.Alias.Kind != MappingNode {
+ failWantMap()
+ }
+ d.unmarshal(merge, out)
+ case SequenceNode:
+ for i := 0; i < len(merge.Content); i++ {
+ ni := merge.Content[i]
+ if ni.Kind == AliasNode {
+ if ni.Alias != nil && ni.Alias.Kind != MappingNode {
+ failWantMap()
+ }
+ } else if ni.Kind != MappingNode {
+ failWantMap()
+ }
+ d.unmarshal(ni, out)
+ }
+ default:
+ failWantMap()
+ }
+
+ d.mergedFields = mergedFields
+}
+
+func isMerge(n *Node) bool {
+ return n.Kind == ScalarNode && n.Value == "<<" && (n.Tag == "" || n.Tag == "!" || shortTag(n.Tag) == mergeTag)
+}
diff --git a/vendor/go.yaml.in/yaml/v3/emitterc.go b/vendor/go.yaml.in/yaml/v3/emitterc.go
new file mode 100644
index 00000000..ab4e03ba
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/emitterc.go
@@ -0,0 +1,2054 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+// Copyright (c) 2006-2010 Kirill Simonov
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+// of the Software, and to permit persons to whom the Software is furnished to do
+// so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package yaml
+
+import (
+ "bytes"
+ "fmt"
+)
+
+// Flush the buffer if needed.
+func flush(emitter *yaml_emitter_t) bool {
+ if emitter.buffer_pos+5 >= len(emitter.buffer) {
+ return yaml_emitter_flush(emitter)
+ }
+ return true
+}
+
+// Put a character to the output buffer.
+func put(emitter *yaml_emitter_t, value byte) bool {
+ if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
+ return false
+ }
+ emitter.buffer[emitter.buffer_pos] = value
+ emitter.buffer_pos++
+ emitter.column++
+ return true
+}
+
+// Put a line break to the output buffer.
+func put_break(emitter *yaml_emitter_t) bool {
+ if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
+ return false
+ }
+ switch emitter.line_break {
+ case yaml_CR_BREAK:
+ emitter.buffer[emitter.buffer_pos] = '\r'
+ emitter.buffer_pos += 1
+ case yaml_LN_BREAK:
+ emitter.buffer[emitter.buffer_pos] = '\n'
+ emitter.buffer_pos += 1
+ case yaml_CRLN_BREAK:
+ emitter.buffer[emitter.buffer_pos+0] = '\r'
+ emitter.buffer[emitter.buffer_pos+1] = '\n'
+ emitter.buffer_pos += 2
+ default:
+ panic("unknown line break setting")
+ }
+ if emitter.column == 0 {
+ emitter.space_above = true
+ }
+ emitter.column = 0
+ emitter.line++
+ // [Go] Do this here and below and drop from everywhere else (see commented lines).
+ emitter.indention = true
+ return true
+}
+
+// Copy a character from a string into buffer.
+func write(emitter *yaml_emitter_t, s []byte, i *int) bool {
+ if emitter.buffer_pos+5 >= len(emitter.buffer) && !yaml_emitter_flush(emitter) {
+ return false
+ }
+ p := emitter.buffer_pos
+ w := width(s[*i])
+ switch w {
+ case 4:
+ emitter.buffer[p+3] = s[*i+3]
+ fallthrough
+ case 3:
+ emitter.buffer[p+2] = s[*i+2]
+ fallthrough
+ case 2:
+ emitter.buffer[p+1] = s[*i+1]
+ fallthrough
+ case 1:
+ emitter.buffer[p+0] = s[*i+0]
+ default:
+ panic("unknown character width")
+ }
+ emitter.column++
+ emitter.buffer_pos += w
+ *i += w
+ return true
+}
+
+// Write a whole string into buffer.
+func write_all(emitter *yaml_emitter_t, s []byte) bool {
+ for i := 0; i < len(s); {
+ if !write(emitter, s, &i) {
+ return false
+ }
+ }
+ return true
+}
+
+// Copy a line break character from a string into buffer.
+func write_break(emitter *yaml_emitter_t, s []byte, i *int) bool {
+ if s[*i] == '\n' {
+ if !put_break(emitter) {
+ return false
+ }
+ *i++
+ } else {
+ if !write(emitter, s, i) {
+ return false
+ }
+ if emitter.column == 0 {
+ emitter.space_above = true
+ }
+ emitter.column = 0
+ emitter.line++
+ // [Go] Do this here and above and drop from everywhere else (see commented lines).
+ emitter.indention = true
+ }
+ return true
+}
+
+// Set an emitter error and return false.
+func yaml_emitter_set_emitter_error(emitter *yaml_emitter_t, problem string) bool {
+ emitter.error = yaml_EMITTER_ERROR
+ emitter.problem = problem
+ return false
+}
+
+// Emit an event.
+func yaml_emitter_emit(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ emitter.events = append(emitter.events, *event)
+ for !yaml_emitter_need_more_events(emitter) {
+ event := &emitter.events[emitter.events_head]
+ if !yaml_emitter_analyze_event(emitter, event) {
+ return false
+ }
+ if !yaml_emitter_state_machine(emitter, event) {
+ return false
+ }
+ yaml_event_delete(event)
+ emitter.events_head++
+ }
+ return true
+}
+
+// Check if we need to accumulate more events before emitting.
+//
+// We accumulate extra
+// - 1 event for DOCUMENT-START
+// - 2 events for SEQUENCE-START
+// - 3 events for MAPPING-START
+func yaml_emitter_need_more_events(emitter *yaml_emitter_t) bool {
+ if emitter.events_head == len(emitter.events) {
+ return true
+ }
+ var accumulate int
+ switch emitter.events[emitter.events_head].typ {
+ case yaml_DOCUMENT_START_EVENT:
+ accumulate = 1
+ break
+ case yaml_SEQUENCE_START_EVENT:
+ accumulate = 2
+ break
+ case yaml_MAPPING_START_EVENT:
+ accumulate = 3
+ break
+ default:
+ return false
+ }
+ if len(emitter.events)-emitter.events_head > accumulate {
+ return false
+ }
+ var level int
+ for i := emitter.events_head; i < len(emitter.events); i++ {
+ switch emitter.events[i].typ {
+ case yaml_STREAM_START_EVENT, yaml_DOCUMENT_START_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT:
+ level++
+ case yaml_STREAM_END_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_END_EVENT, yaml_MAPPING_END_EVENT:
+ level--
+ }
+ if level == 0 {
+ return false
+ }
+ }
+ return true
+}
+
+// Append a directive to the directives stack.
+func yaml_emitter_append_tag_directive(emitter *yaml_emitter_t, value *yaml_tag_directive_t, allow_duplicates bool) bool {
+ for i := 0; i < len(emitter.tag_directives); i++ {
+ if bytes.Equal(value.handle, emitter.tag_directives[i].handle) {
+ if allow_duplicates {
+ return true
+ }
+ return yaml_emitter_set_emitter_error(emitter, "duplicate %TAG directive")
+ }
+ }
+
+ // [Go] Do we actually need to copy this given garbage collection
+ // and the lack of deallocating destructors?
+ tag_copy := yaml_tag_directive_t{
+ handle: make([]byte, len(value.handle)),
+ prefix: make([]byte, len(value.prefix)),
+ }
+ copy(tag_copy.handle, value.handle)
+ copy(tag_copy.prefix, value.prefix)
+ emitter.tag_directives = append(emitter.tag_directives, tag_copy)
+ return true
+}
+
+// Increase the indentation level.
+func yaml_emitter_increase_indent_compact(emitter *yaml_emitter_t, flow, indentless bool, compact_seq bool) bool {
+ emitter.indents = append(emitter.indents, emitter.indent)
+ if emitter.indent < 0 {
+ if flow {
+ emitter.indent = emitter.best_indent
+ } else {
+ emitter.indent = 0
+ }
+ } else if !indentless {
+ // [Go] This was changed so that indentations are more regular.
+ if emitter.states[len(emitter.states)-1] == yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE {
+ // The first indent inside a sequence will just skip the "- " indicator.
+ emitter.indent += 2
+ } else {
+ // Everything else aligns to the chosen indentation.
+ emitter.indent = emitter.best_indent * ((emitter.indent + emitter.best_indent) / emitter.best_indent)
+ if compact_seq {
+ // The value compact_seq passed in is almost always set to `false` when this function is called,
+ // except when we are dealing with sequence nodes. So this gets triggered to subtract 2 only when we
+ // are increasing the indent to account for sequence nodes, which will be correct because we need to
+ // subtract 2 to account for the - at the beginning of the sequence node.
+ emitter.indent = emitter.indent - 2
+ }
+ }
+ }
+ return true
+}
+
+// State dispatcher.
+func yaml_emitter_state_machine(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ switch emitter.state {
+ default:
+ case yaml_EMIT_STREAM_START_STATE:
+ return yaml_emitter_emit_stream_start(emitter, event)
+
+ case yaml_EMIT_FIRST_DOCUMENT_START_STATE:
+ return yaml_emitter_emit_document_start(emitter, event, true)
+
+ case yaml_EMIT_DOCUMENT_START_STATE:
+ return yaml_emitter_emit_document_start(emitter, event, false)
+
+ case yaml_EMIT_DOCUMENT_CONTENT_STATE:
+ return yaml_emitter_emit_document_content(emitter, event)
+
+ case yaml_EMIT_DOCUMENT_END_STATE:
+ return yaml_emitter_emit_document_end(emitter, event)
+
+ case yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
+ return yaml_emitter_emit_flow_sequence_item(emitter, event, true, false)
+
+ case yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE:
+ return yaml_emitter_emit_flow_sequence_item(emitter, event, false, true)
+
+ case yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE:
+ return yaml_emitter_emit_flow_sequence_item(emitter, event, false, false)
+
+ case yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
+ return yaml_emitter_emit_flow_mapping_key(emitter, event, true, false)
+
+ case yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE:
+ return yaml_emitter_emit_flow_mapping_key(emitter, event, false, true)
+
+ case yaml_EMIT_FLOW_MAPPING_KEY_STATE:
+ return yaml_emitter_emit_flow_mapping_key(emitter, event, false, false)
+
+ case yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
+ return yaml_emitter_emit_flow_mapping_value(emitter, event, true)
+
+ case yaml_EMIT_FLOW_MAPPING_VALUE_STATE:
+ return yaml_emitter_emit_flow_mapping_value(emitter, event, false)
+
+ case yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
+ return yaml_emitter_emit_block_sequence_item(emitter, event, true)
+
+ case yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
+ return yaml_emitter_emit_block_sequence_item(emitter, event, false)
+
+ case yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
+ return yaml_emitter_emit_block_mapping_key(emitter, event, true)
+
+ case yaml_EMIT_BLOCK_MAPPING_KEY_STATE:
+ return yaml_emitter_emit_block_mapping_key(emitter, event, false)
+
+ case yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
+ return yaml_emitter_emit_block_mapping_value(emitter, event, true)
+
+ case yaml_EMIT_BLOCK_MAPPING_VALUE_STATE:
+ return yaml_emitter_emit_block_mapping_value(emitter, event, false)
+
+ case yaml_EMIT_END_STATE:
+ return yaml_emitter_set_emitter_error(emitter, "expected nothing after STREAM-END")
+ }
+ panic("invalid emitter state")
+}
+
+// Expect STREAM-START.
+func yaml_emitter_emit_stream_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ if event.typ != yaml_STREAM_START_EVENT {
+ return yaml_emitter_set_emitter_error(emitter, "expected STREAM-START")
+ }
+ if emitter.encoding == yaml_ANY_ENCODING {
+ emitter.encoding = event.encoding
+ if emitter.encoding == yaml_ANY_ENCODING {
+ emitter.encoding = yaml_UTF8_ENCODING
+ }
+ }
+ if emitter.best_indent < 2 || emitter.best_indent > 9 {
+ emitter.best_indent = 2
+ }
+ if emitter.best_width >= 0 && emitter.best_width <= emitter.best_indent*2 {
+ emitter.best_width = 80
+ }
+ if emitter.best_width < 0 {
+ emitter.best_width = 1<<31 - 1
+ }
+ if emitter.line_break == yaml_ANY_BREAK {
+ emitter.line_break = yaml_LN_BREAK
+ }
+
+ emitter.indent = -1
+ emitter.line = 0
+ emitter.column = 0
+ emitter.whitespace = true
+ emitter.indention = true
+ emitter.space_above = true
+ emitter.foot_indent = -1
+
+ if emitter.encoding != yaml_UTF8_ENCODING {
+ if !yaml_emitter_write_bom(emitter) {
+ return false
+ }
+ }
+ emitter.state = yaml_EMIT_FIRST_DOCUMENT_START_STATE
+ return true
+}
+
+// Expect DOCUMENT-START or STREAM-END.
+func yaml_emitter_emit_document_start(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
+
+ if event.typ == yaml_DOCUMENT_START_EVENT {
+
+ if event.version_directive != nil {
+ if !yaml_emitter_analyze_version_directive(emitter, event.version_directive) {
+ return false
+ }
+ }
+
+ for i := 0; i < len(event.tag_directives); i++ {
+ tag_directive := &event.tag_directives[i]
+ if !yaml_emitter_analyze_tag_directive(emitter, tag_directive) {
+ return false
+ }
+ if !yaml_emitter_append_tag_directive(emitter, tag_directive, false) {
+ return false
+ }
+ }
+
+ for i := 0; i < len(default_tag_directives); i++ {
+ tag_directive := &default_tag_directives[i]
+ if !yaml_emitter_append_tag_directive(emitter, tag_directive, true) {
+ return false
+ }
+ }
+
+ implicit := event.implicit
+ if !first || emitter.canonical {
+ implicit = false
+ }
+
+ if emitter.open_ended && (event.version_directive != nil || len(event.tag_directives) > 0) {
+ if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+
+ if event.version_directive != nil {
+ implicit = false
+ if !yaml_emitter_write_indicator(emitter, []byte("%YAML"), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte("1.1"), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+
+ if len(event.tag_directives) > 0 {
+ implicit = false
+ for i := 0; i < len(event.tag_directives); i++ {
+ tag_directive := &event.tag_directives[i]
+ if !yaml_emitter_write_indicator(emitter, []byte("%TAG"), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_tag_handle(emitter, tag_directive.handle) {
+ return false
+ }
+ if !yaml_emitter_write_tag_content(emitter, tag_directive.prefix, true) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ }
+
+ if yaml_emitter_check_empty_document(emitter) {
+ implicit = false
+ }
+ if !implicit {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte("---"), true, false, false) {
+ return false
+ }
+ if emitter.canonical || true {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ }
+
+ if len(emitter.head_comment) > 0 {
+ if !yaml_emitter_process_head_comment(emitter) {
+ return false
+ }
+ if !put_break(emitter) {
+ return false
+ }
+ }
+
+ emitter.state = yaml_EMIT_DOCUMENT_CONTENT_STATE
+ return true
+ }
+
+ if event.typ == yaml_STREAM_END_EVENT {
+ if emitter.open_ended {
+ if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !yaml_emitter_flush(emitter) {
+ return false
+ }
+ emitter.state = yaml_EMIT_END_STATE
+ return true
+ }
+
+ return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-START or STREAM-END")
+}
+
+// yaml_emitter_increase_indent preserves the original signature and delegates to
+// yaml_emitter_increase_indent_compact without compact-sequence indentation
+func yaml_emitter_increase_indent(emitter *yaml_emitter_t, flow, indentless bool) bool {
+ return yaml_emitter_increase_indent_compact(emitter, flow, indentless, false)
+}
+
+// yaml_emitter_process_line_comment preserves the original signature and delegates to
+// yaml_emitter_process_line_comment_linebreak passing false for linebreak
+func yaml_emitter_process_line_comment(emitter *yaml_emitter_t) bool {
+ return yaml_emitter_process_line_comment_linebreak(emitter, false)
+}
+
+// Expect the root node.
+func yaml_emitter_emit_document_content(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ emitter.states = append(emitter.states, yaml_EMIT_DOCUMENT_END_STATE)
+
+ if !yaml_emitter_process_head_comment(emitter) {
+ return false
+ }
+ if !yaml_emitter_emit_node(emitter, event, true, false, false, false) {
+ return false
+ }
+ if !yaml_emitter_process_line_comment(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_foot_comment(emitter) {
+ return false
+ }
+ return true
+}
+
+// Expect DOCUMENT-END.
+func yaml_emitter_emit_document_end(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ if event.typ != yaml_DOCUMENT_END_EVENT {
+ return yaml_emitter_set_emitter_error(emitter, "expected DOCUMENT-END")
+ }
+ // [Go] Force document foot separation.
+ emitter.foot_indent = 0
+ if !yaml_emitter_process_foot_comment(emitter) {
+ return false
+ }
+ emitter.foot_indent = -1
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if !event.implicit {
+ // [Go] Allocate the slice elsewhere.
+ if !yaml_emitter_write_indicator(emitter, []byte("..."), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !yaml_emitter_flush(emitter) {
+ return false
+ }
+ emitter.state = yaml_EMIT_DOCUMENT_START_STATE
+ emitter.tag_directives = emitter.tag_directives[:0]
+ return true
+}
+
+// Expect a flow item node.
+func yaml_emitter_emit_flow_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first, trail bool) bool {
+ if first {
+ if !yaml_emitter_write_indicator(emitter, []byte{'['}, true, true, false) {
+ return false
+ }
+ if !yaml_emitter_increase_indent(emitter, true, false) {
+ return false
+ }
+ emitter.flow_level++
+ }
+
+ if event.typ == yaml_SEQUENCE_END_EVENT {
+ if emitter.canonical && !first && !trail {
+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
+ return false
+ }
+ }
+ emitter.flow_level--
+ emitter.indent = emitter.indents[len(emitter.indents)-1]
+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
+ if emitter.column == 0 || emitter.canonical && !first {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{']'}, false, false, false) {
+ return false
+ }
+ if !yaml_emitter_process_line_comment(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_foot_comment(emitter) {
+ return false
+ }
+ emitter.state = emitter.states[len(emitter.states)-1]
+ emitter.states = emitter.states[:len(emitter.states)-1]
+
+ return true
+ }
+
+ if !first && !trail {
+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
+ return false
+ }
+ }
+
+ if !yaml_emitter_process_head_comment(emitter) {
+ return false
+ }
+ if emitter.column == 0 {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+
+ if emitter.canonical || emitter.column > emitter.best_width {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE)
+ } else {
+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE)
+ }
+ if !yaml_emitter_emit_node(emitter, event, false, true, false, false) {
+ return false
+ }
+ if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
+ return false
+ }
+ }
+ if !yaml_emitter_process_line_comment(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_foot_comment(emitter) {
+ return false
+ }
+ return true
+}
+
+// Expect a flow key node.
+func yaml_emitter_emit_flow_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first, trail bool) bool {
+ if first {
+ if !yaml_emitter_write_indicator(emitter, []byte{'{'}, true, true, false) {
+ return false
+ }
+ if !yaml_emitter_increase_indent(emitter, true, false) {
+ return false
+ }
+ emitter.flow_level++
+ }
+
+ if event.typ == yaml_MAPPING_END_EVENT {
+ if (emitter.canonical || len(emitter.head_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0) && !first && !trail {
+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
+ return false
+ }
+ }
+ if !yaml_emitter_process_head_comment(emitter) {
+ return false
+ }
+ emitter.flow_level--
+ emitter.indent = emitter.indents[len(emitter.indents)-1]
+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
+ if emitter.canonical && !first {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'}'}, false, false, false) {
+ return false
+ }
+ if !yaml_emitter_process_line_comment(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_foot_comment(emitter) {
+ return false
+ }
+ emitter.state = emitter.states[len(emitter.states)-1]
+ emitter.states = emitter.states[:len(emitter.states)-1]
+ return true
+ }
+
+ if !first && !trail {
+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
+ return false
+ }
+ }
+
+ if !yaml_emitter_process_head_comment(emitter) {
+ return false
+ }
+
+ if emitter.column == 0 {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+
+ if emitter.canonical || emitter.column > emitter.best_width {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+
+ if !emitter.canonical && yaml_emitter_check_simple_key(emitter) {
+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE)
+ return yaml_emitter_emit_node(emitter, event, false, false, true, true)
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, false) {
+ return false
+ }
+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_VALUE_STATE)
+ return yaml_emitter_emit_node(emitter, event, false, false, true, false)
+}
+
+// Expect a flow value node.
+func yaml_emitter_emit_flow_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
+ if simple {
+ if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
+ return false
+ }
+ } else {
+ if emitter.canonical || emitter.column > emitter.best_width {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, false) {
+ return false
+ }
+ }
+ if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE)
+ } else {
+ emitter.states = append(emitter.states, yaml_EMIT_FLOW_MAPPING_KEY_STATE)
+ }
+ if !yaml_emitter_emit_node(emitter, event, false, false, true, false) {
+ return false
+ }
+ if len(emitter.line_comment)+len(emitter.foot_comment)+len(emitter.tail_comment) > 0 {
+ if !yaml_emitter_write_indicator(emitter, []byte{','}, false, false, false) {
+ return false
+ }
+ }
+ if !yaml_emitter_process_line_comment(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_foot_comment(emitter) {
+ return false
+ }
+ return true
+}
+
+// Expect a block item node.
+func yaml_emitter_emit_block_sequence_item(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
+ if first {
+ // emitter.mapping context tells us if we are currently in a mapping context.
+ // emiiter.column tells us which column we are in in the yaml output. 0 is the first char of the column.
+ // emitter.indentation tells us if the last character was an indentation character.
+ // emitter.compact_sequence_indent tells us if '- ' is considered part of the indentation for sequence elements.
+ // So, `seq` means that we are in a mapping context, and we are either at the first char of the column or
+ // the last character was not an indentation character, and we consider '- ' part of the indentation
+ // for sequence elements.
+ seq := emitter.mapping_context && (emitter.column == 0 || !emitter.indention) &&
+ emitter.compact_sequence_indent
+ if !yaml_emitter_increase_indent_compact(emitter, false, false, seq) {
+ return false
+ }
+ }
+ if event.typ == yaml_SEQUENCE_END_EVENT {
+ emitter.indent = emitter.indents[len(emitter.indents)-1]
+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
+ emitter.state = emitter.states[len(emitter.states)-1]
+ emitter.states = emitter.states[:len(emitter.states)-1]
+ return true
+ }
+ if !yaml_emitter_process_head_comment(emitter) {
+ return false
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'-'}, true, false, true) {
+ return false
+ }
+ emitter.states = append(emitter.states, yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE)
+ if !yaml_emitter_emit_node(emitter, event, false, true, false, false) {
+ return false
+ }
+ if !yaml_emitter_process_line_comment(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_foot_comment(emitter) {
+ return false
+ }
+ return true
+}
+
+// Expect a block key node.
+func yaml_emitter_emit_block_mapping_key(emitter *yaml_emitter_t, event *yaml_event_t, first bool) bool {
+ if first {
+ if !yaml_emitter_increase_indent(emitter, false, false) {
+ return false
+ }
+ }
+ if !yaml_emitter_process_head_comment(emitter) {
+ return false
+ }
+ if event.typ == yaml_MAPPING_END_EVENT {
+ emitter.indent = emitter.indents[len(emitter.indents)-1]
+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
+ emitter.state = emitter.states[len(emitter.states)-1]
+ emitter.states = emitter.states[:len(emitter.states)-1]
+ return true
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if len(emitter.line_comment) > 0 {
+ // [Go] A line comment was provided for the key. That's unusual as the
+ // scanner associates line comments with the value. Either way,
+ // save the line comment and render it appropriately later.
+ emitter.key_line_comment = emitter.line_comment
+ emitter.line_comment = nil
+ }
+ if yaml_emitter_check_simple_key(emitter) {
+ emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE)
+ return yaml_emitter_emit_node(emitter, event, false, false, true, true)
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'?'}, true, false, true) {
+ return false
+ }
+ emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_VALUE_STATE)
+ return yaml_emitter_emit_node(emitter, event, false, false, true, false)
+}
+
+// Expect a block value node.
+func yaml_emitter_emit_block_mapping_value(emitter *yaml_emitter_t, event *yaml_event_t, simple bool) bool {
+ if simple {
+ if !yaml_emitter_write_indicator(emitter, []byte{':'}, false, false, false) {
+ return false
+ }
+ } else {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{':'}, true, false, true) {
+ return false
+ }
+ }
+ if len(emitter.key_line_comment) > 0 {
+ // [Go] Line comments are generally associated with the value, but when there's
+ // no value on the same line as a mapping key they end up attached to the
+ // key itself.
+ if event.typ == yaml_SCALAR_EVENT {
+ if len(emitter.line_comment) == 0 {
+ // A scalar is coming and it has no line comments by itself yet,
+ // so just let it handle the line comment as usual. If it has a
+ // line comment, we can't have both so the one from the key is lost.
+ emitter.line_comment = emitter.key_line_comment
+ emitter.key_line_comment = nil
+ }
+ } else if event.sequence_style() != yaml_FLOW_SEQUENCE_STYLE && (event.typ == yaml_MAPPING_START_EVENT || event.typ == yaml_SEQUENCE_START_EVENT) {
+ // An indented block follows, so write the comment right now.
+ emitter.line_comment, emitter.key_line_comment = emitter.key_line_comment, emitter.line_comment
+ if !yaml_emitter_process_line_comment(emitter) {
+ return false
+ }
+ emitter.line_comment, emitter.key_line_comment = emitter.key_line_comment, emitter.line_comment
+ }
+ }
+ emitter.states = append(emitter.states, yaml_EMIT_BLOCK_MAPPING_KEY_STATE)
+ if !yaml_emitter_emit_node(emitter, event, false, false, true, false) {
+ return false
+ }
+ if !yaml_emitter_process_line_comment(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_foot_comment(emitter) {
+ return false
+ }
+ return true
+}
+
+func yaml_emitter_silent_nil_event(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ return event.typ == yaml_SCALAR_EVENT && event.implicit && !emitter.canonical && len(emitter.scalar_data.value) == 0
+}
+
+// Expect a node.
+func yaml_emitter_emit_node(emitter *yaml_emitter_t, event *yaml_event_t,
+ root bool, sequence bool, mapping bool, simple_key bool) bool {
+
+ emitter.root_context = root
+ emitter.sequence_context = sequence
+ emitter.mapping_context = mapping
+ emitter.simple_key_context = simple_key
+
+ switch event.typ {
+ case yaml_ALIAS_EVENT:
+ return yaml_emitter_emit_alias(emitter, event)
+ case yaml_SCALAR_EVENT:
+ return yaml_emitter_emit_scalar(emitter, event)
+ case yaml_SEQUENCE_START_EVENT:
+ return yaml_emitter_emit_sequence_start(emitter, event)
+ case yaml_MAPPING_START_EVENT:
+ return yaml_emitter_emit_mapping_start(emitter, event)
+ default:
+ return yaml_emitter_set_emitter_error(emitter,
+ fmt.Sprintf("expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, but got %v", event.typ))
+ }
+}
+
+// Expect ALIAS.
+func yaml_emitter_emit_alias(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ if !yaml_emitter_process_anchor(emitter) {
+ return false
+ }
+ emitter.state = emitter.states[len(emitter.states)-1]
+ emitter.states = emitter.states[:len(emitter.states)-1]
+ return true
+}
+
+// Expect SCALAR.
+func yaml_emitter_emit_scalar(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ if !yaml_emitter_select_scalar_style(emitter, event) {
+ return false
+ }
+ if !yaml_emitter_process_anchor(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_tag(emitter) {
+ return false
+ }
+ if !yaml_emitter_increase_indent(emitter, true, false) {
+ return false
+ }
+ if !yaml_emitter_process_scalar(emitter) {
+ return false
+ }
+ emitter.indent = emitter.indents[len(emitter.indents)-1]
+ emitter.indents = emitter.indents[:len(emitter.indents)-1]
+ emitter.state = emitter.states[len(emitter.states)-1]
+ emitter.states = emitter.states[:len(emitter.states)-1]
+ return true
+}
+
+// Expect SEQUENCE-START.
+func yaml_emitter_emit_sequence_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ if !yaml_emitter_process_anchor(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_tag(emitter) {
+ return false
+ }
+ if emitter.flow_level > 0 || emitter.canonical || event.sequence_style() == yaml_FLOW_SEQUENCE_STYLE ||
+ yaml_emitter_check_empty_sequence(emitter) {
+ emitter.state = yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE
+ } else {
+ emitter.state = yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE
+ }
+ return true
+}
+
+// Expect MAPPING-START.
+func yaml_emitter_emit_mapping_start(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+ if !yaml_emitter_process_anchor(emitter) {
+ return false
+ }
+ if !yaml_emitter_process_tag(emitter) {
+ return false
+ }
+ if emitter.flow_level > 0 || emitter.canonical || event.mapping_style() == yaml_FLOW_MAPPING_STYLE ||
+ yaml_emitter_check_empty_mapping(emitter) {
+ emitter.state = yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE
+ } else {
+ emitter.state = yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE
+ }
+ return true
+}
+
+// Check if the document content is an empty scalar.
+func yaml_emitter_check_empty_document(emitter *yaml_emitter_t) bool {
+ return false // [Go] Huh?
+}
+
+// Check if the next events represent an empty sequence.
+func yaml_emitter_check_empty_sequence(emitter *yaml_emitter_t) bool {
+ if len(emitter.events)-emitter.events_head < 2 {
+ return false
+ }
+ return emitter.events[emitter.events_head].typ == yaml_SEQUENCE_START_EVENT &&
+ emitter.events[emitter.events_head+1].typ == yaml_SEQUENCE_END_EVENT
+}
+
+// Check if the next events represent an empty mapping.
+func yaml_emitter_check_empty_mapping(emitter *yaml_emitter_t) bool {
+ if len(emitter.events)-emitter.events_head < 2 {
+ return false
+ }
+ return emitter.events[emitter.events_head].typ == yaml_MAPPING_START_EVENT &&
+ emitter.events[emitter.events_head+1].typ == yaml_MAPPING_END_EVENT
+}
+
+// Check if the next node can be expressed as a simple key.
+func yaml_emitter_check_simple_key(emitter *yaml_emitter_t) bool {
+ length := 0
+ switch emitter.events[emitter.events_head].typ {
+ case yaml_ALIAS_EVENT:
+ length += len(emitter.anchor_data.anchor)
+ case yaml_SCALAR_EVENT:
+ if emitter.scalar_data.multiline {
+ return false
+ }
+ length += len(emitter.anchor_data.anchor) +
+ len(emitter.tag_data.handle) +
+ len(emitter.tag_data.suffix) +
+ len(emitter.scalar_data.value)
+ case yaml_SEQUENCE_START_EVENT:
+ if !yaml_emitter_check_empty_sequence(emitter) {
+ return false
+ }
+ length += len(emitter.anchor_data.anchor) +
+ len(emitter.tag_data.handle) +
+ len(emitter.tag_data.suffix)
+ case yaml_MAPPING_START_EVENT:
+ if !yaml_emitter_check_empty_mapping(emitter) {
+ return false
+ }
+ length += len(emitter.anchor_data.anchor) +
+ len(emitter.tag_data.handle) +
+ len(emitter.tag_data.suffix)
+ default:
+ return false
+ }
+ return length <= 128
+}
+
+// Determine an acceptable scalar style.
+func yaml_emitter_select_scalar_style(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+
+ no_tag := len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0
+ if no_tag && !event.implicit && !event.quoted_implicit {
+ return yaml_emitter_set_emitter_error(emitter, "neither tag nor implicit flags are specified")
+ }
+
+ style := event.scalar_style()
+ if style == yaml_ANY_SCALAR_STYLE {
+ style = yaml_PLAIN_SCALAR_STYLE
+ }
+ if emitter.canonical {
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+ if emitter.simple_key_context && emitter.scalar_data.multiline {
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+
+ if style == yaml_PLAIN_SCALAR_STYLE {
+ if emitter.flow_level > 0 && !emitter.scalar_data.flow_plain_allowed ||
+ emitter.flow_level == 0 && !emitter.scalar_data.block_plain_allowed {
+ style = yaml_SINGLE_QUOTED_SCALAR_STYLE
+ }
+ if len(emitter.scalar_data.value) == 0 && (emitter.flow_level > 0 || emitter.simple_key_context) {
+ style = yaml_SINGLE_QUOTED_SCALAR_STYLE
+ }
+ if no_tag && !event.implicit {
+ style = yaml_SINGLE_QUOTED_SCALAR_STYLE
+ }
+ }
+ if style == yaml_SINGLE_QUOTED_SCALAR_STYLE {
+ if !emitter.scalar_data.single_quoted_allowed {
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+ }
+ if style == yaml_LITERAL_SCALAR_STYLE || style == yaml_FOLDED_SCALAR_STYLE {
+ if !emitter.scalar_data.block_allowed || emitter.flow_level > 0 || emitter.simple_key_context {
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+ }
+
+ if no_tag && !event.quoted_implicit && style != yaml_PLAIN_SCALAR_STYLE {
+ emitter.tag_data.handle = []byte{'!'}
+ }
+ emitter.scalar_data.style = style
+ return true
+}
+
+// Write an anchor.
+func yaml_emitter_process_anchor(emitter *yaml_emitter_t) bool {
+ if emitter.anchor_data.anchor == nil {
+ return true
+ }
+ c := []byte{'&'}
+ if emitter.anchor_data.alias {
+ c[0] = '*'
+ }
+ if !yaml_emitter_write_indicator(emitter, c, true, false, false) {
+ return false
+ }
+ return yaml_emitter_write_anchor(emitter, emitter.anchor_data.anchor)
+}
+
+// Write a tag.
+func yaml_emitter_process_tag(emitter *yaml_emitter_t) bool {
+ if len(emitter.tag_data.handle) == 0 && len(emitter.tag_data.suffix) == 0 {
+ return true
+ }
+ if len(emitter.tag_data.handle) > 0 {
+ if !yaml_emitter_write_tag_handle(emitter, emitter.tag_data.handle) {
+ return false
+ }
+ if len(emitter.tag_data.suffix) > 0 {
+ if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
+ return false
+ }
+ }
+ } else {
+ // [Go] Allocate these slices elsewhere.
+ if !yaml_emitter_write_indicator(emitter, []byte("!<"), true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_tag_content(emitter, emitter.tag_data.suffix, false) {
+ return false
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'>'}, false, false, false) {
+ return false
+ }
+ }
+ return true
+}
+
+// Write a scalar.
+func yaml_emitter_process_scalar(emitter *yaml_emitter_t) bool {
+ switch emitter.scalar_data.style {
+ case yaml_PLAIN_SCALAR_STYLE:
+ return yaml_emitter_write_plain_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
+
+ case yaml_SINGLE_QUOTED_SCALAR_STYLE:
+ return yaml_emitter_write_single_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
+
+ case yaml_DOUBLE_QUOTED_SCALAR_STYLE:
+ return yaml_emitter_write_double_quoted_scalar(emitter, emitter.scalar_data.value, !emitter.simple_key_context)
+
+ case yaml_LITERAL_SCALAR_STYLE:
+ return yaml_emitter_write_literal_scalar(emitter, emitter.scalar_data.value)
+
+ case yaml_FOLDED_SCALAR_STYLE:
+ return yaml_emitter_write_folded_scalar(emitter, emitter.scalar_data.value)
+ }
+ panic("unknown scalar style")
+}
+
+// Write a head comment.
+func yaml_emitter_process_head_comment(emitter *yaml_emitter_t) bool {
+ if len(emitter.tail_comment) > 0 {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if !yaml_emitter_write_comment(emitter, emitter.tail_comment) {
+ return false
+ }
+ emitter.tail_comment = emitter.tail_comment[:0]
+ emitter.foot_indent = emitter.indent
+ if emitter.foot_indent < 0 {
+ emitter.foot_indent = 0
+ }
+ }
+
+ if len(emitter.head_comment) == 0 {
+ return true
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if !yaml_emitter_write_comment(emitter, emitter.head_comment) {
+ return false
+ }
+ emitter.head_comment = emitter.head_comment[:0]
+ return true
+}
+
+// Write an line comment.
+func yaml_emitter_process_line_comment_linebreak(emitter *yaml_emitter_t, linebreak bool) bool {
+ if len(emitter.line_comment) == 0 {
+ // The next 3 lines are needed to resolve an issue with leading newlines
+ // See https://github.com/go-yaml/yaml/issues/755
+ // When linebreak is set to true, put_break will be called and will add
+ // the needed newline.
+ if linebreak && !put_break(emitter) {
+ return false
+ }
+ return true
+ }
+ if !emitter.whitespace {
+ if !put(emitter, ' ') {
+ return false
+ }
+ }
+ if !yaml_emitter_write_comment(emitter, emitter.line_comment) {
+ return false
+ }
+ emitter.line_comment = emitter.line_comment[:0]
+ return true
+}
+
+// Write a foot comment.
+func yaml_emitter_process_foot_comment(emitter *yaml_emitter_t) bool {
+ if len(emitter.foot_comment) == 0 {
+ return true
+ }
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if !yaml_emitter_write_comment(emitter, emitter.foot_comment) {
+ return false
+ }
+ emitter.foot_comment = emitter.foot_comment[:0]
+ emitter.foot_indent = emitter.indent
+ if emitter.foot_indent < 0 {
+ emitter.foot_indent = 0
+ }
+ return true
+}
+
+// Check if a %YAML directive is valid.
+func yaml_emitter_analyze_version_directive(emitter *yaml_emitter_t, version_directive *yaml_version_directive_t) bool {
+ if version_directive.major != 1 || version_directive.minor != 1 {
+ return yaml_emitter_set_emitter_error(emitter, "incompatible %YAML directive")
+ }
+ return true
+}
+
+// Check if a %TAG directive is valid.
+func yaml_emitter_analyze_tag_directive(emitter *yaml_emitter_t, tag_directive *yaml_tag_directive_t) bool {
+ handle := tag_directive.handle
+ prefix := tag_directive.prefix
+ if len(handle) == 0 {
+ return yaml_emitter_set_emitter_error(emitter, "tag handle must not be empty")
+ }
+ if handle[0] != '!' {
+ return yaml_emitter_set_emitter_error(emitter, "tag handle must start with '!'")
+ }
+ if handle[len(handle)-1] != '!' {
+ return yaml_emitter_set_emitter_error(emitter, "tag handle must end with '!'")
+ }
+ for i := 1; i < len(handle)-1; i += width(handle[i]) {
+ if !is_alpha(handle, i) {
+ return yaml_emitter_set_emitter_error(emitter, "tag handle must contain alphanumerical characters only")
+ }
+ }
+ if len(prefix) == 0 {
+ return yaml_emitter_set_emitter_error(emitter, "tag prefix must not be empty")
+ }
+ return true
+}
+
+// Check if an anchor is valid.
+func yaml_emitter_analyze_anchor(emitter *yaml_emitter_t, anchor []byte, alias bool) bool {
+ if len(anchor) == 0 {
+ problem := "anchor value must not be empty"
+ if alias {
+ problem = "alias value must not be empty"
+ }
+ return yaml_emitter_set_emitter_error(emitter, problem)
+ }
+ for i := 0; i < len(anchor); i += width(anchor[i]) {
+ if !is_alpha(anchor, i) {
+ problem := "anchor value must contain alphanumerical characters only"
+ if alias {
+ problem = "alias value must contain alphanumerical characters only"
+ }
+ return yaml_emitter_set_emitter_error(emitter, problem)
+ }
+ }
+ emitter.anchor_data.anchor = anchor
+ emitter.anchor_data.alias = alias
+ return true
+}
+
+// Check if a tag is valid.
+func yaml_emitter_analyze_tag(emitter *yaml_emitter_t, tag []byte) bool {
+ if len(tag) == 0 {
+ return yaml_emitter_set_emitter_error(emitter, "tag value must not be empty")
+ }
+ for i := 0; i < len(emitter.tag_directives); i++ {
+ tag_directive := &emitter.tag_directives[i]
+ if bytes.HasPrefix(tag, tag_directive.prefix) {
+ emitter.tag_data.handle = tag_directive.handle
+ emitter.tag_data.suffix = tag[len(tag_directive.prefix):]
+ return true
+ }
+ }
+ emitter.tag_data.suffix = tag
+ return true
+}
+
+// Check if a scalar is valid.
+func yaml_emitter_analyze_scalar(emitter *yaml_emitter_t, value []byte) bool {
+ var (
+ block_indicators = false
+ flow_indicators = false
+ line_breaks = false
+ special_characters = false
+ tab_characters = false
+
+ leading_space = false
+ leading_break = false
+ trailing_space = false
+ trailing_break = false
+ break_space = false
+ space_break = false
+
+ preceded_by_whitespace = false
+ followed_by_whitespace = false
+ previous_space = false
+ previous_break = false
+ )
+
+ emitter.scalar_data.value = value
+
+ if len(value) == 0 {
+ emitter.scalar_data.multiline = false
+ emitter.scalar_data.flow_plain_allowed = false
+ emitter.scalar_data.block_plain_allowed = true
+ emitter.scalar_data.single_quoted_allowed = true
+ emitter.scalar_data.block_allowed = false
+ return true
+ }
+
+ if len(value) >= 3 && ((value[0] == '-' && value[1] == '-' && value[2] == '-') || (value[0] == '.' && value[1] == '.' && value[2] == '.')) {
+ block_indicators = true
+ flow_indicators = true
+ }
+
+ preceded_by_whitespace = true
+ for i, w := 0, 0; i < len(value); i += w {
+ w = width(value[i])
+ followed_by_whitespace = i+w >= len(value) || is_blank(value, i+w)
+
+ if i == 0 {
+ switch value[i] {
+ case '#', ',', '[', ']', '{', '}', '&', '*', '!', '|', '>', '\'', '"', '%', '@', '`':
+ flow_indicators = true
+ block_indicators = true
+ case '?', ':':
+ flow_indicators = true
+ if followed_by_whitespace {
+ block_indicators = true
+ }
+ case '-':
+ if followed_by_whitespace {
+ flow_indicators = true
+ block_indicators = true
+ }
+ }
+ } else {
+ switch value[i] {
+ case ',', '?', '[', ']', '{', '}':
+ flow_indicators = true
+ case ':':
+ flow_indicators = true
+ if followed_by_whitespace {
+ block_indicators = true
+ }
+ case '#':
+ if preceded_by_whitespace {
+ flow_indicators = true
+ block_indicators = true
+ }
+ }
+ }
+
+ if value[i] == '\t' {
+ tab_characters = true
+ } else if !is_printable(value, i) || !is_ascii(value, i) && !emitter.unicode {
+ special_characters = true
+ }
+ if is_space(value, i) {
+ if i == 0 {
+ leading_space = true
+ }
+ if i+width(value[i]) == len(value) {
+ trailing_space = true
+ }
+ if previous_break {
+ break_space = true
+ }
+ previous_space = true
+ previous_break = false
+ } else if is_break(value, i) {
+ line_breaks = true
+ if i == 0 {
+ leading_break = true
+ }
+ if i+width(value[i]) == len(value) {
+ trailing_break = true
+ }
+ if previous_space {
+ space_break = true
+ }
+ previous_space = false
+ previous_break = true
+ } else {
+ previous_space = false
+ previous_break = false
+ }
+
+ // [Go]: Why 'z'? Couldn't be the end of the string as that's the loop condition.
+ preceded_by_whitespace = is_blankz(value, i)
+ }
+
+ emitter.scalar_data.multiline = line_breaks
+ emitter.scalar_data.flow_plain_allowed = true
+ emitter.scalar_data.block_plain_allowed = true
+ emitter.scalar_data.single_quoted_allowed = true
+ emitter.scalar_data.block_allowed = true
+
+ if leading_space || leading_break || trailing_space || trailing_break {
+ emitter.scalar_data.flow_plain_allowed = false
+ emitter.scalar_data.block_plain_allowed = false
+ }
+ if trailing_space {
+ emitter.scalar_data.block_allowed = false
+ }
+ if break_space {
+ emitter.scalar_data.flow_plain_allowed = false
+ emitter.scalar_data.block_plain_allowed = false
+ emitter.scalar_data.single_quoted_allowed = false
+ }
+ if space_break || tab_characters || special_characters {
+ emitter.scalar_data.flow_plain_allowed = false
+ emitter.scalar_data.block_plain_allowed = false
+ emitter.scalar_data.single_quoted_allowed = false
+ }
+ if space_break || special_characters {
+ emitter.scalar_data.block_allowed = false
+ }
+ if line_breaks {
+ emitter.scalar_data.flow_plain_allowed = false
+ emitter.scalar_data.block_plain_allowed = false
+ }
+ if flow_indicators {
+ emitter.scalar_data.flow_plain_allowed = false
+ }
+ if block_indicators {
+ emitter.scalar_data.block_plain_allowed = false
+ }
+ return true
+}
+
+// Check if the event data is valid.
+func yaml_emitter_analyze_event(emitter *yaml_emitter_t, event *yaml_event_t) bool {
+
+ emitter.anchor_data.anchor = nil
+ emitter.tag_data.handle = nil
+ emitter.tag_data.suffix = nil
+ emitter.scalar_data.value = nil
+
+ if len(event.head_comment) > 0 {
+ emitter.head_comment = event.head_comment
+ }
+ if len(event.line_comment) > 0 {
+ emitter.line_comment = event.line_comment
+ }
+ if len(event.foot_comment) > 0 {
+ emitter.foot_comment = event.foot_comment
+ }
+ if len(event.tail_comment) > 0 {
+ emitter.tail_comment = event.tail_comment
+ }
+
+ switch event.typ {
+ case yaml_ALIAS_EVENT:
+ if !yaml_emitter_analyze_anchor(emitter, event.anchor, true) {
+ return false
+ }
+
+ case yaml_SCALAR_EVENT:
+ if len(event.anchor) > 0 {
+ if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
+ return false
+ }
+ }
+ if len(event.tag) > 0 && (emitter.canonical || (!event.implicit && !event.quoted_implicit)) {
+ if !yaml_emitter_analyze_tag(emitter, event.tag) {
+ return false
+ }
+ }
+ if !yaml_emitter_analyze_scalar(emitter, event.value) {
+ return false
+ }
+
+ case yaml_SEQUENCE_START_EVENT:
+ if len(event.anchor) > 0 {
+ if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
+ return false
+ }
+ }
+ if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
+ if !yaml_emitter_analyze_tag(emitter, event.tag) {
+ return false
+ }
+ }
+
+ case yaml_MAPPING_START_EVENT:
+ if len(event.anchor) > 0 {
+ if !yaml_emitter_analyze_anchor(emitter, event.anchor, false) {
+ return false
+ }
+ }
+ if len(event.tag) > 0 && (emitter.canonical || !event.implicit) {
+ if !yaml_emitter_analyze_tag(emitter, event.tag) {
+ return false
+ }
+ }
+ }
+ return true
+}
+
+// Write the BOM character.
+func yaml_emitter_write_bom(emitter *yaml_emitter_t) bool {
+ if !flush(emitter) {
+ return false
+ }
+ pos := emitter.buffer_pos
+ emitter.buffer[pos+0] = '\xEF'
+ emitter.buffer[pos+1] = '\xBB'
+ emitter.buffer[pos+2] = '\xBF'
+ emitter.buffer_pos += 3
+ return true
+}
+
+func yaml_emitter_write_indent(emitter *yaml_emitter_t) bool {
+ indent := emitter.indent
+ if indent < 0 {
+ indent = 0
+ }
+ if !emitter.indention || emitter.column > indent || (emitter.column == indent && !emitter.whitespace) {
+ if !put_break(emitter) {
+ return false
+ }
+ }
+ if emitter.foot_indent == indent {
+ if !put_break(emitter) {
+ return false
+ }
+ }
+ for emitter.column < indent {
+ if !put(emitter, ' ') {
+ return false
+ }
+ }
+ emitter.whitespace = true
+ //emitter.indention = true
+ emitter.space_above = false
+ emitter.foot_indent = -1
+ return true
+}
+
+func yaml_emitter_write_indicator(emitter *yaml_emitter_t, indicator []byte, need_whitespace, is_whitespace, is_indention bool) bool {
+ if need_whitespace && !emitter.whitespace {
+ if !put(emitter, ' ') {
+ return false
+ }
+ }
+ if !write_all(emitter, indicator) {
+ return false
+ }
+ emitter.whitespace = is_whitespace
+ emitter.indention = (emitter.indention && is_indention)
+ emitter.open_ended = false
+ return true
+}
+
+func yaml_emitter_write_anchor(emitter *yaml_emitter_t, value []byte) bool {
+ if !write_all(emitter, value) {
+ return false
+ }
+ emitter.whitespace = false
+ emitter.indention = false
+ return true
+}
+
+func yaml_emitter_write_tag_handle(emitter *yaml_emitter_t, value []byte) bool {
+ if !emitter.whitespace {
+ if !put(emitter, ' ') {
+ return false
+ }
+ }
+ if !write_all(emitter, value) {
+ return false
+ }
+ emitter.whitespace = false
+ emitter.indention = false
+ return true
+}
+
+func yaml_emitter_write_tag_content(emitter *yaml_emitter_t, value []byte, need_whitespace bool) bool {
+ if need_whitespace && !emitter.whitespace {
+ if !put(emitter, ' ') {
+ return false
+ }
+ }
+ for i := 0; i < len(value); {
+ var must_write bool
+ switch value[i] {
+ case ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '_', '.', '~', '*', '\'', '(', ')', '[', ']':
+ must_write = true
+ default:
+ must_write = is_alpha(value, i)
+ }
+ if must_write {
+ if !write(emitter, value, &i) {
+ return false
+ }
+ } else {
+ w := width(value[i])
+ for k := 0; k < w; k++ {
+ octet := value[i]
+ i++
+ if !put(emitter, '%') {
+ return false
+ }
+
+ c := octet >> 4
+ if c < 10 {
+ c += '0'
+ } else {
+ c += 'A' - 10
+ }
+ if !put(emitter, c) {
+ return false
+ }
+
+ c = octet & 0x0f
+ if c < 10 {
+ c += '0'
+ } else {
+ c += 'A' - 10
+ }
+ if !put(emitter, c) {
+ return false
+ }
+ }
+ }
+ }
+ emitter.whitespace = false
+ emitter.indention = false
+ return true
+}
+
+func yaml_emitter_write_plain_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
+ if len(value) > 0 && !emitter.whitespace {
+ if !put(emitter, ' ') {
+ return false
+ }
+ }
+
+ spaces := false
+ breaks := false
+ for i := 0; i < len(value); {
+ if is_space(value, i) {
+ if allow_breaks && !spaces && emitter.column > emitter.best_width && !is_space(value, i+1) {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ i += width(value[i])
+ } else {
+ if !write(emitter, value, &i) {
+ return false
+ }
+ }
+ spaces = true
+ } else if is_break(value, i) {
+ if !breaks && value[i] == '\n' {
+ if !put_break(emitter) {
+ return false
+ }
+ }
+ if !write_break(emitter, value, &i) {
+ return false
+ }
+ //emitter.indention = true
+ breaks = true
+ } else {
+ if breaks {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !write(emitter, value, &i) {
+ return false
+ }
+ emitter.indention = false
+ spaces = false
+ breaks = false
+ }
+ }
+
+ if len(value) > 0 {
+ emitter.whitespace = false
+ }
+ emitter.indention = false
+ if emitter.root_context {
+ emitter.open_ended = true
+ }
+
+ return true
+}
+
+func yaml_emitter_write_single_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
+
+ if !yaml_emitter_write_indicator(emitter, []byte{'\''}, true, false, false) {
+ return false
+ }
+
+ spaces := false
+ breaks := false
+ for i := 0; i < len(value); {
+ if is_space(value, i) {
+ if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 && !is_space(value, i+1) {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ i += width(value[i])
+ } else {
+ if !write(emitter, value, &i) {
+ return false
+ }
+ }
+ spaces = true
+ } else if is_break(value, i) {
+ if !breaks && value[i] == '\n' {
+ if !put_break(emitter) {
+ return false
+ }
+ }
+ if !write_break(emitter, value, &i) {
+ return false
+ }
+ //emitter.indention = true
+ breaks = true
+ } else {
+ if breaks {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if value[i] == '\'' {
+ if !put(emitter, '\'') {
+ return false
+ }
+ }
+ if !write(emitter, value, &i) {
+ return false
+ }
+ emitter.indention = false
+ spaces = false
+ breaks = false
+ }
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'\''}, false, false, false) {
+ return false
+ }
+ emitter.whitespace = false
+ emitter.indention = false
+ return true
+}
+
+func yaml_emitter_write_double_quoted_scalar(emitter *yaml_emitter_t, value []byte, allow_breaks bool) bool {
+ spaces := false
+ if !yaml_emitter_write_indicator(emitter, []byte{'"'}, true, false, false) {
+ return false
+ }
+
+ for i := 0; i < len(value); {
+ if !is_printable(value, i) || (!emitter.unicode && !is_ascii(value, i)) ||
+ is_bom(value, i) || is_break(value, i) ||
+ value[i] == '"' || value[i] == '\\' {
+
+ octet := value[i]
+
+ var w int
+ var v rune
+ switch {
+ case octet&0x80 == 0x00:
+ w, v = 1, rune(octet&0x7F)
+ case octet&0xE0 == 0xC0:
+ w, v = 2, rune(octet&0x1F)
+ case octet&0xF0 == 0xE0:
+ w, v = 3, rune(octet&0x0F)
+ case octet&0xF8 == 0xF0:
+ w, v = 4, rune(octet&0x07)
+ }
+ for k := 1; k < w; k++ {
+ octet = value[i+k]
+ v = (v << 6) + (rune(octet) & 0x3F)
+ }
+ i += w
+
+ if !put(emitter, '\\') {
+ return false
+ }
+
+ var ok bool
+ switch v {
+ case 0x00:
+ ok = put(emitter, '0')
+ case 0x07:
+ ok = put(emitter, 'a')
+ case 0x08:
+ ok = put(emitter, 'b')
+ case 0x09:
+ ok = put(emitter, 't')
+ case 0x0A:
+ ok = put(emitter, 'n')
+ case 0x0b:
+ ok = put(emitter, 'v')
+ case 0x0c:
+ ok = put(emitter, 'f')
+ case 0x0d:
+ ok = put(emitter, 'r')
+ case 0x1b:
+ ok = put(emitter, 'e')
+ case 0x22:
+ ok = put(emitter, '"')
+ case 0x5c:
+ ok = put(emitter, '\\')
+ case 0x85:
+ ok = put(emitter, 'N')
+ case 0xA0:
+ ok = put(emitter, '_')
+ case 0x2028:
+ ok = put(emitter, 'L')
+ case 0x2029:
+ ok = put(emitter, 'P')
+ default:
+ if v <= 0xFF {
+ ok = put(emitter, 'x')
+ w = 2
+ } else if v <= 0xFFFF {
+ ok = put(emitter, 'u')
+ w = 4
+ } else {
+ ok = put(emitter, 'U')
+ w = 8
+ }
+ for k := (w - 1) * 4; ok && k >= 0; k -= 4 {
+ digit := byte((v >> uint(k)) & 0x0F)
+ if digit < 10 {
+ ok = put(emitter, digit+'0')
+ } else {
+ ok = put(emitter, digit+'A'-10)
+ }
+ }
+ }
+ if !ok {
+ return false
+ }
+ spaces = false
+ } else if is_space(value, i) {
+ if allow_breaks && !spaces && emitter.column > emitter.best_width && i > 0 && i < len(value)-1 {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if is_space(value, i+1) {
+ if !put(emitter, '\\') {
+ return false
+ }
+ }
+ i += width(value[i])
+ } else if !write(emitter, value, &i) {
+ return false
+ }
+ spaces = true
+ } else {
+ if !write(emitter, value, &i) {
+ return false
+ }
+ spaces = false
+ }
+ }
+ if !yaml_emitter_write_indicator(emitter, []byte{'"'}, false, false, false) {
+ return false
+ }
+ emitter.whitespace = false
+ emitter.indention = false
+ return true
+}
+
+func yaml_emitter_write_block_scalar_hints(emitter *yaml_emitter_t, value []byte) bool {
+ if is_space(value, 0) || is_break(value, 0) {
+ indent_hint := []byte{'0' + byte(emitter.best_indent)}
+ if !yaml_emitter_write_indicator(emitter, indent_hint, false, false, false) {
+ return false
+ }
+ }
+
+ emitter.open_ended = false
+
+ var chomp_hint [1]byte
+ if len(value) == 0 {
+ chomp_hint[0] = '-'
+ } else {
+ i := len(value) - 1
+ for value[i]&0xC0 == 0x80 {
+ i--
+ }
+ if !is_break(value, i) {
+ chomp_hint[0] = '-'
+ } else if i == 0 {
+ chomp_hint[0] = '+'
+ emitter.open_ended = true
+ } else {
+ i--
+ for value[i]&0xC0 == 0x80 {
+ i--
+ }
+ if is_break(value, i) {
+ chomp_hint[0] = '+'
+ emitter.open_ended = true
+ }
+ }
+ }
+ if chomp_hint[0] != 0 {
+ if !yaml_emitter_write_indicator(emitter, chomp_hint[:], false, false, false) {
+ return false
+ }
+ }
+ return true
+}
+
+func yaml_emitter_write_literal_scalar(emitter *yaml_emitter_t, value []byte) bool {
+ if !yaml_emitter_write_indicator(emitter, []byte{'|'}, true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_block_scalar_hints(emitter, value) {
+ return false
+ }
+ if !yaml_emitter_process_line_comment_linebreak(emitter, true) {
+ return false
+ }
+ //emitter.indention = true
+ emitter.whitespace = true
+ breaks := true
+ for i := 0; i < len(value); {
+ if is_break(value, i) {
+ if !write_break(emitter, value, &i) {
+ return false
+ }
+ //emitter.indention = true
+ breaks = true
+ } else {
+ if breaks {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ }
+ if !write(emitter, value, &i) {
+ return false
+ }
+ emitter.indention = false
+ breaks = false
+ }
+ }
+
+ return true
+}
+
+func yaml_emitter_write_folded_scalar(emitter *yaml_emitter_t, value []byte) bool {
+ if !yaml_emitter_write_indicator(emitter, []byte{'>'}, true, false, false) {
+ return false
+ }
+ if !yaml_emitter_write_block_scalar_hints(emitter, value) {
+ return false
+ }
+ if !yaml_emitter_process_line_comment_linebreak(emitter, true) {
+ return false
+ }
+
+ //emitter.indention = true
+ emitter.whitespace = true
+
+ breaks := true
+ leading_spaces := true
+ for i := 0; i < len(value); {
+ if is_break(value, i) {
+ if !breaks && !leading_spaces && value[i] == '\n' {
+ k := 0
+ for is_break(value, k) {
+ k += width(value[k])
+ }
+ if !is_blankz(value, k) {
+ if !put_break(emitter) {
+ return false
+ }
+ }
+ }
+ if !write_break(emitter, value, &i) {
+ return false
+ }
+ //emitter.indention = true
+ breaks = true
+ } else {
+ if breaks {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ leading_spaces = is_blank(value, i)
+ }
+ if !breaks && is_space(value, i) && !is_space(value, i+1) && emitter.column > emitter.best_width {
+ if !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ i += width(value[i])
+ } else {
+ if !write(emitter, value, &i) {
+ return false
+ }
+ }
+ emitter.indention = false
+ breaks = false
+ }
+ }
+ return true
+}
+
+func yaml_emitter_write_comment(emitter *yaml_emitter_t, comment []byte) bool {
+ breaks := false
+ pound := false
+ for i := 0; i < len(comment); {
+ if is_break(comment, i) {
+ if !write_break(emitter, comment, &i) {
+ return false
+ }
+ //emitter.indention = true
+ breaks = true
+ pound = false
+ } else {
+ if breaks && !yaml_emitter_write_indent(emitter) {
+ return false
+ }
+ if !pound {
+ if comment[i] != '#' && (!put(emitter, '#') || !put(emitter, ' ')) {
+ return false
+ }
+ pound = true
+ }
+ if !write(emitter, comment, &i) {
+ return false
+ }
+ emitter.indention = false
+ breaks = false
+ }
+ }
+ if !breaks && !put_break(emitter) {
+ return false
+ }
+
+ emitter.whitespace = true
+ //emitter.indention = true
+ return true
+}
diff --git a/vendor/go.yaml.in/yaml/v3/encode.go b/vendor/go.yaml.in/yaml/v3/encode.go
new file mode 100644
index 00000000..de9e72a3
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/encode.go
@@ -0,0 +1,577 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package yaml
+
+import (
+ "encoding"
+ "fmt"
+ "io"
+ "reflect"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+ "time"
+ "unicode/utf8"
+)
+
+type encoder struct {
+ emitter yaml_emitter_t
+ event yaml_event_t
+ out []byte
+ flow bool
+ indent int
+ doneInit bool
+}
+
+func newEncoder() *encoder {
+ e := &encoder{}
+ yaml_emitter_initialize(&e.emitter)
+ yaml_emitter_set_output_string(&e.emitter, &e.out)
+ yaml_emitter_set_unicode(&e.emitter, true)
+ return e
+}
+
+func newEncoderWithWriter(w io.Writer) *encoder {
+ e := &encoder{}
+ yaml_emitter_initialize(&e.emitter)
+ yaml_emitter_set_output_writer(&e.emitter, w)
+ yaml_emitter_set_unicode(&e.emitter, true)
+ return e
+}
+
+func (e *encoder) init() {
+ if e.doneInit {
+ return
+ }
+ if e.indent == 0 {
+ e.indent = 4
+ }
+ e.emitter.best_indent = e.indent
+ yaml_stream_start_event_initialize(&e.event, yaml_UTF8_ENCODING)
+ e.emit()
+ e.doneInit = true
+}
+
+func (e *encoder) finish() {
+ e.emitter.open_ended = false
+ yaml_stream_end_event_initialize(&e.event)
+ e.emit()
+}
+
+func (e *encoder) destroy() {
+ yaml_emitter_delete(&e.emitter)
+}
+
+func (e *encoder) emit() {
+ // This will internally delete the e.event value.
+ e.must(yaml_emitter_emit(&e.emitter, &e.event))
+}
+
+func (e *encoder) must(ok bool) {
+ if !ok {
+ msg := e.emitter.problem
+ if msg == "" {
+ msg = "unknown problem generating YAML content"
+ }
+ failf("%s", msg)
+ }
+}
+
+func (e *encoder) marshalDoc(tag string, in reflect.Value) {
+ e.init()
+ var node *Node
+ if in.IsValid() {
+ node, _ = in.Interface().(*Node)
+ }
+ if node != nil && node.Kind == DocumentNode {
+ e.nodev(in)
+ } else {
+ yaml_document_start_event_initialize(&e.event, nil, nil, true)
+ e.emit()
+ e.marshal(tag, in)
+ yaml_document_end_event_initialize(&e.event, true)
+ e.emit()
+ }
+}
+
+func (e *encoder) marshal(tag string, in reflect.Value) {
+ tag = shortTag(tag)
+ if !in.IsValid() || in.Kind() == reflect.Ptr && in.IsNil() {
+ e.nilv()
+ return
+ }
+ iface := in.Interface()
+ switch value := iface.(type) {
+ case *Node:
+ e.nodev(in)
+ return
+ case Node:
+ if !in.CanAddr() {
+ var n = reflect.New(in.Type()).Elem()
+ n.Set(in)
+ in = n
+ }
+ e.nodev(in.Addr())
+ return
+ case time.Time:
+ e.timev(tag, in)
+ return
+ case *time.Time:
+ e.timev(tag, in.Elem())
+ return
+ case time.Duration:
+ e.stringv(tag, reflect.ValueOf(value.String()))
+ return
+ case Marshaler:
+ v, err := value.MarshalYAML()
+ if err != nil {
+ fail(err)
+ }
+ if v == nil {
+ e.nilv()
+ return
+ }
+ e.marshal(tag, reflect.ValueOf(v))
+ return
+ case encoding.TextMarshaler:
+ text, err := value.MarshalText()
+ if err != nil {
+ fail(err)
+ }
+ in = reflect.ValueOf(string(text))
+ case nil:
+ e.nilv()
+ return
+ }
+ switch in.Kind() {
+ case reflect.Interface:
+ e.marshal(tag, in.Elem())
+ case reflect.Map:
+ e.mapv(tag, in)
+ case reflect.Ptr:
+ e.marshal(tag, in.Elem())
+ case reflect.Struct:
+ e.structv(tag, in)
+ case reflect.Slice, reflect.Array:
+ e.slicev(tag, in)
+ case reflect.String:
+ e.stringv(tag, in)
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ e.intv(tag, in)
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ e.uintv(tag, in)
+ case reflect.Float32, reflect.Float64:
+ e.floatv(tag, in)
+ case reflect.Bool:
+ e.boolv(tag, in)
+ default:
+ panic("cannot marshal type: " + in.Type().String())
+ }
+}
+
+func (e *encoder) mapv(tag string, in reflect.Value) {
+ e.mappingv(tag, func() {
+ keys := keyList(in.MapKeys())
+ sort.Sort(keys)
+ for _, k := range keys {
+ e.marshal("", k)
+ e.marshal("", in.MapIndex(k))
+ }
+ })
+}
+
+func (e *encoder) fieldByIndex(v reflect.Value, index []int) (field reflect.Value) {
+ for _, num := range index {
+ for {
+ if v.Kind() == reflect.Ptr {
+ if v.IsNil() {
+ return reflect.Value{}
+ }
+ v = v.Elem()
+ continue
+ }
+ break
+ }
+ v = v.Field(num)
+ }
+ return v
+}
+
+func (e *encoder) structv(tag string, in reflect.Value) {
+ sinfo, err := getStructInfo(in.Type())
+ if err != nil {
+ panic(err)
+ }
+ e.mappingv(tag, func() {
+ for _, info := range sinfo.FieldsList {
+ var value reflect.Value
+ if info.Inline == nil {
+ value = in.Field(info.Num)
+ } else {
+ value = e.fieldByIndex(in, info.Inline)
+ if !value.IsValid() {
+ continue
+ }
+ }
+ if info.OmitEmpty && isZero(value) {
+ continue
+ }
+ e.marshal("", reflect.ValueOf(info.Key))
+ e.flow = info.Flow
+ e.marshal("", value)
+ }
+ if sinfo.InlineMap >= 0 {
+ m := in.Field(sinfo.InlineMap)
+ if m.Len() > 0 {
+ e.flow = false
+ keys := keyList(m.MapKeys())
+ sort.Sort(keys)
+ for _, k := range keys {
+ if _, found := sinfo.FieldsMap[k.String()]; found {
+ panic(fmt.Sprintf("cannot have key %q in inlined map: conflicts with struct field", k.String()))
+ }
+ e.marshal("", k)
+ e.flow = false
+ e.marshal("", m.MapIndex(k))
+ }
+ }
+ }
+ })
+}
+
+func (e *encoder) mappingv(tag string, f func()) {
+ implicit := tag == ""
+ style := yaml_BLOCK_MAPPING_STYLE
+ if e.flow {
+ e.flow = false
+ style = yaml_FLOW_MAPPING_STYLE
+ }
+ yaml_mapping_start_event_initialize(&e.event, nil, []byte(tag), implicit, style)
+ e.emit()
+ f()
+ yaml_mapping_end_event_initialize(&e.event)
+ e.emit()
+}
+
+func (e *encoder) slicev(tag string, in reflect.Value) {
+ implicit := tag == ""
+ style := yaml_BLOCK_SEQUENCE_STYLE
+ if e.flow {
+ e.flow = false
+ style = yaml_FLOW_SEQUENCE_STYLE
+ }
+ e.must(yaml_sequence_start_event_initialize(&e.event, nil, []byte(tag), implicit, style))
+ e.emit()
+ n := in.Len()
+ for i := 0; i < n; i++ {
+ e.marshal("", in.Index(i))
+ }
+ e.must(yaml_sequence_end_event_initialize(&e.event))
+ e.emit()
+}
+
+// isBase60 returns whether s is in base 60 notation as defined in YAML 1.1.
+//
+// The base 60 float notation in YAML 1.1 is a terrible idea and is unsupported
+// in YAML 1.2 and by this package, but these should be marshalled quoted for
+// the time being for compatibility with other parsers.
+func isBase60Float(s string) (result bool) {
+ // Fast path.
+ if s == "" {
+ return false
+ }
+ c := s[0]
+ if !(c == '+' || c == '-' || c >= '0' && c <= '9') || strings.IndexByte(s, ':') < 0 {
+ return false
+ }
+ // Do the full match.
+ return base60float.MatchString(s)
+}
+
+// From http://yaml.org/type/float.html, except the regular expression there
+// is bogus. In practice parsers do not enforce the "\.[0-9_]*" suffix.
+var base60float = regexp.MustCompile(`^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+(?:\.[0-9_]*)?$`)
+
+// isOldBool returns whether s is bool notation as defined in YAML 1.1.
+//
+// We continue to force strings that YAML 1.1 would interpret as booleans to be
+// rendered as quotes strings so that the marshalled output valid for YAML 1.1
+// parsing.
+func isOldBool(s string) (result bool) {
+ switch s {
+ case "y", "Y", "yes", "Yes", "YES", "on", "On", "ON",
+ "n", "N", "no", "No", "NO", "off", "Off", "OFF":
+ return true
+ default:
+ return false
+ }
+}
+
+func (e *encoder) stringv(tag string, in reflect.Value) {
+ var style yaml_scalar_style_t
+ s := in.String()
+ canUsePlain := true
+ switch {
+ case !utf8.ValidString(s):
+ if tag == binaryTag {
+ failf("explicitly tagged !!binary data must be base64-encoded")
+ }
+ if tag != "" {
+ failf("cannot marshal invalid UTF-8 data as %s", shortTag(tag))
+ }
+ // It can't be encoded directly as YAML so use a binary tag
+ // and encode it as base64.
+ tag = binaryTag
+ s = encodeBase64(s)
+ case tag == "":
+ // Check to see if it would resolve to a specific
+ // tag when encoded unquoted. If it doesn't,
+ // there's no need to quote it.
+ rtag, _ := resolve("", s)
+ canUsePlain = rtag == strTag && !(isBase60Float(s) || isOldBool(s))
+ }
+ // Note: it's possible for user code to emit invalid YAML
+ // if they explicitly specify a tag and a string containing
+ // text that's incompatible with that tag.
+ switch {
+ case strings.Contains(s, "\n"):
+ if e.flow {
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ } else {
+ style = yaml_LITERAL_SCALAR_STYLE
+ }
+ case canUsePlain:
+ style = yaml_PLAIN_SCALAR_STYLE
+ default:
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+ e.emitScalar(s, "", tag, style, nil, nil, nil, nil)
+}
+
+func (e *encoder) boolv(tag string, in reflect.Value) {
+ var s string
+ if in.Bool() {
+ s = "true"
+ } else {
+ s = "false"
+ }
+ e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
+}
+
+func (e *encoder) intv(tag string, in reflect.Value) {
+ s := strconv.FormatInt(in.Int(), 10)
+ e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
+}
+
+func (e *encoder) uintv(tag string, in reflect.Value) {
+ s := strconv.FormatUint(in.Uint(), 10)
+ e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
+}
+
+func (e *encoder) timev(tag string, in reflect.Value) {
+ t := in.Interface().(time.Time)
+ s := t.Format(time.RFC3339Nano)
+ e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
+}
+
+func (e *encoder) floatv(tag string, in reflect.Value) {
+ // Issue #352: When formatting, use the precision of the underlying value
+ precision := 64
+ if in.Kind() == reflect.Float32 {
+ precision = 32
+ }
+
+ s := strconv.FormatFloat(in.Float(), 'g', -1, precision)
+ switch s {
+ case "+Inf":
+ s = ".inf"
+ case "-Inf":
+ s = "-.inf"
+ case "NaN":
+ s = ".nan"
+ }
+ e.emitScalar(s, "", tag, yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
+}
+
+func (e *encoder) nilv() {
+ e.emitScalar("null", "", "", yaml_PLAIN_SCALAR_STYLE, nil, nil, nil, nil)
+}
+
+func (e *encoder) emitScalar(value, anchor, tag string, style yaml_scalar_style_t, head, line, foot, tail []byte) {
+ // TODO Kill this function. Replace all initialize calls by their underlining Go literals.
+ implicit := tag == ""
+ if !implicit {
+ tag = longTag(tag)
+ }
+ e.must(yaml_scalar_event_initialize(&e.event, []byte(anchor), []byte(tag), []byte(value), implicit, implicit, style))
+ e.event.head_comment = head
+ e.event.line_comment = line
+ e.event.foot_comment = foot
+ e.event.tail_comment = tail
+ e.emit()
+}
+
+func (e *encoder) nodev(in reflect.Value) {
+ e.node(in.Interface().(*Node), "")
+}
+
+func (e *encoder) node(node *Node, tail string) {
+ // Zero nodes behave as nil.
+ if node.Kind == 0 && node.IsZero() {
+ e.nilv()
+ return
+ }
+
+ // If the tag was not explicitly requested, and dropping it won't change the
+ // implicit tag of the value, don't include it in the presentation.
+ var tag = node.Tag
+ var stag = shortTag(tag)
+ var forceQuoting bool
+ if tag != "" && node.Style&TaggedStyle == 0 {
+ if node.Kind == ScalarNode {
+ if stag == strTag && node.Style&(SingleQuotedStyle|DoubleQuotedStyle|LiteralStyle|FoldedStyle) != 0 {
+ tag = ""
+ } else {
+ rtag, _ := resolve("", node.Value)
+ if rtag == stag {
+ tag = ""
+ } else if stag == strTag {
+ tag = ""
+ forceQuoting = true
+ }
+ }
+ } else {
+ var rtag string
+ switch node.Kind {
+ case MappingNode:
+ rtag = mapTag
+ case SequenceNode:
+ rtag = seqTag
+ }
+ if rtag == stag {
+ tag = ""
+ }
+ }
+ }
+
+ switch node.Kind {
+ case DocumentNode:
+ yaml_document_start_event_initialize(&e.event, nil, nil, true)
+ e.event.head_comment = []byte(node.HeadComment)
+ e.emit()
+ for _, node := range node.Content {
+ e.node(node, "")
+ }
+ yaml_document_end_event_initialize(&e.event, true)
+ e.event.foot_comment = []byte(node.FootComment)
+ e.emit()
+
+ case SequenceNode:
+ style := yaml_BLOCK_SEQUENCE_STYLE
+ if node.Style&FlowStyle != 0 {
+ style = yaml_FLOW_SEQUENCE_STYLE
+ }
+ e.must(yaml_sequence_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style))
+ e.event.head_comment = []byte(node.HeadComment)
+ e.emit()
+ for _, node := range node.Content {
+ e.node(node, "")
+ }
+ e.must(yaml_sequence_end_event_initialize(&e.event))
+ e.event.line_comment = []byte(node.LineComment)
+ e.event.foot_comment = []byte(node.FootComment)
+ e.emit()
+
+ case MappingNode:
+ style := yaml_BLOCK_MAPPING_STYLE
+ if node.Style&FlowStyle != 0 {
+ style = yaml_FLOW_MAPPING_STYLE
+ }
+ yaml_mapping_start_event_initialize(&e.event, []byte(node.Anchor), []byte(longTag(tag)), tag == "", style)
+ e.event.tail_comment = []byte(tail)
+ e.event.head_comment = []byte(node.HeadComment)
+ e.emit()
+
+ // The tail logic below moves the foot comment of prior keys to the following key,
+ // since the value for each key may be a nested structure and the foot needs to be
+ // processed only the entirety of the value is streamed. The last tail is processed
+ // with the mapping end event.
+ var tail string
+ for i := 0; i+1 < len(node.Content); i += 2 {
+ k := node.Content[i]
+ foot := k.FootComment
+ if foot != "" {
+ kopy := *k
+ kopy.FootComment = ""
+ k = &kopy
+ }
+ e.node(k, tail)
+ tail = foot
+
+ v := node.Content[i+1]
+ e.node(v, "")
+ }
+
+ yaml_mapping_end_event_initialize(&e.event)
+ e.event.tail_comment = []byte(tail)
+ e.event.line_comment = []byte(node.LineComment)
+ e.event.foot_comment = []byte(node.FootComment)
+ e.emit()
+
+ case AliasNode:
+ yaml_alias_event_initialize(&e.event, []byte(node.Value))
+ e.event.head_comment = []byte(node.HeadComment)
+ e.event.line_comment = []byte(node.LineComment)
+ e.event.foot_comment = []byte(node.FootComment)
+ e.emit()
+
+ case ScalarNode:
+ value := node.Value
+ if !utf8.ValidString(value) {
+ if stag == binaryTag {
+ failf("explicitly tagged !!binary data must be base64-encoded")
+ }
+ if stag != "" {
+ failf("cannot marshal invalid UTF-8 data as %s", stag)
+ }
+ // It can't be encoded directly as YAML so use a binary tag
+ // and encode it as base64.
+ tag = binaryTag
+ value = encodeBase64(value)
+ }
+
+ style := yaml_PLAIN_SCALAR_STYLE
+ switch {
+ case node.Style&DoubleQuotedStyle != 0:
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ case node.Style&SingleQuotedStyle != 0:
+ style = yaml_SINGLE_QUOTED_SCALAR_STYLE
+ case node.Style&LiteralStyle != 0:
+ style = yaml_LITERAL_SCALAR_STYLE
+ case node.Style&FoldedStyle != 0:
+ style = yaml_FOLDED_SCALAR_STYLE
+ case strings.Contains(value, "\n"):
+ style = yaml_LITERAL_SCALAR_STYLE
+ case forceQuoting:
+ style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+
+ e.emitScalar(value, node.Anchor, tag, style, []byte(node.HeadComment), []byte(node.LineComment), []byte(node.FootComment), []byte(tail))
+ default:
+ failf("cannot encode node with unknown kind %d", node.Kind)
+ }
+}
diff --git a/vendor/go.yaml.in/yaml/v3/parserc.go b/vendor/go.yaml.in/yaml/v3/parserc.go
new file mode 100644
index 00000000..25fe8236
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/parserc.go
@@ -0,0 +1,1274 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+// Copyright (c) 2006-2010 Kirill Simonov
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+// of the Software, and to permit persons to whom the Software is furnished to do
+// so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package yaml
+
+import (
+ "bytes"
+)
+
+// The parser implements the following grammar:
+//
+// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
+// implicit_document ::= block_node DOCUMENT-END*
+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+// block_node_or_indentless_sequence ::=
+// ALIAS
+// | properties (block_content | indentless_block_sequence)?
+// | block_content
+// | indentless_block_sequence
+// block_node ::= ALIAS
+// | properties block_content?
+// | block_content
+// flow_node ::= ALIAS
+// | properties flow_content?
+// | flow_content
+// properties ::= TAG ANCHOR? | ANCHOR TAG?
+// block_content ::= block_collection | flow_collection | SCALAR
+// flow_content ::= flow_collection | SCALAR
+// block_collection ::= block_sequence | block_mapping
+// flow_collection ::= flow_sequence | flow_mapping
+// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+// indentless_sequence ::= (BLOCK-ENTRY block_node?)+
+// block_mapping ::= BLOCK-MAPPING_START
+// ((KEY block_node_or_indentless_sequence?)?
+// (VALUE block_node_or_indentless_sequence?)?)*
+// BLOCK-END
+// flow_sequence ::= FLOW-SEQUENCE-START
+// (flow_sequence_entry FLOW-ENTRY)*
+// flow_sequence_entry?
+// FLOW-SEQUENCE-END
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// flow_mapping ::= FLOW-MAPPING-START
+// (flow_mapping_entry FLOW-ENTRY)*
+// flow_mapping_entry?
+// FLOW-MAPPING-END
+// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+
+// Peek the next token in the token queue.
+func peek_token(parser *yaml_parser_t) *yaml_token_t {
+ if parser.token_available || yaml_parser_fetch_more_tokens(parser) {
+ token := &parser.tokens[parser.tokens_head]
+ yaml_parser_unfold_comments(parser, token)
+ return token
+ }
+ return nil
+}
+
+// yaml_parser_unfold_comments walks through the comments queue and joins all
+// comments behind the position of the provided token into the respective
+// top-level comment slices in the parser.
+func yaml_parser_unfold_comments(parser *yaml_parser_t, token *yaml_token_t) {
+ for parser.comments_head < len(parser.comments) && token.start_mark.index >= parser.comments[parser.comments_head].token_mark.index {
+ comment := &parser.comments[parser.comments_head]
+ if len(comment.head) > 0 {
+ if token.typ == yaml_BLOCK_END_TOKEN {
+ // No heads on ends, so keep comment.head for a follow up token.
+ break
+ }
+ if len(parser.head_comment) > 0 {
+ parser.head_comment = append(parser.head_comment, '\n')
+ }
+ parser.head_comment = append(parser.head_comment, comment.head...)
+ }
+ if len(comment.foot) > 0 {
+ if len(parser.foot_comment) > 0 {
+ parser.foot_comment = append(parser.foot_comment, '\n')
+ }
+ parser.foot_comment = append(parser.foot_comment, comment.foot...)
+ }
+ if len(comment.line) > 0 {
+ if len(parser.line_comment) > 0 {
+ parser.line_comment = append(parser.line_comment, '\n')
+ }
+ parser.line_comment = append(parser.line_comment, comment.line...)
+ }
+ *comment = yaml_comment_t{}
+ parser.comments_head++
+ }
+}
+
+// Remove the next token from the queue (must be called after peek_token).
+func skip_token(parser *yaml_parser_t) {
+ parser.token_available = false
+ parser.tokens_parsed++
+ parser.stream_end_produced = parser.tokens[parser.tokens_head].typ == yaml_STREAM_END_TOKEN
+ parser.tokens_head++
+}
+
+// Get the next event.
+func yaml_parser_parse(parser *yaml_parser_t, event *yaml_event_t) bool {
+ // Erase the event object.
+ *event = yaml_event_t{}
+
+ // No events after the end of the stream or error.
+ if parser.stream_end_produced || parser.error != yaml_NO_ERROR || parser.state == yaml_PARSE_END_STATE {
+ return true
+ }
+
+ // Generate the next event.
+ return yaml_parser_state_machine(parser, event)
+}
+
+// Set parser error.
+func yaml_parser_set_parser_error(parser *yaml_parser_t, problem string, problem_mark yaml_mark_t) bool {
+ parser.error = yaml_PARSER_ERROR
+ parser.problem = problem
+ parser.problem_mark = problem_mark
+ return false
+}
+
+func yaml_parser_set_parser_error_context(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string, problem_mark yaml_mark_t) bool {
+ parser.error = yaml_PARSER_ERROR
+ parser.context = context
+ parser.context_mark = context_mark
+ parser.problem = problem
+ parser.problem_mark = problem_mark
+ return false
+}
+
+// State dispatcher.
+func yaml_parser_state_machine(parser *yaml_parser_t, event *yaml_event_t) bool {
+ //trace("yaml_parser_state_machine", "state:", parser.state.String())
+
+ switch parser.state {
+ case yaml_PARSE_STREAM_START_STATE:
+ return yaml_parser_parse_stream_start(parser, event)
+
+ case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE:
+ return yaml_parser_parse_document_start(parser, event, true)
+
+ case yaml_PARSE_DOCUMENT_START_STATE:
+ return yaml_parser_parse_document_start(parser, event, false)
+
+ case yaml_PARSE_DOCUMENT_CONTENT_STATE:
+ return yaml_parser_parse_document_content(parser, event)
+
+ case yaml_PARSE_DOCUMENT_END_STATE:
+ return yaml_parser_parse_document_end(parser, event)
+
+ case yaml_PARSE_BLOCK_NODE_STATE:
+ return yaml_parser_parse_node(parser, event, true, false)
+
+ case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
+ return yaml_parser_parse_node(parser, event, true, true)
+
+ case yaml_PARSE_FLOW_NODE_STATE:
+ return yaml_parser_parse_node(parser, event, false, false)
+
+ case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
+ return yaml_parser_parse_block_sequence_entry(parser, event, true)
+
+ case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
+ return yaml_parser_parse_block_sequence_entry(parser, event, false)
+
+ case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
+ return yaml_parser_parse_indentless_sequence_entry(parser, event)
+
+ case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
+ return yaml_parser_parse_block_mapping_key(parser, event, true)
+
+ case yaml_PARSE_BLOCK_MAPPING_KEY_STATE:
+ return yaml_parser_parse_block_mapping_key(parser, event, false)
+
+ case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE:
+ return yaml_parser_parse_block_mapping_value(parser, event)
+
+ case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
+ return yaml_parser_parse_flow_sequence_entry(parser, event, true)
+
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
+ return yaml_parser_parse_flow_sequence_entry(parser, event, false)
+
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
+ return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event)
+
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
+ return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event)
+
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
+ return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event)
+
+ case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
+ return yaml_parser_parse_flow_mapping_key(parser, event, true)
+
+ case yaml_PARSE_FLOW_MAPPING_KEY_STATE:
+ return yaml_parser_parse_flow_mapping_key(parser, event, false)
+
+ case yaml_PARSE_FLOW_MAPPING_VALUE_STATE:
+ return yaml_parser_parse_flow_mapping_value(parser, event, false)
+
+ case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
+ return yaml_parser_parse_flow_mapping_value(parser, event, true)
+
+ default:
+ panic("invalid parser state")
+ }
+}
+
+// Parse the production:
+// stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
+//
+// ************
+func yaml_parser_parse_stream_start(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_STREAM_START_TOKEN {
+ return yaml_parser_set_parser_error(parser, "did not find expected ", token.start_mark)
+ }
+ parser.state = yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE
+ *event = yaml_event_t{
+ typ: yaml_STREAM_START_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ encoding: token.encoding,
+ }
+ skip_token(parser)
+ return true
+}
+
+// Parse the productions:
+// implicit_document ::= block_node DOCUMENT-END*
+//
+// *
+//
+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+//
+// *************************
+func yaml_parser_parse_document_start(parser *yaml_parser_t, event *yaml_event_t, implicit bool) bool {
+
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ // Parse extra document end indicators.
+ if !implicit {
+ for token.typ == yaml_DOCUMENT_END_TOKEN {
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ }
+ }
+
+ if implicit && token.typ != yaml_VERSION_DIRECTIVE_TOKEN &&
+ token.typ != yaml_TAG_DIRECTIVE_TOKEN &&
+ token.typ != yaml_DOCUMENT_START_TOKEN &&
+ token.typ != yaml_STREAM_END_TOKEN {
+ // Parse an implicit document.
+ if !yaml_parser_process_directives(parser, nil, nil) {
+ return false
+ }
+ parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
+ parser.state = yaml_PARSE_BLOCK_NODE_STATE
+
+ var head_comment []byte
+ if len(parser.head_comment) > 0 {
+ // [Go] Scan the header comment backwards, and if an empty line is found, break
+ // the header so the part before the last empty line goes into the
+ // document header, while the bottom of it goes into a follow up event.
+ for i := len(parser.head_comment) - 1; i > 0; i-- {
+ if parser.head_comment[i] == '\n' {
+ if i == len(parser.head_comment)-1 {
+ head_comment = parser.head_comment[:i]
+ parser.head_comment = parser.head_comment[i+1:]
+ break
+ } else if parser.head_comment[i-1] == '\n' {
+ head_comment = parser.head_comment[:i-1]
+ parser.head_comment = parser.head_comment[i+1:]
+ break
+ }
+ }
+ }
+ }
+
+ *event = yaml_event_t{
+ typ: yaml_DOCUMENT_START_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+
+ head_comment: head_comment,
+ }
+
+ } else if token.typ != yaml_STREAM_END_TOKEN {
+ // Parse an explicit document.
+ var version_directive *yaml_version_directive_t
+ var tag_directives []yaml_tag_directive_t
+ start_mark := token.start_mark
+ if !yaml_parser_process_directives(parser, &version_directive, &tag_directives) {
+ return false
+ }
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_DOCUMENT_START_TOKEN {
+ yaml_parser_set_parser_error(parser,
+ "did not find expected ", token.start_mark)
+ return false
+ }
+ parser.states = append(parser.states, yaml_PARSE_DOCUMENT_END_STATE)
+ parser.state = yaml_PARSE_DOCUMENT_CONTENT_STATE
+ end_mark := token.end_mark
+
+ *event = yaml_event_t{
+ typ: yaml_DOCUMENT_START_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ version_directive: version_directive,
+ tag_directives: tag_directives,
+ implicit: false,
+ }
+ skip_token(parser)
+
+ } else {
+ // Parse the stream end.
+ parser.state = yaml_PARSE_END_STATE
+ *event = yaml_event_t{
+ typ: yaml_STREAM_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ }
+ skip_token(parser)
+ }
+
+ return true
+}
+
+// Parse the productions:
+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+//
+// ***********
+func yaml_parser_parse_document_content(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ if token.typ == yaml_VERSION_DIRECTIVE_TOKEN ||
+ token.typ == yaml_TAG_DIRECTIVE_TOKEN ||
+ token.typ == yaml_DOCUMENT_START_TOKEN ||
+ token.typ == yaml_DOCUMENT_END_TOKEN ||
+ token.typ == yaml_STREAM_END_TOKEN {
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+ return yaml_parser_process_empty_scalar(parser, event,
+ token.start_mark)
+ }
+ return yaml_parser_parse_node(parser, event, true, false)
+}
+
+// Parse the productions:
+// implicit_document ::= block_node DOCUMENT-END*
+//
+// *************
+//
+// explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+func yaml_parser_parse_document_end(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ start_mark := token.start_mark
+ end_mark := token.start_mark
+
+ implicit := true
+ if token.typ == yaml_DOCUMENT_END_TOKEN {
+ end_mark = token.end_mark
+ skip_token(parser)
+ implicit = false
+ }
+
+ parser.tag_directives = parser.tag_directives[:0]
+
+ parser.state = yaml_PARSE_DOCUMENT_START_STATE
+ *event = yaml_event_t{
+ typ: yaml_DOCUMENT_END_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ implicit: implicit,
+ }
+ yaml_parser_set_event_comments(parser, event)
+ if len(event.head_comment) > 0 && len(event.foot_comment) == 0 {
+ event.foot_comment = event.head_comment
+ event.head_comment = nil
+ }
+ return true
+}
+
+func yaml_parser_set_event_comments(parser *yaml_parser_t, event *yaml_event_t) {
+ event.head_comment = parser.head_comment
+ event.line_comment = parser.line_comment
+ event.foot_comment = parser.foot_comment
+ parser.head_comment = nil
+ parser.line_comment = nil
+ parser.foot_comment = nil
+ parser.tail_comment = nil
+ parser.stem_comment = nil
+}
+
+// Parse the productions:
+// block_node_or_indentless_sequence ::=
+//
+// ALIAS
+// *****
+// | properties (block_content | indentless_block_sequence)?
+// ********** *
+// | block_content | indentless_block_sequence
+// *
+//
+// block_node ::= ALIAS
+//
+// *****
+// | properties block_content?
+// ********** *
+// | block_content
+// *
+//
+// flow_node ::= ALIAS
+//
+// *****
+// | properties flow_content?
+// ********** *
+// | flow_content
+// *
+//
+// properties ::= TAG ANCHOR? | ANCHOR TAG?
+//
+// *************************
+//
+// block_content ::= block_collection | flow_collection | SCALAR
+//
+// ******
+//
+// flow_content ::= flow_collection | SCALAR
+//
+// ******
+func yaml_parser_parse_node(parser *yaml_parser_t, event *yaml_event_t, block, indentless_sequence bool) bool {
+ //defer trace("yaml_parser_parse_node", "block:", block, "indentless_sequence:", indentless_sequence)()
+
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ if token.typ == yaml_ALIAS_TOKEN {
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+ *event = yaml_event_t{
+ typ: yaml_ALIAS_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ anchor: token.value,
+ }
+ yaml_parser_set_event_comments(parser, event)
+ skip_token(parser)
+ return true
+ }
+
+ start_mark := token.start_mark
+ end_mark := token.start_mark
+
+ var tag_token bool
+ var tag_handle, tag_suffix, anchor []byte
+ var tag_mark yaml_mark_t
+ if token.typ == yaml_ANCHOR_TOKEN {
+ anchor = token.value
+ start_mark = token.start_mark
+ end_mark = token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ == yaml_TAG_TOKEN {
+ tag_token = true
+ tag_handle = token.value
+ tag_suffix = token.suffix
+ tag_mark = token.start_mark
+ end_mark = token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ }
+ } else if token.typ == yaml_TAG_TOKEN {
+ tag_token = true
+ tag_handle = token.value
+ tag_suffix = token.suffix
+ start_mark = token.start_mark
+ tag_mark = token.start_mark
+ end_mark = token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ == yaml_ANCHOR_TOKEN {
+ anchor = token.value
+ end_mark = token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ }
+ }
+
+ var tag []byte
+ if tag_token {
+ if len(tag_handle) == 0 {
+ tag = tag_suffix
+ tag_suffix = nil
+ } else {
+ for i := range parser.tag_directives {
+ if bytes.Equal(parser.tag_directives[i].handle, tag_handle) {
+ tag = append([]byte(nil), parser.tag_directives[i].prefix...)
+ tag = append(tag, tag_suffix...)
+ break
+ }
+ }
+ if len(tag) == 0 {
+ yaml_parser_set_parser_error_context(parser,
+ "while parsing a node", start_mark,
+ "found undefined tag handle", tag_mark)
+ return false
+ }
+ }
+ }
+
+ implicit := len(tag) == 0
+ if indentless_sequence && token.typ == yaml_BLOCK_ENTRY_TOKEN {
+ end_mark = token.end_mark
+ parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_START_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
+ }
+ return true
+ }
+ if token.typ == yaml_SCALAR_TOKEN {
+ var plain_implicit, quoted_implicit bool
+ end_mark = token.end_mark
+ if (len(tag) == 0 && token.style == yaml_PLAIN_SCALAR_STYLE) || (len(tag) == 1 && tag[0] == '!') {
+ plain_implicit = true
+ } else if len(tag) == 0 {
+ quoted_implicit = true
+ }
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+
+ *event = yaml_event_t{
+ typ: yaml_SCALAR_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ value: token.value,
+ implicit: plain_implicit,
+ quoted_implicit: quoted_implicit,
+ style: yaml_style_t(token.style),
+ }
+ yaml_parser_set_event_comments(parser, event)
+ skip_token(parser)
+ return true
+ }
+ if token.typ == yaml_FLOW_SEQUENCE_START_TOKEN {
+ // [Go] Some of the events below can be merged as they differ only on style.
+ end_mark = token.end_mark
+ parser.state = yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_START_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(yaml_FLOW_SEQUENCE_STYLE),
+ }
+ yaml_parser_set_event_comments(parser, event)
+ return true
+ }
+ if token.typ == yaml_FLOW_MAPPING_START_TOKEN {
+ end_mark = token.end_mark
+ parser.state = yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_START_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(yaml_FLOW_MAPPING_STYLE),
+ }
+ yaml_parser_set_event_comments(parser, event)
+ return true
+ }
+ if block && token.typ == yaml_BLOCK_SEQUENCE_START_TOKEN {
+ end_mark = token.end_mark
+ parser.state = yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_START_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(yaml_BLOCK_SEQUENCE_STYLE),
+ }
+ if parser.stem_comment != nil {
+ event.head_comment = parser.stem_comment
+ parser.stem_comment = nil
+ }
+ return true
+ }
+ if block && token.typ == yaml_BLOCK_MAPPING_START_TOKEN {
+ end_mark = token.end_mark
+ parser.state = yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_START_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ style: yaml_style_t(yaml_BLOCK_MAPPING_STYLE),
+ }
+ if parser.stem_comment != nil {
+ event.head_comment = parser.stem_comment
+ parser.stem_comment = nil
+ }
+ return true
+ }
+ if len(anchor) > 0 || len(tag) > 0 {
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+
+ *event = yaml_event_t{
+ typ: yaml_SCALAR_EVENT,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ anchor: anchor,
+ tag: tag,
+ implicit: implicit,
+ quoted_implicit: false,
+ style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE),
+ }
+ return true
+ }
+
+ context := "while parsing a flow node"
+ if block {
+ context = "while parsing a block node"
+ }
+ yaml_parser_set_parser_error_context(parser, context, start_mark,
+ "did not find expected node content", token.start_mark)
+ return false
+}
+
+// Parse the productions:
+// block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+//
+// ******************** *********** * *********
+func yaml_parser_parse_block_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
+ if first {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ parser.marks = append(parser.marks, token.start_mark)
+ skip_token(parser)
+ }
+
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ if token.typ == yaml_BLOCK_ENTRY_TOKEN {
+ mark := token.end_mark
+ prior_head_len := len(parser.head_comment)
+ skip_token(parser)
+ yaml_parser_split_stem_comment(parser, prior_head_len)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_BLOCK_ENTRY_TOKEN && token.typ != yaml_BLOCK_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE)
+ return yaml_parser_parse_node(parser, event, true, false)
+ } else {
+ parser.state = yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE
+ return yaml_parser_process_empty_scalar(parser, event, mark)
+ }
+ }
+ if token.typ == yaml_BLOCK_END_TOKEN {
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ }
+
+ skip_token(parser)
+ return true
+ }
+
+ context_mark := parser.marks[len(parser.marks)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+ return yaml_parser_set_parser_error_context(parser,
+ "while parsing a block collection", context_mark,
+ "did not find expected '-' indicator", token.start_mark)
+}
+
+// Parse the productions:
+// indentless_sequence ::= (BLOCK-ENTRY block_node?)+
+//
+// *********** *
+func yaml_parser_parse_indentless_sequence_entry(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ if token.typ == yaml_BLOCK_ENTRY_TOKEN {
+ mark := token.end_mark
+ prior_head_len := len(parser.head_comment)
+ skip_token(parser)
+ yaml_parser_split_stem_comment(parser, prior_head_len)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_BLOCK_ENTRY_TOKEN &&
+ token.typ != yaml_KEY_TOKEN &&
+ token.typ != yaml_VALUE_TOKEN &&
+ token.typ != yaml_BLOCK_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE)
+ return yaml_parser_parse_node(parser, event, true, false)
+ }
+ parser.state = yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE
+ return yaml_parser_process_empty_scalar(parser, event, mark)
+ }
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.start_mark, // [Go] Shouldn't this be token.end_mark?
+ }
+ return true
+}
+
+// Split stem comment from head comment.
+//
+// When a sequence or map is found under a sequence entry, the former head comment
+// is assigned to the underlying sequence or map as a whole, not the individual
+// sequence or map entry as would be expected otherwise. To handle this case the
+// previous head comment is moved aside as the stem comment.
+func yaml_parser_split_stem_comment(parser *yaml_parser_t, stem_len int) {
+ if stem_len == 0 {
+ return
+ }
+
+ token := peek_token(parser)
+ if token == nil || token.typ != yaml_BLOCK_SEQUENCE_START_TOKEN && token.typ != yaml_BLOCK_MAPPING_START_TOKEN {
+ return
+ }
+
+ parser.stem_comment = parser.head_comment[:stem_len]
+ if len(parser.head_comment) == stem_len {
+ parser.head_comment = nil
+ } else {
+ // Copy suffix to prevent very strange bugs if someone ever appends
+ // further bytes to the prefix in the stem_comment slice above.
+ parser.head_comment = append([]byte(nil), parser.head_comment[stem_len+1:]...)
+ }
+}
+
+// Parse the productions:
+// block_mapping ::= BLOCK-MAPPING_START
+//
+// *******************
+// ((KEY block_node_or_indentless_sequence?)?
+// *** *
+// (VALUE block_node_or_indentless_sequence?)?)*
+//
+// BLOCK-END
+// *********
+func yaml_parser_parse_block_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
+ if first {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ parser.marks = append(parser.marks, token.start_mark)
+ skip_token(parser)
+ }
+
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ // [Go] A tail comment was left from the prior mapping value processed. Emit an event
+ // as it needs to be processed with that value and not the following key.
+ if len(parser.tail_comment) > 0 {
+ *event = yaml_event_t{
+ typ: yaml_TAIL_COMMENT_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ foot_comment: parser.tail_comment,
+ }
+ parser.tail_comment = nil
+ return true
+ }
+
+ if token.typ == yaml_KEY_TOKEN {
+ mark := token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_KEY_TOKEN &&
+ token.typ != yaml_VALUE_TOKEN &&
+ token.typ != yaml_BLOCK_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_VALUE_STATE)
+ return yaml_parser_parse_node(parser, event, true, true)
+ } else {
+ parser.state = yaml_PARSE_BLOCK_MAPPING_VALUE_STATE
+ return yaml_parser_process_empty_scalar(parser, event, mark)
+ }
+ } else if token.typ == yaml_BLOCK_END_TOKEN {
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ }
+ yaml_parser_set_event_comments(parser, event)
+ skip_token(parser)
+ return true
+ }
+
+ context_mark := parser.marks[len(parser.marks)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+ return yaml_parser_set_parser_error_context(parser,
+ "while parsing a block mapping", context_mark,
+ "did not find expected key", token.start_mark)
+}
+
+// Parse the productions:
+// block_mapping ::= BLOCK-MAPPING_START
+//
+// ((KEY block_node_or_indentless_sequence?)?
+//
+// (VALUE block_node_or_indentless_sequence?)?)*
+// ***** *
+// BLOCK-END
+func yaml_parser_parse_block_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ == yaml_VALUE_TOKEN {
+ mark := token.end_mark
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_KEY_TOKEN &&
+ token.typ != yaml_VALUE_TOKEN &&
+ token.typ != yaml_BLOCK_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_BLOCK_MAPPING_KEY_STATE)
+ return yaml_parser_parse_node(parser, event, true, true)
+ }
+ parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE
+ return yaml_parser_process_empty_scalar(parser, event, mark)
+ }
+ parser.state = yaml_PARSE_BLOCK_MAPPING_KEY_STATE
+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
+}
+
+// Parse the productions:
+// flow_sequence ::= FLOW-SEQUENCE-START
+//
+// *******************
+// (flow_sequence_entry FLOW-ENTRY)*
+// * **********
+// flow_sequence_entry?
+// *
+// FLOW-SEQUENCE-END
+// *****************
+//
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+//
+// *
+func yaml_parser_parse_flow_sequence_entry(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
+ if first {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ parser.marks = append(parser.marks, token.start_mark)
+ skip_token(parser)
+ }
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
+ if !first {
+ if token.typ == yaml_FLOW_ENTRY_TOKEN {
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ } else {
+ context_mark := parser.marks[len(parser.marks)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+ return yaml_parser_set_parser_error_context(parser,
+ "while parsing a flow sequence", context_mark,
+ "did not find expected ',' or ']'", token.start_mark)
+ }
+ }
+
+ if token.typ == yaml_KEY_TOKEN {
+ parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_START_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ implicit: true,
+ style: yaml_style_t(yaml_FLOW_MAPPING_STYLE),
+ }
+ skip_token(parser)
+ return true
+ } else if token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE)
+ return yaml_parser_parse_node(parser, event, false, false)
+ }
+ }
+
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+
+ *event = yaml_event_t{
+ typ: yaml_SEQUENCE_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ }
+ yaml_parser_set_event_comments(parser, event)
+
+ skip_token(parser)
+ return true
+}
+
+// Parse the productions:
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+//
+// *** *
+func yaml_parser_parse_flow_sequence_entry_mapping_key(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_VALUE_TOKEN &&
+ token.typ != yaml_FLOW_ENTRY_TOKEN &&
+ token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE)
+ return yaml_parser_parse_node(parser, event, false, false)
+ }
+ mark := token.end_mark
+ skip_token(parser)
+ parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE
+ return yaml_parser_process_empty_scalar(parser, event, mark)
+}
+
+// Parse the productions:
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+//
+// ***** *
+func yaml_parser_parse_flow_sequence_entry_mapping_value(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ == yaml_VALUE_TOKEN {
+ skip_token(parser)
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_SEQUENCE_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE)
+ return yaml_parser_parse_node(parser, event, false, false)
+ }
+ }
+ parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE
+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
+}
+
+// Parse the productions:
+// flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+//
+// *
+func yaml_parser_parse_flow_sequence_entry_mapping_end(parser *yaml_parser_t, event *yaml_event_t) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ parser.state = yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.start_mark, // [Go] Shouldn't this be end_mark?
+ }
+ return true
+}
+
+// Parse the productions:
+// flow_mapping ::= FLOW-MAPPING-START
+//
+// ******************
+// (flow_mapping_entry FLOW-ENTRY)*
+// * **********
+// flow_mapping_entry?
+// ******************
+// FLOW-MAPPING-END
+// ****************
+//
+// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// - *** *
+func yaml_parser_parse_flow_mapping_key(parser *yaml_parser_t, event *yaml_event_t, first bool) bool {
+ if first {
+ token := peek_token(parser)
+ parser.marks = append(parser.marks, token.start_mark)
+ skip_token(parser)
+ }
+
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ if token.typ != yaml_FLOW_MAPPING_END_TOKEN {
+ if !first {
+ if token.typ == yaml_FLOW_ENTRY_TOKEN {
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ } else {
+ context_mark := parser.marks[len(parser.marks)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+ return yaml_parser_set_parser_error_context(parser,
+ "while parsing a flow mapping", context_mark,
+ "did not find expected ',' or '}'", token.start_mark)
+ }
+ }
+
+ if token.typ == yaml_KEY_TOKEN {
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_VALUE_TOKEN &&
+ token.typ != yaml_FLOW_ENTRY_TOKEN &&
+ token.typ != yaml_FLOW_MAPPING_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_VALUE_STATE)
+ return yaml_parser_parse_node(parser, event, false, false)
+ } else {
+ parser.state = yaml_PARSE_FLOW_MAPPING_VALUE_STATE
+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
+ }
+ } else if token.typ != yaml_FLOW_MAPPING_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE)
+ return yaml_parser_parse_node(parser, event, false, false)
+ }
+ }
+
+ parser.state = parser.states[len(parser.states)-1]
+ parser.states = parser.states[:len(parser.states)-1]
+ parser.marks = parser.marks[:len(parser.marks)-1]
+ *event = yaml_event_t{
+ typ: yaml_MAPPING_END_EVENT,
+ start_mark: token.start_mark,
+ end_mark: token.end_mark,
+ }
+ yaml_parser_set_event_comments(parser, event)
+ skip_token(parser)
+ return true
+}
+
+// Parse the productions:
+// flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+// - ***** *
+func yaml_parser_parse_flow_mapping_value(parser *yaml_parser_t, event *yaml_event_t, empty bool) bool {
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if empty {
+ parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE
+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
+ }
+ if token.typ == yaml_VALUE_TOKEN {
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ if token.typ != yaml_FLOW_ENTRY_TOKEN && token.typ != yaml_FLOW_MAPPING_END_TOKEN {
+ parser.states = append(parser.states, yaml_PARSE_FLOW_MAPPING_KEY_STATE)
+ return yaml_parser_parse_node(parser, event, false, false)
+ }
+ }
+ parser.state = yaml_PARSE_FLOW_MAPPING_KEY_STATE
+ return yaml_parser_process_empty_scalar(parser, event, token.start_mark)
+}
+
+// Generate an empty scalar event.
+func yaml_parser_process_empty_scalar(parser *yaml_parser_t, event *yaml_event_t, mark yaml_mark_t) bool {
+ *event = yaml_event_t{
+ typ: yaml_SCALAR_EVENT,
+ start_mark: mark,
+ end_mark: mark,
+ value: nil, // Empty
+ implicit: true,
+ style: yaml_style_t(yaml_PLAIN_SCALAR_STYLE),
+ }
+ return true
+}
+
+var default_tag_directives = []yaml_tag_directive_t{
+ {[]byte("!"), []byte("!")},
+ {[]byte("!!"), []byte("tag:yaml.org,2002:")},
+}
+
+// Parse directives.
+func yaml_parser_process_directives(parser *yaml_parser_t,
+ version_directive_ref **yaml_version_directive_t,
+ tag_directives_ref *[]yaml_tag_directive_t) bool {
+
+ var version_directive *yaml_version_directive_t
+ var tag_directives []yaml_tag_directive_t
+
+ token := peek_token(parser)
+ if token == nil {
+ return false
+ }
+
+ for token.typ == yaml_VERSION_DIRECTIVE_TOKEN || token.typ == yaml_TAG_DIRECTIVE_TOKEN {
+ if token.typ == yaml_VERSION_DIRECTIVE_TOKEN {
+ if version_directive != nil {
+ yaml_parser_set_parser_error(parser,
+ "found duplicate %YAML directive", token.start_mark)
+ return false
+ }
+ if token.major != 1 || token.minor != 1 {
+ yaml_parser_set_parser_error(parser,
+ "found incompatible YAML document", token.start_mark)
+ return false
+ }
+ version_directive = &yaml_version_directive_t{
+ major: token.major,
+ minor: token.minor,
+ }
+ } else if token.typ == yaml_TAG_DIRECTIVE_TOKEN {
+ value := yaml_tag_directive_t{
+ handle: token.value,
+ prefix: token.prefix,
+ }
+ if !yaml_parser_append_tag_directive(parser, value, false, token.start_mark) {
+ return false
+ }
+ tag_directives = append(tag_directives, value)
+ }
+
+ skip_token(parser)
+ token = peek_token(parser)
+ if token == nil {
+ return false
+ }
+ }
+
+ for i := range default_tag_directives {
+ if !yaml_parser_append_tag_directive(parser, default_tag_directives[i], true, token.start_mark) {
+ return false
+ }
+ }
+
+ if version_directive_ref != nil {
+ *version_directive_ref = version_directive
+ }
+ if tag_directives_ref != nil {
+ *tag_directives_ref = tag_directives
+ }
+ return true
+}
+
+// Append a tag directive to the directives stack.
+func yaml_parser_append_tag_directive(parser *yaml_parser_t, value yaml_tag_directive_t, allow_duplicates bool, mark yaml_mark_t) bool {
+ for i := range parser.tag_directives {
+ if bytes.Equal(value.handle, parser.tag_directives[i].handle) {
+ if allow_duplicates {
+ return true
+ }
+ return yaml_parser_set_parser_error(parser, "found duplicate %TAG directive", mark)
+ }
+ }
+
+ // [Go] I suspect the copy is unnecessary. This was likely done
+ // because there was no way to track ownership of the data.
+ value_copy := yaml_tag_directive_t{
+ handle: make([]byte, len(value.handle)),
+ prefix: make([]byte, len(value.prefix)),
+ }
+ copy(value_copy.handle, value.handle)
+ copy(value_copy.prefix, value.prefix)
+ parser.tag_directives = append(parser.tag_directives, value_copy)
+ return true
+}
diff --git a/vendor/go.yaml.in/yaml/v3/readerc.go b/vendor/go.yaml.in/yaml/v3/readerc.go
new file mode 100644
index 00000000..56af2453
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/readerc.go
@@ -0,0 +1,434 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+// Copyright (c) 2006-2010 Kirill Simonov
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+// of the Software, and to permit persons to whom the Software is furnished to do
+// so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package yaml
+
+import (
+ "io"
+)
+
+// Set the reader error and return 0.
+func yaml_parser_set_reader_error(parser *yaml_parser_t, problem string, offset int, value int) bool {
+ parser.error = yaml_READER_ERROR
+ parser.problem = problem
+ parser.problem_offset = offset
+ parser.problem_value = value
+ return false
+}
+
+// Byte order marks.
+const (
+ bom_UTF8 = "\xef\xbb\xbf"
+ bom_UTF16LE = "\xff\xfe"
+ bom_UTF16BE = "\xfe\xff"
+)
+
+// Determine the input stream encoding by checking the BOM symbol. If no BOM is
+// found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure.
+func yaml_parser_determine_encoding(parser *yaml_parser_t) bool {
+ // Ensure that we had enough bytes in the raw buffer.
+ for !parser.eof && len(parser.raw_buffer)-parser.raw_buffer_pos < 3 {
+ if !yaml_parser_update_raw_buffer(parser) {
+ return false
+ }
+ }
+
+ // Determine the encoding.
+ buf := parser.raw_buffer
+ pos := parser.raw_buffer_pos
+ avail := len(buf) - pos
+ if avail >= 2 && buf[pos] == bom_UTF16LE[0] && buf[pos+1] == bom_UTF16LE[1] {
+ parser.encoding = yaml_UTF16LE_ENCODING
+ parser.raw_buffer_pos += 2
+ parser.offset += 2
+ } else if avail >= 2 && buf[pos] == bom_UTF16BE[0] && buf[pos+1] == bom_UTF16BE[1] {
+ parser.encoding = yaml_UTF16BE_ENCODING
+ parser.raw_buffer_pos += 2
+ parser.offset += 2
+ } else if avail >= 3 && buf[pos] == bom_UTF8[0] && buf[pos+1] == bom_UTF8[1] && buf[pos+2] == bom_UTF8[2] {
+ parser.encoding = yaml_UTF8_ENCODING
+ parser.raw_buffer_pos += 3
+ parser.offset += 3
+ } else {
+ parser.encoding = yaml_UTF8_ENCODING
+ }
+ return true
+}
+
+// Update the raw buffer.
+func yaml_parser_update_raw_buffer(parser *yaml_parser_t) bool {
+ size_read := 0
+
+ // Return if the raw buffer is full.
+ if parser.raw_buffer_pos == 0 && len(parser.raw_buffer) == cap(parser.raw_buffer) {
+ return true
+ }
+
+ // Return on EOF.
+ if parser.eof {
+ return true
+ }
+
+ // Move the remaining bytes in the raw buffer to the beginning.
+ if parser.raw_buffer_pos > 0 && parser.raw_buffer_pos < len(parser.raw_buffer) {
+ copy(parser.raw_buffer, parser.raw_buffer[parser.raw_buffer_pos:])
+ }
+ parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)-parser.raw_buffer_pos]
+ parser.raw_buffer_pos = 0
+
+ // Call the read handler to fill the buffer.
+ size_read, err := parser.read_handler(parser, parser.raw_buffer[len(parser.raw_buffer):cap(parser.raw_buffer)])
+ parser.raw_buffer = parser.raw_buffer[:len(parser.raw_buffer)+size_read]
+ if err == io.EOF {
+ parser.eof = true
+ } else if err != nil {
+ return yaml_parser_set_reader_error(parser, "input error: "+err.Error(), parser.offset, -1)
+ }
+ return true
+}
+
+// Ensure that the buffer contains at least `length` characters.
+// Return true on success, false on failure.
+//
+// The length is supposed to be significantly less that the buffer size.
+func yaml_parser_update_buffer(parser *yaml_parser_t, length int) bool {
+ if parser.read_handler == nil {
+ panic("read handler must be set")
+ }
+
+ // [Go] This function was changed to guarantee the requested length size at EOF.
+ // The fact we need to do this is pretty awful, but the description above implies
+ // for that to be the case, and there are tests
+
+ // If the EOF flag is set and the raw buffer is empty, do nothing.
+ if parser.eof && parser.raw_buffer_pos == len(parser.raw_buffer) {
+ // [Go] ACTUALLY! Read the documentation of this function above.
+ // This is just broken. To return true, we need to have the
+ // given length in the buffer. Not doing that means every single
+ // check that calls this function to make sure the buffer has a
+ // given length is Go) panicking; or C) accessing invalid memory.
+ //return true
+ }
+
+ // Return if the buffer contains enough characters.
+ if parser.unread >= length {
+ return true
+ }
+
+ // Determine the input encoding if it is not known yet.
+ if parser.encoding == yaml_ANY_ENCODING {
+ if !yaml_parser_determine_encoding(parser) {
+ return false
+ }
+ }
+
+ // Move the unread characters to the beginning of the buffer.
+ buffer_len := len(parser.buffer)
+ if parser.buffer_pos > 0 && parser.buffer_pos < buffer_len {
+ copy(parser.buffer, parser.buffer[parser.buffer_pos:])
+ buffer_len -= parser.buffer_pos
+ parser.buffer_pos = 0
+ } else if parser.buffer_pos == buffer_len {
+ buffer_len = 0
+ parser.buffer_pos = 0
+ }
+
+ // Open the whole buffer for writing, and cut it before returning.
+ parser.buffer = parser.buffer[:cap(parser.buffer)]
+
+ // Fill the buffer until it has enough characters.
+ first := true
+ for parser.unread < length {
+
+ // Fill the raw buffer if necessary.
+ if !first || parser.raw_buffer_pos == len(parser.raw_buffer) {
+ if !yaml_parser_update_raw_buffer(parser) {
+ parser.buffer = parser.buffer[:buffer_len]
+ return false
+ }
+ }
+ first = false
+
+ // Decode the raw buffer.
+ inner:
+ for parser.raw_buffer_pos != len(parser.raw_buffer) {
+ var value rune
+ var width int
+
+ raw_unread := len(parser.raw_buffer) - parser.raw_buffer_pos
+
+ // Decode the next character.
+ switch parser.encoding {
+ case yaml_UTF8_ENCODING:
+ // Decode a UTF-8 character. Check RFC 3629
+ // (http://www.ietf.org/rfc/rfc3629.txt) for more details.
+ //
+ // The following table (taken from the RFC) is used for
+ // decoding.
+ //
+ // Char. number range | UTF-8 octet sequence
+ // (hexadecimal) | (binary)
+ // --------------------+------------------------------------
+ // 0000 0000-0000 007F | 0xxxxxxx
+ // 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
+ // 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
+ // 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ //
+ // Additionally, the characters in the range 0xD800-0xDFFF
+ // are prohibited as they are reserved for use with UTF-16
+ // surrogate pairs.
+
+ // Determine the length of the UTF-8 sequence.
+ octet := parser.raw_buffer[parser.raw_buffer_pos]
+ switch {
+ case octet&0x80 == 0x00:
+ width = 1
+ case octet&0xE0 == 0xC0:
+ width = 2
+ case octet&0xF0 == 0xE0:
+ width = 3
+ case octet&0xF8 == 0xF0:
+ width = 4
+ default:
+ // The leading octet is invalid.
+ return yaml_parser_set_reader_error(parser,
+ "invalid leading UTF-8 octet",
+ parser.offset, int(octet))
+ }
+
+ // Check if the raw buffer contains an incomplete character.
+ if width > raw_unread {
+ if parser.eof {
+ return yaml_parser_set_reader_error(parser,
+ "incomplete UTF-8 octet sequence",
+ parser.offset, -1)
+ }
+ break inner
+ }
+
+ // Decode the leading octet.
+ switch {
+ case octet&0x80 == 0x00:
+ value = rune(octet & 0x7F)
+ case octet&0xE0 == 0xC0:
+ value = rune(octet & 0x1F)
+ case octet&0xF0 == 0xE0:
+ value = rune(octet & 0x0F)
+ case octet&0xF8 == 0xF0:
+ value = rune(octet & 0x07)
+ default:
+ value = 0
+ }
+
+ // Check and decode the trailing octets.
+ for k := 1; k < width; k++ {
+ octet = parser.raw_buffer[parser.raw_buffer_pos+k]
+
+ // Check if the octet is valid.
+ if (octet & 0xC0) != 0x80 {
+ return yaml_parser_set_reader_error(parser,
+ "invalid trailing UTF-8 octet",
+ parser.offset+k, int(octet))
+ }
+
+ // Decode the octet.
+ value = (value << 6) + rune(octet&0x3F)
+ }
+
+ // Check the length of the sequence against the value.
+ switch {
+ case width == 1:
+ case width == 2 && value >= 0x80:
+ case width == 3 && value >= 0x800:
+ case width == 4 && value >= 0x10000:
+ default:
+ return yaml_parser_set_reader_error(parser,
+ "invalid length of a UTF-8 sequence",
+ parser.offset, -1)
+ }
+
+ // Check the range of the value.
+ if value >= 0xD800 && value <= 0xDFFF || value > 0x10FFFF {
+ return yaml_parser_set_reader_error(parser,
+ "invalid Unicode character",
+ parser.offset, int(value))
+ }
+
+ case yaml_UTF16LE_ENCODING, yaml_UTF16BE_ENCODING:
+ var low, high int
+ if parser.encoding == yaml_UTF16LE_ENCODING {
+ low, high = 0, 1
+ } else {
+ low, high = 1, 0
+ }
+
+ // The UTF-16 encoding is not as simple as one might
+ // naively think. Check RFC 2781
+ // (http://www.ietf.org/rfc/rfc2781.txt).
+ //
+ // Normally, two subsequent bytes describe a Unicode
+ // character. However a special technique (called a
+ // surrogate pair) is used for specifying character
+ // values larger than 0xFFFF.
+ //
+ // A surrogate pair consists of two pseudo-characters:
+ // high surrogate area (0xD800-0xDBFF)
+ // low surrogate area (0xDC00-0xDFFF)
+ //
+ // The following formulas are used for decoding
+ // and encoding characters using surrogate pairs:
+ //
+ // U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF)
+ // U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF)
+ // W1 = 110110yyyyyyyyyy
+ // W2 = 110111xxxxxxxxxx
+ //
+ // where U is the character value, W1 is the high surrogate
+ // area, W2 is the low surrogate area.
+
+ // Check for incomplete UTF-16 character.
+ if raw_unread < 2 {
+ if parser.eof {
+ return yaml_parser_set_reader_error(parser,
+ "incomplete UTF-16 character",
+ parser.offset, -1)
+ }
+ break inner
+ }
+
+ // Get the character.
+ value = rune(parser.raw_buffer[parser.raw_buffer_pos+low]) +
+ (rune(parser.raw_buffer[parser.raw_buffer_pos+high]) << 8)
+
+ // Check for unexpected low surrogate area.
+ if value&0xFC00 == 0xDC00 {
+ return yaml_parser_set_reader_error(parser,
+ "unexpected low surrogate area",
+ parser.offset, int(value))
+ }
+
+ // Check for a high surrogate area.
+ if value&0xFC00 == 0xD800 {
+ width = 4
+
+ // Check for incomplete surrogate pair.
+ if raw_unread < 4 {
+ if parser.eof {
+ return yaml_parser_set_reader_error(parser,
+ "incomplete UTF-16 surrogate pair",
+ parser.offset, -1)
+ }
+ break inner
+ }
+
+ // Get the next character.
+ value2 := rune(parser.raw_buffer[parser.raw_buffer_pos+low+2]) +
+ (rune(parser.raw_buffer[parser.raw_buffer_pos+high+2]) << 8)
+
+ // Check for a low surrogate area.
+ if value2&0xFC00 != 0xDC00 {
+ return yaml_parser_set_reader_error(parser,
+ "expected low surrogate area",
+ parser.offset+2, int(value2))
+ }
+
+ // Generate the value of the surrogate pair.
+ value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF)
+ } else {
+ width = 2
+ }
+
+ default:
+ panic("impossible")
+ }
+
+ // Check if the character is in the allowed range:
+ // #x9 | #xA | #xD | [#x20-#x7E] (8 bit)
+ // | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit)
+ // | [#x10000-#x10FFFF] (32 bit)
+ switch {
+ case value == 0x09:
+ case value == 0x0A:
+ case value == 0x0D:
+ case value >= 0x20 && value <= 0x7E:
+ case value == 0x85:
+ case value >= 0xA0 && value <= 0xD7FF:
+ case value >= 0xE000 && value <= 0xFFFD:
+ case value >= 0x10000 && value <= 0x10FFFF:
+ default:
+ return yaml_parser_set_reader_error(parser,
+ "control characters are not allowed",
+ parser.offset, int(value))
+ }
+
+ // Move the raw pointers.
+ parser.raw_buffer_pos += width
+ parser.offset += width
+
+ // Finally put the character into the buffer.
+ if value <= 0x7F {
+ // 0000 0000-0000 007F . 0xxxxxxx
+ parser.buffer[buffer_len+0] = byte(value)
+ buffer_len += 1
+ } else if value <= 0x7FF {
+ // 0000 0080-0000 07FF . 110xxxxx 10xxxxxx
+ parser.buffer[buffer_len+0] = byte(0xC0 + (value >> 6))
+ parser.buffer[buffer_len+1] = byte(0x80 + (value & 0x3F))
+ buffer_len += 2
+ } else if value <= 0xFFFF {
+ // 0000 0800-0000 FFFF . 1110xxxx 10xxxxxx 10xxxxxx
+ parser.buffer[buffer_len+0] = byte(0xE0 + (value >> 12))
+ parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 6) & 0x3F))
+ parser.buffer[buffer_len+2] = byte(0x80 + (value & 0x3F))
+ buffer_len += 3
+ } else {
+ // 0001 0000-0010 FFFF . 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ parser.buffer[buffer_len+0] = byte(0xF0 + (value >> 18))
+ parser.buffer[buffer_len+1] = byte(0x80 + ((value >> 12) & 0x3F))
+ parser.buffer[buffer_len+2] = byte(0x80 + ((value >> 6) & 0x3F))
+ parser.buffer[buffer_len+3] = byte(0x80 + (value & 0x3F))
+ buffer_len += 4
+ }
+
+ parser.unread++
+ }
+
+ // On EOF, put NUL into the buffer and return.
+ if parser.eof {
+ parser.buffer[buffer_len] = 0
+ buffer_len++
+ parser.unread++
+ break
+ }
+ }
+ // [Go] Read the documentation of this function above. To return true,
+ // we need to have the given length in the buffer. Not doing that means
+ // every single check that calls this function to make sure the buffer
+ // has a given length is Go) panicking; or C) accessing invalid memory.
+ // This happens here due to the EOF above breaking early.
+ for buffer_len < length {
+ parser.buffer[buffer_len] = 0
+ buffer_len++
+ }
+ parser.buffer = parser.buffer[:buffer_len]
+ return true
+}
diff --git a/vendor/go.yaml.in/yaml/v3/resolve.go b/vendor/go.yaml.in/yaml/v3/resolve.go
new file mode 100644
index 00000000..64ae8880
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/resolve.go
@@ -0,0 +1,326 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package yaml
+
+import (
+ "encoding/base64"
+ "math"
+ "regexp"
+ "strconv"
+ "strings"
+ "time"
+)
+
+type resolveMapItem struct {
+ value interface{}
+ tag string
+}
+
+var resolveTable = make([]byte, 256)
+var resolveMap = make(map[string]resolveMapItem)
+
+func init() {
+ t := resolveTable
+ t[int('+')] = 'S' // Sign
+ t[int('-')] = 'S'
+ for _, c := range "0123456789" {
+ t[int(c)] = 'D' // Digit
+ }
+ for _, c := range "yYnNtTfFoO~" {
+ t[int(c)] = 'M' // In map
+ }
+ t[int('.')] = '.' // Float (potentially in map)
+
+ var resolveMapList = []struct {
+ v interface{}
+ tag string
+ l []string
+ }{
+ {true, boolTag, []string{"true", "True", "TRUE"}},
+ {false, boolTag, []string{"false", "False", "FALSE"}},
+ {nil, nullTag, []string{"", "~", "null", "Null", "NULL"}},
+ {math.NaN(), floatTag, []string{".nan", ".NaN", ".NAN"}},
+ {math.Inf(+1), floatTag, []string{".inf", ".Inf", ".INF"}},
+ {math.Inf(+1), floatTag, []string{"+.inf", "+.Inf", "+.INF"}},
+ {math.Inf(-1), floatTag, []string{"-.inf", "-.Inf", "-.INF"}},
+ {"<<", mergeTag, []string{"<<"}},
+ }
+
+ m := resolveMap
+ for _, item := range resolveMapList {
+ for _, s := range item.l {
+ m[s] = resolveMapItem{item.v, item.tag}
+ }
+ }
+}
+
+const (
+ nullTag = "!!null"
+ boolTag = "!!bool"
+ strTag = "!!str"
+ intTag = "!!int"
+ floatTag = "!!float"
+ timestampTag = "!!timestamp"
+ seqTag = "!!seq"
+ mapTag = "!!map"
+ binaryTag = "!!binary"
+ mergeTag = "!!merge"
+)
+
+var longTags = make(map[string]string)
+var shortTags = make(map[string]string)
+
+func init() {
+ for _, stag := range []string{nullTag, boolTag, strTag, intTag, floatTag, timestampTag, seqTag, mapTag, binaryTag, mergeTag} {
+ ltag := longTag(stag)
+ longTags[stag] = ltag
+ shortTags[ltag] = stag
+ }
+}
+
+const longTagPrefix = "tag:yaml.org,2002:"
+
+func shortTag(tag string) string {
+ if strings.HasPrefix(tag, longTagPrefix) {
+ if stag, ok := shortTags[tag]; ok {
+ return stag
+ }
+ return "!!" + tag[len(longTagPrefix):]
+ }
+ return tag
+}
+
+func longTag(tag string) string {
+ if strings.HasPrefix(tag, "!!") {
+ if ltag, ok := longTags[tag]; ok {
+ return ltag
+ }
+ return longTagPrefix + tag[2:]
+ }
+ return tag
+}
+
+func resolvableTag(tag string) bool {
+ switch tag {
+ case "", strTag, boolTag, intTag, floatTag, nullTag, timestampTag:
+ return true
+ }
+ return false
+}
+
+var yamlStyleFloat = regexp.MustCompile(`^[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?$`)
+
+func resolve(tag string, in string) (rtag string, out interface{}) {
+ tag = shortTag(tag)
+ if !resolvableTag(tag) {
+ return tag, in
+ }
+
+ defer func() {
+ switch tag {
+ case "", rtag, strTag, binaryTag:
+ return
+ case floatTag:
+ if rtag == intTag {
+ switch v := out.(type) {
+ case int64:
+ rtag = floatTag
+ out = float64(v)
+ return
+ case int:
+ rtag = floatTag
+ out = float64(v)
+ return
+ }
+ }
+ }
+ failf("cannot decode %s `%s` as a %s", shortTag(rtag), in, shortTag(tag))
+ }()
+
+ // Any data is accepted as a !!str or !!binary.
+ // Otherwise, the prefix is enough of a hint about what it might be.
+ hint := byte('N')
+ if in != "" {
+ hint = resolveTable[in[0]]
+ }
+ if hint != 0 && tag != strTag && tag != binaryTag {
+ // Handle things we can lookup in a map.
+ if item, ok := resolveMap[in]; ok {
+ return item.tag, item.value
+ }
+
+ // Base 60 floats are a bad idea, were dropped in YAML 1.2, and
+ // are purposefully unsupported here. They're still quoted on
+ // the way out for compatibility with other parser, though.
+
+ switch hint {
+ case 'M':
+ // We've already checked the map above.
+
+ case '.':
+ // Not in the map, so maybe a normal float.
+ floatv, err := strconv.ParseFloat(in, 64)
+ if err == nil {
+ return floatTag, floatv
+ }
+
+ case 'D', 'S':
+ // Int, float, or timestamp.
+ // Only try values as a timestamp if the value is unquoted or there's an explicit
+ // !!timestamp tag.
+ if tag == "" || tag == timestampTag {
+ t, ok := parseTimestamp(in)
+ if ok {
+ return timestampTag, t
+ }
+ }
+
+ plain := strings.Replace(in, "_", "", -1)
+ intv, err := strconv.ParseInt(plain, 0, 64)
+ if err == nil {
+ if intv == int64(int(intv)) {
+ return intTag, int(intv)
+ } else {
+ return intTag, intv
+ }
+ }
+ uintv, err := strconv.ParseUint(plain, 0, 64)
+ if err == nil {
+ return intTag, uintv
+ }
+ if yamlStyleFloat.MatchString(plain) {
+ floatv, err := strconv.ParseFloat(plain, 64)
+ if err == nil {
+ return floatTag, floatv
+ }
+ }
+ if strings.HasPrefix(plain, "0b") {
+ intv, err := strconv.ParseInt(plain[2:], 2, 64)
+ if err == nil {
+ if intv == int64(int(intv)) {
+ return intTag, int(intv)
+ } else {
+ return intTag, intv
+ }
+ }
+ uintv, err := strconv.ParseUint(plain[2:], 2, 64)
+ if err == nil {
+ return intTag, uintv
+ }
+ } else if strings.HasPrefix(plain, "-0b") {
+ intv, err := strconv.ParseInt("-"+plain[3:], 2, 64)
+ if err == nil {
+ if true || intv == int64(int(intv)) {
+ return intTag, int(intv)
+ } else {
+ return intTag, intv
+ }
+ }
+ }
+ // Octals as introduced in version 1.2 of the spec.
+ // Octals from the 1.1 spec, spelled as 0777, are still
+ // decoded by default in v3 as well for compatibility.
+ // May be dropped in v4 depending on how usage evolves.
+ if strings.HasPrefix(plain, "0o") {
+ intv, err := strconv.ParseInt(plain[2:], 8, 64)
+ if err == nil {
+ if intv == int64(int(intv)) {
+ return intTag, int(intv)
+ } else {
+ return intTag, intv
+ }
+ }
+ uintv, err := strconv.ParseUint(plain[2:], 8, 64)
+ if err == nil {
+ return intTag, uintv
+ }
+ } else if strings.HasPrefix(plain, "-0o") {
+ intv, err := strconv.ParseInt("-"+plain[3:], 8, 64)
+ if err == nil {
+ if true || intv == int64(int(intv)) {
+ return intTag, int(intv)
+ } else {
+ return intTag, intv
+ }
+ }
+ }
+ default:
+ panic("internal error: missing handler for resolver table: " + string(rune(hint)) + " (with " + in + ")")
+ }
+ }
+ return strTag, in
+}
+
+// encodeBase64 encodes s as base64 that is broken up into multiple lines
+// as appropriate for the resulting length.
+func encodeBase64(s string) string {
+ const lineLen = 70
+ encLen := base64.StdEncoding.EncodedLen(len(s))
+ lines := encLen/lineLen + 1
+ buf := make([]byte, encLen*2+lines)
+ in := buf[0:encLen]
+ out := buf[encLen:]
+ base64.StdEncoding.Encode(in, []byte(s))
+ k := 0
+ for i := 0; i < len(in); i += lineLen {
+ j := i + lineLen
+ if j > len(in) {
+ j = len(in)
+ }
+ k += copy(out[k:], in[i:j])
+ if lines > 1 {
+ out[k] = '\n'
+ k++
+ }
+ }
+ return string(out[:k])
+}
+
+// This is a subset of the formats allowed by the regular expression
+// defined at http://yaml.org/type/timestamp.html.
+var allowedTimestampFormats = []string{
+ "2006-1-2T15:4:5.999999999Z07:00", // RCF3339Nano with short date fields.
+ "2006-1-2t15:4:5.999999999Z07:00", // RFC3339Nano with short date fields and lower-case "t".
+ "2006-1-2 15:4:5.999999999", // space separated with no time zone
+ "2006-1-2", // date only
+ // Notable exception: time.Parse cannot handle: "2001-12-14 21:59:43.10 -5"
+ // from the set of examples.
+}
+
+// parseTimestamp parses s as a timestamp string and
+// returns the timestamp and reports whether it succeeded.
+// Timestamp formats are defined at http://yaml.org/type/timestamp.html
+func parseTimestamp(s string) (time.Time, bool) {
+ // TODO write code to check all the formats supported by
+ // http://yaml.org/type/timestamp.html instead of using time.Parse.
+
+ // Quick check: all date formats start with YYYY-.
+ i := 0
+ for ; i < len(s); i++ {
+ if c := s[i]; c < '0' || c > '9' {
+ break
+ }
+ }
+ if i != 4 || i == len(s) || s[i] != '-' {
+ return time.Time{}, false
+ }
+ for _, format := range allowedTimestampFormats {
+ if t, err := time.Parse(format, s); err == nil {
+ return t, true
+ }
+ }
+ return time.Time{}, false
+}
diff --git a/vendor/go.yaml.in/yaml/v3/scannerc.go b/vendor/go.yaml.in/yaml/v3/scannerc.go
new file mode 100644
index 00000000..30b1f089
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/scannerc.go
@@ -0,0 +1,3040 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+// Copyright (c) 2006-2010 Kirill Simonov
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+// of the Software, and to permit persons to whom the Software is furnished to do
+// so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package yaml
+
+import (
+ "bytes"
+ "fmt"
+)
+
+// Introduction
+// ************
+//
+// The following notes assume that you are familiar with the YAML specification
+// (http://yaml.org/spec/1.2/spec.html). We mostly follow it, although in
+// some cases we are less restrictive that it requires.
+//
+// The process of transforming a YAML stream into a sequence of events is
+// divided on two steps: Scanning and Parsing.
+//
+// The Scanner transforms the input stream into a sequence of tokens, while the
+// parser transform the sequence of tokens produced by the Scanner into a
+// sequence of parsing events.
+//
+// The Scanner is rather clever and complicated. The Parser, on the contrary,
+// is a straightforward implementation of a recursive-descendant parser (or,
+// LL(1) parser, as it is usually called).
+//
+// Actually there are two issues of Scanning that might be called "clever", the
+// rest is quite straightforward. The issues are "block collection start" and
+// "simple keys". Both issues are explained below in details.
+//
+// Here the Scanning step is explained and implemented. We start with the list
+// of all the tokens produced by the Scanner together with short descriptions.
+//
+// Now, tokens:
+//
+// STREAM-START(encoding) # The stream start.
+// STREAM-END # The stream end.
+// VERSION-DIRECTIVE(major,minor) # The '%YAML' directive.
+// TAG-DIRECTIVE(handle,prefix) # The '%TAG' directive.
+// DOCUMENT-START # '---'
+// DOCUMENT-END # '...'
+// BLOCK-SEQUENCE-START # Indentation increase denoting a block
+// BLOCK-MAPPING-START # sequence or a block mapping.
+// BLOCK-END # Indentation decrease.
+// FLOW-SEQUENCE-START # '['
+// FLOW-SEQUENCE-END # ']'
+// BLOCK-SEQUENCE-START # '{'
+// BLOCK-SEQUENCE-END # '}'
+// BLOCK-ENTRY # '-'
+// FLOW-ENTRY # ','
+// KEY # '?' or nothing (simple keys).
+// VALUE # ':'
+// ALIAS(anchor) # '*anchor'
+// ANCHOR(anchor) # '&anchor'
+// TAG(handle,suffix) # '!handle!suffix'
+// SCALAR(value,style) # A scalar.
+//
+// The following two tokens are "virtual" tokens denoting the beginning and the
+// end of the stream:
+//
+// STREAM-START(encoding)
+// STREAM-END
+//
+// We pass the information about the input stream encoding with the
+// STREAM-START token.
+//
+// The next two tokens are responsible for tags:
+//
+// VERSION-DIRECTIVE(major,minor)
+// TAG-DIRECTIVE(handle,prefix)
+//
+// Example:
+//
+// %YAML 1.1
+// %TAG ! !foo
+// %TAG !yaml! tag:yaml.org,2002:
+// ---
+//
+// The correspoding sequence of tokens:
+//
+// STREAM-START(utf-8)
+// VERSION-DIRECTIVE(1,1)
+// TAG-DIRECTIVE("!","!foo")
+// TAG-DIRECTIVE("!yaml","tag:yaml.org,2002:")
+// DOCUMENT-START
+// STREAM-END
+//
+// Note that the VERSION-DIRECTIVE and TAG-DIRECTIVE tokens occupy a whole
+// line.
+//
+// The document start and end indicators are represented by:
+//
+// DOCUMENT-START
+// DOCUMENT-END
+//
+// Note that if a YAML stream contains an implicit document (without '---'
+// and '...' indicators), no DOCUMENT-START and DOCUMENT-END tokens will be
+// produced.
+//
+// In the following examples, we present whole documents together with the
+// produced tokens.
+//
+// 1. An implicit document:
+//
+// 'a scalar'
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// SCALAR("a scalar",single-quoted)
+// STREAM-END
+//
+// 2. An explicit document:
+//
+// ---
+// 'a scalar'
+// ...
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// DOCUMENT-START
+// SCALAR("a scalar",single-quoted)
+// DOCUMENT-END
+// STREAM-END
+//
+// 3. Several documents in a stream:
+//
+// 'a scalar'
+// ---
+// 'another scalar'
+// ---
+// 'yet another scalar'
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// SCALAR("a scalar",single-quoted)
+// DOCUMENT-START
+// SCALAR("another scalar",single-quoted)
+// DOCUMENT-START
+// SCALAR("yet another scalar",single-quoted)
+// STREAM-END
+//
+// We have already introduced the SCALAR token above. The following tokens are
+// used to describe aliases, anchors, tag, and scalars:
+//
+// ALIAS(anchor)
+// ANCHOR(anchor)
+// TAG(handle,suffix)
+// SCALAR(value,style)
+//
+// The following series of examples illustrate the usage of these tokens:
+//
+// 1. A recursive sequence:
+//
+// &A [ *A ]
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// ANCHOR("A")
+// FLOW-SEQUENCE-START
+// ALIAS("A")
+// FLOW-SEQUENCE-END
+// STREAM-END
+//
+// 2. A tagged scalar:
+//
+// !!float "3.14" # A good approximation.
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// TAG("!!","float")
+// SCALAR("3.14",double-quoted)
+// STREAM-END
+//
+// 3. Various scalar styles:
+//
+// --- # Implicit empty plain scalars do not produce tokens.
+// --- a plain scalar
+// --- 'a single-quoted scalar'
+// --- "a double-quoted scalar"
+// --- |-
+// a literal scalar
+// --- >-
+// a folded
+// scalar
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// DOCUMENT-START
+// DOCUMENT-START
+// SCALAR("a plain scalar",plain)
+// DOCUMENT-START
+// SCALAR("a single-quoted scalar",single-quoted)
+// DOCUMENT-START
+// SCALAR("a double-quoted scalar",double-quoted)
+// DOCUMENT-START
+// SCALAR("a literal scalar",literal)
+// DOCUMENT-START
+// SCALAR("a folded scalar",folded)
+// STREAM-END
+//
+// Now it's time to review collection-related tokens. We will start with
+// flow collections:
+//
+// FLOW-SEQUENCE-START
+// FLOW-SEQUENCE-END
+// FLOW-MAPPING-START
+// FLOW-MAPPING-END
+// FLOW-ENTRY
+// KEY
+// VALUE
+//
+// The tokens FLOW-SEQUENCE-START, FLOW-SEQUENCE-END, FLOW-MAPPING-START, and
+// FLOW-MAPPING-END represent the indicators '[', ']', '{', and '}'
+// correspondingly. FLOW-ENTRY represent the ',' indicator. Finally the
+// indicators '?' and ':', which are used for denoting mapping keys and values,
+// are represented by the KEY and VALUE tokens.
+//
+// The following examples show flow collections:
+//
+// 1. A flow sequence:
+//
+// [item 1, item 2, item 3]
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// FLOW-SEQUENCE-START
+// SCALAR("item 1",plain)
+// FLOW-ENTRY
+// SCALAR("item 2",plain)
+// FLOW-ENTRY
+// SCALAR("item 3",plain)
+// FLOW-SEQUENCE-END
+// STREAM-END
+//
+// 2. A flow mapping:
+//
+// {
+// a simple key: a value, # Note that the KEY token is produced.
+// ? a complex key: another value,
+// }
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// FLOW-MAPPING-START
+// KEY
+// SCALAR("a simple key",plain)
+// VALUE
+// SCALAR("a value",plain)
+// FLOW-ENTRY
+// KEY
+// SCALAR("a complex key",plain)
+// VALUE
+// SCALAR("another value",plain)
+// FLOW-ENTRY
+// FLOW-MAPPING-END
+// STREAM-END
+//
+// A simple key is a key which is not denoted by the '?' indicator. Note that
+// the Scanner still produce the KEY token whenever it encounters a simple key.
+//
+// For scanning block collections, the following tokens are used (note that we
+// repeat KEY and VALUE here):
+//
+// BLOCK-SEQUENCE-START
+// BLOCK-MAPPING-START
+// BLOCK-END
+// BLOCK-ENTRY
+// KEY
+// VALUE
+//
+// The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation
+// increase that precedes a block collection (cf. the INDENT token in Python).
+// The token BLOCK-END denote indentation decrease that ends a block collection
+// (cf. the DEDENT token in Python). However YAML has some syntax pecularities
+// that makes detections of these tokens more complex.
+//
+// The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators
+// '-', '?', and ':' correspondingly.
+//
+// The following examples show how the tokens BLOCK-SEQUENCE-START,
+// BLOCK-MAPPING-START, and BLOCK-END are emitted by the Scanner:
+//
+// 1. Block sequences:
+//
+// - item 1
+// - item 2
+// -
+// - item 3.1
+// - item 3.2
+// -
+// key 1: value 1
+// key 2: value 2
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// BLOCK-SEQUENCE-START
+// BLOCK-ENTRY
+// SCALAR("item 1",plain)
+// BLOCK-ENTRY
+// SCALAR("item 2",plain)
+// BLOCK-ENTRY
+// BLOCK-SEQUENCE-START
+// BLOCK-ENTRY
+// SCALAR("item 3.1",plain)
+// BLOCK-ENTRY
+// SCALAR("item 3.2",plain)
+// BLOCK-END
+// BLOCK-ENTRY
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("key 1",plain)
+// VALUE
+// SCALAR("value 1",plain)
+// KEY
+// SCALAR("key 2",plain)
+// VALUE
+// SCALAR("value 2",plain)
+// BLOCK-END
+// BLOCK-END
+// STREAM-END
+//
+// 2. Block mappings:
+//
+// a simple key: a value # The KEY token is produced here.
+// ? a complex key
+// : another value
+// a mapping:
+// key 1: value 1
+// key 2: value 2
+// a sequence:
+// - item 1
+// - item 2
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("a simple key",plain)
+// VALUE
+// SCALAR("a value",plain)
+// KEY
+// SCALAR("a complex key",plain)
+// VALUE
+// SCALAR("another value",plain)
+// KEY
+// SCALAR("a mapping",plain)
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("key 1",plain)
+// VALUE
+// SCALAR("value 1",plain)
+// KEY
+// SCALAR("key 2",plain)
+// VALUE
+// SCALAR("value 2",plain)
+// BLOCK-END
+// KEY
+// SCALAR("a sequence",plain)
+// VALUE
+// BLOCK-SEQUENCE-START
+// BLOCK-ENTRY
+// SCALAR("item 1",plain)
+// BLOCK-ENTRY
+// SCALAR("item 2",plain)
+// BLOCK-END
+// BLOCK-END
+// STREAM-END
+//
+// YAML does not always require to start a new block collection from a new
+// line. If the current line contains only '-', '?', and ':' indicators, a new
+// block collection may start at the current line. The following examples
+// illustrate this case:
+//
+// 1. Collections in a sequence:
+//
+// - - item 1
+// - item 2
+// - key 1: value 1
+// key 2: value 2
+// - ? complex key
+// : complex value
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// BLOCK-SEQUENCE-START
+// BLOCK-ENTRY
+// BLOCK-SEQUENCE-START
+// BLOCK-ENTRY
+// SCALAR("item 1",plain)
+// BLOCK-ENTRY
+// SCALAR("item 2",plain)
+// BLOCK-END
+// BLOCK-ENTRY
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("key 1",plain)
+// VALUE
+// SCALAR("value 1",plain)
+// KEY
+// SCALAR("key 2",plain)
+// VALUE
+// SCALAR("value 2",plain)
+// BLOCK-END
+// BLOCK-ENTRY
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("complex key")
+// VALUE
+// SCALAR("complex value")
+// BLOCK-END
+// BLOCK-END
+// STREAM-END
+//
+// 2. Collections in a mapping:
+//
+// ? a sequence
+// : - item 1
+// - item 2
+// ? a mapping
+// : key 1: value 1
+// key 2: value 2
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("a sequence",plain)
+// VALUE
+// BLOCK-SEQUENCE-START
+// BLOCK-ENTRY
+// SCALAR("item 1",plain)
+// BLOCK-ENTRY
+// SCALAR("item 2",plain)
+// BLOCK-END
+// KEY
+// SCALAR("a mapping",plain)
+// VALUE
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("key 1",plain)
+// VALUE
+// SCALAR("value 1",plain)
+// KEY
+// SCALAR("key 2",plain)
+// VALUE
+// SCALAR("value 2",plain)
+// BLOCK-END
+// BLOCK-END
+// STREAM-END
+//
+// YAML also permits non-indented sequences if they are included into a block
+// mapping. In this case, the token BLOCK-SEQUENCE-START is not produced:
+//
+// key:
+// - item 1 # BLOCK-SEQUENCE-START is NOT produced here.
+// - item 2
+//
+// Tokens:
+//
+// STREAM-START(utf-8)
+// BLOCK-MAPPING-START
+// KEY
+// SCALAR("key",plain)
+// VALUE
+// BLOCK-ENTRY
+// SCALAR("item 1",plain)
+// BLOCK-ENTRY
+// SCALAR("item 2",plain)
+// BLOCK-END
+//
+
+// Ensure that the buffer contains the required number of characters.
+// Return true on success, false on failure (reader error or memory error).
+func cache(parser *yaml_parser_t, length int) bool {
+ // [Go] This was inlined: !cache(A, B) -> unread < B && !update(A, B)
+ return parser.unread >= length || yaml_parser_update_buffer(parser, length)
+}
+
+// Advance the buffer pointer.
+func skip(parser *yaml_parser_t) {
+ if !is_blank(parser.buffer, parser.buffer_pos) {
+ parser.newlines = 0
+ }
+ parser.mark.index++
+ parser.mark.column++
+ parser.unread--
+ parser.buffer_pos += width(parser.buffer[parser.buffer_pos])
+}
+
+func skip_line(parser *yaml_parser_t) {
+ if is_crlf(parser.buffer, parser.buffer_pos) {
+ parser.mark.index += 2
+ parser.mark.column = 0
+ parser.mark.line++
+ parser.unread -= 2
+ parser.buffer_pos += 2
+ parser.newlines++
+ } else if is_break(parser.buffer, parser.buffer_pos) {
+ parser.mark.index++
+ parser.mark.column = 0
+ parser.mark.line++
+ parser.unread--
+ parser.buffer_pos += width(parser.buffer[parser.buffer_pos])
+ parser.newlines++
+ }
+}
+
+// Copy a character to a string buffer and advance pointers.
+func read(parser *yaml_parser_t, s []byte) []byte {
+ if !is_blank(parser.buffer, parser.buffer_pos) {
+ parser.newlines = 0
+ }
+ w := width(parser.buffer[parser.buffer_pos])
+ if w == 0 {
+ panic("invalid character sequence")
+ }
+ if len(s) == 0 {
+ s = make([]byte, 0, 32)
+ }
+ if w == 1 && len(s)+w <= cap(s) {
+ s = s[:len(s)+1]
+ s[len(s)-1] = parser.buffer[parser.buffer_pos]
+ parser.buffer_pos++
+ } else {
+ s = append(s, parser.buffer[parser.buffer_pos:parser.buffer_pos+w]...)
+ parser.buffer_pos += w
+ }
+ parser.mark.index++
+ parser.mark.column++
+ parser.unread--
+ return s
+}
+
+// Copy a line break character to a string buffer and advance pointers.
+func read_line(parser *yaml_parser_t, s []byte) []byte {
+ buf := parser.buffer
+ pos := parser.buffer_pos
+ switch {
+ case buf[pos] == '\r' && buf[pos+1] == '\n':
+ // CR LF . LF
+ s = append(s, '\n')
+ parser.buffer_pos += 2
+ parser.mark.index++
+ parser.unread--
+ case buf[pos] == '\r' || buf[pos] == '\n':
+ // CR|LF . LF
+ s = append(s, '\n')
+ parser.buffer_pos += 1
+ case buf[pos] == '\xC2' && buf[pos+1] == '\x85':
+ // NEL . LF
+ s = append(s, '\n')
+ parser.buffer_pos += 2
+ case buf[pos] == '\xE2' && buf[pos+1] == '\x80' && (buf[pos+2] == '\xA8' || buf[pos+2] == '\xA9'):
+ // LS|PS . LS|PS
+ s = append(s, buf[parser.buffer_pos:pos+3]...)
+ parser.buffer_pos += 3
+ default:
+ return s
+ }
+ parser.mark.index++
+ parser.mark.column = 0
+ parser.mark.line++
+ parser.unread--
+ parser.newlines++
+ return s
+}
+
+// Get the next token.
+func yaml_parser_scan(parser *yaml_parser_t, token *yaml_token_t) bool {
+ // Erase the token object.
+ *token = yaml_token_t{} // [Go] Is this necessary?
+
+ // No tokens after STREAM-END or error.
+ if parser.stream_end_produced || parser.error != yaml_NO_ERROR {
+ return true
+ }
+
+ // Ensure that the tokens queue contains enough tokens.
+ if !parser.token_available {
+ if !yaml_parser_fetch_more_tokens(parser) {
+ return false
+ }
+ }
+
+ // Fetch the next token from the queue.
+ *token = parser.tokens[parser.tokens_head]
+ parser.tokens_head++
+ parser.tokens_parsed++
+ parser.token_available = false
+
+ if token.typ == yaml_STREAM_END_TOKEN {
+ parser.stream_end_produced = true
+ }
+ return true
+}
+
+// Set the scanner error and return false.
+func yaml_parser_set_scanner_error(parser *yaml_parser_t, context string, context_mark yaml_mark_t, problem string) bool {
+ parser.error = yaml_SCANNER_ERROR
+ parser.context = context
+ parser.context_mark = context_mark
+ parser.problem = problem
+ parser.problem_mark = parser.mark
+ return false
+}
+
+func yaml_parser_set_scanner_tag_error(parser *yaml_parser_t, directive bool, context_mark yaml_mark_t, problem string) bool {
+ context := "while parsing a tag"
+ if directive {
+ context = "while parsing a %TAG directive"
+ }
+ return yaml_parser_set_scanner_error(parser, context, context_mark, problem)
+}
+
+func trace(args ...interface{}) func() {
+ pargs := append([]interface{}{"+++"}, args...)
+ fmt.Println(pargs...)
+ pargs = append([]interface{}{"---"}, args...)
+ return func() { fmt.Println(pargs...) }
+}
+
+// Ensure that the tokens queue contains at least one token which can be
+// returned to the Parser.
+func yaml_parser_fetch_more_tokens(parser *yaml_parser_t) bool {
+ // While we need more tokens to fetch, do it.
+ for {
+ // [Go] The comment parsing logic requires a lookahead of two tokens
+ // so that foot comments may be parsed in time of associating them
+ // with the tokens that are parsed before them, and also for line
+ // comments to be transformed into head comments in some edge cases.
+ if parser.tokens_head < len(parser.tokens)-2 {
+ // If a potential simple key is at the head position, we need to fetch
+ // the next token to disambiguate it.
+ head_tok_idx, ok := parser.simple_keys_by_tok[parser.tokens_parsed]
+ if !ok {
+ break
+ } else if valid, ok := yaml_simple_key_is_valid(parser, &parser.simple_keys[head_tok_idx]); !ok {
+ return false
+ } else if !valid {
+ break
+ }
+ }
+ // Fetch the next token.
+ if !yaml_parser_fetch_next_token(parser) {
+ return false
+ }
+ }
+
+ parser.token_available = true
+ return true
+}
+
+// The dispatcher for token fetchers.
+func yaml_parser_fetch_next_token(parser *yaml_parser_t) (ok bool) {
+ // Ensure that the buffer is initialized.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ // Check if we just started scanning. Fetch STREAM-START then.
+ if !parser.stream_start_produced {
+ return yaml_parser_fetch_stream_start(parser)
+ }
+
+ scan_mark := parser.mark
+
+ // Eat whitespaces and comments until we reach the next token.
+ if !yaml_parser_scan_to_next_token(parser) {
+ return false
+ }
+
+ // [Go] While unrolling indents, transform the head comments of prior
+ // indentation levels observed after scan_start into foot comments at
+ // the respective indexes.
+
+ // Check the indentation level against the current column.
+ if !yaml_parser_unroll_indent(parser, parser.mark.column, scan_mark) {
+ return false
+ }
+
+ // Ensure that the buffer contains at least 4 characters. 4 is the length
+ // of the longest indicators ('--- ' and '... ').
+ if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {
+ return false
+ }
+
+ // Is it the end of the stream?
+ if is_z(parser.buffer, parser.buffer_pos) {
+ return yaml_parser_fetch_stream_end(parser)
+ }
+
+ // Is it a directive?
+ if parser.mark.column == 0 && parser.buffer[parser.buffer_pos] == '%' {
+ return yaml_parser_fetch_directive(parser)
+ }
+
+ buf := parser.buffer
+ pos := parser.buffer_pos
+
+ // Is it the document start indicator?
+ if parser.mark.column == 0 && buf[pos] == '-' && buf[pos+1] == '-' && buf[pos+2] == '-' && is_blankz(buf, pos+3) {
+ return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_START_TOKEN)
+ }
+
+ // Is it the document end indicator?
+ if parser.mark.column == 0 && buf[pos] == '.' && buf[pos+1] == '.' && buf[pos+2] == '.' && is_blankz(buf, pos+3) {
+ return yaml_parser_fetch_document_indicator(parser, yaml_DOCUMENT_END_TOKEN)
+ }
+
+ comment_mark := parser.mark
+ if len(parser.tokens) > 0 && (parser.flow_level == 0 && buf[pos] == ':' || parser.flow_level > 0 && buf[pos] == ',') {
+ // Associate any following comments with the prior token.
+ comment_mark = parser.tokens[len(parser.tokens)-1].start_mark
+ }
+ defer func() {
+ if !ok {
+ return
+ }
+ if len(parser.tokens) > 0 && parser.tokens[len(parser.tokens)-1].typ == yaml_BLOCK_ENTRY_TOKEN {
+ // Sequence indicators alone have no line comments. It becomes
+ // a head comment for whatever follows.
+ return
+ }
+ if !yaml_parser_scan_line_comment(parser, comment_mark) {
+ ok = false
+ return
+ }
+ }()
+
+ // Is it the flow sequence start indicator?
+ if buf[pos] == '[' {
+ return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_SEQUENCE_START_TOKEN)
+ }
+
+ // Is it the flow mapping start indicator?
+ if parser.buffer[parser.buffer_pos] == '{' {
+ return yaml_parser_fetch_flow_collection_start(parser, yaml_FLOW_MAPPING_START_TOKEN)
+ }
+
+ // Is it the flow sequence end indicator?
+ if parser.buffer[parser.buffer_pos] == ']' {
+ return yaml_parser_fetch_flow_collection_end(parser,
+ yaml_FLOW_SEQUENCE_END_TOKEN)
+ }
+
+ // Is it the flow mapping end indicator?
+ if parser.buffer[parser.buffer_pos] == '}' {
+ return yaml_parser_fetch_flow_collection_end(parser,
+ yaml_FLOW_MAPPING_END_TOKEN)
+ }
+
+ // Is it the flow entry indicator?
+ if parser.buffer[parser.buffer_pos] == ',' {
+ return yaml_parser_fetch_flow_entry(parser)
+ }
+
+ // Is it the block entry indicator?
+ if parser.buffer[parser.buffer_pos] == '-' && is_blankz(parser.buffer, parser.buffer_pos+1) {
+ return yaml_parser_fetch_block_entry(parser)
+ }
+
+ // Is it the key indicator?
+ if parser.buffer[parser.buffer_pos] == '?' && (parser.flow_level > 0 || is_blankz(parser.buffer, parser.buffer_pos+1)) {
+ return yaml_parser_fetch_key(parser)
+ }
+
+ // Is it the value indicator?
+ if parser.buffer[parser.buffer_pos] == ':' && (parser.flow_level > 0 || is_blankz(parser.buffer, parser.buffer_pos+1)) {
+ return yaml_parser_fetch_value(parser)
+ }
+
+ // Is it an alias?
+ if parser.buffer[parser.buffer_pos] == '*' {
+ return yaml_parser_fetch_anchor(parser, yaml_ALIAS_TOKEN)
+ }
+
+ // Is it an anchor?
+ if parser.buffer[parser.buffer_pos] == '&' {
+ return yaml_parser_fetch_anchor(parser, yaml_ANCHOR_TOKEN)
+ }
+
+ // Is it a tag?
+ if parser.buffer[parser.buffer_pos] == '!' {
+ return yaml_parser_fetch_tag(parser)
+ }
+
+ // Is it a literal scalar?
+ if parser.buffer[parser.buffer_pos] == '|' && parser.flow_level == 0 {
+ return yaml_parser_fetch_block_scalar(parser, true)
+ }
+
+ // Is it a folded scalar?
+ if parser.buffer[parser.buffer_pos] == '>' && parser.flow_level == 0 {
+ return yaml_parser_fetch_block_scalar(parser, false)
+ }
+
+ // Is it a single-quoted scalar?
+ if parser.buffer[parser.buffer_pos] == '\'' {
+ return yaml_parser_fetch_flow_scalar(parser, true)
+ }
+
+ // Is it a double-quoted scalar?
+ if parser.buffer[parser.buffer_pos] == '"' {
+ return yaml_parser_fetch_flow_scalar(parser, false)
+ }
+
+ // Is it a plain scalar?
+ //
+ // A plain scalar may start with any non-blank characters except
+ //
+ // '-', '?', ':', ',', '[', ']', '{', '}',
+ // '#', '&', '*', '!', '|', '>', '\'', '\"',
+ // '%', '@', '`'.
+ //
+ // In the block context (and, for the '-' indicator, in the flow context
+ // too), it may also start with the characters
+ //
+ // '-', '?', ':'
+ //
+ // if it is followed by a non-space character.
+ //
+ // The last rule is more restrictive than the specification requires.
+ // [Go] TODO Make this logic more reasonable.
+ //switch parser.buffer[parser.buffer_pos] {
+ //case '-', '?', ':', ',', '?', '-', ',', ':', ']', '[', '}', '{', '&', '#', '!', '*', '>', '|', '"', '\'', '@', '%', '-', '`':
+ //}
+ if !(is_blankz(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == '-' ||
+ parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == ':' ||
+ parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '[' ||
+ parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '{' ||
+ parser.buffer[parser.buffer_pos] == '}' || parser.buffer[parser.buffer_pos] == '#' ||
+ parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '*' ||
+ parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '|' ||
+ parser.buffer[parser.buffer_pos] == '>' || parser.buffer[parser.buffer_pos] == '\'' ||
+ parser.buffer[parser.buffer_pos] == '"' || parser.buffer[parser.buffer_pos] == '%' ||
+ parser.buffer[parser.buffer_pos] == '@' || parser.buffer[parser.buffer_pos] == '`') ||
+ (parser.buffer[parser.buffer_pos] == '-' && !is_blank(parser.buffer, parser.buffer_pos+1)) ||
+ (parser.flow_level == 0 &&
+ (parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == ':') &&
+ !is_blankz(parser.buffer, parser.buffer_pos+1)) {
+ return yaml_parser_fetch_plain_scalar(parser)
+ }
+
+ // If we don't determine the token type so far, it is an error.
+ return yaml_parser_set_scanner_error(parser,
+ "while scanning for the next token", parser.mark,
+ "found character that cannot start any token")
+}
+
+func yaml_simple_key_is_valid(parser *yaml_parser_t, simple_key *yaml_simple_key_t) (valid, ok bool) {
+ if !simple_key.possible {
+ return false, true
+ }
+
+ // The 1.2 specification says:
+ //
+ // "If the ? indicator is omitted, parsing needs to see past the
+ // implicit key to recognize it as such. To limit the amount of
+ // lookahead required, the “:” indicator must appear at most 1024
+ // Unicode characters beyond the start of the key. In addition, the key
+ // is restricted to a single line."
+ //
+ if simple_key.mark.line < parser.mark.line || simple_key.mark.index+1024 < parser.mark.index {
+ // Check if the potential simple key to be removed is required.
+ if simple_key.required {
+ return false, yaml_parser_set_scanner_error(parser,
+ "while scanning a simple key", simple_key.mark,
+ "could not find expected ':'")
+ }
+ simple_key.possible = false
+ return false, true
+ }
+ return true, true
+}
+
+// Check if a simple key may start at the current position and add it if
+// needed.
+func yaml_parser_save_simple_key(parser *yaml_parser_t) bool {
+ // A simple key is required at the current position if the scanner is in
+ // the block context and the current column coincides with the indentation
+ // level.
+
+ required := parser.flow_level == 0 && parser.indent == parser.mark.column
+
+ //
+ // If the current position may start a simple key, save it.
+ //
+ if parser.simple_key_allowed {
+ simple_key := yaml_simple_key_t{
+ possible: true,
+ required: required,
+ token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head),
+ mark: parser.mark,
+ }
+
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+ parser.simple_keys[len(parser.simple_keys)-1] = simple_key
+ parser.simple_keys_by_tok[simple_key.token_number] = len(parser.simple_keys) - 1
+ }
+ return true
+}
+
+// Remove a potential simple key at the current flow level.
+func yaml_parser_remove_simple_key(parser *yaml_parser_t) bool {
+ i := len(parser.simple_keys) - 1
+ if parser.simple_keys[i].possible {
+ // If the key is required, it is an error.
+ if parser.simple_keys[i].required {
+ return yaml_parser_set_scanner_error(parser,
+ "while scanning a simple key", parser.simple_keys[i].mark,
+ "could not find expected ':'")
+ }
+ // Remove the key from the stack.
+ parser.simple_keys[i].possible = false
+ delete(parser.simple_keys_by_tok, parser.simple_keys[i].token_number)
+ }
+ return true
+}
+
+// max_flow_level limits the flow_level
+const max_flow_level = 10000
+
+// Increase the flow level and resize the simple key list if needed.
+func yaml_parser_increase_flow_level(parser *yaml_parser_t) bool {
+ // Reset the simple key on the next level.
+ parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{
+ possible: false,
+ required: false,
+ token_number: parser.tokens_parsed + (len(parser.tokens) - parser.tokens_head),
+ mark: parser.mark,
+ })
+
+ // Increase the flow level.
+ parser.flow_level++
+ if parser.flow_level > max_flow_level {
+ return yaml_parser_set_scanner_error(parser,
+ "while increasing flow level", parser.simple_keys[len(parser.simple_keys)-1].mark,
+ fmt.Sprintf("exceeded max depth of %d", max_flow_level))
+ }
+ return true
+}
+
+// Decrease the flow level.
+func yaml_parser_decrease_flow_level(parser *yaml_parser_t) bool {
+ if parser.flow_level > 0 {
+ parser.flow_level--
+ last := len(parser.simple_keys) - 1
+ delete(parser.simple_keys_by_tok, parser.simple_keys[last].token_number)
+ parser.simple_keys = parser.simple_keys[:last]
+ }
+ return true
+}
+
+// max_indents limits the indents stack size
+const max_indents = 10000
+
+// Push the current indentation level to the stack and set the new level
+// the current column is greater than the indentation level. In this case,
+// append or insert the specified token into the token queue.
+func yaml_parser_roll_indent(parser *yaml_parser_t, column, number int, typ yaml_token_type_t, mark yaml_mark_t) bool {
+ // In the flow context, do nothing.
+ if parser.flow_level > 0 {
+ return true
+ }
+
+ if parser.indent < column {
+ // Push the current indentation level to the stack and set the new
+ // indentation level.
+ parser.indents = append(parser.indents, parser.indent)
+ parser.indent = column
+ if len(parser.indents) > max_indents {
+ return yaml_parser_set_scanner_error(parser,
+ "while increasing indent level", parser.simple_keys[len(parser.simple_keys)-1].mark,
+ fmt.Sprintf("exceeded max depth of %d", max_indents))
+ }
+
+ // Create a token and insert it into the queue.
+ token := yaml_token_t{
+ typ: typ,
+ start_mark: mark,
+ end_mark: mark,
+ }
+ if number > -1 {
+ number -= parser.tokens_parsed
+ }
+ yaml_insert_token(parser, number, &token)
+ }
+ return true
+}
+
+// Pop indentation levels from the indents stack until the current level
+// becomes less or equal to the column. For each indentation level, append
+// the BLOCK-END token.
+func yaml_parser_unroll_indent(parser *yaml_parser_t, column int, scan_mark yaml_mark_t) bool {
+ // In the flow context, do nothing.
+ if parser.flow_level > 0 {
+ return true
+ }
+
+ block_mark := scan_mark
+ block_mark.index--
+
+ // Loop through the indentation levels in the stack.
+ for parser.indent > column {
+
+ // [Go] Reposition the end token before potential following
+ // foot comments of parent blocks. For that, search
+ // backwards for recent comments that were at the same
+ // indent as the block that is ending now.
+ stop_index := block_mark.index
+ for i := len(parser.comments) - 1; i >= 0; i-- {
+ comment := &parser.comments[i]
+
+ if comment.end_mark.index < stop_index {
+ // Don't go back beyond the start of the comment/whitespace scan, unless column < 0.
+ // If requested indent column is < 0, then the document is over and everything else
+ // is a foot anyway.
+ break
+ }
+ if comment.start_mark.column == parser.indent+1 {
+ // This is a good match. But maybe there's a former comment
+ // at that same indent level, so keep searching.
+ block_mark = comment.start_mark
+ }
+
+ // While the end of the former comment matches with
+ // the start of the following one, we know there's
+ // nothing in between and scanning is still safe.
+ stop_index = comment.scan_mark.index
+ }
+
+ // Create a token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_BLOCK_END_TOKEN,
+ start_mark: block_mark,
+ end_mark: block_mark,
+ }
+ yaml_insert_token(parser, -1, &token)
+
+ // Pop the indentation level.
+ parser.indent = parser.indents[len(parser.indents)-1]
+ parser.indents = parser.indents[:len(parser.indents)-1]
+ }
+ return true
+}
+
+// Initialize the scanner and produce the STREAM-START token.
+func yaml_parser_fetch_stream_start(parser *yaml_parser_t) bool {
+
+ // Set the initial indentation.
+ parser.indent = -1
+
+ // Initialize the simple key stack.
+ parser.simple_keys = append(parser.simple_keys, yaml_simple_key_t{})
+
+ parser.simple_keys_by_tok = make(map[int]int)
+
+ // A simple key is allowed at the beginning of the stream.
+ parser.simple_key_allowed = true
+
+ // We have started.
+ parser.stream_start_produced = true
+
+ // Create the STREAM-START token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_STREAM_START_TOKEN,
+ start_mark: parser.mark,
+ end_mark: parser.mark,
+ encoding: parser.encoding,
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the STREAM-END token and shut down the scanner.
+func yaml_parser_fetch_stream_end(parser *yaml_parser_t) bool {
+
+ // Force new line.
+ if parser.mark.column != 0 {
+ parser.mark.column = 0
+ parser.mark.line++
+ }
+
+ // Reset the indentation level.
+ if !yaml_parser_unroll_indent(parser, -1, parser.mark) {
+ return false
+ }
+
+ // Reset simple keys.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ parser.simple_key_allowed = false
+
+ // Create the STREAM-END token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_STREAM_END_TOKEN,
+ start_mark: parser.mark,
+ end_mark: parser.mark,
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token.
+func yaml_parser_fetch_directive(parser *yaml_parser_t) bool {
+ // Reset the indentation level.
+ if !yaml_parser_unroll_indent(parser, -1, parser.mark) {
+ return false
+ }
+
+ // Reset simple keys.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ parser.simple_key_allowed = false
+
+ // Create the YAML-DIRECTIVE or TAG-DIRECTIVE token.
+ token := yaml_token_t{}
+ if !yaml_parser_scan_directive(parser, &token) {
+ return false
+ }
+ // Append the token to the queue.
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the DOCUMENT-START or DOCUMENT-END token.
+func yaml_parser_fetch_document_indicator(parser *yaml_parser_t, typ yaml_token_type_t) bool {
+ // Reset the indentation level.
+ if !yaml_parser_unroll_indent(parser, -1, parser.mark) {
+ return false
+ }
+
+ // Reset simple keys.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ parser.simple_key_allowed = false
+
+ // Consume the token.
+ start_mark := parser.mark
+
+ skip(parser)
+ skip(parser)
+ skip(parser)
+
+ end_mark := parser.mark
+
+ // Create the DOCUMENT-START or DOCUMENT-END token.
+ token := yaml_token_t{
+ typ: typ,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ // Append the token to the queue.
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token.
+func yaml_parser_fetch_flow_collection_start(parser *yaml_parser_t, typ yaml_token_type_t) bool {
+
+ // The indicators '[' and '{' may start a simple key.
+ if !yaml_parser_save_simple_key(parser) {
+ return false
+ }
+
+ // Increase the flow level.
+ if !yaml_parser_increase_flow_level(parser) {
+ return false
+ }
+
+ // A simple key may follow the indicators '[' and '{'.
+ parser.simple_key_allowed = true
+
+ // Consume the token.
+ start_mark := parser.mark
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token.
+ token := yaml_token_t{
+ typ: typ,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ // Append the token to the queue.
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the FLOW-SEQUENCE-END or FLOW-MAPPING-END token.
+func yaml_parser_fetch_flow_collection_end(parser *yaml_parser_t, typ yaml_token_type_t) bool {
+ // Reset any potential simple key on the current flow level.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ // Decrease the flow level.
+ if !yaml_parser_decrease_flow_level(parser) {
+ return false
+ }
+
+ // No simple keys after the indicators ']' and '}'.
+ parser.simple_key_allowed = false
+
+ // Consume the token.
+
+ start_mark := parser.mark
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token.
+ token := yaml_token_t{
+ typ: typ,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ // Append the token to the queue.
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the FLOW-ENTRY token.
+func yaml_parser_fetch_flow_entry(parser *yaml_parser_t) bool {
+ // Reset any potential simple keys on the current flow level.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ // Simple keys are allowed after ','.
+ parser.simple_key_allowed = true
+
+ // Consume the token.
+ start_mark := parser.mark
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create the FLOW-ENTRY token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_FLOW_ENTRY_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the BLOCK-ENTRY token.
+func yaml_parser_fetch_block_entry(parser *yaml_parser_t) bool {
+ // Check if the scanner is in the block context.
+ if parser.flow_level == 0 {
+ // Check if we are allowed to start a new entry.
+ if !parser.simple_key_allowed {
+ return yaml_parser_set_scanner_error(parser, "", parser.mark,
+ "block sequence entries are not allowed in this context")
+ }
+ // Add the BLOCK-SEQUENCE-START token if needed.
+ if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_SEQUENCE_START_TOKEN, parser.mark) {
+ return false
+ }
+ } else {
+ // It is an error for the '-' indicator to occur in the flow context,
+ // but we let the Parser detect and report about it because the Parser
+ // is able to point to the context.
+ }
+
+ // Reset any potential simple keys on the current flow level.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ // Simple keys are allowed after '-'.
+ parser.simple_key_allowed = true
+
+ // Consume the token.
+ start_mark := parser.mark
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create the BLOCK-ENTRY token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_BLOCK_ENTRY_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the KEY token.
+func yaml_parser_fetch_key(parser *yaml_parser_t) bool {
+
+ // In the block context, additional checks are required.
+ if parser.flow_level == 0 {
+ // Check if we are allowed to start a new key (not nessesary simple).
+ if !parser.simple_key_allowed {
+ return yaml_parser_set_scanner_error(parser, "", parser.mark,
+ "mapping keys are not allowed in this context")
+ }
+ // Add the BLOCK-MAPPING-START token if needed.
+ if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) {
+ return false
+ }
+ }
+
+ // Reset any potential simple keys on the current flow level.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ // Simple keys are allowed after '?' in the block context.
+ parser.simple_key_allowed = parser.flow_level == 0
+
+ // Consume the token.
+ start_mark := parser.mark
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create the KEY token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_KEY_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the VALUE token.
+func yaml_parser_fetch_value(parser *yaml_parser_t) bool {
+
+ simple_key := &parser.simple_keys[len(parser.simple_keys)-1]
+
+ // Have we found a simple key?
+ if valid, ok := yaml_simple_key_is_valid(parser, simple_key); !ok {
+ return false
+
+ } else if valid {
+
+ // Create the KEY token and insert it into the queue.
+ token := yaml_token_t{
+ typ: yaml_KEY_TOKEN,
+ start_mark: simple_key.mark,
+ end_mark: simple_key.mark,
+ }
+ yaml_insert_token(parser, simple_key.token_number-parser.tokens_parsed, &token)
+
+ // In the block context, we may need to add the BLOCK-MAPPING-START token.
+ if !yaml_parser_roll_indent(parser, simple_key.mark.column,
+ simple_key.token_number,
+ yaml_BLOCK_MAPPING_START_TOKEN, simple_key.mark) {
+ return false
+ }
+
+ // Remove the simple key.
+ simple_key.possible = false
+ delete(parser.simple_keys_by_tok, simple_key.token_number)
+
+ // A simple key cannot follow another simple key.
+ parser.simple_key_allowed = false
+
+ } else {
+ // The ':' indicator follows a complex key.
+
+ // In the block context, extra checks are required.
+ if parser.flow_level == 0 {
+
+ // Check if we are allowed to start a complex value.
+ if !parser.simple_key_allowed {
+ return yaml_parser_set_scanner_error(parser, "", parser.mark,
+ "mapping values are not allowed in this context")
+ }
+
+ // Add the BLOCK-MAPPING-START token if needed.
+ if !yaml_parser_roll_indent(parser, parser.mark.column, -1, yaml_BLOCK_MAPPING_START_TOKEN, parser.mark) {
+ return false
+ }
+ }
+
+ // Simple keys after ':' are allowed in the block context.
+ parser.simple_key_allowed = parser.flow_level == 0
+ }
+
+ // Consume the token.
+ start_mark := parser.mark
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create the VALUE token and append it to the queue.
+ token := yaml_token_t{
+ typ: yaml_VALUE_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the ALIAS or ANCHOR token.
+func yaml_parser_fetch_anchor(parser *yaml_parser_t, typ yaml_token_type_t) bool {
+ // An anchor or an alias could be a simple key.
+ if !yaml_parser_save_simple_key(parser) {
+ return false
+ }
+
+ // A simple key cannot follow an anchor or an alias.
+ parser.simple_key_allowed = false
+
+ // Create the ALIAS or ANCHOR token and append it to the queue.
+ var token yaml_token_t
+ if !yaml_parser_scan_anchor(parser, &token, typ) {
+ return false
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the TAG token.
+func yaml_parser_fetch_tag(parser *yaml_parser_t) bool {
+ // A tag could be a simple key.
+ if !yaml_parser_save_simple_key(parser) {
+ return false
+ }
+
+ // A simple key cannot follow a tag.
+ parser.simple_key_allowed = false
+
+ // Create the TAG token and append it to the queue.
+ var token yaml_token_t
+ if !yaml_parser_scan_tag(parser, &token) {
+ return false
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the SCALAR(...,literal) or SCALAR(...,folded) tokens.
+func yaml_parser_fetch_block_scalar(parser *yaml_parser_t, literal bool) bool {
+ // Remove any potential simple keys.
+ if !yaml_parser_remove_simple_key(parser) {
+ return false
+ }
+
+ // A simple key may follow a block scalar.
+ parser.simple_key_allowed = true
+
+ // Create the SCALAR token and append it to the queue.
+ var token yaml_token_t
+ if !yaml_parser_scan_block_scalar(parser, &token, literal) {
+ return false
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the SCALAR(...,single-quoted) or SCALAR(...,double-quoted) tokens.
+func yaml_parser_fetch_flow_scalar(parser *yaml_parser_t, single bool) bool {
+ // A plain scalar could be a simple key.
+ if !yaml_parser_save_simple_key(parser) {
+ return false
+ }
+
+ // A simple key cannot follow a flow scalar.
+ parser.simple_key_allowed = false
+
+ // Create the SCALAR token and append it to the queue.
+ var token yaml_token_t
+ if !yaml_parser_scan_flow_scalar(parser, &token, single) {
+ return false
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Produce the SCALAR(...,plain) token.
+func yaml_parser_fetch_plain_scalar(parser *yaml_parser_t) bool {
+ // A plain scalar could be a simple key.
+ if !yaml_parser_save_simple_key(parser) {
+ return false
+ }
+
+ // A simple key cannot follow a flow scalar.
+ parser.simple_key_allowed = false
+
+ // Create the SCALAR token and append it to the queue.
+ var token yaml_token_t
+ if !yaml_parser_scan_plain_scalar(parser, &token) {
+ return false
+ }
+ yaml_insert_token(parser, -1, &token)
+ return true
+}
+
+// Eat whitespaces and comments until the next token is found.
+func yaml_parser_scan_to_next_token(parser *yaml_parser_t) bool {
+
+ scan_mark := parser.mark
+
+ // Until the next token is not found.
+ for {
+ // Allow the BOM mark to start a line.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if parser.mark.column == 0 && is_bom(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ }
+
+ // Eat whitespaces.
+ // Tabs are allowed:
+ // - in the flow context
+ // - in the block context, but not at the beginning of the line or
+ // after '-', '?', or ':' (complex value).
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ for parser.buffer[parser.buffer_pos] == ' ' || ((parser.flow_level > 0 || !parser.simple_key_allowed) && parser.buffer[parser.buffer_pos] == '\t') {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Check if we just had a line comment under a sequence entry that
+ // looks more like a header to the following content. Similar to this:
+ //
+ // - # The comment
+ // - Some data
+ //
+ // If so, transform the line comment to a head comment and reposition.
+ if len(parser.comments) > 0 && len(parser.tokens) > 1 {
+ tokenA := parser.tokens[len(parser.tokens)-2]
+ tokenB := parser.tokens[len(parser.tokens)-1]
+ comment := &parser.comments[len(parser.comments)-1]
+ if tokenA.typ == yaml_BLOCK_SEQUENCE_START_TOKEN && tokenB.typ == yaml_BLOCK_ENTRY_TOKEN && len(comment.line) > 0 && !is_break(parser.buffer, parser.buffer_pos) {
+ // If it was in the prior line, reposition so it becomes a
+ // header of the follow up token. Otherwise, keep it in place
+ // so it becomes a header of the former.
+ comment.head = comment.line
+ comment.line = nil
+ if comment.start_mark.line == parser.mark.line-1 {
+ comment.token_mark = parser.mark
+ }
+ }
+ }
+
+ // Eat a comment until a line break.
+ if parser.buffer[parser.buffer_pos] == '#' {
+ if !yaml_parser_scan_comments(parser, scan_mark) {
+ return false
+ }
+ }
+
+ // If it is a line break, eat it.
+ if is_break(parser.buffer, parser.buffer_pos) {
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ skip_line(parser)
+
+ // In the block context, a new line may start a simple key.
+ if parser.flow_level == 0 {
+ parser.simple_key_allowed = true
+ }
+ } else {
+ break // We have found a token.
+ }
+ }
+
+ return true
+}
+
+// Scan a YAML-DIRECTIVE or TAG-DIRECTIVE token.
+//
+// Scope:
+//
+// %YAML 1.1 # a comment \n
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+// %TAG !yaml! tag:yaml.org,2002: \n
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+func yaml_parser_scan_directive(parser *yaml_parser_t, token *yaml_token_t) bool {
+ // Eat '%'.
+ start_mark := parser.mark
+ skip(parser)
+
+ // Scan the directive name.
+ var name []byte
+ if !yaml_parser_scan_directive_name(parser, start_mark, &name) {
+ return false
+ }
+
+ // Is it a YAML directive?
+ if bytes.Equal(name, []byte("YAML")) {
+ // Scan the VERSION directive value.
+ var major, minor int8
+ if !yaml_parser_scan_version_directive_value(parser, start_mark, &major, &minor) {
+ return false
+ }
+ end_mark := parser.mark
+
+ // Create a VERSION-DIRECTIVE token.
+ *token = yaml_token_t{
+ typ: yaml_VERSION_DIRECTIVE_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ major: major,
+ minor: minor,
+ }
+
+ // Is it a TAG directive?
+ } else if bytes.Equal(name, []byte("TAG")) {
+ // Scan the TAG directive value.
+ var handle, prefix []byte
+ if !yaml_parser_scan_tag_directive_value(parser, start_mark, &handle, &prefix) {
+ return false
+ }
+ end_mark := parser.mark
+
+ // Create a TAG-DIRECTIVE token.
+ *token = yaml_token_t{
+ typ: yaml_TAG_DIRECTIVE_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ value: handle,
+ prefix: prefix,
+ }
+
+ // Unknown directive.
+ } else {
+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
+ start_mark, "found unknown directive name")
+ return false
+ }
+
+ // Eat the rest of the line including any comments.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ for is_blank(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ if parser.buffer[parser.buffer_pos] == '#' {
+ // [Go] Discard this inline comment for the time being.
+ //if !yaml_parser_scan_line_comment(parser, start_mark) {
+ // return false
+ //}
+ for !is_breakz(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+ }
+
+ // Check if we are at the end of the line.
+ if !is_breakz(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
+ start_mark, "did not find expected comment or line break")
+ return false
+ }
+
+ // Eat a line break.
+ if is_break(parser.buffer, parser.buffer_pos) {
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ skip_line(parser)
+ }
+
+ return true
+}
+
+// Scan the directive name.
+//
+// Scope:
+//
+// %YAML 1.1 # a comment \n
+// ^^^^
+// %TAG !yaml! tag:yaml.org,2002: \n
+// ^^^
+func yaml_parser_scan_directive_name(parser *yaml_parser_t, start_mark yaml_mark_t, name *[]byte) bool {
+ // Consume the directive name.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ var s []byte
+ for is_alpha(parser.buffer, parser.buffer_pos) {
+ s = read(parser, s)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Check if the name is empty.
+ if len(s) == 0 {
+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
+ start_mark, "could not find expected directive name")
+ return false
+ }
+
+ // Check for an blank character after the name.
+ if !is_blankz(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
+ start_mark, "found unexpected non-alphabetical character")
+ return false
+ }
+ *name = s
+ return true
+}
+
+// Scan the value of VERSION-DIRECTIVE.
+//
+// Scope:
+//
+// %YAML 1.1 # a comment \n
+// ^^^^^^
+func yaml_parser_scan_version_directive_value(parser *yaml_parser_t, start_mark yaml_mark_t, major, minor *int8) bool {
+ // Eat whitespaces.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ for is_blank(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Consume the major version number.
+ if !yaml_parser_scan_version_directive_number(parser, start_mark, major) {
+ return false
+ }
+
+ // Eat '.'.
+ if parser.buffer[parser.buffer_pos] != '.' {
+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
+ start_mark, "did not find expected digit or '.' character")
+ }
+
+ skip(parser)
+
+ // Consume the minor version number.
+ if !yaml_parser_scan_version_directive_number(parser, start_mark, minor) {
+ return false
+ }
+ return true
+}
+
+const max_number_length = 2
+
+// Scan the version number of VERSION-DIRECTIVE.
+//
+// Scope:
+//
+// %YAML 1.1 # a comment \n
+// ^
+// %YAML 1.1 # a comment \n
+// ^
+func yaml_parser_scan_version_directive_number(parser *yaml_parser_t, start_mark yaml_mark_t, number *int8) bool {
+
+ // Repeat while the next character is digit.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ var value, length int8
+ for is_digit(parser.buffer, parser.buffer_pos) {
+ // Check if the number is too long.
+ length++
+ if length > max_number_length {
+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
+ start_mark, "found extremely long version number")
+ }
+ value = value*10 + int8(as_digit(parser.buffer, parser.buffer_pos))
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Check if the number was present.
+ if length == 0 {
+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
+ start_mark, "did not find expected version number")
+ }
+ *number = value
+ return true
+}
+
+// Scan the value of a TAG-DIRECTIVE token.
+//
+// Scope:
+//
+// %TAG !yaml! tag:yaml.org,2002: \n
+// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+func yaml_parser_scan_tag_directive_value(parser *yaml_parser_t, start_mark yaml_mark_t, handle, prefix *[]byte) bool {
+ var handle_value, prefix_value []byte
+
+ // Eat whitespaces.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ for is_blank(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Scan a handle.
+ if !yaml_parser_scan_tag_handle(parser, true, start_mark, &handle_value) {
+ return false
+ }
+
+ // Expect a whitespace.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if !is_blank(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
+ start_mark, "did not find expected whitespace")
+ return false
+ }
+
+ // Eat whitespaces.
+ for is_blank(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Scan a prefix.
+ if !yaml_parser_scan_tag_uri(parser, true, nil, start_mark, &prefix_value) {
+ return false
+ }
+
+ // Expect a whitespace or line break.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if !is_blankz(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
+ start_mark, "did not find expected whitespace or line break")
+ return false
+ }
+
+ *handle = handle_value
+ *prefix = prefix_value
+ return true
+}
+
+func yaml_parser_scan_anchor(parser *yaml_parser_t, token *yaml_token_t, typ yaml_token_type_t) bool {
+ var s []byte
+
+ // Eat the indicator character.
+ start_mark := parser.mark
+ skip(parser)
+
+ // Consume the value.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ for is_alpha(parser.buffer, parser.buffer_pos) {
+ s = read(parser, s)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ end_mark := parser.mark
+
+ /*
+ * Check if length of the anchor is greater than 0 and it is followed by
+ * a whitespace character or one of the indicators:
+ *
+ * '?', ':', ',', ']', '}', '%', '@', '`'.
+ */
+
+ if len(s) == 0 ||
+ !(is_blankz(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == '?' ||
+ parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == ',' ||
+ parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '}' ||
+ parser.buffer[parser.buffer_pos] == '%' || parser.buffer[parser.buffer_pos] == '@' ||
+ parser.buffer[parser.buffer_pos] == '`') {
+ context := "while scanning an alias"
+ if typ == yaml_ANCHOR_TOKEN {
+ context = "while scanning an anchor"
+ }
+ yaml_parser_set_scanner_error(parser, context, start_mark,
+ "did not find expected alphabetic or numeric character")
+ return false
+ }
+
+ // Create a token.
+ *token = yaml_token_t{
+ typ: typ,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ value: s,
+ }
+
+ return true
+}
+
+/*
+ * Scan a TAG token.
+ */
+
+func yaml_parser_scan_tag(parser *yaml_parser_t, token *yaml_token_t) bool {
+ var handle, suffix []byte
+
+ start_mark := parser.mark
+
+ // Check if the tag is in the canonical form.
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+
+ if parser.buffer[parser.buffer_pos+1] == '<' {
+ // Keep the handle as ''
+
+ // Eat '!<'
+ skip(parser)
+ skip(parser)
+
+ // Consume the tag value.
+ if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) {
+ return false
+ }
+
+ // Check for '>' and eat it.
+ if parser.buffer[parser.buffer_pos] != '>' {
+ yaml_parser_set_scanner_error(parser, "while scanning a tag",
+ start_mark, "did not find the expected '>'")
+ return false
+ }
+
+ skip(parser)
+ } else {
+ // The tag has either the '!suffix' or the '!handle!suffix' form.
+
+ // First, try to scan a handle.
+ if !yaml_parser_scan_tag_handle(parser, false, start_mark, &handle) {
+ return false
+ }
+
+ // Check if it is, indeed, handle.
+ if handle[0] == '!' && len(handle) > 1 && handle[len(handle)-1] == '!' {
+ // Scan the suffix now.
+ if !yaml_parser_scan_tag_uri(parser, false, nil, start_mark, &suffix) {
+ return false
+ }
+ } else {
+ // It wasn't a handle after all. Scan the rest of the tag.
+ if !yaml_parser_scan_tag_uri(parser, false, handle, start_mark, &suffix) {
+ return false
+ }
+
+ // Set the handle to '!'.
+ handle = []byte{'!'}
+
+ // A special case: the '!' tag. Set the handle to '' and the
+ // suffix to '!'.
+ if len(suffix) == 0 {
+ handle, suffix = suffix, handle
+ }
+ }
+ }
+
+ // Check the character which ends the tag.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if !is_blankz(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a tag",
+ start_mark, "did not find expected whitespace or line break")
+ return false
+ }
+
+ end_mark := parser.mark
+
+ // Create a token.
+ *token = yaml_token_t{
+ typ: yaml_TAG_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ value: handle,
+ suffix: suffix,
+ }
+ return true
+}
+
+// Scan a tag handle.
+func yaml_parser_scan_tag_handle(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, handle *[]byte) bool {
+ // Check the initial '!' character.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if parser.buffer[parser.buffer_pos] != '!' {
+ yaml_parser_set_scanner_tag_error(parser, directive,
+ start_mark, "did not find expected '!'")
+ return false
+ }
+
+ var s []byte
+
+ // Copy the '!' character.
+ s = read(parser, s)
+
+ // Copy all subsequent alphabetical and numerical characters.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ for is_alpha(parser.buffer, parser.buffer_pos) {
+ s = read(parser, s)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Check if the trailing character is '!' and copy it.
+ if parser.buffer[parser.buffer_pos] == '!' {
+ s = read(parser, s)
+ } else {
+ // It's either the '!' tag or not really a tag handle. If it's a %TAG
+ // directive, it's an error. If it's a tag token, it must be a part of URI.
+ if directive && string(s) != "!" {
+ yaml_parser_set_scanner_tag_error(parser, directive,
+ start_mark, "did not find expected '!'")
+ return false
+ }
+ }
+
+ *handle = s
+ return true
+}
+
+// Scan a tag.
+func yaml_parser_scan_tag_uri(parser *yaml_parser_t, directive bool, head []byte, start_mark yaml_mark_t, uri *[]byte) bool {
+ //size_t length = head ? strlen((char *)head) : 0
+ var s []byte
+ hasTag := len(head) > 0
+
+ // Copy the head if needed.
+ //
+ // Note that we don't copy the leading '!' character.
+ if len(head) > 1 {
+ s = append(s, head[1:]...)
+ }
+
+ // Scan the tag.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ // The set of characters that may appear in URI is as follows:
+ //
+ // '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',
+ // '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']',
+ // '%'.
+ // [Go] TODO Convert this into more reasonable logic.
+ for is_alpha(parser.buffer, parser.buffer_pos) || parser.buffer[parser.buffer_pos] == ';' ||
+ parser.buffer[parser.buffer_pos] == '/' || parser.buffer[parser.buffer_pos] == '?' ||
+ parser.buffer[parser.buffer_pos] == ':' || parser.buffer[parser.buffer_pos] == '@' ||
+ parser.buffer[parser.buffer_pos] == '&' || parser.buffer[parser.buffer_pos] == '=' ||
+ parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '$' ||
+ parser.buffer[parser.buffer_pos] == ',' || parser.buffer[parser.buffer_pos] == '.' ||
+ parser.buffer[parser.buffer_pos] == '!' || parser.buffer[parser.buffer_pos] == '~' ||
+ parser.buffer[parser.buffer_pos] == '*' || parser.buffer[parser.buffer_pos] == '\'' ||
+ parser.buffer[parser.buffer_pos] == '(' || parser.buffer[parser.buffer_pos] == ')' ||
+ parser.buffer[parser.buffer_pos] == '[' || parser.buffer[parser.buffer_pos] == ']' ||
+ parser.buffer[parser.buffer_pos] == '%' {
+ // Check if it is a URI-escape sequence.
+ if parser.buffer[parser.buffer_pos] == '%' {
+ if !yaml_parser_scan_uri_escapes(parser, directive, start_mark, &s) {
+ return false
+ }
+ } else {
+ s = read(parser, s)
+ }
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ hasTag = true
+ }
+
+ if !hasTag {
+ yaml_parser_set_scanner_tag_error(parser, directive,
+ start_mark, "did not find expected tag URI")
+ return false
+ }
+ *uri = s
+ return true
+}
+
+// Decode an URI-escape sequence corresponding to a single UTF-8 character.
+func yaml_parser_scan_uri_escapes(parser *yaml_parser_t, directive bool, start_mark yaml_mark_t, s *[]byte) bool {
+
+ // Decode the required number of characters.
+ w := 1024
+ for w > 0 {
+ // Check for a URI-escaped octet.
+ if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) {
+ return false
+ }
+
+ if !(parser.buffer[parser.buffer_pos] == '%' &&
+ is_hex(parser.buffer, parser.buffer_pos+1) &&
+ is_hex(parser.buffer, parser.buffer_pos+2)) {
+ return yaml_parser_set_scanner_tag_error(parser, directive,
+ start_mark, "did not find URI escaped octet")
+ }
+
+ // Get the octet.
+ octet := byte((as_hex(parser.buffer, parser.buffer_pos+1) << 4) + as_hex(parser.buffer, parser.buffer_pos+2))
+
+ // If it is the leading octet, determine the length of the UTF-8 sequence.
+ if w == 1024 {
+ w = width(octet)
+ if w == 0 {
+ return yaml_parser_set_scanner_tag_error(parser, directive,
+ start_mark, "found an incorrect leading UTF-8 octet")
+ }
+ } else {
+ // Check if the trailing octet is correct.
+ if octet&0xC0 != 0x80 {
+ return yaml_parser_set_scanner_tag_error(parser, directive,
+ start_mark, "found an incorrect trailing UTF-8 octet")
+ }
+ }
+
+ // Copy the octet and move the pointers.
+ *s = append(*s, octet)
+ skip(parser)
+ skip(parser)
+ skip(parser)
+ w--
+ }
+ return true
+}
+
+// Scan a block scalar.
+func yaml_parser_scan_block_scalar(parser *yaml_parser_t, token *yaml_token_t, literal bool) bool {
+ // Eat the indicator '|' or '>'.
+ start_mark := parser.mark
+ skip(parser)
+
+ // Scan the additional block scalar indicators.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ // Check for a chomping indicator.
+ var chomping, increment int
+ if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' {
+ // Set the chomping method and eat the indicator.
+ if parser.buffer[parser.buffer_pos] == '+' {
+ chomping = +1
+ } else {
+ chomping = -1
+ }
+ skip(parser)
+
+ // Check for an indentation indicator.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if is_digit(parser.buffer, parser.buffer_pos) {
+ // Check that the indentation is greater than 0.
+ if parser.buffer[parser.buffer_pos] == '0' {
+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
+ start_mark, "found an indentation indicator equal to 0")
+ return false
+ }
+
+ // Get the indentation level and eat the indicator.
+ increment = as_digit(parser.buffer, parser.buffer_pos)
+ skip(parser)
+ }
+
+ } else if is_digit(parser.buffer, parser.buffer_pos) {
+ // Do the same as above, but in the opposite order.
+
+ if parser.buffer[parser.buffer_pos] == '0' {
+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
+ start_mark, "found an indentation indicator equal to 0")
+ return false
+ }
+ increment = as_digit(parser.buffer, parser.buffer_pos)
+ skip(parser)
+
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if parser.buffer[parser.buffer_pos] == '+' || parser.buffer[parser.buffer_pos] == '-' {
+ if parser.buffer[parser.buffer_pos] == '+' {
+ chomping = +1
+ } else {
+ chomping = -1
+ }
+ skip(parser)
+ }
+ }
+
+ // Eat whitespaces and comments to the end of the line.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ for is_blank(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+ if parser.buffer[parser.buffer_pos] == '#' {
+ if !yaml_parser_scan_line_comment(parser, start_mark) {
+ return false
+ }
+ for !is_breakz(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+ }
+
+ // Check if we are at the end of the line.
+ if !is_breakz(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
+ start_mark, "did not find expected comment or line break")
+ return false
+ }
+
+ // Eat a line break.
+ if is_break(parser.buffer, parser.buffer_pos) {
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ skip_line(parser)
+ }
+
+ end_mark := parser.mark
+
+ // Set the indentation level if it was specified.
+ var indent int
+ if increment > 0 {
+ if parser.indent >= 0 {
+ indent = parser.indent + increment
+ } else {
+ indent = increment
+ }
+ }
+
+ // Scan the leading line breaks and determine the indentation level if needed.
+ var s, leading_break, trailing_breaks []byte
+ if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) {
+ return false
+ }
+
+ // Scan the block scalar content.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ var leading_blank, trailing_blank bool
+ for parser.mark.column == indent && !is_z(parser.buffer, parser.buffer_pos) {
+ // We are at the beginning of a non-empty line.
+
+ // Is it a trailing whitespace?
+ trailing_blank = is_blank(parser.buffer, parser.buffer_pos)
+
+ // Check if we need to fold the leading line break.
+ if !literal && !leading_blank && !trailing_blank && len(leading_break) > 0 && leading_break[0] == '\n' {
+ // Do we need to join the lines by space?
+ if len(trailing_breaks) == 0 {
+ s = append(s, ' ')
+ }
+ } else {
+ s = append(s, leading_break...)
+ }
+ leading_break = leading_break[:0]
+
+ // Append the remaining line breaks.
+ s = append(s, trailing_breaks...)
+ trailing_breaks = trailing_breaks[:0]
+
+ // Is it a leading whitespace?
+ leading_blank = is_blank(parser.buffer, parser.buffer_pos)
+
+ // Consume the current line.
+ for !is_breakz(parser.buffer, parser.buffer_pos) {
+ s = read(parser, s)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Consume the line break.
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+
+ leading_break = read_line(parser, leading_break)
+
+ // Eat the following indentation spaces and line breaks.
+ if !yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks, start_mark, &end_mark) {
+ return false
+ }
+ }
+
+ // Chomp the tail.
+ if chomping != -1 {
+ s = append(s, leading_break...)
+ }
+ if chomping == 1 {
+ s = append(s, trailing_breaks...)
+ }
+
+ // Create a token.
+ *token = yaml_token_t{
+ typ: yaml_SCALAR_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ value: s,
+ style: yaml_LITERAL_SCALAR_STYLE,
+ }
+ if !literal {
+ token.style = yaml_FOLDED_SCALAR_STYLE
+ }
+ return true
+}
+
+// Scan indentation spaces and line breaks for a block scalar. Determine the
+// indentation level if needed.
+func yaml_parser_scan_block_scalar_breaks(parser *yaml_parser_t, indent *int, breaks *[]byte, start_mark yaml_mark_t, end_mark *yaml_mark_t) bool {
+ *end_mark = parser.mark
+
+ // Eat the indentation spaces and line breaks.
+ max_indent := 0
+ for {
+ // Eat the indentation spaces.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ for (*indent == 0 || parser.mark.column < *indent) && is_space(parser.buffer, parser.buffer_pos) {
+ skip(parser)
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+ if parser.mark.column > max_indent {
+ max_indent = parser.mark.column
+ }
+
+ // Check for a tab character messing the indentation.
+ if (*indent == 0 || parser.mark.column < *indent) && is_tab(parser.buffer, parser.buffer_pos) {
+ return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
+ start_mark, "found a tab character where an indentation space is expected")
+ }
+
+ // Have we found a non-empty line?
+ if !is_break(parser.buffer, parser.buffer_pos) {
+ break
+ }
+
+ // Consume the line break.
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ // [Go] Should really be returning breaks instead.
+ *breaks = read_line(parser, *breaks)
+ *end_mark = parser.mark
+ }
+
+ // Determine the indentation level if needed.
+ if *indent == 0 {
+ *indent = max_indent
+ if *indent < parser.indent+1 {
+ *indent = parser.indent + 1
+ }
+ if *indent < 1 {
+ *indent = 1
+ }
+ }
+ return true
+}
+
+// Scan a quoted scalar.
+func yaml_parser_scan_flow_scalar(parser *yaml_parser_t, token *yaml_token_t, single bool) bool {
+ // Eat the left quote.
+ start_mark := parser.mark
+ skip(parser)
+
+ // Consume the content of the quoted scalar.
+ var s, leading_break, trailing_breaks, whitespaces []byte
+ for {
+ // Check that there are no document indicators at the beginning of the line.
+ if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {
+ return false
+ }
+
+ if parser.mark.column == 0 &&
+ ((parser.buffer[parser.buffer_pos+0] == '-' &&
+ parser.buffer[parser.buffer_pos+1] == '-' &&
+ parser.buffer[parser.buffer_pos+2] == '-') ||
+ (parser.buffer[parser.buffer_pos+0] == '.' &&
+ parser.buffer[parser.buffer_pos+1] == '.' &&
+ parser.buffer[parser.buffer_pos+2] == '.')) &&
+ is_blankz(parser.buffer, parser.buffer_pos+3) {
+ yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
+ start_mark, "found unexpected document indicator")
+ return false
+ }
+
+ // Check for EOF.
+ if is_z(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
+ start_mark, "found unexpected end of stream")
+ return false
+ }
+
+ // Consume non-blank characters.
+ leading_blanks := false
+ for !is_blankz(parser.buffer, parser.buffer_pos) {
+ if single && parser.buffer[parser.buffer_pos] == '\'' && parser.buffer[parser.buffer_pos+1] == '\'' {
+ // Is is an escaped single quote.
+ s = append(s, '\'')
+ skip(parser)
+ skip(parser)
+
+ } else if single && parser.buffer[parser.buffer_pos] == '\'' {
+ // It is a right single quote.
+ break
+ } else if !single && parser.buffer[parser.buffer_pos] == '"' {
+ // It is a right double quote.
+ break
+
+ } else if !single && parser.buffer[parser.buffer_pos] == '\\' && is_break(parser.buffer, parser.buffer_pos+1) {
+ // It is an escaped line break.
+ if parser.unread < 3 && !yaml_parser_update_buffer(parser, 3) {
+ return false
+ }
+ skip(parser)
+ skip_line(parser)
+ leading_blanks = true
+ break
+
+ } else if !single && parser.buffer[parser.buffer_pos] == '\\' {
+ // It is an escape sequence.
+ code_length := 0
+
+ // Check the escape character.
+ switch parser.buffer[parser.buffer_pos+1] {
+ case '0':
+ s = append(s, 0)
+ case 'a':
+ s = append(s, '\x07')
+ case 'b':
+ s = append(s, '\x08')
+ case 't', '\t':
+ s = append(s, '\x09')
+ case 'n':
+ s = append(s, '\x0A')
+ case 'v':
+ s = append(s, '\x0B')
+ case 'f':
+ s = append(s, '\x0C')
+ case 'r':
+ s = append(s, '\x0D')
+ case 'e':
+ s = append(s, '\x1B')
+ case ' ':
+ s = append(s, '\x20')
+ case '"':
+ s = append(s, '"')
+ case '\'':
+ s = append(s, '\'')
+ case '\\':
+ s = append(s, '\\')
+ case 'N': // NEL (#x85)
+ s = append(s, '\xC2')
+ s = append(s, '\x85')
+ case '_': // #xA0
+ s = append(s, '\xC2')
+ s = append(s, '\xA0')
+ case 'L': // LS (#x2028)
+ s = append(s, '\xE2')
+ s = append(s, '\x80')
+ s = append(s, '\xA8')
+ case 'P': // PS (#x2029)
+ s = append(s, '\xE2')
+ s = append(s, '\x80')
+ s = append(s, '\xA9')
+ case 'x':
+ code_length = 2
+ case 'u':
+ code_length = 4
+ case 'U':
+ code_length = 8
+ default:
+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
+ start_mark, "found unknown escape character")
+ return false
+ }
+
+ skip(parser)
+ skip(parser)
+
+ // Consume an arbitrary escape code.
+ if code_length > 0 {
+ var value int
+
+ // Scan the character value.
+ if parser.unread < code_length && !yaml_parser_update_buffer(parser, code_length) {
+ return false
+ }
+ for k := 0; k < code_length; k++ {
+ if !is_hex(parser.buffer, parser.buffer_pos+k) {
+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
+ start_mark, "did not find expected hexdecimal number")
+ return false
+ }
+ value = (value << 4) + as_hex(parser.buffer, parser.buffer_pos+k)
+ }
+
+ // Check the value and write the character.
+ if (value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF {
+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
+ start_mark, "found invalid Unicode character escape code")
+ return false
+ }
+ if value <= 0x7F {
+ s = append(s, byte(value))
+ } else if value <= 0x7FF {
+ s = append(s, byte(0xC0+(value>>6)))
+ s = append(s, byte(0x80+(value&0x3F)))
+ } else if value <= 0xFFFF {
+ s = append(s, byte(0xE0+(value>>12)))
+ s = append(s, byte(0x80+((value>>6)&0x3F)))
+ s = append(s, byte(0x80+(value&0x3F)))
+ } else {
+ s = append(s, byte(0xF0+(value>>18)))
+ s = append(s, byte(0x80+((value>>12)&0x3F)))
+ s = append(s, byte(0x80+((value>>6)&0x3F)))
+ s = append(s, byte(0x80+(value&0x3F)))
+ }
+
+ // Advance the pointer.
+ for k := 0; k < code_length; k++ {
+ skip(parser)
+ }
+ }
+ } else {
+ // It is a non-escaped non-blank character.
+ s = read(parser, s)
+ }
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ }
+
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ // Check if we are at the end of the scalar.
+ if single {
+ if parser.buffer[parser.buffer_pos] == '\'' {
+ break
+ }
+ } else {
+ if parser.buffer[parser.buffer_pos] == '"' {
+ break
+ }
+ }
+
+ // Consume blank characters.
+ for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) {
+ if is_blank(parser.buffer, parser.buffer_pos) {
+ // Consume a space or a tab character.
+ if !leading_blanks {
+ whitespaces = read(parser, whitespaces)
+ } else {
+ skip(parser)
+ }
+ } else {
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+
+ // Check if it is a first line break.
+ if !leading_blanks {
+ whitespaces = whitespaces[:0]
+ leading_break = read_line(parser, leading_break)
+ leading_blanks = true
+ } else {
+ trailing_breaks = read_line(parser, trailing_breaks)
+ }
+ }
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Join the whitespaces or fold line breaks.
+ if leading_blanks {
+ // Do we need to fold line breaks?
+ if len(leading_break) > 0 && leading_break[0] == '\n' {
+ if len(trailing_breaks) == 0 {
+ s = append(s, ' ')
+ } else {
+ s = append(s, trailing_breaks...)
+ }
+ } else {
+ s = append(s, leading_break...)
+ s = append(s, trailing_breaks...)
+ }
+ trailing_breaks = trailing_breaks[:0]
+ leading_break = leading_break[:0]
+ } else {
+ s = append(s, whitespaces...)
+ whitespaces = whitespaces[:0]
+ }
+ }
+
+ // Eat the right quote.
+ skip(parser)
+ end_mark := parser.mark
+
+ // Create a token.
+ *token = yaml_token_t{
+ typ: yaml_SCALAR_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ value: s,
+ style: yaml_SINGLE_QUOTED_SCALAR_STYLE,
+ }
+ if !single {
+ token.style = yaml_DOUBLE_QUOTED_SCALAR_STYLE
+ }
+ return true
+}
+
+// Scan a plain scalar.
+func yaml_parser_scan_plain_scalar(parser *yaml_parser_t, token *yaml_token_t) bool {
+
+ var s, leading_break, trailing_breaks, whitespaces []byte
+ var leading_blanks bool
+ var indent = parser.indent + 1
+
+ start_mark := parser.mark
+ end_mark := parser.mark
+
+ // Consume the content of the plain scalar.
+ for {
+ // Check for a document indicator.
+ if parser.unread < 4 && !yaml_parser_update_buffer(parser, 4) {
+ return false
+ }
+ if parser.mark.column == 0 &&
+ ((parser.buffer[parser.buffer_pos+0] == '-' &&
+ parser.buffer[parser.buffer_pos+1] == '-' &&
+ parser.buffer[parser.buffer_pos+2] == '-') ||
+ (parser.buffer[parser.buffer_pos+0] == '.' &&
+ parser.buffer[parser.buffer_pos+1] == '.' &&
+ parser.buffer[parser.buffer_pos+2] == '.')) &&
+ is_blankz(parser.buffer, parser.buffer_pos+3) {
+ break
+ }
+
+ // Check for a comment.
+ if parser.buffer[parser.buffer_pos] == '#' {
+ break
+ }
+
+ // Consume non-blank characters.
+ for !is_blankz(parser.buffer, parser.buffer_pos) {
+
+ // Check for indicators that may end a plain scalar.
+ if (parser.buffer[parser.buffer_pos] == ':' && is_blankz(parser.buffer, parser.buffer_pos+1)) ||
+ (parser.flow_level > 0 &&
+ (parser.buffer[parser.buffer_pos] == ',' ||
+ parser.buffer[parser.buffer_pos] == '?' || parser.buffer[parser.buffer_pos] == '[' ||
+ parser.buffer[parser.buffer_pos] == ']' || parser.buffer[parser.buffer_pos] == '{' ||
+ parser.buffer[parser.buffer_pos] == '}')) {
+ break
+ }
+
+ // Check if we need to join whitespaces and breaks.
+ if leading_blanks || len(whitespaces) > 0 {
+ if leading_blanks {
+ // Do we need to fold line breaks?
+ if leading_break[0] == '\n' {
+ if len(trailing_breaks) == 0 {
+ s = append(s, ' ')
+ } else {
+ s = append(s, trailing_breaks...)
+ }
+ } else {
+ s = append(s, leading_break...)
+ s = append(s, trailing_breaks...)
+ }
+ trailing_breaks = trailing_breaks[:0]
+ leading_break = leading_break[:0]
+ leading_blanks = false
+ } else {
+ s = append(s, whitespaces...)
+ whitespaces = whitespaces[:0]
+ }
+ }
+
+ // Copy the character.
+ s = read(parser, s)
+
+ end_mark = parser.mark
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ }
+
+ // Is it the end?
+ if !(is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos)) {
+ break
+ }
+
+ // Consume blank characters.
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+
+ for is_blank(parser.buffer, parser.buffer_pos) || is_break(parser.buffer, parser.buffer_pos) {
+ if is_blank(parser.buffer, parser.buffer_pos) {
+
+ // Check for tab characters that abuse indentation.
+ if leading_blanks && parser.mark.column < indent && is_tab(parser.buffer, parser.buffer_pos) {
+ yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
+ start_mark, "found a tab character that violates indentation")
+ return false
+ }
+
+ // Consume a space or a tab character.
+ if !leading_blanks {
+ whitespaces = read(parser, whitespaces)
+ } else {
+ skip(parser)
+ }
+ } else {
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+
+ // Check if it is a first line break.
+ if !leading_blanks {
+ whitespaces = whitespaces[:0]
+ leading_break = read_line(parser, leading_break)
+ leading_blanks = true
+ } else {
+ trailing_breaks = read_line(parser, trailing_breaks)
+ }
+ }
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ }
+
+ // Check indentation level.
+ if parser.flow_level == 0 && parser.mark.column < indent {
+ break
+ }
+ }
+
+ // Create a token.
+ *token = yaml_token_t{
+ typ: yaml_SCALAR_TOKEN,
+ start_mark: start_mark,
+ end_mark: end_mark,
+ value: s,
+ style: yaml_PLAIN_SCALAR_STYLE,
+ }
+
+ // Note that we change the 'simple_key_allowed' flag.
+ if leading_blanks {
+ parser.simple_key_allowed = true
+ }
+ return true
+}
+
+func yaml_parser_scan_line_comment(parser *yaml_parser_t, token_mark yaml_mark_t) bool {
+ if parser.newlines > 0 {
+ return true
+ }
+
+ var start_mark yaml_mark_t
+ var text []byte
+
+ for peek := 0; peek < 512; peek++ {
+ if parser.unread < peek+1 && !yaml_parser_update_buffer(parser, peek+1) {
+ break
+ }
+ if is_blank(parser.buffer, parser.buffer_pos+peek) {
+ continue
+ }
+ if parser.buffer[parser.buffer_pos+peek] == '#' {
+ seen := parser.mark.index + peek
+ for {
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if is_breakz(parser.buffer, parser.buffer_pos) {
+ if parser.mark.index >= seen {
+ break
+ }
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ skip_line(parser)
+ } else if parser.mark.index >= seen {
+ if len(text) == 0 {
+ start_mark = parser.mark
+ }
+ text = read(parser, text)
+ } else {
+ skip(parser)
+ }
+ }
+ }
+ break
+ }
+ if len(text) > 0 {
+ parser.comments = append(parser.comments, yaml_comment_t{
+ token_mark: token_mark,
+ start_mark: start_mark,
+ line: text,
+ })
+ }
+ return true
+}
+
+func yaml_parser_scan_comments(parser *yaml_parser_t, scan_mark yaml_mark_t) bool {
+ token := parser.tokens[len(parser.tokens)-1]
+
+ if token.typ == yaml_FLOW_ENTRY_TOKEN && len(parser.tokens) > 1 {
+ token = parser.tokens[len(parser.tokens)-2]
+ }
+
+ var token_mark = token.start_mark
+ var start_mark yaml_mark_t
+ var next_indent = parser.indent
+ if next_indent < 0 {
+ next_indent = 0
+ }
+
+ var recent_empty = false
+ var first_empty = parser.newlines <= 1
+
+ var line = parser.mark.line
+ var column = parser.mark.column
+
+ var text []byte
+
+ // The foot line is the place where a comment must start to
+ // still be considered as a foot of the prior content.
+ // If there's some content in the currently parsed line, then
+ // the foot is the line below it.
+ var foot_line = -1
+ if scan_mark.line > 0 {
+ foot_line = parser.mark.line - parser.newlines + 1
+ if parser.newlines == 0 && parser.mark.column > 1 {
+ foot_line++
+ }
+ }
+
+ var peek = 0
+ for ; peek < 512; peek++ {
+ if parser.unread < peek+1 && !yaml_parser_update_buffer(parser, peek+1) {
+ break
+ }
+ column++
+ if is_blank(parser.buffer, parser.buffer_pos+peek) {
+ continue
+ }
+ c := parser.buffer[parser.buffer_pos+peek]
+ var close_flow = parser.flow_level > 0 && (c == ']' || c == '}')
+ if close_flow || is_breakz(parser.buffer, parser.buffer_pos+peek) {
+ // Got line break or terminator.
+ if close_flow || !recent_empty {
+ if close_flow || first_empty && (start_mark.line == foot_line && token.typ != yaml_VALUE_TOKEN || start_mark.column-1 < next_indent) {
+ // This is the first empty line and there were no empty lines before,
+ // so this initial part of the comment is a foot of the prior token
+ // instead of being a head for the following one. Split it up.
+ // Alternatively, this might also be the last comment inside a flow
+ // scope, so it must be a footer.
+ if len(text) > 0 {
+ if start_mark.column-1 < next_indent {
+ // If dedented it's unrelated to the prior token.
+ token_mark = start_mark
+ }
+ parser.comments = append(parser.comments, yaml_comment_t{
+ scan_mark: scan_mark,
+ token_mark: token_mark,
+ start_mark: start_mark,
+ end_mark: yaml_mark_t{parser.mark.index + peek, line, column},
+ foot: text,
+ })
+ scan_mark = yaml_mark_t{parser.mark.index + peek, line, column}
+ token_mark = scan_mark
+ text = nil
+ }
+ } else {
+ if len(text) > 0 && parser.buffer[parser.buffer_pos+peek] != 0 {
+ text = append(text, '\n')
+ }
+ }
+ }
+ if !is_break(parser.buffer, parser.buffer_pos+peek) {
+ break
+ }
+ first_empty = false
+ recent_empty = true
+ column = 0
+ line++
+ continue
+ }
+
+ if len(text) > 0 && (close_flow || column-1 < next_indent && column != start_mark.column) {
+ // The comment at the different indentation is a foot of the
+ // preceding data rather than a head of the upcoming one.
+ parser.comments = append(parser.comments, yaml_comment_t{
+ scan_mark: scan_mark,
+ token_mark: token_mark,
+ start_mark: start_mark,
+ end_mark: yaml_mark_t{parser.mark.index + peek, line, column},
+ foot: text,
+ })
+ scan_mark = yaml_mark_t{parser.mark.index + peek, line, column}
+ token_mark = scan_mark
+ text = nil
+ }
+
+ if parser.buffer[parser.buffer_pos+peek] != '#' {
+ break
+ }
+
+ if len(text) == 0 {
+ start_mark = yaml_mark_t{parser.mark.index + peek, line, column}
+ } else {
+ text = append(text, '\n')
+ }
+
+ recent_empty = false
+
+ // Consume until after the consumed comment line.
+ seen := parser.mark.index + peek
+ for {
+ if parser.unread < 1 && !yaml_parser_update_buffer(parser, 1) {
+ return false
+ }
+ if is_breakz(parser.buffer, parser.buffer_pos) {
+ if parser.mark.index >= seen {
+ break
+ }
+ if parser.unread < 2 && !yaml_parser_update_buffer(parser, 2) {
+ return false
+ }
+ skip_line(parser)
+ } else if parser.mark.index >= seen {
+ text = read(parser, text)
+ } else {
+ skip(parser)
+ }
+ }
+
+ peek = 0
+ column = 0
+ line = parser.mark.line
+ next_indent = parser.indent
+ if next_indent < 0 {
+ next_indent = 0
+ }
+ }
+
+ if len(text) > 0 {
+ parser.comments = append(parser.comments, yaml_comment_t{
+ scan_mark: scan_mark,
+ token_mark: start_mark,
+ start_mark: start_mark,
+ end_mark: yaml_mark_t{parser.mark.index + peek - 1, line, column},
+ head: text,
+ })
+ }
+ return true
+}
diff --git a/vendor/go.yaml.in/yaml/v3/sorter.go b/vendor/go.yaml.in/yaml/v3/sorter.go
new file mode 100644
index 00000000..9210ece7
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/sorter.go
@@ -0,0 +1,134 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package yaml
+
+import (
+ "reflect"
+ "unicode"
+)
+
+type keyList []reflect.Value
+
+func (l keyList) Len() int { return len(l) }
+func (l keyList) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
+func (l keyList) Less(i, j int) bool {
+ a := l[i]
+ b := l[j]
+ ak := a.Kind()
+ bk := b.Kind()
+ for (ak == reflect.Interface || ak == reflect.Ptr) && !a.IsNil() {
+ a = a.Elem()
+ ak = a.Kind()
+ }
+ for (bk == reflect.Interface || bk == reflect.Ptr) && !b.IsNil() {
+ b = b.Elem()
+ bk = b.Kind()
+ }
+ af, aok := keyFloat(a)
+ bf, bok := keyFloat(b)
+ if aok && bok {
+ if af != bf {
+ return af < bf
+ }
+ if ak != bk {
+ return ak < bk
+ }
+ return numLess(a, b)
+ }
+ if ak != reflect.String || bk != reflect.String {
+ return ak < bk
+ }
+ ar, br := []rune(a.String()), []rune(b.String())
+ digits := false
+ for i := 0; i < len(ar) && i < len(br); i++ {
+ if ar[i] == br[i] {
+ digits = unicode.IsDigit(ar[i])
+ continue
+ }
+ al := unicode.IsLetter(ar[i])
+ bl := unicode.IsLetter(br[i])
+ if al && bl {
+ return ar[i] < br[i]
+ }
+ if al || bl {
+ if digits {
+ return al
+ } else {
+ return bl
+ }
+ }
+ var ai, bi int
+ var an, bn int64
+ if ar[i] == '0' || br[i] == '0' {
+ for j := i - 1; j >= 0 && unicode.IsDigit(ar[j]); j-- {
+ if ar[j] != '0' {
+ an = 1
+ bn = 1
+ break
+ }
+ }
+ }
+ for ai = i; ai < len(ar) && unicode.IsDigit(ar[ai]); ai++ {
+ an = an*10 + int64(ar[ai]-'0')
+ }
+ for bi = i; bi < len(br) && unicode.IsDigit(br[bi]); bi++ {
+ bn = bn*10 + int64(br[bi]-'0')
+ }
+ if an != bn {
+ return an < bn
+ }
+ if ai != bi {
+ return ai < bi
+ }
+ return ar[i] < br[i]
+ }
+ return len(ar) < len(br)
+}
+
+// keyFloat returns a float value for v if it is a number/bool
+// and whether it is a number/bool or not.
+func keyFloat(v reflect.Value) (f float64, ok bool) {
+ switch v.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return float64(v.Int()), true
+ case reflect.Float32, reflect.Float64:
+ return v.Float(), true
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return float64(v.Uint()), true
+ case reflect.Bool:
+ if v.Bool() {
+ return 1, true
+ }
+ return 0, true
+ }
+ return 0, false
+}
+
+// numLess returns whether a < b.
+// a and b must necessarily have the same kind.
+func numLess(a, b reflect.Value) bool {
+ switch a.Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return a.Int() < b.Int()
+ case reflect.Float32, reflect.Float64:
+ return a.Float() < b.Float()
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return a.Uint() < b.Uint()
+ case reflect.Bool:
+ return !a.Bool() && b.Bool()
+ }
+ panic("not a number")
+}
diff --git a/vendor/go.yaml.in/yaml/v3/writerc.go b/vendor/go.yaml.in/yaml/v3/writerc.go
new file mode 100644
index 00000000..266d0b09
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/writerc.go
@@ -0,0 +1,48 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+// Copyright (c) 2006-2010 Kirill Simonov
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+// of the Software, and to permit persons to whom the Software is furnished to do
+// so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package yaml
+
+// Set the writer error and return false.
+func yaml_emitter_set_writer_error(emitter *yaml_emitter_t, problem string) bool {
+ emitter.error = yaml_WRITER_ERROR
+ emitter.problem = problem
+ return false
+}
+
+// Flush the output buffer.
+func yaml_emitter_flush(emitter *yaml_emitter_t) bool {
+ if emitter.write_handler == nil {
+ panic("write handler not set")
+ }
+
+ // Check if the buffer is empty.
+ if emitter.buffer_pos == 0 {
+ return true
+ }
+
+ if err := emitter.write_handler(emitter, emitter.buffer[:emitter.buffer_pos]); err != nil {
+ return yaml_emitter_set_writer_error(emitter, "write error: "+err.Error())
+ }
+ emitter.buffer_pos = 0
+ return true
+}
diff --git a/vendor/go.yaml.in/yaml/v3/yaml.go b/vendor/go.yaml.in/yaml/v3/yaml.go
new file mode 100644
index 00000000..0b101cd2
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/yaml.go
@@ -0,0 +1,703 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package yaml implements YAML support for the Go language.
+//
+// Source code and other details for the project are available at GitHub:
+//
+// https://github.com/yaml/go-yaml
+package yaml
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "reflect"
+ "strings"
+ "sync"
+ "unicode/utf8"
+)
+
+// The Unmarshaler interface may be implemented by types to customize their
+// behavior when being unmarshaled from a YAML document.
+type Unmarshaler interface {
+ UnmarshalYAML(value *Node) error
+}
+
+type obsoleteUnmarshaler interface {
+ UnmarshalYAML(unmarshal func(interface{}) error) error
+}
+
+// The Marshaler interface may be implemented by types to customize their
+// behavior when being marshaled into a YAML document. The returned value
+// is marshaled in place of the original value implementing Marshaler.
+//
+// If an error is returned by MarshalYAML, the marshaling procedure stops
+// and returns with the provided error.
+type Marshaler interface {
+ MarshalYAML() (interface{}, error)
+}
+
+// Unmarshal decodes the first document found within the in byte slice
+// and assigns decoded values into the out value.
+//
+// Maps and pointers (to a struct, string, int, etc) are accepted as out
+// values. If an internal pointer within a struct is not initialized,
+// the yaml package will initialize it if necessary for unmarshalling
+// the provided data. The out parameter must not be nil.
+//
+// The type of the decoded values should be compatible with the respective
+// values in out. If one or more values cannot be decoded due to a type
+// mismatches, decoding continues partially until the end of the YAML
+// content, and a *yaml.TypeError is returned with details for all
+// missed values.
+//
+// Struct fields are only unmarshalled if they are exported (have an
+// upper case first letter), and are unmarshalled using the field name
+// lowercased as the default key. Custom keys may be defined via the
+// "yaml" name in the field tag: the content preceding the first comma
+// is used as the key, and the following comma-separated options are
+// used to tweak the marshalling process (see Marshal).
+// Conflicting names result in a runtime error.
+//
+// For example:
+//
+// type T struct {
+// F int `yaml:"a,omitempty"`
+// B int
+// }
+// var t T
+// yaml.Unmarshal([]byte("a: 1\nb: 2"), &t)
+//
+// See the documentation of Marshal for the format of tags and a list of
+// supported tag options.
+func Unmarshal(in []byte, out interface{}) (err error) {
+ return unmarshal(in, out, false)
+}
+
+// A Decoder reads and decodes YAML values from an input stream.
+type Decoder struct {
+ parser *parser
+ knownFields bool
+}
+
+// NewDecoder returns a new decoder that reads from r.
+//
+// The decoder introduces its own buffering and may read
+// data from r beyond the YAML values requested.
+func NewDecoder(r io.Reader) *Decoder {
+ return &Decoder{
+ parser: newParserFromReader(r),
+ }
+}
+
+// KnownFields ensures that the keys in decoded mappings to
+// exist as fields in the struct being decoded into.
+func (dec *Decoder) KnownFields(enable bool) {
+ dec.knownFields = enable
+}
+
+// Decode reads the next YAML-encoded value from its input
+// and stores it in the value pointed to by v.
+//
+// See the documentation for Unmarshal for details about the
+// conversion of YAML into a Go value.
+func (dec *Decoder) Decode(v interface{}) (err error) {
+ d := newDecoder()
+ d.knownFields = dec.knownFields
+ defer handleErr(&err)
+ node := dec.parser.parse()
+ if node == nil {
+ return io.EOF
+ }
+ out := reflect.ValueOf(v)
+ if out.Kind() == reflect.Ptr && !out.IsNil() {
+ out = out.Elem()
+ }
+ d.unmarshal(node, out)
+ if len(d.terrors) > 0 {
+ return &TypeError{d.terrors}
+ }
+ return nil
+}
+
+// Decode decodes the node and stores its data into the value pointed to by v.
+//
+// See the documentation for Unmarshal for details about the
+// conversion of YAML into a Go value.
+func (n *Node) Decode(v interface{}) (err error) {
+ d := newDecoder()
+ defer handleErr(&err)
+ out := reflect.ValueOf(v)
+ if out.Kind() == reflect.Ptr && !out.IsNil() {
+ out = out.Elem()
+ }
+ d.unmarshal(n, out)
+ if len(d.terrors) > 0 {
+ return &TypeError{d.terrors}
+ }
+ return nil
+}
+
+func unmarshal(in []byte, out interface{}, strict bool) (err error) {
+ defer handleErr(&err)
+ d := newDecoder()
+ p := newParser(in)
+ defer p.destroy()
+ node := p.parse()
+ if node != nil {
+ v := reflect.ValueOf(out)
+ if v.Kind() == reflect.Ptr && !v.IsNil() {
+ v = v.Elem()
+ }
+ d.unmarshal(node, v)
+ }
+ if len(d.terrors) > 0 {
+ return &TypeError{d.terrors}
+ }
+ return nil
+}
+
+// Marshal serializes the value provided into a YAML document. The structure
+// of the generated document will reflect the structure of the value itself.
+// Maps and pointers (to struct, string, int, etc) are accepted as the in value.
+//
+// Struct fields are only marshalled if they are exported (have an upper case
+// first letter), and are marshalled using the field name lowercased as the
+// default key. Custom keys may be defined via the "yaml" name in the field
+// tag: the content preceding the first comma is used as the key, and the
+// following comma-separated options are used to tweak the marshalling process.
+// Conflicting names result in a runtime error.
+//
+// The field tag format accepted is:
+//
+// `(...) yaml:"[][,[,]]" (...)`
+//
+// The following flags are currently supported:
+//
+// omitempty Only include the field if it's not set to the zero
+// value for the type or to empty slices or maps.
+// Zero valued structs will be omitted if all their public
+// fields are zero, unless they implement an IsZero
+// method (see the IsZeroer interface type), in which
+// case the field will be excluded if IsZero returns true.
+//
+// flow Marshal using a flow style (useful for structs,
+// sequences and maps).
+//
+// inline Inline the field, which must be a struct or a map,
+// causing all of its fields or keys to be processed as if
+// they were part of the outer struct. For maps, keys must
+// not conflict with the yaml keys of other struct fields.
+//
+// In addition, if the key is "-", the field is ignored.
+//
+// For example:
+//
+// type T struct {
+// F int `yaml:"a,omitempty"`
+// B int
+// }
+// yaml.Marshal(&T{B: 2}) // Returns "b: 2\n"
+// yaml.Marshal(&T{F: 1}} // Returns "a: 1\nb: 0\n"
+func Marshal(in interface{}) (out []byte, err error) {
+ defer handleErr(&err)
+ e := newEncoder()
+ defer e.destroy()
+ e.marshalDoc("", reflect.ValueOf(in))
+ e.finish()
+ out = e.out
+ return
+}
+
+// An Encoder writes YAML values to an output stream.
+type Encoder struct {
+ encoder *encoder
+}
+
+// NewEncoder returns a new encoder that writes to w.
+// The Encoder should be closed after use to flush all data
+// to w.
+func NewEncoder(w io.Writer) *Encoder {
+ return &Encoder{
+ encoder: newEncoderWithWriter(w),
+ }
+}
+
+// Encode writes the YAML encoding of v to the stream.
+// If multiple items are encoded to the stream, the
+// second and subsequent document will be preceded
+// with a "---" document separator, but the first will not.
+//
+// See the documentation for Marshal for details about the conversion of Go
+// values to YAML.
+func (e *Encoder) Encode(v interface{}) (err error) {
+ defer handleErr(&err)
+ e.encoder.marshalDoc("", reflect.ValueOf(v))
+ return nil
+}
+
+// Encode encodes value v and stores its representation in n.
+//
+// See the documentation for Marshal for details about the
+// conversion of Go values into YAML.
+func (n *Node) Encode(v interface{}) (err error) {
+ defer handleErr(&err)
+ e := newEncoder()
+ defer e.destroy()
+ e.marshalDoc("", reflect.ValueOf(v))
+ e.finish()
+ p := newParser(e.out)
+ p.textless = true
+ defer p.destroy()
+ doc := p.parse()
+ *n = *doc.Content[0]
+ return nil
+}
+
+// SetIndent changes the used indentation used when encoding.
+func (e *Encoder) SetIndent(spaces int) {
+ if spaces < 0 {
+ panic("yaml: cannot indent to a negative number of spaces")
+ }
+ e.encoder.indent = spaces
+}
+
+// CompactSeqIndent makes it so that '- ' is considered part of the indentation.
+func (e *Encoder) CompactSeqIndent() {
+ e.encoder.emitter.compact_sequence_indent = true
+}
+
+// DefaultSeqIndent makes it so that '- ' is not considered part of the indentation.
+func (e *Encoder) DefaultSeqIndent() {
+ e.encoder.emitter.compact_sequence_indent = false
+}
+
+// Close closes the encoder by writing any remaining data.
+// It does not write a stream terminating string "...".
+func (e *Encoder) Close() (err error) {
+ defer handleErr(&err)
+ e.encoder.finish()
+ return nil
+}
+
+func handleErr(err *error) {
+ if v := recover(); v != nil {
+ if e, ok := v.(yamlError); ok {
+ *err = e.err
+ } else {
+ panic(v)
+ }
+ }
+}
+
+type yamlError struct {
+ err error
+}
+
+func fail(err error) {
+ panic(yamlError{err})
+}
+
+func failf(format string, args ...interface{}) {
+ panic(yamlError{fmt.Errorf("yaml: "+format, args...)})
+}
+
+// A TypeError is returned by Unmarshal when one or more fields in
+// the YAML document cannot be properly decoded into the requested
+// types. When this error is returned, the value is still
+// unmarshaled partially.
+type TypeError struct {
+ Errors []string
+}
+
+func (e *TypeError) Error() string {
+ return fmt.Sprintf("yaml: unmarshal errors:\n %s", strings.Join(e.Errors, "\n "))
+}
+
+type Kind uint32
+
+const (
+ DocumentNode Kind = 1 << iota
+ SequenceNode
+ MappingNode
+ ScalarNode
+ AliasNode
+)
+
+type Style uint32
+
+const (
+ TaggedStyle Style = 1 << iota
+ DoubleQuotedStyle
+ SingleQuotedStyle
+ LiteralStyle
+ FoldedStyle
+ FlowStyle
+)
+
+// Node represents an element in the YAML document hierarchy. While documents
+// are typically encoded and decoded into higher level types, such as structs
+// and maps, Node is an intermediate representation that allows detailed
+// control over the content being decoded or encoded.
+//
+// It's worth noting that although Node offers access into details such as
+// line numbers, colums, and comments, the content when re-encoded will not
+// have its original textual representation preserved. An effort is made to
+// render the data plesantly, and to preserve comments near the data they
+// describe, though.
+//
+// Values that make use of the Node type interact with the yaml package in the
+// same way any other type would do, by encoding and decoding yaml data
+// directly or indirectly into them.
+//
+// For example:
+//
+// var person struct {
+// Name string
+// Address yaml.Node
+// }
+// err := yaml.Unmarshal(data, &person)
+//
+// Or by itself:
+//
+// var person Node
+// err := yaml.Unmarshal(data, &person)
+type Node struct {
+ // Kind defines whether the node is a document, a mapping, a sequence,
+ // a scalar value, or an alias to another node. The specific data type of
+ // scalar nodes may be obtained via the ShortTag and LongTag methods.
+ Kind Kind
+
+ // Style allows customizing the apperance of the node in the tree.
+ Style Style
+
+ // Tag holds the YAML tag defining the data type for the value.
+ // When decoding, this field will always be set to the resolved tag,
+ // even when it wasn't explicitly provided in the YAML content.
+ // When encoding, if this field is unset the value type will be
+ // implied from the node properties, and if it is set, it will only
+ // be serialized into the representation if TaggedStyle is used or
+ // the implicit tag diverges from the provided one.
+ Tag string
+
+ // Value holds the unescaped and unquoted represenation of the value.
+ Value string
+
+ // Anchor holds the anchor name for this node, which allows aliases to point to it.
+ Anchor string
+
+ // Alias holds the node that this alias points to. Only valid when Kind is AliasNode.
+ Alias *Node
+
+ // Content holds contained nodes for documents, mappings, and sequences.
+ Content []*Node
+
+ // HeadComment holds any comments in the lines preceding the node and
+ // not separated by an empty line.
+ HeadComment string
+
+ // LineComment holds any comments at the end of the line where the node is in.
+ LineComment string
+
+ // FootComment holds any comments following the node and before empty lines.
+ FootComment string
+
+ // Line and Column hold the node position in the decoded YAML text.
+ // These fields are not respected when encoding the node.
+ Line int
+ Column int
+}
+
+// IsZero returns whether the node has all of its fields unset.
+func (n *Node) IsZero() bool {
+ return n.Kind == 0 && n.Style == 0 && n.Tag == "" && n.Value == "" && n.Anchor == "" && n.Alias == nil && n.Content == nil &&
+ n.HeadComment == "" && n.LineComment == "" && n.FootComment == "" && n.Line == 0 && n.Column == 0
+}
+
+// LongTag returns the long form of the tag that indicates the data type for
+// the node. If the Tag field isn't explicitly defined, one will be computed
+// based on the node properties.
+func (n *Node) LongTag() string {
+ return longTag(n.ShortTag())
+}
+
+// ShortTag returns the short form of the YAML tag that indicates data type for
+// the node. If the Tag field isn't explicitly defined, one will be computed
+// based on the node properties.
+func (n *Node) ShortTag() string {
+ if n.indicatedString() {
+ return strTag
+ }
+ if n.Tag == "" || n.Tag == "!" {
+ switch n.Kind {
+ case MappingNode:
+ return mapTag
+ case SequenceNode:
+ return seqTag
+ case AliasNode:
+ if n.Alias != nil {
+ return n.Alias.ShortTag()
+ }
+ case ScalarNode:
+ tag, _ := resolve("", n.Value)
+ return tag
+ case 0:
+ // Special case to make the zero value convenient.
+ if n.IsZero() {
+ return nullTag
+ }
+ }
+ return ""
+ }
+ return shortTag(n.Tag)
+}
+
+func (n *Node) indicatedString() bool {
+ return n.Kind == ScalarNode &&
+ (shortTag(n.Tag) == strTag ||
+ (n.Tag == "" || n.Tag == "!") && n.Style&(SingleQuotedStyle|DoubleQuotedStyle|LiteralStyle|FoldedStyle) != 0)
+}
+
+// SetString is a convenience function that sets the node to a string value
+// and defines its style in a pleasant way depending on its content.
+func (n *Node) SetString(s string) {
+ n.Kind = ScalarNode
+ if utf8.ValidString(s) {
+ n.Value = s
+ n.Tag = strTag
+ } else {
+ n.Value = encodeBase64(s)
+ n.Tag = binaryTag
+ }
+ if strings.Contains(n.Value, "\n") {
+ n.Style = LiteralStyle
+ }
+}
+
+// --------------------------------------------------------------------------
+// Maintain a mapping of keys to structure field indexes
+
+// The code in this section was copied from mgo/bson.
+
+// structInfo holds details for the serialization of fields of
+// a given struct.
+type structInfo struct {
+ FieldsMap map[string]fieldInfo
+ FieldsList []fieldInfo
+
+ // InlineMap is the number of the field in the struct that
+ // contains an ,inline map, or -1 if there's none.
+ InlineMap int
+
+ // InlineUnmarshalers holds indexes to inlined fields that
+ // contain unmarshaler values.
+ InlineUnmarshalers [][]int
+}
+
+type fieldInfo struct {
+ Key string
+ Num int
+ OmitEmpty bool
+ Flow bool
+ // Id holds the unique field identifier, so we can cheaply
+ // check for field duplicates without maintaining an extra map.
+ Id int
+
+ // Inline holds the field index if the field is part of an inlined struct.
+ Inline []int
+}
+
+var structMap = make(map[reflect.Type]*structInfo)
+var fieldMapMutex sync.RWMutex
+var unmarshalerType reflect.Type
+
+func init() {
+ var v Unmarshaler
+ unmarshalerType = reflect.ValueOf(&v).Elem().Type()
+}
+
+func getStructInfo(st reflect.Type) (*structInfo, error) {
+ fieldMapMutex.RLock()
+ sinfo, found := structMap[st]
+ fieldMapMutex.RUnlock()
+ if found {
+ return sinfo, nil
+ }
+
+ n := st.NumField()
+ fieldsMap := make(map[string]fieldInfo)
+ fieldsList := make([]fieldInfo, 0, n)
+ inlineMap := -1
+ inlineUnmarshalers := [][]int(nil)
+ for i := 0; i != n; i++ {
+ field := st.Field(i)
+ if field.PkgPath != "" && !field.Anonymous {
+ continue // Private field
+ }
+
+ info := fieldInfo{Num: i}
+
+ tag := field.Tag.Get("yaml")
+ if tag == "" && strings.Index(string(field.Tag), ":") < 0 {
+ tag = string(field.Tag)
+ }
+ if tag == "-" {
+ continue
+ }
+
+ inline := false
+ fields := strings.Split(tag, ",")
+ if len(fields) > 1 {
+ for _, flag := range fields[1:] {
+ switch flag {
+ case "omitempty":
+ info.OmitEmpty = true
+ case "flow":
+ info.Flow = true
+ case "inline":
+ inline = true
+ default:
+ return nil, errors.New(fmt.Sprintf("unsupported flag %q in tag %q of type %s", flag, tag, st))
+ }
+ }
+ tag = fields[0]
+ }
+
+ if inline {
+ switch field.Type.Kind() {
+ case reflect.Map:
+ if inlineMap >= 0 {
+ return nil, errors.New("multiple ,inline maps in struct " + st.String())
+ }
+ if field.Type.Key() != reflect.TypeOf("") {
+ return nil, errors.New("option ,inline needs a map with string keys in struct " + st.String())
+ }
+ inlineMap = info.Num
+ case reflect.Struct, reflect.Ptr:
+ ftype := field.Type
+ for ftype.Kind() == reflect.Ptr {
+ ftype = ftype.Elem()
+ }
+ if ftype.Kind() != reflect.Struct {
+ return nil, errors.New("option ,inline may only be used on a struct or map field")
+ }
+ if reflect.PtrTo(ftype).Implements(unmarshalerType) {
+ inlineUnmarshalers = append(inlineUnmarshalers, []int{i})
+ } else {
+ sinfo, err := getStructInfo(ftype)
+ if err != nil {
+ return nil, err
+ }
+ for _, index := range sinfo.InlineUnmarshalers {
+ inlineUnmarshalers = append(inlineUnmarshalers, append([]int{i}, index...))
+ }
+ for _, finfo := range sinfo.FieldsList {
+ if _, found := fieldsMap[finfo.Key]; found {
+ msg := "duplicated key '" + finfo.Key + "' in struct " + st.String()
+ return nil, errors.New(msg)
+ }
+ if finfo.Inline == nil {
+ finfo.Inline = []int{i, finfo.Num}
+ } else {
+ finfo.Inline = append([]int{i}, finfo.Inline...)
+ }
+ finfo.Id = len(fieldsList)
+ fieldsMap[finfo.Key] = finfo
+ fieldsList = append(fieldsList, finfo)
+ }
+ }
+ default:
+ return nil, errors.New("option ,inline may only be used on a struct or map field")
+ }
+ continue
+ }
+
+ if tag != "" {
+ info.Key = tag
+ } else {
+ info.Key = strings.ToLower(field.Name)
+ }
+
+ if _, found = fieldsMap[info.Key]; found {
+ msg := "duplicated key '" + info.Key + "' in struct " + st.String()
+ return nil, errors.New(msg)
+ }
+
+ info.Id = len(fieldsList)
+ fieldsList = append(fieldsList, info)
+ fieldsMap[info.Key] = info
+ }
+
+ sinfo = &structInfo{
+ FieldsMap: fieldsMap,
+ FieldsList: fieldsList,
+ InlineMap: inlineMap,
+ InlineUnmarshalers: inlineUnmarshalers,
+ }
+
+ fieldMapMutex.Lock()
+ structMap[st] = sinfo
+ fieldMapMutex.Unlock()
+ return sinfo, nil
+}
+
+// IsZeroer is used to check whether an object is zero to
+// determine whether it should be omitted when marshaling
+// with the omitempty flag. One notable implementation
+// is time.Time.
+type IsZeroer interface {
+ IsZero() bool
+}
+
+func isZero(v reflect.Value) bool {
+ kind := v.Kind()
+ if z, ok := v.Interface().(IsZeroer); ok {
+ if (kind == reflect.Ptr || kind == reflect.Interface) && v.IsNil() {
+ return true
+ }
+ return z.IsZero()
+ }
+ switch kind {
+ case reflect.String:
+ return len(v.String()) == 0
+ case reflect.Interface, reflect.Ptr:
+ return v.IsNil()
+ case reflect.Slice:
+ return v.Len() == 0
+ case reflect.Map:
+ return v.Len() == 0
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ return v.Int() == 0
+ case reflect.Float32, reflect.Float64:
+ return v.Float() == 0
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+ return v.Uint() == 0
+ case reflect.Bool:
+ return !v.Bool()
+ case reflect.Struct:
+ vt := v.Type()
+ for i := v.NumField() - 1; i >= 0; i-- {
+ if vt.Field(i).PkgPath != "" {
+ continue // Private field
+ }
+ if !isZero(v.Field(i)) {
+ return false
+ }
+ }
+ return true
+ }
+ return false
+}
diff --git a/vendor/go.yaml.in/yaml/v3/yamlh.go b/vendor/go.yaml.in/yaml/v3/yamlh.go
new file mode 100644
index 00000000..f59aa40f
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/yamlh.go
@@ -0,0 +1,811 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+// Copyright (c) 2006-2010 Kirill Simonov
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+// of the Software, and to permit persons to whom the Software is furnished to do
+// so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package yaml
+
+import (
+ "fmt"
+ "io"
+)
+
+// The version directive data.
+type yaml_version_directive_t struct {
+ major int8 // The major version number.
+ minor int8 // The minor version number.
+}
+
+// The tag directive data.
+type yaml_tag_directive_t struct {
+ handle []byte // The tag handle.
+ prefix []byte // The tag prefix.
+}
+
+type yaml_encoding_t int
+
+// The stream encoding.
+const (
+ // Let the parser choose the encoding.
+ yaml_ANY_ENCODING yaml_encoding_t = iota
+
+ yaml_UTF8_ENCODING // The default UTF-8 encoding.
+ yaml_UTF16LE_ENCODING // The UTF-16-LE encoding with BOM.
+ yaml_UTF16BE_ENCODING // The UTF-16-BE encoding with BOM.
+)
+
+type yaml_break_t int
+
+// Line break types.
+const (
+ // Let the parser choose the break type.
+ yaml_ANY_BREAK yaml_break_t = iota
+
+ yaml_CR_BREAK // Use CR for line breaks (Mac style).
+ yaml_LN_BREAK // Use LN for line breaks (Unix style).
+ yaml_CRLN_BREAK // Use CR LN for line breaks (DOS style).
+)
+
+type yaml_error_type_t int
+
+// Many bad things could happen with the parser and emitter.
+const (
+ // No error is produced.
+ yaml_NO_ERROR yaml_error_type_t = iota
+
+ yaml_MEMORY_ERROR // Cannot allocate or reallocate a block of memory.
+ yaml_READER_ERROR // Cannot read or decode the input stream.
+ yaml_SCANNER_ERROR // Cannot scan the input stream.
+ yaml_PARSER_ERROR // Cannot parse the input stream.
+ yaml_COMPOSER_ERROR // Cannot compose a YAML document.
+ yaml_WRITER_ERROR // Cannot write to the output stream.
+ yaml_EMITTER_ERROR // Cannot emit a YAML stream.
+)
+
+// The pointer position.
+type yaml_mark_t struct {
+ index int // The position index.
+ line int // The position line.
+ column int // The position column.
+}
+
+// Node Styles
+
+type yaml_style_t int8
+
+type yaml_scalar_style_t yaml_style_t
+
+// Scalar styles.
+const (
+ // Let the emitter choose the style.
+ yaml_ANY_SCALAR_STYLE yaml_scalar_style_t = 0
+
+ yaml_PLAIN_SCALAR_STYLE yaml_scalar_style_t = 1 << iota // The plain scalar style.
+ yaml_SINGLE_QUOTED_SCALAR_STYLE // The single-quoted scalar style.
+ yaml_DOUBLE_QUOTED_SCALAR_STYLE // The double-quoted scalar style.
+ yaml_LITERAL_SCALAR_STYLE // The literal scalar style.
+ yaml_FOLDED_SCALAR_STYLE // The folded scalar style.
+)
+
+type yaml_sequence_style_t yaml_style_t
+
+// Sequence styles.
+const (
+ // Let the emitter choose the style.
+ yaml_ANY_SEQUENCE_STYLE yaml_sequence_style_t = iota
+
+ yaml_BLOCK_SEQUENCE_STYLE // The block sequence style.
+ yaml_FLOW_SEQUENCE_STYLE // The flow sequence style.
+)
+
+type yaml_mapping_style_t yaml_style_t
+
+// Mapping styles.
+const (
+ // Let the emitter choose the style.
+ yaml_ANY_MAPPING_STYLE yaml_mapping_style_t = iota
+
+ yaml_BLOCK_MAPPING_STYLE // The block mapping style.
+ yaml_FLOW_MAPPING_STYLE // The flow mapping style.
+)
+
+// Tokens
+
+type yaml_token_type_t int
+
+// Token types.
+const (
+ // An empty token.
+ yaml_NO_TOKEN yaml_token_type_t = iota
+
+ yaml_STREAM_START_TOKEN // A STREAM-START token.
+ yaml_STREAM_END_TOKEN // A STREAM-END token.
+
+ yaml_VERSION_DIRECTIVE_TOKEN // A VERSION-DIRECTIVE token.
+ yaml_TAG_DIRECTIVE_TOKEN // A TAG-DIRECTIVE token.
+ yaml_DOCUMENT_START_TOKEN // A DOCUMENT-START token.
+ yaml_DOCUMENT_END_TOKEN // A DOCUMENT-END token.
+
+ yaml_BLOCK_SEQUENCE_START_TOKEN // A BLOCK-SEQUENCE-START token.
+ yaml_BLOCK_MAPPING_START_TOKEN // A BLOCK-SEQUENCE-END token.
+ yaml_BLOCK_END_TOKEN // A BLOCK-END token.
+
+ yaml_FLOW_SEQUENCE_START_TOKEN // A FLOW-SEQUENCE-START token.
+ yaml_FLOW_SEQUENCE_END_TOKEN // A FLOW-SEQUENCE-END token.
+ yaml_FLOW_MAPPING_START_TOKEN // A FLOW-MAPPING-START token.
+ yaml_FLOW_MAPPING_END_TOKEN // A FLOW-MAPPING-END token.
+
+ yaml_BLOCK_ENTRY_TOKEN // A BLOCK-ENTRY token.
+ yaml_FLOW_ENTRY_TOKEN // A FLOW-ENTRY token.
+ yaml_KEY_TOKEN // A KEY token.
+ yaml_VALUE_TOKEN // A VALUE token.
+
+ yaml_ALIAS_TOKEN // An ALIAS token.
+ yaml_ANCHOR_TOKEN // An ANCHOR token.
+ yaml_TAG_TOKEN // A TAG token.
+ yaml_SCALAR_TOKEN // A SCALAR token.
+)
+
+func (tt yaml_token_type_t) String() string {
+ switch tt {
+ case yaml_NO_TOKEN:
+ return "yaml_NO_TOKEN"
+ case yaml_STREAM_START_TOKEN:
+ return "yaml_STREAM_START_TOKEN"
+ case yaml_STREAM_END_TOKEN:
+ return "yaml_STREAM_END_TOKEN"
+ case yaml_VERSION_DIRECTIVE_TOKEN:
+ return "yaml_VERSION_DIRECTIVE_TOKEN"
+ case yaml_TAG_DIRECTIVE_TOKEN:
+ return "yaml_TAG_DIRECTIVE_TOKEN"
+ case yaml_DOCUMENT_START_TOKEN:
+ return "yaml_DOCUMENT_START_TOKEN"
+ case yaml_DOCUMENT_END_TOKEN:
+ return "yaml_DOCUMENT_END_TOKEN"
+ case yaml_BLOCK_SEQUENCE_START_TOKEN:
+ return "yaml_BLOCK_SEQUENCE_START_TOKEN"
+ case yaml_BLOCK_MAPPING_START_TOKEN:
+ return "yaml_BLOCK_MAPPING_START_TOKEN"
+ case yaml_BLOCK_END_TOKEN:
+ return "yaml_BLOCK_END_TOKEN"
+ case yaml_FLOW_SEQUENCE_START_TOKEN:
+ return "yaml_FLOW_SEQUENCE_START_TOKEN"
+ case yaml_FLOW_SEQUENCE_END_TOKEN:
+ return "yaml_FLOW_SEQUENCE_END_TOKEN"
+ case yaml_FLOW_MAPPING_START_TOKEN:
+ return "yaml_FLOW_MAPPING_START_TOKEN"
+ case yaml_FLOW_MAPPING_END_TOKEN:
+ return "yaml_FLOW_MAPPING_END_TOKEN"
+ case yaml_BLOCK_ENTRY_TOKEN:
+ return "yaml_BLOCK_ENTRY_TOKEN"
+ case yaml_FLOW_ENTRY_TOKEN:
+ return "yaml_FLOW_ENTRY_TOKEN"
+ case yaml_KEY_TOKEN:
+ return "yaml_KEY_TOKEN"
+ case yaml_VALUE_TOKEN:
+ return "yaml_VALUE_TOKEN"
+ case yaml_ALIAS_TOKEN:
+ return "yaml_ALIAS_TOKEN"
+ case yaml_ANCHOR_TOKEN:
+ return "yaml_ANCHOR_TOKEN"
+ case yaml_TAG_TOKEN:
+ return "yaml_TAG_TOKEN"
+ case yaml_SCALAR_TOKEN:
+ return "yaml_SCALAR_TOKEN"
+ }
+ return ""
+}
+
+// The token structure.
+type yaml_token_t struct {
+ // The token type.
+ typ yaml_token_type_t
+
+ // The start/end of the token.
+ start_mark, end_mark yaml_mark_t
+
+ // The stream encoding (for yaml_STREAM_START_TOKEN).
+ encoding yaml_encoding_t
+
+ // The alias/anchor/scalar value or tag/tag directive handle
+ // (for yaml_ALIAS_TOKEN, yaml_ANCHOR_TOKEN, yaml_SCALAR_TOKEN, yaml_TAG_TOKEN, yaml_TAG_DIRECTIVE_TOKEN).
+ value []byte
+
+ // The tag suffix (for yaml_TAG_TOKEN).
+ suffix []byte
+
+ // The tag directive prefix (for yaml_TAG_DIRECTIVE_TOKEN).
+ prefix []byte
+
+ // The scalar style (for yaml_SCALAR_TOKEN).
+ style yaml_scalar_style_t
+
+ // The version directive major/minor (for yaml_VERSION_DIRECTIVE_TOKEN).
+ major, minor int8
+}
+
+// Events
+
+type yaml_event_type_t int8
+
+// Event types.
+const (
+ // An empty event.
+ yaml_NO_EVENT yaml_event_type_t = iota
+
+ yaml_STREAM_START_EVENT // A STREAM-START event.
+ yaml_STREAM_END_EVENT // A STREAM-END event.
+ yaml_DOCUMENT_START_EVENT // A DOCUMENT-START event.
+ yaml_DOCUMENT_END_EVENT // A DOCUMENT-END event.
+ yaml_ALIAS_EVENT // An ALIAS event.
+ yaml_SCALAR_EVENT // A SCALAR event.
+ yaml_SEQUENCE_START_EVENT // A SEQUENCE-START event.
+ yaml_SEQUENCE_END_EVENT // A SEQUENCE-END event.
+ yaml_MAPPING_START_EVENT // A MAPPING-START event.
+ yaml_MAPPING_END_EVENT // A MAPPING-END event.
+ yaml_TAIL_COMMENT_EVENT
+)
+
+var eventStrings = []string{
+ yaml_NO_EVENT: "none",
+ yaml_STREAM_START_EVENT: "stream start",
+ yaml_STREAM_END_EVENT: "stream end",
+ yaml_DOCUMENT_START_EVENT: "document start",
+ yaml_DOCUMENT_END_EVENT: "document end",
+ yaml_ALIAS_EVENT: "alias",
+ yaml_SCALAR_EVENT: "scalar",
+ yaml_SEQUENCE_START_EVENT: "sequence start",
+ yaml_SEQUENCE_END_EVENT: "sequence end",
+ yaml_MAPPING_START_EVENT: "mapping start",
+ yaml_MAPPING_END_EVENT: "mapping end",
+ yaml_TAIL_COMMENT_EVENT: "tail comment",
+}
+
+func (e yaml_event_type_t) String() string {
+ if e < 0 || int(e) >= len(eventStrings) {
+ return fmt.Sprintf("unknown event %d", e)
+ }
+ return eventStrings[e]
+}
+
+// The event structure.
+type yaml_event_t struct {
+
+ // The event type.
+ typ yaml_event_type_t
+
+ // The start and end of the event.
+ start_mark, end_mark yaml_mark_t
+
+ // The document encoding (for yaml_STREAM_START_EVENT).
+ encoding yaml_encoding_t
+
+ // The version directive (for yaml_DOCUMENT_START_EVENT).
+ version_directive *yaml_version_directive_t
+
+ // The list of tag directives (for yaml_DOCUMENT_START_EVENT).
+ tag_directives []yaml_tag_directive_t
+
+ // The comments
+ head_comment []byte
+ line_comment []byte
+ foot_comment []byte
+ tail_comment []byte
+
+ // The anchor (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_ALIAS_EVENT).
+ anchor []byte
+
+ // The tag (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT).
+ tag []byte
+
+ // The scalar value (for yaml_SCALAR_EVENT).
+ value []byte
+
+ // Is the document start/end indicator implicit, or the tag optional?
+ // (for yaml_DOCUMENT_START_EVENT, yaml_DOCUMENT_END_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT, yaml_SCALAR_EVENT).
+ implicit bool
+
+ // Is the tag optional for any non-plain style? (for yaml_SCALAR_EVENT).
+ quoted_implicit bool
+
+ // The style (for yaml_SCALAR_EVENT, yaml_SEQUENCE_START_EVENT, yaml_MAPPING_START_EVENT).
+ style yaml_style_t
+}
+
+func (e *yaml_event_t) scalar_style() yaml_scalar_style_t { return yaml_scalar_style_t(e.style) }
+func (e *yaml_event_t) sequence_style() yaml_sequence_style_t { return yaml_sequence_style_t(e.style) }
+func (e *yaml_event_t) mapping_style() yaml_mapping_style_t { return yaml_mapping_style_t(e.style) }
+
+// Nodes
+
+const (
+ yaml_NULL_TAG = "tag:yaml.org,2002:null" // The tag !!null with the only possible value: null.
+ yaml_BOOL_TAG = "tag:yaml.org,2002:bool" // The tag !!bool with the values: true and false.
+ yaml_STR_TAG = "tag:yaml.org,2002:str" // The tag !!str for string values.
+ yaml_INT_TAG = "tag:yaml.org,2002:int" // The tag !!int for integer values.
+ yaml_FLOAT_TAG = "tag:yaml.org,2002:float" // The tag !!float for float values.
+ yaml_TIMESTAMP_TAG = "tag:yaml.org,2002:timestamp" // The tag !!timestamp for date and time values.
+
+ yaml_SEQ_TAG = "tag:yaml.org,2002:seq" // The tag !!seq is used to denote sequences.
+ yaml_MAP_TAG = "tag:yaml.org,2002:map" // The tag !!map is used to denote mapping.
+
+ // Not in original libyaml.
+ yaml_BINARY_TAG = "tag:yaml.org,2002:binary"
+ yaml_MERGE_TAG = "tag:yaml.org,2002:merge"
+
+ yaml_DEFAULT_SCALAR_TAG = yaml_STR_TAG // The default scalar tag is !!str.
+ yaml_DEFAULT_SEQUENCE_TAG = yaml_SEQ_TAG // The default sequence tag is !!seq.
+ yaml_DEFAULT_MAPPING_TAG = yaml_MAP_TAG // The default mapping tag is !!map.
+)
+
+type yaml_node_type_t int
+
+// Node types.
+const (
+ // An empty node.
+ yaml_NO_NODE yaml_node_type_t = iota
+
+ yaml_SCALAR_NODE // A scalar node.
+ yaml_SEQUENCE_NODE // A sequence node.
+ yaml_MAPPING_NODE // A mapping node.
+)
+
+// An element of a sequence node.
+type yaml_node_item_t int
+
+// An element of a mapping node.
+type yaml_node_pair_t struct {
+ key int // The key of the element.
+ value int // The value of the element.
+}
+
+// The node structure.
+type yaml_node_t struct {
+ typ yaml_node_type_t // The node type.
+ tag []byte // The node tag.
+
+ // The node data.
+
+ // The scalar parameters (for yaml_SCALAR_NODE).
+ scalar struct {
+ value []byte // The scalar value.
+ length int // The length of the scalar value.
+ style yaml_scalar_style_t // The scalar style.
+ }
+
+ // The sequence parameters (for YAML_SEQUENCE_NODE).
+ sequence struct {
+ items_data []yaml_node_item_t // The stack of sequence items.
+ style yaml_sequence_style_t // The sequence style.
+ }
+
+ // The mapping parameters (for yaml_MAPPING_NODE).
+ mapping struct {
+ pairs_data []yaml_node_pair_t // The stack of mapping pairs (key, value).
+ pairs_start *yaml_node_pair_t // The beginning of the stack.
+ pairs_end *yaml_node_pair_t // The end of the stack.
+ pairs_top *yaml_node_pair_t // The top of the stack.
+ style yaml_mapping_style_t // The mapping style.
+ }
+
+ start_mark yaml_mark_t // The beginning of the node.
+ end_mark yaml_mark_t // The end of the node.
+
+}
+
+// The document structure.
+type yaml_document_t struct {
+
+ // The document nodes.
+ nodes []yaml_node_t
+
+ // The version directive.
+ version_directive *yaml_version_directive_t
+
+ // The list of tag directives.
+ tag_directives_data []yaml_tag_directive_t
+ tag_directives_start int // The beginning of the tag directives list.
+ tag_directives_end int // The end of the tag directives list.
+
+ start_implicit int // Is the document start indicator implicit?
+ end_implicit int // Is the document end indicator implicit?
+
+ // The start/end of the document.
+ start_mark, end_mark yaml_mark_t
+}
+
+// The prototype of a read handler.
+//
+// The read handler is called when the parser needs to read more bytes from the
+// source. The handler should write not more than size bytes to the buffer.
+// The number of written bytes should be set to the size_read variable.
+//
+// [in,out] data A pointer to an application data specified by
+//
+// yaml_parser_set_input().
+//
+// [out] buffer The buffer to write the data from the source.
+// [in] size The size of the buffer.
+// [out] size_read The actual number of bytes read from the source.
+//
+// On success, the handler should return 1. If the handler failed,
+// the returned value should be 0. On EOF, the handler should set the
+// size_read to 0 and return 1.
+type yaml_read_handler_t func(parser *yaml_parser_t, buffer []byte) (n int, err error)
+
+// This structure holds information about a potential simple key.
+type yaml_simple_key_t struct {
+ possible bool // Is a simple key possible?
+ required bool // Is a simple key required?
+ token_number int // The number of the token.
+ mark yaml_mark_t // The position mark.
+}
+
+// The states of the parser.
+type yaml_parser_state_t int
+
+const (
+ yaml_PARSE_STREAM_START_STATE yaml_parser_state_t = iota
+
+ yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE // Expect the beginning of an implicit document.
+ yaml_PARSE_DOCUMENT_START_STATE // Expect DOCUMENT-START.
+ yaml_PARSE_DOCUMENT_CONTENT_STATE // Expect the content of a document.
+ yaml_PARSE_DOCUMENT_END_STATE // Expect DOCUMENT-END.
+ yaml_PARSE_BLOCK_NODE_STATE // Expect a block node.
+ yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE // Expect a block node or indentless sequence.
+ yaml_PARSE_FLOW_NODE_STATE // Expect a flow node.
+ yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a block sequence.
+ yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE // Expect an entry of a block sequence.
+ yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE // Expect an entry of an indentless sequence.
+ yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping.
+ yaml_PARSE_BLOCK_MAPPING_KEY_STATE // Expect a block mapping key.
+ yaml_PARSE_BLOCK_MAPPING_VALUE_STATE // Expect a block mapping value.
+ yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE // Expect the first entry of a flow sequence.
+ yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE // Expect an entry of a flow sequence.
+ yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE // Expect a key of an ordered mapping.
+ yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE // Expect a value of an ordered mapping.
+ yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE // Expect the and of an ordered mapping entry.
+ yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping.
+ yaml_PARSE_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping.
+ yaml_PARSE_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping.
+ yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE // Expect an empty value of a flow mapping.
+ yaml_PARSE_END_STATE // Expect nothing.
+)
+
+func (ps yaml_parser_state_t) String() string {
+ switch ps {
+ case yaml_PARSE_STREAM_START_STATE:
+ return "yaml_PARSE_STREAM_START_STATE"
+ case yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE:
+ return "yaml_PARSE_IMPLICIT_DOCUMENT_START_STATE"
+ case yaml_PARSE_DOCUMENT_START_STATE:
+ return "yaml_PARSE_DOCUMENT_START_STATE"
+ case yaml_PARSE_DOCUMENT_CONTENT_STATE:
+ return "yaml_PARSE_DOCUMENT_CONTENT_STATE"
+ case yaml_PARSE_DOCUMENT_END_STATE:
+ return "yaml_PARSE_DOCUMENT_END_STATE"
+ case yaml_PARSE_BLOCK_NODE_STATE:
+ return "yaml_PARSE_BLOCK_NODE_STATE"
+ case yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
+ return "yaml_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE"
+ case yaml_PARSE_FLOW_NODE_STATE:
+ return "yaml_PARSE_FLOW_NODE_STATE"
+ case yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
+ return "yaml_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE"
+ case yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
+ return "yaml_PARSE_BLOCK_SEQUENCE_ENTRY_STATE"
+ case yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
+ return "yaml_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE"
+ case yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
+ return "yaml_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE"
+ case yaml_PARSE_BLOCK_MAPPING_KEY_STATE:
+ return "yaml_PARSE_BLOCK_MAPPING_KEY_STATE"
+ case yaml_PARSE_BLOCK_MAPPING_VALUE_STATE:
+ return "yaml_PARSE_BLOCK_MAPPING_VALUE_STATE"
+ case yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
+ return "yaml_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE"
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
+ return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_STATE"
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
+ return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE"
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
+ return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE"
+ case yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
+ return "yaml_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE"
+ case yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
+ return "yaml_PARSE_FLOW_MAPPING_FIRST_KEY_STATE"
+ case yaml_PARSE_FLOW_MAPPING_KEY_STATE:
+ return "yaml_PARSE_FLOW_MAPPING_KEY_STATE"
+ case yaml_PARSE_FLOW_MAPPING_VALUE_STATE:
+ return "yaml_PARSE_FLOW_MAPPING_VALUE_STATE"
+ case yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
+ return "yaml_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE"
+ case yaml_PARSE_END_STATE:
+ return "yaml_PARSE_END_STATE"
+ }
+ return ""
+}
+
+// This structure holds aliases data.
+type yaml_alias_data_t struct {
+ anchor []byte // The anchor.
+ index int // The node id.
+ mark yaml_mark_t // The anchor mark.
+}
+
+// The parser structure.
+//
+// All members are internal. Manage the structure using the
+// yaml_parser_ family of functions.
+type yaml_parser_t struct {
+
+ // Error handling
+
+ error yaml_error_type_t // Error type.
+
+ problem string // Error description.
+
+ // The byte about which the problem occurred.
+ problem_offset int
+ problem_value int
+ problem_mark yaml_mark_t
+
+ // The error context.
+ context string
+ context_mark yaml_mark_t
+
+ // Reader stuff
+
+ read_handler yaml_read_handler_t // Read handler.
+
+ input_reader io.Reader // File input data.
+ input []byte // String input data.
+ input_pos int
+
+ eof bool // EOF flag
+
+ buffer []byte // The working buffer.
+ buffer_pos int // The current position of the buffer.
+
+ unread int // The number of unread characters in the buffer.
+
+ newlines int // The number of line breaks since last non-break/non-blank character
+
+ raw_buffer []byte // The raw buffer.
+ raw_buffer_pos int // The current position of the buffer.
+
+ encoding yaml_encoding_t // The input encoding.
+
+ offset int // The offset of the current position (in bytes).
+ mark yaml_mark_t // The mark of the current position.
+
+ // Comments
+
+ head_comment []byte // The current head comments
+ line_comment []byte // The current line comments
+ foot_comment []byte // The current foot comments
+ tail_comment []byte // Foot comment that happens at the end of a block.
+ stem_comment []byte // Comment in item preceding a nested structure (list inside list item, etc)
+
+ comments []yaml_comment_t // The folded comments for all parsed tokens
+ comments_head int
+
+ // Scanner stuff
+
+ stream_start_produced bool // Have we started to scan the input stream?
+ stream_end_produced bool // Have we reached the end of the input stream?
+
+ flow_level int // The number of unclosed '[' and '{' indicators.
+
+ tokens []yaml_token_t // The tokens queue.
+ tokens_head int // The head of the tokens queue.
+ tokens_parsed int // The number of tokens fetched from the queue.
+ token_available bool // Does the tokens queue contain a token ready for dequeueing.
+
+ indent int // The current indentation level.
+ indents []int // The indentation levels stack.
+
+ simple_key_allowed bool // May a simple key occur at the current position?
+ simple_keys []yaml_simple_key_t // The stack of simple keys.
+ simple_keys_by_tok map[int]int // possible simple_key indexes indexed by token_number
+
+ // Parser stuff
+
+ state yaml_parser_state_t // The current parser state.
+ states []yaml_parser_state_t // The parser states stack.
+ marks []yaml_mark_t // The stack of marks.
+ tag_directives []yaml_tag_directive_t // The list of TAG directives.
+
+ // Dumper stuff
+
+ aliases []yaml_alias_data_t // The alias data.
+
+ document *yaml_document_t // The currently parsed document.
+}
+
+type yaml_comment_t struct {
+ scan_mark yaml_mark_t // Position where scanning for comments started
+ token_mark yaml_mark_t // Position after which tokens will be associated with this comment
+ start_mark yaml_mark_t // Position of '#' comment mark
+ end_mark yaml_mark_t // Position where comment terminated
+
+ head []byte
+ line []byte
+ foot []byte
+}
+
+// Emitter Definitions
+
+// The prototype of a write handler.
+//
+// The write handler is called when the emitter needs to flush the accumulated
+// characters to the output. The handler should write @a size bytes of the
+// @a buffer to the output.
+//
+// @param[in,out] data A pointer to an application data specified by
+//
+// yaml_emitter_set_output().
+//
+// @param[in] buffer The buffer with bytes to be written.
+// @param[in] size The size of the buffer.
+//
+// @returns On success, the handler should return @c 1. If the handler failed,
+// the returned value should be @c 0.
+type yaml_write_handler_t func(emitter *yaml_emitter_t, buffer []byte) error
+
+type yaml_emitter_state_t int
+
+// The emitter states.
+const (
+ // Expect STREAM-START.
+ yaml_EMIT_STREAM_START_STATE yaml_emitter_state_t = iota
+
+ yaml_EMIT_FIRST_DOCUMENT_START_STATE // Expect the first DOCUMENT-START or STREAM-END.
+ yaml_EMIT_DOCUMENT_START_STATE // Expect DOCUMENT-START or STREAM-END.
+ yaml_EMIT_DOCUMENT_CONTENT_STATE // Expect the content of a document.
+ yaml_EMIT_DOCUMENT_END_STATE // Expect DOCUMENT-END.
+ yaml_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a flow sequence.
+ yaml_EMIT_FLOW_SEQUENCE_TRAIL_ITEM_STATE // Expect the next item of a flow sequence, with the comma already written out
+ yaml_EMIT_FLOW_SEQUENCE_ITEM_STATE // Expect an item of a flow sequence.
+ yaml_EMIT_FLOW_MAPPING_FIRST_KEY_STATE // Expect the first key of a flow mapping.
+ yaml_EMIT_FLOW_MAPPING_TRAIL_KEY_STATE // Expect the next key of a flow mapping, with the comma already written out
+ yaml_EMIT_FLOW_MAPPING_KEY_STATE // Expect a key of a flow mapping.
+ yaml_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a flow mapping.
+ yaml_EMIT_FLOW_MAPPING_VALUE_STATE // Expect a value of a flow mapping.
+ yaml_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE // Expect the first item of a block sequence.
+ yaml_EMIT_BLOCK_SEQUENCE_ITEM_STATE // Expect an item of a block sequence.
+ yaml_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE // Expect the first key of a block mapping.
+ yaml_EMIT_BLOCK_MAPPING_KEY_STATE // Expect the key of a block mapping.
+ yaml_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE // Expect a value for a simple key of a block mapping.
+ yaml_EMIT_BLOCK_MAPPING_VALUE_STATE // Expect a value of a block mapping.
+ yaml_EMIT_END_STATE // Expect nothing.
+)
+
+// The emitter structure.
+//
+// All members are internal. Manage the structure using the @c yaml_emitter_
+// family of functions.
+type yaml_emitter_t struct {
+
+ // Error handling
+
+ error yaml_error_type_t // Error type.
+ problem string // Error description.
+
+ // Writer stuff
+
+ write_handler yaml_write_handler_t // Write handler.
+
+ output_buffer *[]byte // String output data.
+ output_writer io.Writer // File output data.
+
+ buffer []byte // The working buffer.
+ buffer_pos int // The current position of the buffer.
+
+ raw_buffer []byte // The raw buffer.
+ raw_buffer_pos int // The current position of the buffer.
+
+ encoding yaml_encoding_t // The stream encoding.
+
+ // Emitter stuff
+
+ canonical bool // If the output is in the canonical style?
+ best_indent int // The number of indentation spaces.
+ best_width int // The preferred width of the output lines.
+ unicode bool // Allow unescaped non-ASCII characters?
+ line_break yaml_break_t // The preferred line break.
+
+ state yaml_emitter_state_t // The current emitter state.
+ states []yaml_emitter_state_t // The stack of states.
+
+ events []yaml_event_t // The event queue.
+ events_head int // The head of the event queue.
+
+ indents []int // The stack of indentation levels.
+
+ tag_directives []yaml_tag_directive_t // The list of tag directives.
+
+ indent int // The current indentation level.
+
+ compact_sequence_indent bool // Is '- ' is considered part of the indentation for sequence elements?
+
+ flow_level int // The current flow level.
+
+ root_context bool // Is it the document root context?
+ sequence_context bool // Is it a sequence context?
+ mapping_context bool // Is it a mapping context?
+ simple_key_context bool // Is it a simple mapping key context?
+
+ line int // The current line.
+ column int // The current column.
+ whitespace bool // If the last character was a whitespace?
+ indention bool // If the last character was an indentation character (' ', '-', '?', ':')?
+ open_ended bool // If an explicit document end is required?
+
+ space_above bool // Is there's an empty line above?
+ foot_indent int // The indent used to write the foot comment above, or -1 if none.
+
+ // Anchor analysis.
+ anchor_data struct {
+ anchor []byte // The anchor value.
+ alias bool // Is it an alias?
+ }
+
+ // Tag analysis.
+ tag_data struct {
+ handle []byte // The tag handle.
+ suffix []byte // The tag suffix.
+ }
+
+ // Scalar analysis.
+ scalar_data struct {
+ value []byte // The scalar value.
+ multiline bool // Does the scalar contain line breaks?
+ flow_plain_allowed bool // Can the scalar be expessed in the flow plain style?
+ block_plain_allowed bool // Can the scalar be expressed in the block plain style?
+ single_quoted_allowed bool // Can the scalar be expressed in the single quoted style?
+ block_allowed bool // Can the scalar be expressed in the literal or folded styles?
+ style yaml_scalar_style_t // The output style.
+ }
+
+ // Comments
+ head_comment []byte
+ line_comment []byte
+ foot_comment []byte
+ tail_comment []byte
+
+ key_line_comment []byte
+
+ // Dumper stuff
+
+ opened bool // If the stream was already opened?
+ closed bool // If the stream was already closed?
+
+ // The information associated with the document nodes.
+ anchors *struct {
+ references int // The number of references.
+ anchor int // The anchor id.
+ serialized bool // If the node has been emitted?
+ }
+
+ last_anchor_id int // The last assigned anchor id.
+
+ document *yaml_document_t // The currently emitted document.
+}
diff --git a/vendor/go.yaml.in/yaml/v3/yamlprivateh.go b/vendor/go.yaml.in/yaml/v3/yamlprivateh.go
new file mode 100644
index 00000000..dea1ba96
--- /dev/null
+++ b/vendor/go.yaml.in/yaml/v3/yamlprivateh.go
@@ -0,0 +1,198 @@
+//
+// Copyright (c) 2011-2019 Canonical Ltd
+// Copyright (c) 2006-2010 Kirill Simonov
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+// of the Software, and to permit persons to whom the Software is furnished to do
+// so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+package yaml
+
+const (
+ // The size of the input raw buffer.
+ input_raw_buffer_size = 512
+
+ // The size of the input buffer.
+ // It should be possible to decode the whole raw buffer.
+ input_buffer_size = input_raw_buffer_size * 3
+
+ // The size of the output buffer.
+ output_buffer_size = 128
+
+ // The size of the output raw buffer.
+ // It should be possible to encode the whole output buffer.
+ output_raw_buffer_size = (output_buffer_size*2 + 2)
+
+ // The size of other stacks and queues.
+ initial_stack_size = 16
+ initial_queue_size = 16
+ initial_string_size = 16
+)
+
+// Check if the character at the specified position is an alphabetical
+// character, a digit, '_', or '-'.
+func is_alpha(b []byte, i int) bool {
+ return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'Z' || b[i] >= 'a' && b[i] <= 'z' || b[i] == '_' || b[i] == '-'
+}
+
+// Check if the character at the specified position is a digit.
+func is_digit(b []byte, i int) bool {
+ return b[i] >= '0' && b[i] <= '9'
+}
+
+// Get the value of a digit.
+func as_digit(b []byte, i int) int {
+ return int(b[i]) - '0'
+}
+
+// Check if the character at the specified position is a hex-digit.
+func is_hex(b []byte, i int) bool {
+ return b[i] >= '0' && b[i] <= '9' || b[i] >= 'A' && b[i] <= 'F' || b[i] >= 'a' && b[i] <= 'f'
+}
+
+// Get the value of a hex-digit.
+func as_hex(b []byte, i int) int {
+ bi := b[i]
+ if bi >= 'A' && bi <= 'F' {
+ return int(bi) - 'A' + 10
+ }
+ if bi >= 'a' && bi <= 'f' {
+ return int(bi) - 'a' + 10
+ }
+ return int(bi) - '0'
+}
+
+// Check if the character is ASCII.
+func is_ascii(b []byte, i int) bool {
+ return b[i] <= 0x7F
+}
+
+// Check if the character at the start of the buffer can be printed unescaped.
+func is_printable(b []byte, i int) bool {
+ return ((b[i] == 0x0A) || // . == #x0A
+ (b[i] >= 0x20 && b[i] <= 0x7E) || // #x20 <= . <= #x7E
+ (b[i] == 0xC2 && b[i+1] >= 0xA0) || // #0xA0 <= . <= #xD7FF
+ (b[i] > 0xC2 && b[i] < 0xED) ||
+ (b[i] == 0xED && b[i+1] < 0xA0) ||
+ (b[i] == 0xEE) ||
+ (b[i] == 0xEF && // #xE000 <= . <= #xFFFD
+ !(b[i+1] == 0xBB && b[i+2] == 0xBF) && // && . != #xFEFF
+ !(b[i+1] == 0xBF && (b[i+2] == 0xBE || b[i+2] == 0xBF))))
+}
+
+// Check if the character at the specified position is NUL.
+func is_z(b []byte, i int) bool {
+ return b[i] == 0x00
+}
+
+// Check if the beginning of the buffer is a BOM.
+func is_bom(b []byte, i int) bool {
+ return b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF
+}
+
+// Check if the character at the specified position is space.
+func is_space(b []byte, i int) bool {
+ return b[i] == ' '
+}
+
+// Check if the character at the specified position is tab.
+func is_tab(b []byte, i int) bool {
+ return b[i] == '\t'
+}
+
+// Check if the character at the specified position is blank (space or tab).
+func is_blank(b []byte, i int) bool {
+ //return is_space(b, i) || is_tab(b, i)
+ return b[i] == ' ' || b[i] == '\t'
+}
+
+// Check if the character at the specified position is a line break.
+func is_break(b []byte, i int) bool {
+ return (b[i] == '\r' || // CR (#xD)
+ b[i] == '\n' || // LF (#xA)
+ b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9) // PS (#x2029)
+}
+
+func is_crlf(b []byte, i int) bool {
+ return b[i] == '\r' && b[i+1] == '\n'
+}
+
+// Check if the character is a line break or NUL.
+func is_breakz(b []byte, i int) bool {
+ //return is_break(b, i) || is_z(b, i)
+ return (
+ // is_break:
+ b[i] == '\r' || // CR (#xD)
+ b[i] == '\n' || // LF (#xA)
+ b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
+ // is_z:
+ b[i] == 0)
+}
+
+// Check if the character is a line break, space, or NUL.
+func is_spacez(b []byte, i int) bool {
+ //return is_space(b, i) || is_breakz(b, i)
+ return (
+ // is_space:
+ b[i] == ' ' ||
+ // is_breakz:
+ b[i] == '\r' || // CR (#xD)
+ b[i] == '\n' || // LF (#xA)
+ b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
+ b[i] == 0)
+}
+
+// Check if the character is a line break, space, tab, or NUL.
+func is_blankz(b []byte, i int) bool {
+ //return is_blank(b, i) || is_breakz(b, i)
+ return (
+ // is_blank:
+ b[i] == ' ' || b[i] == '\t' ||
+ // is_breakz:
+ b[i] == '\r' || // CR (#xD)
+ b[i] == '\n' || // LF (#xA)
+ b[i] == 0xC2 && b[i+1] == 0x85 || // NEL (#x85)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA8 || // LS (#x2028)
+ b[i] == 0xE2 && b[i+1] == 0x80 && b[i+2] == 0xA9 || // PS (#x2029)
+ b[i] == 0)
+}
+
+// Determine the width of the character.
+func width(b byte) int {
+ // Don't replace these by a switch without first
+ // confirming that it is being inlined.
+ if b&0x80 == 0x00 {
+ return 1
+ }
+ if b&0xE0 == 0xC0 {
+ return 2
+ }
+ if b&0xF0 == 0xE0 {
+ return 3
+ }
+ if b&0xF8 == 0xF0 {
+ return 4
+ }
+ return 0
+
+}
diff --git a/vendor/golang.org/x/mod/LICENSE b/vendor/golang.org/x/mod/LICENSE
new file mode 100644
index 00000000..2a7cf70d
--- /dev/null
+++ b/vendor/golang.org/x/mod/LICENSE
@@ -0,0 +1,27 @@
+Copyright 2009 The Go Authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+ * Neither the name of Google LLC nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/golang.org/x/mod/PATENTS b/vendor/golang.org/x/mod/PATENTS
new file mode 100644
index 00000000..73309904
--- /dev/null
+++ b/vendor/golang.org/x/mod/PATENTS
@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go. This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation. If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.
diff --git a/vendor/golang.org/x/mod/semver/semver.go b/vendor/golang.org/x/mod/semver/semver.go
new file mode 100644
index 00000000..628f8fd6
--- /dev/null
+++ b/vendor/golang.org/x/mod/semver/semver.go
@@ -0,0 +1,407 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package semver implements comparison of semantic version strings.
+// In this package, semantic version strings must begin with a leading "v",
+// as in "v1.0.0".
+//
+// The general form of a semantic version string accepted by this package is
+//
+// vMAJOR[.MINOR[.PATCH[-PRERELEASE][+BUILD]]]
+//
+// where square brackets indicate optional parts of the syntax;
+// MAJOR, MINOR, and PATCH are decimal integers without extra leading zeros;
+// PRERELEASE and BUILD are each a series of non-empty dot-separated identifiers
+// using only alphanumeric characters and hyphens; and
+// all-numeric PRERELEASE identifiers must not have leading zeros.
+//
+// This package follows Semantic Versioning 2.0.0 (see semver.org)
+// with two exceptions. First, it requires the "v" prefix. Second, it recognizes
+// vMAJOR and vMAJOR.MINOR (with no prerelease or build suffixes)
+// as shorthands for vMAJOR.0.0 and vMAJOR.MINOR.0.
+package semver
+
+import (
+ "slices"
+ "strings"
+)
+
+// parsed returns the parsed form of a semantic version string.
+type parsed struct {
+ major string
+ minor string
+ patch string
+ short string
+ prerelease string
+ build string
+}
+
+// IsValid reports whether v is a valid semantic version string.
+func IsValid(v string) bool {
+ _, ok := parse(v)
+ return ok
+}
+
+// Canonical returns the canonical formatting of the semantic version v.
+// It fills in any missing .MINOR or .PATCH and discards build metadata.
+// Two semantic versions compare equal only if their canonical formattings
+// are identical strings.
+// The canonical invalid semantic version is the empty string.
+func Canonical(v string) string {
+ p, ok := parse(v)
+ if !ok {
+ return ""
+ }
+ if p.build != "" {
+ return v[:len(v)-len(p.build)]
+ }
+ if p.short != "" {
+ return v + p.short
+ }
+ return v
+}
+
+// Major returns the major version prefix of the semantic version v.
+// For example, Major("v2.1.0") == "v2".
+// If v is an invalid semantic version string, Major returns the empty string.
+func Major(v string) string {
+ pv, ok := parse(v)
+ if !ok {
+ return ""
+ }
+ return v[:1+len(pv.major)]
+}
+
+// MajorMinor returns the major.minor version prefix of the semantic version v.
+// For example, MajorMinor("v2.1.0") == "v2.1".
+// If v is an invalid semantic version string, MajorMinor returns the empty string.
+func MajorMinor(v string) string {
+ pv, ok := parse(v)
+ if !ok {
+ return ""
+ }
+ i := 1 + len(pv.major)
+ if j := i + 1 + len(pv.minor); j <= len(v) && v[i] == '.' && v[i+1:j] == pv.minor {
+ return v[:j]
+ }
+ return v[:i] + "." + pv.minor
+}
+
+// Prerelease returns the prerelease suffix of the semantic version v.
+// For example, Prerelease("v2.1.0-pre+meta") == "-pre".
+// If v is an invalid semantic version string, Prerelease returns the empty string.
+func Prerelease(v string) string {
+ pv, ok := parse(v)
+ if !ok {
+ return ""
+ }
+ return pv.prerelease
+}
+
+// Build returns the build suffix of the semantic version v.
+// For example, Build("v2.1.0+meta") == "+meta".
+// If v is an invalid semantic version string, Build returns the empty string.
+func Build(v string) string {
+ pv, ok := parse(v)
+ if !ok {
+ return ""
+ }
+ return pv.build
+}
+
+// Compare returns an integer comparing two versions according to
+// semantic version precedence.
+// The result will be 0 if v == w, -1 if v < w, or +1 if v > w.
+//
+// An invalid semantic version string is considered less than a valid one.
+// All invalid semantic version strings compare equal to each other.
+func Compare(v, w string) int {
+ pv, ok1 := parse(v)
+ pw, ok2 := parse(w)
+ if !ok1 && !ok2 {
+ return 0
+ }
+ if !ok1 {
+ return -1
+ }
+ if !ok2 {
+ return +1
+ }
+ if c := compareInt(pv.major, pw.major); c != 0 {
+ return c
+ }
+ if c := compareInt(pv.minor, pw.minor); c != 0 {
+ return c
+ }
+ if c := compareInt(pv.patch, pw.patch); c != 0 {
+ return c
+ }
+ return comparePrerelease(pv.prerelease, pw.prerelease)
+}
+
+// Max canonicalizes its arguments and then returns the version string
+// that compares greater.
+//
+// Deprecated: use [Compare] instead. In most cases, returning a canonicalized
+// version is not expected or desired.
+func Max(v, w string) string {
+ v = Canonical(v)
+ w = Canonical(w)
+ if Compare(v, w) > 0 {
+ return v
+ }
+ return w
+}
+
+// ByVersion implements [sort.Interface] for sorting semantic version strings.
+type ByVersion []string
+
+func (vs ByVersion) Len() int { return len(vs) }
+func (vs ByVersion) Swap(i, j int) { vs[i], vs[j] = vs[j], vs[i] }
+func (vs ByVersion) Less(i, j int) bool { return compareVersion(vs[i], vs[j]) < 0 }
+
+// Sort sorts a list of semantic version strings using [Compare] and falls back
+// to use [strings.Compare] if both versions are considered equal.
+func Sort(list []string) {
+ slices.SortFunc(list, compareVersion)
+}
+
+func compareVersion(a, b string) int {
+ cmp := Compare(a, b)
+ if cmp != 0 {
+ return cmp
+ }
+ return strings.Compare(a, b)
+}
+
+func parse(v string) (p parsed, ok bool) {
+ if v == "" || v[0] != 'v' {
+ return
+ }
+ p.major, v, ok = parseInt(v[1:])
+ if !ok {
+ return
+ }
+ if v == "" {
+ p.minor = "0"
+ p.patch = "0"
+ p.short = ".0.0"
+ return
+ }
+ if v[0] != '.' {
+ ok = false
+ return
+ }
+ p.minor, v, ok = parseInt(v[1:])
+ if !ok {
+ return
+ }
+ if v == "" {
+ p.patch = "0"
+ p.short = ".0"
+ return
+ }
+ if v[0] != '.' {
+ ok = false
+ return
+ }
+ p.patch, v, ok = parseInt(v[1:])
+ if !ok {
+ return
+ }
+ if len(v) > 0 && v[0] == '-' {
+ p.prerelease, v, ok = parsePrerelease(v)
+ if !ok {
+ return
+ }
+ }
+ if len(v) > 0 && v[0] == '+' {
+ p.build, v, ok = parseBuild(v)
+ if !ok {
+ return
+ }
+ }
+ if v != "" {
+ ok = false
+ return
+ }
+ ok = true
+ return
+}
+
+func parseInt(v string) (t, rest string, ok bool) {
+ if v == "" {
+ return
+ }
+ if v[0] < '0' || '9' < v[0] {
+ return
+ }
+ i := 1
+ for i < len(v) && '0' <= v[i] && v[i] <= '9' {
+ i++
+ }
+ if v[0] == '0' && i != 1 {
+ return
+ }
+ return v[:i], v[i:], true
+}
+
+func parsePrerelease(v string) (t, rest string, ok bool) {
+ // "A pre-release version MAY be denoted by appending a hyphen and
+ // a series of dot separated identifiers immediately following the patch version.
+ // Identifiers MUST comprise only ASCII alphanumerics and hyphen [0-9A-Za-z-].
+ // Identifiers MUST NOT be empty. Numeric identifiers MUST NOT include leading zeroes."
+ if v == "" || v[0] != '-' {
+ return
+ }
+ i := 1
+ start := 1
+ for i < len(v) && v[i] != '+' {
+ if !isIdentChar(v[i]) && v[i] != '.' {
+ return
+ }
+ if v[i] == '.' {
+ if start == i || isBadNum(v[start:i]) {
+ return
+ }
+ start = i + 1
+ }
+ i++
+ }
+ if start == i || isBadNum(v[start:i]) {
+ return
+ }
+ return v[:i], v[i:], true
+}
+
+func parseBuild(v string) (t, rest string, ok bool) {
+ if v == "" || v[0] != '+' {
+ return
+ }
+ i := 1
+ start := 1
+ for i < len(v) {
+ if !isIdentChar(v[i]) && v[i] != '.' {
+ return
+ }
+ if v[i] == '.' {
+ if start == i {
+ return
+ }
+ start = i + 1
+ }
+ i++
+ }
+ if start == i {
+ return
+ }
+ return v[:i], v[i:], true
+}
+
+func isIdentChar(c byte) bool {
+ return 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' || c == '-'
+}
+
+func isBadNum(v string) bool {
+ i := 0
+ for i < len(v) && '0' <= v[i] && v[i] <= '9' {
+ i++
+ }
+ return i == len(v) && i > 1 && v[0] == '0'
+}
+
+func isNum(v string) bool {
+ i := 0
+ for i < len(v) && '0' <= v[i] && v[i] <= '9' {
+ i++
+ }
+ return i == len(v)
+}
+
+func compareInt(x, y string) int {
+ if x == y {
+ return 0
+ }
+ if len(x) < len(y) {
+ return -1
+ }
+ if len(x) > len(y) {
+ return +1
+ }
+ if x < y {
+ return -1
+ } else {
+ return +1
+ }
+}
+
+func comparePrerelease(x, y string) int {
+ // "When major, minor, and patch are equal, a pre-release version has
+ // lower precedence than a normal version.
+ // Example: 1.0.0-alpha < 1.0.0.
+ // Precedence for two pre-release versions with the same major, minor,
+ // and patch version MUST be determined by comparing each dot separated
+ // identifier from left to right until a difference is found as follows:
+ // identifiers consisting of only digits are compared numerically and
+ // identifiers with letters or hyphens are compared lexically in ASCII
+ // sort order. Numeric identifiers always have lower precedence than
+ // non-numeric identifiers. A larger set of pre-release fields has a
+ // higher precedence than a smaller set, if all of the preceding
+ // identifiers are equal.
+ // Example: 1.0.0-alpha < 1.0.0-alpha.1 < 1.0.0-alpha.beta <
+ // 1.0.0-beta < 1.0.0-beta.2 < 1.0.0-beta.11 < 1.0.0-rc.1 < 1.0.0."
+ if x == y {
+ return 0
+ }
+ if x == "" {
+ return +1
+ }
+ if y == "" {
+ return -1
+ }
+ for x != "" && y != "" {
+ x = x[1:] // skip - or .
+ y = y[1:] // skip - or .
+ var dx, dy string
+ dx, x = nextIdent(x)
+ dy, y = nextIdent(y)
+ if dx != dy {
+ ix := isNum(dx)
+ iy := isNum(dy)
+ if ix != iy {
+ if ix {
+ return -1
+ } else {
+ return +1
+ }
+ }
+ if ix {
+ if len(dx) < len(dy) {
+ return -1
+ }
+ if len(dx) > len(dy) {
+ return +1
+ }
+ }
+ if dx < dy {
+ return -1
+ } else {
+ return +1
+ }
+ }
+ }
+ if x == "" {
+ return -1
+ } else {
+ return +1
+ }
+}
+
+func nextIdent(x string) (dx, rest string) {
+ i := 0
+ for i < len(x) && x[i] != '.' {
+ i++
+ }
+ return x[:i], x[i:]
+}
diff --git a/vendor/golang.org/x/net/http2/http2.go b/vendor/golang.org/x/net/http2/http2.go
index 6c18ea23..ea5ae629 100644
--- a/vendor/golang.org/x/net/http2/http2.go
+++ b/vendor/golang.org/x/net/http2/http2.go
@@ -11,8 +11,6 @@
// requires Go 1.6 or later)
//
// See https://http2.github.io/ for more information on HTTP/2.
-//
-// See https://http2.golang.org/ for a test server running this code.
package http2 // import "golang.org/x/net/http2"
import (
diff --git a/vendor/golang.org/x/sync/errgroup/errgroup.go b/vendor/golang.org/x/sync/errgroup/errgroup.go
index cb6bb9ad..1d8cffae 100644
--- a/vendor/golang.org/x/sync/errgroup/errgroup.go
+++ b/vendor/golang.org/x/sync/errgroup/errgroup.go
@@ -12,8 +12,6 @@ package errgroup
import (
"context"
"fmt"
- "runtime"
- "runtime/debug"
"sync"
)
@@ -33,10 +31,6 @@ type Group struct {
errOnce sync.Once
err error
-
- mu sync.Mutex
- panicValue any // = PanicError | PanicValue; non-nil if some Group.Go goroutine panicked.
- abnormal bool // some Group.Go goroutine terminated abnormally (panic or goexit).
}
func (g *Group) done() {
@@ -56,22 +50,13 @@ func WithContext(ctx context.Context) (*Group, context.Context) {
return &Group{cancel: cancel}, ctx
}
-// Wait blocks until all function calls from the Go method have returned
-// normally, then returns the first non-nil error (if any) from them.
-//
-// If any of the calls panics, Wait panics with a [PanicValue];
-// and if any of them calls [runtime.Goexit], Wait calls runtime.Goexit.
+// Wait blocks until all function calls from the Go method have returned, then
+// returns the first non-nil error (if any) from them.
func (g *Group) Wait() error {
g.wg.Wait()
if g.cancel != nil {
g.cancel(g.err)
}
- if g.panicValue != nil {
- panic(g.panicValue)
- }
- if g.abnormal {
- runtime.Goexit()
- }
return g.err
}
@@ -81,53 +66,31 @@ func (g *Group) Wait() error {
// It blocks until the new goroutine can be added without the number of
// goroutines in the group exceeding the configured limit.
//
-// The first goroutine in the group that returns a non-nil error, panics, or
-// invokes [runtime.Goexit] will cancel the associated Context, if any.
+// The first goroutine in the group that returns a non-nil error will
+// cancel the associated Context, if any. The error will be returned
+// by Wait.
func (g *Group) Go(f func() error) {
if g.sem != nil {
g.sem <- token{}
}
- g.add(f)
-}
-
-func (g *Group) add(f func() error) {
g.wg.Add(1)
go func() {
defer g.done()
- normalReturn := false
- defer func() {
- if normalReturn {
- return
- }
- v := recover()
- g.mu.Lock()
- defer g.mu.Unlock()
- if !g.abnormal {
- if g.cancel != nil {
- g.cancel(g.err)
- }
- g.abnormal = true
- }
- if v != nil && g.panicValue == nil {
- switch v := v.(type) {
- case error:
- g.panicValue = PanicError{
- Recovered: v,
- Stack: debug.Stack(),
- }
- default:
- g.panicValue = PanicValue{
- Recovered: v,
- Stack: debug.Stack(),
- }
- }
- }
- }()
- err := f()
- normalReturn = true
- if err != nil {
+ // It is tempting to propagate panics from f()
+ // up to the goroutine that calls Wait, but
+ // it creates more problems than it solves:
+ // - it delays panics arbitrarily,
+ // making bugs harder to detect;
+ // - it turns f's panic stack into a mere value,
+ // hiding it from crash-monitoring tools;
+ // - it risks deadlocks that hide the panic entirely,
+ // if f's panic leaves the program in a state
+ // that prevents the Wait call from being reached.
+ // See #53757, #74275, #74304, #74306.
+
+ if err := f(); err != nil {
g.errOnce.Do(func() {
g.err = err
if g.cancel != nil {
@@ -152,7 +115,19 @@ func (g *Group) TryGo(f func() error) bool {
}
}
- g.add(f)
+ g.wg.Add(1)
+ go func() {
+ defer g.done()
+
+ if err := f(); err != nil {
+ g.errOnce.Do(func() {
+ g.err = err
+ if g.cancel != nil {
+ g.cancel(g.err)
+ }
+ })
+ }
+ }()
return true
}
@@ -174,34 +149,3 @@ func (g *Group) SetLimit(n int) {
}
g.sem = make(chan token, n)
}
-
-// PanicError wraps an error recovered from an unhandled panic
-// when calling a function passed to Go or TryGo.
-type PanicError struct {
- Recovered error
- Stack []byte // result of call to [debug.Stack]
-}
-
-func (p PanicError) Error() string {
- if len(p.Stack) > 0 {
- return fmt.Sprintf("recovered from errgroup.Group: %v\n%s", p.Recovered, p.Stack)
- }
- return fmt.Sprintf("recovered from errgroup.Group: %v", p.Recovered)
-}
-
-func (p PanicError) Unwrap() error { return p.Recovered }
-
-// PanicValue wraps a value that does not implement the error interface,
-// recovered from an unhandled panic when calling a function passed to Go or
-// TryGo.
-type PanicValue struct {
- Recovered any
- Stack []byte // result of call to [debug.Stack]
-}
-
-func (p PanicValue) String() string {
- if len(p.Stack) > 0 {
- return fmt.Sprintf("recovered from errgroup.Group: %v\n%s", p.Recovered, p.Stack)
- }
- return fmt.Sprintf("recovered from errgroup.Group: %v", p.Recovered)
-}
diff --git a/vendor/golang.org/x/sys/unix/mkerrors.sh b/vendor/golang.org/x/sys/unix/mkerrors.sh
index 6ab02b6c..d1c8b264 100644
--- a/vendor/golang.org/x/sys/unix/mkerrors.sh
+++ b/vendor/golang.org/x/sys/unix/mkerrors.sh
@@ -349,6 +349,9 @@ struct ltchars {
#define _HIDIOCGRAWPHYS HIDIOCGRAWPHYS(_HIDIOCGRAWPHYS_LEN)
#define _HIDIOCGRAWUNIQ HIDIOCGRAWUNIQ(_HIDIOCGRAWUNIQ_LEN)
+// Renamed in v6.16, commit c6d732c38f93 ("net: ethtool: remove duplicate defines for family info")
+#define ETHTOOL_FAMILY_NAME ETHTOOL_GENL_NAME
+#define ETHTOOL_FAMILY_VERSION ETHTOOL_GENL_VERSION
'
includes_NetBSD='
diff --git a/vendor/golang.org/x/sys/unix/syscall_darwin.go b/vendor/golang.org/x/sys/unix/syscall_darwin.go
index 798f61ad..7838ca5d 100644
--- a/vendor/golang.org/x/sys/unix/syscall_darwin.go
+++ b/vendor/golang.org/x/sys/unix/syscall_darwin.go
@@ -602,14 +602,9 @@ func Connectx(fd int, srcIf uint32, srcAddr, dstAddr Sockaddr, associd SaeAssocI
return
}
-// sys connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error)
const minIovec = 8
func Readv(fd int, iovs [][]byte) (n int, err error) {
- if !darwinKernelVersionMin(11, 0, 0) {
- return 0, ENOSYS
- }
-
iovecs := make([]Iovec, 0, minIovec)
iovecs = appendBytes(iovecs, iovs)
n, err = readv(fd, iovecs)
@@ -618,9 +613,6 @@ func Readv(fd int, iovs [][]byte) (n int, err error) {
}
func Preadv(fd int, iovs [][]byte, offset int64) (n int, err error) {
- if !darwinKernelVersionMin(11, 0, 0) {
- return 0, ENOSYS
- }
iovecs := make([]Iovec, 0, minIovec)
iovecs = appendBytes(iovecs, iovs)
n, err = preadv(fd, iovecs, offset)
@@ -629,10 +621,6 @@ func Preadv(fd int, iovs [][]byte, offset int64) (n int, err error) {
}
func Writev(fd int, iovs [][]byte) (n int, err error) {
- if !darwinKernelVersionMin(11, 0, 0) {
- return 0, ENOSYS
- }
-
iovecs := make([]Iovec, 0, minIovec)
iovecs = appendBytes(iovecs, iovs)
if raceenabled {
@@ -644,10 +632,6 @@ func Writev(fd int, iovs [][]byte) (n int, err error) {
}
func Pwritev(fd int, iovs [][]byte, offset int64) (n int, err error) {
- if !darwinKernelVersionMin(11, 0, 0) {
- return 0, ENOSYS
- }
-
iovecs := make([]Iovec, 0, minIovec)
iovecs = appendBytes(iovecs, iovs)
if raceenabled {
@@ -707,45 +691,7 @@ func readvRacedetect(iovecs []Iovec, n int, err error) {
}
}
-func darwinMajorMinPatch() (maj, min, patch int, err error) {
- var un Utsname
- err = Uname(&un)
- if err != nil {
- return
- }
-
- var mmp [3]int
- c := 0
-Loop:
- for _, b := range un.Release[:] {
- switch {
- case b >= '0' && b <= '9':
- mmp[c] = 10*mmp[c] + int(b-'0')
- case b == '.':
- c++
- if c > 2 {
- return 0, 0, 0, ENOTSUP
- }
- case b == 0:
- break Loop
- default:
- return 0, 0, 0, ENOTSUP
- }
- }
- if c != 2 {
- return 0, 0, 0, ENOTSUP
- }
- return mmp[0], mmp[1], mmp[2], nil
-}
-
-func darwinKernelVersionMin(maj, min, patch int) bool {
- actualMaj, actualMin, actualPatch, err := darwinMajorMinPatch()
- if err != nil {
- return false
- }
- return actualMaj > maj || actualMaj == maj && (actualMin > min || actualMin == min && actualPatch >= patch)
-}
-
+//sys connectx(fd int, endpoints *SaEndpoints, associd SaeAssocID, flags uint32, iov []Iovec, n *uintptr, connid *SaeConnID) (err error)
//sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error)
//sys shmat(id int, addr uintptr, flag int) (ret uintptr, err error)
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux.go b/vendor/golang.org/x/sys/unix/zerrors_linux.go
index 4f432bfe..b6db27d9 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux.go
@@ -319,6 +319,7 @@ const (
AUDIT_INTEGRITY_POLICY_RULE = 0x70f
AUDIT_INTEGRITY_RULE = 0x70d
AUDIT_INTEGRITY_STATUS = 0x70a
+ AUDIT_INTEGRITY_USERSPACE = 0x710
AUDIT_IPC = 0x517
AUDIT_IPC_SET_PERM = 0x51f
AUDIT_IPE_ACCESS = 0x58c
@@ -327,6 +328,8 @@ const (
AUDIT_KERNEL = 0x7d0
AUDIT_KERNEL_OTHER = 0x524
AUDIT_KERN_MODULE = 0x532
+ AUDIT_LANDLOCK_ACCESS = 0x58f
+ AUDIT_LANDLOCK_DOMAIN = 0x590
AUDIT_LAST_FEATURE = 0x1
AUDIT_LAST_KERN_ANOM_MSG = 0x707
AUDIT_LAST_USER_MSG = 0x4af
@@ -491,6 +494,7 @@ const (
BPF_F_BEFORE = 0x8
BPF_F_ID = 0x20
BPF_F_NETFILTER_IP_DEFRAG = 0x1
+ BPF_F_PREORDER = 0x40
BPF_F_QUERY_EFFECTIVE = 0x1
BPF_F_REDIRECT_FLAGS = 0x19
BPF_F_REPLACE = 0x4
@@ -527,6 +531,7 @@ const (
BPF_LDX = 0x1
BPF_LEN = 0x80
BPF_LL_OFF = -0x200000
+ BPF_LOAD_ACQ = 0x100
BPF_LSH = 0x60
BPF_MAJOR_VERSION = 0x1
BPF_MAXINSNS = 0x1000
@@ -554,6 +559,7 @@ const (
BPF_RET = 0x6
BPF_RSH = 0x70
BPF_ST = 0x2
+ BPF_STORE_REL = 0x110
BPF_STX = 0x3
BPF_SUB = 0x10
BPF_TAG_SIZE = 0x8
@@ -843,9 +849,9 @@ const (
DM_UUID_FLAG = 0x4000
DM_UUID_LEN = 0x81
DM_VERSION = 0xc138fd00
- DM_VERSION_EXTRA = "-ioctl (2023-03-01)"
+ DM_VERSION_EXTRA = "-ioctl (2025-04-28)"
DM_VERSION_MAJOR = 0x4
- DM_VERSION_MINOR = 0x30
+ DM_VERSION_MINOR = 0x32
DM_VERSION_PATCHLEVEL = 0x0
DT_BLK = 0x6
DT_CHR = 0x2
@@ -936,11 +942,10 @@ const (
EPOLL_CTL_MOD = 0x3
EPOLL_IOC_TYPE = 0x8a
EROFS_SUPER_MAGIC_V1 = 0xe0f5e1e2
- ESP_V4_FLOW = 0xa
- ESP_V6_FLOW = 0xc
- ETHER_FLOW = 0x12
ETHTOOL_BUSINFO_LEN = 0x20
ETHTOOL_EROMVERS_LEN = 0x20
+ ETHTOOL_FAMILY_NAME = "ethtool"
+ ETHTOOL_FAMILY_VERSION = 0x1
ETHTOOL_FEC_AUTO = 0x2
ETHTOOL_FEC_BASER = 0x10
ETHTOOL_FEC_LLRS = 0x20
@@ -1203,13 +1208,18 @@ const (
FAN_DENY = 0x2
FAN_ENABLE_AUDIT = 0x40
FAN_EPIDFD = -0x2
+ FAN_ERRNO_BITS = 0x8
+ FAN_ERRNO_MASK = 0xff
+ FAN_ERRNO_SHIFT = 0x18
FAN_EVENT_INFO_TYPE_DFID = 0x3
FAN_EVENT_INFO_TYPE_DFID_NAME = 0x2
FAN_EVENT_INFO_TYPE_ERROR = 0x5
FAN_EVENT_INFO_TYPE_FID = 0x1
+ FAN_EVENT_INFO_TYPE_MNT = 0x7
FAN_EVENT_INFO_TYPE_NEW_DFID_NAME = 0xc
FAN_EVENT_INFO_TYPE_OLD_DFID_NAME = 0xa
FAN_EVENT_INFO_TYPE_PIDFD = 0x4
+ FAN_EVENT_INFO_TYPE_RANGE = 0x6
FAN_EVENT_METADATA_LEN = 0x18
FAN_EVENT_ON_CHILD = 0x8000000
FAN_FS_ERROR = 0x8000
@@ -1224,9 +1234,12 @@ const (
FAN_MARK_IGNORED_SURV_MODIFY = 0x40
FAN_MARK_IGNORE_SURV = 0x440
FAN_MARK_INODE = 0x0
+ FAN_MARK_MNTNS = 0x110
FAN_MARK_MOUNT = 0x10
FAN_MARK_ONLYDIR = 0x8
FAN_MARK_REMOVE = 0x2
+ FAN_MNT_ATTACH = 0x1000000
+ FAN_MNT_DETACH = 0x2000000
FAN_MODIFY = 0x2
FAN_MOVE = 0xc0
FAN_MOVED_FROM = 0x40
@@ -1240,6 +1253,7 @@ const (
FAN_OPEN_EXEC = 0x1000
FAN_OPEN_EXEC_PERM = 0x40000
FAN_OPEN_PERM = 0x10000
+ FAN_PRE_ACCESS = 0x100000
FAN_Q_OVERFLOW = 0x4000
FAN_RENAME = 0x10000000
FAN_REPORT_DFID_NAME = 0xc00
@@ -1247,6 +1261,7 @@ const (
FAN_REPORT_DIR_FID = 0x400
FAN_REPORT_FD_ERROR = 0x2000
FAN_REPORT_FID = 0x200
+ FAN_REPORT_MNT = 0x4000
FAN_REPORT_NAME = 0x800
FAN_REPORT_PIDFD = 0x80
FAN_REPORT_TARGET_FID = 0x1000
@@ -1266,6 +1281,7 @@ const (
FIB_RULE_PERMANENT = 0x1
FIB_RULE_UNRESOLVED = 0x4
FIDEDUPERANGE = 0xc0189436
+ FSCRYPT_ADD_KEY_FLAG_HW_WRAPPED = 0x1
FSCRYPT_KEY_DESCRIPTOR_SIZE = 0x8
FSCRYPT_KEY_DESC_PREFIX = "fscrypt:"
FSCRYPT_KEY_DESC_PREFIX_SIZE = 0x8
@@ -1574,7 +1590,6 @@ const (
IPV6_DONTFRAG = 0x3e
IPV6_DROP_MEMBERSHIP = 0x15
IPV6_DSTOPTS = 0x3b
- IPV6_FLOW = 0x11
IPV6_FREEBIND = 0x4e
IPV6_HDRINCL = 0x24
IPV6_HOPLIMIT = 0x34
@@ -1625,7 +1640,6 @@ const (
IPV6_TRANSPARENT = 0x4b
IPV6_UNICAST_HOPS = 0x10
IPV6_UNICAST_IF = 0x4c
- IPV6_USER_FLOW = 0xe
IPV6_V6ONLY = 0x1a
IPV6_VERSION = 0x60
IPV6_VERSION_MASK = 0xf0
@@ -1687,7 +1701,6 @@ const (
IP_TTL = 0x2
IP_UNBLOCK_SOURCE = 0x25
IP_UNICAST_IF = 0x32
- IP_USER_FLOW = 0xd
IP_XFRM_POLICY = 0x11
ISOFS_SUPER_MAGIC = 0x9660
ISTRIP = 0x20
@@ -1809,7 +1822,11 @@ const (
LANDLOCK_ACCESS_FS_WRITE_FILE = 0x2
LANDLOCK_ACCESS_NET_BIND_TCP = 0x1
LANDLOCK_ACCESS_NET_CONNECT_TCP = 0x2
+ LANDLOCK_CREATE_RULESET_ERRATA = 0x2
LANDLOCK_CREATE_RULESET_VERSION = 0x1
+ LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON = 0x2
+ LANDLOCK_RESTRICT_SELF_LOG_SAME_EXEC_OFF = 0x1
+ LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF = 0x4
LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET = 0x1
LANDLOCK_SCOPE_SIGNAL = 0x2
LINUX_REBOOT_CMD_CAD_OFF = 0x0
@@ -2485,6 +2502,10 @@ const (
PR_FP_EXC_UND = 0x40000
PR_FP_MODE_FR = 0x1
PR_FP_MODE_FRE = 0x2
+ PR_FUTEX_HASH = 0x4e
+ PR_FUTEX_HASH_GET_IMMUTABLE = 0x3
+ PR_FUTEX_HASH_GET_SLOTS = 0x2
+ PR_FUTEX_HASH_SET_SLOTS = 0x1
PR_GET_AUXV = 0x41555856
PR_GET_CHILD_SUBREAPER = 0x25
PR_GET_DUMPABLE = 0x3
@@ -2644,6 +2665,10 @@ const (
PR_TAGGED_ADDR_ENABLE = 0x1
PR_TASK_PERF_EVENTS_DISABLE = 0x1f
PR_TASK_PERF_EVENTS_ENABLE = 0x20
+ PR_TIMER_CREATE_RESTORE_IDS = 0x4d
+ PR_TIMER_CREATE_RESTORE_IDS_GET = 0x2
+ PR_TIMER_CREATE_RESTORE_IDS_OFF = 0x0
+ PR_TIMER_CREATE_RESTORE_IDS_ON = 0x1
PR_TIMING_STATISTICAL = 0x0
PR_TIMING_TIMESTAMP = 0x1
PR_TSC_ENABLE = 0x1
@@ -2724,6 +2749,7 @@ const (
PTRACE_SETREGSET = 0x4205
PTRACE_SETSIGINFO = 0x4203
PTRACE_SETSIGMASK = 0x420b
+ PTRACE_SET_SYSCALL_INFO = 0x4212
PTRACE_SET_SYSCALL_USER_DISPATCH_CONFIG = 0x4210
PTRACE_SINGLESTEP = 0x9
PTRACE_SYSCALL = 0x18
@@ -2787,7 +2813,7 @@ const (
RTAX_UNSPEC = 0x0
RTAX_WINDOW = 0x3
RTA_ALIGNTO = 0x4
- RTA_MAX = 0x1e
+ RTA_MAX = 0x1f
RTCF_DIRECTSRC = 0x4000000
RTCF_DOREDIRECT = 0x1000000
RTCF_LOG = 0x2000000
@@ -2864,10 +2890,12 @@ const (
RTM_DELACTION = 0x31
RTM_DELADDR = 0x15
RTM_DELADDRLABEL = 0x49
+ RTM_DELANYCAST = 0x3d
RTM_DELCHAIN = 0x65
RTM_DELLINK = 0x11
RTM_DELLINKPROP = 0x6d
RTM_DELMDB = 0x55
+ RTM_DELMULTICAST = 0x39
RTM_DELNEIGH = 0x1d
RTM_DELNETCONF = 0x51
RTM_DELNEXTHOP = 0x69
@@ -2917,11 +2945,13 @@ const (
RTM_NEWACTION = 0x30
RTM_NEWADDR = 0x14
RTM_NEWADDRLABEL = 0x48
+ RTM_NEWANYCAST = 0x3c
RTM_NEWCACHEREPORT = 0x60
RTM_NEWCHAIN = 0x64
RTM_NEWLINK = 0x10
RTM_NEWLINKPROP = 0x6c
RTM_NEWMDB = 0x54
+ RTM_NEWMULTICAST = 0x38
RTM_NEWNDUSEROPT = 0x44
RTM_NEWNEIGH = 0x1c
RTM_NEWNEIGHTBL = 0x40
@@ -2970,6 +3000,7 @@ const (
RTPROT_NTK = 0xf
RTPROT_OPENR = 0x63
RTPROT_OSPF = 0xbc
+ RTPROT_OVN = 0x54
RTPROT_RA = 0x9
RTPROT_REDIRECT = 0x1
RTPROT_RIP = 0xbd
@@ -2987,11 +3018,12 @@ const (
RUSAGE_THREAD = 0x1
RWF_APPEND = 0x10
RWF_ATOMIC = 0x40
+ RWF_DONTCACHE = 0x80
RWF_DSYNC = 0x2
RWF_HIPRI = 0x1
RWF_NOAPPEND = 0x20
RWF_NOWAIT = 0x8
- RWF_SUPPORTED = 0x7f
+ RWF_SUPPORTED = 0xff
RWF_SYNC = 0x4
RWF_WRITE_LIFE_NOT_SET = 0x0
SCHED_BATCH = 0x3
@@ -3271,6 +3303,7 @@ const (
STATX_BTIME = 0x800
STATX_CTIME = 0x80
STATX_DIOALIGN = 0x2000
+ STATX_DIO_READ_ALIGN = 0x20000
STATX_GID = 0x10
STATX_INO = 0x100
STATX_MNT_ID = 0x1000
@@ -3322,7 +3355,7 @@ const (
TASKSTATS_GENL_NAME = "TASKSTATS"
TASKSTATS_GENL_VERSION = 0x1
TASKSTATS_TYPE_MAX = 0x6
- TASKSTATS_VERSION = 0xe
+ TASKSTATS_VERSION = 0x10
TCIFLUSH = 0x0
TCIOFF = 0x2
TCIOFLUSH = 0x2
@@ -3392,8 +3425,6 @@ const (
TCP_TX_DELAY = 0x25
TCP_ULP = 0x1f
TCP_USER_TIMEOUT = 0x12
- TCP_V4_FLOW = 0x1
- TCP_V6_FLOW = 0x5
TCP_WINDOW_CLAMP = 0xa
TCP_ZEROCOPY_RECEIVE = 0x23
TFD_TIMER_ABSTIME = 0x1
@@ -3503,6 +3534,7 @@ const (
TP_STATUS_WRONG_FORMAT = 0x4
TRACEFS_MAGIC = 0x74726163
TS_COMM_LEN = 0x20
+ UBI_IOCECNFO = 0xc01c6f06
UDF_SUPER_MAGIC = 0x15013346
UDP_CORK = 0x1
UDP_ENCAP = 0x64
@@ -3515,8 +3547,6 @@ const (
UDP_NO_CHECK6_RX = 0x66
UDP_NO_CHECK6_TX = 0x65
UDP_SEGMENT = 0x67
- UDP_V4_FLOW = 0x2
- UDP_V6_FLOW = 0x6
UMOUNT_NOFOLLOW = 0x8
USBDEVICE_SUPER_MAGIC = 0x9fa2
UTIME_NOW = 0x3fffffff
@@ -3559,7 +3589,7 @@ const (
WDIOS_TEMPPANIC = 0x4
WDIOS_UNKNOWN = -0x1
WEXITED = 0x4
- WGALLOWEDIP_A_MAX = 0x3
+ WGALLOWEDIP_A_MAX = 0x4
WGDEVICE_A_MAX = 0x8
WGPEER_A_MAX = 0xa
WG_CMD_MAX = 0x1
@@ -3673,6 +3703,7 @@ const (
XDP_SHARED_UMEM = 0x1
XDP_STATISTICS = 0x7
XDP_TXMD_FLAGS_CHECKSUM = 0x2
+ XDP_TXMD_FLAGS_LAUNCH_TIME = 0x4
XDP_TXMD_FLAGS_TIMESTAMP = 0x1
XDP_TX_METADATA = 0x2
XDP_TX_RING = 0x3
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
index 75207613..1c37f9fb 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_386.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x30
CSIZE = 0x30
CSTOPB = 0x40
+ DM_MPATH_PROBE_PATHS = 0xfd12
ECCGETLAYOUT = 0x81484d11
ECCGETSTATS = 0x80104d12
ECHOCTL = 0x200
@@ -360,6 +361,7 @@ const (
SO_OOBINLINE = 0xa
SO_PASSCRED = 0x10
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x11
@@ -372,6 +374,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x12
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x14
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x14
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
index c68acda5..6f54d34a 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_amd64.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x30
CSIZE = 0x30
CSTOPB = 0x40
+ DM_MPATH_PROBE_PATHS = 0xfd12
ECCGETLAYOUT = 0x81484d11
ECCGETSTATS = 0x80104d12
ECHOCTL = 0x200
@@ -361,6 +362,7 @@ const (
SO_OOBINLINE = 0xa
SO_PASSCRED = 0x10
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x11
@@ -373,6 +375,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x12
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x14
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x14
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
index a8c607ab..783ec5c1 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x30
CSIZE = 0x30
CSTOPB = 0x40
+ DM_MPATH_PROBE_PATHS = 0xfd12
ECCGETLAYOUT = 0x81484d11
ECCGETSTATS = 0x80104d12
ECHOCTL = 0x200
@@ -366,6 +367,7 @@ const (
SO_OOBINLINE = 0xa
SO_PASSCRED = 0x10
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x11
@@ -378,6 +380,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x12
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x14
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x14
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
index 18563dd8..ca83d3ba 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_arm64.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x30
CSIZE = 0x30
CSTOPB = 0x40
+ DM_MPATH_PROBE_PATHS = 0xfd12
ECCGETLAYOUT = 0x81484d11
ECCGETSTATS = 0x80104d12
ECHOCTL = 0x200
@@ -359,6 +360,7 @@ const (
SO_OOBINLINE = 0xa
SO_PASSCRED = 0x10
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x11
@@ -371,6 +373,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x12
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x14
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x14
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
index 22912cda..607e611c 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_loong64.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x30
CSIZE = 0x30
CSTOPB = 0x40
+ DM_MPATH_PROBE_PATHS = 0xfd12
ECCGETLAYOUT = 0x81484d11
ECCGETSTATS = 0x80104d12
ECHOCTL = 0x200
@@ -353,6 +354,7 @@ const (
SO_OOBINLINE = 0xa
SO_PASSCRED = 0x10
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x11
@@ -365,6 +367,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x12
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x14
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x14
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
index 29344eb3..b9cb5bd3 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x30
CSIZE = 0x30
CSTOPB = 0x40
+ DM_MPATH_PROBE_PATHS = 0x2000fd12
ECCGETLAYOUT = 0x41484d11
ECCGETSTATS = 0x40104d12
ECHOCTL = 0x200
@@ -359,6 +360,7 @@ const (
SO_OOBINLINE = 0x100
SO_PASSCRED = 0x11
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x12
@@ -371,6 +373,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x1004
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x1006
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x1006
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
index 20d51fb9..65b078a6 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x30
CSIZE = 0x30
CSTOPB = 0x40
+ DM_MPATH_PROBE_PATHS = 0x2000fd12
ECCGETLAYOUT = 0x41484d11
ECCGETSTATS = 0x40104d12
ECHOCTL = 0x200
@@ -359,6 +360,7 @@ const (
SO_OOBINLINE = 0x100
SO_PASSCRED = 0x11
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x12
@@ -371,6 +373,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x1004
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x1006
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x1006
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
index 321b6090..5298a303 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mips64le.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x30
CSIZE = 0x30
CSTOPB = 0x40
+ DM_MPATH_PROBE_PATHS = 0x2000fd12
ECCGETLAYOUT = 0x41484d11
ECCGETSTATS = 0x40104d12
ECHOCTL = 0x200
@@ -359,6 +360,7 @@ const (
SO_OOBINLINE = 0x100
SO_PASSCRED = 0x11
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x12
@@ -371,6 +373,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x1004
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x1006
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x1006
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
index 9bacdf1e..7bc557c8 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_mipsle.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x30
CSIZE = 0x30
CSTOPB = 0x40
+ DM_MPATH_PROBE_PATHS = 0x2000fd12
ECCGETLAYOUT = 0x41484d11
ECCGETSTATS = 0x40104d12
ECHOCTL = 0x200
@@ -359,6 +360,7 @@ const (
SO_OOBINLINE = 0x100
SO_PASSCRED = 0x11
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x12
@@ -371,6 +373,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x1004
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x1006
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x1006
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
index c2242726..152399bb 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x300
CSIZE = 0x300
CSTOPB = 0x400
+ DM_MPATH_PROBE_PATHS = 0x2000fd12
ECCGETLAYOUT = 0x41484d11
ECCGETSTATS = 0x40104d12
ECHOCTL = 0x40
@@ -414,6 +415,7 @@ const (
SO_OOBINLINE = 0xa
SO_PASSCRED = 0x14
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x15
@@ -426,6 +428,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x10
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x12
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x12
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
index 6270c8ee..1a1ce240 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x300
CSIZE = 0x300
CSTOPB = 0x400
+ DM_MPATH_PROBE_PATHS = 0x2000fd12
ECCGETLAYOUT = 0x41484d11
ECCGETSTATS = 0x40104d12
ECHOCTL = 0x40
@@ -418,6 +419,7 @@ const (
SO_OOBINLINE = 0xa
SO_PASSCRED = 0x14
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x15
@@ -430,6 +432,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x10
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x12
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x12
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
index 9966c194..4231a1fb 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_ppc64le.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x300
CSIZE = 0x300
CSTOPB = 0x400
+ DM_MPATH_PROBE_PATHS = 0x2000fd12
ECCGETLAYOUT = 0x41484d11
ECCGETSTATS = 0x40104d12
ECHOCTL = 0x40
@@ -418,6 +419,7 @@ const (
SO_OOBINLINE = 0xa
SO_PASSCRED = 0x14
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x15
@@ -430,6 +432,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x10
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x12
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x12
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
index 848e5fcc..21c0e952 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_riscv64.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x30
CSIZE = 0x30
CSTOPB = 0x40
+ DM_MPATH_PROBE_PATHS = 0xfd12
ECCGETLAYOUT = 0x81484d11
ECCGETSTATS = 0x80104d12
ECHOCTL = 0x200
@@ -350,6 +351,7 @@ const (
SO_OOBINLINE = 0xa
SO_PASSCRED = 0x10
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x11
@@ -362,6 +364,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x12
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x14
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x14
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
index 669b2adb..f00d1cd7 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_s390x.go
@@ -68,6 +68,7 @@ const (
CS8 = 0x30
CSIZE = 0x30
CSTOPB = 0x40
+ DM_MPATH_PROBE_PATHS = 0xfd12
ECCGETLAYOUT = 0x81484d11
ECCGETSTATS = 0x80104d12
ECHOCTL = 0x200
@@ -422,6 +423,7 @@ const (
SO_OOBINLINE = 0xa
SO_PASSCRED = 0x10
SO_PASSPIDFD = 0x4c
+ SO_PASSRIGHTS = 0x53
SO_PASSSEC = 0x22
SO_PEEK_OFF = 0x2a
SO_PEERCRED = 0x11
@@ -434,6 +436,7 @@ const (
SO_RCVBUFFORCE = 0x21
SO_RCVLOWAT = 0x12
SO_RCVMARK = 0x4b
+ SO_RCVPRIORITY = 0x52
SO_RCVTIMEO = 0x14
SO_RCVTIMEO_NEW = 0x42
SO_RCVTIMEO_OLD = 0x14
diff --git a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
index 4834e575..bc8d539e 100644
--- a/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zerrors_linux_sparc64.go
@@ -71,6 +71,7 @@ const (
CS8 = 0x30
CSIZE = 0x30
CSTOPB = 0x40
+ DM_MPATH_PROBE_PATHS = 0x2000fd12
ECCGETLAYOUT = 0x41484d11
ECCGETSTATS = 0x40104d12
ECHOCTL = 0x200
@@ -461,6 +462,7 @@ const (
SO_OOBINLINE = 0x100
SO_PASSCRED = 0x2
SO_PASSPIDFD = 0x55
+ SO_PASSRIGHTS = 0x5c
SO_PASSSEC = 0x1f
SO_PEEK_OFF = 0x26
SO_PEERCRED = 0x40
@@ -473,6 +475,7 @@ const (
SO_RCVBUFFORCE = 0x100b
SO_RCVLOWAT = 0x800
SO_RCVMARK = 0x54
+ SO_RCVPRIORITY = 0x5b
SO_RCVTIMEO = 0x2000
SO_RCVTIMEO_NEW = 0x44
SO_RCVTIMEO_OLD = 0x2000
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
index c79aaff3..aca56ee4 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_386.go
@@ -462,4 +462,5 @@ const (
SYS_GETXATTRAT = 464
SYS_LISTXATTRAT = 465
SYS_REMOVEXATTRAT = 466
+ SYS_OPEN_TREE_ATTR = 467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
index 5eb45069..2ea1ef58 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_amd64.go
@@ -385,4 +385,5 @@ const (
SYS_GETXATTRAT = 464
SYS_LISTXATTRAT = 465
SYS_REMOVEXATTRAT = 466
+ SYS_OPEN_TREE_ATTR = 467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
index 05e50297..d22c8af3 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm.go
@@ -426,4 +426,5 @@ const (
SYS_GETXATTRAT = 464
SYS_LISTXATTRAT = 465
SYS_REMOVEXATTRAT = 466
+ SYS_OPEN_TREE_ATTR = 467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
index 38c53ec5..5ee264ae 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_arm64.go
@@ -329,4 +329,5 @@ const (
SYS_GETXATTRAT = 464
SYS_LISTXATTRAT = 465
SYS_REMOVEXATTRAT = 466
+ SYS_OPEN_TREE_ATTR = 467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
index 31d2e71a..f9f03ebf 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_loong64.go
@@ -325,4 +325,5 @@ const (
SYS_GETXATTRAT = 464
SYS_LISTXATTRAT = 465
SYS_REMOVEXATTRAT = 466
+ SYS_OPEN_TREE_ATTR = 467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
index f4184a33..87c2118e 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips.go
@@ -446,4 +446,5 @@ const (
SYS_GETXATTRAT = 4464
SYS_LISTXATTRAT = 4465
SYS_REMOVEXATTRAT = 4466
+ SYS_OPEN_TREE_ATTR = 4467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
index 05b99622..391ad102 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64.go
@@ -376,4 +376,5 @@ const (
SYS_GETXATTRAT = 5464
SYS_LISTXATTRAT = 5465
SYS_REMOVEXATTRAT = 5466
+ SYS_OPEN_TREE_ATTR = 5467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
index 43a256e9..56561577 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mips64le.go
@@ -376,4 +376,5 @@ const (
SYS_GETXATTRAT = 5464
SYS_LISTXATTRAT = 5465
SYS_REMOVEXATTRAT = 5466
+ SYS_OPEN_TREE_ATTR = 5467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
index eea5ddfc..0482b52e 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_mipsle.go
@@ -446,4 +446,5 @@ const (
SYS_GETXATTRAT = 4464
SYS_LISTXATTRAT = 4465
SYS_REMOVEXATTRAT = 4466
+ SYS_OPEN_TREE_ATTR = 4467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
index 0d777bfb..71806f08 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go
@@ -453,4 +453,5 @@ const (
SYS_GETXATTRAT = 464
SYS_LISTXATTRAT = 465
SYS_REMOVEXATTRAT = 466
+ SYS_OPEN_TREE_ATTR = 467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
index b4463650..e35a7105 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64.go
@@ -425,4 +425,5 @@ const (
SYS_GETXATTRAT = 464
SYS_LISTXATTRAT = 465
SYS_REMOVEXATTRAT = 466
+ SYS_OPEN_TREE_ATTR = 467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
index 0c7d21c1..2aea4767 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc64le.go
@@ -425,4 +425,5 @@ const (
SYS_GETXATTRAT = 464
SYS_LISTXATTRAT = 465
SYS_REMOVEXATTRAT = 466
+ SYS_OPEN_TREE_ATTR = 467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
index 84053916..6c9bb4e5 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_riscv64.go
@@ -330,4 +330,5 @@ const (
SYS_GETXATTRAT = 464
SYS_LISTXATTRAT = 465
SYS_REMOVEXATTRAT = 466
+ SYS_OPEN_TREE_ATTR = 467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
index fcf1b790..680bc991 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_s390x.go
@@ -391,4 +391,5 @@ const (
SYS_GETXATTRAT = 464
SYS_LISTXATTRAT = 465
SYS_REMOVEXATTRAT = 466
+ SYS_OPEN_TREE_ATTR = 467
)
diff --git a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
index 52d15b5f..620f2710 100644
--- a/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/zsysnum_linux_sparc64.go
@@ -404,4 +404,5 @@ const (
SYS_GETXATTRAT = 464
SYS_LISTXATTRAT = 465
SYS_REMOVEXATTRAT = 466
+ SYS_OPEN_TREE_ATTR = 467
)
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux.go b/vendor/golang.org/x/sys/unix/ztypes_linux.go
index a46abe64..cd236443 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux.go
@@ -114,8 +114,10 @@ type Statx_t struct {
Atomic_write_unit_min uint32
Atomic_write_unit_max uint32
Atomic_write_segments_max uint32
+ Dio_read_offset_align uint32
+ Atomic_write_unit_max_opt uint32
_ [1]uint32
- _ [9]uint64
+ _ [8]uint64
}
type Fsid struct {
@@ -199,7 +201,8 @@ type FscryptAddKeyArg struct {
Key_spec FscryptKeySpecifier
Raw_size uint32
Key_id uint32
- _ [8]uint32
+ Flags uint32
+ _ [7]uint32
}
type FscryptRemoveKeyArg struct {
@@ -2226,8 +2229,11 @@ const (
NFT_PAYLOAD_LL_HEADER = 0x0
NFT_PAYLOAD_NETWORK_HEADER = 0x1
NFT_PAYLOAD_TRANSPORT_HEADER = 0x2
+ NFT_PAYLOAD_INNER_HEADER = 0x3
+ NFT_PAYLOAD_TUN_HEADER = 0x4
NFT_PAYLOAD_CSUM_NONE = 0x0
NFT_PAYLOAD_CSUM_INET = 0x1
+ NFT_PAYLOAD_CSUM_SCTP = 0x2
NFT_PAYLOAD_L4CSUM_PSEUDOHDR = 0x1
NFTA_PAYLOAD_UNSPEC = 0x0
NFTA_PAYLOAD_DREG = 0x1
@@ -2314,6 +2320,11 @@ const (
NFT_CT_AVGPKT = 0x10
NFT_CT_ZONE = 0x11
NFT_CT_EVENTMASK = 0x12
+ NFT_CT_SRC_IP = 0x13
+ NFT_CT_DST_IP = 0x14
+ NFT_CT_SRC_IP6 = 0x15
+ NFT_CT_DST_IP6 = 0x16
+ NFT_CT_ID = 0x17
NFTA_CT_UNSPEC = 0x0
NFTA_CT_DREG = 0x1
NFTA_CT_KEY = 0x2
@@ -2594,8 +2605,8 @@ const (
SOF_TIMESTAMPING_BIND_PHC = 0x8000
SOF_TIMESTAMPING_OPT_ID_TCP = 0x10000
- SOF_TIMESTAMPING_LAST = 0x20000
- SOF_TIMESTAMPING_MASK = 0x3ffff
+ SOF_TIMESTAMPING_LAST = 0x40000
+ SOF_TIMESTAMPING_MASK = 0x7ffff
SCM_TSTAMP_SND = 0x0
SCM_TSTAMP_SCHED = 0x1
@@ -3802,7 +3813,16 @@ const (
ETHTOOL_MSG_PSE_GET = 0x24
ETHTOOL_MSG_PSE_SET = 0x25
ETHTOOL_MSG_RSS_GET = 0x26
- ETHTOOL_MSG_USER_MAX = 0x2d
+ ETHTOOL_MSG_PLCA_GET_CFG = 0x27
+ ETHTOOL_MSG_PLCA_SET_CFG = 0x28
+ ETHTOOL_MSG_PLCA_GET_STATUS = 0x29
+ ETHTOOL_MSG_MM_GET = 0x2a
+ ETHTOOL_MSG_MM_SET = 0x2b
+ ETHTOOL_MSG_MODULE_FW_FLASH_ACT = 0x2c
+ ETHTOOL_MSG_PHY_GET = 0x2d
+ ETHTOOL_MSG_TSCONFIG_GET = 0x2e
+ ETHTOOL_MSG_TSCONFIG_SET = 0x2f
+ ETHTOOL_MSG_USER_MAX = 0x2f
ETHTOOL_MSG_KERNEL_NONE = 0x0
ETHTOOL_MSG_STRSET_GET_REPLY = 0x1
ETHTOOL_MSG_LINKINFO_GET_REPLY = 0x2
@@ -3842,7 +3862,17 @@ const (
ETHTOOL_MSG_MODULE_NTF = 0x24
ETHTOOL_MSG_PSE_GET_REPLY = 0x25
ETHTOOL_MSG_RSS_GET_REPLY = 0x26
- ETHTOOL_MSG_KERNEL_MAX = 0x2e
+ ETHTOOL_MSG_PLCA_GET_CFG_REPLY = 0x27
+ ETHTOOL_MSG_PLCA_GET_STATUS_REPLY = 0x28
+ ETHTOOL_MSG_PLCA_NTF = 0x29
+ ETHTOOL_MSG_MM_GET_REPLY = 0x2a
+ ETHTOOL_MSG_MM_NTF = 0x2b
+ ETHTOOL_MSG_MODULE_FW_FLASH_NTF = 0x2c
+ ETHTOOL_MSG_PHY_GET_REPLY = 0x2d
+ ETHTOOL_MSG_PHY_NTF = 0x2e
+ ETHTOOL_MSG_TSCONFIG_GET_REPLY = 0x2f
+ ETHTOOL_MSG_TSCONFIG_SET_REPLY = 0x30
+ ETHTOOL_MSG_KERNEL_MAX = 0x30
ETHTOOL_FLAG_COMPACT_BITSETS = 0x1
ETHTOOL_FLAG_OMIT_REPLY = 0x2
ETHTOOL_FLAG_STATS = 0x4
@@ -3949,7 +3979,12 @@ const (
ETHTOOL_A_RINGS_TCP_DATA_SPLIT = 0xb
ETHTOOL_A_RINGS_CQE_SIZE = 0xc
ETHTOOL_A_RINGS_TX_PUSH = 0xd
- ETHTOOL_A_RINGS_MAX = 0x10
+ ETHTOOL_A_RINGS_RX_PUSH = 0xe
+ ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN = 0xf
+ ETHTOOL_A_RINGS_TX_PUSH_BUF_LEN_MAX = 0x10
+ ETHTOOL_A_RINGS_HDS_THRESH = 0x11
+ ETHTOOL_A_RINGS_HDS_THRESH_MAX = 0x12
+ ETHTOOL_A_RINGS_MAX = 0x12
ETHTOOL_A_CHANNELS_UNSPEC = 0x0
ETHTOOL_A_CHANNELS_HEADER = 0x1
ETHTOOL_A_CHANNELS_RX_MAX = 0x2
@@ -4015,7 +4050,9 @@ const (
ETHTOOL_A_TSINFO_TX_TYPES = 0x3
ETHTOOL_A_TSINFO_RX_FILTERS = 0x4
ETHTOOL_A_TSINFO_PHC_INDEX = 0x5
- ETHTOOL_A_TSINFO_MAX = 0x6
+ ETHTOOL_A_TSINFO_STATS = 0x6
+ ETHTOOL_A_TSINFO_HWTSTAMP_PROVIDER = 0x7
+ ETHTOOL_A_TSINFO_MAX = 0x9
ETHTOOL_A_CABLE_TEST_UNSPEC = 0x0
ETHTOOL_A_CABLE_TEST_HEADER = 0x1
ETHTOOL_A_CABLE_TEST_MAX = 0x1
@@ -4101,6 +4138,19 @@ const (
ETHTOOL_A_TUNNEL_INFO_MAX = 0x2
)
+const (
+ TCP_V4_FLOW = 0x1
+ UDP_V4_FLOW = 0x2
+ TCP_V6_FLOW = 0x5
+ UDP_V6_FLOW = 0x6
+ ESP_V4_FLOW = 0xa
+ ESP_V6_FLOW = 0xc
+ IP_USER_FLOW = 0xd
+ IPV6_USER_FLOW = 0xe
+ IPV6_FLOW = 0x11
+ ETHER_FLOW = 0x12
+)
+
const SPEED_UNKNOWN = -0x1
type EthtoolDrvinfo struct {
@@ -4613,6 +4663,7 @@ const (
NL80211_ATTR_AKM_SUITES = 0x4c
NL80211_ATTR_AP_ISOLATE = 0x60
NL80211_ATTR_AP_SETTINGS_FLAGS = 0x135
+ NL80211_ATTR_ASSOC_SPP_AMSDU = 0x14a
NL80211_ATTR_AUTH_DATA = 0x9c
NL80211_ATTR_AUTH_TYPE = 0x35
NL80211_ATTR_BANDS = 0xef
@@ -4623,6 +4674,7 @@ const (
NL80211_ATTR_BSS_BASIC_RATES = 0x24
NL80211_ATTR_BSS = 0x2f
NL80211_ATTR_BSS_CTS_PROT = 0x1c
+ NL80211_ATTR_BSS_DUMP_INCLUDE_USE_DATA = 0x147
NL80211_ATTR_BSS_HT_OPMODE = 0x6d
NL80211_ATTR_BSSID = 0xf5
NL80211_ATTR_BSS_SELECT = 0xe3
@@ -4682,6 +4734,7 @@ const (
NL80211_ATTR_DTIM_PERIOD = 0xd
NL80211_ATTR_DURATION = 0x57
NL80211_ATTR_EHT_CAPABILITY = 0x136
+ NL80211_ATTR_EMA_RNR_ELEMS = 0x145
NL80211_ATTR_EML_CAPABILITY = 0x13d
NL80211_ATTR_EXT_CAPA = 0xa9
NL80211_ATTR_EXT_CAPA_MASK = 0xaa
@@ -4717,6 +4770,7 @@ const (
NL80211_ATTR_HIDDEN_SSID = 0x7e
NL80211_ATTR_HT_CAPABILITY = 0x1f
NL80211_ATTR_HT_CAPABILITY_MASK = 0x94
+ NL80211_ATTR_HW_TIMESTAMP_ENABLED = 0x144
NL80211_ATTR_IE_ASSOC_RESP = 0x80
NL80211_ATTR_IE = 0x2a
NL80211_ATTR_IE_PROBE_RESP = 0x7f
@@ -4747,9 +4801,10 @@ const (
NL80211_ATTR_MAC_HINT = 0xc8
NL80211_ATTR_MAC_MASK = 0xd7
NL80211_ATTR_MAX_AP_ASSOC_STA = 0xca
- NL80211_ATTR_MAX = 0x14d
+ NL80211_ATTR_MAX = 0x151
NL80211_ATTR_MAX_CRIT_PROT_DURATION = 0xb4
NL80211_ATTR_MAX_CSA_COUNTERS = 0xce
+ NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS = 0x143
NL80211_ATTR_MAX_MATCH_SETS = 0x85
NL80211_ATTR_MAX_NUM_AKM_SUITES = 0x13c
NL80211_ATTR_MAX_NUM_PMKIDS = 0x56
@@ -4774,9 +4829,12 @@ const (
NL80211_ATTR_MGMT_SUBTYPE = 0x29
NL80211_ATTR_MLD_ADDR = 0x13a
NL80211_ATTR_MLD_CAPA_AND_OPS = 0x13e
+ NL80211_ATTR_MLO_LINK_DISABLED = 0x146
NL80211_ATTR_MLO_LINK_ID = 0x139
NL80211_ATTR_MLO_LINKS = 0x138
NL80211_ATTR_MLO_SUPPORT = 0x13b
+ NL80211_ATTR_MLO_TTLM_DLINK = 0x148
+ NL80211_ATTR_MLO_TTLM_ULINK = 0x149
NL80211_ATTR_MNTR_FLAGS = 0x17
NL80211_ATTR_MPATH_INFO = 0x1b
NL80211_ATTR_MPATH_NEXT_HOP = 0x1a
@@ -4809,12 +4867,14 @@ const (
NL80211_ATTR_PORT_AUTHORIZED = 0x103
NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN = 0x5
NL80211_ATTR_POWER_RULE_MAX_EIRP = 0x6
+ NL80211_ATTR_POWER_RULE_PSD = 0x8
NL80211_ATTR_PREV_BSSID = 0x4f
NL80211_ATTR_PRIVACY = 0x46
NL80211_ATTR_PROBE_RESP = 0x91
NL80211_ATTR_PROBE_RESP_OFFLOAD = 0x90
NL80211_ATTR_PROTOCOL_FEATURES = 0xad
NL80211_ATTR_PS_STATE = 0x5d
+ NL80211_ATTR_PUNCT_BITMAP = 0x142
NL80211_ATTR_QOS_MAP = 0xc7
NL80211_ATTR_RADAR_BACKGROUND = 0x134
NL80211_ATTR_RADAR_EVENT = 0xa8
@@ -4943,7 +5003,9 @@ const (
NL80211_ATTR_WIPHY_FREQ = 0x26
NL80211_ATTR_WIPHY_FREQ_HINT = 0xc9
NL80211_ATTR_WIPHY_FREQ_OFFSET = 0x122
+ NL80211_ATTR_WIPHY_INTERFACE_COMBINATIONS = 0x14c
NL80211_ATTR_WIPHY_NAME = 0x2
+ NL80211_ATTR_WIPHY_RADIOS = 0x14b
NL80211_ATTR_WIPHY_RETRY_LONG = 0x3e
NL80211_ATTR_WIPHY_RETRY_SHORT = 0x3d
NL80211_ATTR_WIPHY_RTS_THRESHOLD = 0x40
@@ -4978,6 +5040,8 @@ const (
NL80211_BAND_ATTR_IFTYPE_DATA = 0x9
NL80211_BAND_ATTR_MAX = 0xd
NL80211_BAND_ATTR_RATES = 0x2
+ NL80211_BAND_ATTR_S1G_CAPA = 0xd
+ NL80211_BAND_ATTR_S1G_MCS_NSS_SET = 0xc
NL80211_BAND_ATTR_VHT_CAPA = 0x8
NL80211_BAND_ATTR_VHT_MCS_SET = 0x7
NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MAC = 0x8
@@ -5001,6 +5065,10 @@ const (
NL80211_BSS_BEACON_INTERVAL = 0x4
NL80211_BSS_BEACON_TSF = 0xd
NL80211_BSS_BSSID = 0x1
+ NL80211_BSS_CANNOT_USE_6GHZ_PWR_MISMATCH = 0x2
+ NL80211_BSS_CANNOT_USE_NSTR_NONPRIMARY = 0x1
+ NL80211_BSS_CANNOT_USE_REASONS = 0x18
+ NL80211_BSS_CANNOT_USE_UHB_PWR_MISMATCH = 0x2
NL80211_BSS_CAPABILITY = 0x5
NL80211_BSS_CHAIN_SIGNAL = 0x13
NL80211_BSS_CHAN_WIDTH_10 = 0x1
@@ -5032,6 +5100,9 @@ const (
NL80211_BSS_STATUS = 0x9
NL80211_BSS_STATUS_IBSS_JOINED = 0x2
NL80211_BSS_TSF = 0x3
+ NL80211_BSS_USE_FOR = 0x17
+ NL80211_BSS_USE_FOR_MLD_LINK = 0x2
+ NL80211_BSS_USE_FOR_NORMAL = 0x1
NL80211_CHAN_HT20 = 0x1
NL80211_CHAN_HT40MINUS = 0x2
NL80211_CHAN_HT40PLUS = 0x3
@@ -5117,7 +5188,8 @@ const (
NL80211_CMD_LEAVE_IBSS = 0x2c
NL80211_CMD_LEAVE_MESH = 0x45
NL80211_CMD_LEAVE_OCB = 0x6d
- NL80211_CMD_MAX = 0x9b
+ NL80211_CMD_LINKS_REMOVED = 0x9a
+ NL80211_CMD_MAX = 0x9d
NL80211_CMD_MICHAEL_MIC_FAILURE = 0x29
NL80211_CMD_MODIFY_LINK_STA = 0x97
NL80211_CMD_NAN_MATCH = 0x78
@@ -5161,6 +5233,7 @@ const (
NL80211_CMD_SET_COALESCE = 0x65
NL80211_CMD_SET_CQM = 0x3f
NL80211_CMD_SET_FILS_AAD = 0x92
+ NL80211_CMD_SET_HW_TIMESTAMP = 0x99
NL80211_CMD_SET_INTERFACE = 0x6
NL80211_CMD_SET_KEY = 0xa
NL80211_CMD_SET_MAC_ACL = 0x5d
@@ -5180,6 +5253,7 @@ const (
NL80211_CMD_SET_SAR_SPECS = 0x8c
NL80211_CMD_SET_STATION = 0x12
NL80211_CMD_SET_TID_CONFIG = 0x89
+ NL80211_CMD_SET_TID_TO_LINK_MAPPING = 0x9b
NL80211_CMD_SET_TX_BITRATE_MASK = 0x39
NL80211_CMD_SET_WDS_PEER = 0x42
NL80211_CMD_SET_WIPHY = 0x2
@@ -5247,6 +5321,7 @@ const (
NL80211_EXT_FEATURE_AIRTIME_FAIRNESS = 0x21
NL80211_EXT_FEATURE_AP_PMKSA_CACHING = 0x22
NL80211_EXT_FEATURE_AQL = 0x28
+ NL80211_EXT_FEATURE_AUTH_AND_DEAUTH_RANDOM_TA = 0x40
NL80211_EXT_FEATURE_BEACON_PROTECTION_CLIENT = 0x2e
NL80211_EXT_FEATURE_BEACON_PROTECTION = 0x29
NL80211_EXT_FEATURE_BEACON_RATE_HE = 0x36
@@ -5262,6 +5337,7 @@ const (
NL80211_EXT_FEATURE_CQM_RSSI_LIST = 0xd
NL80211_EXT_FEATURE_DATA_ACK_SIGNAL_SUPPORT = 0x1b
NL80211_EXT_FEATURE_DEL_IBSS_STA = 0x2c
+ NL80211_EXT_FEATURE_DFS_CONCURRENT = 0x43
NL80211_EXT_FEATURE_DFS_OFFLOAD = 0x19
NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER = 0x20
NL80211_EXT_FEATURE_EXT_KEY_ID = 0x24
@@ -5281,9 +5357,12 @@ const (
NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION = 0x14
NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE = 0x13
NL80211_EXT_FEATURE_OPERATING_CHANNEL_VALIDATION = 0x31
+ NL80211_EXT_FEATURE_OWE_OFFLOAD_AP = 0x42
+ NL80211_EXT_FEATURE_OWE_OFFLOAD = 0x41
NL80211_EXT_FEATURE_POWERED_ADDR_CHANGE = 0x3d
NL80211_EXT_FEATURE_PROTECTED_TWT = 0x2b
NL80211_EXT_FEATURE_PROT_RANGE_NEGO_AND_MEASURE = 0x39
+ NL80211_EXT_FEATURE_PUNCT = 0x3e
NL80211_EXT_FEATURE_RADAR_BACKGROUND = 0x3c
NL80211_EXT_FEATURE_RRM = 0x1
NL80211_EXT_FEATURE_SAE_OFFLOAD_AP = 0x33
@@ -5295,8 +5374,10 @@ const (
NL80211_EXT_FEATURE_SCHED_SCAN_BAND_SPECIFIC_RSSI_THOLD = 0x23
NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI = 0xc
NL80211_EXT_FEATURE_SECURE_LTF = 0x37
+ NL80211_EXT_FEATURE_SECURE_NAN = 0x3f
NL80211_EXT_FEATURE_SECURE_RTT = 0x38
NL80211_EXT_FEATURE_SET_SCAN_DWELL = 0x5
+ NL80211_EXT_FEATURE_SPP_AMSDU_SUPPORT = 0x44
NL80211_EXT_FEATURE_STA_TX_PWR = 0x25
NL80211_EXT_FEATURE_TXQS = 0x1c
NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP = 0x35
@@ -5343,7 +5424,10 @@ const (
NL80211_FREQUENCY_ATTR_2MHZ = 0x16
NL80211_FREQUENCY_ATTR_4MHZ = 0x17
NL80211_FREQUENCY_ATTR_8MHZ = 0x18
+ NL80211_FREQUENCY_ATTR_ALLOW_6GHZ_VLP_AP = 0x21
+ NL80211_FREQUENCY_ATTR_CAN_MONITOR = 0x20
NL80211_FREQUENCY_ATTR_DFS_CAC_TIME = 0xd
+ NL80211_FREQUENCY_ATTR_DFS_CONCURRENT = 0x1d
NL80211_FREQUENCY_ATTR_DFS_STATE = 0x7
NL80211_FREQUENCY_ATTR_DFS_TIME = 0x8
NL80211_FREQUENCY_ATTR_DISABLED = 0x2
@@ -5351,12 +5435,14 @@ const (
NL80211_FREQUENCY_ATTR_GO_CONCURRENT = 0xf
NL80211_FREQUENCY_ATTR_INDOOR_ONLY = 0xe
NL80211_FREQUENCY_ATTR_IR_CONCURRENT = 0xf
- NL80211_FREQUENCY_ATTR_MAX = 0x21
+ NL80211_FREQUENCY_ATTR_MAX = 0x22
NL80211_FREQUENCY_ATTR_MAX_TX_POWER = 0x6
NL80211_FREQUENCY_ATTR_NO_10MHZ = 0x11
NL80211_FREQUENCY_ATTR_NO_160MHZ = 0xc
NL80211_FREQUENCY_ATTR_NO_20MHZ = 0x10
NL80211_FREQUENCY_ATTR_NO_320MHZ = 0x1a
+ NL80211_FREQUENCY_ATTR_NO_6GHZ_AFC_CLIENT = 0x1f
+ NL80211_FREQUENCY_ATTR_NO_6GHZ_VLP_CLIENT = 0x1e
NL80211_FREQUENCY_ATTR_NO_80MHZ = 0xb
NL80211_FREQUENCY_ATTR_NO_EHT = 0x1b
NL80211_FREQUENCY_ATTR_NO_HE = 0x13
@@ -5364,8 +5450,11 @@ const (
NL80211_FREQUENCY_ATTR_NO_HT40_PLUS = 0xa
NL80211_FREQUENCY_ATTR_NO_IBSS = 0x3
NL80211_FREQUENCY_ATTR_NO_IR = 0x3
+ NL80211_FREQUENCY_ATTR_NO_UHB_AFC_CLIENT = 0x1f
+ NL80211_FREQUENCY_ATTR_NO_UHB_VLP_CLIENT = 0x1e
NL80211_FREQUENCY_ATTR_OFFSET = 0x14
NL80211_FREQUENCY_ATTR_PASSIVE_SCAN = 0x3
+ NL80211_FREQUENCY_ATTR_PSD = 0x1c
NL80211_FREQUENCY_ATTR_RADAR = 0x5
NL80211_FREQUENCY_ATTR_WMM = 0x12
NL80211_FTM_RESP_ATTR_CIVICLOC = 0x3
@@ -5430,6 +5519,7 @@ const (
NL80211_IFTYPE_STATION = 0x2
NL80211_IFTYPE_UNSPECIFIED = 0x0
NL80211_IFTYPE_WDS = 0x5
+ NL80211_KCK_EXT_LEN_32 = 0x20
NL80211_KCK_EXT_LEN = 0x18
NL80211_KCK_LEN = 0x10
NL80211_KEK_EXT_LEN = 0x20
@@ -5458,9 +5548,10 @@ const (
NL80211_MAX_SUPP_HT_RATES = 0x4d
NL80211_MAX_SUPP_RATES = 0x20
NL80211_MAX_SUPP_REG_RULES = 0x80
+ NL80211_MAX_SUPP_SELECTORS = 0x80
NL80211_MBSSID_CONFIG_ATTR_EMA = 0x5
NL80211_MBSSID_CONFIG_ATTR_INDEX = 0x3
- NL80211_MBSSID_CONFIG_ATTR_MAX = 0x5
+ NL80211_MBSSID_CONFIG_ATTR_MAX = 0x6
NL80211_MBSSID_CONFIG_ATTR_MAX_EMA_PROFILE_PERIODICITY = 0x2
NL80211_MBSSID_CONFIG_ATTR_MAX_INTERFACES = 0x1
NL80211_MBSSID_CONFIG_ATTR_TX_IFINDEX = 0x4
@@ -5703,11 +5794,16 @@ const (
NL80211_RADAR_PRE_CAC_EXPIRED = 0x4
NL80211_RATE_INFO_10_MHZ_WIDTH = 0xb
NL80211_RATE_INFO_160_MHZ_WIDTH = 0xa
+ NL80211_RATE_INFO_16_MHZ_WIDTH = 0x1d
+ NL80211_RATE_INFO_1_MHZ_WIDTH = 0x19
+ NL80211_RATE_INFO_2_MHZ_WIDTH = 0x1a
NL80211_RATE_INFO_320_MHZ_WIDTH = 0x12
NL80211_RATE_INFO_40_MHZ_WIDTH = 0x3
+ NL80211_RATE_INFO_4_MHZ_WIDTH = 0x1b
NL80211_RATE_INFO_5_MHZ_WIDTH = 0xc
NL80211_RATE_INFO_80_MHZ_WIDTH = 0x8
NL80211_RATE_INFO_80P80_MHZ_WIDTH = 0x9
+ NL80211_RATE_INFO_8_MHZ_WIDTH = 0x1c
NL80211_RATE_INFO_BITRATE32 = 0x5
NL80211_RATE_INFO_BITRATE = 0x1
NL80211_RATE_INFO_EHT_GI_0_8 = 0x0
@@ -5753,6 +5849,8 @@ const (
NL80211_RATE_INFO_HE_RU_ALLOC = 0x11
NL80211_RATE_INFO_MAX = 0x1d
NL80211_RATE_INFO_MCS = 0x2
+ NL80211_RATE_INFO_S1G_MCS = 0x17
+ NL80211_RATE_INFO_S1G_NSS = 0x18
NL80211_RATE_INFO_SHORT_GI = 0x4
NL80211_RATE_INFO_VHT_MCS = 0x6
NL80211_RATE_INFO_VHT_NSS = 0x7
@@ -5770,14 +5868,19 @@ const (
NL80211_REKEY_DATA_KEK = 0x1
NL80211_REKEY_DATA_REPLAY_CTR = 0x3
NL80211_REPLAY_CTR_LEN = 0x8
+ NL80211_RRF_ALLOW_6GHZ_VLP_AP = 0x1000000
NL80211_RRF_AUTO_BW = 0x800
NL80211_RRF_DFS = 0x10
+ NL80211_RRF_DFS_CONCURRENT = 0x200000
NL80211_RRF_GO_CONCURRENT = 0x1000
NL80211_RRF_IR_CONCURRENT = 0x1000
NL80211_RRF_NO_160MHZ = 0x10000
NL80211_RRF_NO_320MHZ = 0x40000
+ NL80211_RRF_NO_6GHZ_AFC_CLIENT = 0x800000
+ NL80211_RRF_NO_6GHZ_VLP_CLIENT = 0x400000
NL80211_RRF_NO_80MHZ = 0x8000
NL80211_RRF_NO_CCK = 0x2
+ NL80211_RRF_NO_EHT = 0x80000
NL80211_RRF_NO_HE = 0x20000
NL80211_RRF_NO_HT40 = 0x6000
NL80211_RRF_NO_HT40MINUS = 0x2000
@@ -5788,7 +5891,10 @@ const (
NL80211_RRF_NO_IR = 0x80
NL80211_RRF_NO_OFDM = 0x1
NL80211_RRF_NO_OUTDOOR = 0x8
+ NL80211_RRF_NO_UHB_AFC_CLIENT = 0x800000
+ NL80211_RRF_NO_UHB_VLP_CLIENT = 0x400000
NL80211_RRF_PASSIVE_SCAN = 0x80
+ NL80211_RRF_PSD = 0x100000
NL80211_RRF_PTMP_ONLY = 0x40
NL80211_RRF_PTP_ONLY = 0x20
NL80211_RXMGMT_FLAG_ANSWERED = 0x1
@@ -5849,6 +5955,7 @@ const (
NL80211_STA_FLAG_MAX_OLD_API = 0x6
NL80211_STA_FLAG_MFP = 0x4
NL80211_STA_FLAG_SHORT_PREAMBLE = 0x2
+ NL80211_STA_FLAG_SPP_AMSDU = 0x8
NL80211_STA_FLAG_TDLS_PEER = 0x6
NL80211_STA_FLAG_WME = 0x3
NL80211_STA_INFO_ACK_SIGNAL_AVG = 0x23
@@ -6007,6 +6114,13 @@ const (
NL80211_VHT_CAPABILITY_LEN = 0xc
NL80211_VHT_NSS_MAX = 0x8
NL80211_WIPHY_NAME_MAXLEN = 0x40
+ NL80211_WIPHY_RADIO_ATTR_FREQ_RANGE = 0x2
+ NL80211_WIPHY_RADIO_ATTR_INDEX = 0x1
+ NL80211_WIPHY_RADIO_ATTR_INTERFACE_COMBINATION = 0x3
+ NL80211_WIPHY_RADIO_ATTR_MAX = 0x4
+ NL80211_WIPHY_RADIO_FREQ_ATTR_END = 0x2
+ NL80211_WIPHY_RADIO_FREQ_ATTR_MAX = 0x2
+ NL80211_WIPHY_RADIO_FREQ_ATTR_START = 0x1
NL80211_WMMR_AIFSN = 0x3
NL80211_WMMR_CW_MAX = 0x2
NL80211_WMMR_CW_MIN = 0x1
@@ -6038,6 +6152,7 @@ const (
NL80211_WOWLAN_TRIG_PKT_PATTERN = 0x4
NL80211_WOWLAN_TRIG_RFKILL_RELEASE = 0x9
NL80211_WOWLAN_TRIG_TCP_CONNECTION = 0xe
+ NL80211_WOWLAN_TRIG_UNPROTECTED_DEAUTH_DISASSOC = 0x14
NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211 = 0xa
NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN = 0xb
NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023 = 0xc
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
index fd402da4..485f2d3a 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_386.go
@@ -282,7 +282,7 @@ type Taskstats struct {
Ac_exitcode uint32
Ac_flag uint8
Ac_nice uint8
- _ [4]byte
+ _ [6]byte
Cpu_count uint64
Cpu_delay_total uint64
Blkio_count uint64
@@ -338,6 +338,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint32
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
index eb7a5e18..ecbd1ad8 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_amd64.go
@@ -351,6 +351,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint64
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
index d78ac108..02f0463a 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm.go
@@ -91,7 +91,7 @@ type Stat_t struct {
Gid uint32
Rdev uint64
_ uint16
- _ [4]byte
+ _ [6]byte
Size int64
Blksize int32
_ [4]byte
@@ -273,7 +273,7 @@ type Taskstats struct {
Ac_exitcode uint32
Ac_flag uint8
Ac_nice uint8
- _ [4]byte
+ _ [6]byte
Cpu_count uint64
Cpu_delay_total uint64
Blkio_count uint64
@@ -329,6 +329,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint32
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
index cd06d47f..6f4d400d 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_arm64.go
@@ -330,6 +330,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint64
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go
index 2f28fe26..cd532cfa 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_loong64.go
@@ -331,6 +331,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint64
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
index 71d6cac2..41336208 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips.go
@@ -278,7 +278,7 @@ type Taskstats struct {
Ac_exitcode uint32
Ac_flag uint8
Ac_nice uint8
- _ [4]byte
+ _ [6]byte
Cpu_count uint64
Cpu_delay_total uint64
Blkio_count uint64
@@ -334,6 +334,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint32
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
index 8596d453..eaa37eb7 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64.go
@@ -333,6 +333,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint64
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
index cd60ea18..98ae6a1e 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mips64le.go
@@ -333,6 +333,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint64
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
index b0ae420c..cae19615 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_mipsle.go
@@ -278,7 +278,7 @@ type Taskstats struct {
Ac_exitcode uint32
Ac_flag uint8
Ac_nice uint8
- _ [4]byte
+ _ [6]byte
Cpu_count uint64
Cpu_delay_total uint64
Blkio_count uint64
@@ -334,6 +334,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint32
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go
index 83597287..6ce3b4e0 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go
@@ -90,7 +90,7 @@ type Stat_t struct {
Gid uint32
Rdev uint64
_ uint16
- _ [4]byte
+ _ [6]byte
Size int64
Blksize int32
_ [4]byte
@@ -285,7 +285,7 @@ type Taskstats struct {
Ac_exitcode uint32
Ac_flag uint8
Ac_nice uint8
- _ [4]byte
+ _ [6]byte
Cpu_count uint64
Cpu_delay_total uint64
Blkio_count uint64
@@ -341,6 +341,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint32
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
index 69eb6a5c..c7429c6a 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64.go
@@ -340,6 +340,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint64
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
index 5f583cb6..4bf4baf4 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_ppc64le.go
@@ -340,6 +340,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint64
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
index ad05b51a..e9709d70 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_riscv64.go
@@ -358,6 +358,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint64
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
index cf3ce900..fb44268c 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_s390x.go
@@ -353,6 +353,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint64
diff --git a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
index 590b5673..9c38265c 100644
--- a/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
+++ b/vendor/golang.org/x/sys/unix/ztypes_linux_sparc64.go
@@ -335,6 +335,22 @@ type Taskstats struct {
Wpcopy_delay_total uint64
Irq_count uint64
Irq_delay_total uint64
+ Cpu_delay_max uint64
+ Cpu_delay_min uint64
+ Blkio_delay_max uint64
+ Blkio_delay_min uint64
+ Swapin_delay_max uint64
+ Swapin_delay_min uint64
+ Freepages_delay_max uint64
+ Freepages_delay_min uint64
+ Thrashing_delay_max uint64
+ Thrashing_delay_min uint64
+ Compact_delay_max uint64
+ Compact_delay_min uint64
+ Wpcopy_delay_max uint64
+ Wpcopy_delay_min uint64
+ Irq_delay_max uint64
+ Irq_delay_min uint64
}
type cpuMask uint64
diff --git a/vendor/golang.org/x/term/term_windows.go b/vendor/golang.org/x/term/term_windows.go
index df6bf948..0ddd81c0 100644
--- a/vendor/golang.org/x/term/term_windows.go
+++ b/vendor/golang.org/x/term/term_windows.go
@@ -20,12 +20,14 @@ func isTerminal(fd int) bool {
return err == nil
}
+// This is intended to be used on a console input handle.
+// See https://learn.microsoft.com/en-us/windows/console/setconsolemode
func makeRaw(fd int) (*State, error) {
var st uint32
if err := windows.GetConsoleMode(windows.Handle(fd), &st); err != nil {
return nil, err
}
- raw := st &^ (windows.ENABLE_ECHO_INPUT | windows.ENABLE_PROCESSED_INPUT | windows.ENABLE_LINE_INPUT | windows.ENABLE_PROCESSED_OUTPUT)
+ raw := st &^ (windows.ENABLE_ECHO_INPUT | windows.ENABLE_PROCESSED_INPUT | windows.ENABLE_LINE_INPUT)
raw |= windows.ENABLE_VIRTUAL_TERMINAL_INPUT
if err := windows.SetConsoleMode(windows.Handle(fd), raw); err != nil {
return nil, err
diff --git a/vendor/golang.org/x/term/terminal.go b/vendor/golang.org/x/term/terminal.go
index 13e9a64a..bddb2e2a 100644
--- a/vendor/golang.org/x/term/terminal.go
+++ b/vendor/golang.org/x/term/terminal.go
@@ -146,6 +146,7 @@ const (
keyCtrlD = 4
keyCtrlU = 21
keyEnter = '\r'
+ keyLF = '\n'
keyEscape = 27
keyBackspace = 127
keyUnknown = 0xd800 /* UTF-16 surrogate area */ + iota
@@ -497,7 +498,7 @@ func (t *Terminal) historyAdd(entry string) {
// handleKey processes the given key and, optionally, returns a line of text
// that the user has entered.
func (t *Terminal) handleKey(key rune) (line string, ok bool) {
- if t.pasteActive && key != keyEnter {
+ if t.pasteActive && key != keyEnter && key != keyLF {
t.addKeyToLine(key)
return
}
@@ -567,7 +568,7 @@ func (t *Terminal) handleKey(key rune) (line string, ok bool) {
t.setLine(runes, len(runes))
}
}
- case keyEnter:
+ case keyEnter, keyLF:
t.moveCursorToPos(len(t.line))
t.queue([]rune("\r\n"))
line = string(t.line)
@@ -812,6 +813,10 @@ func (t *Terminal) readLine() (line string, err error) {
if !t.pasteActive {
lineIsPasted = false
}
+ // If we have CR, consume LF if present (CRLF sequence) to avoid returning an extra empty line.
+ if key == keyEnter && len(rest) > 0 && rest[0] == keyLF {
+ rest = rest[1:]
+ }
line, lineOk = t.handleKey(key)
}
if len(rest) > 0 {
diff --git a/vendor/golang.org/x/tools/internal/astutil/edge/edge.go b/vendor/golang.org/x/tools/go/ast/edge/edge.go
similarity index 100%
rename from vendor/golang.org/x/tools/internal/astutil/edge/edge.go
rename to vendor/golang.org/x/tools/go/ast/edge/edge.go
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/cursor.go b/vendor/golang.org/x/tools/go/ast/inspector/cursor.go
new file mode 100644
index 00000000..31c8d2f2
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/ast/inspector/cursor.go
@@ -0,0 +1,502 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package inspector
+
+import (
+ "fmt"
+ "go/ast"
+ "go/token"
+ "iter"
+ "reflect"
+
+ "golang.org/x/tools/go/ast/edge"
+)
+
+// A Cursor represents an [ast.Node]. It is immutable.
+//
+// Two Cursors compare equal if they represent the same node.
+//
+// Call [Inspector.Root] to obtain a valid cursor for the virtual root
+// node of the traversal.
+//
+// Use the following methods to navigate efficiently around the tree:
+// - for ancestors, use [Cursor.Parent] and [Cursor.Enclosing];
+// - for children, use [Cursor.Child], [Cursor.Children],
+// [Cursor.FirstChild], and [Cursor.LastChild];
+// - for siblings, use [Cursor.PrevSibling] and [Cursor.NextSibling];
+// - for descendants, use [Cursor.FindByPos], [Cursor.FindNode],
+// [Cursor.Inspect], and [Cursor.Preorder].
+//
+// Use the [Cursor.ChildAt] and [Cursor.ParentEdge] methods for
+// information about the edges in a tree: which field (and slice
+// element) of the parent node holds the child.
+type Cursor struct {
+ in *Inspector
+ index int32 // index of push node; -1 for virtual root node
+}
+
+// Root returns a cursor for the virtual root node,
+// whose children are the files provided to [New].
+//
+// Its [Cursor.Node] and [Cursor.Stack] methods return nil.
+func (in *Inspector) Root() Cursor {
+ return Cursor{in, -1}
+}
+
+// At returns the cursor at the specified index in the traversal,
+// which must have been obtained from [Cursor.Index] on a Cursor
+// belonging to the same Inspector (see [Cursor.Inspector]).
+func (in *Inspector) At(index int32) Cursor {
+ if index < 0 {
+ panic("negative index")
+ }
+ if int(index) >= len(in.events) {
+ panic("index out of range for this inspector")
+ }
+ if in.events[index].index < index {
+ panic("invalid index") // (a push, not a pop)
+ }
+ return Cursor{in, index}
+}
+
+// Inspector returns the cursor's Inspector.
+func (c Cursor) Inspector() *Inspector { return c.in }
+
+// Index returns the index of this cursor position within the package.
+//
+// Clients should not assume anything about the numeric Index value
+// except that it increases monotonically throughout the traversal.
+// It is provided for use with [At].
+//
+// Index must not be called on the Root node.
+func (c Cursor) Index() int32 {
+ if c.index < 0 {
+ panic("Index called on Root node")
+ }
+ return c.index
+}
+
+// Node returns the node at the current cursor position,
+// or nil for the cursor returned by [Inspector.Root].
+func (c Cursor) Node() ast.Node {
+ if c.index < 0 {
+ return nil
+ }
+ return c.in.events[c.index].node
+}
+
+// String returns information about the cursor's node, if any.
+func (c Cursor) String() string {
+ if c.in == nil {
+ return "(invalid)"
+ }
+ if c.index < 0 {
+ return "(root)"
+ }
+ return reflect.TypeOf(c.Node()).String()
+}
+
+// indices return the [start, end) half-open interval of event indices.
+func (c Cursor) indices() (int32, int32) {
+ if c.index < 0 {
+ return 0, int32(len(c.in.events)) // root: all events
+ } else {
+ return c.index, c.in.events[c.index].index + 1 // just one subtree
+ }
+}
+
+// Preorder returns an iterator over the nodes of the subtree
+// represented by c in depth-first order. Each node in the sequence is
+// represented by a Cursor that allows access to the Node, but may
+// also be used to start a new traversal, or to obtain the stack of
+// nodes enclosing the cursor.
+//
+// The traversal sequence is determined by [ast.Inspect]. The types
+// argument, if non-empty, enables type-based filtering of events. The
+// function f if is called only for nodes whose type matches an
+// element of the types slice.
+//
+// If you need control over descent into subtrees,
+// or need both pre- and post-order notifications, use [Cursor.Inspect]
+func (c Cursor) Preorder(types ...ast.Node) iter.Seq[Cursor] {
+ mask := maskOf(types)
+
+ return func(yield func(Cursor) bool) {
+ events := c.in.events
+
+ for i, limit := c.indices(); i < limit; {
+ ev := events[i]
+ if ev.index > i { // push?
+ if ev.typ&mask != 0 && !yield(Cursor{c.in, i}) {
+ break
+ }
+ pop := ev.index
+ if events[pop].typ&mask == 0 {
+ // Subtree does not contain types: skip.
+ i = pop + 1
+ continue
+ }
+ }
+ i++
+ }
+ }
+}
+
+// Inspect visits the nodes of the subtree represented by c in
+// depth-first order. It calls f(n) for each node n before it
+// visits n's children. If f returns true, Inspect invokes f
+// recursively for each of the non-nil children of the node.
+//
+// Each node is represented by a Cursor that allows access to the
+// Node, but may also be used to start a new traversal, or to obtain
+// the stack of nodes enclosing the cursor.
+//
+// The complete traversal sequence is determined by [ast.Inspect].
+// The types argument, if non-empty, enables type-based filtering of
+// events. The function f if is called only for nodes whose type
+// matches an element of the types slice.
+func (c Cursor) Inspect(types []ast.Node, f func(c Cursor) (descend bool)) {
+ mask := maskOf(types)
+ events := c.in.events
+ for i, limit := c.indices(); i < limit; {
+ ev := events[i]
+ if ev.index > i {
+ // push
+ pop := ev.index
+ if ev.typ&mask != 0 && !f(Cursor{c.in, i}) ||
+ events[pop].typ&mask == 0 {
+ // The user opted not to descend, or the
+ // subtree does not contain types:
+ // skip past the pop.
+ i = pop + 1
+ continue
+ }
+ }
+ i++
+ }
+}
+
+// Enclosing returns an iterator over the nodes enclosing the current
+// current node, starting with the Cursor itself.
+//
+// Enclosing must not be called on the Root node (whose [Cursor.Node] returns nil).
+//
+// The types argument, if non-empty, enables type-based filtering of
+// events: the sequence includes only enclosing nodes whose type
+// matches an element of the types slice.
+func (c Cursor) Enclosing(types ...ast.Node) iter.Seq[Cursor] {
+ if c.index < 0 {
+ panic("Cursor.Enclosing called on Root node")
+ }
+
+ mask := maskOf(types)
+
+ return func(yield func(Cursor) bool) {
+ events := c.in.events
+ for i := c.index; i >= 0; i = events[i].parent {
+ if events[i].typ&mask != 0 && !yield(Cursor{c.in, i}) {
+ break
+ }
+ }
+ }
+}
+
+// Parent returns the parent of the current node.
+//
+// Parent must not be called on the Root node (whose [Cursor.Node] returns nil).
+func (c Cursor) Parent() Cursor {
+ if c.index < 0 {
+ panic("Cursor.Parent called on Root node")
+ }
+
+ return Cursor{c.in, c.in.events[c.index].parent}
+}
+
+// ParentEdge returns the identity of the field in the parent node
+// that holds this cursor's node, and if it is a list, the index within it.
+//
+// For example, f(x, y) is a CallExpr whose three children are Idents.
+// f has edge kind [edge.CallExpr_Fun] and index -1.
+// x and y have kind [edge.CallExpr_Args] and indices 0 and 1, respectively.
+//
+// If called on a child of the Root node, it returns ([edge.Invalid], -1).
+//
+// ParentEdge must not be called on the Root node (whose [Cursor.Node] returns nil).
+func (c Cursor) ParentEdge() (edge.Kind, int) {
+ if c.index < 0 {
+ panic("Cursor.ParentEdge called on Root node")
+ }
+ events := c.in.events
+ pop := events[c.index].index
+ return unpackEdgeKindAndIndex(events[pop].parent)
+}
+
+// ChildAt returns the cursor for the child of the
+// current node identified by its edge and index.
+// The index must be -1 if the edge.Kind is not a slice.
+// The indicated child node must exist.
+//
+// ChildAt must not be called on the Root node (whose [Cursor.Node] returns nil).
+//
+// Invariant: c.Parent().ChildAt(c.ParentEdge()) == c.
+func (c Cursor) ChildAt(k edge.Kind, idx int) Cursor {
+ target := packEdgeKindAndIndex(k, idx)
+
+ // Unfortunately there's no shortcut to looping.
+ events := c.in.events
+ i := c.index + 1
+ for {
+ pop := events[i].index
+ if pop < i {
+ break
+ }
+ if events[pop].parent == target {
+ return Cursor{c.in, i}
+ }
+ i = pop + 1
+ }
+ panic(fmt.Sprintf("ChildAt(%v, %d): no such child of %v", k, idx, c))
+}
+
+// Child returns the cursor for n, which must be a direct child of c's Node.
+//
+// Child must not be called on the Root node (whose [Cursor.Node] returns nil).
+func (c Cursor) Child(n ast.Node) Cursor {
+ if c.index < 0 {
+ panic("Cursor.Child called on Root node")
+ }
+
+ if false {
+ // reference implementation
+ for child := range c.Children() {
+ if child.Node() == n {
+ return child
+ }
+ }
+
+ } else {
+ // optimized implementation
+ events := c.in.events
+ for i := c.index + 1; events[i].index > i; i = events[i].index + 1 {
+ if events[i].node == n {
+ return Cursor{c.in, i}
+ }
+ }
+ }
+ panic(fmt.Sprintf("Child(%T): not a child of %v", n, c))
+}
+
+// NextSibling returns the cursor for the next sibling node in the same list
+// (for example, of files, decls, specs, statements, fields, or expressions) as
+// the current node. It returns (zero, false) if the node is the last node in
+// the list, or is not part of a list.
+//
+// NextSibling must not be called on the Root node.
+//
+// See note at [Cursor.Children].
+func (c Cursor) NextSibling() (Cursor, bool) {
+ if c.index < 0 {
+ panic("Cursor.NextSibling called on Root node")
+ }
+
+ events := c.in.events
+ i := events[c.index].index + 1 // after corresponding pop
+ if i < int32(len(events)) {
+ if events[i].index > i { // push?
+ return Cursor{c.in, i}, true
+ }
+ }
+ return Cursor{}, false
+}
+
+// PrevSibling returns the cursor for the previous sibling node in the
+// same list (for example, of files, decls, specs, statements, fields,
+// or expressions) as the current node. It returns zero if the node is
+// the first node in the list, or is not part of a list.
+//
+// It must not be called on the Root node.
+//
+// See note at [Cursor.Children].
+func (c Cursor) PrevSibling() (Cursor, bool) {
+ if c.index < 0 {
+ panic("Cursor.PrevSibling called on Root node")
+ }
+
+ events := c.in.events
+ i := c.index - 1
+ if i >= 0 {
+ if j := events[i].index; j < i { // pop?
+ return Cursor{c.in, j}, true
+ }
+ }
+ return Cursor{}, false
+}
+
+// FirstChild returns the first direct child of the current node,
+// or zero if it has no children.
+func (c Cursor) FirstChild() (Cursor, bool) {
+ events := c.in.events
+ i := c.index + 1 // i=0 if c is root
+ if i < int32(len(events)) && events[i].index > i { // push?
+ return Cursor{c.in, i}, true
+ }
+ return Cursor{}, false
+}
+
+// LastChild returns the last direct child of the current node,
+// or zero if it has no children.
+func (c Cursor) LastChild() (Cursor, bool) {
+ events := c.in.events
+ if c.index < 0 { // root?
+ if len(events) > 0 {
+ // return push of final event (a pop)
+ return Cursor{c.in, events[len(events)-1].index}, true
+ }
+ } else {
+ j := events[c.index].index - 1 // before corresponding pop
+ // Inv: j == c.index if c has no children
+ // or j is last child's pop.
+ if j > c.index { // c has children
+ return Cursor{c.in, events[j].index}, true
+ }
+ }
+ return Cursor{}, false
+}
+
+// Children returns an iterator over the direct children of the
+// current node, if any.
+//
+// When using Children, NextChild, and PrevChild, bear in mind that a
+// Node's children may come from different fields, some of which may
+// be lists of nodes without a distinguished intervening container
+// such as [ast.BlockStmt].
+//
+// For example, [ast.CaseClause] has a field List of expressions and a
+// field Body of statements, so the children of a CaseClause are a mix
+// of expressions and statements. Other nodes that have "uncontained"
+// list fields include:
+//
+// - [ast.ValueSpec] (Names, Values)
+// - [ast.CompositeLit] (Type, Elts)
+// - [ast.IndexListExpr] (X, Indices)
+// - [ast.CallExpr] (Fun, Args)
+// - [ast.AssignStmt] (Lhs, Rhs)
+//
+// So, do not assume that the previous sibling of an ast.Stmt is also
+// an ast.Stmt, or if it is, that they are executed sequentially,
+// unless you have established that, say, its parent is a BlockStmt
+// or its [Cursor.ParentEdge] is [edge.BlockStmt_List].
+// For example, given "for S1; ; S2 {}", the predecessor of S2 is S1,
+// even though they are not executed in sequence.
+func (c Cursor) Children() iter.Seq[Cursor] {
+ return func(yield func(Cursor) bool) {
+ c, ok := c.FirstChild()
+ for ok && yield(c) {
+ c, ok = c.NextSibling()
+ }
+ }
+}
+
+// Contains reports whether c contains or is equal to c2.
+//
+// Both Cursors must belong to the same [Inspector];
+// neither may be its Root node.
+func (c Cursor) Contains(c2 Cursor) bool {
+ if c.in != c2.in {
+ panic("different inspectors")
+ }
+ events := c.in.events
+ return c.index <= c2.index && events[c2.index].index <= events[c.index].index
+}
+
+// FindNode returns the cursor for node n if it belongs to the subtree
+// rooted at c. It returns zero if n is not found.
+func (c Cursor) FindNode(n ast.Node) (Cursor, bool) {
+
+ // FindNode is equivalent to this code,
+ // but more convenient and 15-20% faster:
+ if false {
+ for candidate := range c.Preorder(n) {
+ if candidate.Node() == n {
+ return candidate, true
+ }
+ }
+ return Cursor{}, false
+ }
+
+ // TODO(adonovan): opt: should we assume Node.Pos is accurate
+ // and combine type-based filtering with position filtering
+ // like FindByPos?
+
+ mask := maskOf([]ast.Node{n})
+ events := c.in.events
+
+ for i, limit := c.indices(); i < limit; i++ {
+ ev := events[i]
+ if ev.index > i { // push?
+ if ev.typ&mask != 0 && ev.node == n {
+ return Cursor{c.in, i}, true
+ }
+ pop := ev.index
+ if events[pop].typ&mask == 0 {
+ // Subtree does not contain type of n: skip.
+ i = pop
+ }
+ }
+ }
+ return Cursor{}, false
+}
+
+// FindByPos returns the cursor for the innermost node n in the tree
+// rooted at c such that n.Pos() <= start && end <= n.End().
+// (For an *ast.File, it uses the bounds n.FileStart-n.FileEnd.)
+//
+// It returns zero if none is found.
+// Precondition: start <= end.
+//
+// See also [astutil.PathEnclosingInterval], which
+// tolerates adjoining whitespace.
+func (c Cursor) FindByPos(start, end token.Pos) (Cursor, bool) {
+ if end < start {
+ panic("end < start")
+ }
+ events := c.in.events
+
+ // This algorithm could be implemented using c.Inspect,
+ // but it is about 2.5x slower.
+
+ best := int32(-1) // push index of latest (=innermost) node containing range
+ for i, limit := c.indices(); i < limit; i++ {
+ ev := events[i]
+ if ev.index > i { // push?
+ n := ev.node
+ var nodeEnd token.Pos
+ if file, ok := n.(*ast.File); ok {
+ nodeEnd = file.FileEnd
+ // Note: files may be out of Pos order.
+ if file.FileStart > start {
+ i = ev.index // disjoint, after; skip to next file
+ continue
+ }
+ } else {
+ nodeEnd = n.End()
+ if n.Pos() > start {
+ break // disjoint, after; stop
+ }
+ }
+ // Inv: node.{Pos,FileStart} <= start
+ if end <= nodeEnd {
+ // node fully contains target range
+ best = i
+ } else if nodeEnd < start {
+ i = ev.index // disjoint, before; skip forward
+ }
+ }
+ }
+ if best >= 0 {
+ return Cursor{c.in, best}, true
+ }
+ return Cursor{}, false
+}
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/inspector.go b/vendor/golang.org/x/tools/go/ast/inspector/inspector.go
index 674490a6..a703cdfc 100644
--- a/vendor/golang.org/x/tools/go/ast/inspector/inspector.go
+++ b/vendor/golang.org/x/tools/go/ast/inspector/inspector.go
@@ -13,10 +13,19 @@
// This representation is sometimes called a "balanced parenthesis tree."
//
// Experiments suggest the inspector's traversals are about 2.5x faster
-// than ast.Inspect, but it may take around 5 traversals for this
+// than [ast.Inspect], but it may take around 5 traversals for this
// benefit to amortize the inspector's construction cost.
// If efficiency is the primary concern, do not use Inspector for
// one-off traversals.
+//
+// The [Cursor] type provides a more flexible API for efficient
+// navigation of syntax trees in all four "cardinal directions". For
+// example, traversals may be nested, so you can find each node of
+// type A and then search within it for nodes of type B. Or you can
+// traverse from a node to its immediate neighbors: its parent, its
+// previous and next sibling, or its first and last child. We
+// recommend using methods of Cursor in preference to Inspector where
+// possible.
package inspector
// There are four orthogonal features in a traversal:
@@ -37,9 +46,8 @@ package inspector
import (
"go/ast"
- _ "unsafe"
- "golang.org/x/tools/internal/astutil/edge"
+ "golang.org/x/tools/go/ast/edge"
)
// An Inspector provides methods for inspecting
@@ -48,18 +56,12 @@ type Inspector struct {
events []event
}
-//go:linkname events golang.org/x/tools/go/ast/inspector.events
-func events(in *Inspector) []event { return in.events }
-
-//go:linkname packEdgeKindAndIndex golang.org/x/tools/go/ast/inspector.packEdgeKindAndIndex
func packEdgeKindAndIndex(ek edge.Kind, index int) int32 {
return int32(uint32(index+1)<<7 | uint32(ek))
}
// unpackEdgeKindAndIndex unpacks the edge kind and edge index (within
// an []ast.Node slice) from the parent field of a pop event.
-//
-//go:linkname unpackEdgeKindAndIndex golang.org/x/tools/go/ast/inspector.unpackEdgeKindAndIndex
func unpackEdgeKindAndIndex(x int32) (edge.Kind, int) {
// The "parent" field of a pop node holds the
// edge Kind in the lower 7 bits and the index+1
@@ -83,15 +85,21 @@ type event struct {
// TODO: Experiment with storing only the second word of event.node (unsafe.Pointer).
// Type can be recovered from the sole bit in typ.
+// [Tried this, wasn't faster. --adonovan]
// Preorder visits all the nodes of the files supplied to New in
// depth-first order. It calls f(n) for each node n before it visits
// n's children.
//
-// The complete traversal sequence is determined by ast.Inspect.
+// The complete traversal sequence is determined by [ast.Inspect].
// The types argument, if non-empty, enables type-based filtering of
// events. The function f is called only for nodes whose type
// matches an element of the types slice.
+//
+// The [Cursor.Preorder] method provides a richer alternative interface.
+// Example:
+//
+// for c := range in.Root().Preorder(types) { ... }
func (in *Inspector) Preorder(types []ast.Node, f func(ast.Node)) {
// Because it avoids postorder calls to f, and the pruning
// check, Preorder is almost twice as fast as Nodes. The two
@@ -131,10 +139,18 @@ func (in *Inspector) Preorder(types []ast.Node, f func(ast.Node)) {
// of the non-nil children of the node, followed by a call of
// f(n, false).
//
-// The complete traversal sequence is determined by ast.Inspect.
+// The complete traversal sequence is determined by [ast.Inspect].
// The types argument, if non-empty, enables type-based filtering of
// events. The function f if is called only for nodes whose type
// matches an element of the types slice.
+//
+// The [Cursor.Inspect] method provides a richer alternative interface.
+// Example:
+//
+// in.Root().Inspect(types, func(c Cursor) bool {
+// ...
+// return true
+// }
func (in *Inspector) Nodes(types []ast.Node, f func(n ast.Node, push bool) (proceed bool)) {
mask := maskOf(types)
for i := int32(0); i < int32(len(in.events)); {
@@ -168,6 +184,15 @@ func (in *Inspector) Nodes(types []ast.Node, f func(n ast.Node, push bool) (proc
// supplies each call to f an additional argument, the current
// traversal stack. The stack's first element is the outermost node,
// an *ast.File; its last is the innermost, n.
+//
+// The [Cursor.Inspect] method provides a richer alternative interface.
+// Example:
+//
+// in.Root().Inspect(types, func(c Cursor) bool {
+// stack := slices.Collect(c.Enclosing())
+// ...
+// return true
+// })
func (in *Inspector) WithStack(types []ast.Node, f func(n ast.Node, push bool, stack []ast.Node) (proceed bool)) {
mask := maskOf(types)
var stack []ast.Node
@@ -233,7 +258,7 @@ type visitor struct {
type item struct {
index int32 // index of current node's push event
parentIndex int32 // index of parent node's push event
- typAccum uint64 // accumulated type bits of current node's descendents
+ typAccum uint64 // accumulated type bits of current node's descendants
edgeKindAndIndex int32 // edge.Kind and index, bit packed
}
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/typeof.go b/vendor/golang.org/x/tools/go/ast/inspector/typeof.go
index e936c67c..9852331a 100644
--- a/vendor/golang.org/x/tools/go/ast/inspector/typeof.go
+++ b/vendor/golang.org/x/tools/go/ast/inspector/typeof.go
@@ -12,8 +12,6 @@ package inspector
import (
"go/ast"
"math"
-
- _ "unsafe"
)
const (
@@ -217,7 +215,6 @@ func typeOf(n ast.Node) uint64 {
return 0
}
-//go:linkname maskOf golang.org/x/tools/go/ast/inspector.maskOf
func maskOf(nodes []ast.Node) uint64 {
if len(nodes) == 0 {
return math.MaxUint64 // match all node types
diff --git a/vendor/golang.org/x/tools/go/ast/inspector/walk.go b/vendor/golang.org/x/tools/go/ast/inspector/walk.go
index 5a42174a..5f1c93c8 100644
--- a/vendor/golang.org/x/tools/go/ast/inspector/walk.go
+++ b/vendor/golang.org/x/tools/go/ast/inspector/walk.go
@@ -13,7 +13,7 @@ import (
"fmt"
"go/ast"
- "golang.org/x/tools/internal/astutil/edge"
+ "golang.org/x/tools/go/ast/edge"
)
func walkList[N ast.Node](v *visitor, ek edge.Kind, list []N) {
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
new file mode 100644
index 00000000..7b90bc92
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcexportdata/gcexportdata.go
@@ -0,0 +1,236 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package gcexportdata provides functions for reading and writing
+// export data, which is a serialized description of the API of a Go
+// package including the names, kinds, types, and locations of all
+// exported declarations.
+//
+// The standard Go compiler (cmd/compile) writes an export data file
+// for each package it compiles, which it later reads when compiling
+// packages that import the earlier one. The compiler must thus
+// contain logic to both write and read export data.
+// (See the "Export" section in the cmd/compile/README file.)
+//
+// The [Read] function in this package can read files produced by the
+// compiler, producing [go/types] data structures. As a matter of
+// policy, Read supports export data files produced by only the last
+// two Go releases plus tip; see https://go.dev/issue/68898. The
+// export data files produced by the compiler contain additional
+// details related to generics, inlining, and other optimizations that
+// cannot be decoded by the [Read] function.
+//
+// In files written by the compiler, the export data is not at the
+// start of the file. Before calling Read, use [NewReader] to locate
+// the desired portion of the file.
+//
+// The [Write] function in this package encodes the exported API of a
+// Go package ([types.Package]) as a file. Such files can be later
+// decoded by Read, but cannot be consumed by the compiler.
+//
+// # Future changes
+//
+// Although Read supports the formats written by both Write and the
+// compiler, the two are quite different, and there is an open
+// proposal (https://go.dev/issue/69491) to separate these APIs.
+//
+// Under that proposal, this package would ultimately provide only the
+// Read operation for compiler export data, which must be defined in
+// this module (golang.org/x/tools), not in the standard library, to
+// avoid version skew for developer tools that need to read compiler
+// export data both before and after a Go release, such as from Go
+// 1.23 to Go 1.24. Because this package lives in the tools module,
+// clients can update their version of the module some time before the
+// Go 1.24 release and rebuild and redeploy their tools, which will
+// then be able to consume both Go 1.23 and Go 1.24 export data files,
+// so they will work before and after the Go update. (See discussion
+// at https://go.dev/issue/15651.)
+//
+// The operations to import and export [go/types] data structures
+// would be defined in the go/types package as Import and Export.
+// [Write] would (eventually) delegate to Export,
+// and [Read], when it detects a file produced by Export,
+// would delegate to Import.
+//
+// # Deprecations
+//
+// The [NewImporter] and [Find] functions are deprecated and should
+// not be used in new code. The [WriteBundle] and [ReadBundle]
+// functions are experimental, and there is an open proposal to
+// deprecate them (https://go.dev/issue/69573).
+package gcexportdata
+
+import (
+ "bufio"
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "go/token"
+ "go/types"
+ "io"
+ "os/exec"
+
+ "golang.org/x/tools/internal/gcimporter"
+)
+
+// Find returns the name of an object (.o) or archive (.a) file
+// containing type information for the specified import path,
+// using the go command.
+// If no file was found, an empty filename is returned.
+//
+// A relative srcDir is interpreted relative to the current working directory.
+//
+// Find also returns the package's resolved (canonical) import path,
+// reflecting the effects of srcDir and vendoring on importPath.
+//
+// Deprecated: Use the higher-level API in golang.org/x/tools/go/packages,
+// which is more efficient.
+func Find(importPath, srcDir string) (filename, path string) {
+ cmd := exec.Command("go", "list", "-json", "-export", "--", importPath)
+ cmd.Dir = srcDir
+ out, err := cmd.Output()
+ if err != nil {
+ return "", ""
+ }
+ var data struct {
+ ImportPath string
+ Export string
+ }
+ json.Unmarshal(out, &data)
+ return data.Export, data.ImportPath
+}
+
+// NewReader returns a reader for the export data section of an object
+// (.o) or archive (.a) file read from r. The new reader may provide
+// additional trailing data beyond the end of the export data.
+func NewReader(r io.Reader) (io.Reader, error) {
+ buf := bufio.NewReader(r)
+ size, err := gcimporter.FindExportData(buf)
+ if err != nil {
+ return nil, err
+ }
+
+ // We were given an archive and found the __.PKGDEF in it.
+ // This tells us the size of the export data, and we don't
+ // need to return the entire file.
+ return &io.LimitedReader{
+ R: buf,
+ N: size,
+ }, nil
+}
+
+// readAll works the same way as io.ReadAll, but avoids allocations and copies
+// by preallocating a byte slice of the necessary size if the size is known up
+// front. This is always possible when the input is an archive. In that case,
+// NewReader will return the known size using an io.LimitedReader.
+func readAll(r io.Reader) ([]byte, error) {
+ if lr, ok := r.(*io.LimitedReader); ok {
+ data := make([]byte, lr.N)
+ _, err := io.ReadFull(lr, data)
+ return data, err
+ }
+ return io.ReadAll(r)
+}
+
+// Read reads export data from in, decodes it, and returns type
+// information for the package.
+//
+// Read is capable of reading export data produced by [Write] at the
+// same source code version, or by the last two Go releases (plus tip)
+// of the standard Go compiler. Reading files from older compilers may
+// produce an error.
+//
+// The package path (effectively its linker symbol prefix) is
+// specified by path, since unlike the package name, this information
+// may not be recorded in the export data.
+//
+// File position information is added to fset.
+//
+// Read may inspect and add to the imports map to ensure that references
+// within the export data to other packages are consistent. The caller
+// must ensure that imports[path] does not exist, or exists but is
+// incomplete (see types.Package.Complete), and Read inserts the
+// resulting package into this map entry.
+//
+// On return, the state of the reader is undefined.
+func Read(in io.Reader, fset *token.FileSet, imports map[string]*types.Package, path string) (*types.Package, error) {
+ data, err := readAll(in)
+ if err != nil {
+ return nil, fmt.Errorf("reading export data for %q: %v", path, err)
+ }
+
+ if bytes.HasPrefix(data, []byte("!")) {
+ return nil, fmt.Errorf("can't read export data for %q directly from an archive file (call gcexportdata.NewReader first to extract export data)", path)
+ }
+
+ // The indexed export format starts with an 'i'; the older
+ // binary export format starts with a 'c', 'd', or 'v'
+ // (from "version"). Select appropriate importer.
+ if len(data) > 0 {
+ switch data[0] {
+ case 'v', 'c', 'd':
+ // binary, produced by cmd/compile till go1.10
+ return nil, fmt.Errorf("binary (%c) import format is no longer supported", data[0])
+
+ case 'i':
+ // indexed, produced by cmd/compile till go1.19,
+ // and also by [Write].
+ //
+ // If proposal #69491 is accepted, go/types
+ // serialization will be implemented by
+ // types.Export, to which Write would eventually
+ // delegate (explicitly dropping any pretence at
+ // inter-version Write-Read compatibility).
+ // This [Read] function would delegate to types.Import
+ // when it detects that the file was produced by Export.
+ _, pkg, err := gcimporter.IImportData(fset, imports, data[1:], path)
+ return pkg, err
+
+ case 'u':
+ // unified, produced by cmd/compile since go1.20
+ _, pkg, err := gcimporter.UImportData(fset, imports, data[1:], path)
+ return pkg, err
+
+ default:
+ l := min(len(data), 10)
+ return nil, fmt.Errorf("unexpected export data with prefix %q for path %s", string(data[:l]), path)
+ }
+ }
+ return nil, fmt.Errorf("empty export data for %s", path)
+}
+
+// Write writes encoded type information for the specified package to out.
+// The FileSet provides file position information for named objects.
+func Write(out io.Writer, fset *token.FileSet, pkg *types.Package) error {
+ if _, err := io.WriteString(out, "i"); err != nil {
+ return err
+ }
+ return gcimporter.IExportData(out, fset, pkg)
+}
+
+// ReadBundle reads an export bundle from in, decodes it, and returns type
+// information for the packages.
+// File position information is added to fset.
+//
+// ReadBundle may inspect and add to the imports map to ensure that references
+// within the export bundle to other packages are consistent.
+//
+// On return, the state of the reader is undefined.
+//
+// Experimental: This API is experimental and may change in the future.
+func ReadBundle(in io.Reader, fset *token.FileSet, imports map[string]*types.Package) ([]*types.Package, error) {
+ data, err := readAll(in)
+ if err != nil {
+ return nil, fmt.Errorf("reading export bundle: %v", err)
+ }
+ return gcimporter.IImportBundle(fset, imports, data)
+}
+
+// WriteBundle writes encoded type information for the specified packages to out.
+// The FileSet provides file position information for named objects.
+//
+// Experimental: This API is experimental and may change in the future.
+func WriteBundle(out io.Writer, fset *token.FileSet, pkgs []*types.Package) error {
+ return gcimporter.IExportBundle(out, fset, pkgs)
+}
diff --git a/vendor/golang.org/x/tools/go/gcexportdata/importer.go b/vendor/golang.org/x/tools/go/gcexportdata/importer.go
new file mode 100644
index 00000000..37a7247e
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/gcexportdata/importer.go
@@ -0,0 +1,75 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gcexportdata
+
+import (
+ "fmt"
+ "go/token"
+ "go/types"
+ "os"
+)
+
+// NewImporter returns a new instance of the types.Importer interface
+// that reads type information from export data files written by gc.
+// The Importer also satisfies types.ImporterFrom.
+//
+// Export data files are located using "go build" workspace conventions
+// and the build.Default context.
+//
+// Use this importer instead of go/importer.For("gc", ...) to avoid the
+// version-skew problems described in the documentation of this package,
+// or to control the FileSet or access the imports map populated during
+// package loading.
+//
+// Deprecated: Use the higher-level API in golang.org/x/tools/go/packages,
+// which is more efficient.
+func NewImporter(fset *token.FileSet, imports map[string]*types.Package) types.ImporterFrom {
+ return importer{fset, imports}
+}
+
+type importer struct {
+ fset *token.FileSet
+ imports map[string]*types.Package
+}
+
+func (imp importer) Import(importPath string) (*types.Package, error) {
+ return imp.ImportFrom(importPath, "", 0)
+}
+
+func (imp importer) ImportFrom(importPath, srcDir string, mode types.ImportMode) (_ *types.Package, err error) {
+ filename, path := Find(importPath, srcDir)
+ if filename == "" {
+ if importPath == "unsafe" {
+ // Even for unsafe, call Find first in case
+ // the package was vendored.
+ return types.Unsafe, nil
+ }
+ return nil, fmt.Errorf("can't find import: %s", importPath)
+ }
+
+ if pkg, ok := imp.imports[path]; ok && pkg.Complete() {
+ return pkg, nil // cache hit
+ }
+
+ // open file
+ f, err := os.Open(filename)
+ if err != nil {
+ return nil, err
+ }
+ defer func() {
+ f.Close()
+ if err != nil {
+ // add file name to error
+ err = fmt.Errorf("reading export data: %s: %v", filename, err)
+ }
+ }()
+
+ r, err := NewReader(f)
+ if err != nil {
+ return nil, err
+ }
+
+ return Read(r, imp.fset, imp.imports, path)
+}
diff --git a/vendor/golang.org/x/tools/go/packages/doc.go b/vendor/golang.org/x/tools/go/packages/doc.go
new file mode 100644
index 00000000..366aab6b
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/doc.go
@@ -0,0 +1,253 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package packages loads Go packages for inspection and analysis.
+
+The [Load] function takes as input a list of patterns and returns a
+list of [Package] values describing individual packages matched by those
+patterns.
+A [Config] specifies configuration options, the most important of which is
+the [LoadMode], which controls the amount of detail in the loaded packages.
+
+Load passes most patterns directly to the underlying build tool.
+The default build tool is the go command.
+Its supported patterns are described at
+https://pkg.go.dev/cmd/go#hdr-Package_lists_and_patterns.
+Other build systems may be supported by providing a "driver";
+see [The driver protocol].
+
+All patterns with the prefix "query=", where query is a
+non-empty string of letters from [a-z], are reserved and may be
+interpreted as query operators.
+
+Two query operators are currently supported: "file" and "pattern".
+
+The query "file=path/to/file.go" matches the package or packages enclosing
+the Go source file path/to/file.go. For example "file=~/go/src/fmt/print.go"
+might return the packages "fmt" and "fmt [fmt.test]".
+
+The query "pattern=string" causes "string" to be passed directly to
+the underlying build tool. In most cases this is unnecessary,
+but an application can use Load("pattern=" + x) as an escaping mechanism
+to ensure that x is not interpreted as a query operator if it contains '='.
+
+All other query operators are reserved for future use and currently
+cause Load to report an error.
+
+The Package struct provides basic information about the package, including
+
+ - ID, a unique identifier for the package in the returned set;
+ - GoFiles, the names of the package's Go source files;
+ - Imports, a map from source import strings to the Packages they name;
+ - Types, the type information for the package's exported symbols;
+ - Syntax, the parsed syntax trees for the package's source code; and
+ - TypesInfo, the result of a complete type-check of the package syntax trees.
+
+(See the documentation for type Package for the complete list of fields
+and more detailed descriptions.)
+
+For example,
+
+ Load(nil, "bytes", "unicode...")
+
+returns four Package structs describing the standard library packages
+bytes, unicode, unicode/utf16, and unicode/utf8. Note that one pattern
+can match multiple packages and that a package might be matched by
+multiple patterns: in general it is not possible to determine which
+packages correspond to which patterns.
+
+Note that the list returned by Load contains only the packages matched
+by the patterns. Their dependencies can be found by walking the import
+graph using the Imports fields.
+
+The Load function can be configured by passing a pointer to a Config as
+the first argument. A nil Config is equivalent to the zero Config, which
+causes Load to run in [LoadFiles] mode, collecting minimal information.
+See the documentation for type Config for details.
+
+As noted earlier, the Config.Mode controls the amount of detail
+reported about the loaded packages. See the documentation for type LoadMode
+for details.
+
+Most tools should pass their command-line arguments (after any flags)
+uninterpreted to Load, so that it can interpret them
+according to the conventions of the underlying build system.
+
+See the Example function for typical usage.
+See also [golang.org/x/tools/go/packages/internal/linecount]
+for an example application.
+
+# The driver protocol
+
+Load may be used to load Go packages even in Go projects that use
+alternative build systems, by installing an appropriate "driver"
+program for the build system and specifying its location in the
+GOPACKAGESDRIVER environment variable.
+For example,
+https://github.com/bazelbuild/rules_go/wiki/Editor-and-tool-integration
+explains how to use the driver for Bazel.
+
+The driver program is responsible for interpreting patterns in its
+preferred notation and reporting information about the packages that
+those patterns identify. Drivers must also support the special "file="
+and "pattern=" patterns described above.
+
+The patterns are provided as positional command-line arguments. A
+JSON-encoded [DriverRequest] message providing additional information
+is written to the driver's standard input. The driver must write a
+JSON-encoded [DriverResponse] message to its standard output. (This
+message differs from the JSON schema produced by 'go list'.)
+
+The value of the PWD environment variable seen by the driver process
+is the preferred name of its working directory. (The working directory
+may have other aliases due to symbolic links; see the comment on the
+Dir field of [exec.Cmd] for related information.)
+When the driver process emits in its response the name of a file
+that is a descendant of this directory, it must use an absolute path
+that has the value of PWD as a prefix, to ensure that the returned
+filenames satisfy the original query.
+*/
+package packages // import "golang.org/x/tools/go/packages"
+
+/*
+
+Motivation and design considerations
+
+The new package's design solves problems addressed by two existing
+packages: go/build, which locates and describes packages, and
+golang.org/x/tools/go/loader, which loads, parses and type-checks them.
+The go/build.Package structure encodes too much of the 'go build' way
+of organizing projects, leaving us in need of a data type that describes a
+package of Go source code independent of the underlying build system.
+We wanted something that works equally well with go build and vgo, and
+also other build systems such as Bazel and Blaze, making it possible to
+construct analysis tools that work in all these environments.
+Tools such as errcheck and staticcheck were essentially unavailable to
+the Go community at Google, and some of Google's internal tools for Go
+are unavailable externally.
+This new package provides a uniform way to obtain package metadata by
+querying each of these build systems, optionally supporting their
+preferred command-line notations for packages, so that tools integrate
+neatly with users' build environments. The Metadata query function
+executes an external query tool appropriate to the current workspace.
+
+Loading packages always returns the complete import graph "all the way down",
+even if all you want is information about a single package, because the query
+mechanisms of all the build systems we currently support ({go,vgo} list, and
+blaze/bazel aspect-based query) cannot provide detailed information
+about one package without visiting all its dependencies too, so there is
+no additional asymptotic cost to providing transitive information.
+(This property might not be true of a hypothetical 5th build system.)
+
+In calls to TypeCheck, all initial packages, and any package that
+transitively depends on one of them, must be loaded from source.
+Consider A->B->C->D->E: if A,C are initial, A,B,C must be loaded from
+source; D may be loaded from export data, and E may not be loaded at all
+(though it's possible that D's export data mentions it, so a
+types.Package may be created for it and exposed.)
+
+The old loader had a feature to suppress type-checking of function
+bodies on a per-package basis, primarily intended to reduce the work of
+obtaining type information for imported packages. Now that imports are
+satisfied by export data, the optimization no longer seems necessary.
+
+Despite some early attempts, the old loader did not exploit export data,
+instead always using the equivalent of WholeProgram mode. This was due
+to the complexity of mixing source and export data packages (now
+resolved by the upward traversal mentioned above), and because export data
+files were nearly always missing or stale. Now that 'go build' supports
+caching, all the underlying build systems can guarantee to produce
+export data in a reasonable (amortized) time.
+
+Test "main" packages synthesized by the build system are now reported as
+first-class packages, avoiding the need for clients (such as go/ssa) to
+reinvent this generation logic.
+
+One way in which go/packages is simpler than the old loader is in its
+treatment of in-package tests. In-package tests are packages that
+consist of all the files of the library under test, plus the test files.
+The old loader constructed in-package tests by a two-phase process of
+mutation called "augmentation": first it would construct and type check
+all the ordinary library packages and type-check the packages that
+depend on them; then it would add more (test) files to the package and
+type-check again. This two-phase approach had four major problems:
+1) in processing the tests, the loader modified the library package,
+ leaving no way for a client application to see both the test
+ package and the library package; one would mutate into the other.
+2) because test files can declare additional methods on types defined in
+ the library portion of the package, the dispatch of method calls in
+ the library portion was affected by the presence of the test files.
+ This should have been a clue that the packages were logically
+ different.
+3) this model of "augmentation" assumed at most one in-package test
+ per library package, which is true of projects using 'go build',
+ but not other build systems.
+4) because of the two-phase nature of test processing, all packages that
+ import the library package had to be processed before augmentation,
+ forcing a "one-shot" API and preventing the client from calling Load
+ in several times in sequence as is now possible in WholeProgram mode.
+ (TypeCheck mode has a similar one-shot restriction for a different reason.)
+
+Early drafts of this package supported "multi-shot" operation.
+Although it allowed clients to make a sequence of calls (or concurrent
+calls) to Load, building up the graph of Packages incrementally,
+it was of marginal value: it complicated the API
+(since it allowed some options to vary across calls but not others),
+it complicated the implementation,
+it cannot be made to work in Types mode, as explained above,
+and it was less efficient than making one combined call (when this is possible).
+Among the clients we have inspected, none made multiple calls to load
+but could not be easily and satisfactorily modified to make only a single call.
+However, applications changes may be required.
+For example, the ssadump command loads the user-specified packages
+and in addition the runtime package. It is tempting to simply append
+"runtime" to the user-provided list, but that does not work if the user
+specified an ad-hoc package such as [a.go b.go].
+Instead, ssadump no longer requests the runtime package,
+but seeks it among the dependencies of the user-specified packages,
+and emits an error if it is not found.
+
+Questions & Tasks
+
+- Add GOARCH/GOOS?
+ They are not portable concepts, but could be made portable.
+ Our goal has been to allow users to express themselves using the conventions
+ of the underlying build system: if the build system honors GOARCH
+ during a build and during a metadata query, then so should
+ applications built atop that query mechanism.
+ Conversely, if the target architecture of the build is determined by
+ command-line flags, the application can pass the relevant
+ flags through to the build system using a command such as:
+ myapp -query_flag="--cpu=amd64" -query_flag="--os=darwin"
+ However, this approach is low-level, unwieldy, and non-portable.
+ GOOS and GOARCH seem important enough to warrant a dedicated option.
+
+- How should we handle partial failures such as a mixture of good and
+ malformed patterns, existing and non-existent packages, successful and
+ failed builds, import failures, import cycles, and so on, in a call to
+ Load?
+
+- Support bazel, blaze, and go1.10 list, not just go1.11 list.
+
+- Handle (and test) various partial success cases, e.g.
+ a mixture of good packages and:
+ invalid patterns
+ nonexistent packages
+ empty packages
+ packages with malformed package or import declarations
+ unreadable files
+ import cycles
+ other parse errors
+ type errors
+ Make sure we record errors at the correct place in the graph.
+
+- Missing packages among initial arguments are not reported.
+ Return bogus packages for them, like golist does.
+
+- "undeclared name" errors (for example) are reported out of source file
+ order. I suspect this is due to the breadth-first resolution now used
+ by go/types. Is that a bug? Discuss with gri.
+
+*/
diff --git a/vendor/golang.org/x/tools/go/packages/external.go b/vendor/golang.org/x/tools/go/packages/external.go
new file mode 100644
index 00000000..f37bc651
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/external.go
@@ -0,0 +1,153 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package packages
+
+// This file defines the protocol that enables an external "driver"
+// tool to supply package metadata in place of 'go list'.
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "os"
+ "os/exec"
+ "slices"
+ "strings"
+)
+
+// DriverRequest defines the schema of a request for package metadata
+// from an external driver program. The JSON-encoded DriverRequest
+// message is provided to the driver program's standard input. The
+// query patterns are provided as command-line arguments.
+//
+// See the package documentation for an overview.
+type DriverRequest struct {
+ Mode LoadMode `json:"mode"`
+
+ // Env specifies the environment the underlying build system should be run in.
+ Env []string `json:"env"`
+
+ // BuildFlags are flags that should be passed to the underlying build system.
+ BuildFlags []string `json:"build_flags"`
+
+ // Tests specifies whether the patterns should also return test packages.
+ Tests bool `json:"tests"`
+
+ // Overlay maps file paths (relative to the driver's working directory)
+ // to the contents of overlay files (see Config.Overlay).
+ Overlay map[string][]byte `json:"overlay"`
+}
+
+// DriverResponse defines the schema of a response from an external
+// driver program, providing the results of a query for package
+// metadata. The driver program must write a JSON-encoded
+// DriverResponse message to its standard output.
+//
+// See the package documentation for an overview.
+type DriverResponse struct {
+ // NotHandled is returned if the request can't be handled by the current
+ // driver. If an external driver returns a response with NotHandled, the
+ // rest of the DriverResponse is ignored, and go/packages will fallback
+ // to the next driver. If go/packages is extended in the future to support
+ // lists of multiple drivers, go/packages will fall back to the next driver.
+ NotHandled bool
+
+ // Compiler and Arch are the arguments pass of types.SizesFor
+ // to get a types.Sizes to use when type checking.
+ Compiler string
+ Arch string
+
+ // Roots is the set of package IDs that make up the root packages.
+ // We have to encode this separately because when we encode a single package
+ // we cannot know if it is one of the roots as that requires knowledge of the
+ // graph it is part of.
+ Roots []string `json:",omitempty"`
+
+ // Packages is the full set of packages in the graph.
+ // The packages are not connected into a graph.
+ // The Imports if populated will be stubs that only have their ID set.
+ // Imports will be connected and then type and syntax information added in a
+ // later pass (see refine).
+ Packages []*Package
+
+ // GoVersion is the minor version number used by the driver
+ // (e.g. the go command on the PATH) when selecting .go files.
+ // Zero means unknown.
+ GoVersion int
+}
+
+// driver is the type for functions that query the build system for the
+// packages named by the patterns.
+type driver func(cfg *Config, patterns []string) (*DriverResponse, error)
+
+// findExternalDriver returns the file path of a tool that supplies
+// the build system package structure, or "" if not found.
+// If GOPACKAGESDRIVER is set in the environment findExternalTool returns its
+// value, otherwise it searches for a binary named gopackagesdriver on the PATH.
+func findExternalDriver(cfg *Config) driver {
+ const toolPrefix = "GOPACKAGESDRIVER="
+ tool := ""
+ for _, env := range cfg.Env {
+ if val, ok := strings.CutPrefix(env, toolPrefix); ok {
+ tool = val
+ }
+ }
+ if tool != "" && tool == "off" {
+ return nil
+ }
+ if tool == "" {
+ var err error
+ tool, err = exec.LookPath("gopackagesdriver")
+ if err != nil {
+ return nil
+ }
+ }
+ return func(cfg *Config, patterns []string) (*DriverResponse, error) {
+ req, err := json.Marshal(DriverRequest{
+ Mode: cfg.Mode,
+ Env: cfg.Env,
+ BuildFlags: cfg.BuildFlags,
+ Tests: cfg.Tests,
+ Overlay: cfg.Overlay,
+ })
+ if err != nil {
+ return nil, fmt.Errorf("failed to encode message to driver tool: %v", err)
+ }
+
+ buf := new(bytes.Buffer)
+ stderr := new(bytes.Buffer)
+ cmd := exec.CommandContext(cfg.Context, tool, patterns...)
+ cmd.Dir = cfg.Dir
+ // The cwd gets resolved to the real path. On Darwin, where
+ // /tmp is a symlink, this breaks anything that expects the
+ // working directory to keep the original path, including the
+ // go command when dealing with modules.
+ //
+ // os.Getwd stdlib has a special feature where if the
+ // cwd and the PWD are the same node then it trusts
+ // the PWD, so by setting it in the env for the child
+ // process we fix up all the paths returned by the go
+ // command.
+ //
+ // (See similar trick in Invocation.run in ../../internal/gocommand/invoke.go)
+ cmd.Env = append(slices.Clip(cfg.Env), "PWD="+cfg.Dir)
+ cmd.Stdin = bytes.NewReader(req)
+ cmd.Stdout = buf
+ cmd.Stderr = stderr
+
+ if err := cmd.Run(); err != nil {
+ return nil, fmt.Errorf("%v: %v: %s", tool, err, cmd.Stderr)
+ }
+ if len(stderr.Bytes()) != 0 && os.Getenv("GOPACKAGESPRINTDRIVERERRORS") != "" {
+ fmt.Fprintf(os.Stderr, "%s stderr: <<%s>>\n", cmdDebugStr(cmd), stderr)
+ }
+
+ var response DriverResponse
+ if err := json.Unmarshal(buf.Bytes(), &response); err != nil {
+ return nil, err
+ }
+ return &response, nil
+ }
+}
diff --git a/vendor/golang.org/x/tools/go/packages/golist.go b/vendor/golang.org/x/tools/go/packages/golist.go
new file mode 100644
index 00000000..89f89dd2
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/golist.go
@@ -0,0 +1,1092 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package packages
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "log"
+ "os"
+ "os/exec"
+ "path"
+ "path/filepath"
+ "reflect"
+ "sort"
+ "strconv"
+ "strings"
+ "sync"
+ "unicode"
+
+ "golang.org/x/tools/internal/gocommand"
+ "golang.org/x/tools/internal/packagesinternal"
+)
+
+// debug controls verbose logging.
+var debug, _ = strconv.ParseBool(os.Getenv("GOPACKAGESDEBUG"))
+
+// A goTooOldError reports that the go command
+// found by exec.LookPath is too old to use the new go list behavior.
+type goTooOldError struct {
+ error
+}
+
+// responseDeduper wraps a DriverResponse, deduplicating its contents.
+type responseDeduper struct {
+ seenRoots map[string]bool
+ seenPackages map[string]*Package
+ dr *DriverResponse
+}
+
+func newDeduper() *responseDeduper {
+ return &responseDeduper{
+ dr: &DriverResponse{},
+ seenRoots: map[string]bool{},
+ seenPackages: map[string]*Package{},
+ }
+}
+
+// addAll fills in r with a DriverResponse.
+func (r *responseDeduper) addAll(dr *DriverResponse) {
+ for _, pkg := range dr.Packages {
+ r.addPackage(pkg)
+ }
+ for _, root := range dr.Roots {
+ r.addRoot(root)
+ }
+ r.dr.GoVersion = dr.GoVersion
+}
+
+func (r *responseDeduper) addPackage(p *Package) {
+ if r.seenPackages[p.ID] != nil {
+ return
+ }
+ r.seenPackages[p.ID] = p
+ r.dr.Packages = append(r.dr.Packages, p)
+}
+
+func (r *responseDeduper) addRoot(id string) {
+ if r.seenRoots[id] {
+ return
+ }
+ r.seenRoots[id] = true
+ r.dr.Roots = append(r.dr.Roots, id)
+}
+
+type golistState struct {
+ cfg *Config
+ ctx context.Context
+
+ runner *gocommand.Runner
+
+ // overlay is the JSON file that encodes the Config.Overlay
+ // mapping, used by 'go list -overlay=...'.
+ overlay string
+
+ envOnce sync.Once
+ goEnvError error
+ goEnv map[string]string
+
+ rootsOnce sync.Once
+ rootDirsError error
+ rootDirs map[string]string
+
+ goVersionOnce sync.Once
+ goVersionError error
+ goVersion int // The X in Go 1.X.
+
+ // vendorDirs caches the (non)existence of vendor directories.
+ vendorDirs map[string]bool
+}
+
+// getEnv returns Go environment variables. Only specific variables are
+// populated -- computing all of them is slow.
+func (state *golistState) getEnv() (map[string]string, error) {
+ state.envOnce.Do(func() {
+ var b *bytes.Buffer
+ b, state.goEnvError = state.invokeGo("env", "-json", "GOMOD", "GOPATH")
+ if state.goEnvError != nil {
+ return
+ }
+
+ state.goEnv = make(map[string]string)
+ decoder := json.NewDecoder(b)
+ if state.goEnvError = decoder.Decode(&state.goEnv); state.goEnvError != nil {
+ return
+ }
+ })
+ return state.goEnv, state.goEnvError
+}
+
+// mustGetEnv is a convenience function that can be used if getEnv has already succeeded.
+func (state *golistState) mustGetEnv() map[string]string {
+ env, err := state.getEnv()
+ if err != nil {
+ panic(fmt.Sprintf("mustGetEnv: %v", err))
+ }
+ return env
+}
+
+// goListDriver uses the go list command to interpret the patterns and produce
+// the build system package structure.
+// See driver for more details.
+//
+// overlay is the JSON file that encodes the cfg.Overlay
+// mapping, used by 'go list -overlay=...'
+func goListDriver(cfg *Config, runner *gocommand.Runner, overlay string, patterns []string) (_ *DriverResponse, err error) {
+ // Make sure that any asynchronous go commands are killed when we return.
+ parentCtx := cfg.Context
+ if parentCtx == nil {
+ parentCtx = context.Background()
+ }
+ ctx, cancel := context.WithCancel(parentCtx)
+ defer cancel()
+
+ response := newDeduper()
+
+ state := &golistState{
+ cfg: cfg,
+ ctx: ctx,
+ vendorDirs: map[string]bool{},
+ overlay: overlay,
+ runner: runner,
+ }
+
+ // Fill in response.Sizes asynchronously if necessary.
+ if cfg.Mode&NeedTypesSizes != 0 || cfg.Mode&(NeedTypes|NeedTypesInfo) != 0 {
+ errCh := make(chan error)
+ go func() {
+ compiler, arch, err := getSizesForArgs(ctx, state.cfgInvocation(), runner)
+ response.dr.Compiler = compiler
+ response.dr.Arch = arch
+ errCh <- err
+ }()
+ defer func() {
+ if sizesErr := <-errCh; sizesErr != nil {
+ err = sizesErr
+ }
+ }()
+ }
+
+ // Determine files requested in contains patterns
+ var containFiles []string
+ restPatterns := make([]string, 0, len(patterns))
+ // Extract file= and other [querytype]= patterns. Report an error if querytype
+ // doesn't exist.
+extractQueries:
+ for _, pattern := range patterns {
+ eqidx := strings.Index(pattern, "=")
+ if eqidx < 0 {
+ restPatterns = append(restPatterns, pattern)
+ } else {
+ query, value := pattern[:eqidx], pattern[eqidx+len("="):]
+ switch query {
+ case "file":
+ containFiles = append(containFiles, value)
+ case "pattern":
+ restPatterns = append(restPatterns, value)
+ case "": // not a reserved query
+ restPatterns = append(restPatterns, pattern)
+ default:
+ for _, rune := range query {
+ if rune < 'a' || rune > 'z' { // not a reserved query
+ restPatterns = append(restPatterns, pattern)
+ continue extractQueries
+ }
+ }
+ // Reject all other patterns containing "="
+ return nil, fmt.Errorf("invalid query type %q in query pattern %q", query, pattern)
+ }
+ }
+ }
+
+ // See if we have any patterns to pass through to go list. Zero initial
+ // patterns also requires a go list call, since it's the equivalent of
+ // ".".
+ if len(restPatterns) > 0 || len(patterns) == 0 {
+ dr, err := state.createDriverResponse(restPatterns...)
+ if err != nil {
+ return nil, err
+ }
+ response.addAll(dr)
+ }
+
+ if len(containFiles) != 0 {
+ if err := state.runContainsQueries(response, containFiles); err != nil {
+ return nil, err
+ }
+ }
+
+ // (We may yet return an error due to defer.)
+ return response.dr, nil
+}
+
+// abs returns an absolute representation of path, based on cfg.Dir.
+func (cfg *Config) abs(path string) (string, error) {
+ if filepath.IsAbs(path) {
+ return path, nil
+ }
+ // In case cfg.Dir is relative, pass it to filepath.Abs.
+ return filepath.Abs(filepath.Join(cfg.Dir, path))
+}
+
+func (state *golistState) runContainsQueries(response *responseDeduper, queries []string) error {
+ for _, query := range queries {
+ // TODO(matloob): Do only one query per directory.
+ fdir := filepath.Dir(query)
+ // Pass absolute path of directory to go list so that it knows to treat it as a directory,
+ // not a package path.
+ pattern, err := state.cfg.abs(fdir)
+ if err != nil {
+ return fmt.Errorf("could not determine absolute path of file= query path %q: %v", query, err)
+ }
+ dirResponse, err := state.createDriverResponse(pattern)
+
+ // If there was an error loading the package, or no packages are returned,
+ // or the package is returned with errors, try to load the file as an
+ // ad-hoc package.
+ // Usually the error will appear in a returned package, but may not if we're
+ // in module mode and the ad-hoc is located outside a module.
+ if err != nil || len(dirResponse.Packages) == 0 || len(dirResponse.Packages) == 1 && len(dirResponse.Packages[0].GoFiles) == 0 &&
+ len(dirResponse.Packages[0].Errors) == 1 {
+ var queryErr error
+ if dirResponse, queryErr = state.adhocPackage(pattern, query); queryErr != nil {
+ return err // return the original error
+ }
+ }
+ isRoot := make(map[string]bool, len(dirResponse.Roots))
+ for _, root := range dirResponse.Roots {
+ isRoot[root] = true
+ }
+ for _, pkg := range dirResponse.Packages {
+ // Add any new packages to the main set
+ // We don't bother to filter packages that will be dropped by the changes of roots,
+ // that will happen anyway during graph construction outside this function.
+ // Over-reporting packages is not a problem.
+ response.addPackage(pkg)
+ // if the package was not a root one, it cannot have the file
+ if !isRoot[pkg.ID] {
+ continue
+ }
+ for _, pkgFile := range pkg.GoFiles {
+ if filepath.Base(query) == filepath.Base(pkgFile) {
+ response.addRoot(pkg.ID)
+ break
+ }
+ }
+ }
+ }
+ return nil
+}
+
+// adhocPackage attempts to load or construct an ad-hoc package for a given
+// query, if the original call to the driver produced inadequate results.
+func (state *golistState) adhocPackage(pattern, query string) (*DriverResponse, error) {
+ response, err := state.createDriverResponse(query)
+ if err != nil {
+ return nil, err
+ }
+ // If we get nothing back from `go list`,
+ // try to make this file into its own ad-hoc package.
+ // TODO(rstambler): Should this check against the original response?
+ if len(response.Packages) == 0 {
+ response.Packages = append(response.Packages, &Package{
+ ID: "command-line-arguments",
+ PkgPath: query,
+ GoFiles: []string{query},
+ CompiledGoFiles: []string{query},
+ Imports: make(map[string]*Package),
+ })
+ response.Roots = append(response.Roots, "command-line-arguments")
+ }
+ // Handle special cases.
+ if len(response.Packages) == 1 {
+ // golang/go#33482: If this is a file= query for ad-hoc packages where
+ // the file only exists on an overlay, and exists outside of a module,
+ // add the file to the package and remove the errors.
+ if response.Packages[0].ID == "command-line-arguments" ||
+ filepath.ToSlash(response.Packages[0].PkgPath) == filepath.ToSlash(query) {
+ if len(response.Packages[0].GoFiles) == 0 {
+ filename := filepath.Join(pattern, filepath.Base(query)) // avoid recomputing abspath
+ // TODO(matloob): check if the file is outside of a root dir?
+ for path := range state.cfg.Overlay {
+ if path == filename {
+ response.Packages[0].Errors = nil
+ response.Packages[0].GoFiles = []string{path}
+ response.Packages[0].CompiledGoFiles = []string{path}
+ }
+ }
+ }
+ }
+ }
+ return response, nil
+}
+
+// Fields must match go list;
+// see $GOROOT/src/cmd/go/internal/load/pkg.go.
+type jsonPackage struct {
+ ImportPath string
+ Dir string
+ Name string
+ Target string
+ Export string
+ GoFiles []string
+ CompiledGoFiles []string
+ IgnoredGoFiles []string
+ IgnoredOtherFiles []string
+ EmbedPatterns []string
+ EmbedFiles []string
+ CFiles []string
+ CgoFiles []string
+ CXXFiles []string
+ MFiles []string
+ HFiles []string
+ FFiles []string
+ SFiles []string
+ SwigFiles []string
+ SwigCXXFiles []string
+ SysoFiles []string
+ Imports []string
+ ImportMap map[string]string
+ Deps []string
+ Module *Module
+ TestGoFiles []string
+ TestImports []string
+ XTestGoFiles []string
+ XTestImports []string
+ ForTest string // q in a "p [q.test]" package, else ""
+ DepOnly bool
+
+ Error *packagesinternal.PackageError
+ DepsErrors []*packagesinternal.PackageError
+}
+
+type jsonPackageError struct {
+ ImportStack []string
+ Pos string
+ Err string
+}
+
+func otherFiles(p *jsonPackage) [][]string {
+ return [][]string{p.CFiles, p.CXXFiles, p.MFiles, p.HFiles, p.FFiles, p.SFiles, p.SwigFiles, p.SwigCXXFiles, p.SysoFiles}
+}
+
+// createDriverResponse uses the "go list" command to expand the pattern
+// words and return a response for the specified packages.
+func (state *golistState) createDriverResponse(words ...string) (*DriverResponse, error) {
+ // go list uses the following identifiers in ImportPath and Imports:
+ //
+ // "p" -- importable package or main (command)
+ // "q.test" -- q's test executable
+ // "p [q.test]" -- variant of p as built for q's test executable
+ // "q_test [q.test]" -- q's external test package
+ //
+ // The packages p that are built differently for a test q.test
+ // are q itself, plus any helpers used by the external test q_test,
+ // typically including "testing" and all its dependencies.
+
+ // Run "go list" for complete
+ // information on the specified packages.
+ goVersion, err := state.getGoVersion()
+ if err != nil {
+ return nil, err
+ }
+ buf, err := state.invokeGo("list", golistargs(state.cfg, words, goVersion)...)
+ if err != nil {
+ return nil, err
+ }
+
+ seen := make(map[string]*jsonPackage)
+ pkgs := make(map[string]*Package)
+ additionalErrors := make(map[string][]Error)
+ // Decode the JSON and convert it to Package form.
+ response := &DriverResponse{
+ GoVersion: goVersion,
+ }
+ for dec := json.NewDecoder(buf); dec.More(); {
+ p := new(jsonPackage)
+ if err := dec.Decode(p); err != nil {
+ return nil, fmt.Errorf("JSON decoding failed: %v", err)
+ }
+
+ if p.ImportPath == "" {
+ // The documentation for go list says that “[e]rroneous packages will have
+ // a non-empty ImportPath”. If for some reason it comes back empty, we
+ // prefer to error out rather than silently discarding data or handing
+ // back a package without any way to refer to it.
+ if p.Error != nil {
+ return nil, Error{
+ Pos: p.Error.Pos,
+ Msg: p.Error.Err,
+ }
+ }
+ return nil, fmt.Errorf("package missing import path: %+v", p)
+ }
+
+ // Work around https://golang.org/issue/33157:
+ // go list -e, when given an absolute path, will find the package contained at
+ // that directory. But when no package exists there, it will return a fake package
+ // with an error and the ImportPath set to the absolute path provided to go list.
+ // Try to convert that absolute path to what its package path would be if it's
+ // contained in a known module or GOPATH entry. This will allow the package to be
+ // properly "reclaimed" when overlays are processed.
+ if filepath.IsAbs(p.ImportPath) && p.Error != nil {
+ pkgPath, ok, err := state.getPkgPath(p.ImportPath)
+ if err != nil {
+ return nil, err
+ }
+ if ok {
+ p.ImportPath = pkgPath
+ }
+ }
+
+ if old, found := seen[p.ImportPath]; found {
+ // If one version of the package has an error, and the other doesn't, assume
+ // that this is a case where go list is reporting a fake dependency variant
+ // of the imported package: When a package tries to invalidly import another
+ // package, go list emits a variant of the imported package (with the same
+ // import path, but with an error on it, and the package will have a
+ // DepError set on it). An example of when this can happen is for imports of
+ // main packages: main packages can not be imported, but they may be
+ // separately matched and listed by another pattern.
+ // See golang.org/issue/36188 for more details.
+
+ // The plan is that eventually, hopefully in Go 1.15, the error will be
+ // reported on the importing package rather than the duplicate "fake"
+ // version of the imported package. Once all supported versions of Go
+ // have the new behavior this logic can be deleted.
+ // TODO(matloob): delete the workaround logic once all supported versions of
+ // Go return the errors on the proper package.
+
+ // There should be exactly one version of a package that doesn't have an
+ // error.
+ if old.Error == nil && p.Error == nil {
+ if !reflect.DeepEqual(p, old) {
+ return nil, fmt.Errorf("internal error: go list gives conflicting information for package %v", p.ImportPath)
+ }
+ continue
+ }
+
+ // Determine if this package's error needs to be bubbled up.
+ // This is a hack, and we expect for go list to eventually set the error
+ // on the package.
+ if old.Error != nil {
+ var errkind string
+ if strings.Contains(old.Error.Err, "not an importable package") {
+ errkind = "not an importable package"
+ } else if strings.Contains(old.Error.Err, "use of internal package") && strings.Contains(old.Error.Err, "not allowed") {
+ errkind = "use of internal package not allowed"
+ }
+ if errkind != "" {
+ if len(old.Error.ImportStack) < 1 {
+ return nil, fmt.Errorf(`internal error: go list gave a %q error with empty import stack`, errkind)
+ }
+ importingPkg := old.Error.ImportStack[len(old.Error.ImportStack)-1]
+ if importingPkg == old.ImportPath {
+ // Using an older version of Go which put this package itself on top of import
+ // stack, instead of the importer. Look for importer in second from top
+ // position.
+ if len(old.Error.ImportStack) < 2 {
+ return nil, fmt.Errorf(`internal error: go list gave a %q error with an import stack without importing package`, errkind)
+ }
+ importingPkg = old.Error.ImportStack[len(old.Error.ImportStack)-2]
+ }
+ additionalErrors[importingPkg] = append(additionalErrors[importingPkg], Error{
+ Pos: old.Error.Pos,
+ Msg: old.Error.Err,
+ Kind: ListError,
+ })
+ }
+ }
+
+ // Make sure that if there's a version of the package without an error,
+ // that's the one reported to the user.
+ if old.Error == nil {
+ continue
+ }
+
+ // This package will replace the old one at the end of the loop.
+ }
+ seen[p.ImportPath] = p
+
+ pkg := &Package{
+ Name: p.Name,
+ ID: p.ImportPath,
+ Dir: p.Dir,
+ Target: p.Target,
+ GoFiles: absJoin(p.Dir, p.GoFiles, p.CgoFiles),
+ CompiledGoFiles: absJoin(p.Dir, p.CompiledGoFiles),
+ OtherFiles: absJoin(p.Dir, otherFiles(p)...),
+ EmbedFiles: absJoin(p.Dir, p.EmbedFiles),
+ EmbedPatterns: absJoin(p.Dir, p.EmbedPatterns),
+ IgnoredFiles: absJoin(p.Dir, p.IgnoredGoFiles, p.IgnoredOtherFiles),
+ ForTest: p.ForTest,
+ depsErrors: p.DepsErrors,
+ Module: p.Module,
+ }
+
+ if (state.cfg.Mode&typecheckCgo) != 0 && len(p.CgoFiles) != 0 {
+ if len(p.CompiledGoFiles) > len(p.GoFiles) {
+ // We need the cgo definitions, which are in the first
+ // CompiledGoFile after the non-cgo ones. This is a hack but there
+ // isn't currently a better way to find it. We also need the pure
+ // Go files and unprocessed cgo files, all of which are already
+ // in pkg.GoFiles.
+ cgoTypes := p.CompiledGoFiles[len(p.GoFiles)]
+ pkg.CompiledGoFiles = append([]string{cgoTypes}, pkg.GoFiles...)
+ } else {
+ // golang/go#38990: go list silently fails to do cgo processing
+ pkg.CompiledGoFiles = nil
+ pkg.Errors = append(pkg.Errors, Error{
+ Msg: "go list failed to return CompiledGoFiles. This may indicate failure to perform cgo processing; try building at the command line. See https://golang.org/issue/38990.",
+ Kind: ListError,
+ })
+ }
+ }
+
+ // Work around https://golang.org/issue/28749:
+ // cmd/go puts assembly, C, and C++ files in CompiledGoFiles.
+ // Remove files from CompiledGoFiles that are non-go files
+ // (or are not files that look like they are from the cache).
+ if len(pkg.CompiledGoFiles) > 0 {
+ out := pkg.CompiledGoFiles[:0]
+ for _, f := range pkg.CompiledGoFiles {
+ if ext := filepath.Ext(f); ext != ".go" && ext != "" { // ext == "" means the file is from the cache, so probably cgo-processed file
+ continue
+ }
+ out = append(out, f)
+ }
+ pkg.CompiledGoFiles = out
+ }
+
+ // Extract the PkgPath from the package's ID.
+ if i := strings.IndexByte(pkg.ID, ' '); i >= 0 {
+ pkg.PkgPath = pkg.ID[:i]
+ } else {
+ pkg.PkgPath = pkg.ID
+ }
+
+ if pkg.PkgPath == "unsafe" {
+ pkg.CompiledGoFiles = nil // ignore fake unsafe.go file (#59929)
+ } else if len(pkg.CompiledGoFiles) == 0 {
+ // Work around for pre-go.1.11 versions of go list.
+ // TODO(matloob): they should be handled by the fallback.
+ // Can we delete this?
+ pkg.CompiledGoFiles = pkg.GoFiles
+ }
+
+ // Assume go list emits only absolute paths for Dir.
+ if p.Dir != "" && !filepath.IsAbs(p.Dir) {
+ log.Fatalf("internal error: go list returned non-absolute Package.Dir: %s", p.Dir)
+ }
+
+ if p.Export != "" && !filepath.IsAbs(p.Export) {
+ pkg.ExportFile = filepath.Join(p.Dir, p.Export)
+ } else {
+ pkg.ExportFile = p.Export
+ }
+
+ // imports
+ //
+ // Imports contains the IDs of all imported packages.
+ // ImportsMap records (path, ID) only where they differ.
+ ids := make(map[string]bool)
+ for _, id := range p.Imports {
+ ids[id] = true
+ }
+ pkg.Imports = make(map[string]*Package)
+ for path, id := range p.ImportMap {
+ pkg.Imports[path] = &Package{ID: id} // non-identity import
+ delete(ids, id)
+ }
+ for id := range ids {
+ if id == "C" {
+ continue
+ }
+
+ pkg.Imports[id] = &Package{ID: id} // identity import
+ }
+ if !p.DepOnly {
+ response.Roots = append(response.Roots, pkg.ID)
+ }
+
+ // Temporary work-around for golang/go#39986. Parse filenames out of
+ // error messages. This happens if there are unrecoverable syntax
+ // errors in the source, so we can't match on a specific error message.
+ //
+ // TODO(rfindley): remove this heuristic, in favor of considering
+ // InvalidGoFiles from the list driver.
+ if err := p.Error; err != nil && state.shouldAddFilenameFromError(p) {
+ addFilenameFromPos := func(pos string) bool {
+ split := strings.Split(pos, ":")
+ if len(split) < 1 {
+ return false
+ }
+ filename := strings.TrimSpace(split[0])
+ if filename == "" {
+ return false
+ }
+ if !filepath.IsAbs(filename) {
+ filename = filepath.Join(state.cfg.Dir, filename)
+ }
+ info, _ := os.Stat(filename)
+ if info == nil {
+ return false
+ }
+ pkg.CompiledGoFiles = append(pkg.CompiledGoFiles, filename)
+ pkg.GoFiles = append(pkg.GoFiles, filename)
+ return true
+ }
+ found := addFilenameFromPos(err.Pos)
+ // In some cases, go list only reports the error position in the
+ // error text, not the error position. One such case is when the
+ // file's package name is a keyword (see golang.org/issue/39763).
+ if !found {
+ addFilenameFromPos(err.Err)
+ }
+ }
+
+ if p.Error != nil {
+ msg := strings.TrimSpace(p.Error.Err) // Trim to work around golang.org/issue/32363.
+ // Address golang.org/issue/35964 by appending import stack to error message.
+ if msg == "import cycle not allowed" && len(p.Error.ImportStack) != 0 {
+ msg += fmt.Sprintf(": import stack: %v", p.Error.ImportStack)
+ }
+ pkg.Errors = append(pkg.Errors, Error{
+ Pos: p.Error.Pos,
+ Msg: msg,
+ Kind: ListError,
+ })
+ }
+
+ pkgs[pkg.ID] = pkg
+ }
+
+ for id, errs := range additionalErrors {
+ if p, ok := pkgs[id]; ok {
+ p.Errors = append(p.Errors, errs...)
+ }
+ }
+ for _, pkg := range pkgs {
+ response.Packages = append(response.Packages, pkg)
+ }
+ sort.Slice(response.Packages, func(i, j int) bool { return response.Packages[i].ID < response.Packages[j].ID })
+
+ return response, nil
+}
+
+func (state *golistState) shouldAddFilenameFromError(p *jsonPackage) bool {
+ if len(p.GoFiles) > 0 || len(p.CompiledGoFiles) > 0 {
+ return false
+ }
+
+ goV, err := state.getGoVersion()
+ if err != nil {
+ return false
+ }
+
+ // On Go 1.14 and earlier, only add filenames from errors if the import stack is empty.
+ // The import stack behaves differently for these versions than newer Go versions.
+ if goV < 15 {
+ return len(p.Error.ImportStack) == 0
+ }
+
+ // On Go 1.15 and later, only parse filenames out of error if there's no import stack,
+ // or the current package is at the top of the import stack. This is not guaranteed
+ // to work perfectly, but should avoid some cases where files in errors don't belong to this
+ // package.
+ return len(p.Error.ImportStack) == 0 || p.Error.ImportStack[len(p.Error.ImportStack)-1] == p.ImportPath
+}
+
+// getGoVersion returns the effective minor version of the go command.
+func (state *golistState) getGoVersion() (int, error) {
+ state.goVersionOnce.Do(func() {
+ state.goVersion, state.goVersionError = gocommand.GoVersion(state.ctx, state.cfgInvocation(), state.runner)
+ })
+ return state.goVersion, state.goVersionError
+}
+
+// getPkgPath finds the package path of a directory if it's relative to a root
+// directory.
+func (state *golistState) getPkgPath(dir string) (string, bool, error) {
+ if !filepath.IsAbs(dir) {
+ panic("non-absolute dir passed to getPkgPath")
+ }
+ roots, err := state.determineRootDirs()
+ if err != nil {
+ return "", false, err
+ }
+
+ for rdir, rpath := range roots {
+ // Make sure that the directory is in the module,
+ // to avoid creating a path relative to another module.
+ if !strings.HasPrefix(dir, rdir) {
+ continue
+ }
+ // TODO(matloob): This doesn't properly handle symlinks.
+ r, err := filepath.Rel(rdir, dir)
+ if err != nil {
+ continue
+ }
+ if rpath != "" {
+ // We choose only one root even though the directory even it can belong in multiple modules
+ // or GOPATH entries. This is okay because we only need to work with absolute dirs when a
+ // file is missing from disk, for instance when gopls calls go/packages in an overlay.
+ // Once the file is saved, gopls, or the next invocation of the tool will get the correct
+ // result straight from golist.
+ // TODO(matloob): Implement module tiebreaking?
+ return path.Join(rpath, filepath.ToSlash(r)), true, nil
+ }
+ return filepath.ToSlash(r), true, nil
+ }
+ return "", false, nil
+}
+
+// absJoin absolutizes and flattens the lists of files.
+func absJoin(dir string, fileses ...[]string) (res []string) {
+ for _, files := range fileses {
+ for _, file := range files {
+ if !filepath.IsAbs(file) {
+ file = filepath.Join(dir, file)
+ }
+ res = append(res, file)
+ }
+ }
+ return res
+}
+
+func jsonFlag(cfg *Config, goVersion int) string {
+ if goVersion < 19 {
+ return "-json"
+ }
+ var fields []string
+ added := make(map[string]bool)
+ addFields := func(fs ...string) {
+ for _, f := range fs {
+ if !added[f] {
+ added[f] = true
+ fields = append(fields, f)
+ }
+ }
+ }
+ addFields("Name", "ImportPath", "Error") // These fields are always needed
+ if cfg.Mode&NeedFiles != 0 || cfg.Mode&(NeedTypes|NeedTypesInfo) != 0 {
+ addFields("Dir", "GoFiles", "IgnoredGoFiles", "IgnoredOtherFiles", "CFiles",
+ "CgoFiles", "CXXFiles", "MFiles", "HFiles", "FFiles", "SFiles",
+ "SwigFiles", "SwigCXXFiles", "SysoFiles")
+ if cfg.Tests {
+ addFields("TestGoFiles", "XTestGoFiles")
+ }
+ }
+ if cfg.Mode&(NeedTypes|NeedTypesInfo) != 0 {
+ // CompiledGoFiles seems to be required for the test case TestCgoNoSyntax,
+ // even when -compiled isn't passed in.
+ // TODO(#52435): Should we make the test ask for -compiled, or automatically
+ // request CompiledGoFiles in certain circumstances?
+ addFields("Dir", "CompiledGoFiles")
+ }
+ if cfg.Mode&NeedCompiledGoFiles != 0 {
+ addFields("Dir", "CompiledGoFiles", "Export")
+ }
+ if cfg.Mode&NeedImports != 0 {
+ // When imports are requested, DepOnly is used to distinguish between packages
+ // explicitly requested and transitive imports of those packages.
+ addFields("DepOnly", "Imports", "ImportMap")
+ if cfg.Tests {
+ addFields("TestImports", "XTestImports")
+ }
+ }
+ if cfg.Mode&NeedDeps != 0 {
+ addFields("DepOnly")
+ }
+ if usesExportData(cfg) {
+ // Request Dir in the unlikely case Export is not absolute.
+ addFields("Dir", "Export")
+ }
+ if cfg.Mode&NeedForTest != 0 {
+ addFields("ForTest")
+ }
+ if cfg.Mode&needInternalDepsErrors != 0 {
+ addFields("DepsErrors")
+ }
+ if cfg.Mode&NeedModule != 0 {
+ addFields("Module")
+ }
+ if cfg.Mode&NeedEmbedFiles != 0 {
+ addFields("EmbedFiles")
+ }
+ if cfg.Mode&NeedEmbedPatterns != 0 {
+ addFields("EmbedPatterns")
+ }
+ if cfg.Mode&NeedTarget != 0 {
+ addFields("Target")
+ }
+ return "-json=" + strings.Join(fields, ",")
+}
+
+func golistargs(cfg *Config, words []string, goVersion int) []string {
+ const findFlags = NeedImports | NeedTypes | NeedSyntax | NeedTypesInfo
+ fullargs := []string{
+ "-e", jsonFlag(cfg, goVersion),
+ fmt.Sprintf("-compiled=%t", cfg.Mode&(NeedCompiledGoFiles|NeedSyntax|NeedTypes|NeedTypesInfo|NeedTypesSizes) != 0),
+ fmt.Sprintf("-test=%t", cfg.Tests),
+ fmt.Sprintf("-export=%t", usesExportData(cfg)),
+ fmt.Sprintf("-deps=%t", cfg.Mode&NeedImports != 0),
+ // go list doesn't let you pass -test and -find together,
+ // probably because you'd just get the TestMain.
+ fmt.Sprintf("-find=%t", !cfg.Tests && cfg.Mode&findFlags == 0 && !usesExportData(cfg)),
+ }
+
+ // golang/go#60456: with go1.21 and later, go list serves pgo variants, which
+ // can be costly to compute and may result in redundant processing for the
+ // caller. Disable these variants. If someone wants to add e.g. a NeedPGO
+ // mode flag, that should be a separate proposal.
+ if goVersion >= 21 {
+ fullargs = append(fullargs, "-pgo=off")
+ }
+
+ fullargs = append(fullargs, cfg.BuildFlags...)
+ fullargs = append(fullargs, "--")
+ fullargs = append(fullargs, words...)
+ return fullargs
+}
+
+// cfgInvocation returns an Invocation that reflects cfg's settings.
+func (state *golistState) cfgInvocation() gocommand.Invocation {
+ cfg := state.cfg
+ return gocommand.Invocation{
+ BuildFlags: cfg.BuildFlags,
+ CleanEnv: cfg.Env != nil,
+ Env: cfg.Env,
+ Logf: cfg.Logf,
+ WorkingDir: cfg.Dir,
+ Overlay: state.overlay,
+ }
+}
+
+// invokeGo returns the stdout of a go command invocation.
+func (state *golistState) invokeGo(verb string, args ...string) (*bytes.Buffer, error) {
+ cfg := state.cfg
+
+ inv := state.cfgInvocation()
+ inv.Verb = verb
+ inv.Args = args
+
+ stdout, stderr, friendlyErr, err := state.runner.RunRaw(cfg.Context, inv)
+ if err != nil {
+ // Check for 'go' executable not being found.
+ if ee, ok := err.(*exec.Error); ok && ee.Err == exec.ErrNotFound {
+ return nil, fmt.Errorf("'go list' driver requires 'go', but %s", exec.ErrNotFound)
+ }
+
+ exitErr, ok := err.(*exec.ExitError)
+ if !ok {
+ // Catastrophic error:
+ // - context cancellation
+ return nil, fmt.Errorf("couldn't run 'go': %w", err)
+ }
+
+ // Old go version?
+ if strings.Contains(stderr.String(), "flag provided but not defined") {
+ return nil, goTooOldError{fmt.Errorf("unsupported version of go: %s: %s", exitErr, stderr)}
+ }
+
+ // Related to #24854
+ if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "unexpected directory layout") {
+ return nil, friendlyErr
+ }
+
+ // Return an error if 'go list' failed due to missing tools in
+ // $GOROOT/pkg/tool/$GOOS_$GOARCH (#69606).
+ if len(stderr.String()) > 0 && strings.Contains(stderr.String(), `go: no such tool`) {
+ return nil, friendlyErr
+ }
+
+ // Is there an error running the C compiler in cgo? This will be reported in the "Error" field
+ // and should be suppressed by go list -e.
+ //
+ // This condition is not perfect yet because the error message can include other error messages than runtime/cgo.
+ isPkgPathRune := func(r rune) bool {
+ // From https://golang.org/ref/spec#Import_declarations:
+ // Implementation restriction: A compiler may restrict ImportPaths to non-empty strings
+ // using only characters belonging to Unicode's L, M, N, P, and S general categories
+ // (the Graphic characters without spaces) and may also exclude the
+ // characters !"#$%&'()*,:;<=>?[\]^`{|} and the Unicode replacement character U+FFFD.
+ return unicode.IsOneOf([]*unicode.RangeTable{unicode.L, unicode.M, unicode.N, unicode.P, unicode.S}, r) &&
+ !strings.ContainsRune("!\"#$%&'()*,:;<=>?[\\]^`{|}\uFFFD", r)
+ }
+ // golang/go#36770: Handle case where cmd/go prints module download messages before the error.
+ msg := stderr.String()
+ for strings.HasPrefix(msg, "go: downloading") {
+ msg = msg[strings.IndexRune(msg, '\n')+1:]
+ }
+ if len(stderr.String()) > 0 && strings.HasPrefix(stderr.String(), "# ") {
+ msg := msg[len("# "):]
+ if strings.HasPrefix(strings.TrimLeftFunc(msg, isPkgPathRune), "\n") {
+ return stdout, nil
+ }
+ // Treat pkg-config errors as a special case (golang.org/issue/36770).
+ if strings.HasPrefix(msg, "pkg-config") {
+ return stdout, nil
+ }
+ }
+
+ // This error only appears in stderr. See golang.org/cl/166398 for a fix in go list to show
+ // the error in the Err section of stdout in case -e option is provided.
+ // This fix is provided for backwards compatibility.
+ if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "named files must be .go files") {
+ output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
+ strings.Trim(stderr.String(), "\n"))
+ return bytes.NewBufferString(output), nil
+ }
+
+ // Similar to the previous error, but currently lacks a fix in Go.
+ if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "named files must all be in one directory") {
+ output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
+ strings.Trim(stderr.String(), "\n"))
+ return bytes.NewBufferString(output), nil
+ }
+
+ // Backwards compatibility for Go 1.11 because 1.12 and 1.13 put the directory in the ImportPath.
+ // If the package doesn't exist, put the absolute path of the directory into the error message,
+ // as Go 1.13 list does.
+ const noSuchDirectory = "no such directory"
+ if len(stderr.String()) > 0 && strings.Contains(stderr.String(), noSuchDirectory) {
+ errstr := stderr.String()
+ abspath := strings.TrimSpace(errstr[strings.Index(errstr, noSuchDirectory)+len(noSuchDirectory):])
+ output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
+ abspath, strings.Trim(stderr.String(), "\n"))
+ return bytes.NewBufferString(output), nil
+ }
+
+ // Workaround for #29280: go list -e has incorrect behavior when an ad-hoc package doesn't exist.
+ // Note that the error message we look for in this case is different that the one looked for above.
+ if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "no such file or directory") {
+ output := fmt.Sprintf(`{"ImportPath": "command-line-arguments","Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
+ strings.Trim(stderr.String(), "\n"))
+ return bytes.NewBufferString(output), nil
+ }
+
+ // Workaround for #34273. go list -e with GO111MODULE=on has incorrect behavior when listing a
+ // directory outside any module.
+ if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "outside available modules") {
+ output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
+ // TODO(matloob): command-line-arguments isn't correct here.
+ "command-line-arguments", strings.Trim(stderr.String(), "\n"))
+ return bytes.NewBufferString(output), nil
+ }
+
+ // Another variation of the previous error
+ if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "outside module root") {
+ output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
+ // TODO(matloob): command-line-arguments isn't correct here.
+ "command-line-arguments", strings.Trim(stderr.String(), "\n"))
+ return bytes.NewBufferString(output), nil
+ }
+
+ // Workaround for an instance of golang.org/issue/26755: go list -e will return a non-zero exit
+ // status if there's a dependency on a package that doesn't exist. But it should return
+ // a zero exit status and set an error on that package.
+ if len(stderr.String()) > 0 && strings.Contains(stderr.String(), "no Go files in") {
+ // Don't clobber stdout if `go list` actually returned something.
+ if len(stdout.String()) > 0 {
+ return stdout, nil
+ }
+ // try to extract package name from string
+ stderrStr := stderr.String()
+ var importPath string
+ colon := strings.Index(stderrStr, ":")
+ if colon > 0 && strings.HasPrefix(stderrStr, "go build ") {
+ importPath = stderrStr[len("go build "):colon]
+ }
+ output := fmt.Sprintf(`{"ImportPath": %q,"Incomplete": true,"Error": {"Pos": "","Err": %q}}`,
+ importPath, strings.Trim(stderrStr, "\n"))
+ return bytes.NewBufferString(output), nil
+ }
+
+ // Export mode entails a build.
+ // If that build fails, errors appear on stderr
+ // (despite the -e flag) and the Export field is blank.
+ // Do not fail in that case.
+ // The same is true if an ad-hoc package given to go list doesn't exist.
+ // TODO(matloob): Remove these once we can depend on go list to exit with a zero status with -e even when
+ // packages don't exist or a build fails.
+ if !usesExportData(cfg) && !containsGoFile(args) {
+ return nil, friendlyErr
+ }
+ }
+ return stdout, nil
+}
+
+func containsGoFile(s []string) bool {
+ for _, f := range s {
+ if strings.HasSuffix(f, ".go") {
+ return true
+ }
+ }
+ return false
+}
+
+func cmdDebugStr(cmd *exec.Cmd) string {
+ env := make(map[string]string)
+ for _, kv := range cmd.Env {
+ split := strings.SplitN(kv, "=", 2)
+ k, v := split[0], split[1]
+ env[k] = v
+ }
+
+ var args []string
+ for _, arg := range cmd.Args {
+ quoted := strconv.Quote(arg)
+ if quoted[1:len(quoted)-1] != arg || strings.Contains(arg, " ") {
+ args = append(args, quoted)
+ } else {
+ args = append(args, arg)
+ }
+ }
+ return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v GOPROXY=%v PWD=%v %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["GOPROXY"], env["PWD"], strings.Join(args, " "))
+}
+
+// getSizesForArgs queries 'go list' for the appropriate
+// Compiler and GOARCH arguments to pass to [types.SizesFor].
+func getSizesForArgs(ctx context.Context, inv gocommand.Invocation, gocmdRunner *gocommand.Runner) (string, string, error) {
+ inv.Verb = "list"
+ inv.Args = []string{"-f", "{{context.GOARCH}} {{context.Compiler}}", "--", "unsafe"}
+ stdout, stderr, friendlyErr, rawErr := gocmdRunner.RunRaw(ctx, inv)
+ var goarch, compiler string
+ if rawErr != nil {
+ rawErrMsg := rawErr.Error()
+ if strings.Contains(rawErrMsg, "cannot find main module") ||
+ strings.Contains(rawErrMsg, "go.mod file not found") {
+ // User's running outside of a module.
+ // All bets are off. Get GOARCH and guess compiler is gc.
+ // TODO(matloob): Is this a problem in practice?
+ inv.Verb = "env"
+ inv.Args = []string{"GOARCH"}
+ envout, enverr := gocmdRunner.Run(ctx, inv)
+ if enverr != nil {
+ return "", "", enverr
+ }
+ goarch = strings.TrimSpace(envout.String())
+ compiler = "gc"
+ } else if friendlyErr != nil {
+ return "", "", friendlyErr
+ } else {
+ // This should be unreachable, but be defensive
+ // in case RunRaw's error results are inconsistent.
+ return "", "", rawErr
+ }
+ } else {
+ fields := strings.Fields(stdout.String())
+ if len(fields) < 2 {
+ return "", "", fmt.Errorf("could not parse GOARCH and Go compiler in format \" \":\nstdout: <<%s>>\nstderr: <<%s>>",
+ stdout.String(), stderr.String())
+ }
+ goarch = fields[0]
+ compiler = fields[1]
+ }
+ return compiler, goarch, nil
+}
diff --git a/vendor/golang.org/x/tools/go/packages/golist_overlay.go b/vendor/golang.org/x/tools/go/packages/golist_overlay.go
new file mode 100644
index 00000000..d9d5a45c
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/golist_overlay.go
@@ -0,0 +1,83 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package packages
+
+import (
+ "encoding/json"
+ "path/filepath"
+
+ "golang.org/x/tools/internal/gocommand"
+)
+
+// determineRootDirs returns a mapping from absolute directories that could
+// contain code to their corresponding import path prefixes.
+func (state *golistState) determineRootDirs() (map[string]string, error) {
+ env, err := state.getEnv()
+ if err != nil {
+ return nil, err
+ }
+ if env["GOMOD"] != "" {
+ state.rootsOnce.Do(func() {
+ state.rootDirs, state.rootDirsError = state.determineRootDirsModules()
+ })
+ } else {
+ state.rootsOnce.Do(func() {
+ state.rootDirs, state.rootDirsError = state.determineRootDirsGOPATH()
+ })
+ }
+ return state.rootDirs, state.rootDirsError
+}
+
+func (state *golistState) determineRootDirsModules() (map[string]string, error) {
+ // List all of the modules--the first will be the directory for the main
+ // module. Any replaced modules will also need to be treated as roots.
+ // Editing files in the module cache isn't a great idea, so we don't
+ // plan to ever support that.
+ out, err := state.invokeGo("list", "-m", "-json", "all")
+ if err != nil {
+ // 'go list all' will fail if we're outside of a module and
+ // GO111MODULE=on. Try falling back without 'all'.
+ var innerErr error
+ out, innerErr = state.invokeGo("list", "-m", "-json")
+ if innerErr != nil {
+ return nil, err
+ }
+ }
+ roots := map[string]string{}
+ modules := map[string]string{}
+ var i int
+ for dec := json.NewDecoder(out); dec.More(); {
+ mod := new(gocommand.ModuleJSON)
+ if err := dec.Decode(mod); err != nil {
+ return nil, err
+ }
+ if mod.Dir != "" && mod.Path != "" {
+ // This is a valid module; add it to the map.
+ absDir, err := state.cfg.abs(mod.Dir)
+ if err != nil {
+ return nil, err
+ }
+ modules[absDir] = mod.Path
+ // The first result is the main module.
+ if i == 0 || mod.Replace != nil && mod.Replace.Path != "" {
+ roots[absDir] = mod.Path
+ }
+ }
+ i++
+ }
+ return roots, nil
+}
+
+func (state *golistState) determineRootDirsGOPATH() (map[string]string, error) {
+ m := map[string]string{}
+ for _, dir := range filepath.SplitList(state.mustGetEnv()["GOPATH"]) {
+ absDir, err := filepath.Abs(dir)
+ if err != nil {
+ return nil, err
+ }
+ m[filepath.Join(absDir, "src")] = ""
+ }
+ return m, nil
+}
diff --git a/vendor/golang.org/x/tools/go/packages/loadmode_string.go b/vendor/golang.org/x/tools/go/packages/loadmode_string.go
new file mode 100644
index 00000000..69eec9f4
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/loadmode_string.go
@@ -0,0 +1,56 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package packages
+
+import (
+ "fmt"
+ "strings"
+)
+
+var modes = [...]struct {
+ mode LoadMode
+ name string
+}{
+ {NeedName, "NeedName"},
+ {NeedFiles, "NeedFiles"},
+ {NeedCompiledGoFiles, "NeedCompiledGoFiles"},
+ {NeedImports, "NeedImports"},
+ {NeedDeps, "NeedDeps"},
+ {NeedExportFile, "NeedExportFile"},
+ {NeedTypes, "NeedTypes"},
+ {NeedSyntax, "NeedSyntax"},
+ {NeedTypesInfo, "NeedTypesInfo"},
+ {NeedTypesSizes, "NeedTypesSizes"},
+ {NeedForTest, "NeedForTest"},
+ {NeedModule, "NeedModule"},
+ {NeedEmbedFiles, "NeedEmbedFiles"},
+ {NeedEmbedPatterns, "NeedEmbedPatterns"},
+ {NeedTarget, "NeedTarget"},
+}
+
+func (mode LoadMode) String() string {
+ if mode == 0 {
+ return "LoadMode(0)"
+ }
+ var out []string
+ // named bits
+ for _, item := range modes {
+ if (mode & item.mode) != 0 {
+ mode ^= item.mode
+ out = append(out, item.name)
+ }
+ }
+ // unnamed residue
+ if mode != 0 {
+ if out == nil {
+ return fmt.Sprintf("LoadMode(%#x)", int(mode))
+ }
+ out = append(out, fmt.Sprintf("%#x", int(mode)))
+ }
+ if len(out) == 1 {
+ return out[0]
+ }
+ return "(" + strings.Join(out, "|") + ")"
+}
diff --git a/vendor/golang.org/x/tools/go/packages/packages.go b/vendor/golang.org/x/tools/go/packages/packages.go
new file mode 100644
index 00000000..060ab08e
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/packages.go
@@ -0,0 +1,1559 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package packages
+
+// See doc.go for package documentation and implementation notes.
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "go/ast"
+ "go/parser"
+ "go/scanner"
+ "go/token"
+ "go/types"
+ "log"
+ "os"
+ "path/filepath"
+ "runtime"
+ "strings"
+ "sync"
+ "sync/atomic"
+ "time"
+
+ "golang.org/x/sync/errgroup"
+
+ "golang.org/x/tools/go/gcexportdata"
+ "golang.org/x/tools/internal/gocommand"
+ "golang.org/x/tools/internal/packagesinternal"
+ "golang.org/x/tools/internal/typesinternal"
+)
+
+// A LoadMode controls the amount of detail to return when loading.
+// The bits below can be combined to specify which fields should be
+// filled in the result packages.
+//
+// The zero value is a special case, equivalent to combining
+// the NeedName, NeedFiles, and NeedCompiledGoFiles bits.
+//
+// ID and Errors (if present) will always be filled.
+// [Load] may return more information than requested.
+//
+// The Mode flag is a union of several bits named NeedName,
+// NeedFiles, and so on, each of which determines whether
+// a given field of Package (Name, Files, etc) should be
+// populated.
+//
+// For convenience, we provide named constants for the most
+// common combinations of Need flags:
+//
+// [LoadFiles] lists of files in each package
+// [LoadImports] ... plus imports
+// [LoadTypes] ... plus type information
+// [LoadSyntax] ... plus type-annotated syntax
+// [LoadAllSyntax] ... for all dependencies
+//
+// Unfortunately there are a number of open bugs related to
+// interactions among the LoadMode bits:
+// - https://go.dev/issue/56633
+// - https://go.dev/issue/56677
+// - https://go.dev/issue/58726
+// - https://go.dev/issue/63517
+type LoadMode int
+
+const (
+ // NeedName adds Name and PkgPath.
+ NeedName LoadMode = 1 << iota
+
+ // NeedFiles adds Dir, GoFiles, OtherFiles, and IgnoredFiles
+ NeedFiles
+
+ // NeedCompiledGoFiles adds CompiledGoFiles.
+ NeedCompiledGoFiles
+
+ // NeedImports adds Imports. If NeedDeps is not set, the Imports field will contain
+ // "placeholder" Packages with only the ID set.
+ NeedImports
+
+ // NeedDeps adds the fields requested by the LoadMode in the packages in Imports.
+ NeedDeps
+
+ // NeedExportFile adds ExportFile.
+ NeedExportFile
+
+ // NeedTypes adds Types, Fset, and IllTyped.
+ NeedTypes
+
+ // NeedSyntax adds Syntax and Fset.
+ NeedSyntax
+
+ // NeedTypesInfo adds TypesInfo and Fset.
+ NeedTypesInfo
+
+ // NeedTypesSizes adds TypesSizes.
+ NeedTypesSizes
+
+ // needInternalDepsErrors adds the internal deps errors field for use by gopls.
+ needInternalDepsErrors
+
+ // NeedForTest adds ForTest.
+ //
+ // Tests must also be set on the context for this field to be populated.
+ NeedForTest
+
+ // typecheckCgo enables full support for type checking cgo. Requires Go 1.15+.
+ // Modifies CompiledGoFiles and Types, and has no effect on its own.
+ typecheckCgo
+
+ // NeedModule adds Module.
+ NeedModule
+
+ // NeedEmbedFiles adds EmbedFiles.
+ NeedEmbedFiles
+
+ // NeedEmbedPatterns adds EmbedPatterns.
+ NeedEmbedPatterns
+
+ // NeedTarget adds Target.
+ NeedTarget
+
+ // Be sure to update loadmode_string.go when adding new items!
+)
+
+const (
+ // LoadFiles loads the name and file names for the initial packages.
+ LoadFiles = NeedName | NeedFiles | NeedCompiledGoFiles
+
+ // LoadImports loads the name, file names, and import mapping for the initial packages.
+ LoadImports = LoadFiles | NeedImports
+
+ // LoadTypes loads exported type information for the initial packages.
+ LoadTypes = LoadImports | NeedTypes | NeedTypesSizes
+
+ // LoadSyntax loads typed syntax for the initial packages.
+ LoadSyntax = LoadTypes | NeedSyntax | NeedTypesInfo
+
+ // LoadAllSyntax loads typed syntax for the initial packages and all dependencies.
+ LoadAllSyntax = LoadSyntax | NeedDeps
+
+ // Deprecated: NeedExportsFile is a historical misspelling of NeedExportFile.
+ //
+ //go:fix inline
+ NeedExportsFile = NeedExportFile
+)
+
+// A Config specifies details about how packages should be loaded.
+// The zero value is a valid configuration.
+//
+// Calls to [Load] do not modify this struct.
+type Config struct {
+ // Mode controls the level of information returned for each package.
+ Mode LoadMode
+
+ // Context specifies the context for the load operation.
+ // Cancelling the context may cause [Load] to abort and
+ // return an error.
+ Context context.Context
+
+ // Logf is the logger for the config.
+ // If the user provides a logger, debug logging is enabled.
+ // If the GOPACKAGESDEBUG environment variable is set to true,
+ // but the logger is nil, default to log.Printf.
+ Logf func(format string, args ...any)
+
+ // Dir is the directory in which to run the build system's query tool
+ // that provides information about the packages.
+ // If Dir is empty, the tool is run in the current directory.
+ Dir string
+
+ // Env is the environment to use when invoking the build system's query tool.
+ // If Env is nil, the current environment is used.
+ // As in os/exec's Cmd, only the last value in the slice for
+ // each environment key is used. To specify the setting of only
+ // a few variables, append to the current environment, as in:
+ //
+ // opt.Env = append(os.Environ(), "GOOS=plan9", "GOARCH=386")
+ //
+ Env []string
+
+ // BuildFlags is a list of command-line flags to be passed through to
+ // the build system's query tool.
+ BuildFlags []string
+
+ // Fset provides source position information for syntax trees and types.
+ // If Fset is nil, Load will use a new fileset, but preserve Fset's value.
+ Fset *token.FileSet
+
+ // ParseFile is called to read and parse each file
+ // when preparing a package's type-checked syntax tree.
+ // It must be safe to call ParseFile simultaneously from multiple goroutines.
+ // If ParseFile is nil, the loader will uses parser.ParseFile.
+ //
+ // ParseFile should parse the source from src and use filename only for
+ // recording position information.
+ //
+ // An application may supply a custom implementation of ParseFile
+ // to change the effective file contents or the behavior of the parser,
+ // or to modify the syntax tree. For example, selectively eliminating
+ // unwanted function bodies can significantly accelerate type checking.
+ ParseFile func(fset *token.FileSet, filename string, src []byte) (*ast.File, error)
+
+ // If Tests is set, the loader includes not just the packages
+ // matching a particular pattern but also any related test packages,
+ // including test-only variants of the package and the test executable.
+ //
+ // For example, when using the go command, loading "fmt" with Tests=true
+ // returns four packages, with IDs "fmt" (the standard package),
+ // "fmt [fmt.test]" (the package as compiled for the test),
+ // "fmt_test" (the test functions from source files in package fmt_test),
+ // and "fmt.test" (the test binary).
+ //
+ // In build systems with explicit names for tests,
+ // setting Tests may have no effect.
+ Tests bool
+
+ // Overlay is a mapping from absolute file paths to file contents.
+ //
+ // For each map entry, [Load] uses the alternative file
+ // contents provided by the overlay mapping instead of reading
+ // from the file system. This mechanism can be used to enable
+ // editor-integrated tools to correctly analyze the contents
+ // of modified but unsaved buffers, for example.
+ //
+ // The overlay mapping is passed to the build system's driver
+ // (see "The driver protocol") so that it too can report
+ // consistent package metadata about unsaved files. However,
+ // drivers may vary in their level of support for overlays.
+ Overlay map[string][]byte
+}
+
+// Load loads and returns the Go packages named by the given patterns.
+//
+// The cfg parameter specifies loading options; nil behaves the same as an empty [Config].
+//
+// The [Config.Mode] field is a set of bits that determine what kinds
+// of information should be computed and returned. Modes that require
+// more information tend to be slower. See [LoadMode] for details
+// and important caveats. Its zero value is equivalent to
+// [NeedName] | [NeedFiles] | [NeedCompiledGoFiles].
+//
+// Each call to Load returns a new set of [Package] instances.
+// The Packages and their Imports form a directed acyclic graph.
+//
+// If the [NeedTypes] mode flag was set, each call to Load uses a new
+// [types.Importer], so [types.Object] and [types.Type] values from
+// different calls to Load must not be mixed as they will have
+// inconsistent notions of type identity.
+//
+// If any of the patterns was invalid as defined by the
+// underlying build system, Load returns an error.
+// It may return an empty list of packages without an error,
+// for instance for an empty expansion of a valid wildcard.
+// Errors associated with a particular package are recorded in the
+// corresponding Package's Errors list, and do not cause Load to
+// return an error. Clients may need to handle such errors before
+// proceeding with further analysis. The [PrintErrors] function is
+// provided for convenient display of all errors.
+func Load(cfg *Config, patterns ...string) ([]*Package, error) {
+ ld := newLoader(cfg)
+ response, external, err := defaultDriver(&ld.Config, patterns...)
+ if err != nil {
+ return nil, err
+ }
+
+ ld.sizes = types.SizesFor(response.Compiler, response.Arch)
+ if ld.sizes == nil && ld.Config.Mode&(NeedTypes|NeedTypesSizes|NeedTypesInfo) != 0 {
+ // Type size information is needed but unavailable.
+ if external {
+ // An external driver may fail to populate the Compiler/GOARCH fields,
+ // especially since they are relatively new (see #63700).
+ // Provide a sensible fallback in this case.
+ ld.sizes = types.SizesFor("gc", runtime.GOARCH)
+ if ld.sizes == nil { // gccgo-only arch
+ ld.sizes = types.SizesFor("gc", "amd64")
+ }
+ } else {
+ // Go list should never fail to deliver accurate size information.
+ // Reject the whole Load since the error is the same for every package.
+ return nil, fmt.Errorf("can't determine type sizes for compiler %q on GOARCH %q",
+ response.Compiler, response.Arch)
+ }
+ }
+
+ return ld.refine(response)
+}
+
+// defaultDriver is a driver that implements go/packages' fallback behavior.
+// It will try to request to an external driver, if one exists. If there's
+// no external driver, or the driver returns a response with NotHandled set,
+// defaultDriver will fall back to the go list driver.
+// The boolean result indicates that an external driver handled the request.
+func defaultDriver(cfg *Config, patterns ...string) (*DriverResponse, bool, error) {
+ const (
+ // windowsArgMax specifies the maximum command line length for
+ // the Windows' CreateProcess function.
+ windowsArgMax = 32767
+ // maxEnvSize is a very rough estimation of the maximum environment
+ // size of a user.
+ maxEnvSize = 16384
+ // safeArgMax specifies the maximum safe command line length to use
+ // by the underlying driver excl. the environment. We choose the Windows'
+ // ARG_MAX as the starting point because it's one of the lowest ARG_MAX
+ // constants out of the different supported platforms,
+ // e.g., https://www.in-ulm.de/~mascheck/various/argmax/#results.
+ safeArgMax = windowsArgMax - maxEnvSize
+ )
+ chunks, err := splitIntoChunks(patterns, safeArgMax)
+ if err != nil {
+ return nil, false, err
+ }
+
+ if driver := findExternalDriver(cfg); driver != nil {
+ response, err := callDriverOnChunks(driver, cfg, chunks)
+ if err != nil {
+ return nil, false, err
+ } else if !response.NotHandled {
+ return response, true, nil
+ }
+ // not handled: fall through
+ }
+
+ // go list fallback
+
+ // Write overlays once, as there are many calls
+ // to 'go list' (one per chunk plus others too).
+ overlayFile, cleanupOverlay, err := gocommand.WriteOverlays(cfg.Overlay)
+ if err != nil {
+ return nil, false, err
+ }
+ defer cleanupOverlay()
+
+ var runner gocommand.Runner // (shared across many 'go list' calls)
+ driver := func(cfg *Config, patterns []string) (*DriverResponse, error) {
+ return goListDriver(cfg, &runner, overlayFile, patterns)
+ }
+ response, err := callDriverOnChunks(driver, cfg, chunks)
+ if err != nil {
+ return nil, false, err
+ }
+ return response, false, err
+}
+
+// splitIntoChunks chunks the slice so that the total number of characters
+// in a chunk is no longer than argMax.
+func splitIntoChunks(patterns []string, argMax int) ([][]string, error) {
+ if argMax <= 0 {
+ return nil, errors.New("failed to split patterns into chunks, negative safe argMax value")
+ }
+ var chunks [][]string
+ charsInChunk := 0
+ nextChunkStart := 0
+ for i, v := range patterns {
+ vChars := len(v)
+ if vChars > argMax {
+ // a single pattern is longer than the maximum safe ARG_MAX, hardly should happen
+ return nil, errors.New("failed to split patterns into chunks, a pattern is too long")
+ }
+ charsInChunk += vChars + 1 // +1 is for a whitespace between patterns that has to be counted too
+ if charsInChunk > argMax {
+ chunks = append(chunks, patterns[nextChunkStart:i])
+ nextChunkStart = i
+ charsInChunk = vChars
+ }
+ }
+ // add the last chunk
+ if nextChunkStart < len(patterns) {
+ chunks = append(chunks, patterns[nextChunkStart:])
+ }
+ return chunks, nil
+}
+
+func callDriverOnChunks(driver driver, cfg *Config, chunks [][]string) (*DriverResponse, error) {
+ if len(chunks) == 0 {
+ return driver(cfg, nil)
+ }
+ responses := make([]*DriverResponse, len(chunks))
+ errNotHandled := errors.New("driver returned NotHandled")
+ var g errgroup.Group
+ for i, chunk := range chunks {
+ g.Go(func() (err error) {
+ responses[i], err = driver(cfg, chunk)
+ if responses[i] != nil && responses[i].NotHandled {
+ err = errNotHandled
+ }
+ return err
+ })
+ }
+ if err := g.Wait(); err != nil {
+ if errors.Is(err, errNotHandled) {
+ return &DriverResponse{NotHandled: true}, nil
+ }
+ return nil, err
+ }
+ return mergeResponses(responses...), nil
+}
+
+func mergeResponses(responses ...*DriverResponse) *DriverResponse {
+ if len(responses) == 0 {
+ return nil
+ }
+ response := newDeduper()
+ response.dr.NotHandled = false
+ response.dr.Compiler = responses[0].Compiler
+ response.dr.Arch = responses[0].Arch
+ response.dr.GoVersion = responses[0].GoVersion
+ for _, v := range responses {
+ response.addAll(v)
+ }
+ return response.dr
+}
+
+// A Package describes a loaded Go package.
+//
+// It also defines part of the JSON schema of [DriverResponse].
+// See the package documentation for an overview.
+type Package struct {
+ // ID is a unique identifier for a package,
+ // in a syntax provided by the underlying build system.
+ //
+ // Because the syntax varies based on the build system,
+ // clients should treat IDs as opaque and not attempt to
+ // interpret them.
+ ID string
+
+ // Name is the package name as it appears in the package source code.
+ Name string
+
+ // PkgPath is the package path as used by the go/types package.
+ PkgPath string
+
+ // Dir is the directory associated with the package, if it exists.
+ //
+ // For packages listed by the go command, this is the directory containing
+ // the package files.
+ Dir string
+
+ // Errors contains any errors encountered querying the metadata
+ // of the package, or while parsing or type-checking its files.
+ Errors []Error
+
+ // TypeErrors contains the subset of errors produced during type checking.
+ TypeErrors []types.Error
+
+ // GoFiles lists the absolute file paths of the package's Go source files.
+ // It may include files that should not be compiled, for example because
+ // they contain non-matching build tags, are documentary pseudo-files such as
+ // unsafe/unsafe.go or builtin/builtin.go, or are subject to cgo preprocessing.
+ GoFiles []string
+
+ // CompiledGoFiles lists the absolute file paths of the package's source
+ // files that are suitable for type checking.
+ // This may differ from GoFiles if files are processed before compilation.
+ CompiledGoFiles []string
+
+ // OtherFiles lists the absolute file paths of the package's non-Go source files,
+ // including assembly, C, C++, Fortran, Objective-C, SWIG, and so on.
+ OtherFiles []string
+
+ // EmbedFiles lists the absolute file paths of the package's files
+ // embedded with go:embed.
+ EmbedFiles []string
+
+ // EmbedPatterns lists the absolute file patterns of the package's
+ // files embedded with go:embed.
+ EmbedPatterns []string
+
+ // IgnoredFiles lists source files that are not part of the package
+ // using the current build configuration but that might be part of
+ // the package using other build configurations.
+ IgnoredFiles []string
+
+ // ExportFile is the absolute path to a file containing type
+ // information for the package as provided by the build system.
+ ExportFile string
+
+ // Target is the absolute install path of the .a file, for libraries,
+ // and of the executable file, for binaries.
+ Target string
+
+ // Imports maps import paths appearing in the package's Go source files
+ // to corresponding loaded Packages.
+ Imports map[string]*Package
+
+ // Module is the module information for the package if it exists.
+ //
+ // Note: it may be missing for std and cmd; see Go issue #65816.
+ Module *Module
+
+ // -- The following fields are not part of the driver JSON schema. --
+
+ // Types provides type information for the package.
+ // The NeedTypes LoadMode bit sets this field for packages matching the
+ // patterns; type information for dependencies may be missing or incomplete,
+ // unless NeedDeps and NeedImports are also set.
+ //
+ // Each call to [Load] returns a consistent set of type
+ // symbols, as defined by the comment at [types.Identical].
+ // Avoid mixing type information from two or more calls to [Load].
+ Types *types.Package `json:"-"`
+
+ // Fset provides position information for Types, TypesInfo, and Syntax.
+ // It is set only when Types is set.
+ Fset *token.FileSet `json:"-"`
+
+ // IllTyped indicates whether the package or any dependency contains errors.
+ // It is set only when Types is set.
+ IllTyped bool `json:"-"`
+
+ // Syntax is the package's syntax trees, for the files listed in CompiledGoFiles.
+ //
+ // The NeedSyntax LoadMode bit populates this field for packages matching the patterns.
+ // If NeedDeps and NeedImports are also set, this field will also be populated
+ // for dependencies.
+ //
+ // Syntax is kept in the same order as CompiledGoFiles, with the caveat that nils are
+ // removed. If parsing returned nil, Syntax may be shorter than CompiledGoFiles.
+ Syntax []*ast.File `json:"-"`
+
+ // TypesInfo provides type information about the package's syntax trees.
+ // It is set only when Syntax is set.
+ TypesInfo *types.Info `json:"-"`
+
+ // TypesSizes provides the effective size function for types in TypesInfo.
+ TypesSizes types.Sizes `json:"-"`
+
+ // -- internal --
+
+ // ForTest is the package under test, if any.
+ ForTest string
+
+ // depsErrors is the DepsErrors field from the go list response, if any.
+ depsErrors []*packagesinternal.PackageError
+}
+
+// Module provides module information for a package.
+//
+// It also defines part of the JSON schema of [DriverResponse].
+// See the package documentation for an overview.
+type Module struct {
+ Path string // module path
+ Version string // module version
+ Replace *Module // replaced by this module
+ Time *time.Time // time version was created
+ Main bool // is this the main module?
+ Indirect bool // is this module only an indirect dependency of main module?
+ Dir string // directory holding files for this module, if any
+ GoMod string // path to go.mod file used when loading this module, if any
+ GoVersion string // go version used in module
+ Error *ModuleError // error loading module
+}
+
+// ModuleError holds errors loading a module.
+type ModuleError struct {
+ Err string // the error itself
+}
+
+func init() {
+ packagesinternal.GetDepsErrors = func(p any) []*packagesinternal.PackageError {
+ return p.(*Package).depsErrors
+ }
+ packagesinternal.TypecheckCgo = int(typecheckCgo)
+ packagesinternal.DepsErrors = int(needInternalDepsErrors)
+}
+
+// An Error describes a problem with a package's metadata, syntax, or types.
+type Error struct {
+ Pos string // "file:line:col" or "file:line" or "" or "-"
+ Msg string
+ Kind ErrorKind
+}
+
+// ErrorKind describes the source of the error, allowing the user to
+// differentiate between errors generated by the driver, the parser, or the
+// type-checker.
+type ErrorKind int
+
+const (
+ UnknownError ErrorKind = iota
+ ListError
+ ParseError
+ TypeError
+)
+
+func (err Error) Error() string {
+ pos := err.Pos
+ if pos == "" {
+ pos = "-" // like token.Position{}.String()
+ }
+ return pos + ": " + err.Msg
+}
+
+// flatPackage is the JSON form of Package
+// It drops all the type and syntax fields, and transforms the Imports
+//
+// TODO(adonovan): identify this struct with Package, effectively
+// publishing the JSON protocol.
+type flatPackage struct {
+ ID string
+ Name string `json:",omitempty"`
+ PkgPath string `json:",omitempty"`
+ Errors []Error `json:",omitempty"`
+ GoFiles []string `json:",omitempty"`
+ CompiledGoFiles []string `json:",omitempty"`
+ OtherFiles []string `json:",omitempty"`
+ EmbedFiles []string `json:",omitempty"`
+ EmbedPatterns []string `json:",omitempty"`
+ IgnoredFiles []string `json:",omitempty"`
+ ExportFile string `json:",omitempty"`
+ Imports map[string]string `json:",omitempty"`
+}
+
+// MarshalJSON returns the Package in its JSON form.
+// For the most part, the structure fields are written out unmodified, and
+// the type and syntax fields are skipped.
+// The imports are written out as just a map of path to package id.
+// The errors are written using a custom type that tries to preserve the
+// structure of error types we know about.
+//
+// This method exists to enable support for additional build systems. It is
+// not intended for use by clients of the API and we may change the format.
+func (p *Package) MarshalJSON() ([]byte, error) {
+ flat := &flatPackage{
+ ID: p.ID,
+ Name: p.Name,
+ PkgPath: p.PkgPath,
+ Errors: p.Errors,
+ GoFiles: p.GoFiles,
+ CompiledGoFiles: p.CompiledGoFiles,
+ OtherFiles: p.OtherFiles,
+ EmbedFiles: p.EmbedFiles,
+ EmbedPatterns: p.EmbedPatterns,
+ IgnoredFiles: p.IgnoredFiles,
+ ExportFile: p.ExportFile,
+ }
+ if len(p.Imports) > 0 {
+ flat.Imports = make(map[string]string, len(p.Imports))
+ for path, ipkg := range p.Imports {
+ flat.Imports[path] = ipkg.ID
+ }
+ }
+ return json.Marshal(flat)
+}
+
+// UnmarshalJSON reads in a Package from its JSON format.
+// See MarshalJSON for details about the format accepted.
+func (p *Package) UnmarshalJSON(b []byte) error {
+ flat := &flatPackage{}
+ if err := json.Unmarshal(b, &flat); err != nil {
+ return err
+ }
+ *p = Package{
+ ID: flat.ID,
+ Name: flat.Name,
+ PkgPath: flat.PkgPath,
+ Errors: flat.Errors,
+ GoFiles: flat.GoFiles,
+ CompiledGoFiles: flat.CompiledGoFiles,
+ OtherFiles: flat.OtherFiles,
+ EmbedFiles: flat.EmbedFiles,
+ EmbedPatterns: flat.EmbedPatterns,
+ IgnoredFiles: flat.IgnoredFiles,
+ ExportFile: flat.ExportFile,
+ }
+ if len(flat.Imports) > 0 {
+ p.Imports = make(map[string]*Package, len(flat.Imports))
+ for path, id := range flat.Imports {
+ p.Imports[path] = &Package{ID: id}
+ }
+ }
+ return nil
+}
+
+func (p *Package) String() string { return p.ID }
+
+// loaderPackage augments Package with state used during the loading phase
+type loaderPackage struct {
+ *Package
+ importErrors map[string]error // maps each bad import to its error
+ preds []*loaderPackage // packages that import this one
+ unfinishedSuccs atomic.Int32 // number of direct imports not yet loaded
+ color uint8 // for cycle detection
+ needsrc bool // load from source (Mode >= LoadTypes)
+ needtypes bool // type information is either requested or depended on
+ initial bool // package was matched by a pattern
+ goVersion int // minor version number of go command on PATH
+}
+
+// loader holds the working state of a single call to load.
+type loader struct {
+ pkgs map[string]*loaderPackage // keyed by Package.ID
+ Config
+ sizes types.Sizes // non-nil if needed by mode
+ parseCache map[string]*parseValue
+ parseCacheMu sync.Mutex
+ exportMu sync.Mutex // enforces mutual exclusion of exportdata operations
+
+ // Config.Mode contains the implied mode (see impliedLoadMode).
+ // Implied mode contains all the fields we need the data for.
+ // In requestedMode there are the actually requested fields.
+ // We'll zero them out before returning packages to the user.
+ // This makes it easier for us to get the conditions where
+ // we need certain modes right.
+ requestedMode LoadMode
+}
+
+type parseValue struct {
+ f *ast.File
+ err error
+ ready chan struct{}
+}
+
+func newLoader(cfg *Config) *loader {
+ ld := &loader{
+ parseCache: map[string]*parseValue{},
+ }
+ if cfg != nil {
+ ld.Config = *cfg
+ // If the user has provided a logger, use it.
+ ld.Config.Logf = cfg.Logf
+ }
+ if ld.Config.Logf == nil {
+ // If the GOPACKAGESDEBUG environment variable is set to true,
+ // but the user has not provided a logger, default to log.Printf.
+ if debug {
+ ld.Config.Logf = log.Printf
+ } else {
+ ld.Config.Logf = func(format string, args ...any) {}
+ }
+ }
+ if ld.Config.Mode == 0 {
+ ld.Config.Mode = NeedName | NeedFiles | NeedCompiledGoFiles // Preserve zero behavior of Mode for backwards compatibility.
+ }
+ if ld.Config.Env == nil {
+ ld.Config.Env = os.Environ()
+ }
+ if ld.Context == nil {
+ ld.Context = context.Background()
+ }
+ if ld.Dir == "" {
+ if dir, err := os.Getwd(); err == nil {
+ ld.Dir = dir
+ }
+ }
+
+ // Save the actually requested fields. We'll zero them out before returning packages to the user.
+ ld.requestedMode = ld.Mode
+ ld.Mode = impliedLoadMode(ld.Mode)
+
+ if ld.Mode&(NeedSyntax|NeedTypes|NeedTypesInfo) != 0 {
+ if ld.Fset == nil {
+ ld.Fset = token.NewFileSet()
+ }
+
+ // ParseFile is required even in LoadTypes mode
+ // because we load source if export data is missing.
+ if ld.ParseFile == nil {
+ ld.ParseFile = func(fset *token.FileSet, filename string, src []byte) (*ast.File, error) {
+ // We implicitly promise to keep doing ast.Object resolution. :(
+ const mode = parser.AllErrors | parser.ParseComments
+ return parser.ParseFile(fset, filename, src, mode)
+ }
+ }
+ }
+
+ return ld
+}
+
+// refine connects the supplied packages into a graph and then adds type
+// and syntax information as requested by the LoadMode.
+func (ld *loader) refine(response *DriverResponse) ([]*Package, error) {
+ roots := response.Roots
+ rootMap := make(map[string]int, len(roots))
+ for i, root := range roots {
+ rootMap[root] = i
+ }
+ ld.pkgs = make(map[string]*loaderPackage)
+ // first pass, fixup and build the map and roots
+ var initial = make([]*loaderPackage, len(roots))
+ for _, pkg := range response.Packages {
+ rootIndex := -1
+ if i, found := rootMap[pkg.ID]; found {
+ rootIndex = i
+ }
+
+ // Overlays can invalidate export data.
+ // TODO(matloob): make this check fine-grained based on dependencies on overlaid files
+ exportDataInvalid := len(ld.Overlay) > 0 || pkg.ExportFile == "" && pkg.PkgPath != "unsafe"
+ // This package needs type information if the caller requested types and the package is
+ // either a root, or it's a non-root and the user requested dependencies ...
+ needtypes := (ld.Mode&(NeedTypes|NeedTypesInfo) != 0 && (rootIndex >= 0 || ld.Mode&NeedDeps != 0))
+ // This package needs source if the call requested source (or types info, which implies source)
+ // and the package is either a root, or itas a non- root and the user requested dependencies...
+ needsrc := ((ld.Mode&(NeedSyntax|NeedTypesInfo) != 0 && (rootIndex >= 0 || ld.Mode&NeedDeps != 0)) ||
+ // ... or if we need types and the exportData is invalid. We fall back to (incompletely)
+ // typechecking packages from source if they fail to compile.
+ (ld.Mode&(NeedTypes|NeedTypesInfo) != 0 && exportDataInvalid)) && pkg.PkgPath != "unsafe"
+ lpkg := &loaderPackage{
+ Package: pkg,
+ needtypes: needtypes,
+ needsrc: needsrc,
+ goVersion: response.GoVersion,
+ }
+ ld.pkgs[lpkg.ID] = lpkg
+ if rootIndex >= 0 {
+ initial[rootIndex] = lpkg
+ lpkg.initial = true
+ }
+ }
+ for i, root := range roots {
+ if initial[i] == nil {
+ return nil, fmt.Errorf("root package %v is missing", root)
+ }
+ }
+
+ // Materialize the import graph if it is needed (NeedImports),
+ // or if we'll be using loadPackages (Need{Syntax|Types|TypesInfo}).
+ var leaves []*loaderPackage // packages with no unfinished successors
+ if ld.Mode&(NeedImports|NeedSyntax|NeedTypes|NeedTypesInfo) != 0 {
+ const (
+ white = 0 // new
+ grey = 1 // in progress
+ black = 2 // complete
+ )
+
+ // visit traverses the import graph, depth-first,
+ // and materializes the graph as Packages.Imports.
+ //
+ // Valid imports are saved in the Packages.Import map.
+ // Invalid imports (cycles and missing nodes) are saved in the importErrors map.
+ // Thus, even in the presence of both kinds of errors,
+ // the Import graph remains a DAG.
+ //
+ // visit returns whether the package needs src or has a transitive
+ // dependency on a package that does. These are the only packages
+ // for which we load source code.
+ var stack []*loaderPackage
+ var visit func(from, lpkg *loaderPackage) bool
+ visit = func(from, lpkg *loaderPackage) bool {
+ if lpkg.color == grey {
+ panic("internal error: grey node")
+ }
+ if lpkg.color == white {
+ lpkg.color = grey
+ stack = append(stack, lpkg) // push
+ stubs := lpkg.Imports // the structure form has only stubs with the ID in the Imports
+ lpkg.Imports = make(map[string]*Package, len(stubs))
+ for importPath, ipkg := range stubs {
+ var importErr error
+ imp := ld.pkgs[ipkg.ID]
+ if imp == nil {
+ // (includes package "C" when DisableCgo)
+ importErr = fmt.Errorf("missing package: %q", ipkg.ID)
+ } else if imp.color == grey {
+ importErr = fmt.Errorf("import cycle: %s", stack)
+ }
+ if importErr != nil {
+ if lpkg.importErrors == nil {
+ lpkg.importErrors = make(map[string]error)
+ }
+ lpkg.importErrors[importPath] = importErr
+ continue
+ }
+
+ if visit(lpkg, imp) {
+ lpkg.needsrc = true
+ }
+ lpkg.Imports[importPath] = imp.Package
+ }
+
+ // -- postorder --
+
+ // Complete type information is required for the
+ // immediate dependencies of each source package.
+ if lpkg.needsrc && ld.Mode&NeedTypes != 0 {
+ for _, ipkg := range lpkg.Imports {
+ ld.pkgs[ipkg.ID].needtypes = true
+ }
+ }
+
+ // NeedTypeSizes causes TypeSizes to be set even
+ // on packages for which types aren't needed.
+ if ld.Mode&NeedTypesSizes != 0 {
+ lpkg.TypesSizes = ld.sizes
+ }
+
+ // Add packages with no imports directly to the queue of leaves.
+ if len(lpkg.Imports) == 0 {
+ leaves = append(leaves, lpkg)
+ }
+
+ stack = stack[:len(stack)-1] // pop
+ lpkg.color = black
+ }
+
+ // Add edge from predecessor.
+ if from != nil {
+ from.unfinishedSuccs.Add(+1) // incref
+ lpkg.preds = append(lpkg.preds, from)
+ }
+
+ return lpkg.needsrc
+ }
+
+ // For each initial package, create its import DAG.
+ for _, lpkg := range initial {
+ visit(nil, lpkg)
+ }
+
+ } else {
+ // !NeedImports: drop the stub (ID-only) import packages
+ // that we are not even going to try to resolve.
+ for _, lpkg := range initial {
+ lpkg.Imports = nil
+ }
+ }
+
+ // Load type data and syntax if needed, starting at
+ // the initial packages (roots of the import DAG).
+ if ld.Mode&(NeedSyntax|NeedTypes|NeedTypesInfo) != 0 {
+
+ // We avoid using g.SetLimit to limit concurrency as
+ // it makes g.Go stop accepting work, which prevents
+ // workers from enqeuing, and thus finishing, and thus
+ // allowing the group to make progress: deadlock.
+ //
+ // Instead we use the ioLimit and cpuLimit semaphores.
+ g, _ := errgroup.WithContext(ld.Context)
+
+ // enqueues adds a package to the type-checking queue.
+ // It must have no unfinished successors.
+ var enqueue func(*loaderPackage)
+ enqueue = func(lpkg *loaderPackage) {
+ g.Go(func() error {
+ // Parse and type-check.
+ ld.loadPackage(lpkg)
+
+ // Notify each waiting predecessor,
+ // and enqueue it when it becomes a leaf.
+ for _, pred := range lpkg.preds {
+ if pred.unfinishedSuccs.Add(-1) == 0 { // decref
+ enqueue(pred)
+ }
+ }
+
+ return nil
+ })
+ }
+
+ // Load leaves first, adding new packages
+ // to the queue as they become leaves.
+ for _, leaf := range leaves {
+ enqueue(leaf)
+ }
+
+ if err := g.Wait(); err != nil {
+ return nil, err // cancelled
+ }
+ }
+
+ // If the context is done, return its error and
+ // throw out [likely] incomplete packages.
+ if err := ld.Context.Err(); err != nil {
+ return nil, err
+ }
+
+ result := make([]*Package, len(initial))
+ for i, lpkg := range initial {
+ result[i] = lpkg.Package
+ }
+ for i := range ld.pkgs {
+ // Clear all unrequested fields,
+ // to catch programs that use more than they request.
+ if ld.requestedMode&NeedName == 0 {
+ ld.pkgs[i].Name = ""
+ ld.pkgs[i].PkgPath = ""
+ }
+ if ld.requestedMode&NeedFiles == 0 {
+ ld.pkgs[i].GoFiles = nil
+ ld.pkgs[i].OtherFiles = nil
+ ld.pkgs[i].IgnoredFiles = nil
+ }
+ if ld.requestedMode&NeedEmbedFiles == 0 {
+ ld.pkgs[i].EmbedFiles = nil
+ }
+ if ld.requestedMode&NeedEmbedPatterns == 0 {
+ ld.pkgs[i].EmbedPatterns = nil
+ }
+ if ld.requestedMode&NeedCompiledGoFiles == 0 {
+ ld.pkgs[i].CompiledGoFiles = nil
+ }
+ if ld.requestedMode&NeedImports == 0 {
+ ld.pkgs[i].Imports = nil
+ }
+ if ld.requestedMode&NeedExportFile == 0 {
+ ld.pkgs[i].ExportFile = ""
+ }
+ if ld.requestedMode&NeedTypes == 0 {
+ ld.pkgs[i].Types = nil
+ ld.pkgs[i].IllTyped = false
+ }
+ if ld.requestedMode&NeedSyntax == 0 {
+ ld.pkgs[i].Syntax = nil
+ }
+ if ld.requestedMode&(NeedSyntax|NeedTypes|NeedTypesInfo) == 0 {
+ ld.pkgs[i].Fset = nil
+ }
+ if ld.requestedMode&NeedTypesInfo == 0 {
+ ld.pkgs[i].TypesInfo = nil
+ }
+ if ld.requestedMode&NeedTypesSizes == 0 {
+ ld.pkgs[i].TypesSizes = nil
+ }
+ if ld.requestedMode&NeedModule == 0 {
+ ld.pkgs[i].Module = nil
+ }
+ }
+
+ return result, nil
+}
+
+// loadPackage loads/parses/typechecks the specified package.
+// It must be called only once per Package,
+// after immediate dependencies are loaded.
+// Precondition: ld.Mode&(NeedSyntax|NeedTypes|NeedTypesInfo) != 0.
+func (ld *loader) loadPackage(lpkg *loaderPackage) {
+ if lpkg.PkgPath == "unsafe" {
+ // Fill in the blanks to avoid surprises.
+ lpkg.Types = types.Unsafe
+ lpkg.Fset = ld.Fset
+ lpkg.Syntax = []*ast.File{}
+ lpkg.TypesInfo = new(types.Info)
+ lpkg.TypesSizes = ld.sizes
+ return
+ }
+
+ // Call NewPackage directly with explicit name.
+ // This avoids skew between golist and go/types when the files'
+ // package declarations are inconsistent.
+ lpkg.Types = types.NewPackage(lpkg.PkgPath, lpkg.Name)
+ lpkg.Fset = ld.Fset
+
+ // Start shutting down if the context is done and do not load
+ // source or export data files.
+ // Packages that import this one will have ld.Context.Err() != nil.
+ // ld.Context.Err() will be returned later by refine.
+ if ld.Context.Err() != nil {
+ return
+ }
+
+ // Subtle: we populate all Types fields with an empty Package
+ // before loading export data so that export data processing
+ // never has to create a types.Package for an indirect dependency,
+ // which would then require that such created packages be explicitly
+ // inserted back into the Import graph as a final step after export data loading.
+ // (Hence this return is after the Types assignment.)
+ // The Diamond test exercises this case.
+ if !lpkg.needtypes && !lpkg.needsrc {
+ return
+ }
+
+ // TODO(adonovan): this condition looks wrong:
+ // I think it should be lpkg.needtypes && !lpg.needsrc,
+ // so that NeedSyntax without NeedTypes can be satisfied by export data.
+ if !lpkg.needsrc {
+ if err := ld.loadFromExportData(lpkg); err != nil {
+ lpkg.Errors = append(lpkg.Errors, Error{
+ Pos: "-",
+ Msg: err.Error(),
+ Kind: UnknownError, // e.g. can't find/open/parse export data
+ })
+ }
+ return // not a source package, don't get syntax trees
+ }
+
+ appendError := func(err error) {
+ // Convert various error types into the one true Error.
+ var errs []Error
+ switch err := err.(type) {
+ case Error:
+ // from driver
+ errs = append(errs, err)
+
+ case *os.PathError:
+ // from parser
+ errs = append(errs, Error{
+ Pos: err.Path + ":1",
+ Msg: err.Err.Error(),
+ Kind: ParseError,
+ })
+
+ case scanner.ErrorList:
+ // from parser
+ for _, err := range err {
+ errs = append(errs, Error{
+ Pos: err.Pos.String(),
+ Msg: err.Msg,
+ Kind: ParseError,
+ })
+ }
+
+ case types.Error:
+ // from type checker
+ lpkg.TypeErrors = append(lpkg.TypeErrors, err)
+ errs = append(errs, Error{
+ Pos: err.Fset.Position(err.Pos).String(),
+ Msg: err.Msg,
+ Kind: TypeError,
+ })
+
+ default:
+ // unexpected impoverished error from parser?
+ errs = append(errs, Error{
+ Pos: "-",
+ Msg: err.Error(),
+ Kind: UnknownError,
+ })
+
+ // If you see this error message, please file a bug.
+ log.Printf("internal error: error %q (%T) without position", err, err)
+ }
+
+ lpkg.Errors = append(lpkg.Errors, errs...)
+ }
+
+ // If the go command on the PATH is newer than the runtime,
+ // then the go/{scanner,ast,parser,types} packages from the
+ // standard library may be unable to process the files
+ // selected by go list.
+ //
+ // There is currently no way to downgrade the effective
+ // version of the go command (see issue 52078), so we proceed
+ // with the newer go command but, in case of parse or type
+ // errors, we emit an additional diagnostic.
+ //
+ // See:
+ // - golang.org/issue/52078 (flag to set release tags)
+ // - golang.org/issue/50825 (gopls legacy version support)
+ // - golang.org/issue/55883 (go/packages confusing error)
+ //
+ // Should we assert a hard minimum of (currently) go1.16 here?
+ var runtimeVersion int
+ if _, err := fmt.Sscanf(runtime.Version(), "go1.%d", &runtimeVersion); err == nil && runtimeVersion < lpkg.goVersion {
+ defer func() {
+ if len(lpkg.Errors) > 0 {
+ appendError(Error{
+ Pos: "-",
+ Msg: fmt.Sprintf("This application uses version go1.%d of the source-processing packages but runs version go1.%d of 'go list'. It may fail to process source files that rely on newer language features. If so, rebuild the application using a newer version of Go.", runtimeVersion, lpkg.goVersion),
+ Kind: UnknownError,
+ })
+ }
+ }()
+ }
+
+ if ld.Config.Mode&NeedTypes != 0 && len(lpkg.CompiledGoFiles) == 0 && lpkg.ExportFile != "" {
+ // The config requested loading sources and types, but sources are missing.
+ // Add an error to the package and fall back to loading from export data.
+ appendError(Error{"-", fmt.Sprintf("sources missing for package %s", lpkg.ID), ParseError})
+ _ = ld.loadFromExportData(lpkg) // ignore any secondary errors
+
+ return // can't get syntax trees for this package
+ }
+
+ files, errs := ld.parseFiles(lpkg.CompiledGoFiles)
+ for _, err := range errs {
+ appendError(err)
+ }
+
+ lpkg.Syntax = files
+ if ld.Config.Mode&(NeedTypes|NeedTypesInfo) == 0 {
+ return
+ }
+
+ // Start shutting down if the context is done and do not type check.
+ // Packages that import this one will have ld.Context.Err() != nil.
+ // ld.Context.Err() will be returned later by refine.
+ if ld.Context.Err() != nil {
+ return
+ }
+
+ // Populate TypesInfo only if needed, as it
+ // causes the type checker to work much harder.
+ if ld.Config.Mode&NeedTypesInfo != 0 {
+ lpkg.TypesInfo = &types.Info{
+ Types: make(map[ast.Expr]types.TypeAndValue),
+ Defs: make(map[*ast.Ident]types.Object),
+ Uses: make(map[*ast.Ident]types.Object),
+ Implicits: make(map[ast.Node]types.Object),
+ Instances: make(map[*ast.Ident]types.Instance),
+ Scopes: make(map[ast.Node]*types.Scope),
+ Selections: make(map[*ast.SelectorExpr]*types.Selection),
+ FileVersions: make(map[*ast.File]string),
+ }
+ }
+ lpkg.TypesSizes = ld.sizes
+
+ importer := importerFunc(func(path string) (*types.Package, error) {
+ if path == "unsafe" {
+ return types.Unsafe, nil
+ }
+
+ // The imports map is keyed by import path.
+ ipkg := lpkg.Imports[path]
+ if ipkg == nil {
+ if err := lpkg.importErrors[path]; err != nil {
+ return nil, err
+ }
+ // There was skew between the metadata and the
+ // import declarations, likely due to an edit
+ // race, or because the ParseFile feature was
+ // used to supply alternative file contents.
+ return nil, fmt.Errorf("no metadata for %s", path)
+ }
+
+ if ipkg.Types != nil && ipkg.Types.Complete() {
+ return ipkg.Types, nil
+ }
+ log.Fatalf("internal error: package %q without types was imported from %q", path, lpkg)
+ panic("unreachable")
+ })
+
+ // type-check
+ tc := &types.Config{
+ Importer: importer,
+
+ // Type-check bodies of functions only in initial packages.
+ // Example: for import graph A->B->C and initial packages {A,C},
+ // we can ignore function bodies in B.
+ IgnoreFuncBodies: ld.Mode&NeedDeps == 0 && !lpkg.initial,
+
+ Error: appendError,
+ Sizes: ld.sizes, // may be nil
+ }
+ if lpkg.Module != nil && lpkg.Module.GoVersion != "" {
+ tc.GoVersion = "go" + lpkg.Module.GoVersion
+ }
+ if (ld.Mode & typecheckCgo) != 0 {
+ if !typesinternal.SetUsesCgo(tc) {
+ appendError(Error{
+ Msg: "typecheckCgo requires Go 1.15+",
+ Kind: ListError,
+ })
+ return
+ }
+ }
+
+ // Type-checking is CPU intensive.
+ cpuLimit <- unit{} // acquire a token
+ defer func() { <-cpuLimit }() // release a token
+
+ typErr := types.NewChecker(tc, ld.Fset, lpkg.Types, lpkg.TypesInfo).Files(lpkg.Syntax)
+ lpkg.importErrors = nil // no longer needed
+
+ // In go/types go1.21 and go1.22, Checker.Files failed fast with a
+ // a "too new" error, without calling tc.Error and without
+ // proceeding to type-check the package (#66525).
+ // We rely on the runtimeVersion error to give the suggested remedy.
+ if typErr != nil && len(lpkg.Errors) == 0 && len(lpkg.Syntax) > 0 {
+ if msg := typErr.Error(); strings.HasPrefix(msg, "package requires newer Go version") {
+ appendError(types.Error{
+ Fset: ld.Fset,
+ Pos: lpkg.Syntax[0].Package,
+ Msg: msg,
+ })
+ }
+ }
+
+ // If !Cgo, the type-checker uses FakeImportC mode, so
+ // it doesn't invoke the importer for import "C",
+ // nor report an error for the import,
+ // or for any undefined C.f reference.
+ // We must detect this explicitly and correctly
+ // mark the package as IllTyped (by reporting an error).
+ // TODO(adonovan): if these errors are annoying,
+ // we could just set IllTyped quietly.
+ if tc.FakeImportC {
+ outer:
+ for _, f := range lpkg.Syntax {
+ for _, imp := range f.Imports {
+ if imp.Path.Value == `"C"` {
+ err := types.Error{Fset: ld.Fset, Pos: imp.Pos(), Msg: `import "C" ignored`}
+ appendError(err)
+ break outer
+ }
+ }
+ }
+ }
+
+ // If types.Checker.Files had an error that was unreported,
+ // make sure to report the unknown error so the package is illTyped.
+ if typErr != nil && len(lpkg.Errors) == 0 {
+ appendError(typErr)
+ }
+
+ // Record accumulated errors.
+ illTyped := len(lpkg.Errors) > 0
+ if !illTyped {
+ for _, imp := range lpkg.Imports {
+ if imp.IllTyped {
+ illTyped = true
+ break
+ }
+ }
+ }
+ lpkg.IllTyped = illTyped
+}
+
+// An importFunc is an implementation of the single-method
+// types.Importer interface based on a function value.
+type importerFunc func(path string) (*types.Package, error)
+
+func (f importerFunc) Import(path string) (*types.Package, error) { return f(path) }
+
+// We use a counting semaphore to limit
+// the number of parallel I/O calls or CPU threads per process.
+var (
+ ioLimit = make(chan unit, 20)
+ cpuLimit = make(chan unit, runtime.GOMAXPROCS(0))
+)
+
+func (ld *loader) parseFile(filename string) (*ast.File, error) {
+ ld.parseCacheMu.Lock()
+ v, ok := ld.parseCache[filename]
+ if ok {
+ // cache hit
+ ld.parseCacheMu.Unlock()
+ <-v.ready
+ } else {
+ // cache miss
+ v = &parseValue{ready: make(chan struct{})}
+ ld.parseCache[filename] = v
+ ld.parseCacheMu.Unlock()
+
+ var src []byte
+ for f, contents := range ld.Config.Overlay {
+ // TODO(adonovan): Inefficient for large overlays.
+ // Do an exact name-based map lookup
+ // (for nonexistent files) followed by a
+ // FileID-based map lookup (for existing ones).
+ if sameFile(f, filename) {
+ src = contents
+ break
+ }
+ }
+ var err error
+ if src == nil {
+ ioLimit <- unit{} // acquire a token
+ src, err = os.ReadFile(filename)
+ <-ioLimit // release a token
+ }
+ if err != nil {
+ v.err = err
+ } else {
+ // Parsing is CPU intensive.
+ cpuLimit <- unit{} // acquire a token
+ v.f, v.err = ld.ParseFile(ld.Fset, filename, src)
+ <-cpuLimit // release a token
+ }
+
+ close(v.ready)
+ }
+ return v.f, v.err
+}
+
+// parseFiles reads and parses the Go source files and returns the ASTs
+// of the ones that could be at least partially parsed, along with a
+// list of I/O and parse errors encountered.
+//
+// Because files are scanned in parallel, the token.Pos
+// positions of the resulting ast.Files are not ordered.
+func (ld *loader) parseFiles(filenames []string) ([]*ast.File, []error) {
+ var (
+ n = len(filenames)
+ parsed = make([]*ast.File, n)
+ errors = make([]error, n)
+ )
+ var g errgroup.Group
+ for i, filename := range filenames {
+ // This creates goroutines unnecessarily in the
+ // cache-hit case, but that case is uncommon.
+ g.Go(func() error {
+ parsed[i], errors[i] = ld.parseFile(filename)
+ return nil
+ })
+ }
+ g.Wait()
+
+ // Eliminate nils, preserving order.
+ var o int
+ for _, f := range parsed {
+ if f != nil {
+ parsed[o] = f
+ o++
+ }
+ }
+ parsed = parsed[:o]
+
+ o = 0
+ for _, err := range errors {
+ if err != nil {
+ errors[o] = err
+ o++
+ }
+ }
+ errors = errors[:o]
+
+ return parsed, errors
+}
+
+// sameFile returns true if x and y have the same basename and denote
+// the same file.
+func sameFile(x, y string) bool {
+ if x == y {
+ // It could be the case that y doesn't exist.
+ // For instance, it may be an overlay file that
+ // hasn't been written to disk. To handle that case
+ // let x == y through. (We added the exact absolute path
+ // string to the CompiledGoFiles list, so the unwritten
+ // overlay case implies x==y.)
+ return true
+ }
+ if strings.EqualFold(filepath.Base(x), filepath.Base(y)) { // (optimisation)
+ if xi, err := os.Stat(x); err == nil {
+ if yi, err := os.Stat(y); err == nil {
+ return os.SameFile(xi, yi)
+ }
+ }
+ }
+ return false
+}
+
+// loadFromExportData ensures that type information is present for the specified
+// package, loading it from an export data file on the first request.
+// On success it sets lpkg.Types to a new Package.
+func (ld *loader) loadFromExportData(lpkg *loaderPackage) error {
+ if lpkg.PkgPath == "" {
+ log.Fatalf("internal error: Package %s has no PkgPath", lpkg)
+ }
+
+ // Because gcexportdata.Read has the potential to create or
+ // modify the types.Package for each node in the transitive
+ // closure of dependencies of lpkg, all exportdata operations
+ // must be sequential. (Finer-grained locking would require
+ // changes to the gcexportdata API.)
+ //
+ // The exportMu lock guards the lpkg.Types field and the
+ // types.Package it points to, for each loaderPackage in the graph.
+ //
+ // Not all accesses to Package.Pkg need to be protected by exportMu:
+ // graph ordering ensures that direct dependencies of source
+ // packages are fully loaded before the importer reads their Pkg field.
+ ld.exportMu.Lock()
+ defer ld.exportMu.Unlock()
+
+ if tpkg := lpkg.Types; tpkg != nil && tpkg.Complete() {
+ return nil // cache hit
+ }
+
+ lpkg.IllTyped = true // fail safe
+
+ if lpkg.ExportFile == "" {
+ // Errors while building export data will have been printed to stderr.
+ return fmt.Errorf("no export data file")
+ }
+ f, err := os.Open(lpkg.ExportFile)
+ if err != nil {
+ return err
+ }
+ defer f.Close()
+
+ // Read gc export data.
+ //
+ // We don't currently support gccgo export data because all
+ // underlying workspaces use the gc toolchain. (Even build
+ // systems that support gccgo don't use it for workspace
+ // queries.)
+ r, err := gcexportdata.NewReader(f)
+ if err != nil {
+ return fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
+ }
+
+ // Build the view.
+ //
+ // The gcexportdata machinery has no concept of package ID.
+ // It identifies packages by their PkgPath, which although not
+ // globally unique is unique within the scope of one invocation
+ // of the linker, type-checker, or gcexportdata.
+ //
+ // So, we must build a PkgPath-keyed view of the global
+ // (conceptually ID-keyed) cache of packages and pass it to
+ // gcexportdata. The view must contain every existing
+ // package that might possibly be mentioned by the
+ // current package---its transitive closure.
+ //
+ // In loadPackage, we unconditionally create a types.Package for
+ // each dependency so that export data loading does not
+ // create new ones.
+ //
+ // TODO(adonovan): it would be simpler and more efficient
+ // if the export data machinery invoked a callback to
+ // get-or-create a package instead of a map.
+ //
+ view := make(map[string]*types.Package) // view seen by gcexportdata
+ seen := make(map[*loaderPackage]bool) // all visited packages
+ var visit func(pkgs map[string]*Package)
+ visit = func(pkgs map[string]*Package) {
+ for _, p := range pkgs {
+ lpkg := ld.pkgs[p.ID]
+ if !seen[lpkg] {
+ seen[lpkg] = true
+ view[lpkg.PkgPath] = lpkg.Types
+ visit(lpkg.Imports)
+ }
+ }
+ }
+ visit(lpkg.Imports)
+
+ viewLen := len(view) + 1 // adding the self package
+ // Parse the export data.
+ // (May modify incomplete packages in view but not create new ones.)
+ tpkg, err := gcexportdata.Read(r, ld.Fset, view, lpkg.PkgPath)
+ if err != nil {
+ return fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
+ }
+ if _, ok := view["go.shape"]; ok {
+ // Account for the pseudopackage "go.shape" that gets
+ // created by generic code.
+ viewLen++
+ }
+ if viewLen != len(view) {
+ log.Panicf("golang.org/x/tools/go/packages: unexpected new packages during load of %s", lpkg.PkgPath)
+ }
+
+ lpkg.Types = tpkg
+ lpkg.IllTyped = false
+ return nil
+}
+
+// impliedLoadMode returns loadMode with its dependencies.
+func impliedLoadMode(loadMode LoadMode) LoadMode {
+ if loadMode&(NeedDeps|NeedTypes|NeedTypesInfo) != 0 {
+ // All these things require knowing the import graph.
+ loadMode |= NeedImports
+ }
+ if loadMode&NeedTypes != 0 {
+ // Types require the GoVersion from Module.
+ loadMode |= NeedModule
+ }
+
+ return loadMode
+}
+
+func usesExportData(cfg *Config) bool {
+ return cfg.Mode&NeedExportFile != 0 || cfg.Mode&NeedTypes != 0 && cfg.Mode&NeedDeps == 0
+}
+
+type unit struct{}
diff --git a/vendor/golang.org/x/tools/go/packages/visit.go b/vendor/golang.org/x/tools/go/packages/visit.go
new file mode 100644
index 00000000..df14ffd9
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/packages/visit.go
@@ -0,0 +1,68 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package packages
+
+import (
+ "fmt"
+ "os"
+ "sort"
+)
+
+// Visit visits all the packages in the import graph whose roots are
+// pkgs, calling the optional pre function the first time each package
+// is encountered (preorder), and the optional post function after a
+// package's dependencies have been visited (postorder).
+// The boolean result of pre(pkg) determines whether
+// the imports of package pkg are visited.
+func Visit(pkgs []*Package, pre func(*Package) bool, post func(*Package)) {
+ seen := make(map[*Package]bool)
+ var visit func(*Package)
+ visit = func(pkg *Package) {
+ if !seen[pkg] {
+ seen[pkg] = true
+
+ if pre == nil || pre(pkg) {
+ paths := make([]string, 0, len(pkg.Imports))
+ for path := range pkg.Imports {
+ paths = append(paths, path)
+ }
+ sort.Strings(paths) // Imports is a map, this makes visit stable
+ for _, path := range paths {
+ visit(pkg.Imports[path])
+ }
+ }
+
+ if post != nil {
+ post(pkg)
+ }
+ }
+ }
+ for _, pkg := range pkgs {
+ visit(pkg)
+ }
+}
+
+// PrintErrors prints to os.Stderr the accumulated errors of all
+// packages in the import graph rooted at pkgs, dependencies first.
+// PrintErrors returns the number of errors printed.
+func PrintErrors(pkgs []*Package) int {
+ var n int
+ errModules := make(map[*Module]bool)
+ Visit(pkgs, nil, func(pkg *Package) {
+ for _, err := range pkg.Errors {
+ fmt.Fprintln(os.Stderr, err)
+ n++
+ }
+
+ // Print pkg.Module.Error once if present.
+ mod := pkg.Module
+ if mod != nil && mod.Error != nil && !errModules[mod] {
+ errModules[mod] = true
+ fmt.Fprintln(os.Stderr, mod.Error.Err)
+ n++
+ }
+ })
+ return n
+}
diff --git a/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go b/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
new file mode 100644
index 00000000..d3c2913b
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/objectpath/objectpath.go
@@ -0,0 +1,817 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package objectpath defines a naming scheme for types.Objects
+// (that is, named entities in Go programs) relative to their enclosing
+// package.
+//
+// Type-checker objects are canonical, so they are usually identified by
+// their address in memory (a pointer), but a pointer has meaning only
+// within one address space. By contrast, objectpath names allow the
+// identity of an object to be sent from one program to another,
+// establishing a correspondence between types.Object variables that are
+// distinct but logically equivalent.
+//
+// A single object may have multiple paths. In this example,
+//
+// type A struct{ X int }
+// type B A
+//
+// the field X has two paths due to its membership of both A and B.
+// The For(obj) function always returns one of these paths, arbitrarily
+// but consistently.
+package objectpath
+
+import (
+ "fmt"
+ "go/types"
+ "strconv"
+ "strings"
+
+ "golang.org/x/tools/internal/aliases"
+ "golang.org/x/tools/internal/typesinternal"
+)
+
+// TODO(adonovan): think about generic aliases.
+
+// A Path is an opaque name that identifies a types.Object
+// relative to its package. Conceptually, the name consists of a
+// sequence of destructuring operations applied to the package scope
+// to obtain the original object.
+// The name does not include the package itself.
+type Path string
+
+// Encoding
+//
+// An object path is a textual and (with training) human-readable encoding
+// of a sequence of destructuring operators, starting from a types.Package.
+// The sequences represent a path through the package/object/type graph.
+// We classify these operators by their type:
+//
+// PO package->object Package.Scope.Lookup
+// OT object->type Object.Type
+// TT type->type Type.{Elem,Key,{,{,Recv}Type}Params,Results,Underlying,Rhs} [EKPRUTrCa]
+// TO type->object Type.{At,Field,Method,Obj} [AFMO]
+//
+// All valid paths start with a package and end at an object
+// and thus may be defined by the regular language:
+//
+// objectpath = PO (OT TT* TO)*
+//
+// The concrete encoding follows directly:
+// - The only PO operator is Package.Scope.Lookup, which requires an identifier.
+// - The only OT operator is Object.Type,
+// which we encode as '.' because dot cannot appear in an identifier.
+// - The TT operators are encoded as [EKPRUTrCa];
+// two of these ({,Recv}TypeParams) require an integer operand,
+// which is encoded as a string of decimal digits.
+// - The TO operators are encoded as [AFMO];
+// three of these (At,Field,Method) require an integer operand,
+// which is encoded as a string of decimal digits.
+// These indices are stable across different representations
+// of the same package, even source and export data.
+// The indices used are implementation specific and may not correspond to
+// the argument to the go/types function.
+//
+// In the example below,
+//
+// package p
+//
+// type T interface {
+// f() (a string, b struct{ X int })
+// }
+//
+// field X has the path "T.UM0.RA1.F0",
+// representing the following sequence of operations:
+//
+// p.Lookup("T") T
+// .Type().Underlying().Method(0). f
+// .Type().Results().At(1) b
+// .Type().Field(0) X
+//
+// The encoding is not maximally compact---every R or P is
+// followed by an A, for example---but this simplifies the
+// encoder and decoder.
+const (
+ // object->type operators
+ opType = '.' // .Type() (Object)
+
+ // type->type operators
+ opElem = 'E' // .Elem() (Pointer, Slice, Array, Chan, Map)
+ opKey = 'K' // .Key() (Map)
+ opParams = 'P' // .Params() (Signature)
+ opResults = 'R' // .Results() (Signature)
+ opUnderlying = 'U' // .Underlying() (Named)
+ opTypeParam = 'T' // .TypeParams.At(i) (Named, Signature)
+ opRecvTypeParam = 'r' // .RecvTypeParams.At(i) (Signature)
+ opConstraint = 'C' // .Constraint() (TypeParam)
+ opRhs = 'a' // .Rhs() (Alias)
+
+ // type->object operators
+ opAt = 'A' // .At(i) (Tuple)
+ opField = 'F' // .Field(i) (Struct)
+ opMethod = 'M' // .Method(i) (Named or Interface; not Struct: "promoted" names are ignored)
+ opObj = 'O' // .Obj() (Named, TypeParam)
+)
+
+// For is equivalent to new(Encoder).For(obj).
+//
+// It may be more efficient to reuse a single Encoder across several calls.
+func For(obj types.Object) (Path, error) {
+ return new(Encoder).For(obj)
+}
+
+// An Encoder amortizes the cost of encoding the paths of multiple objects.
+// The zero value of an Encoder is ready to use.
+type Encoder struct {
+ scopeMemo map[*types.Scope][]types.Object // memoization of scopeObjects
+}
+
+// For returns the path to an object relative to its package,
+// or an error if the object is not accessible from the package's Scope.
+//
+// The For function guarantees to return a path only for the following objects:
+// - package-level types
+// - exported package-level non-types
+// - methods
+// - parameter and result variables
+// - struct fields
+// These objects are sufficient to define the API of their package.
+// The objects described by a package's export data are drawn from this set.
+//
+// The set of objects accessible from a package's Scope depends on
+// whether the package was produced by type-checking syntax, or
+// reading export data; the latter may have a smaller Scope since
+// export data trims objects that are not reachable from an exported
+// declaration. For example, the For function will return a path for
+// an exported method of an unexported type that is not reachable
+// from any public declaration; this path will cause the Object
+// function to fail if called on a package loaded from export data.
+// TODO(adonovan): is this a bug or feature? Should this package
+// compute accessibility in the same way?
+//
+// For does not return a path for predeclared names, imported package
+// names, local names, and unexported package-level names (except
+// types).
+//
+// Example: given this definition,
+//
+// package p
+//
+// type T interface {
+// f() (a string, b struct{ X int })
+// }
+//
+// For(X) would return a path that denotes the following sequence of operations:
+//
+// p.Scope().Lookup("T") (TypeName T)
+// .Type().Underlying().Method(0). (method Func f)
+// .Type().Results().At(1) (field Var b)
+// .Type().Field(0) (field Var X)
+//
+// where p is the package (*types.Package) to which X belongs.
+func (enc *Encoder) For(obj types.Object) (Path, error) {
+ pkg := obj.Pkg()
+
+ // This table lists the cases of interest.
+ //
+ // Object Action
+ // ------ ------
+ // nil reject
+ // builtin reject
+ // pkgname reject
+ // label reject
+ // var
+ // package-level accept
+ // func param/result accept
+ // local reject
+ // struct field accept
+ // const
+ // package-level accept
+ // local reject
+ // func
+ // package-level accept
+ // init functions reject
+ // concrete method accept
+ // interface method accept
+ // type
+ // package-level accept
+ // local reject
+ //
+ // The only accessible package-level objects are members of pkg itself.
+ //
+ // The cases are handled in four steps:
+ //
+ // 1. reject nil and builtin
+ // 2. accept package-level objects
+ // 3. reject obviously invalid objects
+ // 4. search the API for the path to the param/result/field/method.
+
+ // 1. reference to nil or builtin?
+ if pkg == nil {
+ return "", fmt.Errorf("predeclared %s has no path", obj)
+ }
+ scope := pkg.Scope()
+
+ // 2. package-level object?
+ if scope.Lookup(obj.Name()) == obj {
+ // Only exported objects (and non-exported types) have a path.
+ // Non-exported types may be referenced by other objects.
+ if _, ok := obj.(*types.TypeName); !ok && !obj.Exported() {
+ return "", fmt.Errorf("no path for non-exported %v", obj)
+ }
+ return Path(obj.Name()), nil
+ }
+
+ // 3. Not a package-level object.
+ // Reject obviously non-viable cases.
+ switch obj := obj.(type) {
+ case *types.TypeName:
+ if _, ok := types.Unalias(obj.Type()).(*types.TypeParam); !ok {
+ // With the exception of type parameters, only package-level type names
+ // have a path.
+ return "", fmt.Errorf("no path for %v", obj)
+ }
+ case *types.Const, // Only package-level constants have a path.
+ *types.Label, // Labels are function-local.
+ *types.PkgName: // PkgNames are file-local.
+ return "", fmt.Errorf("no path for %v", obj)
+
+ case *types.Var:
+ // Could be:
+ // - a field (obj.IsField())
+ // - a func parameter or result
+ // - a local var.
+ // Sadly there is no way to distinguish
+ // a param/result from a local
+ // so we must proceed to the find.
+
+ case *types.Func:
+ // A func, if not package-level, must be a method.
+ if recv := obj.Type().(*types.Signature).Recv(); recv == nil {
+ return "", fmt.Errorf("func is not a method: %v", obj)
+ }
+
+ if path, ok := enc.concreteMethod(obj); ok {
+ // Fast path for concrete methods that avoids looping over scope.
+ return path, nil
+ }
+
+ default:
+ panic(obj)
+ }
+
+ // 4. Search the API for the path to the var (field/param/result) or method.
+
+ // First inspect package-level named types.
+ // In the presence of path aliases, these give
+ // the best paths because non-types may
+ // refer to types, but not the reverse.
+ empty := make([]byte, 0, 48) // initial space
+ objs := enc.scopeObjects(scope)
+ for _, o := range objs {
+ tname, ok := o.(*types.TypeName)
+ if !ok {
+ continue // handle non-types in second pass
+ }
+
+ path := append(empty, o.Name()...)
+ path = append(path, opType)
+
+ T := o.Type()
+ if alias, ok := T.(*types.Alias); ok {
+ if r := findTypeParam(obj, aliases.TypeParams(alias), path, opTypeParam); r != nil {
+ return Path(r), nil
+ }
+ if r := find(obj, aliases.Rhs(alias), append(path, opRhs)); r != nil {
+ return Path(r), nil
+ }
+
+ } else if tname.IsAlias() {
+ // legacy alias
+ if r := find(obj, T, path); r != nil {
+ return Path(r), nil
+ }
+
+ } else if named, ok := T.(*types.Named); ok {
+ // defined (named) type
+ if r := findTypeParam(obj, named.TypeParams(), path, opTypeParam); r != nil {
+ return Path(r), nil
+ }
+ if r := find(obj, named.Underlying(), append(path, opUnderlying)); r != nil {
+ return Path(r), nil
+ }
+ }
+ }
+
+ // Then inspect everything else:
+ // non-types, and declared methods of defined types.
+ for _, o := range objs {
+ path := append(empty, o.Name()...)
+ if _, ok := o.(*types.TypeName); !ok {
+ if o.Exported() {
+ // exported non-type (const, var, func)
+ if r := find(obj, o.Type(), append(path, opType)); r != nil {
+ return Path(r), nil
+ }
+ }
+ continue
+ }
+
+ // Inspect declared methods of defined types.
+ if T, ok := types.Unalias(o.Type()).(*types.Named); ok {
+ path = append(path, opType)
+ // The method index here is always with respect
+ // to the underlying go/types data structures,
+ // which ultimately derives from source order
+ // and must be preserved by export data.
+ for i := 0; i < T.NumMethods(); i++ {
+ m := T.Method(i)
+ path2 := appendOpArg(path, opMethod, i)
+ if m == obj {
+ return Path(path2), nil // found declared method
+ }
+ if r := find(obj, m.Type(), append(path2, opType)); r != nil {
+ return Path(r), nil
+ }
+ }
+ }
+ }
+
+ return "", fmt.Errorf("can't find path for %v in %s", obj, pkg.Path())
+}
+
+func appendOpArg(path []byte, op byte, arg int) []byte {
+ path = append(path, op)
+ path = strconv.AppendInt(path, int64(arg), 10)
+ return path
+}
+
+// concreteMethod returns the path for meth, which must have a non-nil receiver.
+// The second return value indicates success and may be false if the method is
+// an interface method or if it is an instantiated method.
+//
+// This function is just an optimization that avoids the general scope walking
+// approach. You are expected to fall back to the general approach if this
+// function fails.
+func (enc *Encoder) concreteMethod(meth *types.Func) (Path, bool) {
+ // Concrete methods can only be declared on package-scoped named types. For
+ // that reason we can skip the expensive walk over the package scope: the
+ // path will always be package -> named type -> method. We can trivially get
+ // the type name from the receiver, and only have to look over the type's
+ // methods to find the method index.
+ //
+ // Methods on generic types require special consideration, however. Consider
+ // the following package:
+ //
+ // L1: type S[T any] struct{}
+ // L2: func (recv S[A]) Foo() { recv.Bar() }
+ // L3: func (recv S[B]) Bar() { }
+ // L4: type Alias = S[int]
+ // L5: func _[T any]() { var s S[int]; s.Foo() }
+ //
+ // The receivers of methods on generic types are instantiations. L2 and L3
+ // instantiate S with the type-parameters A and B, which are scoped to the
+ // respective methods. L4 and L5 each instantiate S with int. Each of these
+ // instantiations has its own method set, full of methods (and thus objects)
+ // with receivers whose types are the respective instantiations. In other
+ // words, we have
+ //
+ // S[A].Foo, S[A].Bar
+ // S[B].Foo, S[B].Bar
+ // S[int].Foo, S[int].Bar
+ //
+ // We may thus be trying to produce object paths for any of these objects.
+ //
+ // S[A].Foo and S[B].Bar are the origin methods, and their paths are S.Foo
+ // and S.Bar, which are the paths that this function naturally produces.
+ //
+ // S[A].Bar, S[B].Foo, and both methods on S[int] are instantiations that
+ // don't correspond to the origin methods. For S[int], this is significant.
+ // The most precise object path for S[int].Foo, for example, is Alias.Foo,
+ // not S.Foo. Our function, however, would produce S.Foo, which would
+ // resolve to a different object.
+ //
+ // For S[A].Bar and S[B].Foo it could be argued that S.Bar and S.Foo are
+ // still the correct paths, since only the origin methods have meaningful
+ // paths. But this is likely only true for trivial cases and has edge cases.
+ // Since this function is only an optimization, we err on the side of giving
+ // up, deferring to the slower but definitely correct algorithm. Most users
+ // of objectpath will only be giving us origin methods, anyway, as referring
+ // to instantiated methods is usually not useful.
+
+ if meth.Origin() != meth {
+ return "", false
+ }
+
+ _, named := typesinternal.ReceiverNamed(meth.Type().(*types.Signature).Recv())
+ if named == nil {
+ return "", false
+ }
+
+ if types.IsInterface(named) {
+ // Named interfaces don't have to be package-scoped
+ //
+ // TODO(dominikh): opt: if scope.Lookup(name) == named, then we can apply this optimization to interface
+ // methods, too, I think.
+ return "", false
+ }
+
+ // Preallocate space for the name, opType, opMethod, and some digits.
+ name := named.Obj().Name()
+ path := make([]byte, 0, len(name)+8)
+ path = append(path, name...)
+ path = append(path, opType)
+
+ // Method indices are w.r.t. the go/types data structures,
+ // ultimately deriving from source order,
+ // which is preserved by export data.
+ for i := 0; i < named.NumMethods(); i++ {
+ if named.Method(i) == meth {
+ path = appendOpArg(path, opMethod, i)
+ return Path(path), true
+ }
+ }
+
+ // Due to golang/go#59944, go/types fails to associate the receiver with
+ // certain methods on cgo types.
+ //
+ // TODO(rfindley): replace this panic once golang/go#59944 is fixed in all Go
+ // versions gopls supports.
+ return "", false
+ // panic(fmt.Sprintf("couldn't find method %s on type %s; methods: %#v", meth, named, enc.namedMethods(named)))
+}
+
+// find finds obj within type T, returning the path to it, or nil if not found.
+//
+// The seen map is used to short circuit cycles through type parameters. If
+// nil, it will be allocated as necessary.
+//
+// The seenMethods map is used internally to short circuit cycles through
+// interface methods, such as occur in the following example:
+//
+// type I interface { f() interface{I} }
+//
+// See golang/go#68046 for details.
+func find(obj types.Object, T types.Type, path []byte) []byte {
+ return (&finder{obj: obj}).find(T, path)
+}
+
+// finder closes over search state for a call to find.
+type finder struct {
+ obj types.Object // the sought object
+ seenTParamNames map[*types.TypeName]bool // for cycle breaking through type parameters
+ seenMethods map[*types.Func]bool // for cycle breaking through recursive interfaces
+}
+
+func (f *finder) find(T types.Type, path []byte) []byte {
+ switch T := T.(type) {
+ case *types.Alias:
+ return f.find(types.Unalias(T), path)
+ case *types.Basic, *types.Named:
+ // Named types belonging to pkg were handled already,
+ // so T must belong to another package. No path.
+ return nil
+ case *types.Pointer:
+ return f.find(T.Elem(), append(path, opElem))
+ case *types.Slice:
+ return f.find(T.Elem(), append(path, opElem))
+ case *types.Array:
+ return f.find(T.Elem(), append(path, opElem))
+ case *types.Chan:
+ return f.find(T.Elem(), append(path, opElem))
+ case *types.Map:
+ if r := f.find(T.Key(), append(path, opKey)); r != nil {
+ return r
+ }
+ return f.find(T.Elem(), append(path, opElem))
+ case *types.Signature:
+ if r := f.findTypeParam(T.RecvTypeParams(), path, opRecvTypeParam); r != nil {
+ return r
+ }
+ if r := f.findTypeParam(T.TypeParams(), path, opTypeParam); r != nil {
+ return r
+ }
+ if r := f.find(T.Params(), append(path, opParams)); r != nil {
+ return r
+ }
+ return f.find(T.Results(), append(path, opResults))
+ case *types.Struct:
+ for i := 0; i < T.NumFields(); i++ {
+ fld := T.Field(i)
+ path2 := appendOpArg(path, opField, i)
+ if fld == f.obj {
+ return path2 // found field var
+ }
+ if r := f.find(fld.Type(), append(path2, opType)); r != nil {
+ return r
+ }
+ }
+ return nil
+ case *types.Tuple:
+ for i := 0; i < T.Len(); i++ {
+ v := T.At(i)
+ path2 := appendOpArg(path, opAt, i)
+ if v == f.obj {
+ return path2 // found param/result var
+ }
+ if r := f.find(v.Type(), append(path2, opType)); r != nil {
+ return r
+ }
+ }
+ return nil
+ case *types.Interface:
+ for i := 0; i < T.NumMethods(); i++ {
+ m := T.Method(i)
+ if f.seenMethods[m] {
+ return nil
+ }
+ path2 := appendOpArg(path, opMethod, i)
+ if m == f.obj {
+ return path2 // found interface method
+ }
+ if f.seenMethods == nil {
+ f.seenMethods = make(map[*types.Func]bool)
+ }
+ f.seenMethods[m] = true
+ if r := f.find(m.Type(), append(path2, opType)); r != nil {
+ return r
+ }
+ }
+ return nil
+ case *types.TypeParam:
+ name := T.Obj()
+ if f.seenTParamNames[name] {
+ return nil
+ }
+ if name == f.obj {
+ return append(path, opObj)
+ }
+ if f.seenTParamNames == nil {
+ f.seenTParamNames = make(map[*types.TypeName]bool)
+ }
+ f.seenTParamNames[name] = true
+ if r := f.find(T.Constraint(), append(path, opConstraint)); r != nil {
+ return r
+ }
+ return nil
+ }
+ panic(T)
+}
+
+func findTypeParam(obj types.Object, list *types.TypeParamList, path []byte, op byte) []byte {
+ return (&finder{obj: obj}).findTypeParam(list, path, op)
+}
+
+func (f *finder) findTypeParam(list *types.TypeParamList, path []byte, op byte) []byte {
+ for i := 0; i < list.Len(); i++ {
+ tparam := list.At(i)
+ path2 := appendOpArg(path, op, i)
+ if r := f.find(tparam, path2); r != nil {
+ return r
+ }
+ }
+ return nil
+}
+
+// Object returns the object denoted by path p within the package pkg.
+func Object(pkg *types.Package, p Path) (types.Object, error) {
+ pathstr := string(p)
+ if pathstr == "" {
+ return nil, fmt.Errorf("empty path")
+ }
+
+ var pkgobj, suffix string
+ if dot := strings.IndexByte(pathstr, opType); dot < 0 {
+ pkgobj = pathstr
+ } else {
+ pkgobj = pathstr[:dot]
+ suffix = pathstr[dot:] // suffix starts with "."
+ }
+
+ obj := pkg.Scope().Lookup(pkgobj)
+ if obj == nil {
+ return nil, fmt.Errorf("package %s does not contain %q", pkg.Path(), pkgobj)
+ }
+
+ // abstraction of *types.{Pointer,Slice,Array,Chan,Map}
+ type hasElem interface {
+ Elem() types.Type
+ }
+ // abstraction of *types.{Named,Signature}
+ type hasTypeParams interface {
+ TypeParams() *types.TypeParamList
+ }
+ // abstraction of *types.{Alias,Named,TypeParam}
+ type hasObj interface {
+ Obj() *types.TypeName
+ }
+
+ // The loop state is the pair (t, obj),
+ // exactly one of which is non-nil, initially obj.
+ // All suffixes start with '.' (the only object->type operation),
+ // followed by optional type->type operations,
+ // then a type->object operation.
+ // The cycle then repeats.
+ var t types.Type
+ for suffix != "" {
+ code := suffix[0]
+ suffix = suffix[1:]
+
+ // Codes [AFMTr] have an integer operand.
+ var index int
+ switch code {
+ case opAt, opField, opMethod, opTypeParam, opRecvTypeParam:
+ rest := strings.TrimLeft(suffix, "0123456789")
+ numerals := suffix[:len(suffix)-len(rest)]
+ suffix = rest
+ i, err := strconv.Atoi(numerals)
+ if err != nil {
+ return nil, fmt.Errorf("invalid path: bad numeric operand %q for code %q", numerals, code)
+ }
+ index = int(i)
+ case opObj:
+ // no operand
+ default:
+ // The suffix must end with a type->object operation.
+ if suffix == "" {
+ return nil, fmt.Errorf("invalid path: ends with %q, want [AFMO]", code)
+ }
+ }
+
+ if code == opType {
+ if t != nil {
+ return nil, fmt.Errorf("invalid path: unexpected %q in type context", opType)
+ }
+ t = obj.Type()
+ obj = nil
+ continue
+ }
+
+ if t == nil {
+ return nil, fmt.Errorf("invalid path: code %q in object context", code)
+ }
+
+ // Inv: t != nil, obj == nil
+
+ t = types.Unalias(t)
+ switch code {
+ case opElem:
+ hasElem, ok := t.(hasElem) // Pointer, Slice, Array, Chan, Map
+ if !ok {
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want pointer, slice, array, chan or map)", code, t, t)
+ }
+ t = hasElem.Elem()
+
+ case opKey:
+ mapType, ok := t.(*types.Map)
+ if !ok {
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want map)", code, t, t)
+ }
+ t = mapType.Key()
+
+ case opParams:
+ sig, ok := t.(*types.Signature)
+ if !ok {
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
+ }
+ t = sig.Params()
+
+ case opResults:
+ sig, ok := t.(*types.Signature)
+ if !ok {
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
+ }
+ t = sig.Results()
+
+ case opUnderlying:
+ named, ok := t.(*types.Named)
+ if !ok {
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named)", code, t, t)
+ }
+ t = named.Underlying()
+
+ case opRhs:
+ if alias, ok := t.(*types.Alias); ok {
+ t = aliases.Rhs(alias)
+ } else if false && aliases.Enabled() {
+ // The Enabled check is too expensive, so for now we
+ // simply assume that aliases are not enabled.
+ // TODO(adonovan): replace with "if true {" when go1.24 is assured.
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want alias)", code, t, t)
+ }
+
+ case opTypeParam:
+ hasTypeParams, ok := t.(hasTypeParams) // Named, Signature
+ if !ok {
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named or signature)", code, t, t)
+ }
+ tparams := hasTypeParams.TypeParams()
+ if n := tparams.Len(); index >= n {
+ return nil, fmt.Errorf("tuple index %d out of range [0-%d)", index, n)
+ }
+ t = tparams.At(index)
+
+ case opRecvTypeParam:
+ sig, ok := t.(*types.Signature) // Signature
+ if !ok {
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want signature)", code, t, t)
+ }
+ rtparams := sig.RecvTypeParams()
+ if n := rtparams.Len(); index >= n {
+ return nil, fmt.Errorf("tuple index %d out of range [0-%d)", index, n)
+ }
+ t = rtparams.At(index)
+
+ case opConstraint:
+ tparam, ok := t.(*types.TypeParam)
+ if !ok {
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want type parameter)", code, t, t)
+ }
+ t = tparam.Constraint()
+
+ case opAt:
+ tuple, ok := t.(*types.Tuple)
+ if !ok {
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want tuple)", code, t, t)
+ }
+ if n := tuple.Len(); index >= n {
+ return nil, fmt.Errorf("tuple index %d out of range [0-%d)", index, n)
+ }
+ obj = tuple.At(index)
+ t = nil
+
+ case opField:
+ structType, ok := t.(*types.Struct)
+ if !ok {
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want struct)", code, t, t)
+ }
+ if n := structType.NumFields(); index >= n {
+ return nil, fmt.Errorf("field index %d out of range [0-%d)", index, n)
+ }
+ obj = structType.Field(index)
+ t = nil
+
+ case opMethod:
+ switch t := t.(type) {
+ case *types.Interface:
+ if index >= t.NumMethods() {
+ return nil, fmt.Errorf("method index %d out of range [0-%d)", index, t.NumMethods())
+ }
+ obj = t.Method(index) // Id-ordered
+
+ case *types.Named:
+ if index >= t.NumMethods() {
+ return nil, fmt.Errorf("method index %d out of range [0-%d)", index, t.NumMethods())
+ }
+ obj = t.Method(index)
+
+ default:
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want interface or named)", code, t, t)
+ }
+ t = nil
+
+ case opObj:
+ hasObj, ok := t.(hasObj)
+ if !ok {
+ return nil, fmt.Errorf("cannot apply %q to %s (got %T, want named or type param)", code, t, t)
+ }
+ obj = hasObj.Obj()
+ t = nil
+
+ default:
+ return nil, fmt.Errorf("invalid path: unknown code %q", code)
+ }
+ }
+
+ if obj == nil {
+ panic(p) // path does not end in an object-valued operator
+ }
+
+ if obj.Pkg() != pkg {
+ return nil, fmt.Errorf("path denotes %s, which belongs to a different package", obj)
+ }
+
+ return obj, nil // success
+}
+
+// scopeObjects is a memoization of scope objects.
+// Callers must not modify the result.
+func (enc *Encoder) scopeObjects(scope *types.Scope) []types.Object {
+ m := enc.scopeMemo
+ if m == nil {
+ m = make(map[*types.Scope][]types.Object)
+ enc.scopeMemo = m
+ }
+ objs, ok := m[scope]
+ if !ok {
+ names := scope.Names() // allocates and sorts
+ objs = make([]types.Object, len(names))
+ for i, name := range names {
+ objs[i] = scope.Lookup(name)
+ }
+ m[scope] = objs
+ }
+ return objs
+}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/callee.go b/vendor/golang.org/x/tools/go/types/typeutil/callee.go
new file mode 100644
index 00000000..5f10f56c
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/callee.go
@@ -0,0 +1,85 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typeutil
+
+import (
+ "go/ast"
+ "go/types"
+ _ "unsafe" // for linkname
+)
+
+// Callee returns the named target of a function call, if any:
+// a function, method, builtin, or variable.
+//
+// Functions and methods may potentially have type parameters.
+//
+// Note: for calls of instantiated functions and methods, Callee returns
+// the corresponding generic function or method on the generic type.
+func Callee(info *types.Info, call *ast.CallExpr) types.Object {
+ obj := info.Uses[usedIdent(info, call.Fun)]
+ if obj == nil {
+ return nil
+ }
+ if _, ok := obj.(*types.TypeName); ok {
+ return nil
+ }
+ return obj
+}
+
+// StaticCallee returns the target (function or method) of a static function
+// call, if any. It returns nil for calls to builtins.
+//
+// Note: for calls of instantiated functions and methods, StaticCallee returns
+// the corresponding generic function or method on the generic type.
+func StaticCallee(info *types.Info, call *ast.CallExpr) *types.Func {
+ obj := info.Uses[usedIdent(info, call.Fun)]
+ fn, _ := obj.(*types.Func)
+ if fn == nil || interfaceMethod(fn) {
+ return nil
+ }
+ return fn
+}
+
+// usedIdent is the implementation of [internal/typesinternal.UsedIdent].
+// It returns the identifier associated with e.
+// See typesinternal.UsedIdent for a fuller description.
+// This function should live in typesinternal, but cannot because it would
+// create an import cycle.
+//
+//go:linkname usedIdent golang.org/x/tools/go/types/typeutil.usedIdent
+func usedIdent(info *types.Info, e ast.Expr) *ast.Ident {
+ if info.Types == nil || info.Uses == nil {
+ panic("one of info.Types or info.Uses is nil; both must be populated")
+ }
+ // Look through type instantiation if necessary.
+ switch d := ast.Unparen(e).(type) {
+ case *ast.IndexExpr:
+ if info.Types[d.Index].IsType() {
+ e = d.X
+ }
+ case *ast.IndexListExpr:
+ e = d.X
+ }
+
+ switch e := ast.Unparen(e).(type) {
+ // info.Uses always has the object we want, even for selector expressions.
+ // We don't need info.Selections.
+ // See go/types/recording.go:recordSelection.
+ case *ast.Ident:
+ return e
+ case *ast.SelectorExpr:
+ return e.Sel
+ }
+ return nil
+}
+
+// interfaceMethod reports whether its argument is a method of an interface.
+// This function should live in typesinternal, but cannot because it would create an import cycle.
+//
+//go:linkname interfaceMethod golang.org/x/tools/go/types/typeutil.interfaceMethod
+func interfaceMethod(f *types.Func) bool {
+ recv := f.Signature().Recv()
+ return recv != nil && types.IsInterface(recv.Type())
+}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/imports.go b/vendor/golang.org/x/tools/go/types/typeutil/imports.go
new file mode 100644
index 00000000..b81ce0c3
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/imports.go
@@ -0,0 +1,30 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typeutil
+
+import "go/types"
+
+// Dependencies returns all dependencies of the specified packages.
+//
+// Dependent packages appear in topological order: if package P imports
+// package Q, Q appears earlier than P in the result.
+// The algorithm follows import statements in the order they
+// appear in the source code, so the result is a total order.
+func Dependencies(pkgs ...*types.Package) []*types.Package {
+ var result []*types.Package
+ seen := make(map[*types.Package]bool)
+ var visit func(pkgs []*types.Package)
+ visit = func(pkgs []*types.Package) {
+ for _, p := range pkgs {
+ if !seen[p] {
+ seen[p] = true
+ visit(p.Imports())
+ result = append(result, p)
+ }
+ }
+ }
+ visit(pkgs)
+ return result
+}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/map.go b/vendor/golang.org/x/tools/go/types/typeutil/map.go
new file mode 100644
index 00000000..b6d542c6
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/map.go
@@ -0,0 +1,475 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package typeutil defines various utilities for types, such as [Map],
+// a hash table that maps [types.Type] to any value.
+package typeutil
+
+import (
+ "bytes"
+ "fmt"
+ "go/types"
+ "hash/maphash"
+ "unsafe"
+
+ "golang.org/x/tools/internal/typeparams"
+)
+
+// Map is a hash-table-based mapping from types (types.Type) to
+// arbitrary values. The concrete types that implement
+// the Type interface are pointers. Since they are not canonicalized,
+// == cannot be used to check for equivalence, and thus we cannot
+// simply use a Go map.
+//
+// Just as with map[K]V, a nil *Map is a valid empty map.
+//
+// Read-only map operations ([Map.At], [Map.Len], and so on) may
+// safely be called concurrently.
+//
+// TODO(adonovan): deprecate in favor of https://go.dev/issues/69420
+// and 69559, if the latter proposals for a generic hash-map type and
+// a types.Hash function are accepted.
+type Map struct {
+ table map[uint32][]entry // maps hash to bucket; entry.key==nil means unused
+ length int // number of map entries
+}
+
+// entry is an entry (key/value association) in a hash bucket.
+type entry struct {
+ key types.Type
+ value any
+}
+
+// SetHasher has no effect.
+//
+// It is a relic of an optimization that is no longer profitable. Do
+// not use [Hasher], [MakeHasher], or [SetHasher] in new code.
+func (m *Map) SetHasher(Hasher) {}
+
+// Delete removes the entry with the given key, if any.
+// It returns true if the entry was found.
+func (m *Map) Delete(key types.Type) bool {
+ if m != nil && m.table != nil {
+ hash := hash(key)
+ bucket := m.table[hash]
+ for i, e := range bucket {
+ if e.key != nil && types.Identical(key, e.key) {
+ // We can't compact the bucket as it
+ // would disturb iterators.
+ bucket[i] = entry{}
+ m.length--
+ return true
+ }
+ }
+ }
+ return false
+}
+
+// At returns the map entry for the given key.
+// The result is nil if the entry is not present.
+func (m *Map) At(key types.Type) any {
+ if m != nil && m.table != nil {
+ for _, e := range m.table[hash(key)] {
+ if e.key != nil && types.Identical(key, e.key) {
+ return e.value
+ }
+ }
+ }
+ return nil
+}
+
+// Set sets the map entry for key to val,
+// and returns the previous entry, if any.
+func (m *Map) Set(key types.Type, value any) (prev any) {
+ if m.table != nil {
+ hash := hash(key)
+ bucket := m.table[hash]
+ var hole *entry
+ for i, e := range bucket {
+ if e.key == nil {
+ hole = &bucket[i]
+ } else if types.Identical(key, e.key) {
+ prev = e.value
+ bucket[i].value = value
+ return
+ }
+ }
+
+ if hole != nil {
+ *hole = entry{key, value} // overwrite deleted entry
+ } else {
+ m.table[hash] = append(bucket, entry{key, value})
+ }
+ } else {
+ hash := hash(key)
+ m.table = map[uint32][]entry{hash: {entry{key, value}}}
+ }
+
+ m.length++
+ return
+}
+
+// Len returns the number of map entries.
+func (m *Map) Len() int {
+ if m != nil {
+ return m.length
+ }
+ return 0
+}
+
+// Iterate calls function f on each entry in the map in unspecified order.
+//
+// If f should mutate the map, Iterate provides the same guarantees as
+// Go maps: if f deletes a map entry that Iterate has not yet reached,
+// f will not be invoked for it, but if f inserts a map entry that
+// Iterate has not yet reached, whether or not f will be invoked for
+// it is unspecified.
+func (m *Map) Iterate(f func(key types.Type, value any)) {
+ if m != nil {
+ for _, bucket := range m.table {
+ for _, e := range bucket {
+ if e.key != nil {
+ f(e.key, e.value)
+ }
+ }
+ }
+ }
+}
+
+// Keys returns a new slice containing the set of map keys.
+// The order is unspecified.
+func (m *Map) Keys() []types.Type {
+ keys := make([]types.Type, 0, m.Len())
+ m.Iterate(func(key types.Type, _ any) {
+ keys = append(keys, key)
+ })
+ return keys
+}
+
+func (m *Map) toString(values bool) string {
+ if m == nil {
+ return "{}"
+ }
+ var buf bytes.Buffer
+ fmt.Fprint(&buf, "{")
+ sep := ""
+ m.Iterate(func(key types.Type, value any) {
+ fmt.Fprint(&buf, sep)
+ sep = ", "
+ fmt.Fprint(&buf, key)
+ if values {
+ fmt.Fprintf(&buf, ": %q", value)
+ }
+ })
+ fmt.Fprint(&buf, "}")
+ return buf.String()
+}
+
+// String returns a string representation of the map's entries.
+// Values are printed using fmt.Sprintf("%v", v).
+// Order is unspecified.
+func (m *Map) String() string {
+ return m.toString(true)
+}
+
+// KeysString returns a string representation of the map's key set.
+// Order is unspecified.
+func (m *Map) KeysString() string {
+ return m.toString(false)
+}
+
+// -- Hasher --
+
+// hash returns the hash of type t.
+// TODO(adonovan): replace by types.Hash when Go proposal #69420 is accepted.
+func hash(t types.Type) uint32 {
+ return theHasher.Hash(t)
+}
+
+// A Hasher provides a [Hasher.Hash] method to map a type to its hash value.
+// Hashers are stateless, and all are equivalent.
+type Hasher struct{}
+
+var theHasher Hasher
+
+// MakeHasher returns Hasher{}.
+// Hashers are stateless; all are equivalent.
+func MakeHasher() Hasher { return theHasher }
+
+// Hash computes a hash value for the given type t such that
+// Identical(t, t') => Hash(t) == Hash(t').
+func (h Hasher) Hash(t types.Type) uint32 {
+ return hasher{inGenericSig: false}.hash(t)
+}
+
+// hasher holds the state of a single Hash traversal: whether we are
+// inside the signature of a generic function; this is used to
+// optimize [hasher.hashTypeParam].
+type hasher struct{ inGenericSig bool }
+
+// hashString computes the Fowler–Noll–Vo hash of s.
+func hashString(s string) uint32 {
+ var h uint32
+ for i := 0; i < len(s); i++ {
+ h ^= uint32(s[i])
+ h *= 16777619
+ }
+ return h
+}
+
+// hash computes the hash of t.
+func (h hasher) hash(t types.Type) uint32 {
+ // See Identical for rationale.
+ switch t := t.(type) {
+ case *types.Basic:
+ return uint32(t.Kind())
+
+ case *types.Alias:
+ return h.hash(types.Unalias(t))
+
+ case *types.Array:
+ return 9043 + 2*uint32(t.Len()) + 3*h.hash(t.Elem())
+
+ case *types.Slice:
+ return 9049 + 2*h.hash(t.Elem())
+
+ case *types.Struct:
+ var hash uint32 = 9059
+ for i, n := 0, t.NumFields(); i < n; i++ {
+ f := t.Field(i)
+ if f.Anonymous() {
+ hash += 8861
+ }
+ hash += hashString(t.Tag(i))
+ hash += hashString(f.Name()) // (ignore f.Pkg)
+ hash += h.hash(f.Type())
+ }
+ return hash
+
+ case *types.Pointer:
+ return 9067 + 2*h.hash(t.Elem())
+
+ case *types.Signature:
+ var hash uint32 = 9091
+ if t.Variadic() {
+ hash *= 8863
+ }
+
+ tparams := t.TypeParams()
+ if n := tparams.Len(); n > 0 {
+ h.inGenericSig = true // affects constraints, params, and results
+
+ for i := range n {
+ tparam := tparams.At(i)
+ hash += 7 * h.hash(tparam.Constraint())
+ }
+ }
+
+ return hash + 3*h.hashTuple(t.Params()) + 5*h.hashTuple(t.Results())
+
+ case *types.Union:
+ return h.hashUnion(t)
+
+ case *types.Interface:
+ // Interfaces are identical if they have the same set of methods, with
+ // identical names and types, and they have the same set of type
+ // restrictions. See go/types.identical for more details.
+ var hash uint32 = 9103
+
+ // Hash methods.
+ for i, n := 0, t.NumMethods(); i < n; i++ {
+ // Method order is not significant.
+ // Ignore m.Pkg().
+ m := t.Method(i)
+ // Use shallow hash on method signature to
+ // avoid anonymous interface cycles.
+ hash += 3*hashString(m.Name()) + 5*h.shallowHash(m.Type())
+ }
+
+ // Hash type restrictions.
+ terms, err := typeparams.InterfaceTermSet(t)
+ // if err != nil t has invalid type restrictions.
+ if err == nil {
+ hash += h.hashTermSet(terms)
+ }
+
+ return hash
+
+ case *types.Map:
+ return 9109 + 2*h.hash(t.Key()) + 3*h.hash(t.Elem())
+
+ case *types.Chan:
+ return 9127 + 2*uint32(t.Dir()) + 3*h.hash(t.Elem())
+
+ case *types.Named:
+ hash := h.hashTypeName(t.Obj())
+ targs := t.TypeArgs()
+ for i := 0; i < targs.Len(); i++ {
+ targ := targs.At(i)
+ hash += 2 * h.hash(targ)
+ }
+ return hash
+
+ case *types.TypeParam:
+ return h.hashTypeParam(t)
+
+ case *types.Tuple:
+ return h.hashTuple(t)
+ }
+
+ panic(fmt.Sprintf("%T: %v", t, t))
+}
+
+func (h hasher) hashTuple(tuple *types.Tuple) uint32 {
+ // See go/types.identicalTypes for rationale.
+ n := tuple.Len()
+ hash := 9137 + 2*uint32(n)
+ for i := range n {
+ hash += 3 * h.hash(tuple.At(i).Type())
+ }
+ return hash
+}
+
+func (h hasher) hashUnion(t *types.Union) uint32 {
+ // Hash type restrictions.
+ terms, err := typeparams.UnionTermSet(t)
+ // if err != nil t has invalid type restrictions. Fall back on a non-zero
+ // hash.
+ if err != nil {
+ return 9151
+ }
+ return h.hashTermSet(terms)
+}
+
+func (h hasher) hashTermSet(terms []*types.Term) uint32 {
+ hash := 9157 + 2*uint32(len(terms))
+ for _, term := range terms {
+ // term order is not significant.
+ termHash := h.hash(term.Type())
+ if term.Tilde() {
+ termHash *= 9161
+ }
+ hash += 3 * termHash
+ }
+ return hash
+}
+
+// hashTypeParam returns the hash of a type parameter.
+func (h hasher) hashTypeParam(t *types.TypeParam) uint32 {
+ // Within the signature of a generic function, TypeParams are
+ // identical if they have the same index and constraint, so we
+ // hash them based on index.
+ //
+ // When we are outside a generic function, free TypeParams are
+ // identical iff they are the same object, so we can use a
+ // more discriminating hash consistent with object identity.
+ // This optimization saves [Map] about 4% when hashing all the
+ // types.Info.Types in the forward closure of net/http.
+ if !h.inGenericSig {
+ // Optimization: outside a generic function signature,
+ // use a more discrimating hash consistent with object identity.
+ return h.hashTypeName(t.Obj())
+ }
+ return 9173 + 3*uint32(t.Index())
+}
+
+var theSeed = maphash.MakeSeed()
+
+// hashTypeName hashes the pointer of tname.
+func (hasher) hashTypeName(tname *types.TypeName) uint32 {
+ // Since types.Identical uses == to compare TypeNames,
+ // the Hash function uses maphash.Comparable.
+ // TODO(adonovan): or will, when it becomes available in go1.24.
+ // In the meantime we use the pointer's numeric value.
+ //
+ // hash := maphash.Comparable(theSeed, tname)
+ //
+ // (Another approach would be to hash the name and package
+ // path, and whether or not it is a package-level typename. It
+ // is rare for a package to define multiple local types with
+ // the same name.)
+ ptr := uintptr(unsafe.Pointer(tname))
+ if unsafe.Sizeof(ptr) == 8 {
+ hash := uint64(ptr)
+ return uint32(hash ^ (hash >> 32))
+ } else {
+ return uint32(ptr)
+ }
+}
+
+// shallowHash computes a hash of t without looking at any of its
+// element Types, to avoid potential anonymous cycles in the types of
+// interface methods.
+//
+// When an unnamed non-empty interface type appears anywhere among the
+// arguments or results of an interface method, there is a potential
+// for endless recursion. Consider:
+//
+// type X interface { m() []*interface { X } }
+//
+// The problem is that the Methods of the interface in m's result type
+// include m itself; there is no mention of the named type X that
+// might help us break the cycle.
+// (See comment in go/types.identical, case *Interface, for more.)
+func (h hasher) shallowHash(t types.Type) uint32 {
+ // t is the type of an interface method (Signature),
+ // its params or results (Tuples), or their immediate
+ // elements (mostly Slice, Pointer, Basic, Named),
+ // so there's no need to optimize anything else.
+ switch t := t.(type) {
+ case *types.Alias:
+ return h.shallowHash(types.Unalias(t))
+
+ case *types.Signature:
+ var hash uint32 = 604171
+ if t.Variadic() {
+ hash *= 971767
+ }
+ // The Signature/Tuple recursion is always finite
+ // and invariably shallow.
+ return hash + 1062599*h.shallowHash(t.Params()) + 1282529*h.shallowHash(t.Results())
+
+ case *types.Tuple:
+ n := t.Len()
+ hash := 9137 + 2*uint32(n)
+ for i := range n {
+ hash += 53471161 * h.shallowHash(t.At(i).Type())
+ }
+ return hash
+
+ case *types.Basic:
+ return 45212177 * uint32(t.Kind())
+
+ case *types.Array:
+ return 1524181 + 2*uint32(t.Len())
+
+ case *types.Slice:
+ return 2690201
+
+ case *types.Struct:
+ return 3326489
+
+ case *types.Pointer:
+ return 4393139
+
+ case *types.Union:
+ return 562448657
+
+ case *types.Interface:
+ return 2124679 // no recursion here
+
+ case *types.Map:
+ return 9109
+
+ case *types.Chan:
+ return 9127
+
+ case *types.Named:
+ return h.hashTypeName(t.Obj())
+
+ case *types.TypeParam:
+ return h.hashTypeParam(t)
+ }
+ panic(fmt.Sprintf("shallowHash: %T: %v", t, t))
+}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go b/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go
new file mode 100644
index 00000000..f7666028
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go
@@ -0,0 +1,71 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file implements a cache of method sets.
+
+package typeutil
+
+import (
+ "go/types"
+ "sync"
+)
+
+// A MethodSetCache records the method set of each type T for which
+// MethodSet(T) is called so that repeat queries are fast.
+// The zero value is a ready-to-use cache instance.
+type MethodSetCache struct {
+ mu sync.Mutex
+ named map[*types.Named]struct{ value, pointer *types.MethodSet } // method sets for named N and *N
+ others map[types.Type]*types.MethodSet // all other types
+}
+
+// MethodSet returns the method set of type T. It is thread-safe.
+//
+// If cache is nil, this function is equivalent to types.NewMethodSet(T).
+// Utility functions can thus expose an optional *MethodSetCache
+// parameter to clients that care about performance.
+func (cache *MethodSetCache) MethodSet(T types.Type) *types.MethodSet {
+ if cache == nil {
+ return types.NewMethodSet(T)
+ }
+ cache.mu.Lock()
+ defer cache.mu.Unlock()
+
+ switch T := types.Unalias(T).(type) {
+ case *types.Named:
+ return cache.lookupNamed(T).value
+
+ case *types.Pointer:
+ if N, ok := types.Unalias(T.Elem()).(*types.Named); ok {
+ return cache.lookupNamed(N).pointer
+ }
+ }
+
+ // all other types
+ // (The map uses pointer equivalence, not type identity.)
+ mset := cache.others[T]
+ if mset == nil {
+ mset = types.NewMethodSet(T)
+ if cache.others == nil {
+ cache.others = make(map[types.Type]*types.MethodSet)
+ }
+ cache.others[T] = mset
+ }
+ return mset
+}
+
+func (cache *MethodSetCache) lookupNamed(named *types.Named) struct{ value, pointer *types.MethodSet } {
+ if cache.named == nil {
+ cache.named = make(map[*types.Named]struct{ value, pointer *types.MethodSet })
+ }
+ // Avoid recomputing mset(*T) for each distinct Pointer
+ // instance whose underlying type is a named type.
+ msets, ok := cache.named[named]
+ if !ok {
+ msets.value = types.NewMethodSet(named)
+ msets.pointer = types.NewMethodSet(types.NewPointer(named))
+ cache.named[named] = msets
+ }
+ return msets
+}
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/ui.go b/vendor/golang.org/x/tools/go/types/typeutil/ui.go
new file mode 100644
index 00000000..9dda6a25
--- /dev/null
+++ b/vendor/golang.org/x/tools/go/types/typeutil/ui.go
@@ -0,0 +1,53 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typeutil
+
+// This file defines utilities for user interfaces that display types.
+
+import (
+ "go/types"
+)
+
+// IntuitiveMethodSet returns the intuitive method set of a type T,
+// which is the set of methods you can call on an addressable value of
+// that type.
+//
+// The result always contains MethodSet(T), and is exactly MethodSet(T)
+// for interface types and for pointer-to-concrete types.
+// For all other concrete types T, the result additionally
+// contains each method belonging to *T if there is no identically
+// named method on T itself.
+//
+// This corresponds to user intuition about method sets;
+// this function is intended only for user interfaces.
+//
+// The order of the result is as for types.MethodSet(T).
+func IntuitiveMethodSet(T types.Type, msets *MethodSetCache) []*types.Selection {
+ isPointerToConcrete := func(T types.Type) bool {
+ ptr, ok := types.Unalias(T).(*types.Pointer)
+ return ok && !types.IsInterface(ptr.Elem())
+ }
+
+ var result []*types.Selection
+ mset := msets.MethodSet(T)
+ if types.IsInterface(T) || isPointerToConcrete(T) {
+ for i, n := 0, mset.Len(); i < n; i++ {
+ result = append(result, mset.At(i))
+ }
+ } else {
+ // T is some other concrete type.
+ // Report methods of T and *T, preferring those of T.
+ pmset := msets.MethodSet(types.NewPointer(T))
+ for i, n := 0, pmset.Len(); i < n; i++ {
+ meth := pmset.At(i)
+ if m := mset.Lookup(meth.Obj().Pkg(), meth.Obj().Name()); m != nil {
+ meth = m
+ }
+ result = append(result, meth)
+ }
+
+ }
+ return result
+}
diff --git a/vendor/golang.org/x/tools/internal/aliases/aliases.go b/vendor/golang.org/x/tools/internal/aliases/aliases.go
new file mode 100644
index 00000000..b9425f5a
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/aliases/aliases.go
@@ -0,0 +1,38 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package aliases
+
+import (
+ "go/token"
+ "go/types"
+)
+
+// Package aliases defines backward compatible shims
+// for the types.Alias type representation added in 1.22.
+// This defines placeholders for x/tools until 1.26.
+
+// NewAlias creates a new TypeName in Package pkg that
+// is an alias for the type rhs.
+//
+// The enabled parameter determines whether the resulting [TypeName]'s
+// type is an [types.Alias]. Its value must be the result of a call to
+// [Enabled], which computes the effective value of
+// GODEBUG=gotypesalias=... by invoking the type checker. The Enabled
+// function is expensive and should be called once per task (e.g.
+// package import), not once per call to NewAlias.
+//
+// Precondition: enabled || len(tparams)==0.
+// If materialized aliases are disabled, there must not be any type parameters.
+func NewAlias(enabled bool, pos token.Pos, pkg *types.Package, name string, rhs types.Type, tparams []*types.TypeParam) *types.TypeName {
+ if enabled {
+ tname := types.NewTypeName(pos, pkg, name, nil)
+ SetTypeParams(types.NewAlias(tname, rhs), tparams)
+ return tname
+ }
+ if len(tparams) > 0 {
+ panic("cannot create an alias with type parameters when gotypesalias is not enabled")
+ }
+ return types.NewTypeName(pos, pkg, name, rhs)
+}
diff --git a/vendor/golang.org/x/tools/internal/aliases/aliases_go122.go b/vendor/golang.org/x/tools/internal/aliases/aliases_go122.go
new file mode 100644
index 00000000..7716a333
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/aliases/aliases_go122.go
@@ -0,0 +1,80 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package aliases
+
+import (
+ "go/ast"
+ "go/parser"
+ "go/token"
+ "go/types"
+)
+
+// Rhs returns the type on the right-hand side of the alias declaration.
+func Rhs(alias *types.Alias) types.Type {
+ if alias, ok := any(alias).(interface{ Rhs() types.Type }); ok {
+ return alias.Rhs() // go1.23+
+ }
+
+ // go1.22's Alias didn't have the Rhs method,
+ // so Unalias is the best we can do.
+ return types.Unalias(alias)
+}
+
+// TypeParams returns the type parameter list of the alias.
+func TypeParams(alias *types.Alias) *types.TypeParamList {
+ if alias, ok := any(alias).(interface{ TypeParams() *types.TypeParamList }); ok {
+ return alias.TypeParams() // go1.23+
+ }
+ return nil
+}
+
+// SetTypeParams sets the type parameters of the alias type.
+func SetTypeParams(alias *types.Alias, tparams []*types.TypeParam) {
+ if alias, ok := any(alias).(interface {
+ SetTypeParams(tparams []*types.TypeParam)
+ }); ok {
+ alias.SetTypeParams(tparams) // go1.23+
+ } else if len(tparams) > 0 {
+ panic("cannot set type parameters of an Alias type in go1.22")
+ }
+}
+
+// TypeArgs returns the type arguments used to instantiate the Alias type.
+func TypeArgs(alias *types.Alias) *types.TypeList {
+ if alias, ok := any(alias).(interface{ TypeArgs() *types.TypeList }); ok {
+ return alias.TypeArgs() // go1.23+
+ }
+ return nil // empty (go1.22)
+}
+
+// Origin returns the generic Alias type of which alias is an instance.
+// If alias is not an instance of a generic alias, Origin returns alias.
+func Origin(alias *types.Alias) *types.Alias {
+ if alias, ok := any(alias).(interface{ Origin() *types.Alias }); ok {
+ return alias.Origin() // go1.23+
+ }
+ return alias // not an instance of a generic alias (go1.22)
+}
+
+// Enabled reports whether [NewAlias] should create [types.Alias] types.
+//
+// This function is expensive! Call it sparingly.
+func Enabled() bool {
+ // The only reliable way to compute the answer is to invoke go/types.
+ // We don't parse the GODEBUG environment variable, because
+ // (a) it's tricky to do so in a manner that is consistent
+ // with the godebug package; in particular, a simple
+ // substring check is not good enough. The value is a
+ // rightmost-wins list of options. But more importantly:
+ // (b) it is impossible to detect changes to the effective
+ // setting caused by os.Setenv("GODEBUG"), as happens in
+ // many tests. Therefore any attempt to cache the result
+ // is just incorrect.
+ fset := token.NewFileSet()
+ f, _ := parser.ParseFile(fset, "a.go", "package p; type A = int", parser.SkipObjectResolution)
+ pkg, _ := new(types.Config).Check("p", fset, []*ast.File{f}, nil)
+ _, enabled := pkg.Scope().Lookup("A").Type().(*types.Alias)
+ return enabled
+}
diff --git a/vendor/golang.org/x/tools/internal/event/core/event.go b/vendor/golang.org/x/tools/internal/event/core/event.go
new file mode 100644
index 00000000..a6cf0e64
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/event/core/event.go
@@ -0,0 +1,85 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package core provides support for event based telemetry.
+package core
+
+import (
+ "fmt"
+ "time"
+
+ "golang.org/x/tools/internal/event/label"
+)
+
+// Event holds the information about an event of note that occurred.
+type Event struct {
+ at time.Time
+
+ // As events are often on the stack, storing the first few labels directly
+ // in the event can avoid an allocation at all for the very common cases of
+ // simple events.
+ // The length needs to be large enough to cope with the majority of events
+ // but no so large as to cause undue stack pressure.
+ // A log message with two values will use 3 labels (one for each value and
+ // one for the message itself).
+
+ static [3]label.Label // inline storage for the first few labels
+ dynamic []label.Label // dynamically sized storage for remaining labels
+}
+
+// eventLabelMap implements label.Map for a the labels of an Event.
+type eventLabelMap struct {
+ event Event
+}
+
+func (ev Event) At() time.Time { return ev.at }
+
+func (ev Event) Format(f fmt.State, r rune) {
+ if !ev.at.IsZero() {
+ fmt.Fprint(f, ev.at.Format("2006/01/02 15:04:05 "))
+ }
+ for index := 0; ev.Valid(index); index++ {
+ if l := ev.Label(index); l.Valid() {
+ fmt.Fprintf(f, "\n\t%v", l)
+ }
+ }
+}
+
+func (ev Event) Valid(index int) bool {
+ return index >= 0 && index < len(ev.static)+len(ev.dynamic)
+}
+
+func (ev Event) Label(index int) label.Label {
+ if index < len(ev.static) {
+ return ev.static[index]
+ }
+ return ev.dynamic[index-len(ev.static)]
+}
+
+func (ev Event) Find(key label.Key) label.Label {
+ for _, l := range ev.static {
+ if l.Key() == key {
+ return l
+ }
+ }
+ for _, l := range ev.dynamic {
+ if l.Key() == key {
+ return l
+ }
+ }
+ return label.Label{}
+}
+
+func MakeEvent(static [3]label.Label, labels []label.Label) Event {
+ return Event{
+ static: static,
+ dynamic: labels,
+ }
+}
+
+// CloneEvent event returns a copy of the event with the time adjusted to at.
+func CloneEvent(ev Event, at time.Time) Event {
+ ev.at = at
+ return ev
+}
diff --git a/vendor/golang.org/x/tools/internal/event/core/export.go b/vendor/golang.org/x/tools/internal/event/core/export.go
new file mode 100644
index 00000000..05f3a9a5
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/event/core/export.go
@@ -0,0 +1,70 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package core
+
+import (
+ "context"
+ "sync/atomic"
+ "time"
+ "unsafe"
+
+ "golang.org/x/tools/internal/event/label"
+)
+
+// Exporter is a function that handles events.
+// It may return a modified context and event.
+type Exporter func(context.Context, Event, label.Map) context.Context
+
+var (
+ exporter unsafe.Pointer
+)
+
+// SetExporter sets the global exporter function that handles all events.
+// The exporter is called synchronously from the event call site, so it should
+// return quickly so as not to hold up user code.
+func SetExporter(e Exporter) {
+ p := unsafe.Pointer(&e)
+ if e == nil {
+ // &e is always valid, and so p is always valid, but for the early abort
+ // of ProcessEvent to be efficient it needs to make the nil check on the
+ // pointer without having to dereference it, so we make the nil function
+ // also a nil pointer
+ p = nil
+ }
+ atomic.StorePointer(&exporter, p)
+}
+
+// deliver is called to deliver an event to the supplied exporter.
+// it will fill in the time.
+func deliver(ctx context.Context, exporter Exporter, ev Event) context.Context {
+ // add the current time to the event
+ ev.at = time.Now()
+ // hand the event off to the current exporter
+ return exporter(ctx, ev, ev)
+}
+
+// Export is called to deliver an event to the global exporter if set.
+func Export(ctx context.Context, ev Event) context.Context {
+ // get the global exporter and abort early if there is not one
+ exporterPtr := (*Exporter)(atomic.LoadPointer(&exporter))
+ if exporterPtr == nil {
+ return ctx
+ }
+ return deliver(ctx, *exporterPtr, ev)
+}
+
+// ExportPair is called to deliver a start event to the supplied exporter.
+// It also returns a function that will deliver the end event to the same
+// exporter.
+// It will fill in the time.
+func ExportPair(ctx context.Context, begin, end Event) (context.Context, func()) {
+ // get the global exporter and abort early if there is not one
+ exporterPtr := (*Exporter)(atomic.LoadPointer(&exporter))
+ if exporterPtr == nil {
+ return ctx, func() {}
+ }
+ ctx = deliver(ctx, *exporterPtr, begin)
+ return ctx, func() { deliver(ctx, *exporterPtr, end) }
+}
diff --git a/vendor/golang.org/x/tools/internal/event/core/fast.go b/vendor/golang.org/x/tools/internal/event/core/fast.go
new file mode 100644
index 00000000..06c1d461
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/event/core/fast.go
@@ -0,0 +1,77 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package core
+
+import (
+ "context"
+
+ "golang.org/x/tools/internal/event/keys"
+ "golang.org/x/tools/internal/event/label"
+)
+
+// Log1 takes a message and one label delivers a log event to the exporter.
+// It is a customized version of Print that is faster and does no allocation.
+func Log1(ctx context.Context, message string, t1 label.Label) {
+ Export(ctx, MakeEvent([3]label.Label{
+ keys.Msg.Of(message),
+ t1,
+ }, nil))
+}
+
+// Log2 takes a message and two labels and delivers a log event to the exporter.
+// It is a customized version of Print that is faster and does no allocation.
+func Log2(ctx context.Context, message string, t1 label.Label, t2 label.Label) {
+ Export(ctx, MakeEvent([3]label.Label{
+ keys.Msg.Of(message),
+ t1,
+ t2,
+ }, nil))
+}
+
+// Metric1 sends a label event to the exporter with the supplied labels.
+func Metric1(ctx context.Context, t1 label.Label) context.Context {
+ return Export(ctx, MakeEvent([3]label.Label{
+ keys.Metric.New(),
+ t1,
+ }, nil))
+}
+
+// Metric2 sends a label event to the exporter with the supplied labels.
+func Metric2(ctx context.Context, t1, t2 label.Label) context.Context {
+ return Export(ctx, MakeEvent([3]label.Label{
+ keys.Metric.New(),
+ t1,
+ t2,
+ }, nil))
+}
+
+// Start1 sends a span start event with the supplied label list to the exporter.
+// It also returns a function that will end the span, which should normally be
+// deferred.
+func Start1(ctx context.Context, name string, t1 label.Label) (context.Context, func()) {
+ return ExportPair(ctx,
+ MakeEvent([3]label.Label{
+ keys.Start.Of(name),
+ t1,
+ }, nil),
+ MakeEvent([3]label.Label{
+ keys.End.New(),
+ }, nil))
+}
+
+// Start2 sends a span start event with the supplied label list to the exporter.
+// It also returns a function that will end the span, which should normally be
+// deferred.
+func Start2(ctx context.Context, name string, t1, t2 label.Label) (context.Context, func()) {
+ return ExportPair(ctx,
+ MakeEvent([3]label.Label{
+ keys.Start.Of(name),
+ t1,
+ t2,
+ }, nil),
+ MakeEvent([3]label.Label{
+ keys.End.New(),
+ }, nil))
+}
diff --git a/vendor/golang.org/x/tools/internal/event/doc.go b/vendor/golang.org/x/tools/internal/event/doc.go
new file mode 100644
index 00000000..5dc6e6ba
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/event/doc.go
@@ -0,0 +1,7 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package event provides a set of packages that cover the main
+// concepts of telemetry in an implementation agnostic way.
+package event
diff --git a/vendor/golang.org/x/tools/internal/event/event.go b/vendor/golang.org/x/tools/internal/event/event.go
new file mode 100644
index 00000000..4d55e577
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/event/event.go
@@ -0,0 +1,127 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package event
+
+import (
+ "context"
+
+ "golang.org/x/tools/internal/event/core"
+ "golang.org/x/tools/internal/event/keys"
+ "golang.org/x/tools/internal/event/label"
+)
+
+// Exporter is a function that handles events.
+// It may return a modified context and event.
+type Exporter func(context.Context, core.Event, label.Map) context.Context
+
+// SetExporter sets the global exporter function that handles all events.
+// The exporter is called synchronously from the event call site, so it should
+// return quickly so as not to hold up user code.
+func SetExporter(e Exporter) {
+ core.SetExporter(core.Exporter(e))
+}
+
+// Log takes a message and a label list and combines them into a single event
+// before delivering them to the exporter.
+func Log(ctx context.Context, message string, labels ...label.Label) {
+ core.Export(ctx, core.MakeEvent([3]label.Label{
+ keys.Msg.Of(message),
+ }, labels))
+}
+
+// IsLog returns true if the event was built by the Log function.
+// It is intended to be used in exporters to identify the semantics of the
+// event when deciding what to do with it.
+func IsLog(ev core.Event) bool {
+ return ev.Label(0).Key() == keys.Msg
+}
+
+// Error takes a message and a label list and combines them into a single event
+// before delivering them to the exporter. It captures the error in the
+// delivered event.
+func Error(ctx context.Context, message string, err error, labels ...label.Label) {
+ core.Export(ctx, core.MakeEvent([3]label.Label{
+ keys.Msg.Of(message),
+ keys.Err.Of(err),
+ }, labels))
+}
+
+// IsError returns true if the event was built by the Error function.
+// It is intended to be used in exporters to identify the semantics of the
+// event when deciding what to do with it.
+func IsError(ev core.Event) bool {
+ return ev.Label(0).Key() == keys.Msg &&
+ ev.Label(1).Key() == keys.Err
+}
+
+// Metric sends a label event to the exporter with the supplied labels.
+func Metric(ctx context.Context, labels ...label.Label) {
+ core.Export(ctx, core.MakeEvent([3]label.Label{
+ keys.Metric.New(),
+ }, labels))
+}
+
+// IsMetric returns true if the event was built by the Metric function.
+// It is intended to be used in exporters to identify the semantics of the
+// event when deciding what to do with it.
+func IsMetric(ev core.Event) bool {
+ return ev.Label(0).Key() == keys.Metric
+}
+
+// Label sends a label event to the exporter with the supplied labels.
+func Label(ctx context.Context, labels ...label.Label) context.Context {
+ return core.Export(ctx, core.MakeEvent([3]label.Label{
+ keys.Label.New(),
+ }, labels))
+}
+
+// IsLabel returns true if the event was built by the Label function.
+// It is intended to be used in exporters to identify the semantics of the
+// event when deciding what to do with it.
+func IsLabel(ev core.Event) bool {
+ return ev.Label(0).Key() == keys.Label
+}
+
+// Start sends a span start event with the supplied label list to the exporter.
+// It also returns a function that will end the span, which should normally be
+// deferred.
+func Start(ctx context.Context, name string, labels ...label.Label) (context.Context, func()) {
+ return core.ExportPair(ctx,
+ core.MakeEvent([3]label.Label{
+ keys.Start.Of(name),
+ }, labels),
+ core.MakeEvent([3]label.Label{
+ keys.End.New(),
+ }, nil))
+}
+
+// IsStart returns true if the event was built by the Start function.
+// It is intended to be used in exporters to identify the semantics of the
+// event when deciding what to do with it.
+func IsStart(ev core.Event) bool {
+ return ev.Label(0).Key() == keys.Start
+}
+
+// IsEnd returns true if the event was built by the End function.
+// It is intended to be used in exporters to identify the semantics of the
+// event when deciding what to do with it.
+func IsEnd(ev core.Event) bool {
+ return ev.Label(0).Key() == keys.End
+}
+
+// Detach returns a context without an associated span.
+// This allows the creation of spans that are not children of the current span.
+func Detach(ctx context.Context) context.Context {
+ return core.Export(ctx, core.MakeEvent([3]label.Label{
+ keys.Detach.New(),
+ }, nil))
+}
+
+// IsDetach returns true if the event was built by the Detach function.
+// It is intended to be used in exporters to identify the semantics of the
+// event when deciding what to do with it.
+func IsDetach(ev core.Event) bool {
+ return ev.Label(0).Key() == keys.Detach
+}
diff --git a/vendor/golang.org/x/tools/internal/event/keys/keys.go b/vendor/golang.org/x/tools/internal/event/keys/keys.go
new file mode 100644
index 00000000..4cfa51b6
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/event/keys/keys.go
@@ -0,0 +1,564 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package keys
+
+import (
+ "fmt"
+ "io"
+ "math"
+ "strconv"
+
+ "golang.org/x/tools/internal/event/label"
+)
+
+// Value represents a key for untyped values.
+type Value struct {
+ name string
+ description string
+}
+
+// New creates a new Key for untyped values.
+func New(name, description string) *Value {
+ return &Value{name: name, description: description}
+}
+
+func (k *Value) Name() string { return k.name }
+func (k *Value) Description() string { return k.description }
+
+func (k *Value) Format(w io.Writer, buf []byte, l label.Label) {
+ fmt.Fprint(w, k.From(l))
+}
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *Value) Get(lm label.Map) any {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return nil
+}
+
+// From can be used to get a value from a Label.
+func (k *Value) From(t label.Label) any { return t.UnpackValue() }
+
+// Of creates a new Label with this key and the supplied value.
+func (k *Value) Of(value any) label.Label { return label.OfValue(k, value) }
+
+// Tag represents a key for tagging labels that have no value.
+// These are used when the existence of the label is the entire information it
+// carries, such as marking events to be of a specific kind, or from a specific
+// package.
+type Tag struct {
+ name string
+ description string
+}
+
+// NewTag creates a new Key for tagging labels.
+func NewTag(name, description string) *Tag {
+ return &Tag{name: name, description: description}
+}
+
+func (k *Tag) Name() string { return k.name }
+func (k *Tag) Description() string { return k.description }
+
+func (k *Tag) Format(w io.Writer, buf []byte, l label.Label) {}
+
+// New creates a new Label with this key.
+func (k *Tag) New() label.Label { return label.OfValue(k, nil) }
+
+// Int represents a key
+type Int struct {
+ name string
+ description string
+}
+
+// NewInt creates a new Key for int values.
+func NewInt(name, description string) *Int {
+ return &Int{name: name, description: description}
+}
+
+func (k *Int) Name() string { return k.name }
+func (k *Int) Description() string { return k.description }
+
+func (k *Int) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendInt(buf, int64(k.From(l)), 10))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *Int) Of(v int) label.Label { return label.Of64(k, uint64(v)) }
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *Int) Get(lm label.Map) int {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Label.
+func (k *Int) From(t label.Label) int { return int(t.Unpack64()) }
+
+// Int8 represents a key
+type Int8 struct {
+ name string
+ description string
+}
+
+// NewInt8 creates a new Key for int8 values.
+func NewInt8(name, description string) *Int8 {
+ return &Int8{name: name, description: description}
+}
+
+func (k *Int8) Name() string { return k.name }
+func (k *Int8) Description() string { return k.description }
+
+func (k *Int8) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendInt(buf, int64(k.From(l)), 10))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *Int8) Of(v int8) label.Label { return label.Of64(k, uint64(v)) }
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *Int8) Get(lm label.Map) int8 {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Label.
+func (k *Int8) From(t label.Label) int8 { return int8(t.Unpack64()) }
+
+// Int16 represents a key
+type Int16 struct {
+ name string
+ description string
+}
+
+// NewInt16 creates a new Key for int16 values.
+func NewInt16(name, description string) *Int16 {
+ return &Int16{name: name, description: description}
+}
+
+func (k *Int16) Name() string { return k.name }
+func (k *Int16) Description() string { return k.description }
+
+func (k *Int16) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendInt(buf, int64(k.From(l)), 10))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *Int16) Of(v int16) label.Label { return label.Of64(k, uint64(v)) }
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *Int16) Get(lm label.Map) int16 {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Label.
+func (k *Int16) From(t label.Label) int16 { return int16(t.Unpack64()) }
+
+// Int32 represents a key
+type Int32 struct {
+ name string
+ description string
+}
+
+// NewInt32 creates a new Key for int32 values.
+func NewInt32(name, description string) *Int32 {
+ return &Int32{name: name, description: description}
+}
+
+func (k *Int32) Name() string { return k.name }
+func (k *Int32) Description() string { return k.description }
+
+func (k *Int32) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendInt(buf, int64(k.From(l)), 10))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *Int32) Of(v int32) label.Label { return label.Of64(k, uint64(v)) }
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *Int32) Get(lm label.Map) int32 {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Label.
+func (k *Int32) From(t label.Label) int32 { return int32(t.Unpack64()) }
+
+// Int64 represents a key
+type Int64 struct {
+ name string
+ description string
+}
+
+// NewInt64 creates a new Key for int64 values.
+func NewInt64(name, description string) *Int64 {
+ return &Int64{name: name, description: description}
+}
+
+func (k *Int64) Name() string { return k.name }
+func (k *Int64) Description() string { return k.description }
+
+func (k *Int64) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendInt(buf, k.From(l), 10))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *Int64) Of(v int64) label.Label { return label.Of64(k, uint64(v)) }
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *Int64) Get(lm label.Map) int64 {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Label.
+func (k *Int64) From(t label.Label) int64 { return int64(t.Unpack64()) }
+
+// UInt represents a key
+type UInt struct {
+ name string
+ description string
+}
+
+// NewUInt creates a new Key for uint values.
+func NewUInt(name, description string) *UInt {
+ return &UInt{name: name, description: description}
+}
+
+func (k *UInt) Name() string { return k.name }
+func (k *UInt) Description() string { return k.description }
+
+func (k *UInt) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendUint(buf, uint64(k.From(l)), 10))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *UInt) Of(v uint) label.Label { return label.Of64(k, uint64(v)) }
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *UInt) Get(lm label.Map) uint {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Label.
+func (k *UInt) From(t label.Label) uint { return uint(t.Unpack64()) }
+
+// UInt8 represents a key
+type UInt8 struct {
+ name string
+ description string
+}
+
+// NewUInt8 creates a new Key for uint8 values.
+func NewUInt8(name, description string) *UInt8 {
+ return &UInt8{name: name, description: description}
+}
+
+func (k *UInt8) Name() string { return k.name }
+func (k *UInt8) Description() string { return k.description }
+
+func (k *UInt8) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendUint(buf, uint64(k.From(l)), 10))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *UInt8) Of(v uint8) label.Label { return label.Of64(k, uint64(v)) }
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *UInt8) Get(lm label.Map) uint8 {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Label.
+func (k *UInt8) From(t label.Label) uint8 { return uint8(t.Unpack64()) }
+
+// UInt16 represents a key
+type UInt16 struct {
+ name string
+ description string
+}
+
+// NewUInt16 creates a new Key for uint16 values.
+func NewUInt16(name, description string) *UInt16 {
+ return &UInt16{name: name, description: description}
+}
+
+func (k *UInt16) Name() string { return k.name }
+func (k *UInt16) Description() string { return k.description }
+
+func (k *UInt16) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendUint(buf, uint64(k.From(l)), 10))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *UInt16) Of(v uint16) label.Label { return label.Of64(k, uint64(v)) }
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *UInt16) Get(lm label.Map) uint16 {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Label.
+func (k *UInt16) From(t label.Label) uint16 { return uint16(t.Unpack64()) }
+
+// UInt32 represents a key
+type UInt32 struct {
+ name string
+ description string
+}
+
+// NewUInt32 creates a new Key for uint32 values.
+func NewUInt32(name, description string) *UInt32 {
+ return &UInt32{name: name, description: description}
+}
+
+func (k *UInt32) Name() string { return k.name }
+func (k *UInt32) Description() string { return k.description }
+
+func (k *UInt32) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendUint(buf, uint64(k.From(l)), 10))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *UInt32) Of(v uint32) label.Label { return label.Of64(k, uint64(v)) }
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *UInt32) Get(lm label.Map) uint32 {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Label.
+func (k *UInt32) From(t label.Label) uint32 { return uint32(t.Unpack64()) }
+
+// UInt64 represents a key
+type UInt64 struct {
+ name string
+ description string
+}
+
+// NewUInt64 creates a new Key for uint64 values.
+func NewUInt64(name, description string) *UInt64 {
+ return &UInt64{name: name, description: description}
+}
+
+func (k *UInt64) Name() string { return k.name }
+func (k *UInt64) Description() string { return k.description }
+
+func (k *UInt64) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendUint(buf, k.From(l), 10))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *UInt64) Of(v uint64) label.Label { return label.Of64(k, v) }
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *UInt64) Get(lm label.Map) uint64 {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Label.
+func (k *UInt64) From(t label.Label) uint64 { return t.Unpack64() }
+
+// Float32 represents a key
+type Float32 struct {
+ name string
+ description string
+}
+
+// NewFloat32 creates a new Key for float32 values.
+func NewFloat32(name, description string) *Float32 {
+ return &Float32{name: name, description: description}
+}
+
+func (k *Float32) Name() string { return k.name }
+func (k *Float32) Description() string { return k.description }
+
+func (k *Float32) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendFloat(buf, float64(k.From(l)), 'E', -1, 32))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *Float32) Of(v float32) label.Label {
+ return label.Of64(k, uint64(math.Float32bits(v)))
+}
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *Float32) Get(lm label.Map) float32 {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Label.
+func (k *Float32) From(t label.Label) float32 {
+ return math.Float32frombits(uint32(t.Unpack64()))
+}
+
+// Float64 represents a key
+type Float64 struct {
+ name string
+ description string
+}
+
+// NewFloat64 creates a new Key for int64 values.
+func NewFloat64(name, description string) *Float64 {
+ return &Float64{name: name, description: description}
+}
+
+func (k *Float64) Name() string { return k.name }
+func (k *Float64) Description() string { return k.description }
+
+func (k *Float64) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendFloat(buf, k.From(l), 'E', -1, 64))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *Float64) Of(v float64) label.Label {
+ return label.Of64(k, math.Float64bits(v))
+}
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *Float64) Get(lm label.Map) float64 {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Label.
+func (k *Float64) From(t label.Label) float64 {
+ return math.Float64frombits(t.Unpack64())
+}
+
+// String represents a key
+type String struct {
+ name string
+ description string
+}
+
+// NewString creates a new Key for int64 values.
+func NewString(name, description string) *String {
+ return &String{name: name, description: description}
+}
+
+func (k *String) Name() string { return k.name }
+func (k *String) Description() string { return k.description }
+
+func (k *String) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendQuote(buf, k.From(l)))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *String) Of(v string) label.Label { return label.OfString(k, v) }
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *String) Get(lm label.Map) string {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return ""
+}
+
+// From can be used to get a value from a Label.
+func (k *String) From(t label.Label) string { return t.UnpackString() }
+
+// Boolean represents a key
+type Boolean struct {
+ name string
+ description string
+}
+
+// NewBoolean creates a new Key for bool values.
+func NewBoolean(name, description string) *Boolean {
+ return &Boolean{name: name, description: description}
+}
+
+func (k *Boolean) Name() string { return k.name }
+func (k *Boolean) Description() string { return k.description }
+
+func (k *Boolean) Format(w io.Writer, buf []byte, l label.Label) {
+ w.Write(strconv.AppendBool(buf, k.From(l)))
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *Boolean) Of(v bool) label.Label {
+ if v {
+ return label.Of64(k, 1)
+ }
+ return label.Of64(k, 0)
+}
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *Boolean) Get(lm label.Map) bool {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return false
+}
+
+// From can be used to get a value from a Label.
+func (k *Boolean) From(t label.Label) bool { return t.Unpack64() > 0 }
+
+// Error represents a key
+type Error struct {
+ name string
+ description string
+}
+
+// NewError creates a new Key for int64 values.
+func NewError(name, description string) *Error {
+ return &Error{name: name, description: description}
+}
+
+func (k *Error) Name() string { return k.name }
+func (k *Error) Description() string { return k.description }
+
+func (k *Error) Format(w io.Writer, buf []byte, l label.Label) {
+ io.WriteString(w, k.From(l).Error())
+}
+
+// Of creates a new Label with this key and the supplied value.
+func (k *Error) Of(v error) label.Label { return label.OfValue(k, v) }
+
+// Get can be used to get a label for the key from a label.Map.
+func (k *Error) Get(lm label.Map) error {
+ if t := lm.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return nil
+}
+
+// From can be used to get a value from a Label.
+func (k *Error) From(t label.Label) error {
+ err, _ := t.UnpackValue().(error)
+ return err
+}
diff --git a/vendor/golang.org/x/tools/internal/event/keys/standard.go b/vendor/golang.org/x/tools/internal/event/keys/standard.go
new file mode 100644
index 00000000..7e958665
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/event/keys/standard.go
@@ -0,0 +1,22 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package keys
+
+var (
+ // Msg is a key used to add message strings to label lists.
+ Msg = NewString("message", "a readable message")
+ // Label is a key used to indicate an event adds labels to the context.
+ Label = NewTag("label", "a label context marker")
+ // Start is used for things like traces that have a name.
+ Start = NewString("start", "span start")
+ // Metric is a key used to indicate an event records metrics.
+ End = NewTag("end", "a span end marker")
+ // Metric is a key used to indicate an event records metrics.
+ Detach = NewTag("detach", "a span detach marker")
+ // Err is a key used to add error values to label lists.
+ Err = NewError("error", "an error that occurred")
+ // Metric is a key used to indicate an event records metrics.
+ Metric = NewTag("metric", "a metric event marker")
+)
diff --git a/vendor/golang.org/x/tools/internal/event/keys/util.go b/vendor/golang.org/x/tools/internal/event/keys/util.go
new file mode 100644
index 00000000..c0e8e731
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/event/keys/util.go
@@ -0,0 +1,21 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package keys
+
+import (
+ "sort"
+ "strings"
+)
+
+// Join returns a canonical join of the keys in S:
+// a sorted comma-separated string list.
+func Join[S ~[]T, T ~string](s S) string {
+ strs := make([]string, 0, len(s))
+ for _, v := range s {
+ strs = append(strs, string(v))
+ }
+ sort.Strings(strs)
+ return strings.Join(strs, ",")
+}
diff --git a/vendor/golang.org/x/tools/internal/event/label/label.go b/vendor/golang.org/x/tools/internal/event/label/label.go
new file mode 100644
index 00000000..92a39105
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/event/label/label.go
@@ -0,0 +1,214 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package label
+
+import (
+ "fmt"
+ "io"
+ "reflect"
+ "slices"
+ "unsafe"
+)
+
+// Key is used as the identity of a Label.
+// Keys are intended to be compared by pointer only, the name should be unique
+// for communicating with external systems, but it is not required or enforced.
+type Key interface {
+ // Name returns the key name.
+ Name() string
+ // Description returns a string that can be used to describe the value.
+ Description() string
+
+ // Format is used in formatting to append the value of the label to the
+ // supplied buffer.
+ // The formatter may use the supplied buf as a scratch area to avoid
+ // allocations.
+ Format(w io.Writer, buf []byte, l Label)
+}
+
+// Label holds a key and value pair.
+// It is normally used when passing around lists of labels.
+type Label struct {
+ key Key
+ packed uint64
+ untyped any
+}
+
+// Map is the interface to a collection of Labels indexed by key.
+type Map interface {
+ // Find returns the label that matches the supplied key.
+ Find(key Key) Label
+}
+
+// List is the interface to something that provides an iterable
+// list of labels.
+// Iteration should start from 0 and continue until Valid returns false.
+type List interface {
+ // Valid returns true if the index is within range for the list.
+ // It does not imply the label at that index will itself be valid.
+ Valid(index int) bool
+ // Label returns the label at the given index.
+ Label(index int) Label
+}
+
+// list implements LabelList for a list of Labels.
+type list struct {
+ labels []Label
+}
+
+// filter wraps a LabelList filtering out specific labels.
+type filter struct {
+ keys []Key
+ underlying List
+}
+
+// listMap implements LabelMap for a simple list of labels.
+type listMap struct {
+ labels []Label
+}
+
+// mapChain implements LabelMap for a list of underlying LabelMap.
+type mapChain struct {
+ maps []Map
+}
+
+// OfValue creates a new label from the key and value.
+// This method is for implementing new key types, label creation should
+// normally be done with the Of method of the key.
+func OfValue(k Key, value any) Label { return Label{key: k, untyped: value} }
+
+// UnpackValue assumes the label was built using LabelOfValue and returns the value
+// that was passed to that constructor.
+// This method is for implementing new key types, for type safety normal
+// access should be done with the From method of the key.
+func (t Label) UnpackValue() any { return t.untyped }
+
+// Of64 creates a new label from a key and a uint64. This is often
+// used for non uint64 values that can be packed into a uint64.
+// This method is for implementing new key types, label creation should
+// normally be done with the Of method of the key.
+func Of64(k Key, v uint64) Label { return Label{key: k, packed: v} }
+
+// Unpack64 assumes the label was built using LabelOf64 and returns the value that
+// was passed to that constructor.
+// This method is for implementing new key types, for type safety normal
+// access should be done with the From method of the key.
+func (t Label) Unpack64() uint64 { return t.packed }
+
+type stringptr unsafe.Pointer
+
+// OfString creates a new label from a key and a string.
+// This method is for implementing new key types, label creation should
+// normally be done with the Of method of the key.
+func OfString(k Key, v string) Label {
+ hdr := (*reflect.StringHeader)(unsafe.Pointer(&v))
+ return Label{
+ key: k,
+ packed: uint64(hdr.Len),
+ untyped: stringptr(hdr.Data),
+ }
+}
+
+// UnpackString assumes the label was built using LabelOfString and returns the
+// value that was passed to that constructor.
+// This method is for implementing new key types, for type safety normal
+// access should be done with the From method of the key.
+func (t Label) UnpackString() string {
+ var v string
+ hdr := (*reflect.StringHeader)(unsafe.Pointer(&v))
+ hdr.Data = uintptr(t.untyped.(stringptr))
+ hdr.Len = int(t.packed)
+ return v
+}
+
+// Valid returns true if the Label is a valid one (it has a key).
+func (t Label) Valid() bool { return t.key != nil }
+
+// Key returns the key of this Label.
+func (t Label) Key() Key { return t.key }
+
+// Format is used for debug printing of labels.
+func (t Label) Format(f fmt.State, r rune) {
+ if !t.Valid() {
+ io.WriteString(f, `nil`)
+ return
+ }
+ io.WriteString(f, t.Key().Name())
+ io.WriteString(f, "=")
+ var buf [128]byte
+ t.Key().Format(f, buf[:0], t)
+}
+
+func (l *list) Valid(index int) bool {
+ return index >= 0 && index < len(l.labels)
+}
+
+func (l *list) Label(index int) Label {
+ return l.labels[index]
+}
+
+func (f *filter) Valid(index int) bool {
+ return f.underlying.Valid(index)
+}
+
+func (f *filter) Label(index int) Label {
+ l := f.underlying.Label(index)
+ if slices.Contains(f.keys, l.Key()) {
+ return Label{}
+ }
+ return l
+}
+
+func (lm listMap) Find(key Key) Label {
+ for _, l := range lm.labels {
+ if l.Key() == key {
+ return l
+ }
+ }
+ return Label{}
+}
+
+func (c mapChain) Find(key Key) Label {
+ for _, src := range c.maps {
+ l := src.Find(key)
+ if l.Valid() {
+ return l
+ }
+ }
+ return Label{}
+}
+
+var emptyList = &list{}
+
+func NewList(labels ...Label) List {
+ if len(labels) == 0 {
+ return emptyList
+ }
+ return &list{labels: labels}
+}
+
+func Filter(l List, keys ...Key) List {
+ if len(keys) == 0 {
+ return l
+ }
+ return &filter{keys: keys, underlying: l}
+}
+
+func NewMap(labels ...Label) Map {
+ return listMap{labels: labels}
+}
+
+func MergeMaps(srcs ...Map) Map {
+ var nonNil []Map
+ for _, src := range srcs {
+ if src != nil {
+ nonNil = append(nonNil, src)
+ }
+ }
+ if len(nonNil) == 1 {
+ return nonNil[0]
+ }
+ return mapChain{maps: nonNil}
+}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/bimport.go b/vendor/golang.org/x/tools/internal/gcimporter/bimport.go
new file mode 100644
index 00000000..734c4619
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gcimporter/bimport.go
@@ -0,0 +1,89 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains the remaining vestiges of
+// $GOROOT/src/go/internal/gcimporter/bimport.go.
+
+package gcimporter
+
+import (
+ "fmt"
+ "go/token"
+ "go/types"
+ "sync"
+)
+
+func errorf(format string, args ...any) {
+ panic(fmt.Sprintf(format, args...))
+}
+
+const deltaNewFile = -64 // see cmd/compile/internal/gc/bexport.go
+
+// Synthesize a token.Pos
+type fakeFileSet struct {
+ fset *token.FileSet
+ files map[string]*fileInfo
+}
+
+type fileInfo struct {
+ file *token.File
+ lastline int
+}
+
+const maxlines = 64 * 1024
+
+func (s *fakeFileSet) pos(file string, line, column int) token.Pos {
+ // TODO(mdempsky): Make use of column.
+
+ // Since we don't know the set of needed file positions, we reserve maxlines
+ // positions per file. We delay calling token.File.SetLines until all
+ // positions have been calculated (by way of fakeFileSet.setLines), so that
+ // we can avoid setting unnecessary lines. See also golang/go#46586.
+ f := s.files[file]
+ if f == nil {
+ f = &fileInfo{file: s.fset.AddFile(file, -1, maxlines)}
+ s.files[file] = f
+ }
+ if line > maxlines {
+ line = 1
+ }
+ if line > f.lastline {
+ f.lastline = line
+ }
+
+ // Return a fake position assuming that f.file consists only of newlines.
+ return token.Pos(f.file.Base() + line - 1)
+}
+
+func (s *fakeFileSet) setLines() {
+ fakeLinesOnce.Do(func() {
+ fakeLines = make([]int, maxlines)
+ for i := range fakeLines {
+ fakeLines[i] = i
+ }
+ })
+ for _, f := range s.files {
+ f.file.SetLines(fakeLines[:f.lastline])
+ }
+}
+
+var (
+ fakeLines []int
+ fakeLinesOnce sync.Once
+)
+
+func chanDir(d int) types.ChanDir {
+ // tag values must match the constants in cmd/compile/internal/gc/go.go
+ switch d {
+ case 1 /* Crecv */ :
+ return types.RecvOnly
+ case 2 /* Csend */ :
+ return types.SendOnly
+ case 3 /* Cboth */ :
+ return types.SendRecv
+ default:
+ errorf("unexpected channel dir %d", d)
+ return 0
+ }
+}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go b/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go
new file mode 100644
index 00000000..5662a311
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gcimporter/exportdata.go
@@ -0,0 +1,421 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file should be kept in sync with $GOROOT/src/internal/exportdata/exportdata.go.
+// This file also additionally implements FindExportData for gcexportdata.NewReader.
+
+package gcimporter
+
+import (
+ "bufio"
+ "bytes"
+ "errors"
+ "fmt"
+ "go/build"
+ "io"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "strings"
+ "sync"
+)
+
+// FindExportData positions the reader r at the beginning of the
+// export data section of an underlying cmd/compile created archive
+// file by reading from it. The reader must be positioned at the
+// start of the file before calling this function.
+// This returns the length of the export data in bytes.
+//
+// This function is needed by [gcexportdata.Read], which must
+// accept inputs produced by the last two releases of cmd/compile,
+// plus tip.
+func FindExportData(r *bufio.Reader) (size int64, err error) {
+ arsize, err := FindPackageDefinition(r)
+ if err != nil {
+ return
+ }
+ size = int64(arsize)
+
+ objapi, headers, err := ReadObjectHeaders(r)
+ if err != nil {
+ return
+ }
+ size -= int64(len(objapi))
+ for _, h := range headers {
+ size -= int64(len(h))
+ }
+
+ // Check for the binary export data section header "$$B\n".
+ // TODO(taking): Unify with ReadExportDataHeader so that it stops at the 'u' instead of reading
+ line, err := r.ReadSlice('\n')
+ if err != nil {
+ return
+ }
+ hdr := string(line)
+ if hdr != "$$B\n" {
+ err = fmt.Errorf("unknown export data header: %q", hdr)
+ return
+ }
+ size -= int64(len(hdr))
+
+ // For files with a binary export data header "$$B\n",
+ // these are always terminated by an end-of-section marker "\n$$\n".
+ // So the last bytes must always be this constant.
+ //
+ // The end-of-section marker is not a part of the export data itself.
+ // Do not include these in size.
+ //
+ // It would be nice to have sanity check that the final bytes after
+ // the export data are indeed the end-of-section marker. The split
+ // of gcexportdata.NewReader and gcexportdata.Read make checking this
+ // ugly so gcimporter gives up enforcing this. The compiler and go/types
+ // importer do enforce this, which seems good enough.
+ const endofsection = "\n$$\n"
+ size -= int64(len(endofsection))
+
+ if size < 0 {
+ err = fmt.Errorf("invalid size (%d) in the archive file: %d bytes remain without section headers (recompile package)", arsize, size)
+ return
+ }
+
+ return
+}
+
+// ReadUnified reads the contents of the unified export data from a reader r
+// that contains the contents of a GC-created archive file.
+//
+// On success, the reader will be positioned after the end-of-section marker "\n$$\n".
+//
+// Supported GC-created archive files have 4 layers of nesting:
+// - An archive file containing a package definition file.
+// - The package definition file contains headers followed by a data section.
+// Headers are lines (≤ 4kb) that do not start with "$$".
+// - The data section starts with "$$B\n" followed by export data followed
+// by an end of section marker "\n$$\n". (The section start "$$\n" is no
+// longer supported.)
+// - The export data starts with a format byte ('u') followed by the in
+// the given format. (See ReadExportDataHeader for older formats.)
+//
+// Putting this together, the bytes in a GC-created archive files are expected
+// to look like the following.
+// See cmd/internal/archive for more details on ar file headers.
+//
+// | \n | ar file signature
+// | __.PKGDEF...size...\n | ar header for __.PKGDEF including size.
+// | go object <...>\n | objabi header
+// | \n | other headers such as build id
+// | $$B\n | binary format marker
+// | u\n | unified export
+// | $$\n | end-of-section marker
+// | [optional padding] | padding byte (0x0A) if size is odd
+// | [ar file header] | other ar files
+// | [ar file data] |
+func ReadUnified(r *bufio.Reader) (data []byte, err error) {
+ // We historically guaranteed headers at the default buffer size (4096) work.
+ // This ensures we can use ReadSlice throughout.
+ const minBufferSize = 4096
+ r = bufio.NewReaderSize(r, minBufferSize)
+
+ size, err := FindPackageDefinition(r)
+ if err != nil {
+ return
+ }
+ n := size
+
+ objapi, headers, err := ReadObjectHeaders(r)
+ if err != nil {
+ return
+ }
+ n -= len(objapi)
+ for _, h := range headers {
+ n -= len(h)
+ }
+
+ hdrlen, err := ReadExportDataHeader(r)
+ if err != nil {
+ return
+ }
+ n -= hdrlen
+
+ // size also includes the end of section marker. Remove that many bytes from the end.
+ const marker = "\n$$\n"
+ n -= len(marker)
+
+ if n < 0 {
+ err = fmt.Errorf("invalid size (%d) in the archive file: %d bytes remain without section headers (recompile package)", size, n)
+ return
+ }
+
+ // Read n bytes from buf.
+ data = make([]byte, n)
+ _, err = io.ReadFull(r, data)
+ if err != nil {
+ return
+ }
+
+ // Check for marker at the end.
+ var suffix [len(marker)]byte
+ _, err = io.ReadFull(r, suffix[:])
+ if err != nil {
+ return
+ }
+ if s := string(suffix[:]); s != marker {
+ err = fmt.Errorf("read %q instead of end-of-section marker (%q)", s, marker)
+ return
+ }
+
+ return
+}
+
+// FindPackageDefinition positions the reader r at the beginning of a package
+// definition file ("__.PKGDEF") within a GC-created archive by reading
+// from it, and returns the size of the package definition file in the archive.
+//
+// The reader must be positioned at the start of the archive file before calling
+// this function, and "__.PKGDEF" is assumed to be the first file in the archive.
+//
+// See cmd/internal/archive for details on the archive format.
+func FindPackageDefinition(r *bufio.Reader) (size int, err error) {
+ // Uses ReadSlice to limit risk of malformed inputs.
+
+ // Read first line to make sure this is an object file.
+ line, err := r.ReadSlice('\n')
+ if err != nil {
+ err = fmt.Errorf("can't find export data (%v)", err)
+ return
+ }
+
+ // Is the first line an archive file signature?
+ if string(line) != "!\n" {
+ err = fmt.Errorf("not the start of an archive file (%q)", line)
+ return
+ }
+
+ // package export block should be first
+ size = readArchiveHeader(r, "__.PKGDEF")
+ if size <= 0 {
+ err = fmt.Errorf("not a package file")
+ return
+ }
+
+ return
+}
+
+// ReadObjectHeaders reads object headers from the reader. Object headers are
+// lines that do not start with an end-of-section marker "$$". The first header
+// is the objabi header. On success, the reader will be positioned at the beginning
+// of the end-of-section marker.
+//
+// It returns an error if any header does not fit in r.Size() bytes.
+func ReadObjectHeaders(r *bufio.Reader) (objapi string, headers []string, err error) {
+ // line is a temporary buffer for headers.
+ // Use bounded reads (ReadSlice, Peek) to limit risk of malformed inputs.
+ var line []byte
+
+ // objapi header should be the first line
+ if line, err = r.ReadSlice('\n'); err != nil {
+ err = fmt.Errorf("can't find export data (%v)", err)
+ return
+ }
+ objapi = string(line)
+
+ // objapi header begins with "go object ".
+ if !strings.HasPrefix(objapi, "go object ") {
+ err = fmt.Errorf("not a go object file: %s", objapi)
+ return
+ }
+
+ // process remaining object header lines
+ for {
+ // check for an end of section marker "$$"
+ line, err = r.Peek(2)
+ if err != nil {
+ return
+ }
+ if string(line) == "$$" {
+ return // stop
+ }
+
+ // read next header
+ line, err = r.ReadSlice('\n')
+ if err != nil {
+ return
+ }
+ headers = append(headers, string(line))
+ }
+}
+
+// ReadExportDataHeader reads the export data header and format from r.
+// It returns the number of bytes read, or an error if the format is no longer
+// supported or it failed to read.
+//
+// The only currently supported format is binary export data in the
+// unified export format.
+func ReadExportDataHeader(r *bufio.Reader) (n int, err error) {
+ // Read export data header.
+ line, err := r.ReadSlice('\n')
+ if err != nil {
+ return
+ }
+
+ hdr := string(line)
+ switch hdr {
+ case "$$\n":
+ err = fmt.Errorf("old textual export format no longer supported (recompile package)")
+ return
+
+ case "$$B\n":
+ var format byte
+ format, err = r.ReadByte()
+ if err != nil {
+ return
+ }
+ // The unified export format starts with a 'u'.
+ switch format {
+ case 'u':
+ default:
+ // Older no longer supported export formats include:
+ // indexed export format which started with an 'i'; and
+ // the older binary export format which started with a 'c',
+ // 'd', or 'v' (from "version").
+ err = fmt.Errorf("binary export format %q is no longer supported (recompile package)", format)
+ return
+ }
+
+ default:
+ err = fmt.Errorf("unknown export data header: %q", hdr)
+ return
+ }
+
+ n = len(hdr) + 1 // + 1 is for 'u'
+ return
+}
+
+// FindPkg returns the filename and unique package id for an import
+// path based on package information provided by build.Import (using
+// the build.Default build.Context). A relative srcDir is interpreted
+// relative to the current working directory.
+//
+// FindPkg is only used in tests within x/tools.
+func FindPkg(path, srcDir string) (filename, id string, err error) {
+ // TODO(taking): Move internal/exportdata.FindPkg into its own file,
+ // and then this copy into a _test package.
+ if path == "" {
+ return "", "", errors.New("path is empty")
+ }
+
+ var noext string
+ switch {
+ default:
+ // "x" -> "$GOPATH/pkg/$GOOS_$GOARCH/x.ext", "x"
+ // Don't require the source files to be present.
+ if abs, err := filepath.Abs(srcDir); err == nil { // see issue 14282
+ srcDir = abs
+ }
+ var bp *build.Package
+ bp, err = build.Import(path, srcDir, build.FindOnly|build.AllowBinary)
+ if bp.PkgObj == "" {
+ if bp.Goroot && bp.Dir != "" {
+ filename, err = lookupGorootExport(bp.Dir)
+ if err == nil {
+ _, err = os.Stat(filename)
+ }
+ if err == nil {
+ return filename, bp.ImportPath, nil
+ }
+ }
+ goto notfound
+ } else {
+ noext = strings.TrimSuffix(bp.PkgObj, ".a")
+ }
+ id = bp.ImportPath
+
+ case build.IsLocalImport(path):
+ // "./x" -> "/this/directory/x.ext", "/this/directory/x"
+ noext = filepath.Join(srcDir, path)
+ id = noext
+
+ case filepath.IsAbs(path):
+ // for completeness only - go/build.Import
+ // does not support absolute imports
+ // "/x" -> "/x.ext", "/x"
+ noext = path
+ id = path
+ }
+
+ if false { // for debugging
+ if path != id {
+ fmt.Printf("%s -> %s\n", path, id)
+ }
+ }
+
+ // try extensions
+ for _, ext := range pkgExts {
+ filename = noext + ext
+ f, statErr := os.Stat(filename)
+ if statErr == nil && !f.IsDir() {
+ return filename, id, nil
+ }
+ if err == nil {
+ err = statErr
+ }
+ }
+
+notfound:
+ if err == nil {
+ return "", path, fmt.Errorf("can't find import: %q", path)
+ }
+ return "", path, fmt.Errorf("can't find import: %q: %w", path, err)
+}
+
+var pkgExts = [...]string{".a", ".o"} // a file from the build cache will have no extension
+
+var exportMap sync.Map // package dir → func() (string, error)
+
+// lookupGorootExport returns the location of the export data
+// (normally found in the build cache, but located in GOROOT/pkg
+// in prior Go releases) for the package located in pkgDir.
+//
+// (We use the package's directory instead of its import path
+// mainly to simplify handling of the packages in src/vendor
+// and cmd/vendor.)
+//
+// lookupGorootExport is only used in tests within x/tools.
+func lookupGorootExport(pkgDir string) (string, error) {
+ f, ok := exportMap.Load(pkgDir)
+ if !ok {
+ var (
+ listOnce sync.Once
+ exportPath string
+ err error
+ )
+ f, _ = exportMap.LoadOrStore(pkgDir, func() (string, error) {
+ listOnce.Do(func() {
+ cmd := exec.Command(filepath.Join(build.Default.GOROOT, "bin", "go"), "list", "-export", "-f", "{{.Export}}", pkgDir)
+ cmd.Dir = build.Default.GOROOT
+ cmd.Env = append(os.Environ(), "PWD="+cmd.Dir, "GOROOT="+build.Default.GOROOT)
+ var output []byte
+ output, err = cmd.Output()
+ if err != nil {
+ if ee, ok := err.(*exec.ExitError); ok && len(ee.Stderr) > 0 {
+ err = errors.New(string(ee.Stderr))
+ }
+ return
+ }
+
+ exports := strings.Split(string(bytes.TrimSpace(output)), "\n")
+ if len(exports) != 1 {
+ err = fmt.Errorf("go list reported %d exports; expected 1", len(exports))
+ return
+ }
+
+ exportPath = exports[0]
+ })
+
+ return exportPath, err
+ })
+ }
+
+ return f.(func() (string, error))()
+}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go b/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go
new file mode 100644
index 00000000..3dbd21d1
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gcimporter/gcimporter.go
@@ -0,0 +1,108 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file is a reduced copy of $GOROOT/src/go/internal/gcimporter/gcimporter.go.
+
+// Package gcimporter provides various functions for reading
+// gc-generated object files that can be used to implement the
+// Importer interface defined by the Go 1.5 standard library package.
+//
+// The encoding is deterministic: if the encoder is applied twice to
+// the same types.Package data structure, both encodings are equal.
+// This property may be important to avoid spurious changes in
+// applications such as build systems.
+//
+// However, the encoder is not necessarily idempotent. Importing an
+// exported package may yield a types.Package that, while it
+// represents the same set of Go types as the original, may differ in
+// the details of its internal representation. Because of these
+// differences, re-encoding the imported package may yield a
+// different, but equally valid, encoding of the package.
+package gcimporter // import "golang.org/x/tools/internal/gcimporter"
+
+import (
+ "bufio"
+ "fmt"
+ "go/token"
+ "go/types"
+ "io"
+ "os"
+)
+
+const (
+ // Enable debug during development: it adds some additional checks, and
+ // prevents errors from being recovered.
+ debug = false
+
+ // If trace is set, debugging output is printed to std out.
+ trace = false
+)
+
+// Import imports a gc-generated package given its import path and srcDir, adds
+// the corresponding package object to the packages map, and returns the object.
+// The packages map must contain all packages already imported.
+//
+// Import is only used in tests.
+func Import(fset *token.FileSet, packages map[string]*types.Package, path, srcDir string, lookup func(path string) (io.ReadCloser, error)) (pkg *types.Package, err error) {
+ var rc io.ReadCloser
+ var id string
+ if lookup != nil {
+ // With custom lookup specified, assume that caller has
+ // converted path to a canonical import path for use in the map.
+ if path == "unsafe" {
+ return types.Unsafe, nil
+ }
+ id = path
+
+ // No need to re-import if the package was imported completely before.
+ if pkg = packages[id]; pkg != nil && pkg.Complete() {
+ return
+ }
+ f, err := lookup(path)
+ if err != nil {
+ return nil, err
+ }
+ rc = f
+ } else {
+ var filename string
+ filename, id, err = FindPkg(path, srcDir)
+ if filename == "" {
+ if path == "unsafe" {
+ return types.Unsafe, nil
+ }
+ return nil, err
+ }
+
+ // no need to re-import if the package was imported completely before
+ if pkg = packages[id]; pkg != nil && pkg.Complete() {
+ return
+ }
+
+ // open file
+ f, err := os.Open(filename)
+ if err != nil {
+ return nil, err
+ }
+ defer func() {
+ if err != nil {
+ // add file name to error
+ err = fmt.Errorf("%s: %v", filename, err)
+ }
+ }()
+ rc = f
+ }
+ defer rc.Close()
+
+ buf := bufio.NewReader(rc)
+ data, err := ReadUnified(buf)
+ if err != nil {
+ err = fmt.Errorf("import %q: %v", path, err)
+ return
+ }
+
+ // unified: emitted by cmd/compile since go1.20.
+ _, pkg, err = UImportData(fset, packages, data, id)
+
+ return
+}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iexport.go b/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
new file mode 100644
index 00000000..780873e3
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iexport.go
@@ -0,0 +1,1596 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Indexed package export.
+//
+// The indexed export data format is an evolution of the previous
+// binary export data format. Its chief contribution is introducing an
+// index table, which allows efficient random access of individual
+// declarations and inline function bodies. In turn, this allows
+// avoiding unnecessary work for compilation units that import large
+// packages.
+//
+//
+// The top-level data format is structured as:
+//
+// Header struct {
+// Tag byte // 'i'
+// Version uvarint
+// StringSize uvarint
+// DataSize uvarint
+// }
+//
+// Strings [StringSize]byte
+// Data [DataSize]byte
+//
+// MainIndex []struct{
+// PkgPath stringOff
+// PkgName stringOff
+// PkgHeight uvarint
+//
+// Decls []struct{
+// Name stringOff
+// Offset declOff
+// }
+// }
+//
+// Fingerprint [8]byte
+//
+// uvarint means a uint64 written out using uvarint encoding.
+//
+// []T means a uvarint followed by that many T objects. In other
+// words:
+//
+// Len uvarint
+// Elems [Len]T
+//
+// stringOff means a uvarint that indicates an offset within the
+// Strings section. At that offset is another uvarint, followed by
+// that many bytes, which form the string value.
+//
+// declOff means a uvarint that indicates an offset within the Data
+// section where the associated declaration can be found.
+//
+//
+// There are five kinds of declarations, distinguished by their first
+// byte:
+//
+// type Var struct {
+// Tag byte // 'V'
+// Pos Pos
+// Type typeOff
+// }
+//
+// type Func struct {
+// Tag byte // 'F' or 'G'
+// Pos Pos
+// TypeParams []typeOff // only present if Tag == 'G'
+// Signature Signature
+// }
+//
+// type Const struct {
+// Tag byte // 'C'
+// Pos Pos
+// Value Value
+// }
+//
+// type Type struct {
+// Tag byte // 'T' or 'U'
+// Pos Pos
+// TypeParams []typeOff // only present if Tag == 'U'
+// Underlying typeOff
+//
+// Methods []struct{ // omitted if Underlying is an interface type
+// Pos Pos
+// Name stringOff
+// Recv Param
+// Signature Signature
+// }
+// }
+//
+// type Alias struct {
+// Tag byte // 'A' or 'B'
+// Pos Pos
+// TypeParams []typeOff // only present if Tag == 'B'
+// Type typeOff
+// }
+//
+// // "Automatic" declaration of each typeparam
+// type TypeParam struct {
+// Tag byte // 'P'
+// Pos Pos
+// Implicit bool
+// Constraint typeOff
+// }
+//
+// typeOff means a uvarint that either indicates a predeclared type,
+// or an offset into the Data section. If the uvarint is less than
+// predeclReserved, then it indicates the index into the predeclared
+// types list (see predeclared in bexport.go for order). Otherwise,
+// subtracting predeclReserved yields the offset of a type descriptor.
+//
+// Value means a type, kind, and type-specific value. See
+// (*exportWriter).value for details.
+//
+//
+// There are twelve kinds of type descriptors, distinguished by an itag:
+//
+// type DefinedType struct {
+// Tag itag // definedType
+// Name stringOff
+// PkgPath stringOff
+// }
+//
+// type PointerType struct {
+// Tag itag // pointerType
+// Elem typeOff
+// }
+//
+// type SliceType struct {
+// Tag itag // sliceType
+// Elem typeOff
+// }
+//
+// type ArrayType struct {
+// Tag itag // arrayType
+// Len uint64
+// Elem typeOff
+// }
+//
+// type ChanType struct {
+// Tag itag // chanType
+// Dir uint64 // 1 RecvOnly; 2 SendOnly; 3 SendRecv
+// Elem typeOff
+// }
+//
+// type MapType struct {
+// Tag itag // mapType
+// Key typeOff
+// Elem typeOff
+// }
+//
+// type FuncType struct {
+// Tag itag // signatureType
+// PkgPath stringOff
+// Signature Signature
+// }
+//
+// type StructType struct {
+// Tag itag // structType
+// PkgPath stringOff
+// Fields []struct {
+// Pos Pos
+// Name stringOff
+// Type typeOff
+// Embedded bool
+// Note stringOff
+// }
+// }
+//
+// type InterfaceType struct {
+// Tag itag // interfaceType
+// PkgPath stringOff
+// Embeddeds []struct {
+// Pos Pos
+// Type typeOff
+// }
+// Methods []struct {
+// Pos Pos
+// Name stringOff
+// Signature Signature
+// }
+// }
+//
+// // Reference to a type param declaration
+// type TypeParamType struct {
+// Tag itag // typeParamType
+// Name stringOff
+// PkgPath stringOff
+// }
+//
+// // Instantiation of a generic type (like List[T2] or List[int])
+// type InstanceType struct {
+// Tag itag // instanceType
+// Pos pos
+// TypeArgs []typeOff
+// BaseType typeOff
+// }
+//
+// type UnionType struct {
+// Tag itag // interfaceType
+// Terms []struct {
+// tilde bool
+// Type typeOff
+// }
+// }
+//
+//
+//
+// type Signature struct {
+// Params []Param
+// Results []Param
+// Variadic bool // omitted if Results is empty
+// }
+//
+// type Param struct {
+// Pos Pos
+// Name stringOff
+// Type typOff
+// }
+//
+//
+// Pos encodes a file:line:column triple, incorporating a simple delta
+// encoding scheme within a data object. See exportWriter.pos for
+// details.
+
+package gcimporter
+
+import (
+ "bytes"
+ "encoding/binary"
+ "fmt"
+ "go/constant"
+ "go/token"
+ "go/types"
+ "io"
+ "math/big"
+ "reflect"
+ "slices"
+ "sort"
+ "strconv"
+ "strings"
+
+ "golang.org/x/tools/go/types/objectpath"
+ "golang.org/x/tools/internal/aliases"
+)
+
+// IExportShallow encodes "shallow" export data for the specified package.
+//
+// For types, we use "shallow" export data. Historically, the Go
+// compiler always produced a summary of the types for a given package
+// that included types from other packages that it indirectly
+// referenced: "deep" export data. This had the advantage that the
+// compiler (and analogous tools such as gopls) need only load one
+// file per direct import. However, it meant that the files tended to
+// get larger based on the level of the package in the import
+// graph. For example, higher-level packages in the kubernetes module
+// have over 1MB of "deep" export data, even when they have almost no
+// content of their own, merely because they mention a major type that
+// references many others. In pathological cases the export data was
+// 300x larger than the source for a package due to this quadratic
+// growth.
+//
+// "Shallow" export data means that the serialized types describe only
+// a single package. If those types mention types from other packages,
+// the type checker may need to request additional packages beyond
+// just the direct imports. Type information for the entire transitive
+// closure of imports is provided (lazily) by the DAG.
+//
+// No promises are made about the encoding other than that it can be decoded by
+// the same version of IIExportShallow. If you plan to save export data in the
+// file system, be sure to include a cryptographic digest of the executable in
+// the key to avoid version skew.
+//
+// If the provided reportf func is non-nil, it is used for reporting
+// bugs (e.g. recovered panics) encountered during export, enabling us
+// to obtain via telemetry the stack that would otherwise be lost by
+// merely returning an error.
+func IExportShallow(fset *token.FileSet, pkg *types.Package, reportf ReportFunc) ([]byte, error) {
+ // In principle this operation can only fail if out.Write fails,
+ // but that's impossible for bytes.Buffer---and as a matter of
+ // fact iexportCommon doesn't even check for I/O errors.
+ // TODO(adonovan): handle I/O errors properly.
+ // TODO(adonovan): use byte slices throughout, avoiding copying.
+ const bundle, shallow = false, true
+ var out bytes.Buffer
+ err := iexportCommon(&out, fset, bundle, shallow, iexportVersion, []*types.Package{pkg}, reportf)
+ return out.Bytes(), err
+}
+
+// IImportShallow decodes "shallow" types.Package data encoded by
+// [IExportShallow] in the same executable. This function cannot import data
+// from cmd/compile or gcexportdata.Write.
+//
+// The importer calls getPackages to obtain package symbols for all
+// packages mentioned in the export data, including the one being
+// decoded.
+//
+// If the provided reportf func is non-nil, it will be used for reporting bugs
+// encountered during import.
+// TODO(rfindley): remove reportf when we are confident enough in the new
+// objectpath encoding.
+func IImportShallow(fset *token.FileSet, getPackages GetPackagesFunc, data []byte, path string, reportf ReportFunc) (*types.Package, error) {
+ const bundle = false
+ const shallow = true
+ pkgs, err := iimportCommon(fset, getPackages, data, bundle, path, shallow, reportf)
+ if err != nil {
+ return nil, err
+ }
+ return pkgs[0], nil
+}
+
+// ReportFunc is the type of a function used to report formatted bugs.
+type ReportFunc = func(string, ...any)
+
+// Current bundled export format version. Increase with each format change.
+// 0: initial implementation
+const bundleVersion = 0
+
+// IExportData writes indexed export data for pkg to out.
+//
+// If no file set is provided, position info will be missing.
+// The package path of the top-level package will not be recorded,
+// so that calls to IImportData can override with a provided package path.
+func IExportData(out io.Writer, fset *token.FileSet, pkg *types.Package) error {
+ const bundle, shallow = false, false
+ return iexportCommon(out, fset, bundle, shallow, iexportVersion, []*types.Package{pkg}, nil)
+}
+
+// IExportBundle writes an indexed export bundle for pkgs to out.
+func IExportBundle(out io.Writer, fset *token.FileSet, pkgs []*types.Package) error {
+ const bundle, shallow = true, false
+ return iexportCommon(out, fset, bundle, shallow, iexportVersion, pkgs, nil)
+}
+
+func iexportCommon(out io.Writer, fset *token.FileSet, bundle, shallow bool, version int, pkgs []*types.Package, reportf ReportFunc) (err error) {
+ if !debug {
+ defer func() {
+ if e := recover(); e != nil {
+ // Report the stack via telemetry (see #71067).
+ if reportf != nil {
+ reportf("panic in exporter")
+ }
+ if ierr, ok := e.(internalError); ok {
+ // internalError usually means we exported a
+ // bad go/types data structure: a violation
+ // of an implicit precondition of Export.
+ err = ierr
+ return
+ }
+ // Not an internal error; panic again.
+ panic(e)
+ }
+ }()
+ }
+
+ p := iexporter{
+ fset: fset,
+ version: version,
+ shallow: shallow,
+ allPkgs: map[*types.Package]bool{},
+ stringIndex: map[string]uint64{},
+ declIndex: map[types.Object]uint64{},
+ tparamNames: map[types.Object]string{},
+ typIndex: map[types.Type]uint64{},
+ }
+ if !bundle {
+ p.localpkg = pkgs[0]
+ }
+
+ for i, pt := range predeclared() {
+ p.typIndex[pt] = uint64(i)
+ }
+ if len(p.typIndex) > predeclReserved {
+ panic(internalErrorf("too many predeclared types: %d > %d", len(p.typIndex), predeclReserved))
+ }
+
+ // Initialize work queue with exported declarations.
+ for _, pkg := range pkgs {
+ scope := pkg.Scope()
+ for _, name := range scope.Names() {
+ if token.IsExported(name) {
+ p.pushDecl(scope.Lookup(name))
+ }
+ }
+
+ if bundle {
+ // Ensure pkg and its imports are included in the index.
+ p.allPkgs[pkg] = true
+ for _, imp := range pkg.Imports() {
+ p.allPkgs[imp] = true
+ }
+ }
+ }
+
+ // Loop until no more work.
+ for !p.declTodo.empty() {
+ p.doDecl(p.declTodo.popHead())
+ }
+
+ // Produce index of offset of each file record in files.
+ var files intWriter
+ var fileOffset []uint64 // fileOffset[i] is offset in files of file encoded as i
+ if p.shallow {
+ fileOffset = make([]uint64, len(p.fileInfos))
+ for i, info := range p.fileInfos {
+ fileOffset[i] = uint64(files.Len())
+ p.encodeFile(&files, info.file, info.needed)
+ }
+ }
+
+ // Append indices to data0 section.
+ dataLen := uint64(p.data0.Len())
+ w := p.newWriter()
+ w.writeIndex(p.declIndex)
+
+ if bundle {
+ w.uint64(uint64(len(pkgs)))
+ for _, pkg := range pkgs {
+ w.pkg(pkg)
+ imps := pkg.Imports()
+ w.uint64(uint64(len(imps)))
+ for _, imp := range imps {
+ w.pkg(imp)
+ }
+ }
+ }
+ w.flush()
+
+ // Assemble header.
+ var hdr intWriter
+ if bundle {
+ hdr.uint64(bundleVersion)
+ }
+ hdr.uint64(uint64(p.version))
+ hdr.uint64(uint64(p.strings.Len()))
+ if p.shallow {
+ hdr.uint64(uint64(files.Len()))
+ hdr.uint64(uint64(len(fileOffset)))
+ for _, offset := range fileOffset {
+ hdr.uint64(offset)
+ }
+ }
+ hdr.uint64(dataLen)
+
+ // Flush output.
+ io.Copy(out, &hdr)
+ io.Copy(out, &p.strings)
+ if p.shallow {
+ io.Copy(out, &files)
+ }
+ io.Copy(out, &p.data0)
+
+ return nil
+}
+
+// encodeFile writes to w a representation of the file sufficient to
+// faithfully restore position information about all needed offsets.
+// Mutates the needed array.
+func (p *iexporter) encodeFile(w *intWriter, file *token.File, needed []uint64) {
+ _ = needed[0] // precondition: needed is non-empty
+
+ w.uint64(p.stringOff(file.Name()))
+
+ size := uint64(file.Size())
+ w.uint64(size)
+
+ // Sort the set of needed offsets. Duplicates are harmless.
+ slices.Sort(needed)
+
+ lines := file.Lines() // byte offset of each line start
+ w.uint64(uint64(len(lines)))
+
+ // Rather than record the entire array of line start offsets,
+ // we save only a sparse list of (index, offset) pairs for
+ // the start of each line that contains a needed position.
+ var sparse [][2]int // (index, offset) pairs
+outer:
+ for i, lineStart := range lines {
+ lineEnd := size
+ if i < len(lines)-1 {
+ lineEnd = uint64(lines[i+1])
+ }
+ // Does this line contains a needed offset?
+ if needed[0] < lineEnd {
+ sparse = append(sparse, [2]int{i, lineStart})
+ for needed[0] < lineEnd {
+ needed = needed[1:]
+ if len(needed) == 0 {
+ break outer
+ }
+ }
+ }
+ }
+
+ // Delta-encode the columns.
+ w.uint64(uint64(len(sparse)))
+ var prev [2]int
+ for _, pair := range sparse {
+ w.uint64(uint64(pair[0] - prev[0]))
+ w.uint64(uint64(pair[1] - prev[1]))
+ prev = pair
+ }
+}
+
+// writeIndex writes out an object index. mainIndex indicates whether
+// we're writing out the main index, which is also read by
+// non-compiler tools and includes a complete package description
+// (i.e., name and height).
+func (w *exportWriter) writeIndex(index map[types.Object]uint64) {
+ type pkgObj struct {
+ obj types.Object
+ name string // qualified name; differs from obj.Name for type params
+ }
+ // Build a map from packages to objects from that package.
+ pkgObjs := map[*types.Package][]pkgObj{}
+
+ // For the main index, make sure to include every package that
+ // we reference, even if we're not exporting (or reexporting)
+ // any symbols from it.
+ if w.p.localpkg != nil {
+ pkgObjs[w.p.localpkg] = nil
+ }
+ for pkg := range w.p.allPkgs {
+ pkgObjs[pkg] = nil
+ }
+
+ for obj := range index {
+ name := w.p.exportName(obj)
+ pkgObjs[obj.Pkg()] = append(pkgObjs[obj.Pkg()], pkgObj{obj, name})
+ }
+
+ var pkgs []*types.Package
+ for pkg, objs := range pkgObjs {
+ pkgs = append(pkgs, pkg)
+
+ sort.Slice(objs, func(i, j int) bool {
+ return objs[i].name < objs[j].name
+ })
+ }
+
+ sort.Slice(pkgs, func(i, j int) bool {
+ return w.exportPath(pkgs[i]) < w.exportPath(pkgs[j])
+ })
+
+ w.uint64(uint64(len(pkgs)))
+ for _, pkg := range pkgs {
+ w.string(w.exportPath(pkg))
+ w.string(pkg.Name())
+ w.uint64(uint64(0)) // package height is not needed for go/types
+
+ objs := pkgObjs[pkg]
+ w.uint64(uint64(len(objs)))
+ for _, obj := range objs {
+ w.string(obj.name)
+ w.uint64(index[obj.obj])
+ }
+ }
+}
+
+// exportName returns the 'exported' name of an object. It differs from
+// obj.Name() only for type parameters (see tparamExportName for details).
+func (p *iexporter) exportName(obj types.Object) (res string) {
+ if name := p.tparamNames[obj]; name != "" {
+ return name
+ }
+ return obj.Name()
+}
+
+type iexporter struct {
+ fset *token.FileSet
+ out *bytes.Buffer
+ version int
+
+ shallow bool // don't put types from other packages in the index
+ objEncoder *objectpath.Encoder // encodes objects from other packages in shallow mode; lazily allocated
+ localpkg *types.Package // (nil in bundle mode)
+
+ // allPkgs tracks all packages that have been referenced by
+ // the export data, so we can ensure to include them in the
+ // main index.
+ allPkgs map[*types.Package]bool
+
+ declTodo objQueue
+
+ strings intWriter
+ stringIndex map[string]uint64
+
+ // In shallow mode, object positions are encoded as (file, offset).
+ // Each file is recorded as a line-number table.
+ // Only the lines of needed positions are saved faithfully.
+ fileInfo map[*token.File]uint64 // value is index in fileInfos
+ fileInfos []*filePositions
+
+ data0 intWriter
+ declIndex map[types.Object]uint64
+ tparamNames map[types.Object]string // typeparam->exported name
+ typIndex map[types.Type]uint64
+
+ indent int // for tracing support
+}
+
+type filePositions struct {
+ file *token.File
+ needed []uint64 // unordered list of needed file offsets
+}
+
+func (p *iexporter) trace(format string, args ...any) {
+ if !trace {
+ // Call sites should also be guarded, but having this check here allows
+ // easily enabling/disabling debug trace statements.
+ return
+ }
+ fmt.Printf(strings.Repeat("..", p.indent)+format+"\n", args...)
+}
+
+// objectpathEncoder returns the lazily allocated objectpath.Encoder to use
+// when encoding objects in other packages during shallow export.
+//
+// Using a shared Encoder amortizes some of cost of objectpath search.
+func (p *iexporter) objectpathEncoder() *objectpath.Encoder {
+ if p.objEncoder == nil {
+ p.objEncoder = new(objectpath.Encoder)
+ }
+ return p.objEncoder
+}
+
+// stringOff returns the offset of s within the string section.
+// If not already present, it's added to the end.
+func (p *iexporter) stringOff(s string) uint64 {
+ off, ok := p.stringIndex[s]
+ if !ok {
+ off = uint64(p.strings.Len())
+ p.stringIndex[s] = off
+
+ p.strings.uint64(uint64(len(s)))
+ p.strings.WriteString(s)
+ }
+ return off
+}
+
+// fileIndexAndOffset returns the index of the token.File and the byte offset of pos within it.
+func (p *iexporter) fileIndexAndOffset(file *token.File, pos token.Pos) (uint64, uint64) {
+ index, ok := p.fileInfo[file]
+ if !ok {
+ index = uint64(len(p.fileInfo))
+ p.fileInfos = append(p.fileInfos, &filePositions{file: file})
+ if p.fileInfo == nil {
+ p.fileInfo = make(map[*token.File]uint64)
+ }
+ p.fileInfo[file] = index
+ }
+ // Record each needed offset.
+ info := p.fileInfos[index]
+ offset := uint64(file.Offset(pos))
+ info.needed = append(info.needed, offset)
+
+ return index, offset
+}
+
+// pushDecl adds n to the declaration work queue, if not already present.
+func (p *iexporter) pushDecl(obj types.Object) {
+ // Package unsafe is known to the compiler and predeclared.
+ // Caller should not ask us to do export it.
+ if obj.Pkg() == types.Unsafe {
+ panic("cannot export package unsafe")
+ }
+
+ // Shallow export data: don't index decls from other packages.
+ if p.shallow && obj.Pkg() != p.localpkg {
+ return
+ }
+
+ if _, ok := p.declIndex[obj]; ok {
+ return
+ }
+
+ p.declIndex[obj] = ^uint64(0) // mark obj present in work queue
+ p.declTodo.pushTail(obj)
+}
+
+// exportWriter handles writing out individual data section chunks.
+type exportWriter struct {
+ p *iexporter
+
+ data intWriter
+ prevFile string
+ prevLine int64
+ prevColumn int64
+}
+
+func (w *exportWriter) exportPath(pkg *types.Package) string {
+ if pkg == w.p.localpkg {
+ return ""
+ }
+ return pkg.Path()
+}
+
+func (p *iexporter) doDecl(obj types.Object) {
+ if trace {
+ p.trace("exporting decl %v (%T)", obj, obj)
+ p.indent++
+ defer func() {
+ p.indent--
+ p.trace("=> %s", obj)
+ }()
+ }
+ w := p.newWriter()
+
+ switch obj := obj.(type) {
+ case *types.Var:
+ w.tag(varTag)
+ w.pos(obj.Pos())
+ w.typ(obj.Type(), obj.Pkg())
+
+ case *types.Func:
+ sig, _ := obj.Type().(*types.Signature)
+ if sig.Recv() != nil {
+ // We shouldn't see methods in the package scope,
+ // but the type checker may repair "func () F() {}"
+ // to "func (Invalid) F()" and then treat it like "func F()",
+ // so allow that. See golang/go#57729.
+ if sig.Recv().Type() != types.Typ[types.Invalid] {
+ panic(internalErrorf("unexpected method: %v", sig))
+ }
+ }
+
+ // Function.
+ if sig.TypeParams().Len() == 0 {
+ w.tag(funcTag)
+ } else {
+ w.tag(genericFuncTag)
+ }
+ w.pos(obj.Pos())
+ // The tparam list of the function type is the declaration of the type
+ // params. So, write out the type params right now. Then those type params
+ // will be referenced via their type offset (via typOff) in all other
+ // places in the signature and function where they are used.
+ //
+ // While importing the type parameters, tparamList computes and records
+ // their export name, so that it can be later used when writing the index.
+ if tparams := sig.TypeParams(); tparams.Len() > 0 {
+ w.tparamList(obj.Name(), tparams, obj.Pkg())
+ }
+ w.signature(sig)
+
+ case *types.Const:
+ w.tag(constTag)
+ w.pos(obj.Pos())
+ w.value(obj.Type(), obj.Val())
+
+ case *types.TypeName:
+ t := obj.Type()
+
+ if tparam, ok := types.Unalias(t).(*types.TypeParam); ok {
+ w.tag(typeParamTag)
+ w.pos(obj.Pos())
+ constraint := tparam.Constraint()
+ if p.version >= iexportVersionGo1_18 {
+ implicit := false
+ if iface, _ := types.Unalias(constraint).(*types.Interface); iface != nil {
+ implicit = iface.IsImplicit()
+ }
+ w.bool(implicit)
+ }
+ w.typ(constraint, obj.Pkg())
+ break
+ }
+
+ if obj.IsAlias() {
+ alias, materialized := t.(*types.Alias) // may fail when aliases are not enabled
+
+ var tparams *types.TypeParamList
+ if materialized {
+ tparams = aliases.TypeParams(alias)
+ }
+ if tparams.Len() == 0 {
+ w.tag(aliasTag)
+ } else {
+ w.tag(genericAliasTag)
+ }
+ w.pos(obj.Pos())
+ if tparams.Len() > 0 {
+ w.tparamList(obj.Name(), tparams, obj.Pkg())
+ }
+ if materialized {
+ // Preserve materialized aliases,
+ // even of non-exported types.
+ t = aliases.Rhs(alias)
+ }
+ w.typ(t, obj.Pkg())
+ break
+ }
+
+ // Defined type.
+ named, ok := t.(*types.Named)
+ if !ok {
+ panic(internalErrorf("%s is not a defined type", t))
+ }
+
+ if named.TypeParams().Len() == 0 {
+ w.tag(typeTag)
+ } else {
+ w.tag(genericTypeTag)
+ }
+ w.pos(obj.Pos())
+
+ if named.TypeParams().Len() > 0 {
+ // While importing the type parameters, tparamList computes and records
+ // their export name, so that it can be later used when writing the index.
+ w.tparamList(obj.Name(), named.TypeParams(), obj.Pkg())
+ }
+
+ underlying := named.Underlying()
+ w.typ(underlying, obj.Pkg())
+
+ if types.IsInterface(t) {
+ break
+ }
+
+ n := named.NumMethods()
+ w.uint64(uint64(n))
+ for i := range n {
+ m := named.Method(i)
+ w.pos(m.Pos())
+ w.string(m.Name())
+ sig, _ := m.Type().(*types.Signature)
+
+ // Receiver type parameters are type arguments of the receiver type, so
+ // their name must be qualified before exporting recv.
+ if rparams := sig.RecvTypeParams(); rparams.Len() > 0 {
+ prefix := obj.Name() + "." + m.Name()
+ for i := 0; i < rparams.Len(); i++ {
+ rparam := rparams.At(i)
+ name := tparamExportName(prefix, rparam)
+ w.p.tparamNames[rparam.Obj()] = name
+ }
+ }
+ w.param(sig.Recv())
+ w.signature(sig)
+ }
+
+ default:
+ panic(internalErrorf("unexpected object: %v", obj))
+ }
+
+ p.declIndex[obj] = w.flush()
+}
+
+func (w *exportWriter) tag(tag byte) {
+ w.data.WriteByte(tag)
+}
+
+func (w *exportWriter) pos(pos token.Pos) {
+ if w.p.shallow {
+ w.posV2(pos)
+ } else if w.p.version >= iexportVersionPosCol {
+ w.posV1(pos)
+ } else {
+ w.posV0(pos)
+ }
+}
+
+// posV2 encoding (used only in shallow mode) records positions as
+// (file, offset), where file is the index in the token.File table
+// (which records the file name and newline offsets) and offset is a
+// byte offset. It effectively ignores //line directives.
+func (w *exportWriter) posV2(pos token.Pos) {
+ if pos == token.NoPos {
+ w.uint64(0)
+ return
+ }
+ file := w.p.fset.File(pos) // fset must be non-nil
+ index, offset := w.p.fileIndexAndOffset(file, pos)
+ w.uint64(1 + index)
+ w.uint64(offset)
+}
+
+func (w *exportWriter) posV1(pos token.Pos) {
+ if w.p.fset == nil {
+ w.int64(0)
+ return
+ }
+
+ p := w.p.fset.Position(pos)
+ file := p.Filename
+ line := int64(p.Line)
+ column := int64(p.Column)
+
+ deltaColumn := (column - w.prevColumn) << 1
+ deltaLine := (line - w.prevLine) << 1
+
+ if file != w.prevFile {
+ deltaLine |= 1
+ }
+ if deltaLine != 0 {
+ deltaColumn |= 1
+ }
+
+ w.int64(deltaColumn)
+ if deltaColumn&1 != 0 {
+ w.int64(deltaLine)
+ if deltaLine&1 != 0 {
+ w.string(file)
+ }
+ }
+
+ w.prevFile = file
+ w.prevLine = line
+ w.prevColumn = column
+}
+
+func (w *exportWriter) posV0(pos token.Pos) {
+ if w.p.fset == nil {
+ w.int64(0)
+ return
+ }
+
+ p := w.p.fset.Position(pos)
+ file := p.Filename
+ line := int64(p.Line)
+
+ // When file is the same as the last position (common case),
+ // we can save a few bytes by delta encoding just the line
+ // number.
+ //
+ // Note: Because data objects may be read out of order (or not
+ // at all), we can only apply delta encoding within a single
+ // object. This is handled implicitly by tracking prevFile and
+ // prevLine as fields of exportWriter.
+
+ if file == w.prevFile {
+ delta := line - w.prevLine
+ w.int64(delta)
+ if delta == deltaNewFile {
+ w.int64(-1)
+ }
+ } else {
+ w.int64(deltaNewFile)
+ w.int64(line) // line >= 0
+ w.string(file)
+ w.prevFile = file
+ }
+ w.prevLine = line
+}
+
+func (w *exportWriter) pkg(pkg *types.Package) {
+ // Ensure any referenced packages are declared in the main index.
+ w.p.allPkgs[pkg] = true
+
+ w.string(w.exportPath(pkg))
+}
+
+func (w *exportWriter) qualifiedType(obj *types.TypeName) {
+ name := w.p.exportName(obj)
+
+ // Ensure any referenced declarations are written out too.
+ w.p.pushDecl(obj)
+ w.string(name)
+ w.pkg(obj.Pkg())
+}
+
+// TODO(rfindley): what does 'pkg' even mean here? It would be better to pass
+// it in explicitly into signatures and structs that may use it for
+// constructing fields.
+func (w *exportWriter) typ(t types.Type, pkg *types.Package) {
+ w.data.uint64(w.p.typOff(t, pkg))
+}
+
+func (p *iexporter) newWriter() *exportWriter {
+ return &exportWriter{p: p}
+}
+
+func (w *exportWriter) flush() uint64 {
+ off := uint64(w.p.data0.Len())
+ io.Copy(&w.p.data0, &w.data)
+ return off
+}
+
+func (p *iexporter) typOff(t types.Type, pkg *types.Package) uint64 {
+ off, ok := p.typIndex[t]
+ if !ok {
+ w := p.newWriter()
+ w.doTyp(t, pkg)
+ off = predeclReserved + w.flush()
+ p.typIndex[t] = off
+ }
+ return off
+}
+
+func (w *exportWriter) startType(k itag) {
+ w.data.uint64(uint64(k))
+}
+
+func (w *exportWriter) doTyp(t types.Type, pkg *types.Package) {
+ if trace {
+ w.p.trace("exporting type %s (%T)", t, t)
+ w.p.indent++
+ defer func() {
+ w.p.indent--
+ w.p.trace("=> %s", t)
+ }()
+ }
+ switch t := t.(type) {
+ case *types.Alias:
+ if targs := aliases.TypeArgs(t); targs.Len() > 0 {
+ w.startType(instanceType)
+ w.pos(t.Obj().Pos())
+ w.typeList(targs, pkg)
+ w.typ(aliases.Origin(t), pkg)
+ return
+ }
+ w.startType(aliasType)
+ w.qualifiedType(t.Obj())
+
+ case *types.Named:
+ if targs := t.TypeArgs(); targs.Len() > 0 {
+ w.startType(instanceType)
+ // TODO(rfindley): investigate if this position is correct, and if it
+ // matters.
+ w.pos(t.Obj().Pos())
+ w.typeList(targs, pkg)
+ w.typ(t.Origin(), pkg)
+ return
+ }
+ w.startType(definedType)
+ w.qualifiedType(t.Obj())
+
+ case *types.TypeParam:
+ w.startType(typeParamType)
+ w.qualifiedType(t.Obj())
+
+ case *types.Pointer:
+ w.startType(pointerType)
+ w.typ(t.Elem(), pkg)
+
+ case *types.Slice:
+ w.startType(sliceType)
+ w.typ(t.Elem(), pkg)
+
+ case *types.Array:
+ w.startType(arrayType)
+ w.uint64(uint64(t.Len()))
+ w.typ(t.Elem(), pkg)
+
+ case *types.Chan:
+ w.startType(chanType)
+ // 1 RecvOnly; 2 SendOnly; 3 SendRecv
+ var dir uint64
+ switch t.Dir() {
+ case types.RecvOnly:
+ dir = 1
+ case types.SendOnly:
+ dir = 2
+ case types.SendRecv:
+ dir = 3
+ }
+ w.uint64(dir)
+ w.typ(t.Elem(), pkg)
+
+ case *types.Map:
+ w.startType(mapType)
+ w.typ(t.Key(), pkg)
+ w.typ(t.Elem(), pkg)
+
+ case *types.Signature:
+ w.startType(signatureType)
+ w.pkg(pkg)
+ w.signature(t)
+
+ case *types.Struct:
+ w.startType(structType)
+ n := t.NumFields()
+ // Even for struct{} we must emit some qualifying package, because that's
+ // what the compiler does, and thus that's what the importer expects.
+ fieldPkg := pkg
+ if n > 0 {
+ fieldPkg = t.Field(0).Pkg()
+ }
+ if fieldPkg == nil {
+ // TODO(rfindley): improve this very hacky logic.
+ //
+ // The importer expects a package to be set for all struct types, even
+ // those with no fields. A better encoding might be to set NumFields
+ // before pkg. setPkg panics with a nil package, which may be possible
+ // to reach with invalid packages (and perhaps valid packages, too?), so
+ // (arbitrarily) set the localpkg if available.
+ //
+ // Alternatively, we may be able to simply guarantee that pkg != nil, by
+ // reconsidering the encoding of constant values.
+ if w.p.shallow {
+ fieldPkg = w.p.localpkg
+ } else {
+ panic(internalErrorf("no package to set for empty struct"))
+ }
+ }
+ w.pkg(fieldPkg)
+ w.uint64(uint64(n))
+
+ for i := range n {
+ f := t.Field(i)
+ if w.p.shallow {
+ w.objectPath(f)
+ }
+ w.pos(f.Pos())
+ w.string(f.Name()) // unexported fields implicitly qualified by prior setPkg
+ w.typ(f.Type(), fieldPkg)
+ w.bool(f.Anonymous())
+ w.string(t.Tag(i)) // note (or tag)
+ }
+
+ case *types.Interface:
+ w.startType(interfaceType)
+ w.pkg(pkg)
+
+ n := t.NumEmbeddeds()
+ w.uint64(uint64(n))
+ for i := 0; i < n; i++ {
+ ft := t.EmbeddedType(i)
+ tPkg := pkg
+ if named, _ := types.Unalias(ft).(*types.Named); named != nil {
+ w.pos(named.Obj().Pos())
+ } else {
+ w.pos(token.NoPos)
+ }
+ w.typ(ft, tPkg)
+ }
+
+ // See comment for struct fields. In shallow mode we change the encoding
+ // for interface methods that are promoted from other packages.
+
+ n = t.NumExplicitMethods()
+ w.uint64(uint64(n))
+ for i := 0; i < n; i++ {
+ m := t.ExplicitMethod(i)
+ if w.p.shallow {
+ w.objectPath(m)
+ }
+ w.pos(m.Pos())
+ w.string(m.Name())
+ sig, _ := m.Type().(*types.Signature)
+ w.signature(sig)
+ }
+
+ case *types.Union:
+ w.startType(unionType)
+ nt := t.Len()
+ w.uint64(uint64(nt))
+ for i := range nt {
+ term := t.Term(i)
+ w.bool(term.Tilde())
+ w.typ(term.Type(), pkg)
+ }
+
+ default:
+ panic(internalErrorf("unexpected type: %v, %v", t, reflect.TypeOf(t)))
+ }
+}
+
+// objectPath writes the package and objectPath to use to look up obj in a
+// different package, when encoding in "shallow" mode.
+//
+// When doing a shallow import, the importer creates only the local package,
+// and requests package symbols for dependencies from the client.
+// However, certain types defined in the local package may hold objects defined
+// (perhaps deeply) within another package.
+//
+// For example, consider the following:
+//
+// package a
+// func F() chan * map[string] struct { X int }
+//
+// package b
+// import "a"
+// var B = a.F()
+//
+// In this example, the type of b.B holds fields defined in package a.
+// In order to have the correct canonical objects for the field defined in the
+// type of B, they are encoded as objectPaths and later looked up in the
+// importer. The same problem applies to interface methods.
+func (w *exportWriter) objectPath(obj types.Object) {
+ if obj.Pkg() == nil || obj.Pkg() == w.p.localpkg {
+ // obj.Pkg() may be nil for the builtin error.Error.
+ // In this case, or if obj is declared in the local package, no need to
+ // encode.
+ w.string("")
+ return
+ }
+ objectPath, err := w.p.objectpathEncoder().For(obj)
+ if err != nil {
+ // Fall back to the empty string, which will cause the importer to create a
+ // new object, which matches earlier behavior. Creating a new object is
+ // sufficient for many purposes (such as type checking), but causes certain
+ // references algorithms to fail (golang/go#60819). However, we didn't
+ // notice this problem during months of gopls@v0.12.0 testing.
+ //
+ // TODO(golang/go#61674): this workaround is insufficient, as in the case
+ // where the field forwarded from an instantiated type that may not appear
+ // in the export data of the original package:
+ //
+ // // package a
+ // type A[P any] struct{ F P }
+ //
+ // // package b
+ // type B a.A[int]
+ //
+ // We need to update references algorithms not to depend on this
+ // de-duplication, at which point we may want to simply remove the
+ // workaround here.
+ w.string("")
+ return
+ }
+ w.string(string(objectPath))
+ w.pkg(obj.Pkg())
+}
+
+func (w *exportWriter) signature(sig *types.Signature) {
+ w.paramList(sig.Params())
+ w.paramList(sig.Results())
+ if sig.Params().Len() > 0 {
+ w.bool(sig.Variadic())
+ }
+}
+
+func (w *exportWriter) typeList(ts *types.TypeList, pkg *types.Package) {
+ w.uint64(uint64(ts.Len()))
+ for i := 0; i < ts.Len(); i++ {
+ w.typ(ts.At(i), pkg)
+ }
+}
+
+func (w *exportWriter) tparamList(prefix string, list *types.TypeParamList, pkg *types.Package) {
+ ll := uint64(list.Len())
+ w.uint64(ll)
+ for i := 0; i < list.Len(); i++ {
+ tparam := list.At(i)
+ // Set the type parameter exportName before exporting its type.
+ exportName := tparamExportName(prefix, tparam)
+ w.p.tparamNames[tparam.Obj()] = exportName
+ w.typ(list.At(i), pkg)
+ }
+}
+
+const blankMarker = "$"
+
+// tparamExportName returns the 'exported' name of a type parameter, which
+// differs from its actual object name: it is prefixed with a qualifier, and
+// blank type parameter names are disambiguated by their index in the type
+// parameter list.
+func tparamExportName(prefix string, tparam *types.TypeParam) string {
+ assert(prefix != "")
+ name := tparam.Obj().Name()
+ if name == "_" {
+ name = blankMarker + strconv.Itoa(tparam.Index())
+ }
+ return prefix + "." + name
+}
+
+// tparamName returns the real name of a type parameter, after stripping its
+// qualifying prefix and reverting blank-name encoding. See tparamExportName
+// for details.
+func tparamName(exportName string) string {
+ // Remove the "path" from the type param name that makes it unique.
+ ix := strings.LastIndex(exportName, ".")
+ if ix < 0 {
+ errorf("malformed type parameter export name %s: missing prefix", exportName)
+ }
+ name := exportName[ix+1:]
+ if strings.HasPrefix(name, blankMarker) {
+ return "_"
+ }
+ return name
+}
+
+func (w *exportWriter) paramList(tup *types.Tuple) {
+ n := tup.Len()
+ w.uint64(uint64(n))
+ for i := range n {
+ w.param(tup.At(i))
+ }
+}
+
+func (w *exportWriter) param(obj types.Object) {
+ w.pos(obj.Pos())
+ w.localIdent(obj)
+ w.typ(obj.Type(), obj.Pkg())
+}
+
+func (w *exportWriter) value(typ types.Type, v constant.Value) {
+ w.typ(typ, nil)
+ if w.p.version >= iexportVersionGo1_18 {
+ w.int64(int64(v.Kind()))
+ }
+
+ if v.Kind() == constant.Unknown {
+ // golang/go#60605: treat unknown constant values as if they have invalid type
+ //
+ // This loses some fidelity over the package type-checked from source, but that
+ // is acceptable.
+ //
+ // TODO(rfindley): we should switch on the recorded constant kind rather
+ // than the constant type
+ return
+ }
+
+ switch b := typ.Underlying().(*types.Basic); b.Info() & types.IsConstType {
+ case types.IsBoolean:
+ w.bool(constant.BoolVal(v))
+ case types.IsInteger:
+ var i big.Int
+ if i64, exact := constant.Int64Val(v); exact {
+ i.SetInt64(i64)
+ } else if ui64, exact := constant.Uint64Val(v); exact {
+ i.SetUint64(ui64)
+ } else {
+ i.SetString(v.ExactString(), 10)
+ }
+ w.mpint(&i, typ)
+ case types.IsFloat:
+ f := constantToFloat(v)
+ w.mpfloat(f, typ)
+ case types.IsComplex:
+ w.mpfloat(constantToFloat(constant.Real(v)), typ)
+ w.mpfloat(constantToFloat(constant.Imag(v)), typ)
+ case types.IsString:
+ w.string(constant.StringVal(v))
+ default:
+ if b.Kind() == types.Invalid {
+ // package contains type errors
+ break
+ }
+ panic(internalErrorf("unexpected type %v (%v)", typ, typ.Underlying()))
+ }
+}
+
+// constantToFloat converts a constant.Value with kind constant.Float to a
+// big.Float.
+func constantToFloat(x constant.Value) *big.Float {
+ x = constant.ToFloat(x)
+ // Use the same floating-point precision (512) as cmd/compile
+ // (see Mpprec in cmd/compile/internal/gc/mpfloat.go).
+ const mpprec = 512
+ var f big.Float
+ f.SetPrec(mpprec)
+ if v, exact := constant.Float64Val(x); exact {
+ // float64
+ f.SetFloat64(v)
+ } else if num, denom := constant.Num(x), constant.Denom(x); num.Kind() == constant.Int {
+ // TODO(gri): add big.Rat accessor to constant.Value.
+ n := valueToRat(num)
+ d := valueToRat(denom)
+ f.SetRat(n.Quo(n, d))
+ } else {
+ // Value too large to represent as a fraction => inaccessible.
+ // TODO(gri): add big.Float accessor to constant.Value.
+ _, ok := f.SetString(x.ExactString())
+ assert(ok)
+ }
+ return &f
+}
+
+func valueToRat(x constant.Value) *big.Rat {
+ // Convert little-endian to big-endian.
+ // I can't believe this is necessary.
+ bytes := constant.Bytes(x)
+ for i := 0; i < len(bytes)/2; i++ {
+ bytes[i], bytes[len(bytes)-1-i] = bytes[len(bytes)-1-i], bytes[i]
+ }
+ return new(big.Rat).SetInt(new(big.Int).SetBytes(bytes))
+}
+
+// mpint exports a multi-precision integer.
+//
+// For unsigned types, small values are written out as a single
+// byte. Larger values are written out as a length-prefixed big-endian
+// byte string, where the length prefix is encoded as its complement.
+// For example, bytes 0, 1, and 2 directly represent the integer
+// values 0, 1, and 2; while bytes 255, 254, and 253 indicate a 1-,
+// 2-, and 3-byte big-endian string follow.
+//
+// Encoding for signed types use the same general approach as for
+// unsigned types, except small values use zig-zag encoding and the
+// bottom bit of length prefix byte for large values is reserved as a
+// sign bit.
+//
+// The exact boundary between small and large encodings varies
+// according to the maximum number of bytes needed to encode a value
+// of type typ. As a special case, 8-bit types are always encoded as a
+// single byte.
+//
+// TODO(mdempsky): Is this level of complexity really worthwhile?
+func (w *exportWriter) mpint(x *big.Int, typ types.Type) {
+ basic, ok := typ.Underlying().(*types.Basic)
+ if !ok {
+ panic(internalErrorf("unexpected type %v (%T)", typ.Underlying(), typ.Underlying()))
+ }
+
+ signed, maxBytes := intSize(basic)
+
+ negative := x.Sign() < 0
+ if !signed && negative {
+ panic(internalErrorf("negative unsigned integer; type %v, value %v", typ, x))
+ }
+
+ b := x.Bytes()
+ if len(b) > 0 && b[0] == 0 {
+ panic(internalErrorf("leading zeros"))
+ }
+ if uint(len(b)) > maxBytes {
+ panic(internalErrorf("bad mpint length: %d > %d (type %v, value %v)", len(b), maxBytes, typ, x))
+ }
+
+ maxSmall := 256 - maxBytes
+ if signed {
+ maxSmall = 256 - 2*maxBytes
+ }
+ if maxBytes == 1 {
+ maxSmall = 256
+ }
+
+ // Check if x can use small value encoding.
+ if len(b) <= 1 {
+ var ux uint
+ if len(b) == 1 {
+ ux = uint(b[0])
+ }
+ if signed {
+ ux <<= 1
+ if negative {
+ ux--
+ }
+ }
+ if ux < maxSmall {
+ w.data.WriteByte(byte(ux))
+ return
+ }
+ }
+
+ n := 256 - uint(len(b))
+ if signed {
+ n = 256 - 2*uint(len(b))
+ if negative {
+ n |= 1
+ }
+ }
+ if n < maxSmall || n >= 256 {
+ panic(internalErrorf("encoding mistake: %d, %v, %v => %d", len(b), signed, negative, n))
+ }
+
+ w.data.WriteByte(byte(n))
+ w.data.Write(b)
+}
+
+// mpfloat exports a multi-precision floating point number.
+//
+// The number's value is decomposed into mantissa × 2**exponent, where
+// mantissa is an integer. The value is written out as mantissa (as a
+// multi-precision integer) and then the exponent, except exponent is
+// omitted if mantissa is zero.
+func (w *exportWriter) mpfloat(f *big.Float, typ types.Type) {
+ if f.IsInf() {
+ panic("infinite constant")
+ }
+
+ // Break into f = mant × 2**exp, with 0.5 <= mant < 1.
+ var mant big.Float
+ exp := int64(f.MantExp(&mant))
+
+ // Scale so that mant is an integer.
+ prec := mant.MinPrec()
+ mant.SetMantExp(&mant, int(prec))
+ exp -= int64(prec)
+
+ manti, acc := mant.Int(nil)
+ if acc != big.Exact {
+ panic(internalErrorf("mantissa scaling failed for %f (%s)", f, acc))
+ }
+ w.mpint(manti, typ)
+ if manti.Sign() != 0 {
+ w.int64(exp)
+ }
+}
+
+func (w *exportWriter) bool(b bool) bool {
+ var x uint64
+ if b {
+ x = 1
+ }
+ w.uint64(x)
+ return b
+}
+
+func (w *exportWriter) int64(x int64) { w.data.int64(x) }
+func (w *exportWriter) uint64(x uint64) { w.data.uint64(x) }
+func (w *exportWriter) string(s string) { w.uint64(w.p.stringOff(s)) }
+
+func (w *exportWriter) localIdent(obj types.Object) {
+ // Anonymous parameters.
+ if obj == nil {
+ w.string("")
+ return
+ }
+
+ name := obj.Name()
+ if name == "_" {
+ w.string("_")
+ return
+ }
+
+ w.string(name)
+}
+
+type intWriter struct {
+ bytes.Buffer
+}
+
+func (w *intWriter) int64(x int64) {
+ var buf [binary.MaxVarintLen64]byte
+ n := binary.PutVarint(buf[:], x)
+ w.Write(buf[:n])
+}
+
+func (w *intWriter) uint64(x uint64) {
+ var buf [binary.MaxVarintLen64]byte
+ n := binary.PutUvarint(buf[:], x)
+ w.Write(buf[:n])
+}
+
+func assert(cond bool) {
+ if !cond {
+ panic("internal error: assertion failed")
+ }
+}
+
+// The below is copied from go/src/cmd/compile/internal/gc/syntax.go.
+
+// objQueue is a FIFO queue of types.Object. The zero value of objQueue is
+// a ready-to-use empty queue.
+type objQueue struct {
+ ring []types.Object
+ head, tail int
+}
+
+// empty returns true if q contains no Nodes.
+func (q *objQueue) empty() bool {
+ return q.head == q.tail
+}
+
+// pushTail appends n to the tail of the queue.
+func (q *objQueue) pushTail(obj types.Object) {
+ if len(q.ring) == 0 {
+ q.ring = make([]types.Object, 16)
+ } else if q.head+len(q.ring) == q.tail {
+ // Grow the ring.
+ nring := make([]types.Object, len(q.ring)*2)
+ // Copy the old elements.
+ part := q.ring[q.head%len(q.ring):]
+ if q.tail-q.head <= len(part) {
+ part = part[:q.tail-q.head]
+ copy(nring, part)
+ } else {
+ pos := copy(nring, part)
+ copy(nring[pos:], q.ring[:q.tail%len(q.ring)])
+ }
+ q.ring, q.head, q.tail = nring, 0, q.tail-q.head
+ }
+
+ q.ring[q.tail%len(q.ring)] = obj
+ q.tail++
+}
+
+// popHead pops a node from the head of the queue. It panics if q is empty.
+func (q *objQueue) popHead() types.Object {
+ if q.empty() {
+ panic("dequeue empty")
+ }
+ obj := q.ring[q.head%len(q.ring)]
+ q.head++
+ return obj
+}
+
+// internalError represents an error generated inside this package.
+type internalError string
+
+func (e internalError) Error() string { return "gcimporter: " + string(e) }
+
+// TODO(adonovan): make this call panic, so that it's symmetric with errorf.
+// Otherwise it's easy to forget to do anything with the error.
+//
+// TODO(adonovan): also, consider switching the names "errorf" and
+// "internalErrorf" as the former is used for bugs, whose cause is
+// internal inconsistency, whereas the latter is used for ordinary
+// situations like bad input, whose cause is external.
+func internalErrorf(format string, args ...any) error {
+ return internalError(fmt.Sprintf(format, args...))
+}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iimport.go b/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
new file mode 100644
index 00000000..82e6c9d2
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iimport.go
@@ -0,0 +1,1120 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Indexed package import.
+// See iexport.go for the export data format.
+
+package gcimporter
+
+import (
+ "bytes"
+ "encoding/binary"
+ "fmt"
+ "go/constant"
+ "go/token"
+ "go/types"
+ "io"
+ "math/big"
+ "slices"
+ "sort"
+ "strings"
+
+ "golang.org/x/tools/go/types/objectpath"
+ "golang.org/x/tools/internal/aliases"
+ "golang.org/x/tools/internal/typesinternal"
+)
+
+type intReader struct {
+ *bytes.Reader
+ path string
+}
+
+func (r *intReader) int64() int64 {
+ i, err := binary.ReadVarint(r.Reader)
+ if err != nil {
+ errorf("import %q: read varint error: %v", r.path, err)
+ }
+ return i
+}
+
+func (r *intReader) uint64() uint64 {
+ i, err := binary.ReadUvarint(r.Reader)
+ if err != nil {
+ errorf("import %q: read varint error: %v", r.path, err)
+ }
+ return i
+}
+
+// Keep this in sync with constants in iexport.go.
+const (
+ iexportVersionGo1_11 = 0
+ iexportVersionPosCol = 1
+ iexportVersionGo1_18 = 2
+ iexportVersionGenerics = 2
+ iexportVersion = iexportVersionGenerics
+
+ iexportVersionCurrent = 2
+)
+
+type ident struct {
+ pkg *types.Package
+ name string
+}
+
+const predeclReserved = 32
+
+type itag uint64
+
+const (
+ // Types
+ definedType itag = iota
+ pointerType
+ sliceType
+ arrayType
+ chanType
+ mapType
+ signatureType
+ structType
+ interfaceType
+ typeParamType
+ instanceType
+ unionType
+ aliasType
+)
+
+// Object tags
+const (
+ varTag = 'V'
+ funcTag = 'F'
+ genericFuncTag = 'G'
+ constTag = 'C'
+ aliasTag = 'A'
+ genericAliasTag = 'B'
+ typeParamTag = 'P'
+ typeTag = 'T'
+ genericTypeTag = 'U'
+)
+
+// IImportData imports a package from the serialized package data
+// and returns 0 and a reference to the package.
+// If the export data version is not recognized or the format is otherwise
+// compromised, an error is returned.
+func IImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (int, *types.Package, error) {
+ pkgs, err := iimportCommon(fset, GetPackagesFromMap(imports), data, false, path, false, nil)
+ if err != nil {
+ return 0, nil, err
+ }
+ return 0, pkgs[0], nil
+}
+
+// IImportBundle imports a set of packages from the serialized package bundle.
+func IImportBundle(fset *token.FileSet, imports map[string]*types.Package, data []byte) ([]*types.Package, error) {
+ return iimportCommon(fset, GetPackagesFromMap(imports), data, true, "", false, nil)
+}
+
+// A GetPackagesFunc function obtains the non-nil symbols for a set of
+// packages, creating and recursively importing them as needed. An
+// implementation should store each package symbol is in the Pkg
+// field of the items array.
+//
+// Any error causes importing to fail. This can be used to quickly read
+// the import manifest of an export data file without fully decoding it.
+type GetPackagesFunc = func(items []GetPackagesItem) error
+
+// A GetPackagesItem is a request from the importer for the package
+// symbol of the specified name and path.
+type GetPackagesItem struct {
+ Name, Path string
+ Pkg *types.Package // to be filled in by GetPackagesFunc call
+
+ // private importer state
+ pathOffset uint64
+ nameIndex map[string]uint64
+}
+
+// GetPackagesFromMap returns a GetPackagesFunc that retrieves
+// packages from the given map of package path to package.
+//
+// The returned function may mutate m: each requested package that is not
+// found is created with types.NewPackage and inserted into m.
+func GetPackagesFromMap(m map[string]*types.Package) GetPackagesFunc {
+ return func(items []GetPackagesItem) error {
+ for i, item := range items {
+ pkg, ok := m[item.Path]
+ if !ok {
+ pkg = types.NewPackage(item.Path, item.Name)
+ m[item.Path] = pkg
+ }
+ items[i].Pkg = pkg
+ }
+ return nil
+ }
+}
+
+func iimportCommon(fset *token.FileSet, getPackages GetPackagesFunc, data []byte, bundle bool, path string, shallow bool, reportf ReportFunc) (pkgs []*types.Package, err error) {
+ const currentVersion = iexportVersionCurrent
+ version := int64(-1)
+ if !debug {
+ defer func() {
+ if e := recover(); e != nil {
+ if bundle {
+ err = fmt.Errorf("%v", e)
+ } else if version > currentVersion {
+ err = fmt.Errorf("cannot import %q (%v), export data is newer version - update tool", path, e)
+ } else {
+ err = fmt.Errorf("internal error while importing %q (%v); please report an issue", path, e)
+ }
+ }
+ }()
+ }
+
+ r := &intReader{bytes.NewReader(data), path}
+
+ if bundle {
+ if v := r.uint64(); v != bundleVersion {
+ errorf("unknown bundle format version %d", v)
+ }
+ }
+
+ version = int64(r.uint64())
+ switch version {
+ case iexportVersionGo1_18, iexportVersionPosCol, iexportVersionGo1_11:
+ default:
+ if version > iexportVersionGo1_18 {
+ errorf("unstable iexport format version %d, just rebuild compiler and std library", version)
+ } else {
+ errorf("unknown iexport format version %d", version)
+ }
+ }
+
+ sLen := int64(r.uint64())
+ var fLen int64
+ var fileOffset []uint64
+ if shallow {
+ // Shallow mode uses a different position encoding.
+ fLen = int64(r.uint64())
+ fileOffset = make([]uint64, r.uint64())
+ for i := range fileOffset {
+ fileOffset[i] = r.uint64()
+ }
+ }
+ dLen := int64(r.uint64())
+
+ whence, _ := r.Seek(0, io.SeekCurrent)
+ stringData := data[whence : whence+sLen]
+ fileData := data[whence+sLen : whence+sLen+fLen]
+ declData := data[whence+sLen+fLen : whence+sLen+fLen+dLen]
+ r.Seek(sLen+fLen+dLen, io.SeekCurrent)
+
+ p := iimporter{
+ version: int(version),
+ ipath: path,
+ aliases: aliases.Enabled(),
+ shallow: shallow,
+ reportf: reportf,
+
+ stringData: stringData,
+ stringCache: make(map[uint64]string),
+ fileOffset: fileOffset,
+ fileData: fileData,
+ fileCache: make([]*token.File, len(fileOffset)),
+ pkgCache: make(map[uint64]*types.Package),
+
+ declData: declData,
+ pkgIndex: make(map[*types.Package]map[string]uint64),
+ typCache: make(map[uint64]types.Type),
+ // Separate map for typeparams, keyed by their package and unique
+ // name.
+ tparamIndex: make(map[ident]types.Type),
+
+ fake: fakeFileSet{
+ fset: fset,
+ files: make(map[string]*fileInfo),
+ },
+ }
+ defer p.fake.setLines() // set lines for files in fset
+
+ for i, pt := range predeclared() {
+ p.typCache[uint64(i)] = pt
+ }
+
+ // Gather the relevant packages from the manifest.
+ items := make([]GetPackagesItem, r.uint64())
+ uniquePkgPaths := make(map[string]bool)
+ for i := range items {
+ pkgPathOff := r.uint64()
+ pkgPath := p.stringAt(pkgPathOff)
+ pkgName := p.stringAt(r.uint64())
+ _ = r.uint64() // package height; unused by go/types
+
+ if pkgPath == "" {
+ pkgPath = path
+ }
+ items[i].Name = pkgName
+ items[i].Path = pkgPath
+ items[i].pathOffset = pkgPathOff
+
+ // Read index for package.
+ nameIndex := make(map[string]uint64)
+ nSyms := r.uint64()
+ // In shallow mode, only the current package (i=0) has an index.
+ assert(!(shallow && i > 0 && nSyms != 0))
+ for ; nSyms > 0; nSyms-- {
+ name := p.stringAt(r.uint64())
+ nameIndex[name] = r.uint64()
+ }
+
+ items[i].nameIndex = nameIndex
+
+ uniquePkgPaths[pkgPath] = true
+ }
+ // Debugging #63822; hypothesis: there are duplicate PkgPaths.
+ if len(uniquePkgPaths) != len(items) {
+ reportf("found duplicate PkgPaths while reading export data manifest: %v", items)
+ }
+
+ // Request packages all at once from the client,
+ // enabling a parallel implementation.
+ if err := getPackages(items); err != nil {
+ return nil, err // don't wrap this error
+ }
+
+ // Check the results and complete the index.
+ pkgList := make([]*types.Package, len(items))
+ for i, item := range items {
+ pkg := item.Pkg
+ if pkg == nil {
+ errorf("internal error: getPackages returned nil package for %q", item.Path)
+ } else if pkg.Path() != item.Path {
+ errorf("internal error: getPackages returned wrong path %q, want %q", pkg.Path(), item.Path)
+ } else if pkg.Name() != item.Name {
+ errorf("internal error: getPackages returned wrong name %s for package %q, want %s", pkg.Name(), item.Path, item.Name)
+ }
+ p.pkgCache[item.pathOffset] = pkg
+ p.pkgIndex[pkg] = item.nameIndex
+ pkgList[i] = pkg
+ }
+
+ if bundle {
+ pkgs = make([]*types.Package, r.uint64())
+ for i := range pkgs {
+ pkg := p.pkgAt(r.uint64())
+ imps := make([]*types.Package, r.uint64())
+ for j := range imps {
+ imps[j] = p.pkgAt(r.uint64())
+ }
+ pkg.SetImports(imps)
+ pkgs[i] = pkg
+ }
+ } else {
+ if len(pkgList) == 0 {
+ errorf("no packages found for %s", path)
+ panic("unreachable")
+ }
+ pkgs = pkgList[:1]
+
+ // record all referenced packages as imports
+ list := slices.Clone(pkgList[1:])
+ sort.Sort(byPath(list))
+ pkgs[0].SetImports(list)
+ }
+
+ for _, pkg := range pkgs {
+ if pkg.Complete() {
+ continue
+ }
+
+ names := make([]string, 0, len(p.pkgIndex[pkg]))
+ for name := range p.pkgIndex[pkg] {
+ names = append(names, name)
+ }
+ sort.Strings(names)
+ for _, name := range names {
+ p.doDecl(pkg, name)
+ }
+
+ // package was imported completely and without errors
+ pkg.MarkComplete()
+ }
+
+ // SetConstraint can't be called if the constraint type is not yet complete.
+ // When type params are created in the typeParamTag case of (*importReader).obj(),
+ // the associated constraint type may not be complete due to recursion.
+ // Therefore, we defer calling SetConstraint there, and call it here instead
+ // after all types are complete.
+ for _, d := range p.later {
+ d.t.SetConstraint(d.constraint)
+ }
+
+ for _, typ := range p.interfaceList {
+ typ.Complete()
+ }
+
+ // Workaround for golang/go#61561. See the doc for instanceList for details.
+ for _, typ := range p.instanceList {
+ if iface, _ := typ.Underlying().(*types.Interface); iface != nil {
+ iface.Complete()
+ }
+ }
+
+ return pkgs, nil
+}
+
+type setConstraintArgs struct {
+ t *types.TypeParam
+ constraint types.Type
+}
+
+type iimporter struct {
+ version int
+ ipath string
+
+ aliases bool
+ shallow bool
+ reportf ReportFunc // if non-nil, used to report bugs
+
+ stringData []byte
+ stringCache map[uint64]string
+ fileOffset []uint64 // fileOffset[i] is offset in fileData for info about file encoded as i
+ fileData []byte
+ fileCache []*token.File // memoized decoding of file encoded as i
+ pkgCache map[uint64]*types.Package
+
+ declData []byte
+ pkgIndex map[*types.Package]map[string]uint64
+ typCache map[uint64]types.Type
+ tparamIndex map[ident]types.Type
+
+ fake fakeFileSet
+ interfaceList []*types.Interface
+
+ // Workaround for the go/types bug golang/go#61561: instances produced during
+ // instantiation may contain incomplete interfaces. Here we only complete the
+ // underlying type of the instance, which is the most common case but doesn't
+ // handle parameterized interface literals defined deeper in the type.
+ instanceList []types.Type // instances for later completion (see golang/go#61561)
+
+ // Arguments for calls to SetConstraint that are deferred due to recursive types
+ later []setConstraintArgs
+
+ indent int // for tracing support
+}
+
+func (p *iimporter) trace(format string, args ...any) {
+ if !trace {
+ // Call sites should also be guarded, but having this check here allows
+ // easily enabling/disabling debug trace statements.
+ return
+ }
+ fmt.Printf(strings.Repeat("..", p.indent)+format+"\n", args...)
+}
+
+func (p *iimporter) doDecl(pkg *types.Package, name string) {
+ if debug {
+ p.trace("import decl %s", name)
+ p.indent++
+ defer func() {
+ p.indent--
+ p.trace("=> %s", name)
+ }()
+ }
+ // See if we've already imported this declaration.
+ if obj := pkg.Scope().Lookup(name); obj != nil {
+ return
+ }
+
+ off, ok := p.pkgIndex[pkg][name]
+ if !ok {
+ // In deep mode, the index should be complete. In shallow
+ // mode, we should have already recursively loaded necessary
+ // dependencies so the above Lookup succeeds.
+ errorf("%v.%v not in index", pkg, name)
+ }
+
+ r := &importReader{p: p, currPkg: pkg}
+ r.declReader.Reset(p.declData[off:])
+
+ r.obj(name)
+}
+
+func (p *iimporter) stringAt(off uint64) string {
+ if s, ok := p.stringCache[off]; ok {
+ return s
+ }
+
+ slen, n := binary.Uvarint(p.stringData[off:])
+ if n <= 0 {
+ errorf("varint failed")
+ }
+ spos := off + uint64(n)
+ s := string(p.stringData[spos : spos+slen])
+ p.stringCache[off] = s
+ return s
+}
+
+func (p *iimporter) fileAt(index uint64) *token.File {
+ file := p.fileCache[index]
+ if file == nil {
+ off := p.fileOffset[index]
+ file = p.decodeFile(intReader{bytes.NewReader(p.fileData[off:]), p.ipath})
+ p.fileCache[index] = file
+ }
+ return file
+}
+
+func (p *iimporter) decodeFile(rd intReader) *token.File {
+ filename := p.stringAt(rd.uint64())
+ size := int(rd.uint64())
+ file := p.fake.fset.AddFile(filename, -1, size)
+
+ // SetLines requires a nondecreasing sequence.
+ // Because it is common for clients to derive the interval
+ // [start, start+len(name)] from a start position, and we
+ // want to ensure that the end offset is on the same line,
+ // we fill in the gaps of the sparse encoding with values
+ // that strictly increase by the largest possible amount.
+ // This allows us to avoid having to record the actual end
+ // offset of each needed line.
+
+ lines := make([]int, int(rd.uint64()))
+ var index, offset int
+ for i, n := 0, int(rd.uint64()); i < n; i++ {
+ index += int(rd.uint64())
+ offset += int(rd.uint64())
+ lines[index] = offset
+
+ // Ensure monotonicity between points.
+ for j := index - 1; j > 0 && lines[j] == 0; j-- {
+ lines[j] = lines[j+1] - 1
+ }
+ }
+
+ // Ensure monotonicity after last point.
+ for j := len(lines) - 1; j > 0 && lines[j] == 0; j-- {
+ size--
+ lines[j] = size
+ }
+
+ if !file.SetLines(lines) {
+ errorf("SetLines failed: %d", lines) // can't happen
+ }
+ return file
+}
+
+func (p *iimporter) pkgAt(off uint64) *types.Package {
+ if pkg, ok := p.pkgCache[off]; ok {
+ return pkg
+ }
+ path := p.stringAt(off)
+ errorf("missing package %q in %q", path, p.ipath)
+ return nil
+}
+
+func (p *iimporter) typAt(off uint64, base *types.Named) types.Type {
+ if t, ok := p.typCache[off]; ok && canReuse(base, t) {
+ return t
+ }
+
+ if off < predeclReserved {
+ errorf("predeclared type missing from cache: %v", off)
+ }
+
+ r := &importReader{p: p}
+ r.declReader.Reset(p.declData[off-predeclReserved:])
+ t := r.doType(base)
+
+ if canReuse(base, t) {
+ p.typCache[off] = t
+ }
+ return t
+}
+
+// canReuse reports whether the type rhs on the RHS of the declaration for def
+// may be re-used.
+//
+// Specifically, if def is non-nil and rhs is an interface type with methods, it
+// may not be re-used because we have a convention of setting the receiver type
+// for interface methods to def.
+func canReuse(def *types.Named, rhs types.Type) bool {
+ if def == nil {
+ return true
+ }
+ iface, _ := types.Unalias(rhs).(*types.Interface)
+ if iface == nil {
+ return true
+ }
+ // Don't use iface.Empty() here as iface may not be complete.
+ return iface.NumEmbeddeds() == 0 && iface.NumExplicitMethods() == 0
+}
+
+type importReader struct {
+ p *iimporter
+ declReader bytes.Reader
+ currPkg *types.Package
+ prevFile string
+ prevLine int64
+ prevColumn int64
+}
+
+// markBlack is redefined in iimport_go123.go, to work around golang/go#69912.
+//
+// If TypeNames are not marked black (in the sense of go/types cycle
+// detection), they may be mutated when dot-imported. Fix this by punching a
+// hole through the type, when compiling with Go 1.23. (The bug has been fixed
+// for 1.24, but the fix was not worth back-porting).
+var markBlack = func(name *types.TypeName) {}
+
+func (r *importReader) obj(name string) {
+ tag := r.byte()
+ pos := r.pos()
+
+ switch tag {
+ case aliasTag, genericAliasTag:
+ var tparams []*types.TypeParam
+ if tag == genericAliasTag {
+ tparams = r.tparamList()
+ }
+ typ := r.typ()
+ obj := aliases.NewAlias(r.p.aliases, pos, r.currPkg, name, typ, tparams)
+ markBlack(obj) // workaround for golang/go#69912
+ r.declare(obj)
+
+ case constTag:
+ typ, val := r.value()
+
+ r.declare(types.NewConst(pos, r.currPkg, name, typ, val))
+
+ case funcTag, genericFuncTag:
+ var tparams []*types.TypeParam
+ if tag == genericFuncTag {
+ tparams = r.tparamList()
+ }
+ sig := r.signature(nil, nil, tparams)
+ r.declare(types.NewFunc(pos, r.currPkg, name, sig))
+
+ case typeTag, genericTypeTag:
+ // Types can be recursive. We need to setup a stub
+ // declaration before recursing.
+ obj := types.NewTypeName(pos, r.currPkg, name, nil)
+ named := types.NewNamed(obj, nil, nil)
+
+ markBlack(obj) // workaround for golang/go#69912
+
+ // Declare obj before calling r.tparamList, so the new type name is recognized
+ // if used in the constraint of one of its own typeparams (see #48280).
+ r.declare(obj)
+ if tag == genericTypeTag {
+ tparams := r.tparamList()
+ named.SetTypeParams(tparams)
+ }
+
+ underlying := r.p.typAt(r.uint64(), named).Underlying()
+ named.SetUnderlying(underlying)
+
+ if !isInterface(underlying) {
+ for n := r.uint64(); n > 0; n-- {
+ mpos := r.pos()
+ mname := r.ident()
+ recv := r.param()
+
+ // If the receiver has any targs, set those as the
+ // rparams of the method (since those are the
+ // typeparams being used in the method sig/body).
+ _, recvNamed := typesinternal.ReceiverNamed(recv)
+ targs := recvNamed.TypeArgs()
+ var rparams []*types.TypeParam
+ if targs.Len() > 0 {
+ rparams = make([]*types.TypeParam, targs.Len())
+ for i := range rparams {
+ rparams[i] = types.Unalias(targs.At(i)).(*types.TypeParam)
+ }
+ }
+ msig := r.signature(recv, rparams, nil)
+
+ named.AddMethod(types.NewFunc(mpos, r.currPkg, mname, msig))
+ }
+ }
+
+ case typeParamTag:
+ // We need to "declare" a typeparam in order to have a name that
+ // can be referenced recursively (if needed) in the type param's
+ // bound.
+ if r.p.version < iexportVersionGenerics {
+ errorf("unexpected type param type")
+ }
+ name0 := tparamName(name)
+ tn := types.NewTypeName(pos, r.currPkg, name0, nil)
+ t := types.NewTypeParam(tn, nil)
+
+ // To handle recursive references to the typeparam within its
+ // bound, save the partial type in tparamIndex before reading the bounds.
+ id := ident{r.currPkg, name}
+ r.p.tparamIndex[id] = t
+ var implicit bool
+ if r.p.version >= iexportVersionGo1_18 {
+ implicit = r.bool()
+ }
+ constraint := r.typ()
+ if implicit {
+ iface, _ := types.Unalias(constraint).(*types.Interface)
+ if iface == nil {
+ errorf("non-interface constraint marked implicit")
+ }
+ iface.MarkImplicit()
+ }
+ // The constraint type may not be complete, if we
+ // are in the middle of a type recursion involving type
+ // constraints. So, we defer SetConstraint until we have
+ // completely set up all types in ImportData.
+ r.p.later = append(r.p.later, setConstraintArgs{t: t, constraint: constraint})
+
+ case varTag:
+ typ := r.typ()
+
+ v := types.NewVar(pos, r.currPkg, name, typ)
+ typesinternal.SetVarKind(v, typesinternal.PackageVar)
+ r.declare(v)
+
+ default:
+ errorf("unexpected tag: %v", tag)
+ }
+}
+
+func (r *importReader) declare(obj types.Object) {
+ obj.Pkg().Scope().Insert(obj)
+}
+
+func (r *importReader) value() (typ types.Type, val constant.Value) {
+ typ = r.typ()
+ if r.p.version >= iexportVersionGo1_18 {
+ // TODO: add support for using the kind.
+ _ = constant.Kind(r.int64())
+ }
+
+ switch b := typ.Underlying().(*types.Basic); b.Info() & types.IsConstType {
+ case types.IsBoolean:
+ val = constant.MakeBool(r.bool())
+
+ case types.IsString:
+ val = constant.MakeString(r.string())
+
+ case types.IsInteger:
+ var x big.Int
+ r.mpint(&x, b)
+ val = constant.Make(&x)
+
+ case types.IsFloat:
+ val = r.mpfloat(b)
+
+ case types.IsComplex:
+ re := r.mpfloat(b)
+ im := r.mpfloat(b)
+ val = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
+
+ default:
+ if b.Kind() == types.Invalid {
+ val = constant.MakeUnknown()
+ return
+ }
+ errorf("unexpected type %v", typ) // panics
+ panic("unreachable")
+ }
+
+ return
+}
+
+func intSize(b *types.Basic) (signed bool, maxBytes uint) {
+ if (b.Info() & types.IsUntyped) != 0 {
+ return true, 64
+ }
+
+ switch b.Kind() {
+ case types.Float32, types.Complex64:
+ return true, 3
+ case types.Float64, types.Complex128:
+ return true, 7
+ }
+
+ signed = (b.Info() & types.IsUnsigned) == 0
+ switch b.Kind() {
+ case types.Int8, types.Uint8:
+ maxBytes = 1
+ case types.Int16, types.Uint16:
+ maxBytes = 2
+ case types.Int32, types.Uint32:
+ maxBytes = 4
+ default:
+ maxBytes = 8
+ }
+
+ return
+}
+
+func (r *importReader) mpint(x *big.Int, typ *types.Basic) {
+ signed, maxBytes := intSize(typ)
+
+ maxSmall := 256 - maxBytes
+ if signed {
+ maxSmall = 256 - 2*maxBytes
+ }
+ if maxBytes == 1 {
+ maxSmall = 256
+ }
+
+ n, _ := r.declReader.ReadByte()
+ if uint(n) < maxSmall {
+ v := int64(n)
+ if signed {
+ v >>= 1
+ if n&1 != 0 {
+ v = ^v
+ }
+ }
+ x.SetInt64(v)
+ return
+ }
+
+ v := -n
+ if signed {
+ v = -(n &^ 1) >> 1
+ }
+ if v < 1 || uint(v) > maxBytes {
+ errorf("weird decoding: %v, %v => %v", n, signed, v)
+ }
+ b := make([]byte, v)
+ io.ReadFull(&r.declReader, b)
+ x.SetBytes(b)
+ if signed && n&1 != 0 {
+ x.Neg(x)
+ }
+}
+
+func (r *importReader) mpfloat(typ *types.Basic) constant.Value {
+ var mant big.Int
+ r.mpint(&mant, typ)
+ var f big.Float
+ f.SetInt(&mant)
+ if f.Sign() != 0 {
+ f.SetMantExp(&f, int(r.int64()))
+ }
+ return constant.Make(&f)
+}
+
+func (r *importReader) ident() string {
+ return r.string()
+}
+
+func (r *importReader) qualifiedIdent() (*types.Package, string) {
+ name := r.string()
+ pkg := r.pkg()
+ return pkg, name
+}
+
+func (r *importReader) pos() token.Pos {
+ if r.p.shallow {
+ // precise offsets are encoded only in shallow mode
+ return r.posv2()
+ }
+ if r.p.version >= iexportVersionPosCol {
+ r.posv1()
+ } else {
+ r.posv0()
+ }
+
+ if r.prevFile == "" && r.prevLine == 0 && r.prevColumn == 0 {
+ return token.NoPos
+ }
+ return r.p.fake.pos(r.prevFile, int(r.prevLine), int(r.prevColumn))
+}
+
+func (r *importReader) posv0() {
+ delta := r.int64()
+ if delta != deltaNewFile {
+ r.prevLine += delta
+ } else if l := r.int64(); l == -1 {
+ r.prevLine += deltaNewFile
+ } else {
+ r.prevFile = r.string()
+ r.prevLine = l
+ }
+}
+
+func (r *importReader) posv1() {
+ delta := r.int64()
+ r.prevColumn += delta >> 1
+ if delta&1 != 0 {
+ delta = r.int64()
+ r.prevLine += delta >> 1
+ if delta&1 != 0 {
+ r.prevFile = r.string()
+ }
+ }
+}
+
+func (r *importReader) posv2() token.Pos {
+ file := r.uint64()
+ if file == 0 {
+ return token.NoPos
+ }
+ tf := r.p.fileAt(file - 1)
+ return tf.Pos(int(r.uint64()))
+}
+
+func (r *importReader) typ() types.Type {
+ return r.p.typAt(r.uint64(), nil)
+}
+
+func isInterface(t types.Type) bool {
+ _, ok := types.Unalias(t).(*types.Interface)
+ return ok
+}
+
+func (r *importReader) pkg() *types.Package { return r.p.pkgAt(r.uint64()) }
+func (r *importReader) string() string { return r.p.stringAt(r.uint64()) }
+
+func (r *importReader) doType(base *types.Named) (res types.Type) {
+ k := r.kind()
+ if debug {
+ r.p.trace("importing type %d (base: %v)", k, base)
+ r.p.indent++
+ defer func() {
+ r.p.indent--
+ r.p.trace("=> %s", res)
+ }()
+ }
+ switch k {
+ default:
+ errorf("unexpected kind tag in %q: %v", r.p.ipath, k)
+ return nil
+
+ case aliasType, definedType:
+ pkg, name := r.qualifiedIdent()
+ r.p.doDecl(pkg, name)
+ return pkg.Scope().Lookup(name).(*types.TypeName).Type()
+ case pointerType:
+ return types.NewPointer(r.typ())
+ case sliceType:
+ return types.NewSlice(r.typ())
+ case arrayType:
+ n := r.uint64()
+ return types.NewArray(r.typ(), int64(n))
+ case chanType:
+ dir := chanDir(int(r.uint64()))
+ return types.NewChan(dir, r.typ())
+ case mapType:
+ return types.NewMap(r.typ(), r.typ())
+ case signatureType:
+ r.currPkg = r.pkg()
+ return r.signature(nil, nil, nil)
+
+ case structType:
+ r.currPkg = r.pkg()
+
+ fields := make([]*types.Var, r.uint64())
+ tags := make([]string, len(fields))
+ for i := range fields {
+ var field *types.Var
+ if r.p.shallow {
+ field, _ = r.objectPathObject().(*types.Var)
+ }
+
+ fpos := r.pos()
+ fname := r.ident()
+ ftyp := r.typ()
+ emb := r.bool()
+ tag := r.string()
+
+ // Either this is not a shallow import, the field is local, or the
+ // encoded objectPath failed to produce an object (a bug).
+ //
+ // Even in this last, buggy case, fall back on creating a new field. As
+ // discussed in iexport.go, this is not correct, but mostly works and is
+ // preferable to failing (for now at least).
+ if field == nil {
+ field = types.NewField(fpos, r.currPkg, fname, ftyp, emb)
+ }
+
+ fields[i] = field
+ tags[i] = tag
+ }
+ return types.NewStruct(fields, tags)
+
+ case interfaceType:
+ r.currPkg = r.pkg()
+
+ embeddeds := make([]types.Type, r.uint64())
+ for i := range embeddeds {
+ _ = r.pos()
+ embeddeds[i] = r.typ()
+ }
+
+ methods := make([]*types.Func, r.uint64())
+ for i := range methods {
+ var method *types.Func
+ if r.p.shallow {
+ method, _ = r.objectPathObject().(*types.Func)
+ }
+
+ mpos := r.pos()
+ mname := r.ident()
+
+ // TODO(mdempsky): Matches bimport.go, but I
+ // don't agree with this.
+ var recv *types.Var
+ if base != nil {
+ recv = types.NewVar(token.NoPos, r.currPkg, "", base)
+ }
+ msig := r.signature(recv, nil, nil)
+
+ if method == nil {
+ method = types.NewFunc(mpos, r.currPkg, mname, msig)
+ }
+ methods[i] = method
+ }
+
+ typ := types.NewInterfaceType(methods, embeddeds)
+ r.p.interfaceList = append(r.p.interfaceList, typ)
+ return typ
+
+ case typeParamType:
+ if r.p.version < iexportVersionGenerics {
+ errorf("unexpected type param type")
+ }
+ pkg, name := r.qualifiedIdent()
+ id := ident{pkg, name}
+ if t, ok := r.p.tparamIndex[id]; ok {
+ // We're already in the process of importing this typeparam.
+ return t
+ }
+ // Otherwise, import the definition of the typeparam now.
+ r.p.doDecl(pkg, name)
+ return r.p.tparamIndex[id]
+
+ case instanceType:
+ if r.p.version < iexportVersionGenerics {
+ errorf("unexpected instantiation type")
+ }
+ // pos does not matter for instances: they are positioned on the original
+ // type.
+ _ = r.pos()
+ len := r.uint64()
+ targs := make([]types.Type, len)
+ for i := range targs {
+ targs[i] = r.typ()
+ }
+ baseType := r.typ()
+ // The imported instantiated type doesn't include any methods, so
+ // we must always use the methods of the base (orig) type.
+ // TODO provide a non-nil *Environment
+ t, _ := types.Instantiate(nil, baseType, targs, false)
+
+ // Workaround for golang/go#61561. See the doc for instanceList for details.
+ r.p.instanceList = append(r.p.instanceList, t)
+ return t
+
+ case unionType:
+ if r.p.version < iexportVersionGenerics {
+ errorf("unexpected instantiation type")
+ }
+ terms := make([]*types.Term, r.uint64())
+ for i := range terms {
+ terms[i] = types.NewTerm(r.bool(), r.typ())
+ }
+ return types.NewUnion(terms)
+ }
+}
+
+func (r *importReader) kind() itag {
+ return itag(r.uint64())
+}
+
+// objectPathObject is the inverse of exportWriter.objectPath.
+//
+// In shallow mode, certain fields and methods may need to be looked up in an
+// imported package. See the doc for exportWriter.objectPath for a full
+// explanation.
+func (r *importReader) objectPathObject() types.Object {
+ objPath := objectpath.Path(r.string())
+ if objPath == "" {
+ return nil
+ }
+ pkg := r.pkg()
+ obj, err := objectpath.Object(pkg, objPath)
+ if err != nil {
+ if r.p.reportf != nil {
+ r.p.reportf("failed to find object for objectPath %q: %v", objPath, err)
+ }
+ }
+ return obj
+}
+
+func (r *importReader) signature(recv *types.Var, rparams []*types.TypeParam, tparams []*types.TypeParam) *types.Signature {
+ params := r.paramList()
+ results := r.paramList()
+ variadic := params.Len() > 0 && r.bool()
+ return types.NewSignatureType(recv, rparams, tparams, params, results, variadic)
+}
+
+func (r *importReader) tparamList() []*types.TypeParam {
+ n := r.uint64()
+ if n == 0 {
+ return nil
+ }
+ xs := make([]*types.TypeParam, n)
+ for i := range xs {
+ // Note: the standard library importer is tolerant of nil types here,
+ // though would panic in SetTypeParams.
+ xs[i] = types.Unalias(r.typ()).(*types.TypeParam)
+ }
+ return xs
+}
+
+func (r *importReader) paramList() *types.Tuple {
+ xs := make([]*types.Var, r.uint64())
+ for i := range xs {
+ xs[i] = r.param()
+ }
+ return types.NewTuple(xs...)
+}
+
+func (r *importReader) param() *types.Var {
+ pos := r.pos()
+ name := r.ident()
+ typ := r.typ()
+ return types.NewParam(pos, r.currPkg, name, typ)
+}
+
+func (r *importReader) bool() bool {
+ return r.uint64() != 0
+}
+
+func (r *importReader) int64() int64 {
+ n, err := binary.ReadVarint(&r.declReader)
+ if err != nil {
+ errorf("readVarint: %v", err)
+ }
+ return n
+}
+
+func (r *importReader) uint64() uint64 {
+ n, err := binary.ReadUvarint(&r.declReader)
+ if err != nil {
+ errorf("readUvarint: %v", err)
+ }
+ return n
+}
+
+func (r *importReader) byte() byte {
+ x, err := r.declReader.ReadByte()
+ if err != nil {
+ errorf("declReader.ReadByte: %v", err)
+ }
+ return x
+}
+
+type byPath []*types.Package
+
+func (a byPath) Len() int { return len(a) }
+func (a byPath) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a byPath) Less(i, j int) bool { return a[i].Path() < a[j].Path() }
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/iimport_go122.go b/vendor/golang.org/x/tools/internal/gcimporter/iimport_go122.go
new file mode 100644
index 00000000..7586bfac
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gcimporter/iimport_go122.go
@@ -0,0 +1,53 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build go1.22 && !go1.24
+
+package gcimporter
+
+import (
+ "go/token"
+ "go/types"
+ "unsafe"
+)
+
+// TODO(rfindley): delete this workaround once go1.24 is assured.
+
+func init() {
+ // Update markBlack so that it correctly sets the color
+ // of imported TypeNames.
+ //
+ // See the doc comment for markBlack for details.
+
+ type color uint32
+ const (
+ white color = iota
+ black
+ grey
+ )
+ type object struct {
+ _ *types.Scope
+ _ token.Pos
+ _ *types.Package
+ _ string
+ _ types.Type
+ _ uint32
+ color_ color
+ _ token.Pos
+ }
+ type typeName struct {
+ object
+ }
+
+ // If the size of types.TypeName changes, this will fail to compile.
+ const delta = int64(unsafe.Sizeof(typeName{})) - int64(unsafe.Sizeof(types.TypeName{}))
+ var _ [-delta * delta]int
+
+ markBlack = func(obj *types.TypeName) {
+ type uP = unsafe.Pointer
+ var ptr *typeName
+ *(*uP)(uP(&ptr)) = uP(obj)
+ ptr.color_ = black
+ }
+}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go b/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go
new file mode 100644
index 00000000..907c8557
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gcimporter/predeclared.go
@@ -0,0 +1,91 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gcimporter
+
+import (
+ "go/types"
+ "sync"
+)
+
+// predecl is a cache for the predeclared types in types.Universe.
+//
+// Cache a distinct result based on the runtime value of any.
+// The pointer value of the any type varies based on GODEBUG settings.
+var predeclMu sync.Mutex
+var predecl map[types.Type][]types.Type
+
+func predeclared() []types.Type {
+ anyt := types.Universe.Lookup("any").Type()
+
+ predeclMu.Lock()
+ defer predeclMu.Unlock()
+
+ if pre, ok := predecl[anyt]; ok {
+ return pre
+ }
+
+ if predecl == nil {
+ predecl = make(map[types.Type][]types.Type)
+ }
+
+ decls := []types.Type{ // basic types
+ types.Typ[types.Bool],
+ types.Typ[types.Int],
+ types.Typ[types.Int8],
+ types.Typ[types.Int16],
+ types.Typ[types.Int32],
+ types.Typ[types.Int64],
+ types.Typ[types.Uint],
+ types.Typ[types.Uint8],
+ types.Typ[types.Uint16],
+ types.Typ[types.Uint32],
+ types.Typ[types.Uint64],
+ types.Typ[types.Uintptr],
+ types.Typ[types.Float32],
+ types.Typ[types.Float64],
+ types.Typ[types.Complex64],
+ types.Typ[types.Complex128],
+ types.Typ[types.String],
+
+ // basic type aliases
+ types.Universe.Lookup("byte").Type(),
+ types.Universe.Lookup("rune").Type(),
+
+ // error
+ types.Universe.Lookup("error").Type(),
+
+ // untyped types
+ types.Typ[types.UntypedBool],
+ types.Typ[types.UntypedInt],
+ types.Typ[types.UntypedRune],
+ types.Typ[types.UntypedFloat],
+ types.Typ[types.UntypedComplex],
+ types.Typ[types.UntypedString],
+ types.Typ[types.UntypedNil],
+
+ // package unsafe
+ types.Typ[types.UnsafePointer],
+
+ // invalid type
+ types.Typ[types.Invalid], // only appears in packages with errors
+
+ // used internally by gc; never used by this package or in .a files
+ anyType{},
+
+ // comparable
+ types.Universe.Lookup("comparable").Type(),
+
+ // any
+ anyt,
+ }
+
+ predecl[anyt] = decls
+ return decls
+}
+
+type anyType struct{}
+
+func (t anyType) Underlying() types.Type { return t }
+func (t anyType) String() string { return "any" }
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/support.go b/vendor/golang.org/x/tools/internal/gcimporter/support.go
new file mode 100644
index 00000000..4af810dc
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gcimporter/support.go
@@ -0,0 +1,30 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gcimporter
+
+import (
+ "bufio"
+ "io"
+ "strconv"
+ "strings"
+)
+
+// Copy of $GOROOT/src/cmd/internal/archive.ReadHeader.
+func readArchiveHeader(b *bufio.Reader, name string) int {
+ // architecture-independent object file output
+ const HeaderSize = 60
+
+ var buf [HeaderSize]byte
+ if _, err := io.ReadFull(b, buf[:]); err != nil {
+ return -1
+ }
+ aname := strings.Trim(string(buf[0:16]), " ")
+ if !strings.HasPrefix(aname, name) {
+ return -1
+ }
+ asize := strings.Trim(string(buf[48:58]), " ")
+ i, _ := strconv.Atoi(asize)
+ return i
+}
diff --git a/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go b/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go
new file mode 100644
index 00000000..37b4a39e
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gcimporter/ureader_yes.go
@@ -0,0 +1,761 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Derived from go/internal/gcimporter/ureader.go
+
+package gcimporter
+
+import (
+ "fmt"
+ "go/token"
+ "go/types"
+ "sort"
+
+ "golang.org/x/tools/internal/aliases"
+ "golang.org/x/tools/internal/pkgbits"
+ "golang.org/x/tools/internal/typesinternal"
+)
+
+// A pkgReader holds the shared state for reading a unified IR package
+// description.
+type pkgReader struct {
+ pkgbits.PkgDecoder
+
+ fake fakeFileSet
+
+ ctxt *types.Context
+ imports map[string]*types.Package // previously imported packages, indexed by path
+ aliases bool // create types.Alias nodes
+
+ // lazily initialized arrays corresponding to the unified IR
+ // PosBase, Pkg, and Type sections, respectively.
+ posBases []string // position bases (i.e., file names)
+ pkgs []*types.Package
+ typs []types.Type
+
+ // laterFns holds functions that need to be invoked at the end of
+ // import reading.
+ laterFns []func()
+ // laterFors is used in case of 'type A B' to ensure that B is processed before A.
+ laterFors map[types.Type]int
+
+ // ifaces holds a list of constructed Interfaces, which need to have
+ // Complete called after importing is done.
+ ifaces []*types.Interface
+}
+
+// later adds a function to be invoked at the end of import reading.
+func (pr *pkgReader) later(fn func()) {
+ pr.laterFns = append(pr.laterFns, fn)
+}
+
+// See cmd/compile/internal/noder.derivedInfo.
+type derivedInfo struct {
+ idx pkgbits.Index
+}
+
+// See cmd/compile/internal/noder.typeInfo.
+type typeInfo struct {
+ idx pkgbits.Index
+ derived bool
+}
+
+func UImportData(fset *token.FileSet, imports map[string]*types.Package, data []byte, path string) (_ int, pkg *types.Package, err error) {
+ if !debug {
+ defer func() {
+ if x := recover(); x != nil {
+ err = fmt.Errorf("internal error in importing %q (%v); please report an issue", path, x)
+ }
+ }()
+ }
+
+ s := string(data)
+ input := pkgbits.NewPkgDecoder(path, s)
+ pkg = readUnifiedPackage(fset, nil, imports, input)
+ return
+}
+
+// laterFor adds a function to be invoked at the end of import reading, and records the type that function is finishing.
+func (pr *pkgReader) laterFor(t types.Type, fn func()) {
+ if pr.laterFors == nil {
+ pr.laterFors = make(map[types.Type]int)
+ }
+ pr.laterFors[t] = len(pr.laterFns)
+ pr.laterFns = append(pr.laterFns, fn)
+}
+
+// readUnifiedPackage reads a package description from the given
+// unified IR export data decoder.
+func readUnifiedPackage(fset *token.FileSet, ctxt *types.Context, imports map[string]*types.Package, input pkgbits.PkgDecoder) *types.Package {
+ pr := pkgReader{
+ PkgDecoder: input,
+
+ fake: fakeFileSet{
+ fset: fset,
+ files: make(map[string]*fileInfo),
+ },
+
+ ctxt: ctxt,
+ imports: imports,
+ aliases: aliases.Enabled(),
+
+ posBases: make([]string, input.NumElems(pkgbits.RelocPosBase)),
+ pkgs: make([]*types.Package, input.NumElems(pkgbits.RelocPkg)),
+ typs: make([]types.Type, input.NumElems(pkgbits.RelocType)),
+ }
+ defer pr.fake.setLines()
+
+ r := pr.newReader(pkgbits.RelocMeta, pkgbits.PublicRootIdx, pkgbits.SyncPublic)
+ pkg := r.pkg()
+ if r.Version().Has(pkgbits.HasInit) {
+ r.Bool()
+ }
+
+ for i, n := 0, r.Len(); i < n; i++ {
+ // As if r.obj(), but avoiding the Scope.Lookup call,
+ // to avoid eager loading of imports.
+ r.Sync(pkgbits.SyncObject)
+ if r.Version().Has(pkgbits.DerivedFuncInstance) {
+ assert(!r.Bool())
+ }
+ r.p.objIdx(r.Reloc(pkgbits.RelocObj))
+ assert(r.Len() == 0)
+ }
+
+ r.Sync(pkgbits.SyncEOF)
+
+ for _, fn := range pr.laterFns {
+ fn()
+ }
+
+ for _, iface := range pr.ifaces {
+ iface.Complete()
+ }
+
+ // Imports() of pkg are all of the transitive packages that were loaded.
+ var imps []*types.Package
+ for _, imp := range pr.pkgs {
+ if imp != nil && imp != pkg {
+ imps = append(imps, imp)
+ }
+ }
+ sort.Sort(byPath(imps))
+ pkg.SetImports(imps)
+
+ pkg.MarkComplete()
+ return pkg
+}
+
+// A reader holds the state for reading a single unified IR element
+// within a package.
+type reader struct {
+ pkgbits.Decoder
+
+ p *pkgReader
+
+ dict *readerDict
+}
+
+// A readerDict holds the state for type parameters that parameterize
+// the current unified IR element.
+type readerDict struct {
+ // bounds is a slice of typeInfos corresponding to the underlying
+ // bounds of the element's type parameters.
+ bounds []typeInfo
+
+ // tparams is a slice of the constructed TypeParams for the element.
+ tparams []*types.TypeParam
+
+ // derived is a slice of types derived from tparams, which may be
+ // instantiated while reading the current element.
+ derived []derivedInfo
+ derivedTypes []types.Type // lazily instantiated from derived
+}
+
+func (pr *pkgReader) newReader(k pkgbits.RelocKind, idx pkgbits.Index, marker pkgbits.SyncMarker) *reader {
+ return &reader{
+ Decoder: pr.NewDecoder(k, idx, marker),
+ p: pr,
+ }
+}
+
+func (pr *pkgReader) tempReader(k pkgbits.RelocKind, idx pkgbits.Index, marker pkgbits.SyncMarker) *reader {
+ return &reader{
+ Decoder: pr.TempDecoder(k, idx, marker),
+ p: pr,
+ }
+}
+
+func (pr *pkgReader) retireReader(r *reader) {
+ pr.RetireDecoder(&r.Decoder)
+}
+
+// @@@ Positions
+
+func (r *reader) pos() token.Pos {
+ r.Sync(pkgbits.SyncPos)
+ if !r.Bool() {
+ return token.NoPos
+ }
+
+ // TODO(mdempsky): Delta encoding.
+ posBase := r.posBase()
+ line := r.Uint()
+ col := r.Uint()
+ return r.p.fake.pos(posBase, int(line), int(col))
+}
+
+func (r *reader) posBase() string {
+ return r.p.posBaseIdx(r.Reloc(pkgbits.RelocPosBase))
+}
+
+func (pr *pkgReader) posBaseIdx(idx pkgbits.Index) string {
+ if b := pr.posBases[idx]; b != "" {
+ return b
+ }
+
+ var filename string
+ {
+ r := pr.tempReader(pkgbits.RelocPosBase, idx, pkgbits.SyncPosBase)
+
+ // Within types2, position bases have a lot more details (e.g.,
+ // keeping track of where //line directives appeared exactly).
+ //
+ // For go/types, we just track the file name.
+
+ filename = r.String()
+
+ if r.Bool() { // file base
+ // Was: "b = token.NewTrimmedFileBase(filename, true)"
+ } else { // line base
+ pos := r.pos()
+ line := r.Uint()
+ col := r.Uint()
+
+ // Was: "b = token.NewLineBase(pos, filename, true, line, col)"
+ _, _, _ = pos, line, col
+ }
+ pr.retireReader(r)
+ }
+ b := filename
+ pr.posBases[idx] = b
+ return b
+}
+
+// @@@ Packages
+
+func (r *reader) pkg() *types.Package {
+ r.Sync(pkgbits.SyncPkg)
+ return r.p.pkgIdx(r.Reloc(pkgbits.RelocPkg))
+}
+
+func (pr *pkgReader) pkgIdx(idx pkgbits.Index) *types.Package {
+ // TODO(mdempsky): Consider using some non-nil pointer to indicate
+ // the universe scope, so we don't need to keep re-reading it.
+ if pkg := pr.pkgs[idx]; pkg != nil {
+ return pkg
+ }
+
+ pkg := pr.newReader(pkgbits.RelocPkg, idx, pkgbits.SyncPkgDef).doPkg()
+ pr.pkgs[idx] = pkg
+ return pkg
+}
+
+func (r *reader) doPkg() *types.Package {
+ path := r.String()
+ switch path {
+ // cmd/compile emits path="main" for main packages because
+ // that's the linker symbol prefix it used; but we need
+ // the package's path as it would be reported by go list,
+ // hence "main" below.
+ // See test at go/packages.TestMainPackagePathInModeTypes.
+ case "", "main":
+ path = r.p.PkgPath()
+ case "builtin":
+ return nil // universe
+ case "unsafe":
+ return types.Unsafe
+ }
+
+ if pkg := r.p.imports[path]; pkg != nil {
+ return pkg
+ }
+
+ name := r.String()
+
+ pkg := types.NewPackage(path, name)
+ r.p.imports[path] = pkg
+
+ return pkg
+}
+
+// @@@ Types
+
+func (r *reader) typ() types.Type {
+ return r.p.typIdx(r.typInfo(), r.dict)
+}
+
+func (r *reader) typInfo() typeInfo {
+ r.Sync(pkgbits.SyncType)
+ if r.Bool() {
+ return typeInfo{idx: pkgbits.Index(r.Len()), derived: true}
+ }
+ return typeInfo{idx: r.Reloc(pkgbits.RelocType), derived: false}
+}
+
+func (pr *pkgReader) typIdx(info typeInfo, dict *readerDict) types.Type {
+ idx := info.idx
+ var where *types.Type
+ if info.derived {
+ where = &dict.derivedTypes[idx]
+ idx = dict.derived[idx].idx
+ } else {
+ where = &pr.typs[idx]
+ }
+
+ if typ := *where; typ != nil {
+ return typ
+ }
+
+ var typ types.Type
+ {
+ r := pr.tempReader(pkgbits.RelocType, idx, pkgbits.SyncTypeIdx)
+ r.dict = dict
+
+ typ = r.doTyp()
+ assert(typ != nil)
+ pr.retireReader(r)
+ }
+ // See comment in pkgReader.typIdx explaining how this happens.
+ if prev := *where; prev != nil {
+ return prev
+ }
+
+ *where = typ
+ return typ
+}
+
+func (r *reader) doTyp() (res types.Type) {
+ switch tag := pkgbits.CodeType(r.Code(pkgbits.SyncType)); tag {
+ default:
+ errorf("unhandled type tag: %v", tag)
+ panic("unreachable")
+
+ case pkgbits.TypeBasic:
+ return types.Typ[r.Len()]
+
+ case pkgbits.TypeNamed:
+ obj, targs := r.obj()
+ name := obj.(*types.TypeName)
+ if len(targs) != 0 {
+ t, _ := types.Instantiate(r.p.ctxt, name.Type(), targs, false)
+ return t
+ }
+ return name.Type()
+
+ case pkgbits.TypeTypeParam:
+ return r.dict.tparams[r.Len()]
+
+ case pkgbits.TypeArray:
+ len := int64(r.Uint64())
+ return types.NewArray(r.typ(), len)
+ case pkgbits.TypeChan:
+ dir := types.ChanDir(r.Len())
+ return types.NewChan(dir, r.typ())
+ case pkgbits.TypeMap:
+ return types.NewMap(r.typ(), r.typ())
+ case pkgbits.TypePointer:
+ return types.NewPointer(r.typ())
+ case pkgbits.TypeSignature:
+ return r.signature(nil, nil, nil)
+ case pkgbits.TypeSlice:
+ return types.NewSlice(r.typ())
+ case pkgbits.TypeStruct:
+ return r.structType()
+ case pkgbits.TypeInterface:
+ return r.interfaceType()
+ case pkgbits.TypeUnion:
+ return r.unionType()
+ }
+}
+
+func (r *reader) structType() *types.Struct {
+ fields := make([]*types.Var, r.Len())
+ var tags []string
+ for i := range fields {
+ pos := r.pos()
+ pkg, name := r.selector()
+ ftyp := r.typ()
+ tag := r.String()
+ embedded := r.Bool()
+
+ fields[i] = types.NewField(pos, pkg, name, ftyp, embedded)
+ if tag != "" {
+ for len(tags) < i {
+ tags = append(tags, "")
+ }
+ tags = append(tags, tag)
+ }
+ }
+ return types.NewStruct(fields, tags)
+}
+
+func (r *reader) unionType() *types.Union {
+ terms := make([]*types.Term, r.Len())
+ for i := range terms {
+ terms[i] = types.NewTerm(r.Bool(), r.typ())
+ }
+ return types.NewUnion(terms)
+}
+
+func (r *reader) interfaceType() *types.Interface {
+ methods := make([]*types.Func, r.Len())
+ embeddeds := make([]types.Type, r.Len())
+ implicit := len(methods) == 0 && len(embeddeds) == 1 && r.Bool()
+
+ for i := range methods {
+ pos := r.pos()
+ pkg, name := r.selector()
+ mtyp := r.signature(nil, nil, nil)
+ methods[i] = types.NewFunc(pos, pkg, name, mtyp)
+ }
+
+ for i := range embeddeds {
+ embeddeds[i] = r.typ()
+ }
+
+ iface := types.NewInterfaceType(methods, embeddeds)
+ if implicit {
+ iface.MarkImplicit()
+ }
+
+ // We need to call iface.Complete(), but if there are any embedded
+ // defined types, then we may not have set their underlying
+ // interface type yet. So we need to defer calling Complete until
+ // after we've called SetUnderlying everywhere.
+ //
+ // TODO(mdempsky): After CL 424876 lands, it should be safe to call
+ // iface.Complete() immediately.
+ r.p.ifaces = append(r.p.ifaces, iface)
+
+ return iface
+}
+
+func (r *reader) signature(recv *types.Var, rtparams, tparams []*types.TypeParam) *types.Signature {
+ r.Sync(pkgbits.SyncSignature)
+
+ params := r.params()
+ results := r.params()
+ variadic := r.Bool()
+
+ return types.NewSignatureType(recv, rtparams, tparams, params, results, variadic)
+}
+
+func (r *reader) params() *types.Tuple {
+ r.Sync(pkgbits.SyncParams)
+
+ params := make([]*types.Var, r.Len())
+ for i := range params {
+ params[i] = r.param()
+ }
+
+ return types.NewTuple(params...)
+}
+
+func (r *reader) param() *types.Var {
+ r.Sync(pkgbits.SyncParam)
+
+ pos := r.pos()
+ pkg, name := r.localIdent()
+ typ := r.typ()
+
+ return types.NewParam(pos, pkg, name, typ)
+}
+
+// @@@ Objects
+
+func (r *reader) obj() (types.Object, []types.Type) {
+ r.Sync(pkgbits.SyncObject)
+
+ if r.Version().Has(pkgbits.DerivedFuncInstance) {
+ assert(!r.Bool())
+ }
+
+ pkg, name := r.p.objIdx(r.Reloc(pkgbits.RelocObj))
+ obj := pkgScope(pkg).Lookup(name)
+
+ targs := make([]types.Type, r.Len())
+ for i := range targs {
+ targs[i] = r.typ()
+ }
+
+ return obj, targs
+}
+
+func (pr *pkgReader) objIdx(idx pkgbits.Index) (*types.Package, string) {
+
+ var objPkg *types.Package
+ var objName string
+ var tag pkgbits.CodeObj
+ {
+ rname := pr.tempReader(pkgbits.RelocName, idx, pkgbits.SyncObject1)
+
+ objPkg, objName = rname.qualifiedIdent()
+ assert(objName != "")
+
+ tag = pkgbits.CodeObj(rname.Code(pkgbits.SyncCodeObj))
+ pr.retireReader(rname)
+ }
+
+ if tag == pkgbits.ObjStub {
+ assert(objPkg == nil || objPkg == types.Unsafe)
+ return objPkg, objName
+ }
+
+ // Ignore local types promoted to global scope (#55110).
+ if _, suffix := splitVargenSuffix(objName); suffix != "" {
+ return objPkg, objName
+ }
+
+ if objPkg.Scope().Lookup(objName) == nil {
+ dict := pr.objDictIdx(idx)
+
+ r := pr.newReader(pkgbits.RelocObj, idx, pkgbits.SyncObject1)
+ r.dict = dict
+
+ declare := func(obj types.Object) {
+ objPkg.Scope().Insert(obj)
+ }
+
+ switch tag {
+ default:
+ panic("weird")
+
+ case pkgbits.ObjAlias:
+ pos := r.pos()
+ var tparams []*types.TypeParam
+ if r.Version().Has(pkgbits.AliasTypeParamNames) {
+ tparams = r.typeParamNames()
+ }
+ typ := r.typ()
+ declare(aliases.NewAlias(r.p.aliases, pos, objPkg, objName, typ, tparams))
+
+ case pkgbits.ObjConst:
+ pos := r.pos()
+ typ := r.typ()
+ val := r.Value()
+ declare(types.NewConst(pos, objPkg, objName, typ, val))
+
+ case pkgbits.ObjFunc:
+ pos := r.pos()
+ tparams := r.typeParamNames()
+ sig := r.signature(nil, nil, tparams)
+ declare(types.NewFunc(pos, objPkg, objName, sig))
+
+ case pkgbits.ObjType:
+ pos := r.pos()
+
+ obj := types.NewTypeName(pos, objPkg, objName, nil)
+ named := types.NewNamed(obj, nil, nil)
+ declare(obj)
+
+ named.SetTypeParams(r.typeParamNames())
+
+ setUnderlying := func(underlying types.Type) {
+ // If the underlying type is an interface, we need to
+ // duplicate its methods so we can replace the receiver
+ // parameter's type (#49906).
+ if iface, ok := types.Unalias(underlying).(*types.Interface); ok && iface.NumExplicitMethods() != 0 {
+ methods := make([]*types.Func, iface.NumExplicitMethods())
+ for i := range methods {
+ fn := iface.ExplicitMethod(i)
+ sig := fn.Type().(*types.Signature)
+
+ recv := types.NewVar(fn.Pos(), fn.Pkg(), "", named)
+ typesinternal.SetVarKind(recv, typesinternal.RecvVar)
+ methods[i] = types.NewFunc(fn.Pos(), fn.Pkg(), fn.Name(), types.NewSignatureType(recv, nil, nil, sig.Params(), sig.Results(), sig.Variadic()))
+ }
+
+ embeds := make([]types.Type, iface.NumEmbeddeds())
+ for i := range embeds {
+ embeds[i] = iface.EmbeddedType(i)
+ }
+
+ newIface := types.NewInterfaceType(methods, embeds)
+ r.p.ifaces = append(r.p.ifaces, newIface)
+ underlying = newIface
+ }
+
+ named.SetUnderlying(underlying)
+ }
+
+ // Since go.dev/cl/455279, we can assume rhs.Underlying() will
+ // always be non-nil. However, to temporarily support users of
+ // older snapshot releases, we continue to fallback to the old
+ // behavior for now.
+ //
+ // TODO(mdempsky): Remove fallback code and simplify after
+ // allowing time for snapshot users to upgrade.
+ rhs := r.typ()
+ if underlying := rhs.Underlying(); underlying != nil {
+ setUnderlying(underlying)
+ } else {
+ pk := r.p
+ pk.laterFor(named, func() {
+ // First be sure that the rhs is initialized, if it needs to be initialized.
+ delete(pk.laterFors, named) // prevent cycles
+ if i, ok := pk.laterFors[rhs]; ok {
+ f := pk.laterFns[i]
+ pk.laterFns[i] = func() {} // function is running now, so replace it with a no-op
+ f() // initialize RHS
+ }
+ setUnderlying(rhs.Underlying())
+ })
+ }
+
+ for i, n := 0, r.Len(); i < n; i++ {
+ named.AddMethod(r.method())
+ }
+
+ case pkgbits.ObjVar:
+ pos := r.pos()
+ typ := r.typ()
+ v := types.NewVar(pos, objPkg, objName, typ)
+ typesinternal.SetVarKind(v, typesinternal.PackageVar)
+ declare(v)
+ }
+ }
+
+ return objPkg, objName
+}
+
+func (pr *pkgReader) objDictIdx(idx pkgbits.Index) *readerDict {
+
+ var dict readerDict
+
+ {
+ r := pr.tempReader(pkgbits.RelocObjDict, idx, pkgbits.SyncObject1)
+ if implicits := r.Len(); implicits != 0 {
+ errorf("unexpected object with %v implicit type parameter(s)", implicits)
+ }
+
+ dict.bounds = make([]typeInfo, r.Len())
+ for i := range dict.bounds {
+ dict.bounds[i] = r.typInfo()
+ }
+
+ dict.derived = make([]derivedInfo, r.Len())
+ dict.derivedTypes = make([]types.Type, len(dict.derived))
+ for i := range dict.derived {
+ dict.derived[i] = derivedInfo{idx: r.Reloc(pkgbits.RelocType)}
+ if r.Version().Has(pkgbits.DerivedInfoNeeded) {
+ assert(!r.Bool())
+ }
+ }
+
+ pr.retireReader(r)
+ }
+ // function references follow, but reader doesn't need those
+
+ return &dict
+}
+
+func (r *reader) typeParamNames() []*types.TypeParam {
+ r.Sync(pkgbits.SyncTypeParamNames)
+
+ // Note: This code assumes it only processes objects without
+ // implement type parameters. This is currently fine, because
+ // reader is only used to read in exported declarations, which are
+ // always package scoped.
+
+ if len(r.dict.bounds) == 0 {
+ return nil
+ }
+
+ // Careful: Type parameter lists may have cycles. To allow for this,
+ // we construct the type parameter list in two passes: first we
+ // create all the TypeNames and TypeParams, then we construct and
+ // set the bound type.
+
+ r.dict.tparams = make([]*types.TypeParam, len(r.dict.bounds))
+ for i := range r.dict.bounds {
+ pos := r.pos()
+ pkg, name := r.localIdent()
+
+ tname := types.NewTypeName(pos, pkg, name, nil)
+ r.dict.tparams[i] = types.NewTypeParam(tname, nil)
+ }
+
+ typs := make([]types.Type, len(r.dict.bounds))
+ for i, bound := range r.dict.bounds {
+ typs[i] = r.p.typIdx(bound, r.dict)
+ }
+
+ // TODO(mdempsky): This is subtle, elaborate further.
+ //
+ // We have to save tparams outside of the closure, because
+ // typeParamNames() can be called multiple times with the same
+ // dictionary instance.
+ //
+ // Also, this needs to happen later to make sure SetUnderlying has
+ // been called.
+ //
+ // TODO(mdempsky): Is it safe to have a single "later" slice or do
+ // we need to have multiple passes? See comments on CL 386002 and
+ // go.dev/issue/52104.
+ tparams := r.dict.tparams
+ r.p.later(func() {
+ for i, typ := range typs {
+ tparams[i].SetConstraint(typ)
+ }
+ })
+
+ return r.dict.tparams
+}
+
+func (r *reader) method() *types.Func {
+ r.Sync(pkgbits.SyncMethod)
+ pos := r.pos()
+ pkg, name := r.selector()
+
+ rparams := r.typeParamNames()
+ sig := r.signature(r.param(), rparams, nil)
+
+ _ = r.pos() // TODO(mdempsky): Remove; this is a hacker for linker.go.
+ return types.NewFunc(pos, pkg, name, sig)
+}
+
+func (r *reader) qualifiedIdent() (*types.Package, string) { return r.ident(pkgbits.SyncSym) }
+func (r *reader) localIdent() (*types.Package, string) { return r.ident(pkgbits.SyncLocalIdent) }
+func (r *reader) selector() (*types.Package, string) { return r.ident(pkgbits.SyncSelector) }
+
+func (r *reader) ident(marker pkgbits.SyncMarker) (*types.Package, string) {
+ r.Sync(marker)
+ return r.pkg(), r.String()
+}
+
+// pkgScope returns pkg.Scope().
+// If pkg is nil, it returns types.Universe instead.
+//
+// TODO(mdempsky): Remove after x/tools can depend on Go 1.19.
+func pkgScope(pkg *types.Package) *types.Scope {
+ if pkg != nil {
+ return pkg.Scope()
+ }
+ return types.Universe
+}
+
+// See cmd/compile/internal/types.SplitVargenSuffix.
+func splitVargenSuffix(name string) (base, suffix string) {
+ i := len(name)
+ for i > 0 && name[i-1] >= '0' && name[i-1] <= '9' {
+ i--
+ }
+ const dot = "·"
+ if i >= len(dot) && name[i-len(dot):i] == dot {
+ i -= len(dot)
+ return name[:i], name[i:]
+ }
+ return name, ""
+}
diff --git a/vendor/golang.org/x/tools/internal/gocommand/invoke.go b/vendor/golang.org/x/tools/internal/gocommand/invoke.go
new file mode 100644
index 00000000..58721202
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gocommand/invoke.go
@@ -0,0 +1,567 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package gocommand is a helper for calling the go command.
+package gocommand
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "io"
+ "log"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "regexp"
+ "runtime"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "golang.org/x/tools/internal/event"
+ "golang.org/x/tools/internal/event/keys"
+ "golang.org/x/tools/internal/event/label"
+)
+
+// A Runner will run go command invocations and serialize
+// them if it sees a concurrency error.
+type Runner struct {
+ // once guards the runner initialization.
+ once sync.Once
+
+ // inFlight tracks available workers.
+ inFlight chan struct{}
+
+ // serialized guards the ability to run a go command serially,
+ // to avoid deadlocks when claiming workers.
+ serialized chan struct{}
+}
+
+const maxInFlight = 10
+
+func (runner *Runner) initialize() {
+ runner.once.Do(func() {
+ runner.inFlight = make(chan struct{}, maxInFlight)
+ runner.serialized = make(chan struct{}, 1)
+ })
+}
+
+// 1.13: go: updates to go.mod needed, but contents have changed
+// 1.14: go: updating go.mod: existing contents have changed since last read
+var modConcurrencyError = regexp.MustCompile(`go:.*go.mod.*contents have changed`)
+
+// event keys for go command invocations
+var (
+ verb = keys.NewString("verb", "go command verb")
+ directory = keys.NewString("directory", "")
+)
+
+func invLabels(inv Invocation) []label.Label {
+ return []label.Label{verb.Of(inv.Verb), directory.Of(inv.WorkingDir)}
+}
+
+// Run is a convenience wrapper around RunRaw.
+// It returns only stdout and a "friendly" error.
+func (runner *Runner) Run(ctx context.Context, inv Invocation) (*bytes.Buffer, error) {
+ ctx, done := event.Start(ctx, "gocommand.Runner.Run", invLabels(inv)...)
+ defer done()
+
+ stdout, _, friendly, _ := runner.RunRaw(ctx, inv)
+ return stdout, friendly
+}
+
+// RunPiped runs the invocation serially, always waiting for any concurrent
+// invocations to complete first.
+func (runner *Runner) RunPiped(ctx context.Context, inv Invocation, stdout, stderr io.Writer) error {
+ ctx, done := event.Start(ctx, "gocommand.Runner.RunPiped", invLabels(inv)...)
+ defer done()
+
+ _, err := runner.runPiped(ctx, inv, stdout, stderr)
+ return err
+}
+
+// RunRaw runs the invocation, serializing requests only if they fight over
+// go.mod changes.
+// Postcondition: both error results have same nilness.
+func (runner *Runner) RunRaw(ctx context.Context, inv Invocation) (*bytes.Buffer, *bytes.Buffer, error, error) {
+ ctx, done := event.Start(ctx, "gocommand.Runner.RunRaw", invLabels(inv)...)
+ defer done()
+ // Make sure the runner is always initialized.
+ runner.initialize()
+
+ // First, try to run the go command concurrently.
+ stdout, stderr, friendlyErr, err := runner.runConcurrent(ctx, inv)
+
+ // If we encounter a load concurrency error, we need to retry serially.
+ if friendlyErr != nil && modConcurrencyError.MatchString(friendlyErr.Error()) {
+ event.Error(ctx, "Load concurrency error, will retry serially", err)
+
+ // Run serially by calling runPiped.
+ stdout.Reset()
+ stderr.Reset()
+ friendlyErr, err = runner.runPiped(ctx, inv, stdout, stderr)
+ }
+
+ return stdout, stderr, friendlyErr, err
+}
+
+// Postcondition: both error results have same nilness.
+func (runner *Runner) runConcurrent(ctx context.Context, inv Invocation) (*bytes.Buffer, *bytes.Buffer, error, error) {
+ // Wait for 1 worker to become available.
+ select {
+ case <-ctx.Done():
+ return nil, nil, ctx.Err(), ctx.Err()
+ case runner.inFlight <- struct{}{}:
+ defer func() { <-runner.inFlight }()
+ }
+
+ stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
+ friendlyErr, err := inv.runWithFriendlyError(ctx, stdout, stderr)
+ return stdout, stderr, friendlyErr, err
+}
+
+// Postcondition: both error results have same nilness.
+func (runner *Runner) runPiped(ctx context.Context, inv Invocation, stdout, stderr io.Writer) (error, error) {
+ // Make sure the runner is always initialized.
+ runner.initialize()
+
+ // Acquire the serialization lock. This avoids deadlocks between two
+ // runPiped commands.
+ select {
+ case <-ctx.Done():
+ return ctx.Err(), ctx.Err()
+ case runner.serialized <- struct{}{}:
+ defer func() { <-runner.serialized }()
+ }
+
+ // Wait for all in-progress go commands to return before proceeding,
+ // to avoid load concurrency errors.
+ for range maxInFlight {
+ select {
+ case <-ctx.Done():
+ return ctx.Err(), ctx.Err()
+ case runner.inFlight <- struct{}{}:
+ // Make sure we always "return" any workers we took.
+ defer func() { <-runner.inFlight }()
+ }
+ }
+
+ return inv.runWithFriendlyError(ctx, stdout, stderr)
+}
+
+// An Invocation represents a call to the go command.
+type Invocation struct {
+ Verb string
+ Args []string
+ BuildFlags []string
+
+ // If ModFlag is set, the go command is invoked with -mod=ModFlag.
+ // TODO(rfindley): remove, in favor of Args.
+ ModFlag string
+
+ // If ModFile is set, the go command is invoked with -modfile=ModFile.
+ // TODO(rfindley): remove, in favor of Args.
+ ModFile string
+
+ // Overlay is the name of the JSON overlay file that describes
+ // unsaved editor buffers; see [WriteOverlays].
+ // If set, the go command is invoked with -overlay=Overlay.
+ // TODO(rfindley): remove, in favor of Args.
+ Overlay string
+
+ // If CleanEnv is set, the invocation will run only with the environment
+ // in Env, not starting with os.Environ.
+ CleanEnv bool
+ Env []string
+ WorkingDir string
+ Logf func(format string, args ...any)
+}
+
+// Postcondition: both error results have same nilness.
+func (i *Invocation) runWithFriendlyError(ctx context.Context, stdout, stderr io.Writer) (friendlyError error, rawError error) {
+ rawError = i.run(ctx, stdout, stderr)
+ if rawError != nil {
+ friendlyError = rawError
+ // Check for 'go' executable not being found.
+ if ee, ok := rawError.(*exec.Error); ok && ee.Err == exec.ErrNotFound {
+ friendlyError = fmt.Errorf("go command required, not found: %v", ee)
+ }
+ if ctx.Err() != nil {
+ friendlyError = ctx.Err()
+ }
+ friendlyError = fmt.Errorf("err: %v: stderr: %s", friendlyError, stderr)
+ }
+ return
+}
+
+// logf logs if i.Logf is non-nil.
+func (i *Invocation) logf(format string, args ...any) {
+ if i.Logf != nil {
+ i.Logf(format, args...)
+ }
+}
+
+func (i *Invocation) run(ctx context.Context, stdout, stderr io.Writer) error {
+ goArgs := []string{i.Verb}
+
+ appendModFile := func() {
+ if i.ModFile != "" {
+ goArgs = append(goArgs, "-modfile="+i.ModFile)
+ }
+ }
+ appendModFlag := func() {
+ if i.ModFlag != "" {
+ goArgs = append(goArgs, "-mod="+i.ModFlag)
+ }
+ }
+ appendOverlayFlag := func() {
+ if i.Overlay != "" {
+ goArgs = append(goArgs, "-overlay="+i.Overlay)
+ }
+ }
+
+ switch i.Verb {
+ case "env", "version":
+ goArgs = append(goArgs, i.Args...)
+ case "mod":
+ // mod needs the sub-verb before flags.
+ goArgs = append(goArgs, i.Args[0])
+ appendModFile()
+ goArgs = append(goArgs, i.Args[1:]...)
+ case "get":
+ goArgs = append(goArgs, i.BuildFlags...)
+ appendModFile()
+ goArgs = append(goArgs, i.Args...)
+
+ default: // notably list and build.
+ goArgs = append(goArgs, i.BuildFlags...)
+ appendModFile()
+ appendModFlag()
+ appendOverlayFlag()
+ goArgs = append(goArgs, i.Args...)
+ }
+ cmd := exec.Command("go", goArgs...)
+ cmd.Stdout = stdout
+ cmd.Stderr = stderr
+
+ // https://go.dev/issue/59541: don't wait forever copying stderr
+ // after the command has exited.
+ // After CL 484741 we copy stdout manually, so we we'll stop reading that as
+ // soon as ctx is done. However, we also don't want to wait around forever
+ // for stderr. Give a much-longer-than-reasonable delay and then assume that
+ // something has wedged in the kernel or runtime.
+ cmd.WaitDelay = 30 * time.Second
+
+ // The cwd gets resolved to the real path. On Darwin, where
+ // /tmp is a symlink, this breaks anything that expects the
+ // working directory to keep the original path, including the
+ // go command when dealing with modules.
+ //
+ // os.Getwd has a special feature where if the cwd and the PWD
+ // are the same node then it trusts the PWD, so by setting it
+ // in the env for the child process we fix up all the paths
+ // returned by the go command.
+ if !i.CleanEnv {
+ cmd.Env = os.Environ()
+ }
+ cmd.Env = append(cmd.Env, i.Env...)
+ if i.WorkingDir != "" {
+ cmd.Env = append(cmd.Env, "PWD="+i.WorkingDir)
+ cmd.Dir = i.WorkingDir
+ }
+
+ debugStr := cmdDebugStr(cmd)
+ i.logf("starting %v", debugStr)
+ start := time.Now()
+ defer func() {
+ i.logf("%s for %v", time.Since(start), debugStr)
+ }()
+
+ return runCmdContext(ctx, cmd)
+}
+
+// DebugHangingGoCommands may be set by tests to enable additional
+// instrumentation (including panics) for debugging hanging Go commands.
+//
+// See golang/go#54461 for details.
+var DebugHangingGoCommands = false
+
+// runCmdContext is like exec.CommandContext except it sends os.Interrupt
+// before os.Kill.
+func runCmdContext(ctx context.Context, cmd *exec.Cmd) (err error) {
+ // If cmd.Stdout is not an *os.File, the exec package will create a pipe and
+ // copy it to the Writer in a goroutine until the process has finished and
+ // either the pipe reaches EOF or command's WaitDelay expires.
+ //
+ // However, the output from 'go list' can be quite large, and we don't want to
+ // keep reading (and allocating buffers) if we've already decided we don't
+ // care about the output. We don't want to wait for the process to finish, and
+ // we don't wait to wait for the WaitDelay to expire either.
+ //
+ // Instead, if cmd.Stdout requires a copying goroutine we explicitly replace
+ // it with a pipe (which is an *os.File), which we can close in order to stop
+ // copying output as soon as we realize we don't care about it.
+ var stdoutW *os.File
+ if cmd.Stdout != nil {
+ if _, ok := cmd.Stdout.(*os.File); !ok {
+ var stdoutR *os.File
+ stdoutR, stdoutW, err = os.Pipe()
+ if err != nil {
+ return err
+ }
+ prevStdout := cmd.Stdout
+ cmd.Stdout = stdoutW
+
+ stdoutErr := make(chan error, 1)
+ go func() {
+ _, err := io.Copy(prevStdout, stdoutR)
+ if err != nil {
+ err = fmt.Errorf("copying stdout: %w", err)
+ }
+ stdoutErr <- err
+ }()
+ defer func() {
+ // We started a goroutine to copy a stdout pipe.
+ // Wait for it to finish, or terminate it if need be.
+ var err2 error
+ select {
+ case err2 = <-stdoutErr:
+ stdoutR.Close()
+ case <-ctx.Done():
+ stdoutR.Close()
+ // Per https://pkg.go.dev/os#File.Close, the call to stdoutR.Close
+ // should cause the Read call in io.Copy to unblock and return
+ // immediately, but we still need to receive from stdoutErr to confirm
+ // that it has happened.
+ <-stdoutErr
+ err2 = ctx.Err()
+ }
+ if err == nil {
+ err = err2
+ }
+ }()
+
+ // Per https://pkg.go.dev/os/exec#Cmd, “If Stdout and Stderr are the
+ // same writer, and have a type that can be compared with ==, at most
+ // one goroutine at a time will call Write.”
+ //
+ // Since we're starting a goroutine that writes to cmd.Stdout, we must
+ // also update cmd.Stderr so that it still holds.
+ func() {
+ defer func() { recover() }()
+ if cmd.Stderr == prevStdout {
+ cmd.Stderr = cmd.Stdout
+ }
+ }()
+ }
+ }
+
+ startTime := time.Now()
+ err = cmd.Start()
+ if stdoutW != nil {
+ // The child process has inherited the pipe file,
+ // so close the copy held in this process.
+ stdoutW.Close()
+ stdoutW = nil
+ }
+ if err != nil {
+ return err
+ }
+
+ resChan := make(chan error, 1)
+ go func() {
+ resChan <- cmd.Wait()
+ }()
+
+ // If we're interested in debugging hanging Go commands, stop waiting after a
+ // minute and panic with interesting information.
+ debug := DebugHangingGoCommands
+ if debug {
+ timer := time.NewTimer(1 * time.Minute)
+ defer timer.Stop()
+ select {
+ case err := <-resChan:
+ return err
+ case <-timer.C:
+ // HandleHangingGoCommand terminates this process.
+ // Pass off resChan in case we can collect the command error.
+ handleHangingGoCommand(startTime, cmd, resChan)
+ case <-ctx.Done():
+ }
+ } else {
+ select {
+ case err := <-resChan:
+ return err
+ case <-ctx.Done():
+ }
+ }
+
+ // Cancelled. Interrupt and see if it ends voluntarily.
+ if err := cmd.Process.Signal(os.Interrupt); err == nil {
+ // (We used to wait only 1s but this proved
+ // fragile on loaded builder machines.)
+ timer := time.NewTimer(5 * time.Second)
+ defer timer.Stop()
+ select {
+ case err := <-resChan:
+ return err
+ case <-timer.C:
+ }
+ }
+
+ // Didn't shut down in response to interrupt. Kill it hard.
+ if err := cmd.Process.Kill(); err != nil && !errors.Is(err, os.ErrProcessDone) && debug {
+ log.Printf("error killing the Go command: %v", err)
+ }
+
+ return <-resChan
+}
+
+// handleHangingGoCommand outputs debugging information to help diagnose the
+// cause of a hanging Go command, and then exits with log.Fatalf.
+func handleHangingGoCommand(start time.Time, cmd *exec.Cmd, resChan chan error) {
+ switch runtime.GOOS {
+ case "linux", "darwin", "freebsd", "netbsd", "openbsd":
+ fmt.Fprintln(os.Stderr, `DETECTED A HANGING GO COMMAND
+
+ The gopls test runner has detected a hanging go command. In order to debug
+ this, the output of ps and lsof/fstat is printed below.
+
+ See golang/go#54461 for more details.`)
+
+ fmt.Fprintln(os.Stderr, "\nps axo ppid,pid,command:")
+ fmt.Fprintln(os.Stderr, "-------------------------")
+ psCmd := exec.Command("ps", "axo", "ppid,pid,command")
+ psCmd.Stdout = os.Stderr
+ psCmd.Stderr = os.Stderr
+ if err := psCmd.Run(); err != nil {
+ log.Printf("Handling hanging Go command: running ps: %v", err)
+ }
+
+ listFiles := "lsof"
+ if runtime.GOOS == "freebsd" || runtime.GOOS == "netbsd" {
+ listFiles = "fstat"
+ }
+
+ fmt.Fprintln(os.Stderr, "\n"+listFiles+":")
+ fmt.Fprintln(os.Stderr, "-----")
+ listFilesCmd := exec.Command(listFiles)
+ listFilesCmd.Stdout = os.Stderr
+ listFilesCmd.Stderr = os.Stderr
+ if err := listFilesCmd.Run(); err != nil {
+ log.Printf("Handling hanging Go command: running %s: %v", listFiles, err)
+ }
+ // Try to extract information about the slow go process by issuing a SIGQUIT.
+ if err := cmd.Process.Signal(sigStuckProcess); err == nil {
+ select {
+ case err := <-resChan:
+ stderr := "not a bytes.Buffer"
+ if buf, _ := cmd.Stderr.(*bytes.Buffer); buf != nil {
+ stderr = buf.String()
+ }
+ log.Printf("Quit hanging go command:\n\terr:%v\n\tstderr:\n%v\n\n", err, stderr)
+ case <-time.After(5 * time.Second):
+ }
+ } else {
+ log.Printf("Sending signal %d to hanging go command: %v", sigStuckProcess, err)
+ }
+ }
+ log.Fatalf("detected hanging go command (golang/go#54461); waited %s\n\tcommand:%s\n\tpid:%d", time.Since(start), cmd, cmd.Process.Pid)
+}
+
+func cmdDebugStr(cmd *exec.Cmd) string {
+ env := make(map[string]string)
+ for _, kv := range cmd.Env {
+ split := strings.SplitN(kv, "=", 2)
+ if len(split) == 2 {
+ k, v := split[0], split[1]
+ env[k] = v
+ }
+ }
+
+ var args []string
+ for _, arg := range cmd.Args {
+ quoted := strconv.Quote(arg)
+ if quoted[1:len(quoted)-1] != arg || strings.Contains(arg, " ") {
+ args = append(args, quoted)
+ } else {
+ args = append(args, arg)
+ }
+ }
+ return fmt.Sprintf("GOROOT=%v GOPATH=%v GO111MODULE=%v GOPROXY=%v PWD=%v %v", env["GOROOT"], env["GOPATH"], env["GO111MODULE"], env["GOPROXY"], env["PWD"], strings.Join(args, " "))
+}
+
+// WriteOverlays writes each value in the overlay (see the Overlay
+// field of go/packages.Config) to a temporary file and returns the name
+// of a JSON file describing the mapping that is suitable for the "go
+// list -overlay" flag.
+//
+// On success, the caller must call the cleanup function exactly once
+// when the files are no longer needed.
+func WriteOverlays(overlay map[string][]byte) (filename string, cleanup func(), err error) {
+ // Do nothing if there are no overlays in the config.
+ if len(overlay) == 0 {
+ return "", func() {}, nil
+ }
+
+ dir, err := os.MkdirTemp("", "gocommand-*")
+ if err != nil {
+ return "", nil, err
+ }
+
+ // The caller must clean up this directory,
+ // unless this function returns an error.
+ // (The cleanup operand of each return
+ // statement below is ignored.)
+ defer func() {
+ cleanup = func() {
+ os.RemoveAll(dir)
+ }
+ if err != nil {
+ cleanup()
+ cleanup = nil
+ }
+ }()
+
+ // Write each map entry to a temporary file.
+ overlays := make(map[string]string)
+ for k, v := range overlay {
+ // Use a unique basename for each file (001-foo.go),
+ // to avoid creating nested directories.
+ base := fmt.Sprintf("%d-%s", 1+len(overlays), filepath.Base(k))
+ filename := filepath.Join(dir, base)
+ err := os.WriteFile(filename, v, 0666)
+ if err != nil {
+ return "", nil, err
+ }
+ overlays[k] = filename
+ }
+
+ // Write the JSON overlay file that maps logical file names to temp files.
+ //
+ // OverlayJSON is the format overlay files are expected to be in.
+ // The Replace map maps from overlaid paths to replacement paths:
+ // the Go command will forward all reads trying to open
+ // each overlaid path to its replacement path, or consider the overlaid
+ // path not to exist if the replacement path is empty.
+ //
+ // From golang/go#39958.
+ type OverlayJSON struct {
+ Replace map[string]string `json:"replace,omitempty"`
+ }
+ b, err := json.Marshal(OverlayJSON{Replace: overlays})
+ if err != nil {
+ return "", nil, err
+ }
+ filename = filepath.Join(dir, "overlay.json")
+ if err := os.WriteFile(filename, b, 0666); err != nil {
+ return "", nil, err
+ }
+
+ return filename, nil, nil
+}
diff --git a/vendor/golang.org/x/tools/internal/gocommand/invoke_notunix.go b/vendor/golang.org/x/tools/internal/gocommand/invoke_notunix.go
new file mode 100644
index 00000000..469c648e
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gocommand/invoke_notunix.go
@@ -0,0 +1,13 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !unix
+
+package gocommand
+
+import "os"
+
+// sigStuckProcess is the signal to send to kill a hanging subprocess.
+// On Unix we send SIGQUIT, but on non-Unix we only have os.Kill.
+var sigStuckProcess = os.Kill
diff --git a/vendor/golang.org/x/tools/internal/gocommand/invoke_unix.go b/vendor/golang.org/x/tools/internal/gocommand/invoke_unix.go
new file mode 100644
index 00000000..169d37c8
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gocommand/invoke_unix.go
@@ -0,0 +1,13 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build unix
+
+package gocommand
+
+import "syscall"
+
+// Sigstuckprocess is the signal to send to kill a hanging subprocess.
+// Send SIGQUIT to get a stack trace.
+var sigStuckProcess = syscall.SIGQUIT
diff --git a/vendor/golang.org/x/tools/internal/gocommand/vendor.go b/vendor/golang.org/x/tools/internal/gocommand/vendor.go
new file mode 100644
index 00000000..e38d1fb4
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gocommand/vendor.go
@@ -0,0 +1,163 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gocommand
+
+import (
+ "bytes"
+ "context"
+ "fmt"
+ "os"
+ "path/filepath"
+ "regexp"
+ "strings"
+ "time"
+
+ "golang.org/x/mod/semver"
+)
+
+// ModuleJSON holds information about a module.
+type ModuleJSON struct {
+ Path string // module path
+ Version string // module version
+ Versions []string // available module versions (with -versions)
+ Replace *ModuleJSON // replaced by this module
+ Time *time.Time // time version was created
+ Update *ModuleJSON // available update, if any (with -u)
+ Main bool // is this the main module?
+ Indirect bool // is this module only an indirect dependency of main module?
+ Dir string // directory holding files for this module, if any
+ GoMod string // path to go.mod file used when loading this module, if any
+ GoVersion string // go version used in module
+}
+
+var modFlagRegexp = regexp.MustCompile(`-mod[ =](\w+)`)
+
+// VendorEnabled reports whether vendoring is enabled. It takes a *Runner to execute Go commands
+// with the supplied context.Context and Invocation. The Invocation can contain pre-defined fields,
+// of which only Verb and Args are modified to run the appropriate Go command.
+// Inspired by setDefaultBuildMod in modload/init.go
+func VendorEnabled(ctx context.Context, inv Invocation, r *Runner) (bool, *ModuleJSON, error) {
+ mainMod, go114, err := getMainModuleAnd114(ctx, inv, r)
+ if err != nil {
+ return false, nil, err
+ }
+
+ // We check the GOFLAGS to see if there is anything overridden or not.
+ inv.Verb = "env"
+ inv.Args = []string{"GOFLAGS"}
+ stdout, err := r.Run(ctx, inv)
+ if err != nil {
+ return false, nil, err
+ }
+ goflags := string(bytes.TrimSpace(stdout.Bytes()))
+ matches := modFlagRegexp.FindStringSubmatch(goflags)
+ var modFlag string
+ if len(matches) != 0 {
+ modFlag = matches[1]
+ }
+ // Don't override an explicit '-mod=' argument.
+ if modFlag == "vendor" {
+ return true, mainMod, nil
+ } else if modFlag != "" {
+ return false, nil, nil
+ }
+ if mainMod == nil || !go114 {
+ return false, nil, nil
+ }
+ // Check 1.14's automatic vendor mode.
+ if fi, err := os.Stat(filepath.Join(mainMod.Dir, "vendor")); err == nil && fi.IsDir() {
+ if mainMod.GoVersion != "" && semver.Compare("v"+mainMod.GoVersion, "v1.14") >= 0 {
+ // The Go version is at least 1.14, and a vendor directory exists.
+ // Set -mod=vendor by default.
+ return true, mainMod, nil
+ }
+ }
+ return false, nil, nil
+}
+
+// getMainModuleAnd114 gets one of the main modules' information and whether the
+// go command in use is 1.14+. This is the information needed to figure out
+// if vendoring should be enabled.
+func getMainModuleAnd114(ctx context.Context, inv Invocation, r *Runner) (*ModuleJSON, bool, error) {
+ const format = `{{.Path}}
+{{.Dir}}
+{{.GoMod}}
+{{.GoVersion}}
+{{range context.ReleaseTags}}{{if eq . "go1.14"}}{{.}}{{end}}{{end}}
+`
+ inv.Verb = "list"
+ inv.Args = []string{"-m", "-f", format}
+ stdout, err := r.Run(ctx, inv)
+ if err != nil {
+ return nil, false, err
+ }
+
+ lines := strings.Split(stdout.String(), "\n")
+ if len(lines) < 5 {
+ return nil, false, fmt.Errorf("unexpected stdout: %q", stdout.String())
+ }
+ mod := &ModuleJSON{
+ Path: lines[0],
+ Dir: lines[1],
+ GoMod: lines[2],
+ GoVersion: lines[3],
+ Main: true,
+ }
+ return mod, lines[4] == "go1.14", nil
+}
+
+// WorkspaceVendorEnabled reports whether workspace vendoring is enabled. It takes a *Runner to execute Go commands
+// with the supplied context.Context and Invocation. The Invocation can contain pre-defined fields,
+// of which only Verb and Args are modified to run the appropriate Go command.
+// Inspired by setDefaultBuildMod in modload/init.go
+func WorkspaceVendorEnabled(ctx context.Context, inv Invocation, r *Runner) (bool, []*ModuleJSON, error) {
+ inv.Verb = "env"
+ inv.Args = []string{"GOWORK"}
+ stdout, err := r.Run(ctx, inv)
+ if err != nil {
+ return false, nil, err
+ }
+ goWork := string(bytes.TrimSpace(stdout.Bytes()))
+ if fi, err := os.Stat(filepath.Join(filepath.Dir(goWork), "vendor")); err == nil && fi.IsDir() {
+ mainMods, err := getWorkspaceMainModules(ctx, inv, r)
+ if err != nil {
+ return false, nil, err
+ }
+ return true, mainMods, nil
+ }
+ return false, nil, nil
+}
+
+// getWorkspaceMainModules gets the main modules' information.
+// This is the information needed to figure out if vendoring should be enabled.
+func getWorkspaceMainModules(ctx context.Context, inv Invocation, r *Runner) ([]*ModuleJSON, error) {
+ const format = `{{.Path}}
+{{.Dir}}
+{{.GoMod}}
+{{.GoVersion}}
+`
+ inv.Verb = "list"
+ inv.Args = []string{"-m", "-f", format}
+ stdout, err := r.Run(ctx, inv)
+ if err != nil {
+ return nil, err
+ }
+
+ lines := strings.Split(strings.TrimSuffix(stdout.String(), "\n"), "\n")
+ if len(lines) < 4 {
+ return nil, fmt.Errorf("unexpected stdout: %q", stdout.String())
+ }
+ mods := make([]*ModuleJSON, 0, len(lines)/4)
+ for i := 0; i < len(lines); i += 4 {
+ mods = append(mods, &ModuleJSON{
+ Path: lines[i],
+ Dir: lines[i+1],
+ GoMod: lines[i+2],
+ GoVersion: lines[i+3],
+ Main: true,
+ })
+ }
+ return mods, nil
+}
diff --git a/vendor/golang.org/x/tools/internal/gocommand/version.go b/vendor/golang.org/x/tools/internal/gocommand/version.go
new file mode 100644
index 00000000..446c5846
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/gocommand/version.go
@@ -0,0 +1,71 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gocommand
+
+import (
+ "context"
+ "fmt"
+ "regexp"
+ "strings"
+)
+
+// GoVersion reports the minor version number of the highest release
+// tag built into the go command on the PATH.
+//
+// Note that this may be higher than the version of the go tool used
+// to build this application, and thus the versions of the standard
+// go/{scanner,parser,ast,types} packages that are linked into it.
+// In that case, callers should either downgrade to the version of
+// go used to build the application, or report an error that the
+// application is too old to use the go command on the PATH.
+func GoVersion(ctx context.Context, inv Invocation, r *Runner) (int, error) {
+ inv.Verb = "list"
+ inv.Args = []string{"-e", "-f", `{{context.ReleaseTags}}`, `--`, `unsafe`}
+ inv.BuildFlags = nil // This is not a build command.
+ inv.ModFlag = ""
+ inv.ModFile = ""
+ inv.Env = append(inv.Env[:len(inv.Env):len(inv.Env)], "GO111MODULE=off")
+
+ stdoutBytes, err := r.Run(ctx, inv)
+ if err != nil {
+ return 0, err
+ }
+ stdout := stdoutBytes.String()
+ if len(stdout) < 3 {
+ return 0, fmt.Errorf("bad ReleaseTags output: %q", stdout)
+ }
+ // Split up "[go1.1 go1.15]" and return highest go1.X value.
+ tags := strings.Fields(stdout[1 : len(stdout)-2])
+ for i := len(tags) - 1; i >= 0; i-- {
+ var version int
+ if _, err := fmt.Sscanf(tags[i], "go1.%d", &version); err != nil {
+ continue
+ }
+ return version, nil
+ }
+ return 0, fmt.Errorf("no parseable ReleaseTags in %v", tags)
+}
+
+// GoVersionOutput returns the complete output of the go version command.
+func GoVersionOutput(ctx context.Context, inv Invocation, r *Runner) (string, error) {
+ inv.Verb = "version"
+ goVersion, err := r.Run(ctx, inv)
+ if err != nil {
+ return "", err
+ }
+ return goVersion.String(), nil
+}
+
+// ParseGoVersionOutput extracts the Go version string
+// from the output of the "go version" command.
+// Given an unrecognized form, it returns an empty string.
+func ParseGoVersionOutput(data string) string {
+ re := regexp.MustCompile(`^go version (go\S+|devel \S+)`)
+ m := re.FindStringSubmatch(data)
+ if len(m) != 2 {
+ return "" // unrecognized version
+ }
+ return m[1]
+}
diff --git a/vendor/golang.org/x/tools/internal/packagesinternal/packages.go b/vendor/golang.org/x/tools/internal/packagesinternal/packages.go
new file mode 100644
index 00000000..929b470b
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/packagesinternal/packages.go
@@ -0,0 +1,23 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package packagesinternal exposes internal-only fields from go/packages.
+package packagesinternal
+
+import "fmt"
+
+var GetDepsErrors = func(p any) []*PackageError { return nil }
+
+type PackageError struct {
+ ImportStack []string // shortest path from package named on command line to this one
+ Pos string // position of error (if present, file:line:col)
+ Err string // the error itself
+}
+
+func (err PackageError) String() string {
+ return fmt.Sprintf("%s: %s (import stack: %s)", err.Pos, err.Err, err.ImportStack)
+}
+
+var TypecheckCgo int
+var DepsErrors int // must be set as a LoadMode to call GetDepsErrors
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/codes.go b/vendor/golang.org/x/tools/internal/pkgbits/codes.go
new file mode 100644
index 00000000..f0cabde9
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/pkgbits/codes.go
@@ -0,0 +1,77 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package pkgbits
+
+// A Code is an enum value that can be encoded into bitstreams.
+//
+// Code types are preferable for enum types, because they allow
+// Decoder to detect desyncs.
+type Code interface {
+ // Marker returns the SyncMarker for the Code's dynamic type.
+ Marker() SyncMarker
+
+ // Value returns the Code's ordinal value.
+ Value() int
+}
+
+// A CodeVal distinguishes among go/constant.Value encodings.
+type CodeVal int
+
+func (c CodeVal) Marker() SyncMarker { return SyncVal }
+func (c CodeVal) Value() int { return int(c) }
+
+// Note: These values are public and cannot be changed without
+// updating the go/types importers.
+
+const (
+ ValBool CodeVal = iota
+ ValString
+ ValInt64
+ ValBigInt
+ ValBigRat
+ ValBigFloat
+)
+
+// A CodeType distinguishes among go/types.Type encodings.
+type CodeType int
+
+func (c CodeType) Marker() SyncMarker { return SyncType }
+func (c CodeType) Value() int { return int(c) }
+
+// Note: These values are public and cannot be changed without
+// updating the go/types importers.
+
+const (
+ TypeBasic CodeType = iota
+ TypeNamed
+ TypePointer
+ TypeSlice
+ TypeArray
+ TypeChan
+ TypeMap
+ TypeSignature
+ TypeStruct
+ TypeInterface
+ TypeUnion
+ TypeTypeParam
+)
+
+// A CodeObj distinguishes among go/types.Object encodings.
+type CodeObj int
+
+func (c CodeObj) Marker() SyncMarker { return SyncCodeObj }
+func (c CodeObj) Value() int { return int(c) }
+
+// Note: These values are public and cannot be changed without
+// updating the go/types importers.
+
+const (
+ ObjAlias CodeObj = iota
+ ObjConst
+ ObjType
+ ObjFunc
+ ObjVar
+ ObjStub
+)
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/decoder.go b/vendor/golang.org/x/tools/internal/pkgbits/decoder.go
new file mode 100644
index 00000000..c0aba26c
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/pkgbits/decoder.go
@@ -0,0 +1,519 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package pkgbits
+
+import (
+ "encoding/binary"
+ "errors"
+ "fmt"
+ "go/constant"
+ "go/token"
+ "io"
+ "math/big"
+ "os"
+ "runtime"
+ "strings"
+)
+
+// A PkgDecoder provides methods for decoding a package's Unified IR
+// export data.
+type PkgDecoder struct {
+ // version is the file format version.
+ version Version
+
+ // sync indicates whether the file uses sync markers.
+ sync bool
+
+ // pkgPath is the package path for the package to be decoded.
+ //
+ // TODO(mdempsky): Remove; unneeded since CL 391014.
+ pkgPath string
+
+ // elemData is the full data payload of the encoded package.
+ // Elements are densely and contiguously packed together.
+ //
+ // The last 8 bytes of elemData are the package fingerprint.
+ elemData string
+
+ // elemEnds stores the byte-offset end positions of element
+ // bitstreams within elemData.
+ //
+ // For example, element I's bitstream data starts at elemEnds[I-1]
+ // (or 0, if I==0) and ends at elemEnds[I].
+ //
+ // Note: elemEnds is indexed by absolute indices, not
+ // section-relative indices.
+ elemEnds []uint32
+
+ // elemEndsEnds stores the index-offset end positions of relocation
+ // sections within elemEnds.
+ //
+ // For example, section K's end positions start at elemEndsEnds[K-1]
+ // (or 0, if K==0) and end at elemEndsEnds[K].
+ elemEndsEnds [numRelocs]uint32
+
+ scratchRelocEnt []RelocEnt
+}
+
+// PkgPath returns the package path for the package
+//
+// TODO(mdempsky): Remove; unneeded since CL 391014.
+func (pr *PkgDecoder) PkgPath() string { return pr.pkgPath }
+
+// SyncMarkers reports whether pr uses sync markers.
+func (pr *PkgDecoder) SyncMarkers() bool { return pr.sync }
+
+// NewPkgDecoder returns a PkgDecoder initialized to read the Unified
+// IR export data from input. pkgPath is the package path for the
+// compilation unit that produced the export data.
+func NewPkgDecoder(pkgPath, input string) PkgDecoder {
+ pr := PkgDecoder{
+ pkgPath: pkgPath,
+ }
+
+ // TODO(mdempsky): Implement direct indexing of input string to
+ // avoid copying the position information.
+
+ r := strings.NewReader(input)
+
+ var ver uint32
+ assert(binary.Read(r, binary.LittleEndian, &ver) == nil)
+ pr.version = Version(ver)
+
+ if pr.version >= numVersions {
+ panic(fmt.Errorf("cannot decode %q, export data version %d is greater than maximum supported version %d", pkgPath, pr.version, numVersions-1))
+ }
+
+ if pr.version.Has(Flags) {
+ var flags uint32
+ assert(binary.Read(r, binary.LittleEndian, &flags) == nil)
+ pr.sync = flags&flagSyncMarkers != 0
+ }
+
+ assert(binary.Read(r, binary.LittleEndian, pr.elemEndsEnds[:]) == nil)
+
+ pr.elemEnds = make([]uint32, pr.elemEndsEnds[len(pr.elemEndsEnds)-1])
+ assert(binary.Read(r, binary.LittleEndian, pr.elemEnds[:]) == nil)
+
+ pos, err := r.Seek(0, io.SeekCurrent)
+ assert(err == nil)
+
+ pr.elemData = input[pos:]
+
+ const fingerprintSize = 8
+ assert(len(pr.elemData)-fingerprintSize == int(pr.elemEnds[len(pr.elemEnds)-1]))
+
+ return pr
+}
+
+// NumElems returns the number of elements in section k.
+func (pr *PkgDecoder) NumElems(k RelocKind) int {
+ count := int(pr.elemEndsEnds[k])
+ if k > 0 {
+ count -= int(pr.elemEndsEnds[k-1])
+ }
+ return count
+}
+
+// TotalElems returns the total number of elements across all sections.
+func (pr *PkgDecoder) TotalElems() int {
+ return len(pr.elemEnds)
+}
+
+// Fingerprint returns the package fingerprint.
+func (pr *PkgDecoder) Fingerprint() [8]byte {
+ var fp [8]byte
+ copy(fp[:], pr.elemData[len(pr.elemData)-8:])
+ return fp
+}
+
+// AbsIdx returns the absolute index for the given (section, index)
+// pair.
+func (pr *PkgDecoder) AbsIdx(k RelocKind, idx Index) int {
+ absIdx := int(idx)
+ if k > 0 {
+ absIdx += int(pr.elemEndsEnds[k-1])
+ }
+ if absIdx >= int(pr.elemEndsEnds[k]) {
+ panicf("%v:%v is out of bounds; %v", k, idx, pr.elemEndsEnds)
+ }
+ return absIdx
+}
+
+// DataIdx returns the raw element bitstream for the given (section,
+// index) pair.
+func (pr *PkgDecoder) DataIdx(k RelocKind, idx Index) string {
+ absIdx := pr.AbsIdx(k, idx)
+
+ var start uint32
+ if absIdx > 0 {
+ start = pr.elemEnds[absIdx-1]
+ }
+ end := pr.elemEnds[absIdx]
+
+ return pr.elemData[start:end]
+}
+
+// StringIdx returns the string value for the given string index.
+func (pr *PkgDecoder) StringIdx(idx Index) string {
+ return pr.DataIdx(RelocString, idx)
+}
+
+// NewDecoder returns a Decoder for the given (section, index) pair,
+// and decodes the given SyncMarker from the element bitstream.
+func (pr *PkgDecoder) NewDecoder(k RelocKind, idx Index, marker SyncMarker) Decoder {
+ r := pr.NewDecoderRaw(k, idx)
+ r.Sync(marker)
+ return r
+}
+
+// TempDecoder returns a Decoder for the given (section, index) pair,
+// and decodes the given SyncMarker from the element bitstream.
+// If possible the Decoder should be RetireDecoder'd when it is no longer
+// needed, this will avoid heap allocations.
+func (pr *PkgDecoder) TempDecoder(k RelocKind, idx Index, marker SyncMarker) Decoder {
+ r := pr.TempDecoderRaw(k, idx)
+ r.Sync(marker)
+ return r
+}
+
+func (pr *PkgDecoder) RetireDecoder(d *Decoder) {
+ pr.scratchRelocEnt = d.Relocs
+ d.Relocs = nil
+}
+
+// NewDecoderRaw returns a Decoder for the given (section, index) pair.
+//
+// Most callers should use NewDecoder instead.
+func (pr *PkgDecoder) NewDecoderRaw(k RelocKind, idx Index) Decoder {
+ r := Decoder{
+ common: pr,
+ k: k,
+ Idx: idx,
+ }
+
+ r.Data.Reset(pr.DataIdx(k, idx))
+ r.Sync(SyncRelocs)
+ r.Relocs = make([]RelocEnt, r.Len())
+ for i := range r.Relocs {
+ r.Sync(SyncReloc)
+ r.Relocs[i] = RelocEnt{RelocKind(r.Len()), Index(r.Len())}
+ }
+
+ return r
+}
+
+func (pr *PkgDecoder) TempDecoderRaw(k RelocKind, idx Index) Decoder {
+ r := Decoder{
+ common: pr,
+ k: k,
+ Idx: idx,
+ }
+
+ r.Data.Reset(pr.DataIdx(k, idx))
+ r.Sync(SyncRelocs)
+ l := r.Len()
+ if cap(pr.scratchRelocEnt) >= l {
+ r.Relocs = pr.scratchRelocEnt[:l]
+ pr.scratchRelocEnt = nil
+ } else {
+ r.Relocs = make([]RelocEnt, l)
+ }
+ for i := range r.Relocs {
+ r.Sync(SyncReloc)
+ r.Relocs[i] = RelocEnt{RelocKind(r.Len()), Index(r.Len())}
+ }
+
+ return r
+}
+
+// A Decoder provides methods for decoding an individual element's
+// bitstream data.
+type Decoder struct {
+ common *PkgDecoder
+
+ Relocs []RelocEnt
+ Data strings.Reader
+
+ k RelocKind
+ Idx Index
+}
+
+func (r *Decoder) checkErr(err error) {
+ if err != nil {
+ panicf("unexpected decoding error: %w", err)
+ }
+}
+
+func (r *Decoder) rawUvarint() uint64 {
+ x, err := readUvarint(&r.Data)
+ r.checkErr(err)
+ return x
+}
+
+// readUvarint is a type-specialized copy of encoding/binary.ReadUvarint.
+// This avoids the interface conversion and thus has better escape properties,
+// which flows up the stack.
+func readUvarint(r *strings.Reader) (uint64, error) {
+ var x uint64
+ var s uint
+ for i := range binary.MaxVarintLen64 {
+ b, err := r.ReadByte()
+ if err != nil {
+ if i > 0 && err == io.EOF {
+ err = io.ErrUnexpectedEOF
+ }
+ return x, err
+ }
+ if b < 0x80 {
+ if i == binary.MaxVarintLen64-1 && b > 1 {
+ return x, overflow
+ }
+ return x | uint64(b)<> 1)
+ if ux&1 != 0 {
+ x = ^x
+ }
+ return x
+}
+
+func (r *Decoder) rawReloc(k RelocKind, idx int) Index {
+ e := r.Relocs[idx]
+ assert(e.Kind == k)
+ return e.Idx
+}
+
+// Sync decodes a sync marker from the element bitstream and asserts
+// that it matches the expected marker.
+//
+// If r.common.sync is false, then Sync is a no-op.
+func (r *Decoder) Sync(mWant SyncMarker) {
+ if !r.common.sync {
+ return
+ }
+
+ pos, _ := r.Data.Seek(0, io.SeekCurrent)
+ mHave := SyncMarker(r.rawUvarint())
+ writerPCs := make([]int, r.rawUvarint())
+ for i := range writerPCs {
+ writerPCs[i] = int(r.rawUvarint())
+ }
+
+ if mHave == mWant {
+ return
+ }
+
+ // There's some tension here between printing:
+ //
+ // (1) full file paths that tools can recognize (e.g., so emacs
+ // hyperlinks the "file:line" text for easy navigation), or
+ //
+ // (2) short file paths that are easier for humans to read (e.g., by
+ // omitting redundant or irrelevant details, so it's easier to
+ // focus on the useful bits that remain).
+ //
+ // The current formatting favors the former, as it seems more
+ // helpful in practice. But perhaps the formatting could be improved
+ // to better address both concerns. For example, use relative file
+ // paths if they would be shorter, or rewrite file paths to contain
+ // "$GOROOT" (like objabi.AbsFile does) if tools can be taught how
+ // to reliably expand that again.
+
+ fmt.Printf("export data desync: package %q, section %v, index %v, offset %v\n", r.common.pkgPath, r.k, r.Idx, pos)
+
+ fmt.Printf("\nfound %v, written at:\n", mHave)
+ if len(writerPCs) == 0 {
+ fmt.Printf("\t[stack trace unavailable; recompile package %q with -d=syncframes]\n", r.common.pkgPath)
+ }
+ for _, pc := range writerPCs {
+ fmt.Printf("\t%s\n", r.common.StringIdx(r.rawReloc(RelocString, pc)))
+ }
+
+ fmt.Printf("\nexpected %v, reading at:\n", mWant)
+ var readerPCs [32]uintptr // TODO(mdempsky): Dynamically size?
+ n := runtime.Callers(2, readerPCs[:])
+ for _, pc := range fmtFrames(readerPCs[:n]...) {
+ fmt.Printf("\t%s\n", pc)
+ }
+
+ // We already printed a stack trace for the reader, so now we can
+ // simply exit. Printing a second one with panic or base.Fatalf
+ // would just be noise.
+ os.Exit(1)
+}
+
+// Bool decodes and returns a bool value from the element bitstream.
+func (r *Decoder) Bool() bool {
+ r.Sync(SyncBool)
+ x, err := r.Data.ReadByte()
+ r.checkErr(err)
+ assert(x < 2)
+ return x != 0
+}
+
+// Int64 decodes and returns an int64 value from the element bitstream.
+func (r *Decoder) Int64() int64 {
+ r.Sync(SyncInt64)
+ return r.rawVarint()
+}
+
+// Uint64 decodes and returns a uint64 value from the element bitstream.
+func (r *Decoder) Uint64() uint64 {
+ r.Sync(SyncUint64)
+ return r.rawUvarint()
+}
+
+// Len decodes and returns a non-negative int value from the element bitstream.
+func (r *Decoder) Len() int { x := r.Uint64(); v := int(x); assert(uint64(v) == x); return v }
+
+// Int decodes and returns an int value from the element bitstream.
+func (r *Decoder) Int() int { x := r.Int64(); v := int(x); assert(int64(v) == x); return v }
+
+// Uint decodes and returns a uint value from the element bitstream.
+func (r *Decoder) Uint() uint { x := r.Uint64(); v := uint(x); assert(uint64(v) == x); return v }
+
+// Code decodes a Code value from the element bitstream and returns
+// its ordinal value. It's the caller's responsibility to convert the
+// result to an appropriate Code type.
+//
+// TODO(mdempsky): Ideally this method would have signature "Code[T
+// Code] T" instead, but we don't allow generic methods and the
+// compiler can't depend on generics yet anyway.
+func (r *Decoder) Code(mark SyncMarker) int {
+ r.Sync(mark)
+ return r.Len()
+}
+
+// Reloc decodes a relocation of expected section k from the element
+// bitstream and returns an index to the referenced element.
+func (r *Decoder) Reloc(k RelocKind) Index {
+ r.Sync(SyncUseReloc)
+ return r.rawReloc(k, r.Len())
+}
+
+// String decodes and returns a string value from the element
+// bitstream.
+func (r *Decoder) String() string {
+ r.Sync(SyncString)
+ return r.common.StringIdx(r.Reloc(RelocString))
+}
+
+// Strings decodes and returns a variable-length slice of strings from
+// the element bitstream.
+func (r *Decoder) Strings() []string {
+ res := make([]string, r.Len())
+ for i := range res {
+ res[i] = r.String()
+ }
+ return res
+}
+
+// Value decodes and returns a constant.Value from the element
+// bitstream.
+func (r *Decoder) Value() constant.Value {
+ r.Sync(SyncValue)
+ isComplex := r.Bool()
+ val := r.scalar()
+ if isComplex {
+ val = constant.BinaryOp(val, token.ADD, constant.MakeImag(r.scalar()))
+ }
+ return val
+}
+
+func (r *Decoder) scalar() constant.Value {
+ switch tag := CodeVal(r.Code(SyncVal)); tag {
+ default:
+ panic(fmt.Errorf("unexpected scalar tag: %v", tag))
+
+ case ValBool:
+ return constant.MakeBool(r.Bool())
+ case ValString:
+ return constant.MakeString(r.String())
+ case ValInt64:
+ return constant.MakeInt64(r.Int64())
+ case ValBigInt:
+ return constant.Make(r.bigInt())
+ case ValBigRat:
+ num := r.bigInt()
+ denom := r.bigInt()
+ return constant.Make(new(big.Rat).SetFrac(num, denom))
+ case ValBigFloat:
+ return constant.Make(r.bigFloat())
+ }
+}
+
+func (r *Decoder) bigInt() *big.Int {
+ v := new(big.Int).SetBytes([]byte(r.String()))
+ if r.Bool() {
+ v.Neg(v)
+ }
+ return v
+}
+
+func (r *Decoder) bigFloat() *big.Float {
+ v := new(big.Float).SetPrec(512)
+ assert(v.UnmarshalText([]byte(r.String())) == nil)
+ return v
+}
+
+// @@@ Helpers
+
+// TODO(mdempsky): These should probably be removed. I think they're a
+// smell that the export data format is not yet quite right.
+
+// PeekPkgPath returns the package path for the specified package
+// index.
+func (pr *PkgDecoder) PeekPkgPath(idx Index) string {
+ var path string
+ {
+ r := pr.TempDecoder(RelocPkg, idx, SyncPkgDef)
+ path = r.String()
+ pr.RetireDecoder(&r)
+ }
+ if path == "" {
+ path = pr.pkgPath
+ }
+ return path
+}
+
+// PeekObj returns the package path, object name, and CodeObj for the
+// specified object index.
+func (pr *PkgDecoder) PeekObj(idx Index) (string, string, CodeObj) {
+ var ridx Index
+ var name string
+ var rcode int
+ {
+ r := pr.TempDecoder(RelocName, idx, SyncObject1)
+ r.Sync(SyncSym)
+ r.Sync(SyncPkg)
+ ridx = r.Reloc(RelocPkg)
+ name = r.String()
+ rcode = r.Code(SyncCodeObj)
+ pr.RetireDecoder(&r)
+ }
+
+ path := pr.PeekPkgPath(ridx)
+ assert(name != "")
+
+ tag := CodeObj(rcode)
+
+ return path, name, tag
+}
+
+// Version reports the version of the bitstream.
+func (w *Decoder) Version() Version { return w.common.version }
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/doc.go b/vendor/golang.org/x/tools/internal/pkgbits/doc.go
new file mode 100644
index 00000000..c8a2796b
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/pkgbits/doc.go
@@ -0,0 +1,32 @@
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package pkgbits implements low-level coding abstractions for
+// Unified IR's export data format.
+//
+// At a low-level, a package is a collection of bitstream elements.
+// Each element has a "kind" and a dense, non-negative index.
+// Elements can be randomly accessed given their kind and index.
+//
+// Individual elements are sequences of variable-length values (e.g.,
+// integers, booleans, strings, go/constant values, cross-references
+// to other elements). Package pkgbits provides APIs for encoding and
+// decoding these low-level values, but the details of mapping
+// higher-level Go constructs into elements is left to higher-level
+// abstractions.
+//
+// Elements may cross-reference each other with "relocations." For
+// example, an element representing a pointer type has a relocation
+// referring to the element type.
+//
+// Go constructs may be composed as a constellation of multiple
+// elements. For example, a declared function may have one element to
+// describe the object (e.g., its name, type, position), and a
+// separate element to describe its function body. This allows readers
+// some flexibility in efficiently seeking or re-reading data (e.g.,
+// inlining requires re-reading the function body for each inlined
+// call, without needing to re-read the object-level details).
+//
+// This is a copy of internal/pkgbits in the Go implementation.
+package pkgbits
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/encoder.go b/vendor/golang.org/x/tools/internal/pkgbits/encoder.go
new file mode 100644
index 00000000..c17a1239
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/pkgbits/encoder.go
@@ -0,0 +1,392 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package pkgbits
+
+import (
+ "bytes"
+ "crypto/md5"
+ "encoding/binary"
+ "go/constant"
+ "io"
+ "math/big"
+ "runtime"
+ "strings"
+)
+
+// A PkgEncoder provides methods for encoding a package's Unified IR
+// export data.
+type PkgEncoder struct {
+ // version of the bitstream.
+ version Version
+
+ // elems holds the bitstream for previously encoded elements.
+ elems [numRelocs][]string
+
+ // stringsIdx maps previously encoded strings to their index within
+ // the RelocString section, to allow deduplication. That is,
+ // elems[RelocString][stringsIdx[s]] == s (if present).
+ stringsIdx map[string]Index
+
+ // syncFrames is the number of frames to write at each sync
+ // marker. A negative value means sync markers are omitted.
+ syncFrames int
+}
+
+// SyncMarkers reports whether pw uses sync markers.
+func (pw *PkgEncoder) SyncMarkers() bool { return pw.syncFrames >= 0 }
+
+// NewPkgEncoder returns an initialized PkgEncoder.
+//
+// syncFrames is the number of caller frames that should be serialized
+// at Sync points. Serializing additional frames results in larger
+// export data files, but can help diagnosing desync errors in
+// higher-level Unified IR reader/writer code. If syncFrames is
+// negative, then sync markers are omitted entirely.
+func NewPkgEncoder(version Version, syncFrames int) PkgEncoder {
+ return PkgEncoder{
+ version: version,
+ stringsIdx: make(map[string]Index),
+ syncFrames: syncFrames,
+ }
+}
+
+// DumpTo writes the package's encoded data to out0 and returns the
+// package fingerprint.
+func (pw *PkgEncoder) DumpTo(out0 io.Writer) (fingerprint [8]byte) {
+ h := md5.New()
+ out := io.MultiWriter(out0, h)
+
+ writeUint32 := func(x uint32) {
+ assert(binary.Write(out, binary.LittleEndian, x) == nil)
+ }
+
+ writeUint32(uint32(pw.version))
+
+ if pw.version.Has(Flags) {
+ var flags uint32
+ if pw.SyncMarkers() {
+ flags |= flagSyncMarkers
+ }
+ writeUint32(flags)
+ }
+
+ // Write elemEndsEnds.
+ var sum uint32
+ for _, elems := range &pw.elems {
+ sum += uint32(len(elems))
+ writeUint32(sum)
+ }
+
+ // Write elemEnds.
+ sum = 0
+ for _, elems := range &pw.elems {
+ for _, elem := range elems {
+ sum += uint32(len(elem))
+ writeUint32(sum)
+ }
+ }
+
+ // Write elemData.
+ for _, elems := range &pw.elems {
+ for _, elem := range elems {
+ _, err := io.WriteString(out, elem)
+ assert(err == nil)
+ }
+ }
+
+ // Write fingerprint.
+ copy(fingerprint[:], h.Sum(nil))
+ _, err := out0.Write(fingerprint[:])
+ assert(err == nil)
+
+ return
+}
+
+// StringIdx adds a string value to the strings section, if not
+// already present, and returns its index.
+func (pw *PkgEncoder) StringIdx(s string) Index {
+ if idx, ok := pw.stringsIdx[s]; ok {
+ assert(pw.elems[RelocString][idx] == s)
+ return idx
+ }
+
+ idx := Index(len(pw.elems[RelocString]))
+ pw.elems[RelocString] = append(pw.elems[RelocString], s)
+ pw.stringsIdx[s] = idx
+ return idx
+}
+
+// NewEncoder returns an Encoder for a new element within the given
+// section, and encodes the given SyncMarker as the start of the
+// element bitstream.
+func (pw *PkgEncoder) NewEncoder(k RelocKind, marker SyncMarker) Encoder {
+ e := pw.NewEncoderRaw(k)
+ e.Sync(marker)
+ return e
+}
+
+// NewEncoderRaw returns an Encoder for a new element within the given
+// section.
+//
+// Most callers should use NewEncoder instead.
+func (pw *PkgEncoder) NewEncoderRaw(k RelocKind) Encoder {
+ idx := Index(len(pw.elems[k]))
+ pw.elems[k] = append(pw.elems[k], "") // placeholder
+
+ return Encoder{
+ p: pw,
+ k: k,
+ Idx: idx,
+ }
+}
+
+// An Encoder provides methods for encoding an individual element's
+// bitstream data.
+type Encoder struct {
+ p *PkgEncoder
+
+ Relocs []RelocEnt
+ RelocMap map[RelocEnt]uint32
+ Data bytes.Buffer // accumulated element bitstream data
+
+ encodingRelocHeader bool
+
+ k RelocKind
+ Idx Index // index within relocation section
+}
+
+// Flush finalizes the element's bitstream and returns its Index.
+func (w *Encoder) Flush() Index {
+ var sb strings.Builder
+
+ // Backup the data so we write the relocations at the front.
+ var tmp bytes.Buffer
+ io.Copy(&tmp, &w.Data)
+
+ // TODO(mdempsky): Consider writing these out separately so they're
+ // easier to strip, along with function bodies, so that we can prune
+ // down to just the data that's relevant to go/types.
+ if w.encodingRelocHeader {
+ panic("encodingRelocHeader already true; recursive flush?")
+ }
+ w.encodingRelocHeader = true
+ w.Sync(SyncRelocs)
+ w.Len(len(w.Relocs))
+ for _, rEnt := range w.Relocs {
+ w.Sync(SyncReloc)
+ w.Len(int(rEnt.Kind))
+ w.Len(int(rEnt.Idx))
+ }
+
+ io.Copy(&sb, &w.Data)
+ io.Copy(&sb, &tmp)
+ w.p.elems[w.k][w.Idx] = sb.String()
+
+ return w.Idx
+}
+
+func (w *Encoder) checkErr(err error) {
+ if err != nil {
+ panicf("unexpected encoding error: %v", err)
+ }
+}
+
+func (w *Encoder) rawUvarint(x uint64) {
+ var buf [binary.MaxVarintLen64]byte
+ n := binary.PutUvarint(buf[:], x)
+ _, err := w.Data.Write(buf[:n])
+ w.checkErr(err)
+}
+
+func (w *Encoder) rawVarint(x int64) {
+ // Zig-zag encode.
+ ux := uint64(x) << 1
+ if x < 0 {
+ ux = ^ux
+ }
+
+ w.rawUvarint(ux)
+}
+
+func (w *Encoder) rawReloc(r RelocKind, idx Index) int {
+ e := RelocEnt{r, idx}
+ if w.RelocMap != nil {
+ if i, ok := w.RelocMap[e]; ok {
+ return int(i)
+ }
+ } else {
+ w.RelocMap = make(map[RelocEnt]uint32)
+ }
+
+ i := len(w.Relocs)
+ w.RelocMap[e] = uint32(i)
+ w.Relocs = append(w.Relocs, e)
+ return i
+}
+
+func (w *Encoder) Sync(m SyncMarker) {
+ if !w.p.SyncMarkers() {
+ return
+ }
+
+ // Writing out stack frame string references requires working
+ // relocations, but writing out the relocations themselves involves
+ // sync markers. To prevent infinite recursion, we simply trim the
+ // stack frame for sync markers within the relocation header.
+ var frames []string
+ if !w.encodingRelocHeader && w.p.syncFrames > 0 {
+ pcs := make([]uintptr, w.p.syncFrames)
+ n := runtime.Callers(2, pcs)
+ frames = fmtFrames(pcs[:n]...)
+ }
+
+ // TODO(mdempsky): Save space by writing out stack frames as a
+ // linked list so we can share common stack frames.
+ w.rawUvarint(uint64(m))
+ w.rawUvarint(uint64(len(frames)))
+ for _, frame := range frames {
+ w.rawUvarint(uint64(w.rawReloc(RelocString, w.p.StringIdx(frame))))
+ }
+}
+
+// Bool encodes and writes a bool value into the element bitstream,
+// and then returns the bool value.
+//
+// For simple, 2-alternative encodings, the idiomatic way to call Bool
+// is something like:
+//
+// if w.Bool(x != 0) {
+// // alternative #1
+// } else {
+// // alternative #2
+// }
+//
+// For multi-alternative encodings, use Code instead.
+func (w *Encoder) Bool(b bool) bool {
+ w.Sync(SyncBool)
+ var x byte
+ if b {
+ x = 1
+ }
+ err := w.Data.WriteByte(x)
+ w.checkErr(err)
+ return b
+}
+
+// Int64 encodes and writes an int64 value into the element bitstream.
+func (w *Encoder) Int64(x int64) {
+ w.Sync(SyncInt64)
+ w.rawVarint(x)
+}
+
+// Uint64 encodes and writes a uint64 value into the element bitstream.
+func (w *Encoder) Uint64(x uint64) {
+ w.Sync(SyncUint64)
+ w.rawUvarint(x)
+}
+
+// Len encodes and writes a non-negative int value into the element bitstream.
+func (w *Encoder) Len(x int) { assert(x >= 0); w.Uint64(uint64(x)) }
+
+// Int encodes and writes an int value into the element bitstream.
+func (w *Encoder) Int(x int) { w.Int64(int64(x)) }
+
+// Uint encodes and writes a uint value into the element bitstream.
+func (w *Encoder) Uint(x uint) { w.Uint64(uint64(x)) }
+
+// Reloc encodes and writes a relocation for the given (section,
+// index) pair into the element bitstream.
+//
+// Note: Only the index is formally written into the element
+// bitstream, so bitstream decoders must know from context which
+// section an encoded relocation refers to.
+func (w *Encoder) Reloc(r RelocKind, idx Index) {
+ w.Sync(SyncUseReloc)
+ w.Len(w.rawReloc(r, idx))
+}
+
+// Code encodes and writes a Code value into the element bitstream.
+func (w *Encoder) Code(c Code) {
+ w.Sync(c.Marker())
+ w.Len(c.Value())
+}
+
+// String encodes and writes a string value into the element
+// bitstream.
+//
+// Internally, strings are deduplicated by adding them to the strings
+// section (if not already present), and then writing a relocation
+// into the element bitstream.
+func (w *Encoder) String(s string) {
+ w.StringRef(w.p.StringIdx(s))
+}
+
+// StringRef writes a reference to the given index, which must be a
+// previously encoded string value.
+func (w *Encoder) StringRef(idx Index) {
+ w.Sync(SyncString)
+ w.Reloc(RelocString, idx)
+}
+
+// Strings encodes and writes a variable-length slice of strings into
+// the element bitstream.
+func (w *Encoder) Strings(ss []string) {
+ w.Len(len(ss))
+ for _, s := range ss {
+ w.String(s)
+ }
+}
+
+// Value encodes and writes a constant.Value into the element
+// bitstream.
+func (w *Encoder) Value(val constant.Value) {
+ w.Sync(SyncValue)
+ if w.Bool(val.Kind() == constant.Complex) {
+ w.scalar(constant.Real(val))
+ w.scalar(constant.Imag(val))
+ } else {
+ w.scalar(val)
+ }
+}
+
+func (w *Encoder) scalar(val constant.Value) {
+ switch v := constant.Val(val).(type) {
+ default:
+ panicf("unhandled %v (%v)", val, val.Kind())
+ case bool:
+ w.Code(ValBool)
+ w.Bool(v)
+ case string:
+ w.Code(ValString)
+ w.String(v)
+ case int64:
+ w.Code(ValInt64)
+ w.Int64(v)
+ case *big.Int:
+ w.Code(ValBigInt)
+ w.bigInt(v)
+ case *big.Rat:
+ w.Code(ValBigRat)
+ w.bigInt(v.Num())
+ w.bigInt(v.Denom())
+ case *big.Float:
+ w.Code(ValBigFloat)
+ w.bigFloat(v)
+ }
+}
+
+func (w *Encoder) bigInt(v *big.Int) {
+ b := v.Bytes()
+ w.String(string(b)) // TODO: More efficient encoding.
+ w.Bool(v.Sign() < 0)
+}
+
+func (w *Encoder) bigFloat(v *big.Float) {
+ b := v.Append(nil, 'p', -1)
+ w.String(string(b)) // TODO: More efficient encoding.
+}
+
+// Version reports the version of the bitstream.
+func (w *Encoder) Version() Version { return w.p.version }
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/flags.go b/vendor/golang.org/x/tools/internal/pkgbits/flags.go
new file mode 100644
index 00000000..65422274
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/pkgbits/flags.go
@@ -0,0 +1,9 @@
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package pkgbits
+
+const (
+ flagSyncMarkers = 1 << iota // file format contains sync markers
+)
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/reloc.go b/vendor/golang.org/x/tools/internal/pkgbits/reloc.go
new file mode 100644
index 00000000..fcdfb97c
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/pkgbits/reloc.go
@@ -0,0 +1,42 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package pkgbits
+
+// A RelocKind indicates a particular section within a unified IR export.
+type RelocKind int32
+
+// An Index represents a bitstream element index within a particular
+// section.
+type Index int32
+
+// A relocEnt (relocation entry) is an entry in an element's local
+// reference table.
+//
+// TODO(mdempsky): Rename this too.
+type RelocEnt struct {
+ Kind RelocKind
+ Idx Index
+}
+
+// Reserved indices within the meta relocation section.
+const (
+ PublicRootIdx Index = 0
+ PrivateRootIdx Index = 1
+)
+
+const (
+ RelocString RelocKind = iota
+ RelocMeta
+ RelocPosBase
+ RelocPkg
+ RelocName
+ RelocType
+ RelocObj
+ RelocObjExt
+ RelocObjDict
+ RelocBody
+
+ numRelocs = iota
+)
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/support.go b/vendor/golang.org/x/tools/internal/pkgbits/support.go
new file mode 100644
index 00000000..50534a29
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/pkgbits/support.go
@@ -0,0 +1,17 @@
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package pkgbits
+
+import "fmt"
+
+func assert(b bool) {
+ if !b {
+ panic("assertion failed")
+ }
+}
+
+func panicf(format string, args ...any) {
+ panic(fmt.Errorf(format, args...))
+}
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/sync.go b/vendor/golang.org/x/tools/internal/pkgbits/sync.go
new file mode 100644
index 00000000..1520b73a
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/pkgbits/sync.go
@@ -0,0 +1,136 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package pkgbits
+
+import (
+ "fmt"
+ "runtime"
+ "strings"
+)
+
+// fmtFrames formats a backtrace for reporting reader/writer desyncs.
+func fmtFrames(pcs ...uintptr) []string {
+ res := make([]string, 0, len(pcs))
+ walkFrames(pcs, func(file string, line int, name string, offset uintptr) {
+ // Trim package from function name. It's just redundant noise.
+ name = strings.TrimPrefix(name, "cmd/compile/internal/noder.")
+
+ res = append(res, fmt.Sprintf("%s:%v: %s +0x%v", file, line, name, offset))
+ })
+ return res
+}
+
+type frameVisitor func(file string, line int, name string, offset uintptr)
+
+// walkFrames calls visit for each call frame represented by pcs.
+//
+// pcs should be a slice of PCs, as returned by runtime.Callers.
+func walkFrames(pcs []uintptr, visit frameVisitor) {
+ if len(pcs) == 0 {
+ return
+ }
+
+ frames := runtime.CallersFrames(pcs)
+ for {
+ frame, more := frames.Next()
+ visit(frame.File, frame.Line, frame.Function, frame.PC-frame.Entry)
+ if !more {
+ return
+ }
+ }
+}
+
+// SyncMarker is an enum type that represents markers that may be
+// written to export data to ensure the reader and writer stay
+// synchronized.
+type SyncMarker int
+
+//go:generate stringer -type=SyncMarker -trimprefix=Sync
+
+const (
+ _ SyncMarker = iota
+
+ // Public markers (known to go/types importers).
+
+ // Low-level coding markers.
+ SyncEOF
+ SyncBool
+ SyncInt64
+ SyncUint64
+ SyncString
+ SyncValue
+ SyncVal
+ SyncRelocs
+ SyncReloc
+ SyncUseReloc
+
+ // Higher-level object and type markers.
+ SyncPublic
+ SyncPos
+ SyncPosBase
+ SyncObject
+ SyncObject1
+ SyncPkg
+ SyncPkgDef
+ SyncMethod
+ SyncType
+ SyncTypeIdx
+ SyncTypeParamNames
+ SyncSignature
+ SyncParams
+ SyncParam
+ SyncCodeObj
+ SyncSym
+ SyncLocalIdent
+ SyncSelector
+
+ // Private markers (only known to cmd/compile).
+ SyncPrivate
+
+ SyncFuncExt
+ SyncVarExt
+ SyncTypeExt
+ SyncPragma
+
+ SyncExprList
+ SyncExprs
+ SyncExpr
+ SyncExprType
+ SyncAssign
+ SyncOp
+ SyncFuncLit
+ SyncCompLit
+
+ SyncDecl
+ SyncFuncBody
+ SyncOpenScope
+ SyncCloseScope
+ SyncCloseAnotherScope
+ SyncDeclNames
+ SyncDeclName
+
+ SyncStmts
+ SyncBlockStmt
+ SyncIfStmt
+ SyncForStmt
+ SyncSwitchStmt
+ SyncRangeStmt
+ SyncCaseClause
+ SyncCommClause
+ SyncSelectStmt
+ SyncDecls
+ SyncLabeledStmt
+ SyncUseObjLocal
+ SyncAddLocal
+ SyncLinkname
+ SyncStmt1
+ SyncStmtsEnd
+ SyncLabel
+ SyncOptLabel
+
+ SyncMultiExpr
+ SyncRType
+ SyncConvRTTI
+)
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/syncmarker_string.go b/vendor/golang.org/x/tools/internal/pkgbits/syncmarker_string.go
new file mode 100644
index 00000000..582ad56d
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/pkgbits/syncmarker_string.go
@@ -0,0 +1,92 @@
+// Code generated by "stringer -type=SyncMarker -trimprefix=Sync"; DO NOT EDIT.
+
+package pkgbits
+
+import "strconv"
+
+func _() {
+ // An "invalid array index" compiler error signifies that the constant values have changed.
+ // Re-run the stringer command to generate them again.
+ var x [1]struct{}
+ _ = x[SyncEOF-1]
+ _ = x[SyncBool-2]
+ _ = x[SyncInt64-3]
+ _ = x[SyncUint64-4]
+ _ = x[SyncString-5]
+ _ = x[SyncValue-6]
+ _ = x[SyncVal-7]
+ _ = x[SyncRelocs-8]
+ _ = x[SyncReloc-9]
+ _ = x[SyncUseReloc-10]
+ _ = x[SyncPublic-11]
+ _ = x[SyncPos-12]
+ _ = x[SyncPosBase-13]
+ _ = x[SyncObject-14]
+ _ = x[SyncObject1-15]
+ _ = x[SyncPkg-16]
+ _ = x[SyncPkgDef-17]
+ _ = x[SyncMethod-18]
+ _ = x[SyncType-19]
+ _ = x[SyncTypeIdx-20]
+ _ = x[SyncTypeParamNames-21]
+ _ = x[SyncSignature-22]
+ _ = x[SyncParams-23]
+ _ = x[SyncParam-24]
+ _ = x[SyncCodeObj-25]
+ _ = x[SyncSym-26]
+ _ = x[SyncLocalIdent-27]
+ _ = x[SyncSelector-28]
+ _ = x[SyncPrivate-29]
+ _ = x[SyncFuncExt-30]
+ _ = x[SyncVarExt-31]
+ _ = x[SyncTypeExt-32]
+ _ = x[SyncPragma-33]
+ _ = x[SyncExprList-34]
+ _ = x[SyncExprs-35]
+ _ = x[SyncExpr-36]
+ _ = x[SyncExprType-37]
+ _ = x[SyncAssign-38]
+ _ = x[SyncOp-39]
+ _ = x[SyncFuncLit-40]
+ _ = x[SyncCompLit-41]
+ _ = x[SyncDecl-42]
+ _ = x[SyncFuncBody-43]
+ _ = x[SyncOpenScope-44]
+ _ = x[SyncCloseScope-45]
+ _ = x[SyncCloseAnotherScope-46]
+ _ = x[SyncDeclNames-47]
+ _ = x[SyncDeclName-48]
+ _ = x[SyncStmts-49]
+ _ = x[SyncBlockStmt-50]
+ _ = x[SyncIfStmt-51]
+ _ = x[SyncForStmt-52]
+ _ = x[SyncSwitchStmt-53]
+ _ = x[SyncRangeStmt-54]
+ _ = x[SyncCaseClause-55]
+ _ = x[SyncCommClause-56]
+ _ = x[SyncSelectStmt-57]
+ _ = x[SyncDecls-58]
+ _ = x[SyncLabeledStmt-59]
+ _ = x[SyncUseObjLocal-60]
+ _ = x[SyncAddLocal-61]
+ _ = x[SyncLinkname-62]
+ _ = x[SyncStmt1-63]
+ _ = x[SyncStmtsEnd-64]
+ _ = x[SyncLabel-65]
+ _ = x[SyncOptLabel-66]
+ _ = x[SyncMultiExpr-67]
+ _ = x[SyncRType-68]
+ _ = x[SyncConvRTTI-69]
+}
+
+const _SyncMarker_name = "EOFBoolInt64Uint64StringValueValRelocsRelocUseRelocPublicPosPosBaseObjectObject1PkgPkgDefMethodTypeTypeIdxTypeParamNamesSignatureParamsParamCodeObjSymLocalIdentSelectorPrivateFuncExtVarExtTypeExtPragmaExprListExprsExprExprTypeAssignOpFuncLitCompLitDeclFuncBodyOpenScopeCloseScopeCloseAnotherScopeDeclNamesDeclNameStmtsBlockStmtIfStmtForStmtSwitchStmtRangeStmtCaseClauseCommClauseSelectStmtDeclsLabeledStmtUseObjLocalAddLocalLinknameStmt1StmtsEndLabelOptLabelMultiExprRTypeConvRTTI"
+
+var _SyncMarker_index = [...]uint16{0, 3, 7, 12, 18, 24, 29, 32, 38, 43, 51, 57, 60, 67, 73, 80, 83, 89, 95, 99, 106, 120, 129, 135, 140, 147, 150, 160, 168, 175, 182, 188, 195, 201, 209, 214, 218, 226, 232, 234, 241, 248, 252, 260, 269, 279, 296, 305, 313, 318, 327, 333, 340, 350, 359, 369, 379, 389, 394, 405, 416, 424, 432, 437, 445, 450, 458, 467, 472, 480}
+
+func (i SyncMarker) String() string {
+ i -= 1
+ if i < 0 || i >= SyncMarker(len(_SyncMarker_index)-1) {
+ return "SyncMarker(" + strconv.FormatInt(int64(i+1), 10) + ")"
+ }
+ return _SyncMarker_name[_SyncMarker_index[i]:_SyncMarker_index[i+1]]
+}
diff --git a/vendor/golang.org/x/tools/internal/pkgbits/version.go b/vendor/golang.org/x/tools/internal/pkgbits/version.go
new file mode 100644
index 00000000..53af9df2
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/pkgbits/version.go
@@ -0,0 +1,85 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package pkgbits
+
+// Version indicates a version of a unified IR bitstream.
+// Each Version indicates the addition, removal, or change of
+// new data in the bitstream.
+//
+// These are serialized to disk and the interpretation remains fixed.
+type Version uint32
+
+const (
+ // V0: initial prototype.
+ //
+ // All data that is not assigned a Field is in version V0
+ // and has not been deprecated.
+ V0 Version = iota
+
+ // V1: adds the Flags uint32 word
+ V1
+
+ // V2: removes unused legacy fields and supports type parameters for aliases.
+ // - remove the legacy "has init" bool from the public root
+ // - remove obj's "derived func instance" bool
+ // - add a TypeParamNames field to ObjAlias
+ // - remove derived info "needed" bool
+ V2
+
+ numVersions = iota
+)
+
+// Field denotes a unit of data in the serialized unified IR bitstream.
+// It is conceptually a like field in a structure.
+//
+// We only really need Fields when the data may or may not be present
+// in a stream based on the Version of the bitstream.
+//
+// Unlike much of pkgbits, Fields are not serialized and
+// can change values as needed.
+type Field int
+
+const (
+ // Flags in a uint32 in the header of a bitstream
+ // that is used to indicate whether optional features are enabled.
+ Flags Field = iota
+
+ // Deprecated: HasInit was a bool indicating whether a package
+ // has any init functions.
+ HasInit
+
+ // Deprecated: DerivedFuncInstance was a bool indicating
+ // whether an object was a function instance.
+ DerivedFuncInstance
+
+ // ObjAlias has a list of TypeParamNames.
+ AliasTypeParamNames
+
+ // Deprecated: DerivedInfoNeeded was a bool indicating
+ // whether a type was a derived type.
+ DerivedInfoNeeded
+
+ numFields = iota
+)
+
+// introduced is the version a field was added.
+var introduced = [numFields]Version{
+ Flags: V1,
+ AliasTypeParamNames: V2,
+}
+
+// removed is the version a field was removed in or 0 for fields
+// that have not yet been deprecated.
+// (So removed[f]-1 is the last version it is included in.)
+var removed = [numFields]Version{
+ HasInit: V2,
+ DerivedFuncInstance: V2,
+ DerivedInfoNeeded: V2,
+}
+
+// Has reports whether field f is present in a bitstream at version v.
+func (v Version) Has(f Field) bool {
+ return introduced[f] <= v && (v < removed[f] || removed[f] == V0)
+}
diff --git a/vendor/golang.org/x/tools/internal/stdlib/deps.go b/vendor/golang.org/x/tools/internal/stdlib/deps.go
new file mode 100644
index 00000000..77cf8d21
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/stdlib/deps.go
@@ -0,0 +1,359 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Code generated by generate.go. DO NOT EDIT.
+
+package stdlib
+
+type pkginfo struct {
+ name string
+ deps string // list of indices of dependencies, as varint-encoded deltas
+}
+
+var deps = [...]pkginfo{
+ {"archive/tar", "\x03j\x03E5\x01\v\x01#\x01\x01\x02\x05\n\x02\x01\x02\x02\v"},
+ {"archive/zip", "\x02\x04`\a\x16\x0205\x01+\x05\x01\x11\x03\x02\r\x04"},
+ {"bufio", "\x03j}F\x13"},
+ {"bytes", "m+R\x03\fH\x02\x02"},
+ {"cmp", ""},
+ {"compress/bzip2", "\x02\x02\xe6\x01C"},
+ {"compress/flate", "\x02k\x03z\r\x025\x01\x03"},
+ {"compress/gzip", "\x02\x04`\a\x03\x15eU"},
+ {"compress/lzw", "\x02k\x03z"},
+ {"compress/zlib", "\x02\x04`\a\x03\x13\x01f"},
+ {"container/heap", "\xae\x02"},
+ {"container/list", ""},
+ {"container/ring", ""},
+ {"context", "m\\i\x01\f"},
+ {"crypto", "\x83\x01gE"},
+ {"crypto/aes", "\x10\n\a\x8e\x02"},
+ {"crypto/cipher", "\x03\x1e\x01\x01\x1d\x11\x1c,Q"},
+ {"crypto/des", "\x10\x13\x1d-,\x96\x01\x03"},
+ {"crypto/dsa", "@\x04)}\x0e"},
+ {"crypto/ecdh", "\x03\v\f\x0e\x04\x14\x04\r\x1c}"},
+ {"crypto/ecdsa", "\x0e\x05\x03\x04\x01\x0e\x16\x01\x04\f\x01\x1c}\x0e\x04L\x01"},
+ {"crypto/ed25519", "\x0e\x1c\x16\n\a\x1c}E"},
+ {"crypto/elliptic", "0=}\x0e:"},
+ {"crypto/fips140", " \x05\x90\x01"},
+ {"crypto/hkdf", "-\x12\x01-\x16"},
+ {"crypto/hmac", "\x1a\x14\x11\x01\x112"},
+ {"crypto/internal/boring", "\x0e\x02\rf"},
+ {"crypto/internal/boring/bbig", "\x1a\xde\x01M"},
+ {"crypto/internal/boring/bcache", "\xb3\x02\x12"},
+ {"crypto/internal/boring/sig", ""},
+ {"crypto/internal/cryptotest", "\x03\r\n)\x0e\x19\x06\x13\x12#\a\t\x11\x11\x11\x1b\x01\f\r\x05\n"},
+ {"crypto/internal/entropy", "E"},
+ {"crypto/internal/fips140", ">/}9\r\x15"},
+ {"crypto/internal/fips140/aes", "\x03\x1d\x03\x02\x13\x04\x01\x01\x05*\x8c\x016"},
+ {"crypto/internal/fips140/aes/gcm", " \x01\x02\x02\x02\x11\x04\x01\x06*\x8a\x01"},
+ {"crypto/internal/fips140/alias", "\xc5\x02"},
+ {"crypto/internal/fips140/bigmod", "%\x17\x01\x06*\x8c\x01"},
+ {"crypto/internal/fips140/check", " \x0e\x06\b\x02\xac\x01["},
+ {"crypto/internal/fips140/check/checktest", "%\xfe\x01\""},
+ {"crypto/internal/fips140/drbg", "\x03\x1c\x01\x01\x04\x13\x04\b\x01(}\x0f9"},
+ {"crypto/internal/fips140/ecdh", "\x03\x1d\x05\x02\t\f1}\x0f9"},
+ {"crypto/internal/fips140/ecdsa", "\x03\x1d\x04\x01\x02\a\x02\x067}H"},
+ {"crypto/internal/fips140/ed25519", "\x03\x1d\x05\x02\x04\v7\xc2\x01\x03"},
+ {"crypto/internal/fips140/edwards25519", "%\a\f\x041\x8c\x019"},
+ {"crypto/internal/fips140/edwards25519/field", "%\x13\x041\x8c\x01"},
+ {"crypto/internal/fips140/hkdf", "\x03\x1d\x05\t\x069"},
+ {"crypto/internal/fips140/hmac", "\x03\x1d\x14\x01\x017"},
+ {"crypto/internal/fips140/mlkem", "\x03\x1d\x05\x02\x0e\x03\x041"},
+ {"crypto/internal/fips140/nistec", "%\f\a\x041\x8c\x01*\x0f\x13"},
+ {"crypto/internal/fips140/nistec/fiat", "%\x135\x8c\x01"},
+ {"crypto/internal/fips140/pbkdf2", "\x03\x1d\x05\t\x069"},
+ {"crypto/internal/fips140/rsa", "\x03\x1d\x04\x01\x02\r\x01\x01\x025}H"},
+ {"crypto/internal/fips140/sha256", "\x03\x1d\x1c\x01\x06*\x8c\x01"},
+ {"crypto/internal/fips140/sha3", "\x03\x1d\x18\x04\x010\x8c\x01L"},
+ {"crypto/internal/fips140/sha512", "\x03\x1d\x1c\x01\x06*\x8c\x01"},
+ {"crypto/internal/fips140/ssh", " \x05"},
+ {"crypto/internal/fips140/subtle", "#"},
+ {"crypto/internal/fips140/tls12", "\x03\x1d\x05\t\x06\x027"},
+ {"crypto/internal/fips140/tls13", "\x03\x1d\x05\b\a\b1"},
+ {"crypto/internal/fips140deps", ""},
+ {"crypto/internal/fips140deps/byteorder", "\x99\x01"},
+ {"crypto/internal/fips140deps/cpu", "\xad\x01\a"},
+ {"crypto/internal/fips140deps/godebug", "\xb5\x01"},
+ {"crypto/internal/fips140hash", "5\x1a4\xc2\x01"},
+ {"crypto/internal/fips140only", "'\r\x01\x01M25"},
+ {"crypto/internal/fips140test", ""},
+ {"crypto/internal/hpke", "\x0e\x01\x01\x03\x1a\x1d#,`N"},
+ {"crypto/internal/impl", "\xb0\x02"},
+ {"crypto/internal/randutil", "\xea\x01\x12"},
+ {"crypto/internal/sysrand", "mi!\x1f\r\x0f\x01\x01\v\x06"},
+ {"crypto/internal/sysrand/internal/seccomp", "m"},
+ {"crypto/md5", "\x0e2-\x16\x16`"},
+ {"crypto/mlkem", "/"},
+ {"crypto/pbkdf2", "2\r\x01-\x16"},
+ {"crypto/rand", "\x1a\x06\a\x19\x04\x01(}\x0eM"},
+ {"crypto/rc4", "#\x1d-\xc2\x01"},
+ {"crypto/rsa", "\x0e\f\x01\t\x0f\f\x01\x04\x06\a\x1c\x03\x1325\r\x01"},
+ {"crypto/sha1", "\x0e\f&-\x16\x16\x14L"},
+ {"crypto/sha256", "\x0e\f\x1aO"},
+ {"crypto/sha3", "\x0e'N\xc2\x01"},
+ {"crypto/sha512", "\x0e\f\x1cM"},
+ {"crypto/subtle", "8\x96\x01U"},
+ {"crypto/tls", "\x03\b\x02\x01\x01\x01\x01\x02\x01\x01\x01\x03\x01\a\x01\v\x02\n\x01\b\x05\x03\x01\x01\x01\x01\x02\x01\x02\x01\x17\x02\x03\x13\x16\x14\b5\x16\x16\r\n\x01\x01\x01\x02\x01\f\x06\x02\x01"},
+ {"crypto/tls/internal/fips140tls", " \x93\x02"},
+ {"crypto/x509", "\x03\v\x01\x01\x01\x01\x01\x01\x01\x011\x03\x02\x01\x01\x02\x05\x0e\x06\x02\x02\x03E\x032\x01\x02\t\x01\x01\x01\a\x10\x05\x01\x06\x02\x05\f\x01\x02\r\x02\x01\x01\x02\x03\x01"},
+ {"crypto/x509/pkix", "c\x06\a\x88\x01G"},
+ {"database/sql", "\x03\nJ\x16\x03z\f\x06\"\x05\n\x02\x03\x01\f\x02\x02\x02"},
+ {"database/sql/driver", "\r`\x03\xae\x01\x11\x10"},
+ {"debug/buildinfo", "\x03W\x02\x01\x01\b\a\x03`\x18\x02\x01+\x0f "},
+ {"debug/dwarf", "\x03c\a\x03z1\x13\x01\x01"},
+ {"debug/elf", "\x03\x06P\r\a\x03`\x19\x01,\x19\x01\x15"},
+ {"debug/gosym", "\x03c\n\xbe\x01\x01\x01\x02"},
+ {"debug/macho", "\x03\x06P\r\n`\x1a,\x19\x01"},
+ {"debug/pe", "\x03\x06P\r\a\x03`\x1a,\x19\x01\x15"},
+ {"debug/plan9obj", "f\a\x03`\x1a,"},
+ {"embed", "m+:\x18\x01T"},
+ {"embed/internal/embedtest", ""},
+ {"encoding", ""},
+ {"encoding/ascii85", "\xea\x01E"},
+ {"encoding/asn1", "\x03j\x03\x87\x01\x01&\x0f\x02\x01\x0f\x03\x01"},
+ {"encoding/base32", "\xea\x01C\x02"},
+ {"encoding/base64", "\x99\x01QC\x02"},
+ {"encoding/binary", "m}\r'\x0f\x05"},
+ {"encoding/csv", "\x02\x01j\x03zF\x11\x02"},
+ {"encoding/gob", "\x02_\x05\a\x03`\x1a\f\x01\x02\x1d\b\x14\x01\x0e\x02"},
+ {"encoding/hex", "m\x03zC\x03"},
+ {"encoding/json", "\x03\x01]\x04\b\x03z\r'\x0f\x02\x01\x02\x0f\x01\x01\x02"},
+ {"encoding/pem", "\x03b\b}C\x03"},
+ {"encoding/xml", "\x02\x01^\f\x03z4\x05\f\x01\x02\x0f\x02"},
+ {"errors", "\xc9\x01|"},
+ {"expvar", "jK9\t\n\x15\r\n\x02\x03\x01\x10"},
+ {"flag", "a\f\x03z,\b\x05\n\x02\x01\x0f"},
+ {"fmt", "mE8\r\x1f\b\x0f\x02\x03\x11"},
+ {"go/ast", "\x03\x01l\x0f\x01j\x03)\b\x0f\x02\x01"},
+ {"go/ast/internal/tests", ""},
+ {"go/build", "\x02\x01j\x03\x01\x03\x02\a\x02\x01\x17\x1e\x04\x02\t\x14\x12\x01+\x01\x04\x01\a\n\x02\x01\x11\x02\x02"},
+ {"go/build/constraint", "m\xc2\x01\x01\x11\x02"},
+ {"go/constant", "p\x10w\x01\x016\x01\x02\x11"},
+ {"go/doc", "\x04l\x01\x06\t=-1\x12\x02\x01\x11\x02"},
+ {"go/doc/comment", "\x03m\xbd\x01\x01\x01\x01\x11\x02"},
+ {"go/format", "\x03m\x01\f\x01\x02jF"},
+ {"go/importer", "s\a\x01\x01\x04\x01i9"},
+ {"go/internal/gccgoimporter", "\x02\x01W\x13\x03\x05\v\x01g\x02,\x01\x05\x13\x01\v\b"},
+ {"go/internal/gcimporter", "\x02n\x10\x01/\x05\x0e',\x17\x03\x02"},
+ {"go/internal/srcimporter", "p\x01\x02\n\x03\x01i,\x01\x05\x14\x02\x13"},
+ {"go/parser", "\x03j\x03\x01\x03\v\x01j\x01+\x06\x14"},
+ {"go/printer", "p\x01\x03\x03\tj\r\x1f\x17\x02\x01\x02\n\x05\x02"},
+ {"go/scanner", "\x03m\x10j2\x12\x01\x12\x02"},
+ {"go/token", "\x04l\xbd\x01\x02\x03\x01\x0e\x02"},
+ {"go/types", "\x03\x01\x06c\x03\x01\x04\b\x03\x02\x15\x1e\x06+\x04\x03\n%\a\n\x01\x01\x01\x02\x01\x0e\x02\x02"},
+ {"go/version", "\xba\x01v"},
+ {"hash", "\xea\x01"},
+ {"hash/adler32", "m\x16\x16"},
+ {"hash/crc32", "m\x16\x16\x14\x85\x01\x01\x12"},
+ {"hash/crc64", "m\x16\x16\x99\x01"},
+ {"hash/fnv", "m\x16\x16`"},
+ {"hash/maphash", "\x94\x01\x05\x1b\x03@N"},
+ {"html", "\xb0\x02\x02\x11"},
+ {"html/template", "\x03g\x06\x19,5\x01\v \x05\x01\x02\x03\x0e\x01\x02\v\x01\x03\x02"},
+ {"image", "\x02k\x1f^\x0f6\x03\x01"},
+ {"image/color", ""},
+ {"image/color/palette", "\x8c\x01"},
+ {"image/draw", "\x8b\x01\x01\x04"},
+ {"image/gif", "\x02\x01\x05e\x03\x1b\x01\x01\x01\vQ"},
+ {"image/internal/imageutil", "\x8b\x01"},
+ {"image/jpeg", "\x02k\x1e\x01\x04Z"},
+ {"image/png", "\x02\a]\n\x13\x02\x06\x01^E"},
+ {"index/suffixarray", "\x03c\a}\r*\f\x01"},
+ {"internal/abi", "\xb4\x01\x91\x01"},
+ {"internal/asan", "\xc5\x02"},
+ {"internal/bisect", "\xa3\x02\x0f\x01"},
+ {"internal/buildcfg", "pG_\x06\x02\x05\f\x01"},
+ {"internal/bytealg", "\xad\x01\x98\x01"},
+ {"internal/byteorder", ""},
+ {"internal/cfg", ""},
+ {"internal/chacha8rand", "\x99\x01\x1b\x91\x01"},
+ {"internal/copyright", ""},
+ {"internal/coverage", ""},
+ {"internal/coverage/calloc", ""},
+ {"internal/coverage/cfile", "j\x06\x17\x16\x01\x02\x01\x01\x01\x01\x01\x01\x01#\x01\x1f,\x06\a\f\x01\x03\f\x06"},
+ {"internal/coverage/cformat", "\x04l-\x04I\f7\x01\x02\f"},
+ {"internal/coverage/cmerge", "p-Z"},
+ {"internal/coverage/decodecounter", "f\n-\v\x02@,\x19\x16"},
+ {"internal/coverage/decodemeta", "\x02d\n\x17\x16\v\x02@,"},
+ {"internal/coverage/encodecounter", "\x02d\n-\f\x01\x02>\f \x17"},
+ {"internal/coverage/encodemeta", "\x02\x01c\n\x13\x04\x16\r\x02>,/"},
+ {"internal/coverage/pods", "\x04l-y\x06\x05\f\x02\x01"},
+ {"internal/coverage/rtcov", "\xc5\x02"},
+ {"internal/coverage/slicereader", "f\nz["},
+ {"internal/coverage/slicewriter", "pz"},
+ {"internal/coverage/stringtab", "p8\x04>"},
+ {"internal/coverage/test", ""},
+ {"internal/coverage/uleb128", ""},
+ {"internal/cpu", "\xc5\x02"},
+ {"internal/dag", "\x04l\xbd\x01\x03"},
+ {"internal/diff", "\x03m\xbe\x01\x02"},
+ {"internal/exportdata", "\x02\x01j\x03\x03]\x1a,\x01\x05\x13\x01\x02"},
+ {"internal/filepathlite", "m+:\x19B"},
+ {"internal/fmtsort", "\x04\x9a\x02\x0f"},
+ {"internal/fuzz", "\x03\nA\x18\x04\x03\x03\x01\f\x0355\r\x02\x1d\x01\x05\x02\x05\f\x01\x02\x01\x01\v\x04\x02"},
+ {"internal/goarch", ""},
+ {"internal/godebug", "\x96\x01 |\x01\x12"},
+ {"internal/godebugs", ""},
+ {"internal/goexperiment", ""},
+ {"internal/goos", ""},
+ {"internal/goroot", "\x96\x02\x01\x05\x14\x02"},
+ {"internal/gover", "\x04"},
+ {"internal/goversion", ""},
+ {"internal/itoa", ""},
+ {"internal/lazyregexp", "\x96\x02\v\x0f\x02"},
+ {"internal/lazytemplate", "\xea\x01,\x1a\x02\v"},
+ {"internal/msan", "\xc5\x02"},
+ {"internal/nettrace", ""},
+ {"internal/obscuretestdata", "e\x85\x01,"},
+ {"internal/oserror", "m"},
+ {"internal/pkgbits", "\x03K\x18\a\x03\x05\vj\x0e\x1e\r\f\x01"},
+ {"internal/platform", ""},
+ {"internal/poll", "mO\x1a\x149\x0f\x01\x01\v\x06"},
+ {"internal/profile", "\x03\x04f\x03z7\r\x01\x01\x0f"},
+ {"internal/profilerecord", ""},
+ {"internal/race", "\x94\x01\xb1\x01"},
+ {"internal/reflectlite", "\x94\x01 3<\""},
+ {"internal/runtime/atomic", "\xc5\x02"},
+ {"internal/runtime/exithook", "\xca\x01{"},
+ {"internal/runtime/maps", "\x94\x01\x01\x1f\v\t\x05\x01w"},
+ {"internal/runtime/math", "\xb4\x01"},
+ {"internal/runtime/sys", "\xb4\x01\x04"},
+ {"internal/runtime/syscall", "\xc5\x02"},
+ {"internal/saferio", "\xea\x01["},
+ {"internal/singleflight", "\xb2\x02"},
+ {"internal/stringslite", "\x98\x01\xad\x01"},
+ {"internal/sync", "\x94\x01 \x14k\x12"},
+ {"internal/synctest", "\xc5\x02"},
+ {"internal/syscall/execenv", "\xb4\x02"},
+ {"internal/syscall/unix", "\xa3\x02\x10\x01\x11"},
+ {"internal/sysinfo", "\x02\x01\xaa\x01=,\x1a\x02"},
+ {"internal/syslist", ""},
+ {"internal/testenv", "\x03\n`\x02\x01*\x1a\x10'+\x01\x05\a\f\x01\x02\x02\x01\n"},
+ {"internal/testlog", "\xb2\x02\x01\x12"},
+ {"internal/testpty", "m\x03\xa6\x01"},
+ {"internal/trace", "\x02\x01\x01\x06\\\a\x03n\x03\x03\x06\x03\n6\x01\x02\x0f\x06"},
+ {"internal/trace/internal/testgen", "\x03c\nl\x03\x02\x03\x011\v\x0f"},
+ {"internal/trace/internal/tracev1", "\x03\x01b\a\x03t\x06\r6\x01"},
+ {"internal/trace/raw", "\x02d\nq\x03\x06E\x01\x11"},
+ {"internal/trace/testtrace", "\x02\x01j\x03l\x03\x06\x057\f\x02\x01"},
+ {"internal/trace/tracev2", ""},
+ {"internal/trace/traceviewer", "\x02]\v\x06\x1a<\x16\a\a\x04\t\n\x15\x01\x05\a\f\x01\x02\r"},
+ {"internal/trace/traceviewer/format", ""},
+ {"internal/trace/version", "pq\t"},
+ {"internal/txtar", "\x03m\xa6\x01\x1a"},
+ {"internal/types/errors", "\xaf\x02"},
+ {"internal/unsafeheader", "\xc5\x02"},
+ {"internal/xcoff", "Y\r\a\x03`\x1a,\x19\x01"},
+ {"internal/zstd", "f\a\x03z\x0f"},
+ {"io", "m\xc5\x01"},
+ {"io/fs", "m+*(1\x12\x12\x04"},
+ {"io/ioutil", "\xea\x01\x01+\x17\x03"},
+ {"iter", "\xc8\x01[\""},
+ {"log", "pz\x05'\r\x0f\x01\f"},
+ {"log/internal", ""},
+ {"log/slog", "\x03\nT\t\x03\x03z\x04\x01\x02\x02\x04'\x05\n\x02\x01\x02\x01\f\x02\x02\x02"},
+ {"log/slog/internal", ""},
+ {"log/slog/internal/benchmarks", "\r`\x03z\x06\x03<\x10"},
+ {"log/slog/internal/buffer", "\xb2\x02"},
+ {"log/slog/internal/slogtest", "\xf0\x01"},
+ {"log/syslog", "m\x03~\x12\x16\x1a\x02\r"},
+ {"maps", "\xed\x01X"},
+ {"math", "\xad\x01LL"},
+ {"math/big", "\x03j\x03)\x14=\r\x02\x024\x01\x02\x13"},
+ {"math/bits", "\xc5\x02"},
+ {"math/cmplx", "\xf7\x01\x02"},
+ {"math/rand", "\xb5\x01B;\x01\x12"},
+ {"math/rand/v2", "m,\x02\\\x02L"},
+ {"mime", "\x02\x01b\b\x03z\f \x17\x03\x02\x0f\x02"},
+ {"mime/multipart", "\x02\x01G#\x03E5\f\x01\x06\x02\x15\x02\x06\x11\x02\x01\x15"},
+ {"mime/quotedprintable", "\x02\x01mz"},
+ {"net", "\x04\t`+\x1d\a\x04\x05\f\x01\x04\x14\x01%\x06\r\n\x05\x01\x01\v\x06\a"},
+ {"net/http", "\x02\x01\x04\x04\x02=\b\x13\x01\a\x03E5\x01\x03\b\x01\x02\x02\x02\x01\x02\x06\x02\x01\x01\n\x01\x01\x05\x01\x02\x05\n\x01\x01\x01\x02\x01\x01\v\x02\x02\x02\b\x01\x01\x01"},
+ {"net/http/cgi", "\x02P\x1b\x03z\x04\b\n\x01\x13\x01\x01\x01\x04\x01\x05\x02\n\x02\x01\x0f\x0e"},
+ {"net/http/cookiejar", "\x04i\x03\x90\x01\x01\b\f\x18\x03\x02\r\x04"},
+ {"net/http/fcgi", "\x02\x01\nY\a\x03z\x16\x01\x01\x14\x1a\x02\r"},
+ {"net/http/httptest", "\x02\x01\nE\x02\x1b\x01z\x04\x12\x01\n\t\x02\x19\x01\x02\r\x0e"},
+ {"net/http/httptrace", "\rEn@\x14\n!"},
+ {"net/http/httputil", "\x02\x01\n`\x03z\x04\x0f\x03\x01\x05\x02\x01\v\x01\x1b\x02\r\x0e"},
+ {"net/http/internal", "\x02\x01j\x03z"},
+ {"net/http/internal/ascii", "\xb0\x02\x11"},
+ {"net/http/internal/httpcommon", "\r`\x03\x96\x01\x0e\x01\x19\x01\x01\x02\x1b\x02"},
+ {"net/http/internal/testcert", "\xb0\x02"},
+ {"net/http/pprof", "\x02\x01\nc\x19,\x11$\x04\x13\x14\x01\r\x06\x03\x01\x02\x01\x0f"},
+ {"net/internal/cgotest", ""},
+ {"net/internal/socktest", "p\xc2\x01\x02"},
+ {"net/mail", "\x02k\x03z\x04\x0f\x03\x14\x1c\x02\r\x04"},
+ {"net/netip", "\x04i+\x01#;\x026\x15"},
+ {"net/rpc", "\x02f\x05\x03\x10\n`\x04\x12\x01\x1d\x0f\x03\x02"},
+ {"net/rpc/jsonrpc", "j\x03\x03z\x16\x11!"},
+ {"net/smtp", "\x19.\v\x13\b\x03z\x16\x14\x1c"},
+ {"net/textproto", "\x02\x01j\x03z\r\t/\x01\x02\x13"},
+ {"net/url", "m\x03\x86\x01%\x12\x02\x01\x15"},
+ {"os", "m+\x01\x18\x03\b\t\r\x03\x01\x04\x10\x018\n\x05\x01\x01\v\x06"},
+ {"os/exec", "\x03\n`H \x01\x14\x01+\x06\a\f\x01\x04\v"},
+ {"os/exec/internal/fdtest", "\xb4\x02"},
+ {"os/signal", "\r\x89\x02\x17\x05\x02"},
+ {"os/user", "\x02\x01j\x03z,\r\f\x01\x02"},
+ {"path", "m+\xab\x01"},
+ {"path/filepath", "m+\x19:+\r\n\x03\x04\x0f"},
+ {"plugin", "m"},
+ {"reflect", "m'\x04\x1c\b\f\x04\x02\x19\x10,\f\x03\x0f\x02\x02"},
+ {"reflect/internal/example1", ""},
+ {"reflect/internal/example2", ""},
+ {"regexp", "\x03\xe7\x018\v\x02\x01\x02\x0f\x02"},
+ {"regexp/syntax", "\xad\x02\x01\x01\x01\x11\x02"},
+ {"runtime", "\x94\x01\x04\x01\x02\f\x06\a\x02\x01\x01\x0f\x03\x01\x01\x01\x01\x01\x03\x0fd"},
+ {"runtime/coverage", "\x9f\x01K"},
+ {"runtime/debug", "pUQ\r\n\x02\x01\x0f\x06"},
+ {"runtime/internal/startlinetest", ""},
+ {"runtime/internal/wasitest", ""},
+ {"runtime/metrics", "\xb6\x01A,\""},
+ {"runtime/pprof", "\x02\x01\x01\x03\x06Y\a\x03$3#\r\x1f\r\n\x01\x01\x01\x02\x02\b\x03\x06"},
+ {"runtime/race", "\xab\x02"},
+ {"runtime/race/internal/amd64v1", ""},
+ {"runtime/trace", "\rcz9\x0f\x01\x12"},
+ {"slices", "\x04\xe9\x01\fL"},
+ {"sort", "\xc9\x0104"},
+ {"strconv", "m+:%\x02J"},
+ {"strings", "m'\x04:\x18\x03\f9\x0f\x02\x02"},
+ {"structs", ""},
+ {"sync", "\xc8\x01\vP\x10\x12"},
+ {"sync/atomic", "\xc5\x02"},
+ {"syscall", "m(\x03\x01\x1b\b\x03\x03\x06\aT\n\x05\x01\x12"},
+ {"testing", "\x03\n`\x02\x01X\x0f\x13\r\x04\x1b\x06\x02\x05\x02\a\x01\x02\x01\x02\x01\f\x02\x02\x02"},
+ {"testing/fstest", "m\x03z\x01\v%\x12\x03\b\a"},
+ {"testing/internal/testdeps", "\x02\v\xa6\x01'\x10,\x03\x05\x03\b\a\x02\r"},
+ {"testing/iotest", "\x03j\x03z\x04"},
+ {"testing/quick", "o\x01\x87\x01\x04#\x12\x0f"},
+ {"testing/slogtest", "\r`\x03\x80\x01.\x05\x12\n"},
+ {"text/scanner", "\x03mz,+\x02"},
+ {"text/tabwriter", "pzY"},
+ {"text/template", "m\x03B8\x01\v\x1f\x01\x05\x01\x02\x05\r\x02\f\x03\x02"},
+ {"text/template/parse", "\x03m\xb3\x01\f\x01\x11\x02"},
+ {"time", "m+\x1d\x1d'*\x0f\x02\x11"},
+ {"time/tzdata", "m\xc7\x01\x11"},
+ {"unicode", ""},
+ {"unicode/utf16", ""},
+ {"unicode/utf8", ""},
+ {"unique", "\x94\x01>\x01P\x0f\x13\x12"},
+ {"unsafe", ""},
+ {"vendor/golang.org/x/crypto/chacha20", "\x10V\a\x8c\x01*'"},
+ {"vendor/golang.org/x/crypto/chacha20poly1305", "\x10V\a\xd9\x01\x04\x01\a"},
+ {"vendor/golang.org/x/crypto/cryptobyte", "c\n\x03\x88\x01&!\n"},
+ {"vendor/golang.org/x/crypto/cryptobyte/asn1", ""},
+ {"vendor/golang.org/x/crypto/internal/alias", "\xc5\x02"},
+ {"vendor/golang.org/x/crypto/internal/poly1305", "Q\x15\x93\x01"},
+ {"vendor/golang.org/x/net/dns/dnsmessage", "m"},
+ {"vendor/golang.org/x/net/http/httpguts", "\x80\x02\x14\x1c\x13\r"},
+ {"vendor/golang.org/x/net/http/httpproxy", "m\x03\x90\x01\x15\x01\x1a\x13\r"},
+ {"vendor/golang.org/x/net/http2/hpack", "\x03j\x03zH"},
+ {"vendor/golang.org/x/net/idna", "p\x87\x019\x13\x10\x02\x01"},
+ {"vendor/golang.org/x/net/nettest", "\x03c\a\x03z\x11\x05\x16\x01\f\f\x01\x02\x02\x01\n"},
+ {"vendor/golang.org/x/sys/cpu", "\x96\x02\r\f\x01\x15"},
+ {"vendor/golang.org/x/text/secure/bidirule", "m\xd6\x01\x11\x01"},
+ {"vendor/golang.org/x/text/transform", "\x03j}Y"},
+ {"vendor/golang.org/x/text/unicode/bidi", "\x03\be~@\x15"},
+ {"vendor/golang.org/x/text/unicode/norm", "f\nzH\x11\x11"},
+ {"weak", "\x94\x01\x8f\x01\""},
+}
diff --git a/vendor/golang.org/x/tools/internal/stdlib/import.go b/vendor/golang.org/x/tools/internal/stdlib/import.go
new file mode 100644
index 00000000..f6909878
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/stdlib/import.go
@@ -0,0 +1,89 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package stdlib
+
+// This file provides the API for the import graph of the standard library.
+//
+// Be aware that the compiler-generated code for every package
+// implicitly depends on package "runtime" and a handful of others
+// (see runtimePkgs in GOROOT/src/cmd/internal/objabi/pkgspecial.go).
+
+import (
+ "encoding/binary"
+ "iter"
+ "slices"
+ "strings"
+)
+
+// Imports returns the sequence of packages directly imported by the
+// named standard packages, in name order.
+// The imports of an unknown package are the empty set.
+//
+// The graph is built into the application and may differ from the
+// graph in the Go source tree being analyzed by the application.
+func Imports(pkgs ...string) iter.Seq[string] {
+ return func(yield func(string) bool) {
+ for _, pkg := range pkgs {
+ if i, ok := find(pkg); ok {
+ var depIndex uint64
+ for data := []byte(deps[i].deps); len(data) > 0; {
+ delta, n := binary.Uvarint(data)
+ depIndex += delta
+ if !yield(deps[depIndex].name) {
+ return
+ }
+ data = data[n:]
+ }
+ }
+ }
+ }
+}
+
+// Dependencies returns the set of all dependencies of the named
+// standard packages, including the initial package,
+// in a deterministic topological order.
+// The dependencies of an unknown package are the empty set.
+//
+// The graph is built into the application and may differ from the
+// graph in the Go source tree being analyzed by the application.
+func Dependencies(pkgs ...string) iter.Seq[string] {
+ return func(yield func(string) bool) {
+ for _, pkg := range pkgs {
+ if i, ok := find(pkg); ok {
+ var seen [1 + len(deps)/8]byte // bit set of seen packages
+ var visit func(i int) bool
+ visit = func(i int) bool {
+ bit := byte(1) << (i % 8)
+ if seen[i/8]&bit == 0 {
+ seen[i/8] |= bit
+ var depIndex uint64
+ for data := []byte(deps[i].deps); len(data) > 0; {
+ delta, n := binary.Uvarint(data)
+ depIndex += delta
+ if !visit(int(depIndex)) {
+ return false
+ }
+ data = data[n:]
+ }
+ if !yield(deps[i].name) {
+ return false
+ }
+ }
+ return true
+ }
+ if !visit(i) {
+ return
+ }
+ }
+ }
+ }
+}
+
+// find returns the index of pkg in the deps table.
+func find(pkg string) (int, bool) {
+ return slices.BinarySearchFunc(deps[:], pkg, func(p pkginfo, n string) int {
+ return strings.Compare(p.name, n)
+ })
+}
diff --git a/vendor/golang.org/x/tools/internal/stdlib/manifest.go b/vendor/golang.org/x/tools/internal/stdlib/manifest.go
new file mode 100644
index 00000000..64f0326b
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/stdlib/manifest.go
@@ -0,0 +1,17676 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Code generated by generate.go. DO NOT EDIT.
+
+package stdlib
+
+var PackageSymbols = map[string][]Symbol{
+ "archive/tar": {
+ {"(*Header).FileInfo", Method, 1, ""},
+ {"(*Reader).Next", Method, 0, ""},
+ {"(*Reader).Read", Method, 0, ""},
+ {"(*Writer).AddFS", Method, 22, ""},
+ {"(*Writer).Close", Method, 0, ""},
+ {"(*Writer).Flush", Method, 0, ""},
+ {"(*Writer).Write", Method, 0, ""},
+ {"(*Writer).WriteHeader", Method, 0, ""},
+ {"(Format).String", Method, 10, ""},
+ {"ErrFieldTooLong", Var, 0, ""},
+ {"ErrHeader", Var, 0, ""},
+ {"ErrInsecurePath", Var, 20, ""},
+ {"ErrWriteAfterClose", Var, 0, ""},
+ {"ErrWriteTooLong", Var, 0, ""},
+ {"FileInfoHeader", Func, 1, "func(fi fs.FileInfo, link string) (*Header, error)"},
+ {"FileInfoNames", Type, 23, ""},
+ {"Format", Type, 10, ""},
+ {"FormatGNU", Const, 10, ""},
+ {"FormatPAX", Const, 10, ""},
+ {"FormatUSTAR", Const, 10, ""},
+ {"FormatUnknown", Const, 10, ""},
+ {"Header", Type, 0, ""},
+ {"Header.AccessTime", Field, 0, ""},
+ {"Header.ChangeTime", Field, 0, ""},
+ {"Header.Devmajor", Field, 0, ""},
+ {"Header.Devminor", Field, 0, ""},
+ {"Header.Format", Field, 10, ""},
+ {"Header.Gid", Field, 0, ""},
+ {"Header.Gname", Field, 0, ""},
+ {"Header.Linkname", Field, 0, ""},
+ {"Header.ModTime", Field, 0, ""},
+ {"Header.Mode", Field, 0, ""},
+ {"Header.Name", Field, 0, ""},
+ {"Header.PAXRecords", Field, 10, ""},
+ {"Header.Size", Field, 0, ""},
+ {"Header.Typeflag", Field, 0, ""},
+ {"Header.Uid", Field, 0, ""},
+ {"Header.Uname", Field, 0, ""},
+ {"Header.Xattrs", Field, 3, ""},
+ {"NewReader", Func, 0, "func(r io.Reader) *Reader"},
+ {"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
+ {"Reader", Type, 0, ""},
+ {"TypeBlock", Const, 0, ""},
+ {"TypeChar", Const, 0, ""},
+ {"TypeCont", Const, 0, ""},
+ {"TypeDir", Const, 0, ""},
+ {"TypeFifo", Const, 0, ""},
+ {"TypeGNULongLink", Const, 1, ""},
+ {"TypeGNULongName", Const, 1, ""},
+ {"TypeGNUSparse", Const, 3, ""},
+ {"TypeLink", Const, 0, ""},
+ {"TypeReg", Const, 0, ""},
+ {"TypeRegA", Const, 0, ""},
+ {"TypeSymlink", Const, 0, ""},
+ {"TypeXGlobalHeader", Const, 0, ""},
+ {"TypeXHeader", Const, 0, ""},
+ {"Writer", Type, 0, ""},
+ },
+ "archive/zip": {
+ {"(*File).DataOffset", Method, 2, ""},
+ {"(*File).FileInfo", Method, 0, ""},
+ {"(*File).ModTime", Method, 0, ""},
+ {"(*File).Mode", Method, 0, ""},
+ {"(*File).Open", Method, 0, ""},
+ {"(*File).OpenRaw", Method, 17, ""},
+ {"(*File).SetModTime", Method, 0, ""},
+ {"(*File).SetMode", Method, 0, ""},
+ {"(*FileHeader).FileInfo", Method, 0, ""},
+ {"(*FileHeader).ModTime", Method, 0, ""},
+ {"(*FileHeader).Mode", Method, 0, ""},
+ {"(*FileHeader).SetModTime", Method, 0, ""},
+ {"(*FileHeader).SetMode", Method, 0, ""},
+ {"(*ReadCloser).Close", Method, 0, ""},
+ {"(*ReadCloser).Open", Method, 16, ""},
+ {"(*ReadCloser).RegisterDecompressor", Method, 6, ""},
+ {"(*Reader).Open", Method, 16, ""},
+ {"(*Reader).RegisterDecompressor", Method, 6, ""},
+ {"(*Writer).AddFS", Method, 22, ""},
+ {"(*Writer).Close", Method, 0, ""},
+ {"(*Writer).Copy", Method, 17, ""},
+ {"(*Writer).Create", Method, 0, ""},
+ {"(*Writer).CreateHeader", Method, 0, ""},
+ {"(*Writer).CreateRaw", Method, 17, ""},
+ {"(*Writer).Flush", Method, 4, ""},
+ {"(*Writer).RegisterCompressor", Method, 6, ""},
+ {"(*Writer).SetComment", Method, 10, ""},
+ {"(*Writer).SetOffset", Method, 5, ""},
+ {"Compressor", Type, 2, ""},
+ {"Decompressor", Type, 2, ""},
+ {"Deflate", Const, 0, ""},
+ {"ErrAlgorithm", Var, 0, ""},
+ {"ErrChecksum", Var, 0, ""},
+ {"ErrFormat", Var, 0, ""},
+ {"ErrInsecurePath", Var, 20, ""},
+ {"File", Type, 0, ""},
+ {"File.FileHeader", Field, 0, ""},
+ {"FileHeader", Type, 0, ""},
+ {"FileHeader.CRC32", Field, 0, ""},
+ {"FileHeader.Comment", Field, 0, ""},
+ {"FileHeader.CompressedSize", Field, 0, ""},
+ {"FileHeader.CompressedSize64", Field, 1, ""},
+ {"FileHeader.CreatorVersion", Field, 0, ""},
+ {"FileHeader.ExternalAttrs", Field, 0, ""},
+ {"FileHeader.Extra", Field, 0, ""},
+ {"FileHeader.Flags", Field, 0, ""},
+ {"FileHeader.Method", Field, 0, ""},
+ {"FileHeader.Modified", Field, 10, ""},
+ {"FileHeader.ModifiedDate", Field, 0, ""},
+ {"FileHeader.ModifiedTime", Field, 0, ""},
+ {"FileHeader.Name", Field, 0, ""},
+ {"FileHeader.NonUTF8", Field, 10, ""},
+ {"FileHeader.ReaderVersion", Field, 0, ""},
+ {"FileHeader.UncompressedSize", Field, 0, ""},
+ {"FileHeader.UncompressedSize64", Field, 1, ""},
+ {"FileInfoHeader", Func, 0, "func(fi fs.FileInfo) (*FileHeader, error)"},
+ {"NewReader", Func, 0, "func(r io.ReaderAt, size int64) (*Reader, error)"},
+ {"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
+ {"OpenReader", Func, 0, "func(name string) (*ReadCloser, error)"},
+ {"ReadCloser", Type, 0, ""},
+ {"ReadCloser.Reader", Field, 0, ""},
+ {"Reader", Type, 0, ""},
+ {"Reader.Comment", Field, 0, ""},
+ {"Reader.File", Field, 0, ""},
+ {"RegisterCompressor", Func, 2, "func(method uint16, comp Compressor)"},
+ {"RegisterDecompressor", Func, 2, "func(method uint16, dcomp Decompressor)"},
+ {"Store", Const, 0, ""},
+ {"Writer", Type, 0, ""},
+ },
+ "bufio": {
+ {"(*Reader).Buffered", Method, 0, ""},
+ {"(*Reader).Discard", Method, 5, ""},
+ {"(*Reader).Peek", Method, 0, ""},
+ {"(*Reader).Read", Method, 0, ""},
+ {"(*Reader).ReadByte", Method, 0, ""},
+ {"(*Reader).ReadBytes", Method, 0, ""},
+ {"(*Reader).ReadLine", Method, 0, ""},
+ {"(*Reader).ReadRune", Method, 0, ""},
+ {"(*Reader).ReadSlice", Method, 0, ""},
+ {"(*Reader).ReadString", Method, 0, ""},
+ {"(*Reader).Reset", Method, 2, ""},
+ {"(*Reader).Size", Method, 10, ""},
+ {"(*Reader).UnreadByte", Method, 0, ""},
+ {"(*Reader).UnreadRune", Method, 0, ""},
+ {"(*Reader).WriteTo", Method, 1, ""},
+ {"(*Scanner).Buffer", Method, 6, ""},
+ {"(*Scanner).Bytes", Method, 1, ""},
+ {"(*Scanner).Err", Method, 1, ""},
+ {"(*Scanner).Scan", Method, 1, ""},
+ {"(*Scanner).Split", Method, 1, ""},
+ {"(*Scanner).Text", Method, 1, ""},
+ {"(*Writer).Available", Method, 0, ""},
+ {"(*Writer).AvailableBuffer", Method, 18, ""},
+ {"(*Writer).Buffered", Method, 0, ""},
+ {"(*Writer).Flush", Method, 0, ""},
+ {"(*Writer).ReadFrom", Method, 1, ""},
+ {"(*Writer).Reset", Method, 2, ""},
+ {"(*Writer).Size", Method, 10, ""},
+ {"(*Writer).Write", Method, 0, ""},
+ {"(*Writer).WriteByte", Method, 0, ""},
+ {"(*Writer).WriteRune", Method, 0, ""},
+ {"(*Writer).WriteString", Method, 0, ""},
+ {"(ReadWriter).Available", Method, 0, ""},
+ {"(ReadWriter).AvailableBuffer", Method, 18, ""},
+ {"(ReadWriter).Discard", Method, 5, ""},
+ {"(ReadWriter).Flush", Method, 0, ""},
+ {"(ReadWriter).Peek", Method, 0, ""},
+ {"(ReadWriter).Read", Method, 0, ""},
+ {"(ReadWriter).ReadByte", Method, 0, ""},
+ {"(ReadWriter).ReadBytes", Method, 0, ""},
+ {"(ReadWriter).ReadFrom", Method, 1, ""},
+ {"(ReadWriter).ReadLine", Method, 0, ""},
+ {"(ReadWriter).ReadRune", Method, 0, ""},
+ {"(ReadWriter).ReadSlice", Method, 0, ""},
+ {"(ReadWriter).ReadString", Method, 0, ""},
+ {"(ReadWriter).UnreadByte", Method, 0, ""},
+ {"(ReadWriter).UnreadRune", Method, 0, ""},
+ {"(ReadWriter).Write", Method, 0, ""},
+ {"(ReadWriter).WriteByte", Method, 0, ""},
+ {"(ReadWriter).WriteRune", Method, 0, ""},
+ {"(ReadWriter).WriteString", Method, 0, ""},
+ {"(ReadWriter).WriteTo", Method, 1, ""},
+ {"ErrAdvanceTooFar", Var, 1, ""},
+ {"ErrBadReadCount", Var, 15, ""},
+ {"ErrBufferFull", Var, 0, ""},
+ {"ErrFinalToken", Var, 6, ""},
+ {"ErrInvalidUnreadByte", Var, 0, ""},
+ {"ErrInvalidUnreadRune", Var, 0, ""},
+ {"ErrNegativeAdvance", Var, 1, ""},
+ {"ErrNegativeCount", Var, 0, ""},
+ {"ErrTooLong", Var, 1, ""},
+ {"MaxScanTokenSize", Const, 1, ""},
+ {"NewReadWriter", Func, 0, "func(r *Reader, w *Writer) *ReadWriter"},
+ {"NewReader", Func, 0, "func(rd io.Reader) *Reader"},
+ {"NewReaderSize", Func, 0, "func(rd io.Reader, size int) *Reader"},
+ {"NewScanner", Func, 1, "func(r io.Reader) *Scanner"},
+ {"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
+ {"NewWriterSize", Func, 0, "func(w io.Writer, size int) *Writer"},
+ {"ReadWriter", Type, 0, ""},
+ {"ReadWriter.Reader", Field, 0, ""},
+ {"ReadWriter.Writer", Field, 0, ""},
+ {"Reader", Type, 0, ""},
+ {"ScanBytes", Func, 1, "func(data []byte, atEOF bool) (advance int, token []byte, err error)"},
+ {"ScanLines", Func, 1, "func(data []byte, atEOF bool) (advance int, token []byte, err error)"},
+ {"ScanRunes", Func, 1, "func(data []byte, atEOF bool) (advance int, token []byte, err error)"},
+ {"ScanWords", Func, 1, "func(data []byte, atEOF bool) (advance int, token []byte, err error)"},
+ {"Scanner", Type, 1, ""},
+ {"SplitFunc", Type, 1, ""},
+ {"Writer", Type, 0, ""},
+ },
+ "bytes": {
+ {"(*Buffer).Available", Method, 21, ""},
+ {"(*Buffer).AvailableBuffer", Method, 21, ""},
+ {"(*Buffer).Bytes", Method, 0, ""},
+ {"(*Buffer).Cap", Method, 5, ""},
+ {"(*Buffer).Grow", Method, 1, ""},
+ {"(*Buffer).Len", Method, 0, ""},
+ {"(*Buffer).Next", Method, 0, ""},
+ {"(*Buffer).Read", Method, 0, ""},
+ {"(*Buffer).ReadByte", Method, 0, ""},
+ {"(*Buffer).ReadBytes", Method, 0, ""},
+ {"(*Buffer).ReadFrom", Method, 0, ""},
+ {"(*Buffer).ReadRune", Method, 0, ""},
+ {"(*Buffer).ReadString", Method, 0, ""},
+ {"(*Buffer).Reset", Method, 0, ""},
+ {"(*Buffer).String", Method, 0, ""},
+ {"(*Buffer).Truncate", Method, 0, ""},
+ {"(*Buffer).UnreadByte", Method, 0, ""},
+ {"(*Buffer).UnreadRune", Method, 0, ""},
+ {"(*Buffer).Write", Method, 0, ""},
+ {"(*Buffer).WriteByte", Method, 0, ""},
+ {"(*Buffer).WriteRune", Method, 0, ""},
+ {"(*Buffer).WriteString", Method, 0, ""},
+ {"(*Buffer).WriteTo", Method, 0, ""},
+ {"(*Reader).Len", Method, 0, ""},
+ {"(*Reader).Read", Method, 0, ""},
+ {"(*Reader).ReadAt", Method, 0, ""},
+ {"(*Reader).ReadByte", Method, 0, ""},
+ {"(*Reader).ReadRune", Method, 0, ""},
+ {"(*Reader).Reset", Method, 7, ""},
+ {"(*Reader).Seek", Method, 0, ""},
+ {"(*Reader).Size", Method, 5, ""},
+ {"(*Reader).UnreadByte", Method, 0, ""},
+ {"(*Reader).UnreadRune", Method, 0, ""},
+ {"(*Reader).WriteTo", Method, 1, ""},
+ {"Buffer", Type, 0, ""},
+ {"Clone", Func, 20, "func(b []byte) []byte"},
+ {"Compare", Func, 0, "func(a []byte, b []byte) int"},
+ {"Contains", Func, 0, "func(b []byte, subslice []byte) bool"},
+ {"ContainsAny", Func, 7, "func(b []byte, chars string) bool"},
+ {"ContainsFunc", Func, 21, "func(b []byte, f func(rune) bool) bool"},
+ {"ContainsRune", Func, 7, "func(b []byte, r rune) bool"},
+ {"Count", Func, 0, "func(s []byte, sep []byte) int"},
+ {"Cut", Func, 18, "func(s []byte, sep []byte) (before []byte, after []byte, found bool)"},
+ {"CutPrefix", Func, 20, "func(s []byte, prefix []byte) (after []byte, found bool)"},
+ {"CutSuffix", Func, 20, "func(s []byte, suffix []byte) (before []byte, found bool)"},
+ {"Equal", Func, 0, "func(a []byte, b []byte) bool"},
+ {"EqualFold", Func, 0, "func(s []byte, t []byte) bool"},
+ {"ErrTooLarge", Var, 0, ""},
+ {"Fields", Func, 0, "func(s []byte) [][]byte"},
+ {"FieldsFunc", Func, 0, "func(s []byte, f func(rune) bool) [][]byte"},
+ {"FieldsFuncSeq", Func, 24, "func(s []byte, f func(rune) bool) iter.Seq[[]byte]"},
+ {"FieldsSeq", Func, 24, "func(s []byte) iter.Seq[[]byte]"},
+ {"HasPrefix", Func, 0, "func(s []byte, prefix []byte) bool"},
+ {"HasSuffix", Func, 0, "func(s []byte, suffix []byte) bool"},
+ {"Index", Func, 0, "func(s []byte, sep []byte) int"},
+ {"IndexAny", Func, 0, "func(s []byte, chars string) int"},
+ {"IndexByte", Func, 0, "func(b []byte, c byte) int"},
+ {"IndexFunc", Func, 0, "func(s []byte, f func(r rune) bool) int"},
+ {"IndexRune", Func, 0, "func(s []byte, r rune) int"},
+ {"Join", Func, 0, "func(s [][]byte, sep []byte) []byte"},
+ {"LastIndex", Func, 0, "func(s []byte, sep []byte) int"},
+ {"LastIndexAny", Func, 0, "func(s []byte, chars string) int"},
+ {"LastIndexByte", Func, 5, "func(s []byte, c byte) int"},
+ {"LastIndexFunc", Func, 0, "func(s []byte, f func(r rune) bool) int"},
+ {"Lines", Func, 24, "func(s []byte) iter.Seq[[]byte]"},
+ {"Map", Func, 0, "func(mapping func(r rune) rune, s []byte) []byte"},
+ {"MinRead", Const, 0, ""},
+ {"NewBuffer", Func, 0, "func(buf []byte) *Buffer"},
+ {"NewBufferString", Func, 0, "func(s string) *Buffer"},
+ {"NewReader", Func, 0, "func(b []byte) *Reader"},
+ {"Reader", Type, 0, ""},
+ {"Repeat", Func, 0, "func(b []byte, count int) []byte"},
+ {"Replace", Func, 0, "func(s []byte, old []byte, new []byte, n int) []byte"},
+ {"ReplaceAll", Func, 12, "func(s []byte, old []byte, new []byte) []byte"},
+ {"Runes", Func, 0, "func(s []byte) []rune"},
+ {"Split", Func, 0, "func(s []byte, sep []byte) [][]byte"},
+ {"SplitAfter", Func, 0, "func(s []byte, sep []byte) [][]byte"},
+ {"SplitAfterN", Func, 0, "func(s []byte, sep []byte, n int) [][]byte"},
+ {"SplitAfterSeq", Func, 24, "func(s []byte, sep []byte) iter.Seq[[]byte]"},
+ {"SplitN", Func, 0, "func(s []byte, sep []byte, n int) [][]byte"},
+ {"SplitSeq", Func, 24, "func(s []byte, sep []byte) iter.Seq[[]byte]"},
+ {"Title", Func, 0, "func(s []byte) []byte"},
+ {"ToLower", Func, 0, "func(s []byte) []byte"},
+ {"ToLowerSpecial", Func, 0, "func(c unicode.SpecialCase, s []byte) []byte"},
+ {"ToTitle", Func, 0, "func(s []byte) []byte"},
+ {"ToTitleSpecial", Func, 0, "func(c unicode.SpecialCase, s []byte) []byte"},
+ {"ToUpper", Func, 0, "func(s []byte) []byte"},
+ {"ToUpperSpecial", Func, 0, "func(c unicode.SpecialCase, s []byte) []byte"},
+ {"ToValidUTF8", Func, 13, "func(s []byte, replacement []byte) []byte"},
+ {"Trim", Func, 0, "func(s []byte, cutset string) []byte"},
+ {"TrimFunc", Func, 0, "func(s []byte, f func(r rune) bool) []byte"},
+ {"TrimLeft", Func, 0, "func(s []byte, cutset string) []byte"},
+ {"TrimLeftFunc", Func, 0, "func(s []byte, f func(r rune) bool) []byte"},
+ {"TrimPrefix", Func, 1, "func(s []byte, prefix []byte) []byte"},
+ {"TrimRight", Func, 0, "func(s []byte, cutset string) []byte"},
+ {"TrimRightFunc", Func, 0, "func(s []byte, f func(r rune) bool) []byte"},
+ {"TrimSpace", Func, 0, "func(s []byte) []byte"},
+ {"TrimSuffix", Func, 1, "func(s []byte, suffix []byte) []byte"},
+ },
+ "cmp": {
+ {"Compare", Func, 21, "func[T Ordered](x T, y T) int"},
+ {"Less", Func, 21, "func[T Ordered](x T, y T) bool"},
+ {"Or", Func, 22, "func[T comparable](vals ...T) T"},
+ {"Ordered", Type, 21, ""},
+ },
+ "compress/bzip2": {
+ {"(StructuralError).Error", Method, 0, ""},
+ {"NewReader", Func, 0, "func(r io.Reader) io.Reader"},
+ {"StructuralError", Type, 0, ""},
+ },
+ "compress/flate": {
+ {"(*ReadError).Error", Method, 0, ""},
+ {"(*WriteError).Error", Method, 0, ""},
+ {"(*Writer).Close", Method, 0, ""},
+ {"(*Writer).Flush", Method, 0, ""},
+ {"(*Writer).Reset", Method, 2, ""},
+ {"(*Writer).Write", Method, 0, ""},
+ {"(CorruptInputError).Error", Method, 0, ""},
+ {"(InternalError).Error", Method, 0, ""},
+ {"BestCompression", Const, 0, ""},
+ {"BestSpeed", Const, 0, ""},
+ {"CorruptInputError", Type, 0, ""},
+ {"DefaultCompression", Const, 0, ""},
+ {"HuffmanOnly", Const, 7, ""},
+ {"InternalError", Type, 0, ""},
+ {"NewReader", Func, 0, "func(r io.Reader) io.ReadCloser"},
+ {"NewReaderDict", Func, 0, "func(r io.Reader, dict []byte) io.ReadCloser"},
+ {"NewWriter", Func, 0, "func(w io.Writer, level int) (*Writer, error)"},
+ {"NewWriterDict", Func, 0, "func(w io.Writer, level int, dict []byte) (*Writer, error)"},
+ {"NoCompression", Const, 0, ""},
+ {"ReadError", Type, 0, ""},
+ {"ReadError.Err", Field, 0, ""},
+ {"ReadError.Offset", Field, 0, ""},
+ {"Reader", Type, 0, ""},
+ {"Resetter", Type, 4, ""},
+ {"WriteError", Type, 0, ""},
+ {"WriteError.Err", Field, 0, ""},
+ {"WriteError.Offset", Field, 0, ""},
+ {"Writer", Type, 0, ""},
+ },
+ "compress/gzip": {
+ {"(*Reader).Close", Method, 0, ""},
+ {"(*Reader).Multistream", Method, 4, ""},
+ {"(*Reader).Read", Method, 0, ""},
+ {"(*Reader).Reset", Method, 3, ""},
+ {"(*Writer).Close", Method, 0, ""},
+ {"(*Writer).Flush", Method, 1, ""},
+ {"(*Writer).Reset", Method, 2, ""},
+ {"(*Writer).Write", Method, 0, ""},
+ {"BestCompression", Const, 0, ""},
+ {"BestSpeed", Const, 0, ""},
+ {"DefaultCompression", Const, 0, ""},
+ {"ErrChecksum", Var, 0, ""},
+ {"ErrHeader", Var, 0, ""},
+ {"Header", Type, 0, ""},
+ {"Header.Comment", Field, 0, ""},
+ {"Header.Extra", Field, 0, ""},
+ {"Header.ModTime", Field, 0, ""},
+ {"Header.Name", Field, 0, ""},
+ {"Header.OS", Field, 0, ""},
+ {"HuffmanOnly", Const, 8, ""},
+ {"NewReader", Func, 0, "func(r io.Reader) (*Reader, error)"},
+ {"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
+ {"NewWriterLevel", Func, 0, "func(w io.Writer, level int) (*Writer, error)"},
+ {"NoCompression", Const, 0, ""},
+ {"Reader", Type, 0, ""},
+ {"Reader.Header", Field, 0, ""},
+ {"Writer", Type, 0, ""},
+ {"Writer.Header", Field, 0, ""},
+ },
+ "compress/lzw": {
+ {"(*Reader).Close", Method, 17, ""},
+ {"(*Reader).Read", Method, 17, ""},
+ {"(*Reader).Reset", Method, 17, ""},
+ {"(*Writer).Close", Method, 17, ""},
+ {"(*Writer).Reset", Method, 17, ""},
+ {"(*Writer).Write", Method, 17, ""},
+ {"LSB", Const, 0, ""},
+ {"MSB", Const, 0, ""},
+ {"NewReader", Func, 0, "func(r io.Reader, order Order, litWidth int) io.ReadCloser"},
+ {"NewWriter", Func, 0, "func(w io.Writer, order Order, litWidth int) io.WriteCloser"},
+ {"Order", Type, 0, ""},
+ {"Reader", Type, 17, ""},
+ {"Writer", Type, 17, ""},
+ },
+ "compress/zlib": {
+ {"(*Writer).Close", Method, 0, ""},
+ {"(*Writer).Flush", Method, 0, ""},
+ {"(*Writer).Reset", Method, 2, ""},
+ {"(*Writer).Write", Method, 0, ""},
+ {"BestCompression", Const, 0, ""},
+ {"BestSpeed", Const, 0, ""},
+ {"DefaultCompression", Const, 0, ""},
+ {"ErrChecksum", Var, 0, ""},
+ {"ErrDictionary", Var, 0, ""},
+ {"ErrHeader", Var, 0, ""},
+ {"HuffmanOnly", Const, 8, ""},
+ {"NewReader", Func, 0, "func(r io.Reader) (io.ReadCloser, error)"},
+ {"NewReaderDict", Func, 0, "func(r io.Reader, dict []byte) (io.ReadCloser, error)"},
+ {"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
+ {"NewWriterLevel", Func, 0, "func(w io.Writer, level int) (*Writer, error)"},
+ {"NewWriterLevelDict", Func, 0, "func(w io.Writer, level int, dict []byte) (*Writer, error)"},
+ {"NoCompression", Const, 0, ""},
+ {"Resetter", Type, 4, ""},
+ {"Writer", Type, 0, ""},
+ },
+ "container/heap": {
+ {"Fix", Func, 2, "func(h Interface, i int)"},
+ {"Init", Func, 0, "func(h Interface)"},
+ {"Interface", Type, 0, ""},
+ {"Pop", Func, 0, "func(h Interface) any"},
+ {"Push", Func, 0, "func(h Interface, x any)"},
+ {"Remove", Func, 0, "func(h Interface, i int) any"},
+ },
+ "container/list": {
+ {"(*Element).Next", Method, 0, ""},
+ {"(*Element).Prev", Method, 0, ""},
+ {"(*List).Back", Method, 0, ""},
+ {"(*List).Front", Method, 0, ""},
+ {"(*List).Init", Method, 0, ""},
+ {"(*List).InsertAfter", Method, 0, ""},
+ {"(*List).InsertBefore", Method, 0, ""},
+ {"(*List).Len", Method, 0, ""},
+ {"(*List).MoveAfter", Method, 2, ""},
+ {"(*List).MoveBefore", Method, 2, ""},
+ {"(*List).MoveToBack", Method, 0, ""},
+ {"(*List).MoveToFront", Method, 0, ""},
+ {"(*List).PushBack", Method, 0, ""},
+ {"(*List).PushBackList", Method, 0, ""},
+ {"(*List).PushFront", Method, 0, ""},
+ {"(*List).PushFrontList", Method, 0, ""},
+ {"(*List).Remove", Method, 0, ""},
+ {"Element", Type, 0, ""},
+ {"Element.Value", Field, 0, ""},
+ {"List", Type, 0, ""},
+ {"New", Func, 0, "func() *List"},
+ },
+ "container/ring": {
+ {"(*Ring).Do", Method, 0, ""},
+ {"(*Ring).Len", Method, 0, ""},
+ {"(*Ring).Link", Method, 0, ""},
+ {"(*Ring).Move", Method, 0, ""},
+ {"(*Ring).Next", Method, 0, ""},
+ {"(*Ring).Prev", Method, 0, ""},
+ {"(*Ring).Unlink", Method, 0, ""},
+ {"New", Func, 0, "func(n int) *Ring"},
+ {"Ring", Type, 0, ""},
+ {"Ring.Value", Field, 0, ""},
+ },
+ "context": {
+ {"AfterFunc", Func, 21, "func(ctx Context, f func()) (stop func() bool)"},
+ {"Background", Func, 7, "func() Context"},
+ {"CancelCauseFunc", Type, 20, ""},
+ {"CancelFunc", Type, 7, ""},
+ {"Canceled", Var, 7, ""},
+ {"Cause", Func, 20, "func(c Context) error"},
+ {"Context", Type, 7, ""},
+ {"DeadlineExceeded", Var, 7, ""},
+ {"TODO", Func, 7, "func() Context"},
+ {"WithCancel", Func, 7, "func(parent Context) (ctx Context, cancel CancelFunc)"},
+ {"WithCancelCause", Func, 20, "func(parent Context) (ctx Context, cancel CancelCauseFunc)"},
+ {"WithDeadline", Func, 7, "func(parent Context, d time.Time) (Context, CancelFunc)"},
+ {"WithDeadlineCause", Func, 21, "func(parent Context, d time.Time, cause error) (Context, CancelFunc)"},
+ {"WithTimeout", Func, 7, "func(parent Context, timeout time.Duration) (Context, CancelFunc)"},
+ {"WithTimeoutCause", Func, 21, "func(parent Context, timeout time.Duration, cause error) (Context, CancelFunc)"},
+ {"WithValue", Func, 7, "func(parent Context, key any, val any) Context"},
+ {"WithoutCancel", Func, 21, "func(parent Context) Context"},
+ },
+ "crypto": {
+ {"(Hash).Available", Method, 0, ""},
+ {"(Hash).HashFunc", Method, 4, ""},
+ {"(Hash).New", Method, 0, ""},
+ {"(Hash).Size", Method, 0, ""},
+ {"(Hash).String", Method, 15, ""},
+ {"BLAKE2b_256", Const, 9, ""},
+ {"BLAKE2b_384", Const, 9, ""},
+ {"BLAKE2b_512", Const, 9, ""},
+ {"BLAKE2s_256", Const, 9, ""},
+ {"Decrypter", Type, 5, ""},
+ {"DecrypterOpts", Type, 5, ""},
+ {"Hash", Type, 0, ""},
+ {"MD4", Const, 0, ""},
+ {"MD5", Const, 0, ""},
+ {"MD5SHA1", Const, 0, ""},
+ {"PrivateKey", Type, 0, ""},
+ {"PublicKey", Type, 2, ""},
+ {"RIPEMD160", Const, 0, ""},
+ {"RegisterHash", Func, 0, "func(h Hash, f func() hash.Hash)"},
+ {"SHA1", Const, 0, ""},
+ {"SHA224", Const, 0, ""},
+ {"SHA256", Const, 0, ""},
+ {"SHA384", Const, 0, ""},
+ {"SHA3_224", Const, 4, ""},
+ {"SHA3_256", Const, 4, ""},
+ {"SHA3_384", Const, 4, ""},
+ {"SHA3_512", Const, 4, ""},
+ {"SHA512", Const, 0, ""},
+ {"SHA512_224", Const, 5, ""},
+ {"SHA512_256", Const, 5, ""},
+ {"Signer", Type, 4, ""},
+ {"SignerOpts", Type, 4, ""},
+ },
+ "crypto/aes": {
+ {"(KeySizeError).Error", Method, 0, ""},
+ {"BlockSize", Const, 0, ""},
+ {"KeySizeError", Type, 0, ""},
+ {"NewCipher", Func, 0, "func(key []byte) (cipher.Block, error)"},
+ },
+ "crypto/cipher": {
+ {"(StreamReader).Read", Method, 0, ""},
+ {"(StreamWriter).Close", Method, 0, ""},
+ {"(StreamWriter).Write", Method, 0, ""},
+ {"AEAD", Type, 2, ""},
+ {"Block", Type, 0, ""},
+ {"BlockMode", Type, 0, ""},
+ {"NewCBCDecrypter", Func, 0, "func(b Block, iv []byte) BlockMode"},
+ {"NewCBCEncrypter", Func, 0, "func(b Block, iv []byte) BlockMode"},
+ {"NewCFBDecrypter", Func, 0, "func(block Block, iv []byte) Stream"},
+ {"NewCFBEncrypter", Func, 0, "func(block Block, iv []byte) Stream"},
+ {"NewCTR", Func, 0, "func(block Block, iv []byte) Stream"},
+ {"NewGCM", Func, 2, "func(cipher Block) (AEAD, error)"},
+ {"NewGCMWithNonceSize", Func, 5, "func(cipher Block, size int) (AEAD, error)"},
+ {"NewGCMWithRandomNonce", Func, 24, "func(cipher Block) (AEAD, error)"},
+ {"NewGCMWithTagSize", Func, 11, "func(cipher Block, tagSize int) (AEAD, error)"},
+ {"NewOFB", Func, 0, "func(b Block, iv []byte) Stream"},
+ {"Stream", Type, 0, ""},
+ {"StreamReader", Type, 0, ""},
+ {"StreamReader.R", Field, 0, ""},
+ {"StreamReader.S", Field, 0, ""},
+ {"StreamWriter", Type, 0, ""},
+ {"StreamWriter.Err", Field, 0, ""},
+ {"StreamWriter.S", Field, 0, ""},
+ {"StreamWriter.W", Field, 0, ""},
+ },
+ "crypto/des": {
+ {"(KeySizeError).Error", Method, 0, ""},
+ {"BlockSize", Const, 0, ""},
+ {"KeySizeError", Type, 0, ""},
+ {"NewCipher", Func, 0, "func(key []byte) (cipher.Block, error)"},
+ {"NewTripleDESCipher", Func, 0, "func(key []byte) (cipher.Block, error)"},
+ },
+ "crypto/dsa": {
+ {"ErrInvalidPublicKey", Var, 0, ""},
+ {"GenerateKey", Func, 0, "func(priv *PrivateKey, rand io.Reader) error"},
+ {"GenerateParameters", Func, 0, "func(params *Parameters, rand io.Reader, sizes ParameterSizes) error"},
+ {"L1024N160", Const, 0, ""},
+ {"L2048N224", Const, 0, ""},
+ {"L2048N256", Const, 0, ""},
+ {"L3072N256", Const, 0, ""},
+ {"ParameterSizes", Type, 0, ""},
+ {"Parameters", Type, 0, ""},
+ {"Parameters.G", Field, 0, ""},
+ {"Parameters.P", Field, 0, ""},
+ {"Parameters.Q", Field, 0, ""},
+ {"PrivateKey", Type, 0, ""},
+ {"PrivateKey.PublicKey", Field, 0, ""},
+ {"PrivateKey.X", Field, 0, ""},
+ {"PublicKey", Type, 0, ""},
+ {"PublicKey.Parameters", Field, 0, ""},
+ {"PublicKey.Y", Field, 0, ""},
+ {"Sign", Func, 0, "func(rand io.Reader, priv *PrivateKey, hash []byte) (r *big.Int, s *big.Int, err error)"},
+ {"Verify", Func, 0, "func(pub *PublicKey, hash []byte, r *big.Int, s *big.Int) bool"},
+ },
+ "crypto/ecdh": {
+ {"(*PrivateKey).Bytes", Method, 20, ""},
+ {"(*PrivateKey).Curve", Method, 20, ""},
+ {"(*PrivateKey).ECDH", Method, 20, ""},
+ {"(*PrivateKey).Equal", Method, 20, ""},
+ {"(*PrivateKey).Public", Method, 20, ""},
+ {"(*PrivateKey).PublicKey", Method, 20, ""},
+ {"(*PublicKey).Bytes", Method, 20, ""},
+ {"(*PublicKey).Curve", Method, 20, ""},
+ {"(*PublicKey).Equal", Method, 20, ""},
+ {"Curve", Type, 20, ""},
+ {"P256", Func, 20, "func() Curve"},
+ {"P384", Func, 20, "func() Curve"},
+ {"P521", Func, 20, "func() Curve"},
+ {"PrivateKey", Type, 20, ""},
+ {"PublicKey", Type, 20, ""},
+ {"X25519", Func, 20, "func() Curve"},
+ },
+ "crypto/ecdsa": {
+ {"(*PrivateKey).ECDH", Method, 20, ""},
+ {"(*PrivateKey).Equal", Method, 15, ""},
+ {"(*PrivateKey).Public", Method, 4, ""},
+ {"(*PrivateKey).Sign", Method, 4, ""},
+ {"(*PublicKey).ECDH", Method, 20, ""},
+ {"(*PublicKey).Equal", Method, 15, ""},
+ {"(PrivateKey).Add", Method, 0, ""},
+ {"(PrivateKey).Double", Method, 0, ""},
+ {"(PrivateKey).IsOnCurve", Method, 0, ""},
+ {"(PrivateKey).Params", Method, 0, ""},
+ {"(PrivateKey).ScalarBaseMult", Method, 0, ""},
+ {"(PrivateKey).ScalarMult", Method, 0, ""},
+ {"(PublicKey).Add", Method, 0, ""},
+ {"(PublicKey).Double", Method, 0, ""},
+ {"(PublicKey).IsOnCurve", Method, 0, ""},
+ {"(PublicKey).Params", Method, 0, ""},
+ {"(PublicKey).ScalarBaseMult", Method, 0, ""},
+ {"(PublicKey).ScalarMult", Method, 0, ""},
+ {"GenerateKey", Func, 0, "func(c elliptic.Curve, rand io.Reader) (*PrivateKey, error)"},
+ {"PrivateKey", Type, 0, ""},
+ {"PrivateKey.D", Field, 0, ""},
+ {"PrivateKey.PublicKey", Field, 0, ""},
+ {"PublicKey", Type, 0, ""},
+ {"PublicKey.Curve", Field, 0, ""},
+ {"PublicKey.X", Field, 0, ""},
+ {"PublicKey.Y", Field, 0, ""},
+ {"Sign", Func, 0, "func(rand io.Reader, priv *PrivateKey, hash []byte) (r *big.Int, s *big.Int, err error)"},
+ {"SignASN1", Func, 15, "func(rand io.Reader, priv *PrivateKey, hash []byte) ([]byte, error)"},
+ {"Verify", Func, 0, "func(pub *PublicKey, hash []byte, r *big.Int, s *big.Int) bool"},
+ {"VerifyASN1", Func, 15, "func(pub *PublicKey, hash []byte, sig []byte) bool"},
+ },
+ "crypto/ed25519": {
+ {"(*Options).HashFunc", Method, 20, ""},
+ {"(PrivateKey).Equal", Method, 15, ""},
+ {"(PrivateKey).Public", Method, 13, ""},
+ {"(PrivateKey).Seed", Method, 13, ""},
+ {"(PrivateKey).Sign", Method, 13, ""},
+ {"(PublicKey).Equal", Method, 15, ""},
+ {"GenerateKey", Func, 13, "func(rand io.Reader) (PublicKey, PrivateKey, error)"},
+ {"NewKeyFromSeed", Func, 13, "func(seed []byte) PrivateKey"},
+ {"Options", Type, 20, ""},
+ {"Options.Context", Field, 20, ""},
+ {"Options.Hash", Field, 20, ""},
+ {"PrivateKey", Type, 13, ""},
+ {"PrivateKeySize", Const, 13, ""},
+ {"PublicKey", Type, 13, ""},
+ {"PublicKeySize", Const, 13, ""},
+ {"SeedSize", Const, 13, ""},
+ {"Sign", Func, 13, "func(privateKey PrivateKey, message []byte) []byte"},
+ {"SignatureSize", Const, 13, ""},
+ {"Verify", Func, 13, "func(publicKey PublicKey, message []byte, sig []byte) bool"},
+ {"VerifyWithOptions", Func, 20, "func(publicKey PublicKey, message []byte, sig []byte, opts *Options) error"},
+ },
+ "crypto/elliptic": {
+ {"(*CurveParams).Add", Method, 0, ""},
+ {"(*CurveParams).Double", Method, 0, ""},
+ {"(*CurveParams).IsOnCurve", Method, 0, ""},
+ {"(*CurveParams).Params", Method, 0, ""},
+ {"(*CurveParams).ScalarBaseMult", Method, 0, ""},
+ {"(*CurveParams).ScalarMult", Method, 0, ""},
+ {"Curve", Type, 0, ""},
+ {"CurveParams", Type, 0, ""},
+ {"CurveParams.B", Field, 0, ""},
+ {"CurveParams.BitSize", Field, 0, ""},
+ {"CurveParams.Gx", Field, 0, ""},
+ {"CurveParams.Gy", Field, 0, ""},
+ {"CurveParams.N", Field, 0, ""},
+ {"CurveParams.Name", Field, 5, ""},
+ {"CurveParams.P", Field, 0, ""},
+ {"GenerateKey", Func, 0, "func(curve Curve, rand io.Reader) (priv []byte, x *big.Int, y *big.Int, err error)"},
+ {"Marshal", Func, 0, "func(curve Curve, x *big.Int, y *big.Int) []byte"},
+ {"MarshalCompressed", Func, 15, "func(curve Curve, x *big.Int, y *big.Int) []byte"},
+ {"P224", Func, 0, "func() Curve"},
+ {"P256", Func, 0, "func() Curve"},
+ {"P384", Func, 0, "func() Curve"},
+ {"P521", Func, 0, "func() Curve"},
+ {"Unmarshal", Func, 0, "func(curve Curve, data []byte) (x *big.Int, y *big.Int)"},
+ {"UnmarshalCompressed", Func, 15, "func(curve Curve, data []byte) (x *big.Int, y *big.Int)"},
+ },
+ "crypto/fips140": {
+ {"Enabled", Func, 24, "func() bool"},
+ },
+ "crypto/hkdf": {
+ {"Expand", Func, 24, "func[H hash.Hash](h func() H, pseudorandomKey []byte, info string, keyLength int) ([]byte, error)"},
+ {"Extract", Func, 24, "func[H hash.Hash](h func() H, secret []byte, salt []byte) ([]byte, error)"},
+ {"Key", Func, 24, "func[Hash hash.Hash](h func() Hash, secret []byte, salt []byte, info string, keyLength int) ([]byte, error)"},
+ },
+ "crypto/hmac": {
+ {"Equal", Func, 1, "func(mac1 []byte, mac2 []byte) bool"},
+ {"New", Func, 0, "func(h func() hash.Hash, key []byte) hash.Hash"},
+ },
+ "crypto/md5": {
+ {"BlockSize", Const, 0, ""},
+ {"New", Func, 0, "func() hash.Hash"},
+ {"Size", Const, 0, ""},
+ {"Sum", Func, 2, "func(data []byte) [16]byte"},
+ },
+ "crypto/mlkem": {
+ {"(*DecapsulationKey1024).Bytes", Method, 24, ""},
+ {"(*DecapsulationKey1024).Decapsulate", Method, 24, ""},
+ {"(*DecapsulationKey1024).EncapsulationKey", Method, 24, ""},
+ {"(*DecapsulationKey768).Bytes", Method, 24, ""},
+ {"(*DecapsulationKey768).Decapsulate", Method, 24, ""},
+ {"(*DecapsulationKey768).EncapsulationKey", Method, 24, ""},
+ {"(*EncapsulationKey1024).Bytes", Method, 24, ""},
+ {"(*EncapsulationKey1024).Encapsulate", Method, 24, ""},
+ {"(*EncapsulationKey768).Bytes", Method, 24, ""},
+ {"(*EncapsulationKey768).Encapsulate", Method, 24, ""},
+ {"CiphertextSize1024", Const, 24, ""},
+ {"CiphertextSize768", Const, 24, ""},
+ {"DecapsulationKey1024", Type, 24, ""},
+ {"DecapsulationKey768", Type, 24, ""},
+ {"EncapsulationKey1024", Type, 24, ""},
+ {"EncapsulationKey768", Type, 24, ""},
+ {"EncapsulationKeySize1024", Const, 24, ""},
+ {"EncapsulationKeySize768", Const, 24, ""},
+ {"GenerateKey1024", Func, 24, "func() (*DecapsulationKey1024, error)"},
+ {"GenerateKey768", Func, 24, "func() (*DecapsulationKey768, error)"},
+ {"NewDecapsulationKey1024", Func, 24, "func(seed []byte) (*DecapsulationKey1024, error)"},
+ {"NewDecapsulationKey768", Func, 24, "func(seed []byte) (*DecapsulationKey768, error)"},
+ {"NewEncapsulationKey1024", Func, 24, "func(encapsulationKey []byte) (*EncapsulationKey1024, error)"},
+ {"NewEncapsulationKey768", Func, 24, "func(encapsulationKey []byte) (*EncapsulationKey768, error)"},
+ {"SeedSize", Const, 24, ""},
+ {"SharedKeySize", Const, 24, ""},
+ },
+ "crypto/pbkdf2": {
+ {"Key", Func, 24, "func[Hash hash.Hash](h func() Hash, password string, salt []byte, iter int, keyLength int) ([]byte, error)"},
+ },
+ "crypto/rand": {
+ {"Int", Func, 0, "func(rand io.Reader, max *big.Int) (n *big.Int, err error)"},
+ {"Prime", Func, 0, "func(rand io.Reader, bits int) (*big.Int, error)"},
+ {"Read", Func, 0, "func(b []byte) (n int, err error)"},
+ {"Reader", Var, 0, ""},
+ {"Text", Func, 24, "func() string"},
+ },
+ "crypto/rc4": {
+ {"(*Cipher).Reset", Method, 0, ""},
+ {"(*Cipher).XORKeyStream", Method, 0, ""},
+ {"(KeySizeError).Error", Method, 0, ""},
+ {"Cipher", Type, 0, ""},
+ {"KeySizeError", Type, 0, ""},
+ {"NewCipher", Func, 0, "func(key []byte) (*Cipher, error)"},
+ },
+ "crypto/rsa": {
+ {"(*PSSOptions).HashFunc", Method, 4, ""},
+ {"(*PrivateKey).Decrypt", Method, 5, ""},
+ {"(*PrivateKey).Equal", Method, 15, ""},
+ {"(*PrivateKey).Precompute", Method, 0, ""},
+ {"(*PrivateKey).Public", Method, 4, ""},
+ {"(*PrivateKey).Sign", Method, 4, ""},
+ {"(*PrivateKey).Size", Method, 11, ""},
+ {"(*PrivateKey).Validate", Method, 0, ""},
+ {"(*PublicKey).Equal", Method, 15, ""},
+ {"(*PublicKey).Size", Method, 11, ""},
+ {"CRTValue", Type, 0, ""},
+ {"CRTValue.Coeff", Field, 0, ""},
+ {"CRTValue.Exp", Field, 0, ""},
+ {"CRTValue.R", Field, 0, ""},
+ {"DecryptOAEP", Func, 0, "func(hash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) ([]byte, error)"},
+ {"DecryptPKCS1v15", Func, 0, "func(random io.Reader, priv *PrivateKey, ciphertext []byte) ([]byte, error)"},
+ {"DecryptPKCS1v15SessionKey", Func, 0, "func(random io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) error"},
+ {"EncryptOAEP", Func, 0, "func(hash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) ([]byte, error)"},
+ {"EncryptPKCS1v15", Func, 0, "func(random io.Reader, pub *PublicKey, msg []byte) ([]byte, error)"},
+ {"ErrDecryption", Var, 0, ""},
+ {"ErrMessageTooLong", Var, 0, ""},
+ {"ErrVerification", Var, 0, ""},
+ {"GenerateKey", Func, 0, "func(random io.Reader, bits int) (*PrivateKey, error)"},
+ {"GenerateMultiPrimeKey", Func, 0, "func(random io.Reader, nprimes int, bits int) (*PrivateKey, error)"},
+ {"OAEPOptions", Type, 5, ""},
+ {"OAEPOptions.Hash", Field, 5, ""},
+ {"OAEPOptions.Label", Field, 5, ""},
+ {"OAEPOptions.MGFHash", Field, 20, ""},
+ {"PKCS1v15DecryptOptions", Type, 5, ""},
+ {"PKCS1v15DecryptOptions.SessionKeyLen", Field, 5, ""},
+ {"PSSOptions", Type, 2, ""},
+ {"PSSOptions.Hash", Field, 4, ""},
+ {"PSSOptions.SaltLength", Field, 2, ""},
+ {"PSSSaltLengthAuto", Const, 2, ""},
+ {"PSSSaltLengthEqualsHash", Const, 2, ""},
+ {"PrecomputedValues", Type, 0, ""},
+ {"PrecomputedValues.CRTValues", Field, 0, ""},
+ {"PrecomputedValues.Dp", Field, 0, ""},
+ {"PrecomputedValues.Dq", Field, 0, ""},
+ {"PrecomputedValues.Qinv", Field, 0, ""},
+ {"PrivateKey", Type, 0, ""},
+ {"PrivateKey.D", Field, 0, ""},
+ {"PrivateKey.Precomputed", Field, 0, ""},
+ {"PrivateKey.Primes", Field, 0, ""},
+ {"PrivateKey.PublicKey", Field, 0, ""},
+ {"PublicKey", Type, 0, ""},
+ {"PublicKey.E", Field, 0, ""},
+ {"PublicKey.N", Field, 0, ""},
+ {"SignPKCS1v15", Func, 0, "func(random io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) ([]byte, error)"},
+ {"SignPSS", Func, 2, "func(rand io.Reader, priv *PrivateKey, hash crypto.Hash, digest []byte, opts *PSSOptions) ([]byte, error)"},
+ {"VerifyPKCS1v15", Func, 0, "func(pub *PublicKey, hash crypto.Hash, hashed []byte, sig []byte) error"},
+ {"VerifyPSS", Func, 2, "func(pub *PublicKey, hash crypto.Hash, digest []byte, sig []byte, opts *PSSOptions) error"},
+ },
+ "crypto/sha1": {
+ {"BlockSize", Const, 0, ""},
+ {"New", Func, 0, "func() hash.Hash"},
+ {"Size", Const, 0, ""},
+ {"Sum", Func, 2, "func(data []byte) [20]byte"},
+ },
+ "crypto/sha256": {
+ {"BlockSize", Const, 0, ""},
+ {"New", Func, 0, "func() hash.Hash"},
+ {"New224", Func, 0, "func() hash.Hash"},
+ {"Size", Const, 0, ""},
+ {"Size224", Const, 0, ""},
+ {"Sum224", Func, 2, "func(data []byte) [28]byte"},
+ {"Sum256", Func, 2, "func(data []byte) [32]byte"},
+ },
+ "crypto/sha3": {
+ {"(*SHA3).AppendBinary", Method, 24, ""},
+ {"(*SHA3).BlockSize", Method, 24, ""},
+ {"(*SHA3).MarshalBinary", Method, 24, ""},
+ {"(*SHA3).Reset", Method, 24, ""},
+ {"(*SHA3).Size", Method, 24, ""},
+ {"(*SHA3).Sum", Method, 24, ""},
+ {"(*SHA3).UnmarshalBinary", Method, 24, ""},
+ {"(*SHA3).Write", Method, 24, ""},
+ {"(*SHAKE).AppendBinary", Method, 24, ""},
+ {"(*SHAKE).BlockSize", Method, 24, ""},
+ {"(*SHAKE).MarshalBinary", Method, 24, ""},
+ {"(*SHAKE).Read", Method, 24, ""},
+ {"(*SHAKE).Reset", Method, 24, ""},
+ {"(*SHAKE).UnmarshalBinary", Method, 24, ""},
+ {"(*SHAKE).Write", Method, 24, ""},
+ {"New224", Func, 24, "func() *SHA3"},
+ {"New256", Func, 24, "func() *SHA3"},
+ {"New384", Func, 24, "func() *SHA3"},
+ {"New512", Func, 24, "func() *SHA3"},
+ {"NewCSHAKE128", Func, 24, "func(N []byte, S []byte) *SHAKE"},
+ {"NewCSHAKE256", Func, 24, "func(N []byte, S []byte) *SHAKE"},
+ {"NewSHAKE128", Func, 24, "func() *SHAKE"},
+ {"NewSHAKE256", Func, 24, "func() *SHAKE"},
+ {"SHA3", Type, 24, ""},
+ {"SHAKE", Type, 24, ""},
+ {"Sum224", Func, 24, "func(data []byte) [28]byte"},
+ {"Sum256", Func, 24, "func(data []byte) [32]byte"},
+ {"Sum384", Func, 24, "func(data []byte) [48]byte"},
+ {"Sum512", Func, 24, "func(data []byte) [64]byte"},
+ {"SumSHAKE128", Func, 24, "func(data []byte, length int) []byte"},
+ {"SumSHAKE256", Func, 24, "func(data []byte, length int) []byte"},
+ },
+ "crypto/sha512": {
+ {"BlockSize", Const, 0, ""},
+ {"New", Func, 0, "func() hash.Hash"},
+ {"New384", Func, 0, "func() hash.Hash"},
+ {"New512_224", Func, 5, "func() hash.Hash"},
+ {"New512_256", Func, 5, "func() hash.Hash"},
+ {"Size", Const, 0, ""},
+ {"Size224", Const, 5, ""},
+ {"Size256", Const, 5, ""},
+ {"Size384", Const, 0, ""},
+ {"Sum384", Func, 2, "func(data []byte) [48]byte"},
+ {"Sum512", Func, 2, "func(data []byte) [64]byte"},
+ {"Sum512_224", Func, 5, "func(data []byte) [28]byte"},
+ {"Sum512_256", Func, 5, "func(data []byte) [32]byte"},
+ },
+ "crypto/subtle": {
+ {"ConstantTimeByteEq", Func, 0, "func(x uint8, y uint8) int"},
+ {"ConstantTimeCompare", Func, 0, "func(x []byte, y []byte) int"},
+ {"ConstantTimeCopy", Func, 0, "func(v int, x []byte, y []byte)"},
+ {"ConstantTimeEq", Func, 0, "func(x int32, y int32) int"},
+ {"ConstantTimeLessOrEq", Func, 2, "func(x int, y int) int"},
+ {"ConstantTimeSelect", Func, 0, "func(v int, x int, y int) int"},
+ {"WithDataIndependentTiming", Func, 24, "func(f func())"},
+ {"XORBytes", Func, 20, "func(dst []byte, x []byte, y []byte) int"},
+ },
+ "crypto/tls": {
+ {"(*CertificateRequestInfo).Context", Method, 17, ""},
+ {"(*CertificateRequestInfo).SupportsCertificate", Method, 14, ""},
+ {"(*CertificateVerificationError).Error", Method, 20, ""},
+ {"(*CertificateVerificationError).Unwrap", Method, 20, ""},
+ {"(*ClientHelloInfo).Context", Method, 17, ""},
+ {"(*ClientHelloInfo).SupportsCertificate", Method, 14, ""},
+ {"(*ClientSessionState).ResumptionState", Method, 21, ""},
+ {"(*Config).BuildNameToCertificate", Method, 0, ""},
+ {"(*Config).Clone", Method, 8, ""},
+ {"(*Config).DecryptTicket", Method, 21, ""},
+ {"(*Config).EncryptTicket", Method, 21, ""},
+ {"(*Config).SetSessionTicketKeys", Method, 5, ""},
+ {"(*Conn).Close", Method, 0, ""},
+ {"(*Conn).CloseWrite", Method, 8, ""},
+ {"(*Conn).ConnectionState", Method, 0, ""},
+ {"(*Conn).Handshake", Method, 0, ""},
+ {"(*Conn).HandshakeContext", Method, 17, ""},
+ {"(*Conn).LocalAddr", Method, 0, ""},
+ {"(*Conn).NetConn", Method, 18, ""},
+ {"(*Conn).OCSPResponse", Method, 0, ""},
+ {"(*Conn).Read", Method, 0, ""},
+ {"(*Conn).RemoteAddr", Method, 0, ""},
+ {"(*Conn).SetDeadline", Method, 0, ""},
+ {"(*Conn).SetReadDeadline", Method, 0, ""},
+ {"(*Conn).SetWriteDeadline", Method, 0, ""},
+ {"(*Conn).VerifyHostname", Method, 0, ""},
+ {"(*Conn).Write", Method, 0, ""},
+ {"(*ConnectionState).ExportKeyingMaterial", Method, 11, ""},
+ {"(*Dialer).Dial", Method, 15, ""},
+ {"(*Dialer).DialContext", Method, 15, ""},
+ {"(*ECHRejectionError).Error", Method, 23, ""},
+ {"(*QUICConn).Close", Method, 21, ""},
+ {"(*QUICConn).ConnectionState", Method, 21, ""},
+ {"(*QUICConn).HandleData", Method, 21, ""},
+ {"(*QUICConn).NextEvent", Method, 21, ""},
+ {"(*QUICConn).SendSessionTicket", Method, 21, ""},
+ {"(*QUICConn).SetTransportParameters", Method, 21, ""},
+ {"(*QUICConn).Start", Method, 21, ""},
+ {"(*QUICConn).StoreSession", Method, 23, ""},
+ {"(*SessionState).Bytes", Method, 21, ""},
+ {"(AlertError).Error", Method, 21, ""},
+ {"(ClientAuthType).String", Method, 15, ""},
+ {"(CurveID).String", Method, 15, ""},
+ {"(QUICEncryptionLevel).String", Method, 21, ""},
+ {"(RecordHeaderError).Error", Method, 6, ""},
+ {"(SignatureScheme).String", Method, 15, ""},
+ {"AlertError", Type, 21, ""},
+ {"Certificate", Type, 0, ""},
+ {"Certificate.Certificate", Field, 0, ""},
+ {"Certificate.Leaf", Field, 0, ""},
+ {"Certificate.OCSPStaple", Field, 0, ""},
+ {"Certificate.PrivateKey", Field, 0, ""},
+ {"Certificate.SignedCertificateTimestamps", Field, 5, ""},
+ {"Certificate.SupportedSignatureAlgorithms", Field, 14, ""},
+ {"CertificateRequestInfo", Type, 8, ""},
+ {"CertificateRequestInfo.AcceptableCAs", Field, 8, ""},
+ {"CertificateRequestInfo.SignatureSchemes", Field, 8, ""},
+ {"CertificateRequestInfo.Version", Field, 14, ""},
+ {"CertificateVerificationError", Type, 20, ""},
+ {"CertificateVerificationError.Err", Field, 20, ""},
+ {"CertificateVerificationError.UnverifiedCertificates", Field, 20, ""},
+ {"CipherSuite", Type, 14, ""},
+ {"CipherSuite.ID", Field, 14, ""},
+ {"CipherSuite.Insecure", Field, 14, ""},
+ {"CipherSuite.Name", Field, 14, ""},
+ {"CipherSuite.SupportedVersions", Field, 14, ""},
+ {"CipherSuiteName", Func, 14, "func(id uint16) string"},
+ {"CipherSuites", Func, 14, "func() []*CipherSuite"},
+ {"Client", Func, 0, "func(conn net.Conn, config *Config) *Conn"},
+ {"ClientAuthType", Type, 0, ""},
+ {"ClientHelloInfo", Type, 4, ""},
+ {"ClientHelloInfo.CipherSuites", Field, 4, ""},
+ {"ClientHelloInfo.Conn", Field, 8, ""},
+ {"ClientHelloInfo.Extensions", Field, 24, ""},
+ {"ClientHelloInfo.ServerName", Field, 4, ""},
+ {"ClientHelloInfo.SignatureSchemes", Field, 8, ""},
+ {"ClientHelloInfo.SupportedCurves", Field, 4, ""},
+ {"ClientHelloInfo.SupportedPoints", Field, 4, ""},
+ {"ClientHelloInfo.SupportedProtos", Field, 8, ""},
+ {"ClientHelloInfo.SupportedVersions", Field, 8, ""},
+ {"ClientSessionCache", Type, 3, ""},
+ {"ClientSessionState", Type, 3, ""},
+ {"Config", Type, 0, ""},
+ {"Config.Certificates", Field, 0, ""},
+ {"Config.CipherSuites", Field, 0, ""},
+ {"Config.ClientAuth", Field, 0, ""},
+ {"Config.ClientCAs", Field, 0, ""},
+ {"Config.ClientSessionCache", Field, 3, ""},
+ {"Config.CurvePreferences", Field, 3, ""},
+ {"Config.DynamicRecordSizingDisabled", Field, 7, ""},
+ {"Config.EncryptedClientHelloConfigList", Field, 23, ""},
+ {"Config.EncryptedClientHelloKeys", Field, 24, ""},
+ {"Config.EncryptedClientHelloRejectionVerify", Field, 23, ""},
+ {"Config.GetCertificate", Field, 4, ""},
+ {"Config.GetClientCertificate", Field, 8, ""},
+ {"Config.GetConfigForClient", Field, 8, ""},
+ {"Config.InsecureSkipVerify", Field, 0, ""},
+ {"Config.KeyLogWriter", Field, 8, ""},
+ {"Config.MaxVersion", Field, 2, ""},
+ {"Config.MinVersion", Field, 2, ""},
+ {"Config.NameToCertificate", Field, 0, ""},
+ {"Config.NextProtos", Field, 0, ""},
+ {"Config.PreferServerCipherSuites", Field, 1, ""},
+ {"Config.Rand", Field, 0, ""},
+ {"Config.Renegotiation", Field, 7, ""},
+ {"Config.RootCAs", Field, 0, ""},
+ {"Config.ServerName", Field, 0, ""},
+ {"Config.SessionTicketKey", Field, 1, ""},
+ {"Config.SessionTicketsDisabled", Field, 1, ""},
+ {"Config.Time", Field, 0, ""},
+ {"Config.UnwrapSession", Field, 21, ""},
+ {"Config.VerifyConnection", Field, 15, ""},
+ {"Config.VerifyPeerCertificate", Field, 8, ""},
+ {"Config.WrapSession", Field, 21, ""},
+ {"Conn", Type, 0, ""},
+ {"ConnectionState", Type, 0, ""},
+ {"ConnectionState.CipherSuite", Field, 0, ""},
+ {"ConnectionState.CurveID", Field, 25, ""},
+ {"ConnectionState.DidResume", Field, 1, ""},
+ {"ConnectionState.ECHAccepted", Field, 23, ""},
+ {"ConnectionState.HandshakeComplete", Field, 0, ""},
+ {"ConnectionState.NegotiatedProtocol", Field, 0, ""},
+ {"ConnectionState.NegotiatedProtocolIsMutual", Field, 0, ""},
+ {"ConnectionState.OCSPResponse", Field, 5, ""},
+ {"ConnectionState.PeerCertificates", Field, 0, ""},
+ {"ConnectionState.ServerName", Field, 0, ""},
+ {"ConnectionState.SignedCertificateTimestamps", Field, 5, ""},
+ {"ConnectionState.TLSUnique", Field, 4, ""},
+ {"ConnectionState.VerifiedChains", Field, 0, ""},
+ {"ConnectionState.Version", Field, 3, ""},
+ {"CurveID", Type, 3, ""},
+ {"CurveP256", Const, 3, ""},
+ {"CurveP384", Const, 3, ""},
+ {"CurveP521", Const, 3, ""},
+ {"Dial", Func, 0, "func(network string, addr string, config *Config) (*Conn, error)"},
+ {"DialWithDialer", Func, 3, "func(dialer *net.Dialer, network string, addr string, config *Config) (*Conn, error)"},
+ {"Dialer", Type, 15, ""},
+ {"Dialer.Config", Field, 15, ""},
+ {"Dialer.NetDialer", Field, 15, ""},
+ {"ECDSAWithP256AndSHA256", Const, 8, ""},
+ {"ECDSAWithP384AndSHA384", Const, 8, ""},
+ {"ECDSAWithP521AndSHA512", Const, 8, ""},
+ {"ECDSAWithSHA1", Const, 10, ""},
+ {"ECHRejectionError", Type, 23, ""},
+ {"ECHRejectionError.RetryConfigList", Field, 23, ""},
+ {"Ed25519", Const, 13, ""},
+ {"EncryptedClientHelloKey", Type, 24, ""},
+ {"EncryptedClientHelloKey.Config", Field, 24, ""},
+ {"EncryptedClientHelloKey.PrivateKey", Field, 24, ""},
+ {"EncryptedClientHelloKey.SendAsRetry", Field, 24, ""},
+ {"InsecureCipherSuites", Func, 14, "func() []*CipherSuite"},
+ {"Listen", Func, 0, "func(network string, laddr string, config *Config) (net.Listener, error)"},
+ {"LoadX509KeyPair", Func, 0, "func(certFile string, keyFile string) (Certificate, error)"},
+ {"NewLRUClientSessionCache", Func, 3, "func(capacity int) ClientSessionCache"},
+ {"NewListener", Func, 0, "func(inner net.Listener, config *Config) net.Listener"},
+ {"NewResumptionState", Func, 21, "func(ticket []byte, state *SessionState) (*ClientSessionState, error)"},
+ {"NoClientCert", Const, 0, ""},
+ {"PKCS1WithSHA1", Const, 8, ""},
+ {"PKCS1WithSHA256", Const, 8, ""},
+ {"PKCS1WithSHA384", Const, 8, ""},
+ {"PKCS1WithSHA512", Const, 8, ""},
+ {"PSSWithSHA256", Const, 8, ""},
+ {"PSSWithSHA384", Const, 8, ""},
+ {"PSSWithSHA512", Const, 8, ""},
+ {"ParseSessionState", Func, 21, "func(data []byte) (*SessionState, error)"},
+ {"QUICClient", Func, 21, "func(config *QUICConfig) *QUICConn"},
+ {"QUICConfig", Type, 21, ""},
+ {"QUICConfig.EnableSessionEvents", Field, 23, ""},
+ {"QUICConfig.TLSConfig", Field, 21, ""},
+ {"QUICConn", Type, 21, ""},
+ {"QUICEncryptionLevel", Type, 21, ""},
+ {"QUICEncryptionLevelApplication", Const, 21, ""},
+ {"QUICEncryptionLevelEarly", Const, 21, ""},
+ {"QUICEncryptionLevelHandshake", Const, 21, ""},
+ {"QUICEncryptionLevelInitial", Const, 21, ""},
+ {"QUICEvent", Type, 21, ""},
+ {"QUICEvent.Data", Field, 21, ""},
+ {"QUICEvent.Kind", Field, 21, ""},
+ {"QUICEvent.Level", Field, 21, ""},
+ {"QUICEvent.SessionState", Field, 23, ""},
+ {"QUICEvent.Suite", Field, 21, ""},
+ {"QUICEventKind", Type, 21, ""},
+ {"QUICHandshakeDone", Const, 21, ""},
+ {"QUICNoEvent", Const, 21, ""},
+ {"QUICRejectedEarlyData", Const, 21, ""},
+ {"QUICResumeSession", Const, 23, ""},
+ {"QUICServer", Func, 21, "func(config *QUICConfig) *QUICConn"},
+ {"QUICSessionTicketOptions", Type, 21, ""},
+ {"QUICSessionTicketOptions.EarlyData", Field, 21, ""},
+ {"QUICSessionTicketOptions.Extra", Field, 23, ""},
+ {"QUICSetReadSecret", Const, 21, ""},
+ {"QUICSetWriteSecret", Const, 21, ""},
+ {"QUICStoreSession", Const, 23, ""},
+ {"QUICTransportParameters", Const, 21, ""},
+ {"QUICTransportParametersRequired", Const, 21, ""},
+ {"QUICWriteData", Const, 21, ""},
+ {"RecordHeaderError", Type, 6, ""},
+ {"RecordHeaderError.Conn", Field, 12, ""},
+ {"RecordHeaderError.Msg", Field, 6, ""},
+ {"RecordHeaderError.RecordHeader", Field, 6, ""},
+ {"RenegotiateFreelyAsClient", Const, 7, ""},
+ {"RenegotiateNever", Const, 7, ""},
+ {"RenegotiateOnceAsClient", Const, 7, ""},
+ {"RenegotiationSupport", Type, 7, ""},
+ {"RequestClientCert", Const, 0, ""},
+ {"RequireAndVerifyClientCert", Const, 0, ""},
+ {"RequireAnyClientCert", Const, 0, ""},
+ {"Server", Func, 0, "func(conn net.Conn, config *Config) *Conn"},
+ {"SessionState", Type, 21, ""},
+ {"SessionState.EarlyData", Field, 21, ""},
+ {"SessionState.Extra", Field, 21, ""},
+ {"SignatureScheme", Type, 8, ""},
+ {"TLS_AES_128_GCM_SHA256", Const, 12, ""},
+ {"TLS_AES_256_GCM_SHA384", Const, 12, ""},
+ {"TLS_CHACHA20_POLY1305_SHA256", Const, 12, ""},
+ {"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA", Const, 2, ""},
+ {"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256", Const, 8, ""},
+ {"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256", Const, 2, ""},
+ {"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA", Const, 2, ""},
+ {"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384", Const, 5, ""},
+ {"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305", Const, 8, ""},
+ {"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256", Const, 14, ""},
+ {"TLS_ECDHE_ECDSA_WITH_RC4_128_SHA", Const, 2, ""},
+ {"TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA", Const, 0, ""},
+ {"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA", Const, 0, ""},
+ {"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256", Const, 8, ""},
+ {"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", Const, 2, ""},
+ {"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA", Const, 1, ""},
+ {"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384", Const, 5, ""},
+ {"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305", Const, 8, ""},
+ {"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256", Const, 14, ""},
+ {"TLS_ECDHE_RSA_WITH_RC4_128_SHA", Const, 0, ""},
+ {"TLS_FALLBACK_SCSV", Const, 4, ""},
+ {"TLS_RSA_WITH_3DES_EDE_CBC_SHA", Const, 0, ""},
+ {"TLS_RSA_WITH_AES_128_CBC_SHA", Const, 0, ""},
+ {"TLS_RSA_WITH_AES_128_CBC_SHA256", Const, 8, ""},
+ {"TLS_RSA_WITH_AES_128_GCM_SHA256", Const, 6, ""},
+ {"TLS_RSA_WITH_AES_256_CBC_SHA", Const, 1, ""},
+ {"TLS_RSA_WITH_AES_256_GCM_SHA384", Const, 6, ""},
+ {"TLS_RSA_WITH_RC4_128_SHA", Const, 0, ""},
+ {"VerifyClientCertIfGiven", Const, 0, ""},
+ {"VersionName", Func, 21, "func(version uint16) string"},
+ {"VersionSSL30", Const, 2, ""},
+ {"VersionTLS10", Const, 2, ""},
+ {"VersionTLS11", Const, 2, ""},
+ {"VersionTLS12", Const, 2, ""},
+ {"VersionTLS13", Const, 12, ""},
+ {"X25519", Const, 8, ""},
+ {"X25519MLKEM768", Const, 24, ""},
+ {"X509KeyPair", Func, 0, "func(certPEMBlock []byte, keyPEMBlock []byte) (Certificate, error)"},
+ },
+ "crypto/x509": {
+ {"(*CertPool).AddCert", Method, 0, ""},
+ {"(*CertPool).AddCertWithConstraint", Method, 22, ""},
+ {"(*CertPool).AppendCertsFromPEM", Method, 0, ""},
+ {"(*CertPool).Clone", Method, 19, ""},
+ {"(*CertPool).Equal", Method, 19, ""},
+ {"(*CertPool).Subjects", Method, 0, ""},
+ {"(*Certificate).CheckCRLSignature", Method, 0, ""},
+ {"(*Certificate).CheckSignature", Method, 0, ""},
+ {"(*Certificate).CheckSignatureFrom", Method, 0, ""},
+ {"(*Certificate).CreateCRL", Method, 0, ""},
+ {"(*Certificate).Equal", Method, 0, ""},
+ {"(*Certificate).Verify", Method, 0, ""},
+ {"(*Certificate).VerifyHostname", Method, 0, ""},
+ {"(*CertificateRequest).CheckSignature", Method, 5, ""},
+ {"(*OID).UnmarshalBinary", Method, 23, ""},
+ {"(*OID).UnmarshalText", Method, 23, ""},
+ {"(*RevocationList).CheckSignatureFrom", Method, 19, ""},
+ {"(CertificateInvalidError).Error", Method, 0, ""},
+ {"(ConstraintViolationError).Error", Method, 0, ""},
+ {"(HostnameError).Error", Method, 0, ""},
+ {"(InsecureAlgorithmError).Error", Method, 6, ""},
+ {"(OID).AppendBinary", Method, 24, ""},
+ {"(OID).AppendText", Method, 24, ""},
+ {"(OID).Equal", Method, 22, ""},
+ {"(OID).EqualASN1OID", Method, 22, ""},
+ {"(OID).MarshalBinary", Method, 23, ""},
+ {"(OID).MarshalText", Method, 23, ""},
+ {"(OID).String", Method, 22, ""},
+ {"(PublicKeyAlgorithm).String", Method, 10, ""},
+ {"(SignatureAlgorithm).String", Method, 6, ""},
+ {"(SystemRootsError).Error", Method, 1, ""},
+ {"(SystemRootsError).Unwrap", Method, 16, ""},
+ {"(UnhandledCriticalExtension).Error", Method, 0, ""},
+ {"(UnknownAuthorityError).Error", Method, 0, ""},
+ {"CANotAuthorizedForExtKeyUsage", Const, 10, ""},
+ {"CANotAuthorizedForThisName", Const, 0, ""},
+ {"CertPool", Type, 0, ""},
+ {"Certificate", Type, 0, ""},
+ {"Certificate.AuthorityKeyId", Field, 0, ""},
+ {"Certificate.BasicConstraintsValid", Field, 0, ""},
+ {"Certificate.CRLDistributionPoints", Field, 2, ""},
+ {"Certificate.DNSNames", Field, 0, ""},
+ {"Certificate.EmailAddresses", Field, 0, ""},
+ {"Certificate.ExcludedDNSDomains", Field, 9, ""},
+ {"Certificate.ExcludedEmailAddresses", Field, 10, ""},
+ {"Certificate.ExcludedIPRanges", Field, 10, ""},
+ {"Certificate.ExcludedURIDomains", Field, 10, ""},
+ {"Certificate.ExtKeyUsage", Field, 0, ""},
+ {"Certificate.Extensions", Field, 2, ""},
+ {"Certificate.ExtraExtensions", Field, 2, ""},
+ {"Certificate.IPAddresses", Field, 1, ""},
+ {"Certificate.InhibitAnyPolicy", Field, 24, ""},
+ {"Certificate.InhibitAnyPolicyZero", Field, 24, ""},
+ {"Certificate.InhibitPolicyMapping", Field, 24, ""},
+ {"Certificate.InhibitPolicyMappingZero", Field, 24, ""},
+ {"Certificate.IsCA", Field, 0, ""},
+ {"Certificate.Issuer", Field, 0, ""},
+ {"Certificate.IssuingCertificateURL", Field, 2, ""},
+ {"Certificate.KeyUsage", Field, 0, ""},
+ {"Certificate.MaxPathLen", Field, 0, ""},
+ {"Certificate.MaxPathLenZero", Field, 4, ""},
+ {"Certificate.NotAfter", Field, 0, ""},
+ {"Certificate.NotBefore", Field, 0, ""},
+ {"Certificate.OCSPServer", Field, 2, ""},
+ {"Certificate.PermittedDNSDomains", Field, 0, ""},
+ {"Certificate.PermittedDNSDomainsCritical", Field, 0, ""},
+ {"Certificate.PermittedEmailAddresses", Field, 10, ""},
+ {"Certificate.PermittedIPRanges", Field, 10, ""},
+ {"Certificate.PermittedURIDomains", Field, 10, ""},
+ {"Certificate.Policies", Field, 22, ""},
+ {"Certificate.PolicyIdentifiers", Field, 0, ""},
+ {"Certificate.PolicyMappings", Field, 24, ""},
+ {"Certificate.PublicKey", Field, 0, ""},
+ {"Certificate.PublicKeyAlgorithm", Field, 0, ""},
+ {"Certificate.Raw", Field, 0, ""},
+ {"Certificate.RawIssuer", Field, 0, ""},
+ {"Certificate.RawSubject", Field, 0, ""},
+ {"Certificate.RawSubjectPublicKeyInfo", Field, 0, ""},
+ {"Certificate.RawTBSCertificate", Field, 0, ""},
+ {"Certificate.RequireExplicitPolicy", Field, 24, ""},
+ {"Certificate.RequireExplicitPolicyZero", Field, 24, ""},
+ {"Certificate.SerialNumber", Field, 0, ""},
+ {"Certificate.Signature", Field, 0, ""},
+ {"Certificate.SignatureAlgorithm", Field, 0, ""},
+ {"Certificate.Subject", Field, 0, ""},
+ {"Certificate.SubjectKeyId", Field, 0, ""},
+ {"Certificate.URIs", Field, 10, ""},
+ {"Certificate.UnhandledCriticalExtensions", Field, 5, ""},
+ {"Certificate.UnknownExtKeyUsage", Field, 0, ""},
+ {"Certificate.Version", Field, 0, ""},
+ {"CertificateInvalidError", Type, 0, ""},
+ {"CertificateInvalidError.Cert", Field, 0, ""},
+ {"CertificateInvalidError.Detail", Field, 10, ""},
+ {"CertificateInvalidError.Reason", Field, 0, ""},
+ {"CertificateRequest", Type, 3, ""},
+ {"CertificateRequest.Attributes", Field, 3, ""},
+ {"CertificateRequest.DNSNames", Field, 3, ""},
+ {"CertificateRequest.EmailAddresses", Field, 3, ""},
+ {"CertificateRequest.Extensions", Field, 3, ""},
+ {"CertificateRequest.ExtraExtensions", Field, 3, ""},
+ {"CertificateRequest.IPAddresses", Field, 3, ""},
+ {"CertificateRequest.PublicKey", Field, 3, ""},
+ {"CertificateRequest.PublicKeyAlgorithm", Field, 3, ""},
+ {"CertificateRequest.Raw", Field, 3, ""},
+ {"CertificateRequest.RawSubject", Field, 3, ""},
+ {"CertificateRequest.RawSubjectPublicKeyInfo", Field, 3, ""},
+ {"CertificateRequest.RawTBSCertificateRequest", Field, 3, ""},
+ {"CertificateRequest.Signature", Field, 3, ""},
+ {"CertificateRequest.SignatureAlgorithm", Field, 3, ""},
+ {"CertificateRequest.Subject", Field, 3, ""},
+ {"CertificateRequest.URIs", Field, 10, ""},
+ {"CertificateRequest.Version", Field, 3, ""},
+ {"ConstraintViolationError", Type, 0, ""},
+ {"CreateCertificate", Func, 0, "func(rand io.Reader, template *Certificate, parent *Certificate, pub any, priv any) ([]byte, error)"},
+ {"CreateCertificateRequest", Func, 3, "func(rand io.Reader, template *CertificateRequest, priv any) (csr []byte, err error)"},
+ {"CreateRevocationList", Func, 15, "func(rand io.Reader, template *RevocationList, issuer *Certificate, priv crypto.Signer) ([]byte, error)"},
+ {"DSA", Const, 0, ""},
+ {"DSAWithSHA1", Const, 0, ""},
+ {"DSAWithSHA256", Const, 0, ""},
+ {"DecryptPEMBlock", Func, 1, "func(b *pem.Block, password []byte) ([]byte, error)"},
+ {"ECDSA", Const, 1, ""},
+ {"ECDSAWithSHA1", Const, 1, ""},
+ {"ECDSAWithSHA256", Const, 1, ""},
+ {"ECDSAWithSHA384", Const, 1, ""},
+ {"ECDSAWithSHA512", Const, 1, ""},
+ {"Ed25519", Const, 13, ""},
+ {"EncryptPEMBlock", Func, 1, "func(rand io.Reader, blockType string, data []byte, password []byte, alg PEMCipher) (*pem.Block, error)"},
+ {"ErrUnsupportedAlgorithm", Var, 0, ""},
+ {"Expired", Const, 0, ""},
+ {"ExtKeyUsage", Type, 0, ""},
+ {"ExtKeyUsageAny", Const, 0, ""},
+ {"ExtKeyUsageClientAuth", Const, 0, ""},
+ {"ExtKeyUsageCodeSigning", Const, 0, ""},
+ {"ExtKeyUsageEmailProtection", Const, 0, ""},
+ {"ExtKeyUsageIPSECEndSystem", Const, 1, ""},
+ {"ExtKeyUsageIPSECTunnel", Const, 1, ""},
+ {"ExtKeyUsageIPSECUser", Const, 1, ""},
+ {"ExtKeyUsageMicrosoftCommercialCodeSigning", Const, 10, ""},
+ {"ExtKeyUsageMicrosoftKernelCodeSigning", Const, 10, ""},
+ {"ExtKeyUsageMicrosoftServerGatedCrypto", Const, 1, ""},
+ {"ExtKeyUsageNetscapeServerGatedCrypto", Const, 1, ""},
+ {"ExtKeyUsageOCSPSigning", Const, 0, ""},
+ {"ExtKeyUsageServerAuth", Const, 0, ""},
+ {"ExtKeyUsageTimeStamping", Const, 0, ""},
+ {"HostnameError", Type, 0, ""},
+ {"HostnameError.Certificate", Field, 0, ""},
+ {"HostnameError.Host", Field, 0, ""},
+ {"IncompatibleUsage", Const, 1, ""},
+ {"IncorrectPasswordError", Var, 1, ""},
+ {"InsecureAlgorithmError", Type, 6, ""},
+ {"InvalidReason", Type, 0, ""},
+ {"IsEncryptedPEMBlock", Func, 1, "func(b *pem.Block) bool"},
+ {"KeyUsage", Type, 0, ""},
+ {"KeyUsageCRLSign", Const, 0, ""},
+ {"KeyUsageCertSign", Const, 0, ""},
+ {"KeyUsageContentCommitment", Const, 0, ""},
+ {"KeyUsageDataEncipherment", Const, 0, ""},
+ {"KeyUsageDecipherOnly", Const, 0, ""},
+ {"KeyUsageDigitalSignature", Const, 0, ""},
+ {"KeyUsageEncipherOnly", Const, 0, ""},
+ {"KeyUsageKeyAgreement", Const, 0, ""},
+ {"KeyUsageKeyEncipherment", Const, 0, ""},
+ {"MD2WithRSA", Const, 0, ""},
+ {"MD5WithRSA", Const, 0, ""},
+ {"MarshalECPrivateKey", Func, 2, "func(key *ecdsa.PrivateKey) ([]byte, error)"},
+ {"MarshalPKCS1PrivateKey", Func, 0, "func(key *rsa.PrivateKey) []byte"},
+ {"MarshalPKCS1PublicKey", Func, 10, "func(key *rsa.PublicKey) []byte"},
+ {"MarshalPKCS8PrivateKey", Func, 10, "func(key any) ([]byte, error)"},
+ {"MarshalPKIXPublicKey", Func, 0, "func(pub any) ([]byte, error)"},
+ {"NameConstraintsWithoutSANs", Const, 10, ""},
+ {"NameMismatch", Const, 8, ""},
+ {"NewCertPool", Func, 0, "func() *CertPool"},
+ {"NoValidChains", Const, 24, ""},
+ {"NotAuthorizedToSign", Const, 0, ""},
+ {"OID", Type, 22, ""},
+ {"OIDFromInts", Func, 22, "func(oid []uint64) (OID, error)"},
+ {"PEMCipher", Type, 1, ""},
+ {"PEMCipher3DES", Const, 1, ""},
+ {"PEMCipherAES128", Const, 1, ""},
+ {"PEMCipherAES192", Const, 1, ""},
+ {"PEMCipherAES256", Const, 1, ""},
+ {"PEMCipherDES", Const, 1, ""},
+ {"ParseCRL", Func, 0, "func(crlBytes []byte) (*pkix.CertificateList, error)"},
+ {"ParseCertificate", Func, 0, "func(der []byte) (*Certificate, error)"},
+ {"ParseCertificateRequest", Func, 3, "func(asn1Data []byte) (*CertificateRequest, error)"},
+ {"ParseCertificates", Func, 0, "func(der []byte) ([]*Certificate, error)"},
+ {"ParseDERCRL", Func, 0, "func(derBytes []byte) (*pkix.CertificateList, error)"},
+ {"ParseECPrivateKey", Func, 1, "func(der []byte) (*ecdsa.PrivateKey, error)"},
+ {"ParseOID", Func, 23, "func(oid string) (OID, error)"},
+ {"ParsePKCS1PrivateKey", Func, 0, "func(der []byte) (*rsa.PrivateKey, error)"},
+ {"ParsePKCS1PublicKey", Func, 10, "func(der []byte) (*rsa.PublicKey, error)"},
+ {"ParsePKCS8PrivateKey", Func, 0, "func(der []byte) (key any, err error)"},
+ {"ParsePKIXPublicKey", Func, 0, "func(derBytes []byte) (pub any, err error)"},
+ {"ParseRevocationList", Func, 19, "func(der []byte) (*RevocationList, error)"},
+ {"PolicyMapping", Type, 24, ""},
+ {"PolicyMapping.IssuerDomainPolicy", Field, 24, ""},
+ {"PolicyMapping.SubjectDomainPolicy", Field, 24, ""},
+ {"PublicKeyAlgorithm", Type, 0, ""},
+ {"PureEd25519", Const, 13, ""},
+ {"RSA", Const, 0, ""},
+ {"RevocationList", Type, 15, ""},
+ {"RevocationList.AuthorityKeyId", Field, 19, ""},
+ {"RevocationList.Extensions", Field, 19, ""},
+ {"RevocationList.ExtraExtensions", Field, 15, ""},
+ {"RevocationList.Issuer", Field, 19, ""},
+ {"RevocationList.NextUpdate", Field, 15, ""},
+ {"RevocationList.Number", Field, 15, ""},
+ {"RevocationList.Raw", Field, 19, ""},
+ {"RevocationList.RawIssuer", Field, 19, ""},
+ {"RevocationList.RawTBSRevocationList", Field, 19, ""},
+ {"RevocationList.RevokedCertificateEntries", Field, 21, ""},
+ {"RevocationList.RevokedCertificates", Field, 15, ""},
+ {"RevocationList.Signature", Field, 19, ""},
+ {"RevocationList.SignatureAlgorithm", Field, 15, ""},
+ {"RevocationList.ThisUpdate", Field, 15, ""},
+ {"RevocationListEntry", Type, 21, ""},
+ {"RevocationListEntry.Extensions", Field, 21, ""},
+ {"RevocationListEntry.ExtraExtensions", Field, 21, ""},
+ {"RevocationListEntry.Raw", Field, 21, ""},
+ {"RevocationListEntry.ReasonCode", Field, 21, ""},
+ {"RevocationListEntry.RevocationTime", Field, 21, ""},
+ {"RevocationListEntry.SerialNumber", Field, 21, ""},
+ {"SHA1WithRSA", Const, 0, ""},
+ {"SHA256WithRSA", Const, 0, ""},
+ {"SHA256WithRSAPSS", Const, 8, ""},
+ {"SHA384WithRSA", Const, 0, ""},
+ {"SHA384WithRSAPSS", Const, 8, ""},
+ {"SHA512WithRSA", Const, 0, ""},
+ {"SHA512WithRSAPSS", Const, 8, ""},
+ {"SetFallbackRoots", Func, 20, "func(roots *CertPool)"},
+ {"SignatureAlgorithm", Type, 0, ""},
+ {"SystemCertPool", Func, 7, "func() (*CertPool, error)"},
+ {"SystemRootsError", Type, 1, ""},
+ {"SystemRootsError.Err", Field, 7, ""},
+ {"TooManyConstraints", Const, 10, ""},
+ {"TooManyIntermediates", Const, 0, ""},
+ {"UnconstrainedName", Const, 10, ""},
+ {"UnhandledCriticalExtension", Type, 0, ""},
+ {"UnknownAuthorityError", Type, 0, ""},
+ {"UnknownAuthorityError.Cert", Field, 8, ""},
+ {"UnknownPublicKeyAlgorithm", Const, 0, ""},
+ {"UnknownSignatureAlgorithm", Const, 0, ""},
+ {"VerifyOptions", Type, 0, ""},
+ {"VerifyOptions.CertificatePolicies", Field, 24, ""},
+ {"VerifyOptions.CurrentTime", Field, 0, ""},
+ {"VerifyOptions.DNSName", Field, 0, ""},
+ {"VerifyOptions.Intermediates", Field, 0, ""},
+ {"VerifyOptions.KeyUsages", Field, 1, ""},
+ {"VerifyOptions.MaxConstraintComparisions", Field, 10, ""},
+ {"VerifyOptions.Roots", Field, 0, ""},
+ },
+ "crypto/x509/pkix": {
+ {"(*CertificateList).HasExpired", Method, 0, ""},
+ {"(*Name).FillFromRDNSequence", Method, 0, ""},
+ {"(Name).String", Method, 10, ""},
+ {"(Name).ToRDNSequence", Method, 0, ""},
+ {"(RDNSequence).String", Method, 10, ""},
+ {"AlgorithmIdentifier", Type, 0, ""},
+ {"AlgorithmIdentifier.Algorithm", Field, 0, ""},
+ {"AlgorithmIdentifier.Parameters", Field, 0, ""},
+ {"AttributeTypeAndValue", Type, 0, ""},
+ {"AttributeTypeAndValue.Type", Field, 0, ""},
+ {"AttributeTypeAndValue.Value", Field, 0, ""},
+ {"AttributeTypeAndValueSET", Type, 3, ""},
+ {"AttributeTypeAndValueSET.Type", Field, 3, ""},
+ {"AttributeTypeAndValueSET.Value", Field, 3, ""},
+ {"CertificateList", Type, 0, ""},
+ {"CertificateList.SignatureAlgorithm", Field, 0, ""},
+ {"CertificateList.SignatureValue", Field, 0, ""},
+ {"CertificateList.TBSCertList", Field, 0, ""},
+ {"Extension", Type, 0, ""},
+ {"Extension.Critical", Field, 0, ""},
+ {"Extension.Id", Field, 0, ""},
+ {"Extension.Value", Field, 0, ""},
+ {"Name", Type, 0, ""},
+ {"Name.CommonName", Field, 0, ""},
+ {"Name.Country", Field, 0, ""},
+ {"Name.ExtraNames", Field, 5, ""},
+ {"Name.Locality", Field, 0, ""},
+ {"Name.Names", Field, 0, ""},
+ {"Name.Organization", Field, 0, ""},
+ {"Name.OrganizationalUnit", Field, 0, ""},
+ {"Name.PostalCode", Field, 0, ""},
+ {"Name.Province", Field, 0, ""},
+ {"Name.SerialNumber", Field, 0, ""},
+ {"Name.StreetAddress", Field, 0, ""},
+ {"RDNSequence", Type, 0, ""},
+ {"RelativeDistinguishedNameSET", Type, 0, ""},
+ {"RevokedCertificate", Type, 0, ""},
+ {"RevokedCertificate.Extensions", Field, 0, ""},
+ {"RevokedCertificate.RevocationTime", Field, 0, ""},
+ {"RevokedCertificate.SerialNumber", Field, 0, ""},
+ {"TBSCertificateList", Type, 0, ""},
+ {"TBSCertificateList.Extensions", Field, 0, ""},
+ {"TBSCertificateList.Issuer", Field, 0, ""},
+ {"TBSCertificateList.NextUpdate", Field, 0, ""},
+ {"TBSCertificateList.Raw", Field, 0, ""},
+ {"TBSCertificateList.RevokedCertificates", Field, 0, ""},
+ {"TBSCertificateList.Signature", Field, 0, ""},
+ {"TBSCertificateList.ThisUpdate", Field, 0, ""},
+ {"TBSCertificateList.Version", Field, 0, ""},
+ },
+ "database/sql": {
+ {"(*ColumnType).DatabaseTypeName", Method, 8, ""},
+ {"(*ColumnType).DecimalSize", Method, 8, ""},
+ {"(*ColumnType).Length", Method, 8, ""},
+ {"(*ColumnType).Name", Method, 8, ""},
+ {"(*ColumnType).Nullable", Method, 8, ""},
+ {"(*ColumnType).ScanType", Method, 8, ""},
+ {"(*Conn).BeginTx", Method, 9, ""},
+ {"(*Conn).Close", Method, 9, ""},
+ {"(*Conn).ExecContext", Method, 9, ""},
+ {"(*Conn).PingContext", Method, 9, ""},
+ {"(*Conn).PrepareContext", Method, 9, ""},
+ {"(*Conn).QueryContext", Method, 9, ""},
+ {"(*Conn).QueryRowContext", Method, 9, ""},
+ {"(*Conn).Raw", Method, 13, ""},
+ {"(*DB).Begin", Method, 0, ""},
+ {"(*DB).BeginTx", Method, 8, ""},
+ {"(*DB).Close", Method, 0, ""},
+ {"(*DB).Conn", Method, 9, ""},
+ {"(*DB).Driver", Method, 0, ""},
+ {"(*DB).Exec", Method, 0, ""},
+ {"(*DB).ExecContext", Method, 8, ""},
+ {"(*DB).Ping", Method, 1, ""},
+ {"(*DB).PingContext", Method, 8, ""},
+ {"(*DB).Prepare", Method, 0, ""},
+ {"(*DB).PrepareContext", Method, 8, ""},
+ {"(*DB).Query", Method, 0, ""},
+ {"(*DB).QueryContext", Method, 8, ""},
+ {"(*DB).QueryRow", Method, 0, ""},
+ {"(*DB).QueryRowContext", Method, 8, ""},
+ {"(*DB).SetConnMaxIdleTime", Method, 15, ""},
+ {"(*DB).SetConnMaxLifetime", Method, 6, ""},
+ {"(*DB).SetMaxIdleConns", Method, 1, ""},
+ {"(*DB).SetMaxOpenConns", Method, 2, ""},
+ {"(*DB).Stats", Method, 5, ""},
+ {"(*Null).Scan", Method, 22, ""},
+ {"(*NullBool).Scan", Method, 0, ""},
+ {"(*NullByte).Scan", Method, 17, ""},
+ {"(*NullFloat64).Scan", Method, 0, ""},
+ {"(*NullInt16).Scan", Method, 17, ""},
+ {"(*NullInt32).Scan", Method, 13, ""},
+ {"(*NullInt64).Scan", Method, 0, ""},
+ {"(*NullString).Scan", Method, 0, ""},
+ {"(*NullTime).Scan", Method, 13, ""},
+ {"(*Row).Err", Method, 15, ""},
+ {"(*Row).Scan", Method, 0, ""},
+ {"(*Rows).Close", Method, 0, ""},
+ {"(*Rows).ColumnTypes", Method, 8, ""},
+ {"(*Rows).Columns", Method, 0, ""},
+ {"(*Rows).Err", Method, 0, ""},
+ {"(*Rows).Next", Method, 0, ""},
+ {"(*Rows).NextResultSet", Method, 8, ""},
+ {"(*Rows).Scan", Method, 0, ""},
+ {"(*Stmt).Close", Method, 0, ""},
+ {"(*Stmt).Exec", Method, 0, ""},
+ {"(*Stmt).ExecContext", Method, 8, ""},
+ {"(*Stmt).Query", Method, 0, ""},
+ {"(*Stmt).QueryContext", Method, 8, ""},
+ {"(*Stmt).QueryRow", Method, 0, ""},
+ {"(*Stmt).QueryRowContext", Method, 8, ""},
+ {"(*Tx).Commit", Method, 0, ""},
+ {"(*Tx).Exec", Method, 0, ""},
+ {"(*Tx).ExecContext", Method, 8, ""},
+ {"(*Tx).Prepare", Method, 0, ""},
+ {"(*Tx).PrepareContext", Method, 8, ""},
+ {"(*Tx).Query", Method, 0, ""},
+ {"(*Tx).QueryContext", Method, 8, ""},
+ {"(*Tx).QueryRow", Method, 0, ""},
+ {"(*Tx).QueryRowContext", Method, 8, ""},
+ {"(*Tx).Rollback", Method, 0, ""},
+ {"(*Tx).Stmt", Method, 0, ""},
+ {"(*Tx).StmtContext", Method, 8, ""},
+ {"(IsolationLevel).String", Method, 11, ""},
+ {"(Null).Value", Method, 22, ""},
+ {"(NullBool).Value", Method, 0, ""},
+ {"(NullByte).Value", Method, 17, ""},
+ {"(NullFloat64).Value", Method, 0, ""},
+ {"(NullInt16).Value", Method, 17, ""},
+ {"(NullInt32).Value", Method, 13, ""},
+ {"(NullInt64).Value", Method, 0, ""},
+ {"(NullString).Value", Method, 0, ""},
+ {"(NullTime).Value", Method, 13, ""},
+ {"ColumnType", Type, 8, ""},
+ {"Conn", Type, 9, ""},
+ {"DB", Type, 0, ""},
+ {"DBStats", Type, 5, ""},
+ {"DBStats.Idle", Field, 11, ""},
+ {"DBStats.InUse", Field, 11, ""},
+ {"DBStats.MaxIdleClosed", Field, 11, ""},
+ {"DBStats.MaxIdleTimeClosed", Field, 15, ""},
+ {"DBStats.MaxLifetimeClosed", Field, 11, ""},
+ {"DBStats.MaxOpenConnections", Field, 11, ""},
+ {"DBStats.OpenConnections", Field, 5, ""},
+ {"DBStats.WaitCount", Field, 11, ""},
+ {"DBStats.WaitDuration", Field, 11, ""},
+ {"Drivers", Func, 4, "func() []string"},
+ {"ErrConnDone", Var, 9, ""},
+ {"ErrNoRows", Var, 0, ""},
+ {"ErrTxDone", Var, 0, ""},
+ {"IsolationLevel", Type, 8, ""},
+ {"LevelDefault", Const, 8, ""},
+ {"LevelLinearizable", Const, 8, ""},
+ {"LevelReadCommitted", Const, 8, ""},
+ {"LevelReadUncommitted", Const, 8, ""},
+ {"LevelRepeatableRead", Const, 8, ""},
+ {"LevelSerializable", Const, 8, ""},
+ {"LevelSnapshot", Const, 8, ""},
+ {"LevelWriteCommitted", Const, 8, ""},
+ {"Named", Func, 8, "func(name string, value any) NamedArg"},
+ {"NamedArg", Type, 8, ""},
+ {"NamedArg.Name", Field, 8, ""},
+ {"NamedArg.Value", Field, 8, ""},
+ {"Null", Type, 22, ""},
+ {"Null.V", Field, 22, ""},
+ {"Null.Valid", Field, 22, ""},
+ {"NullBool", Type, 0, ""},
+ {"NullBool.Bool", Field, 0, ""},
+ {"NullBool.Valid", Field, 0, ""},
+ {"NullByte", Type, 17, ""},
+ {"NullByte.Byte", Field, 17, ""},
+ {"NullByte.Valid", Field, 17, ""},
+ {"NullFloat64", Type, 0, ""},
+ {"NullFloat64.Float64", Field, 0, ""},
+ {"NullFloat64.Valid", Field, 0, ""},
+ {"NullInt16", Type, 17, ""},
+ {"NullInt16.Int16", Field, 17, ""},
+ {"NullInt16.Valid", Field, 17, ""},
+ {"NullInt32", Type, 13, ""},
+ {"NullInt32.Int32", Field, 13, ""},
+ {"NullInt32.Valid", Field, 13, ""},
+ {"NullInt64", Type, 0, ""},
+ {"NullInt64.Int64", Field, 0, ""},
+ {"NullInt64.Valid", Field, 0, ""},
+ {"NullString", Type, 0, ""},
+ {"NullString.String", Field, 0, ""},
+ {"NullString.Valid", Field, 0, ""},
+ {"NullTime", Type, 13, ""},
+ {"NullTime.Time", Field, 13, ""},
+ {"NullTime.Valid", Field, 13, ""},
+ {"Open", Func, 0, "func(driverName string, dataSourceName string) (*DB, error)"},
+ {"OpenDB", Func, 10, "func(c driver.Connector) *DB"},
+ {"Out", Type, 9, ""},
+ {"Out.Dest", Field, 9, ""},
+ {"Out.In", Field, 9, ""},
+ {"RawBytes", Type, 0, ""},
+ {"Register", Func, 0, "func(name string, driver driver.Driver)"},
+ {"Result", Type, 0, ""},
+ {"Row", Type, 0, ""},
+ {"Rows", Type, 0, ""},
+ {"Scanner", Type, 0, ""},
+ {"Stmt", Type, 0, ""},
+ {"Tx", Type, 0, ""},
+ {"TxOptions", Type, 8, ""},
+ {"TxOptions.Isolation", Field, 8, ""},
+ {"TxOptions.ReadOnly", Field, 8, ""},
+ },
+ "database/sql/driver": {
+ {"(NotNull).ConvertValue", Method, 0, ""},
+ {"(Null).ConvertValue", Method, 0, ""},
+ {"(RowsAffected).LastInsertId", Method, 0, ""},
+ {"(RowsAffected).RowsAffected", Method, 0, ""},
+ {"Bool", Var, 0, ""},
+ {"ColumnConverter", Type, 0, ""},
+ {"Conn", Type, 0, ""},
+ {"ConnBeginTx", Type, 8, ""},
+ {"ConnPrepareContext", Type, 8, ""},
+ {"Connector", Type, 10, ""},
+ {"DefaultParameterConverter", Var, 0, ""},
+ {"Driver", Type, 0, ""},
+ {"DriverContext", Type, 10, ""},
+ {"ErrBadConn", Var, 0, ""},
+ {"ErrRemoveArgument", Var, 9, ""},
+ {"ErrSkip", Var, 0, ""},
+ {"Execer", Type, 0, ""},
+ {"ExecerContext", Type, 8, ""},
+ {"Int32", Var, 0, ""},
+ {"IsScanValue", Func, 0, "func(v any) bool"},
+ {"IsValue", Func, 0, "func(v any) bool"},
+ {"IsolationLevel", Type, 8, ""},
+ {"NamedValue", Type, 8, ""},
+ {"NamedValue.Name", Field, 8, ""},
+ {"NamedValue.Ordinal", Field, 8, ""},
+ {"NamedValue.Value", Field, 8, ""},
+ {"NamedValueChecker", Type, 9, ""},
+ {"NotNull", Type, 0, ""},
+ {"NotNull.Converter", Field, 0, ""},
+ {"Null", Type, 0, ""},
+ {"Null.Converter", Field, 0, ""},
+ {"Pinger", Type, 8, ""},
+ {"Queryer", Type, 1, ""},
+ {"QueryerContext", Type, 8, ""},
+ {"Result", Type, 0, ""},
+ {"ResultNoRows", Var, 0, ""},
+ {"Rows", Type, 0, ""},
+ {"RowsAffected", Type, 0, ""},
+ {"RowsColumnTypeDatabaseTypeName", Type, 8, ""},
+ {"RowsColumnTypeLength", Type, 8, ""},
+ {"RowsColumnTypeNullable", Type, 8, ""},
+ {"RowsColumnTypePrecisionScale", Type, 8, ""},
+ {"RowsColumnTypeScanType", Type, 8, ""},
+ {"RowsNextResultSet", Type, 8, ""},
+ {"SessionResetter", Type, 10, ""},
+ {"Stmt", Type, 0, ""},
+ {"StmtExecContext", Type, 8, ""},
+ {"StmtQueryContext", Type, 8, ""},
+ {"String", Var, 0, ""},
+ {"Tx", Type, 0, ""},
+ {"TxOptions", Type, 8, ""},
+ {"TxOptions.Isolation", Field, 8, ""},
+ {"TxOptions.ReadOnly", Field, 8, ""},
+ {"Validator", Type, 15, ""},
+ {"Value", Type, 0, ""},
+ {"ValueConverter", Type, 0, ""},
+ {"Valuer", Type, 0, ""},
+ },
+ "debug/buildinfo": {
+ {"BuildInfo", Type, 18, ""},
+ {"Read", Func, 18, "func(r io.ReaderAt) (*BuildInfo, error)"},
+ {"ReadFile", Func, 18, "func(name string) (info *BuildInfo, err error)"},
+ },
+ "debug/dwarf": {
+ {"(*AddrType).Basic", Method, 0, ""},
+ {"(*AddrType).Common", Method, 0, ""},
+ {"(*AddrType).Size", Method, 0, ""},
+ {"(*AddrType).String", Method, 0, ""},
+ {"(*ArrayType).Common", Method, 0, ""},
+ {"(*ArrayType).Size", Method, 0, ""},
+ {"(*ArrayType).String", Method, 0, ""},
+ {"(*BasicType).Basic", Method, 0, ""},
+ {"(*BasicType).Common", Method, 0, ""},
+ {"(*BasicType).Size", Method, 0, ""},
+ {"(*BasicType).String", Method, 0, ""},
+ {"(*BoolType).Basic", Method, 0, ""},
+ {"(*BoolType).Common", Method, 0, ""},
+ {"(*BoolType).Size", Method, 0, ""},
+ {"(*BoolType).String", Method, 0, ""},
+ {"(*CharType).Basic", Method, 0, ""},
+ {"(*CharType).Common", Method, 0, ""},
+ {"(*CharType).Size", Method, 0, ""},
+ {"(*CharType).String", Method, 0, ""},
+ {"(*CommonType).Common", Method, 0, ""},
+ {"(*CommonType).Size", Method, 0, ""},
+ {"(*ComplexType).Basic", Method, 0, ""},
+ {"(*ComplexType).Common", Method, 0, ""},
+ {"(*ComplexType).Size", Method, 0, ""},
+ {"(*ComplexType).String", Method, 0, ""},
+ {"(*Data).AddSection", Method, 14, ""},
+ {"(*Data).AddTypes", Method, 3, ""},
+ {"(*Data).LineReader", Method, 5, ""},
+ {"(*Data).Ranges", Method, 7, ""},
+ {"(*Data).Reader", Method, 0, ""},
+ {"(*Data).Type", Method, 0, ""},
+ {"(*DotDotDotType).Common", Method, 0, ""},
+ {"(*DotDotDotType).Size", Method, 0, ""},
+ {"(*DotDotDotType).String", Method, 0, ""},
+ {"(*Entry).AttrField", Method, 5, ""},
+ {"(*Entry).Val", Method, 0, ""},
+ {"(*EnumType).Common", Method, 0, ""},
+ {"(*EnumType).Size", Method, 0, ""},
+ {"(*EnumType).String", Method, 0, ""},
+ {"(*FloatType).Basic", Method, 0, ""},
+ {"(*FloatType).Common", Method, 0, ""},
+ {"(*FloatType).Size", Method, 0, ""},
+ {"(*FloatType).String", Method, 0, ""},
+ {"(*FuncType).Common", Method, 0, ""},
+ {"(*FuncType).Size", Method, 0, ""},
+ {"(*FuncType).String", Method, 0, ""},
+ {"(*IntType).Basic", Method, 0, ""},
+ {"(*IntType).Common", Method, 0, ""},
+ {"(*IntType).Size", Method, 0, ""},
+ {"(*IntType).String", Method, 0, ""},
+ {"(*LineReader).Files", Method, 14, ""},
+ {"(*LineReader).Next", Method, 5, ""},
+ {"(*LineReader).Reset", Method, 5, ""},
+ {"(*LineReader).Seek", Method, 5, ""},
+ {"(*LineReader).SeekPC", Method, 5, ""},
+ {"(*LineReader).Tell", Method, 5, ""},
+ {"(*PtrType).Common", Method, 0, ""},
+ {"(*PtrType).Size", Method, 0, ""},
+ {"(*PtrType).String", Method, 0, ""},
+ {"(*QualType).Common", Method, 0, ""},
+ {"(*QualType).Size", Method, 0, ""},
+ {"(*QualType).String", Method, 0, ""},
+ {"(*Reader).AddressSize", Method, 5, ""},
+ {"(*Reader).ByteOrder", Method, 14, ""},
+ {"(*Reader).Next", Method, 0, ""},
+ {"(*Reader).Seek", Method, 0, ""},
+ {"(*Reader).SeekPC", Method, 7, ""},
+ {"(*Reader).SkipChildren", Method, 0, ""},
+ {"(*StructType).Common", Method, 0, ""},
+ {"(*StructType).Defn", Method, 0, ""},
+ {"(*StructType).Size", Method, 0, ""},
+ {"(*StructType).String", Method, 0, ""},
+ {"(*TypedefType).Common", Method, 0, ""},
+ {"(*TypedefType).Size", Method, 0, ""},
+ {"(*TypedefType).String", Method, 0, ""},
+ {"(*UcharType).Basic", Method, 0, ""},
+ {"(*UcharType).Common", Method, 0, ""},
+ {"(*UcharType).Size", Method, 0, ""},
+ {"(*UcharType).String", Method, 0, ""},
+ {"(*UintType).Basic", Method, 0, ""},
+ {"(*UintType).Common", Method, 0, ""},
+ {"(*UintType).Size", Method, 0, ""},
+ {"(*UintType).String", Method, 0, ""},
+ {"(*UnspecifiedType).Basic", Method, 4, ""},
+ {"(*UnspecifiedType).Common", Method, 4, ""},
+ {"(*UnspecifiedType).Size", Method, 4, ""},
+ {"(*UnspecifiedType).String", Method, 4, ""},
+ {"(*UnsupportedType).Common", Method, 13, ""},
+ {"(*UnsupportedType).Size", Method, 13, ""},
+ {"(*UnsupportedType).String", Method, 13, ""},
+ {"(*VoidType).Common", Method, 0, ""},
+ {"(*VoidType).Size", Method, 0, ""},
+ {"(*VoidType).String", Method, 0, ""},
+ {"(Attr).GoString", Method, 0, ""},
+ {"(Attr).String", Method, 0, ""},
+ {"(Class).GoString", Method, 5, ""},
+ {"(Class).String", Method, 5, ""},
+ {"(DecodeError).Error", Method, 0, ""},
+ {"(Tag).GoString", Method, 0, ""},
+ {"(Tag).String", Method, 0, ""},
+ {"AddrType", Type, 0, ""},
+ {"AddrType.BasicType", Field, 0, ""},
+ {"ArrayType", Type, 0, ""},
+ {"ArrayType.CommonType", Field, 0, ""},
+ {"ArrayType.Count", Field, 0, ""},
+ {"ArrayType.StrideBitSize", Field, 0, ""},
+ {"ArrayType.Type", Field, 0, ""},
+ {"Attr", Type, 0, ""},
+ {"AttrAbstractOrigin", Const, 0, ""},
+ {"AttrAccessibility", Const, 0, ""},
+ {"AttrAddrBase", Const, 14, ""},
+ {"AttrAddrClass", Const, 0, ""},
+ {"AttrAlignment", Const, 14, ""},
+ {"AttrAllocated", Const, 0, ""},
+ {"AttrArtificial", Const, 0, ""},
+ {"AttrAssociated", Const, 0, ""},
+ {"AttrBaseTypes", Const, 0, ""},
+ {"AttrBinaryScale", Const, 14, ""},
+ {"AttrBitOffset", Const, 0, ""},
+ {"AttrBitSize", Const, 0, ""},
+ {"AttrByteSize", Const, 0, ""},
+ {"AttrCallAllCalls", Const, 14, ""},
+ {"AttrCallAllSourceCalls", Const, 14, ""},
+ {"AttrCallAllTailCalls", Const, 14, ""},
+ {"AttrCallColumn", Const, 0, ""},
+ {"AttrCallDataLocation", Const, 14, ""},
+ {"AttrCallDataValue", Const, 14, ""},
+ {"AttrCallFile", Const, 0, ""},
+ {"AttrCallLine", Const, 0, ""},
+ {"AttrCallOrigin", Const, 14, ""},
+ {"AttrCallPC", Const, 14, ""},
+ {"AttrCallParameter", Const, 14, ""},
+ {"AttrCallReturnPC", Const, 14, ""},
+ {"AttrCallTailCall", Const, 14, ""},
+ {"AttrCallTarget", Const, 14, ""},
+ {"AttrCallTargetClobbered", Const, 14, ""},
+ {"AttrCallValue", Const, 14, ""},
+ {"AttrCalling", Const, 0, ""},
+ {"AttrCommonRef", Const, 0, ""},
+ {"AttrCompDir", Const, 0, ""},
+ {"AttrConstExpr", Const, 14, ""},
+ {"AttrConstValue", Const, 0, ""},
+ {"AttrContainingType", Const, 0, ""},
+ {"AttrCount", Const, 0, ""},
+ {"AttrDataBitOffset", Const, 14, ""},
+ {"AttrDataLocation", Const, 0, ""},
+ {"AttrDataMemberLoc", Const, 0, ""},
+ {"AttrDecimalScale", Const, 14, ""},
+ {"AttrDecimalSign", Const, 14, ""},
+ {"AttrDeclColumn", Const, 0, ""},
+ {"AttrDeclFile", Const, 0, ""},
+ {"AttrDeclLine", Const, 0, ""},
+ {"AttrDeclaration", Const, 0, ""},
+ {"AttrDefaultValue", Const, 0, ""},
+ {"AttrDefaulted", Const, 14, ""},
+ {"AttrDeleted", Const, 14, ""},
+ {"AttrDescription", Const, 0, ""},
+ {"AttrDigitCount", Const, 14, ""},
+ {"AttrDiscr", Const, 0, ""},
+ {"AttrDiscrList", Const, 0, ""},
+ {"AttrDiscrValue", Const, 0, ""},
+ {"AttrDwoName", Const, 14, ""},
+ {"AttrElemental", Const, 14, ""},
+ {"AttrEncoding", Const, 0, ""},
+ {"AttrEndianity", Const, 14, ""},
+ {"AttrEntrypc", Const, 0, ""},
+ {"AttrEnumClass", Const, 14, ""},
+ {"AttrExplicit", Const, 14, ""},
+ {"AttrExportSymbols", Const, 14, ""},
+ {"AttrExtension", Const, 0, ""},
+ {"AttrExternal", Const, 0, ""},
+ {"AttrFrameBase", Const, 0, ""},
+ {"AttrFriend", Const, 0, ""},
+ {"AttrHighpc", Const, 0, ""},
+ {"AttrIdentifierCase", Const, 0, ""},
+ {"AttrImport", Const, 0, ""},
+ {"AttrInline", Const, 0, ""},
+ {"AttrIsOptional", Const, 0, ""},
+ {"AttrLanguage", Const, 0, ""},
+ {"AttrLinkageName", Const, 14, ""},
+ {"AttrLocation", Const, 0, ""},
+ {"AttrLoclistsBase", Const, 14, ""},
+ {"AttrLowerBound", Const, 0, ""},
+ {"AttrLowpc", Const, 0, ""},
+ {"AttrMacroInfo", Const, 0, ""},
+ {"AttrMacros", Const, 14, ""},
+ {"AttrMainSubprogram", Const, 14, ""},
+ {"AttrMutable", Const, 14, ""},
+ {"AttrName", Const, 0, ""},
+ {"AttrNamelistItem", Const, 0, ""},
+ {"AttrNoreturn", Const, 14, ""},
+ {"AttrObjectPointer", Const, 14, ""},
+ {"AttrOrdering", Const, 0, ""},
+ {"AttrPictureString", Const, 14, ""},
+ {"AttrPriority", Const, 0, ""},
+ {"AttrProducer", Const, 0, ""},
+ {"AttrPrototyped", Const, 0, ""},
+ {"AttrPure", Const, 14, ""},
+ {"AttrRanges", Const, 0, ""},
+ {"AttrRank", Const, 14, ""},
+ {"AttrRecursive", Const, 14, ""},
+ {"AttrReference", Const, 14, ""},
+ {"AttrReturnAddr", Const, 0, ""},
+ {"AttrRnglistsBase", Const, 14, ""},
+ {"AttrRvalueReference", Const, 14, ""},
+ {"AttrSegment", Const, 0, ""},
+ {"AttrSibling", Const, 0, ""},
+ {"AttrSignature", Const, 14, ""},
+ {"AttrSmall", Const, 14, ""},
+ {"AttrSpecification", Const, 0, ""},
+ {"AttrStartScope", Const, 0, ""},
+ {"AttrStaticLink", Const, 0, ""},
+ {"AttrStmtList", Const, 0, ""},
+ {"AttrStrOffsetsBase", Const, 14, ""},
+ {"AttrStride", Const, 0, ""},
+ {"AttrStrideSize", Const, 0, ""},
+ {"AttrStringLength", Const, 0, ""},
+ {"AttrStringLengthBitSize", Const, 14, ""},
+ {"AttrStringLengthByteSize", Const, 14, ""},
+ {"AttrThreadsScaled", Const, 14, ""},
+ {"AttrTrampoline", Const, 0, ""},
+ {"AttrType", Const, 0, ""},
+ {"AttrUpperBound", Const, 0, ""},
+ {"AttrUseLocation", Const, 0, ""},
+ {"AttrUseUTF8", Const, 0, ""},
+ {"AttrVarParam", Const, 0, ""},
+ {"AttrVirtuality", Const, 0, ""},
+ {"AttrVisibility", Const, 0, ""},
+ {"AttrVtableElemLoc", Const, 0, ""},
+ {"BasicType", Type, 0, ""},
+ {"BasicType.BitOffset", Field, 0, ""},
+ {"BasicType.BitSize", Field, 0, ""},
+ {"BasicType.CommonType", Field, 0, ""},
+ {"BasicType.DataBitOffset", Field, 18, ""},
+ {"BoolType", Type, 0, ""},
+ {"BoolType.BasicType", Field, 0, ""},
+ {"CharType", Type, 0, ""},
+ {"CharType.BasicType", Field, 0, ""},
+ {"Class", Type, 5, ""},
+ {"ClassAddrPtr", Const, 14, ""},
+ {"ClassAddress", Const, 5, ""},
+ {"ClassBlock", Const, 5, ""},
+ {"ClassConstant", Const, 5, ""},
+ {"ClassExprLoc", Const, 5, ""},
+ {"ClassFlag", Const, 5, ""},
+ {"ClassLinePtr", Const, 5, ""},
+ {"ClassLocList", Const, 14, ""},
+ {"ClassLocListPtr", Const, 5, ""},
+ {"ClassMacPtr", Const, 5, ""},
+ {"ClassRangeListPtr", Const, 5, ""},
+ {"ClassReference", Const, 5, ""},
+ {"ClassReferenceAlt", Const, 5, ""},
+ {"ClassReferenceSig", Const, 5, ""},
+ {"ClassRngList", Const, 14, ""},
+ {"ClassRngListsPtr", Const, 14, ""},
+ {"ClassStrOffsetsPtr", Const, 14, ""},
+ {"ClassString", Const, 5, ""},
+ {"ClassStringAlt", Const, 5, ""},
+ {"ClassUnknown", Const, 6, ""},
+ {"CommonType", Type, 0, ""},
+ {"CommonType.ByteSize", Field, 0, ""},
+ {"CommonType.Name", Field, 0, ""},
+ {"ComplexType", Type, 0, ""},
+ {"ComplexType.BasicType", Field, 0, ""},
+ {"Data", Type, 0, ""},
+ {"DecodeError", Type, 0, ""},
+ {"DecodeError.Err", Field, 0, ""},
+ {"DecodeError.Name", Field, 0, ""},
+ {"DecodeError.Offset", Field, 0, ""},
+ {"DotDotDotType", Type, 0, ""},
+ {"DotDotDotType.CommonType", Field, 0, ""},
+ {"Entry", Type, 0, ""},
+ {"Entry.Children", Field, 0, ""},
+ {"Entry.Field", Field, 0, ""},
+ {"Entry.Offset", Field, 0, ""},
+ {"Entry.Tag", Field, 0, ""},
+ {"EnumType", Type, 0, ""},
+ {"EnumType.CommonType", Field, 0, ""},
+ {"EnumType.EnumName", Field, 0, ""},
+ {"EnumType.Val", Field, 0, ""},
+ {"EnumValue", Type, 0, ""},
+ {"EnumValue.Name", Field, 0, ""},
+ {"EnumValue.Val", Field, 0, ""},
+ {"ErrUnknownPC", Var, 5, ""},
+ {"Field", Type, 0, ""},
+ {"Field.Attr", Field, 0, ""},
+ {"Field.Class", Field, 5, ""},
+ {"Field.Val", Field, 0, ""},
+ {"FloatType", Type, 0, ""},
+ {"FloatType.BasicType", Field, 0, ""},
+ {"FuncType", Type, 0, ""},
+ {"FuncType.CommonType", Field, 0, ""},
+ {"FuncType.ParamType", Field, 0, ""},
+ {"FuncType.ReturnType", Field, 0, ""},
+ {"IntType", Type, 0, ""},
+ {"IntType.BasicType", Field, 0, ""},
+ {"LineEntry", Type, 5, ""},
+ {"LineEntry.Address", Field, 5, ""},
+ {"LineEntry.BasicBlock", Field, 5, ""},
+ {"LineEntry.Column", Field, 5, ""},
+ {"LineEntry.Discriminator", Field, 5, ""},
+ {"LineEntry.EndSequence", Field, 5, ""},
+ {"LineEntry.EpilogueBegin", Field, 5, ""},
+ {"LineEntry.File", Field, 5, ""},
+ {"LineEntry.ISA", Field, 5, ""},
+ {"LineEntry.IsStmt", Field, 5, ""},
+ {"LineEntry.Line", Field, 5, ""},
+ {"LineEntry.OpIndex", Field, 5, ""},
+ {"LineEntry.PrologueEnd", Field, 5, ""},
+ {"LineFile", Type, 5, ""},
+ {"LineFile.Length", Field, 5, ""},
+ {"LineFile.Mtime", Field, 5, ""},
+ {"LineFile.Name", Field, 5, ""},
+ {"LineReader", Type, 5, ""},
+ {"LineReaderPos", Type, 5, ""},
+ {"New", Func, 0, "func(abbrev []byte, aranges []byte, frame []byte, info []byte, line []byte, pubnames []byte, ranges []byte, str []byte) (*Data, error)"},
+ {"Offset", Type, 0, ""},
+ {"PtrType", Type, 0, ""},
+ {"PtrType.CommonType", Field, 0, ""},
+ {"PtrType.Type", Field, 0, ""},
+ {"QualType", Type, 0, ""},
+ {"QualType.CommonType", Field, 0, ""},
+ {"QualType.Qual", Field, 0, ""},
+ {"QualType.Type", Field, 0, ""},
+ {"Reader", Type, 0, ""},
+ {"StructField", Type, 0, ""},
+ {"StructField.BitOffset", Field, 0, ""},
+ {"StructField.BitSize", Field, 0, ""},
+ {"StructField.ByteOffset", Field, 0, ""},
+ {"StructField.ByteSize", Field, 0, ""},
+ {"StructField.DataBitOffset", Field, 18, ""},
+ {"StructField.Name", Field, 0, ""},
+ {"StructField.Type", Field, 0, ""},
+ {"StructType", Type, 0, ""},
+ {"StructType.CommonType", Field, 0, ""},
+ {"StructType.Field", Field, 0, ""},
+ {"StructType.Incomplete", Field, 0, ""},
+ {"StructType.Kind", Field, 0, ""},
+ {"StructType.StructName", Field, 0, ""},
+ {"Tag", Type, 0, ""},
+ {"TagAccessDeclaration", Const, 0, ""},
+ {"TagArrayType", Const, 0, ""},
+ {"TagAtomicType", Const, 14, ""},
+ {"TagBaseType", Const, 0, ""},
+ {"TagCallSite", Const, 14, ""},
+ {"TagCallSiteParameter", Const, 14, ""},
+ {"TagCatchDwarfBlock", Const, 0, ""},
+ {"TagClassType", Const, 0, ""},
+ {"TagCoarrayType", Const, 14, ""},
+ {"TagCommonDwarfBlock", Const, 0, ""},
+ {"TagCommonInclusion", Const, 0, ""},
+ {"TagCompileUnit", Const, 0, ""},
+ {"TagCondition", Const, 3, ""},
+ {"TagConstType", Const, 0, ""},
+ {"TagConstant", Const, 0, ""},
+ {"TagDwarfProcedure", Const, 0, ""},
+ {"TagDynamicType", Const, 14, ""},
+ {"TagEntryPoint", Const, 0, ""},
+ {"TagEnumerationType", Const, 0, ""},
+ {"TagEnumerator", Const, 0, ""},
+ {"TagFileType", Const, 0, ""},
+ {"TagFormalParameter", Const, 0, ""},
+ {"TagFriend", Const, 0, ""},
+ {"TagGenericSubrange", Const, 14, ""},
+ {"TagImmutableType", Const, 14, ""},
+ {"TagImportedDeclaration", Const, 0, ""},
+ {"TagImportedModule", Const, 0, ""},
+ {"TagImportedUnit", Const, 0, ""},
+ {"TagInheritance", Const, 0, ""},
+ {"TagInlinedSubroutine", Const, 0, ""},
+ {"TagInterfaceType", Const, 0, ""},
+ {"TagLabel", Const, 0, ""},
+ {"TagLexDwarfBlock", Const, 0, ""},
+ {"TagMember", Const, 0, ""},
+ {"TagModule", Const, 0, ""},
+ {"TagMutableType", Const, 0, ""},
+ {"TagNamelist", Const, 0, ""},
+ {"TagNamelistItem", Const, 0, ""},
+ {"TagNamespace", Const, 0, ""},
+ {"TagPackedType", Const, 0, ""},
+ {"TagPartialUnit", Const, 0, ""},
+ {"TagPointerType", Const, 0, ""},
+ {"TagPtrToMemberType", Const, 0, ""},
+ {"TagReferenceType", Const, 0, ""},
+ {"TagRestrictType", Const, 0, ""},
+ {"TagRvalueReferenceType", Const, 3, ""},
+ {"TagSetType", Const, 0, ""},
+ {"TagSharedType", Const, 3, ""},
+ {"TagSkeletonUnit", Const, 14, ""},
+ {"TagStringType", Const, 0, ""},
+ {"TagStructType", Const, 0, ""},
+ {"TagSubprogram", Const, 0, ""},
+ {"TagSubrangeType", Const, 0, ""},
+ {"TagSubroutineType", Const, 0, ""},
+ {"TagTemplateAlias", Const, 3, ""},
+ {"TagTemplateTypeParameter", Const, 0, ""},
+ {"TagTemplateValueParameter", Const, 0, ""},
+ {"TagThrownType", Const, 0, ""},
+ {"TagTryDwarfBlock", Const, 0, ""},
+ {"TagTypeUnit", Const, 3, ""},
+ {"TagTypedef", Const, 0, ""},
+ {"TagUnionType", Const, 0, ""},
+ {"TagUnspecifiedParameters", Const, 0, ""},
+ {"TagUnspecifiedType", Const, 0, ""},
+ {"TagVariable", Const, 0, ""},
+ {"TagVariant", Const, 0, ""},
+ {"TagVariantPart", Const, 0, ""},
+ {"TagVolatileType", Const, 0, ""},
+ {"TagWithStmt", Const, 0, ""},
+ {"Type", Type, 0, ""},
+ {"TypedefType", Type, 0, ""},
+ {"TypedefType.CommonType", Field, 0, ""},
+ {"TypedefType.Type", Field, 0, ""},
+ {"UcharType", Type, 0, ""},
+ {"UcharType.BasicType", Field, 0, ""},
+ {"UintType", Type, 0, ""},
+ {"UintType.BasicType", Field, 0, ""},
+ {"UnspecifiedType", Type, 4, ""},
+ {"UnspecifiedType.BasicType", Field, 4, ""},
+ {"UnsupportedType", Type, 13, ""},
+ {"UnsupportedType.CommonType", Field, 13, ""},
+ {"UnsupportedType.Tag", Field, 13, ""},
+ {"VoidType", Type, 0, ""},
+ {"VoidType.CommonType", Field, 0, ""},
+ },
+ "debug/elf": {
+ {"(*File).Close", Method, 0, ""},
+ {"(*File).DWARF", Method, 0, ""},
+ {"(*File).DynString", Method, 1, ""},
+ {"(*File).DynValue", Method, 21, ""},
+ {"(*File).DynamicSymbols", Method, 4, ""},
+ {"(*File).DynamicVersionNeeds", Method, 24, ""},
+ {"(*File).DynamicVersions", Method, 24, ""},
+ {"(*File).ImportedLibraries", Method, 0, ""},
+ {"(*File).ImportedSymbols", Method, 0, ""},
+ {"(*File).Section", Method, 0, ""},
+ {"(*File).SectionByType", Method, 0, ""},
+ {"(*File).Symbols", Method, 0, ""},
+ {"(*FormatError).Error", Method, 0, ""},
+ {"(*Prog).Open", Method, 0, ""},
+ {"(*Section).Data", Method, 0, ""},
+ {"(*Section).Open", Method, 0, ""},
+ {"(Class).GoString", Method, 0, ""},
+ {"(Class).String", Method, 0, ""},
+ {"(CompressionType).GoString", Method, 6, ""},
+ {"(CompressionType).String", Method, 6, ""},
+ {"(Data).GoString", Method, 0, ""},
+ {"(Data).String", Method, 0, ""},
+ {"(DynFlag).GoString", Method, 0, ""},
+ {"(DynFlag).String", Method, 0, ""},
+ {"(DynFlag1).GoString", Method, 21, ""},
+ {"(DynFlag1).String", Method, 21, ""},
+ {"(DynTag).GoString", Method, 0, ""},
+ {"(DynTag).String", Method, 0, ""},
+ {"(Machine).GoString", Method, 0, ""},
+ {"(Machine).String", Method, 0, ""},
+ {"(NType).GoString", Method, 0, ""},
+ {"(NType).String", Method, 0, ""},
+ {"(OSABI).GoString", Method, 0, ""},
+ {"(OSABI).String", Method, 0, ""},
+ {"(Prog).ReadAt", Method, 0, ""},
+ {"(ProgFlag).GoString", Method, 0, ""},
+ {"(ProgFlag).String", Method, 0, ""},
+ {"(ProgType).GoString", Method, 0, ""},
+ {"(ProgType).String", Method, 0, ""},
+ {"(R_386).GoString", Method, 0, ""},
+ {"(R_386).String", Method, 0, ""},
+ {"(R_390).GoString", Method, 7, ""},
+ {"(R_390).String", Method, 7, ""},
+ {"(R_AARCH64).GoString", Method, 4, ""},
+ {"(R_AARCH64).String", Method, 4, ""},
+ {"(R_ALPHA).GoString", Method, 0, ""},
+ {"(R_ALPHA).String", Method, 0, ""},
+ {"(R_ARM).GoString", Method, 0, ""},
+ {"(R_ARM).String", Method, 0, ""},
+ {"(R_LARCH).GoString", Method, 19, ""},
+ {"(R_LARCH).String", Method, 19, ""},
+ {"(R_MIPS).GoString", Method, 6, ""},
+ {"(R_MIPS).String", Method, 6, ""},
+ {"(R_PPC).GoString", Method, 0, ""},
+ {"(R_PPC).String", Method, 0, ""},
+ {"(R_PPC64).GoString", Method, 5, ""},
+ {"(R_PPC64).String", Method, 5, ""},
+ {"(R_RISCV).GoString", Method, 11, ""},
+ {"(R_RISCV).String", Method, 11, ""},
+ {"(R_SPARC).GoString", Method, 0, ""},
+ {"(R_SPARC).String", Method, 0, ""},
+ {"(R_X86_64).GoString", Method, 0, ""},
+ {"(R_X86_64).String", Method, 0, ""},
+ {"(Section).ReadAt", Method, 0, ""},
+ {"(SectionFlag).GoString", Method, 0, ""},
+ {"(SectionFlag).String", Method, 0, ""},
+ {"(SectionIndex).GoString", Method, 0, ""},
+ {"(SectionIndex).String", Method, 0, ""},
+ {"(SectionType).GoString", Method, 0, ""},
+ {"(SectionType).String", Method, 0, ""},
+ {"(SymBind).GoString", Method, 0, ""},
+ {"(SymBind).String", Method, 0, ""},
+ {"(SymType).GoString", Method, 0, ""},
+ {"(SymType).String", Method, 0, ""},
+ {"(SymVis).GoString", Method, 0, ""},
+ {"(SymVis).String", Method, 0, ""},
+ {"(Type).GoString", Method, 0, ""},
+ {"(Type).String", Method, 0, ""},
+ {"(Version).GoString", Method, 0, ""},
+ {"(Version).String", Method, 0, ""},
+ {"(VersionIndex).Index", Method, 24, ""},
+ {"(VersionIndex).IsHidden", Method, 24, ""},
+ {"ARM_MAGIC_TRAMP_NUMBER", Const, 0, ""},
+ {"COMPRESS_HIOS", Const, 6, ""},
+ {"COMPRESS_HIPROC", Const, 6, ""},
+ {"COMPRESS_LOOS", Const, 6, ""},
+ {"COMPRESS_LOPROC", Const, 6, ""},
+ {"COMPRESS_ZLIB", Const, 6, ""},
+ {"COMPRESS_ZSTD", Const, 21, ""},
+ {"Chdr32", Type, 6, ""},
+ {"Chdr32.Addralign", Field, 6, ""},
+ {"Chdr32.Size", Field, 6, ""},
+ {"Chdr32.Type", Field, 6, ""},
+ {"Chdr64", Type, 6, ""},
+ {"Chdr64.Addralign", Field, 6, ""},
+ {"Chdr64.Size", Field, 6, ""},
+ {"Chdr64.Type", Field, 6, ""},
+ {"Class", Type, 0, ""},
+ {"CompressionType", Type, 6, ""},
+ {"DF_1_CONFALT", Const, 21, ""},
+ {"DF_1_DIRECT", Const, 21, ""},
+ {"DF_1_DISPRELDNE", Const, 21, ""},
+ {"DF_1_DISPRELPND", Const, 21, ""},
+ {"DF_1_EDITED", Const, 21, ""},
+ {"DF_1_ENDFILTEE", Const, 21, ""},
+ {"DF_1_GLOBAL", Const, 21, ""},
+ {"DF_1_GLOBAUDIT", Const, 21, ""},
+ {"DF_1_GROUP", Const, 21, ""},
+ {"DF_1_IGNMULDEF", Const, 21, ""},
+ {"DF_1_INITFIRST", Const, 21, ""},
+ {"DF_1_INTERPOSE", Const, 21, ""},
+ {"DF_1_KMOD", Const, 21, ""},
+ {"DF_1_LOADFLTR", Const, 21, ""},
+ {"DF_1_NOCOMMON", Const, 21, ""},
+ {"DF_1_NODEFLIB", Const, 21, ""},
+ {"DF_1_NODELETE", Const, 21, ""},
+ {"DF_1_NODIRECT", Const, 21, ""},
+ {"DF_1_NODUMP", Const, 21, ""},
+ {"DF_1_NOHDR", Const, 21, ""},
+ {"DF_1_NOKSYMS", Const, 21, ""},
+ {"DF_1_NOOPEN", Const, 21, ""},
+ {"DF_1_NORELOC", Const, 21, ""},
+ {"DF_1_NOW", Const, 21, ""},
+ {"DF_1_ORIGIN", Const, 21, ""},
+ {"DF_1_PIE", Const, 21, ""},
+ {"DF_1_SINGLETON", Const, 21, ""},
+ {"DF_1_STUB", Const, 21, ""},
+ {"DF_1_SYMINTPOSE", Const, 21, ""},
+ {"DF_1_TRANS", Const, 21, ""},
+ {"DF_1_WEAKFILTER", Const, 21, ""},
+ {"DF_BIND_NOW", Const, 0, ""},
+ {"DF_ORIGIN", Const, 0, ""},
+ {"DF_STATIC_TLS", Const, 0, ""},
+ {"DF_SYMBOLIC", Const, 0, ""},
+ {"DF_TEXTREL", Const, 0, ""},
+ {"DT_ADDRRNGHI", Const, 16, ""},
+ {"DT_ADDRRNGLO", Const, 16, ""},
+ {"DT_AUDIT", Const, 16, ""},
+ {"DT_AUXILIARY", Const, 16, ""},
+ {"DT_BIND_NOW", Const, 0, ""},
+ {"DT_CHECKSUM", Const, 16, ""},
+ {"DT_CONFIG", Const, 16, ""},
+ {"DT_DEBUG", Const, 0, ""},
+ {"DT_DEPAUDIT", Const, 16, ""},
+ {"DT_ENCODING", Const, 0, ""},
+ {"DT_FEATURE", Const, 16, ""},
+ {"DT_FILTER", Const, 16, ""},
+ {"DT_FINI", Const, 0, ""},
+ {"DT_FINI_ARRAY", Const, 0, ""},
+ {"DT_FINI_ARRAYSZ", Const, 0, ""},
+ {"DT_FLAGS", Const, 0, ""},
+ {"DT_FLAGS_1", Const, 16, ""},
+ {"DT_GNU_CONFLICT", Const, 16, ""},
+ {"DT_GNU_CONFLICTSZ", Const, 16, ""},
+ {"DT_GNU_HASH", Const, 16, ""},
+ {"DT_GNU_LIBLIST", Const, 16, ""},
+ {"DT_GNU_LIBLISTSZ", Const, 16, ""},
+ {"DT_GNU_PRELINKED", Const, 16, ""},
+ {"DT_HASH", Const, 0, ""},
+ {"DT_HIOS", Const, 0, ""},
+ {"DT_HIPROC", Const, 0, ""},
+ {"DT_INIT", Const, 0, ""},
+ {"DT_INIT_ARRAY", Const, 0, ""},
+ {"DT_INIT_ARRAYSZ", Const, 0, ""},
+ {"DT_JMPREL", Const, 0, ""},
+ {"DT_LOOS", Const, 0, ""},
+ {"DT_LOPROC", Const, 0, ""},
+ {"DT_MIPS_AUX_DYNAMIC", Const, 16, ""},
+ {"DT_MIPS_BASE_ADDRESS", Const, 16, ""},
+ {"DT_MIPS_COMPACT_SIZE", Const, 16, ""},
+ {"DT_MIPS_CONFLICT", Const, 16, ""},
+ {"DT_MIPS_CONFLICTNO", Const, 16, ""},
+ {"DT_MIPS_CXX_FLAGS", Const, 16, ""},
+ {"DT_MIPS_DELTA_CLASS", Const, 16, ""},
+ {"DT_MIPS_DELTA_CLASSSYM", Const, 16, ""},
+ {"DT_MIPS_DELTA_CLASSSYM_NO", Const, 16, ""},
+ {"DT_MIPS_DELTA_CLASS_NO", Const, 16, ""},
+ {"DT_MIPS_DELTA_INSTANCE", Const, 16, ""},
+ {"DT_MIPS_DELTA_INSTANCE_NO", Const, 16, ""},
+ {"DT_MIPS_DELTA_RELOC", Const, 16, ""},
+ {"DT_MIPS_DELTA_RELOC_NO", Const, 16, ""},
+ {"DT_MIPS_DELTA_SYM", Const, 16, ""},
+ {"DT_MIPS_DELTA_SYM_NO", Const, 16, ""},
+ {"DT_MIPS_DYNSTR_ALIGN", Const, 16, ""},
+ {"DT_MIPS_FLAGS", Const, 16, ""},
+ {"DT_MIPS_GOTSYM", Const, 16, ""},
+ {"DT_MIPS_GP_VALUE", Const, 16, ""},
+ {"DT_MIPS_HIDDEN_GOTIDX", Const, 16, ""},
+ {"DT_MIPS_HIPAGENO", Const, 16, ""},
+ {"DT_MIPS_ICHECKSUM", Const, 16, ""},
+ {"DT_MIPS_INTERFACE", Const, 16, ""},
+ {"DT_MIPS_INTERFACE_SIZE", Const, 16, ""},
+ {"DT_MIPS_IVERSION", Const, 16, ""},
+ {"DT_MIPS_LIBLIST", Const, 16, ""},
+ {"DT_MIPS_LIBLISTNO", Const, 16, ""},
+ {"DT_MIPS_LOCALPAGE_GOTIDX", Const, 16, ""},
+ {"DT_MIPS_LOCAL_GOTIDX", Const, 16, ""},
+ {"DT_MIPS_LOCAL_GOTNO", Const, 16, ""},
+ {"DT_MIPS_MSYM", Const, 16, ""},
+ {"DT_MIPS_OPTIONS", Const, 16, ""},
+ {"DT_MIPS_PERF_SUFFIX", Const, 16, ""},
+ {"DT_MIPS_PIXIE_INIT", Const, 16, ""},
+ {"DT_MIPS_PLTGOT", Const, 16, ""},
+ {"DT_MIPS_PROTECTED_GOTIDX", Const, 16, ""},
+ {"DT_MIPS_RLD_MAP", Const, 16, ""},
+ {"DT_MIPS_RLD_MAP_REL", Const, 16, ""},
+ {"DT_MIPS_RLD_TEXT_RESOLVE_ADDR", Const, 16, ""},
+ {"DT_MIPS_RLD_VERSION", Const, 16, ""},
+ {"DT_MIPS_RWPLT", Const, 16, ""},
+ {"DT_MIPS_SYMBOL_LIB", Const, 16, ""},
+ {"DT_MIPS_SYMTABNO", Const, 16, ""},
+ {"DT_MIPS_TIME_STAMP", Const, 16, ""},
+ {"DT_MIPS_UNREFEXTNO", Const, 16, ""},
+ {"DT_MOVEENT", Const, 16, ""},
+ {"DT_MOVESZ", Const, 16, ""},
+ {"DT_MOVETAB", Const, 16, ""},
+ {"DT_NEEDED", Const, 0, ""},
+ {"DT_NULL", Const, 0, ""},
+ {"DT_PLTGOT", Const, 0, ""},
+ {"DT_PLTPAD", Const, 16, ""},
+ {"DT_PLTPADSZ", Const, 16, ""},
+ {"DT_PLTREL", Const, 0, ""},
+ {"DT_PLTRELSZ", Const, 0, ""},
+ {"DT_POSFLAG_1", Const, 16, ""},
+ {"DT_PPC64_GLINK", Const, 16, ""},
+ {"DT_PPC64_OPD", Const, 16, ""},
+ {"DT_PPC64_OPDSZ", Const, 16, ""},
+ {"DT_PPC64_OPT", Const, 16, ""},
+ {"DT_PPC_GOT", Const, 16, ""},
+ {"DT_PPC_OPT", Const, 16, ""},
+ {"DT_PREINIT_ARRAY", Const, 0, ""},
+ {"DT_PREINIT_ARRAYSZ", Const, 0, ""},
+ {"DT_REL", Const, 0, ""},
+ {"DT_RELA", Const, 0, ""},
+ {"DT_RELACOUNT", Const, 16, ""},
+ {"DT_RELAENT", Const, 0, ""},
+ {"DT_RELASZ", Const, 0, ""},
+ {"DT_RELCOUNT", Const, 16, ""},
+ {"DT_RELENT", Const, 0, ""},
+ {"DT_RELSZ", Const, 0, ""},
+ {"DT_RPATH", Const, 0, ""},
+ {"DT_RUNPATH", Const, 0, ""},
+ {"DT_SONAME", Const, 0, ""},
+ {"DT_SPARC_REGISTER", Const, 16, ""},
+ {"DT_STRSZ", Const, 0, ""},
+ {"DT_STRTAB", Const, 0, ""},
+ {"DT_SYMBOLIC", Const, 0, ""},
+ {"DT_SYMENT", Const, 0, ""},
+ {"DT_SYMINENT", Const, 16, ""},
+ {"DT_SYMINFO", Const, 16, ""},
+ {"DT_SYMINSZ", Const, 16, ""},
+ {"DT_SYMTAB", Const, 0, ""},
+ {"DT_SYMTAB_SHNDX", Const, 16, ""},
+ {"DT_TEXTREL", Const, 0, ""},
+ {"DT_TLSDESC_GOT", Const, 16, ""},
+ {"DT_TLSDESC_PLT", Const, 16, ""},
+ {"DT_USED", Const, 16, ""},
+ {"DT_VALRNGHI", Const, 16, ""},
+ {"DT_VALRNGLO", Const, 16, ""},
+ {"DT_VERDEF", Const, 16, ""},
+ {"DT_VERDEFNUM", Const, 16, ""},
+ {"DT_VERNEED", Const, 0, ""},
+ {"DT_VERNEEDNUM", Const, 0, ""},
+ {"DT_VERSYM", Const, 0, ""},
+ {"Data", Type, 0, ""},
+ {"Dyn32", Type, 0, ""},
+ {"Dyn32.Tag", Field, 0, ""},
+ {"Dyn32.Val", Field, 0, ""},
+ {"Dyn64", Type, 0, ""},
+ {"Dyn64.Tag", Field, 0, ""},
+ {"Dyn64.Val", Field, 0, ""},
+ {"DynFlag", Type, 0, ""},
+ {"DynFlag1", Type, 21, ""},
+ {"DynTag", Type, 0, ""},
+ {"DynamicVersion", Type, 24, ""},
+ {"DynamicVersion.Deps", Field, 24, ""},
+ {"DynamicVersion.Flags", Field, 24, ""},
+ {"DynamicVersion.Index", Field, 24, ""},
+ {"DynamicVersion.Name", Field, 24, ""},
+ {"DynamicVersionDep", Type, 24, ""},
+ {"DynamicVersionDep.Dep", Field, 24, ""},
+ {"DynamicVersionDep.Flags", Field, 24, ""},
+ {"DynamicVersionDep.Index", Field, 24, ""},
+ {"DynamicVersionFlag", Type, 24, ""},
+ {"DynamicVersionNeed", Type, 24, ""},
+ {"DynamicVersionNeed.Name", Field, 24, ""},
+ {"DynamicVersionNeed.Needs", Field, 24, ""},
+ {"EI_ABIVERSION", Const, 0, ""},
+ {"EI_CLASS", Const, 0, ""},
+ {"EI_DATA", Const, 0, ""},
+ {"EI_NIDENT", Const, 0, ""},
+ {"EI_OSABI", Const, 0, ""},
+ {"EI_PAD", Const, 0, ""},
+ {"EI_VERSION", Const, 0, ""},
+ {"ELFCLASS32", Const, 0, ""},
+ {"ELFCLASS64", Const, 0, ""},
+ {"ELFCLASSNONE", Const, 0, ""},
+ {"ELFDATA2LSB", Const, 0, ""},
+ {"ELFDATA2MSB", Const, 0, ""},
+ {"ELFDATANONE", Const, 0, ""},
+ {"ELFMAG", Const, 0, ""},
+ {"ELFOSABI_86OPEN", Const, 0, ""},
+ {"ELFOSABI_AIX", Const, 0, ""},
+ {"ELFOSABI_ARM", Const, 0, ""},
+ {"ELFOSABI_AROS", Const, 11, ""},
+ {"ELFOSABI_CLOUDABI", Const, 11, ""},
+ {"ELFOSABI_FENIXOS", Const, 11, ""},
+ {"ELFOSABI_FREEBSD", Const, 0, ""},
+ {"ELFOSABI_HPUX", Const, 0, ""},
+ {"ELFOSABI_HURD", Const, 0, ""},
+ {"ELFOSABI_IRIX", Const, 0, ""},
+ {"ELFOSABI_LINUX", Const, 0, ""},
+ {"ELFOSABI_MODESTO", Const, 0, ""},
+ {"ELFOSABI_NETBSD", Const, 0, ""},
+ {"ELFOSABI_NONE", Const, 0, ""},
+ {"ELFOSABI_NSK", Const, 0, ""},
+ {"ELFOSABI_OPENBSD", Const, 0, ""},
+ {"ELFOSABI_OPENVMS", Const, 0, ""},
+ {"ELFOSABI_SOLARIS", Const, 0, ""},
+ {"ELFOSABI_STANDALONE", Const, 0, ""},
+ {"ELFOSABI_TRU64", Const, 0, ""},
+ {"EM_386", Const, 0, ""},
+ {"EM_486", Const, 0, ""},
+ {"EM_56800EX", Const, 11, ""},
+ {"EM_68HC05", Const, 11, ""},
+ {"EM_68HC08", Const, 11, ""},
+ {"EM_68HC11", Const, 11, ""},
+ {"EM_68HC12", Const, 0, ""},
+ {"EM_68HC16", Const, 11, ""},
+ {"EM_68K", Const, 0, ""},
+ {"EM_78KOR", Const, 11, ""},
+ {"EM_8051", Const, 11, ""},
+ {"EM_860", Const, 0, ""},
+ {"EM_88K", Const, 0, ""},
+ {"EM_960", Const, 0, ""},
+ {"EM_AARCH64", Const, 4, ""},
+ {"EM_ALPHA", Const, 0, ""},
+ {"EM_ALPHA_STD", Const, 0, ""},
+ {"EM_ALTERA_NIOS2", Const, 11, ""},
+ {"EM_AMDGPU", Const, 11, ""},
+ {"EM_ARC", Const, 0, ""},
+ {"EM_ARCA", Const, 11, ""},
+ {"EM_ARC_COMPACT", Const, 11, ""},
+ {"EM_ARC_COMPACT2", Const, 11, ""},
+ {"EM_ARM", Const, 0, ""},
+ {"EM_AVR", Const, 11, ""},
+ {"EM_AVR32", Const, 11, ""},
+ {"EM_BA1", Const, 11, ""},
+ {"EM_BA2", Const, 11, ""},
+ {"EM_BLACKFIN", Const, 11, ""},
+ {"EM_BPF", Const, 11, ""},
+ {"EM_C166", Const, 11, ""},
+ {"EM_CDP", Const, 11, ""},
+ {"EM_CE", Const, 11, ""},
+ {"EM_CLOUDSHIELD", Const, 11, ""},
+ {"EM_COGE", Const, 11, ""},
+ {"EM_COLDFIRE", Const, 0, ""},
+ {"EM_COOL", Const, 11, ""},
+ {"EM_COREA_1ST", Const, 11, ""},
+ {"EM_COREA_2ND", Const, 11, ""},
+ {"EM_CR", Const, 11, ""},
+ {"EM_CR16", Const, 11, ""},
+ {"EM_CRAYNV2", Const, 11, ""},
+ {"EM_CRIS", Const, 11, ""},
+ {"EM_CRX", Const, 11, ""},
+ {"EM_CSR_KALIMBA", Const, 11, ""},
+ {"EM_CUDA", Const, 11, ""},
+ {"EM_CYPRESS_M8C", Const, 11, ""},
+ {"EM_D10V", Const, 11, ""},
+ {"EM_D30V", Const, 11, ""},
+ {"EM_DSP24", Const, 11, ""},
+ {"EM_DSPIC30F", Const, 11, ""},
+ {"EM_DXP", Const, 11, ""},
+ {"EM_ECOG1", Const, 11, ""},
+ {"EM_ECOG16", Const, 11, ""},
+ {"EM_ECOG1X", Const, 11, ""},
+ {"EM_ECOG2", Const, 11, ""},
+ {"EM_ETPU", Const, 11, ""},
+ {"EM_EXCESS", Const, 11, ""},
+ {"EM_F2MC16", Const, 11, ""},
+ {"EM_FIREPATH", Const, 11, ""},
+ {"EM_FR20", Const, 0, ""},
+ {"EM_FR30", Const, 11, ""},
+ {"EM_FT32", Const, 11, ""},
+ {"EM_FX66", Const, 11, ""},
+ {"EM_H8S", Const, 0, ""},
+ {"EM_H8_300", Const, 0, ""},
+ {"EM_H8_300H", Const, 0, ""},
+ {"EM_H8_500", Const, 0, ""},
+ {"EM_HUANY", Const, 11, ""},
+ {"EM_IA_64", Const, 0, ""},
+ {"EM_INTEL205", Const, 11, ""},
+ {"EM_INTEL206", Const, 11, ""},
+ {"EM_INTEL207", Const, 11, ""},
+ {"EM_INTEL208", Const, 11, ""},
+ {"EM_INTEL209", Const, 11, ""},
+ {"EM_IP2K", Const, 11, ""},
+ {"EM_JAVELIN", Const, 11, ""},
+ {"EM_K10M", Const, 11, ""},
+ {"EM_KM32", Const, 11, ""},
+ {"EM_KMX16", Const, 11, ""},
+ {"EM_KMX32", Const, 11, ""},
+ {"EM_KMX8", Const, 11, ""},
+ {"EM_KVARC", Const, 11, ""},
+ {"EM_L10M", Const, 11, ""},
+ {"EM_LANAI", Const, 11, ""},
+ {"EM_LATTICEMICO32", Const, 11, ""},
+ {"EM_LOONGARCH", Const, 19, ""},
+ {"EM_M16C", Const, 11, ""},
+ {"EM_M32", Const, 0, ""},
+ {"EM_M32C", Const, 11, ""},
+ {"EM_M32R", Const, 11, ""},
+ {"EM_MANIK", Const, 11, ""},
+ {"EM_MAX", Const, 11, ""},
+ {"EM_MAXQ30", Const, 11, ""},
+ {"EM_MCHP_PIC", Const, 11, ""},
+ {"EM_MCST_ELBRUS", Const, 11, ""},
+ {"EM_ME16", Const, 0, ""},
+ {"EM_METAG", Const, 11, ""},
+ {"EM_MICROBLAZE", Const, 11, ""},
+ {"EM_MIPS", Const, 0, ""},
+ {"EM_MIPS_RS3_LE", Const, 0, ""},
+ {"EM_MIPS_RS4_BE", Const, 0, ""},
+ {"EM_MIPS_X", Const, 0, ""},
+ {"EM_MMA", Const, 0, ""},
+ {"EM_MMDSP_PLUS", Const, 11, ""},
+ {"EM_MMIX", Const, 11, ""},
+ {"EM_MN10200", Const, 11, ""},
+ {"EM_MN10300", Const, 11, ""},
+ {"EM_MOXIE", Const, 11, ""},
+ {"EM_MSP430", Const, 11, ""},
+ {"EM_NCPU", Const, 0, ""},
+ {"EM_NDR1", Const, 0, ""},
+ {"EM_NDS32", Const, 11, ""},
+ {"EM_NONE", Const, 0, ""},
+ {"EM_NORC", Const, 11, ""},
+ {"EM_NS32K", Const, 11, ""},
+ {"EM_OPEN8", Const, 11, ""},
+ {"EM_OPENRISC", Const, 11, ""},
+ {"EM_PARISC", Const, 0, ""},
+ {"EM_PCP", Const, 0, ""},
+ {"EM_PDP10", Const, 11, ""},
+ {"EM_PDP11", Const, 11, ""},
+ {"EM_PDSP", Const, 11, ""},
+ {"EM_PJ", Const, 11, ""},
+ {"EM_PPC", Const, 0, ""},
+ {"EM_PPC64", Const, 0, ""},
+ {"EM_PRISM", Const, 11, ""},
+ {"EM_QDSP6", Const, 11, ""},
+ {"EM_R32C", Const, 11, ""},
+ {"EM_RCE", Const, 0, ""},
+ {"EM_RH32", Const, 0, ""},
+ {"EM_RISCV", Const, 11, ""},
+ {"EM_RL78", Const, 11, ""},
+ {"EM_RS08", Const, 11, ""},
+ {"EM_RX", Const, 11, ""},
+ {"EM_S370", Const, 0, ""},
+ {"EM_S390", Const, 0, ""},
+ {"EM_SCORE7", Const, 11, ""},
+ {"EM_SEP", Const, 11, ""},
+ {"EM_SE_C17", Const, 11, ""},
+ {"EM_SE_C33", Const, 11, ""},
+ {"EM_SH", Const, 0, ""},
+ {"EM_SHARC", Const, 11, ""},
+ {"EM_SLE9X", Const, 11, ""},
+ {"EM_SNP1K", Const, 11, ""},
+ {"EM_SPARC", Const, 0, ""},
+ {"EM_SPARC32PLUS", Const, 0, ""},
+ {"EM_SPARCV9", Const, 0, ""},
+ {"EM_ST100", Const, 0, ""},
+ {"EM_ST19", Const, 11, ""},
+ {"EM_ST200", Const, 11, ""},
+ {"EM_ST7", Const, 11, ""},
+ {"EM_ST9PLUS", Const, 11, ""},
+ {"EM_STARCORE", Const, 0, ""},
+ {"EM_STM8", Const, 11, ""},
+ {"EM_STXP7X", Const, 11, ""},
+ {"EM_SVX", Const, 11, ""},
+ {"EM_TILE64", Const, 11, ""},
+ {"EM_TILEGX", Const, 11, ""},
+ {"EM_TILEPRO", Const, 11, ""},
+ {"EM_TINYJ", Const, 0, ""},
+ {"EM_TI_ARP32", Const, 11, ""},
+ {"EM_TI_C2000", Const, 11, ""},
+ {"EM_TI_C5500", Const, 11, ""},
+ {"EM_TI_C6000", Const, 11, ""},
+ {"EM_TI_PRU", Const, 11, ""},
+ {"EM_TMM_GPP", Const, 11, ""},
+ {"EM_TPC", Const, 11, ""},
+ {"EM_TRICORE", Const, 0, ""},
+ {"EM_TRIMEDIA", Const, 11, ""},
+ {"EM_TSK3000", Const, 11, ""},
+ {"EM_UNICORE", Const, 11, ""},
+ {"EM_V800", Const, 0, ""},
+ {"EM_V850", Const, 11, ""},
+ {"EM_VAX", Const, 11, ""},
+ {"EM_VIDEOCORE", Const, 11, ""},
+ {"EM_VIDEOCORE3", Const, 11, ""},
+ {"EM_VIDEOCORE5", Const, 11, ""},
+ {"EM_VISIUM", Const, 11, ""},
+ {"EM_VPP500", Const, 0, ""},
+ {"EM_X86_64", Const, 0, ""},
+ {"EM_XCORE", Const, 11, ""},
+ {"EM_XGATE", Const, 11, ""},
+ {"EM_XIMO16", Const, 11, ""},
+ {"EM_XTENSA", Const, 11, ""},
+ {"EM_Z80", Const, 11, ""},
+ {"EM_ZSP", Const, 11, ""},
+ {"ET_CORE", Const, 0, ""},
+ {"ET_DYN", Const, 0, ""},
+ {"ET_EXEC", Const, 0, ""},
+ {"ET_HIOS", Const, 0, ""},
+ {"ET_HIPROC", Const, 0, ""},
+ {"ET_LOOS", Const, 0, ""},
+ {"ET_LOPROC", Const, 0, ""},
+ {"ET_NONE", Const, 0, ""},
+ {"ET_REL", Const, 0, ""},
+ {"EV_CURRENT", Const, 0, ""},
+ {"EV_NONE", Const, 0, ""},
+ {"ErrNoSymbols", Var, 4, ""},
+ {"File", Type, 0, ""},
+ {"File.FileHeader", Field, 0, ""},
+ {"File.Progs", Field, 0, ""},
+ {"File.Sections", Field, 0, ""},
+ {"FileHeader", Type, 0, ""},
+ {"FileHeader.ABIVersion", Field, 0, ""},
+ {"FileHeader.ByteOrder", Field, 0, ""},
+ {"FileHeader.Class", Field, 0, ""},
+ {"FileHeader.Data", Field, 0, ""},
+ {"FileHeader.Entry", Field, 1, ""},
+ {"FileHeader.Machine", Field, 0, ""},
+ {"FileHeader.OSABI", Field, 0, ""},
+ {"FileHeader.Type", Field, 0, ""},
+ {"FileHeader.Version", Field, 0, ""},
+ {"FormatError", Type, 0, ""},
+ {"Header32", Type, 0, ""},
+ {"Header32.Ehsize", Field, 0, ""},
+ {"Header32.Entry", Field, 0, ""},
+ {"Header32.Flags", Field, 0, ""},
+ {"Header32.Ident", Field, 0, ""},
+ {"Header32.Machine", Field, 0, ""},
+ {"Header32.Phentsize", Field, 0, ""},
+ {"Header32.Phnum", Field, 0, ""},
+ {"Header32.Phoff", Field, 0, ""},
+ {"Header32.Shentsize", Field, 0, ""},
+ {"Header32.Shnum", Field, 0, ""},
+ {"Header32.Shoff", Field, 0, ""},
+ {"Header32.Shstrndx", Field, 0, ""},
+ {"Header32.Type", Field, 0, ""},
+ {"Header32.Version", Field, 0, ""},
+ {"Header64", Type, 0, ""},
+ {"Header64.Ehsize", Field, 0, ""},
+ {"Header64.Entry", Field, 0, ""},
+ {"Header64.Flags", Field, 0, ""},
+ {"Header64.Ident", Field, 0, ""},
+ {"Header64.Machine", Field, 0, ""},
+ {"Header64.Phentsize", Field, 0, ""},
+ {"Header64.Phnum", Field, 0, ""},
+ {"Header64.Phoff", Field, 0, ""},
+ {"Header64.Shentsize", Field, 0, ""},
+ {"Header64.Shnum", Field, 0, ""},
+ {"Header64.Shoff", Field, 0, ""},
+ {"Header64.Shstrndx", Field, 0, ""},
+ {"Header64.Type", Field, 0, ""},
+ {"Header64.Version", Field, 0, ""},
+ {"ImportedSymbol", Type, 0, ""},
+ {"ImportedSymbol.Library", Field, 0, ""},
+ {"ImportedSymbol.Name", Field, 0, ""},
+ {"ImportedSymbol.Version", Field, 0, ""},
+ {"Machine", Type, 0, ""},
+ {"NT_FPREGSET", Const, 0, ""},
+ {"NT_PRPSINFO", Const, 0, ""},
+ {"NT_PRSTATUS", Const, 0, ""},
+ {"NType", Type, 0, ""},
+ {"NewFile", Func, 0, "func(r io.ReaderAt) (*File, error)"},
+ {"OSABI", Type, 0, ""},
+ {"Open", Func, 0, "func(name string) (*File, error)"},
+ {"PF_MASKOS", Const, 0, ""},
+ {"PF_MASKPROC", Const, 0, ""},
+ {"PF_R", Const, 0, ""},
+ {"PF_W", Const, 0, ""},
+ {"PF_X", Const, 0, ""},
+ {"PT_AARCH64_ARCHEXT", Const, 16, ""},
+ {"PT_AARCH64_UNWIND", Const, 16, ""},
+ {"PT_ARM_ARCHEXT", Const, 16, ""},
+ {"PT_ARM_EXIDX", Const, 16, ""},
+ {"PT_DYNAMIC", Const, 0, ""},
+ {"PT_GNU_EH_FRAME", Const, 16, ""},
+ {"PT_GNU_MBIND_HI", Const, 16, ""},
+ {"PT_GNU_MBIND_LO", Const, 16, ""},
+ {"PT_GNU_PROPERTY", Const, 16, ""},
+ {"PT_GNU_RELRO", Const, 16, ""},
+ {"PT_GNU_STACK", Const, 16, ""},
+ {"PT_HIOS", Const, 0, ""},
+ {"PT_HIPROC", Const, 0, ""},
+ {"PT_INTERP", Const, 0, ""},
+ {"PT_LOAD", Const, 0, ""},
+ {"PT_LOOS", Const, 0, ""},
+ {"PT_LOPROC", Const, 0, ""},
+ {"PT_MIPS_ABIFLAGS", Const, 16, ""},
+ {"PT_MIPS_OPTIONS", Const, 16, ""},
+ {"PT_MIPS_REGINFO", Const, 16, ""},
+ {"PT_MIPS_RTPROC", Const, 16, ""},
+ {"PT_NOTE", Const, 0, ""},
+ {"PT_NULL", Const, 0, ""},
+ {"PT_OPENBSD_BOOTDATA", Const, 16, ""},
+ {"PT_OPENBSD_NOBTCFI", Const, 23, ""},
+ {"PT_OPENBSD_RANDOMIZE", Const, 16, ""},
+ {"PT_OPENBSD_WXNEEDED", Const, 16, ""},
+ {"PT_PAX_FLAGS", Const, 16, ""},
+ {"PT_PHDR", Const, 0, ""},
+ {"PT_RISCV_ATTRIBUTES", Const, 25, ""},
+ {"PT_S390_PGSTE", Const, 16, ""},
+ {"PT_SHLIB", Const, 0, ""},
+ {"PT_SUNWSTACK", Const, 16, ""},
+ {"PT_SUNW_EH_FRAME", Const, 16, ""},
+ {"PT_TLS", Const, 0, ""},
+ {"Prog", Type, 0, ""},
+ {"Prog.ProgHeader", Field, 0, ""},
+ {"Prog.ReaderAt", Field, 0, ""},
+ {"Prog32", Type, 0, ""},
+ {"Prog32.Align", Field, 0, ""},
+ {"Prog32.Filesz", Field, 0, ""},
+ {"Prog32.Flags", Field, 0, ""},
+ {"Prog32.Memsz", Field, 0, ""},
+ {"Prog32.Off", Field, 0, ""},
+ {"Prog32.Paddr", Field, 0, ""},
+ {"Prog32.Type", Field, 0, ""},
+ {"Prog32.Vaddr", Field, 0, ""},
+ {"Prog64", Type, 0, ""},
+ {"Prog64.Align", Field, 0, ""},
+ {"Prog64.Filesz", Field, 0, ""},
+ {"Prog64.Flags", Field, 0, ""},
+ {"Prog64.Memsz", Field, 0, ""},
+ {"Prog64.Off", Field, 0, ""},
+ {"Prog64.Paddr", Field, 0, ""},
+ {"Prog64.Type", Field, 0, ""},
+ {"Prog64.Vaddr", Field, 0, ""},
+ {"ProgFlag", Type, 0, ""},
+ {"ProgHeader", Type, 0, ""},
+ {"ProgHeader.Align", Field, 0, ""},
+ {"ProgHeader.Filesz", Field, 0, ""},
+ {"ProgHeader.Flags", Field, 0, ""},
+ {"ProgHeader.Memsz", Field, 0, ""},
+ {"ProgHeader.Off", Field, 0, ""},
+ {"ProgHeader.Paddr", Field, 0, ""},
+ {"ProgHeader.Type", Field, 0, ""},
+ {"ProgHeader.Vaddr", Field, 0, ""},
+ {"ProgType", Type, 0, ""},
+ {"R_386", Type, 0, ""},
+ {"R_386_16", Const, 10, ""},
+ {"R_386_32", Const, 0, ""},
+ {"R_386_32PLT", Const, 10, ""},
+ {"R_386_8", Const, 10, ""},
+ {"R_386_COPY", Const, 0, ""},
+ {"R_386_GLOB_DAT", Const, 0, ""},
+ {"R_386_GOT32", Const, 0, ""},
+ {"R_386_GOT32X", Const, 10, ""},
+ {"R_386_GOTOFF", Const, 0, ""},
+ {"R_386_GOTPC", Const, 0, ""},
+ {"R_386_IRELATIVE", Const, 10, ""},
+ {"R_386_JMP_SLOT", Const, 0, ""},
+ {"R_386_NONE", Const, 0, ""},
+ {"R_386_PC16", Const, 10, ""},
+ {"R_386_PC32", Const, 0, ""},
+ {"R_386_PC8", Const, 10, ""},
+ {"R_386_PLT32", Const, 0, ""},
+ {"R_386_RELATIVE", Const, 0, ""},
+ {"R_386_SIZE32", Const, 10, ""},
+ {"R_386_TLS_DESC", Const, 10, ""},
+ {"R_386_TLS_DESC_CALL", Const, 10, ""},
+ {"R_386_TLS_DTPMOD32", Const, 0, ""},
+ {"R_386_TLS_DTPOFF32", Const, 0, ""},
+ {"R_386_TLS_GD", Const, 0, ""},
+ {"R_386_TLS_GD_32", Const, 0, ""},
+ {"R_386_TLS_GD_CALL", Const, 0, ""},
+ {"R_386_TLS_GD_POP", Const, 0, ""},
+ {"R_386_TLS_GD_PUSH", Const, 0, ""},
+ {"R_386_TLS_GOTDESC", Const, 10, ""},
+ {"R_386_TLS_GOTIE", Const, 0, ""},
+ {"R_386_TLS_IE", Const, 0, ""},
+ {"R_386_TLS_IE_32", Const, 0, ""},
+ {"R_386_TLS_LDM", Const, 0, ""},
+ {"R_386_TLS_LDM_32", Const, 0, ""},
+ {"R_386_TLS_LDM_CALL", Const, 0, ""},
+ {"R_386_TLS_LDM_POP", Const, 0, ""},
+ {"R_386_TLS_LDM_PUSH", Const, 0, ""},
+ {"R_386_TLS_LDO_32", Const, 0, ""},
+ {"R_386_TLS_LE", Const, 0, ""},
+ {"R_386_TLS_LE_32", Const, 0, ""},
+ {"R_386_TLS_TPOFF", Const, 0, ""},
+ {"R_386_TLS_TPOFF32", Const, 0, ""},
+ {"R_390", Type, 7, ""},
+ {"R_390_12", Const, 7, ""},
+ {"R_390_16", Const, 7, ""},
+ {"R_390_20", Const, 7, ""},
+ {"R_390_32", Const, 7, ""},
+ {"R_390_64", Const, 7, ""},
+ {"R_390_8", Const, 7, ""},
+ {"R_390_COPY", Const, 7, ""},
+ {"R_390_GLOB_DAT", Const, 7, ""},
+ {"R_390_GOT12", Const, 7, ""},
+ {"R_390_GOT16", Const, 7, ""},
+ {"R_390_GOT20", Const, 7, ""},
+ {"R_390_GOT32", Const, 7, ""},
+ {"R_390_GOT64", Const, 7, ""},
+ {"R_390_GOTENT", Const, 7, ""},
+ {"R_390_GOTOFF", Const, 7, ""},
+ {"R_390_GOTOFF16", Const, 7, ""},
+ {"R_390_GOTOFF64", Const, 7, ""},
+ {"R_390_GOTPC", Const, 7, ""},
+ {"R_390_GOTPCDBL", Const, 7, ""},
+ {"R_390_GOTPLT12", Const, 7, ""},
+ {"R_390_GOTPLT16", Const, 7, ""},
+ {"R_390_GOTPLT20", Const, 7, ""},
+ {"R_390_GOTPLT32", Const, 7, ""},
+ {"R_390_GOTPLT64", Const, 7, ""},
+ {"R_390_GOTPLTENT", Const, 7, ""},
+ {"R_390_GOTPLTOFF16", Const, 7, ""},
+ {"R_390_GOTPLTOFF32", Const, 7, ""},
+ {"R_390_GOTPLTOFF64", Const, 7, ""},
+ {"R_390_JMP_SLOT", Const, 7, ""},
+ {"R_390_NONE", Const, 7, ""},
+ {"R_390_PC16", Const, 7, ""},
+ {"R_390_PC16DBL", Const, 7, ""},
+ {"R_390_PC32", Const, 7, ""},
+ {"R_390_PC32DBL", Const, 7, ""},
+ {"R_390_PC64", Const, 7, ""},
+ {"R_390_PLT16DBL", Const, 7, ""},
+ {"R_390_PLT32", Const, 7, ""},
+ {"R_390_PLT32DBL", Const, 7, ""},
+ {"R_390_PLT64", Const, 7, ""},
+ {"R_390_RELATIVE", Const, 7, ""},
+ {"R_390_TLS_DTPMOD", Const, 7, ""},
+ {"R_390_TLS_DTPOFF", Const, 7, ""},
+ {"R_390_TLS_GD32", Const, 7, ""},
+ {"R_390_TLS_GD64", Const, 7, ""},
+ {"R_390_TLS_GDCALL", Const, 7, ""},
+ {"R_390_TLS_GOTIE12", Const, 7, ""},
+ {"R_390_TLS_GOTIE20", Const, 7, ""},
+ {"R_390_TLS_GOTIE32", Const, 7, ""},
+ {"R_390_TLS_GOTIE64", Const, 7, ""},
+ {"R_390_TLS_IE32", Const, 7, ""},
+ {"R_390_TLS_IE64", Const, 7, ""},
+ {"R_390_TLS_IEENT", Const, 7, ""},
+ {"R_390_TLS_LDCALL", Const, 7, ""},
+ {"R_390_TLS_LDM32", Const, 7, ""},
+ {"R_390_TLS_LDM64", Const, 7, ""},
+ {"R_390_TLS_LDO32", Const, 7, ""},
+ {"R_390_TLS_LDO64", Const, 7, ""},
+ {"R_390_TLS_LE32", Const, 7, ""},
+ {"R_390_TLS_LE64", Const, 7, ""},
+ {"R_390_TLS_LOAD", Const, 7, ""},
+ {"R_390_TLS_TPOFF", Const, 7, ""},
+ {"R_AARCH64", Type, 4, ""},
+ {"R_AARCH64_ABS16", Const, 4, ""},
+ {"R_AARCH64_ABS32", Const, 4, ""},
+ {"R_AARCH64_ABS64", Const, 4, ""},
+ {"R_AARCH64_ADD_ABS_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_ADR_GOT_PAGE", Const, 4, ""},
+ {"R_AARCH64_ADR_PREL_LO21", Const, 4, ""},
+ {"R_AARCH64_ADR_PREL_PG_HI21", Const, 4, ""},
+ {"R_AARCH64_ADR_PREL_PG_HI21_NC", Const, 4, ""},
+ {"R_AARCH64_CALL26", Const, 4, ""},
+ {"R_AARCH64_CONDBR19", Const, 4, ""},
+ {"R_AARCH64_COPY", Const, 4, ""},
+ {"R_AARCH64_GLOB_DAT", Const, 4, ""},
+ {"R_AARCH64_GOT_LD_PREL19", Const, 4, ""},
+ {"R_AARCH64_IRELATIVE", Const, 4, ""},
+ {"R_AARCH64_JUMP26", Const, 4, ""},
+ {"R_AARCH64_JUMP_SLOT", Const, 4, ""},
+ {"R_AARCH64_LD64_GOTOFF_LO15", Const, 10, ""},
+ {"R_AARCH64_LD64_GOTPAGE_LO15", Const, 10, ""},
+ {"R_AARCH64_LD64_GOT_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_LDST128_ABS_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_LDST16_ABS_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_LDST32_ABS_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_LDST64_ABS_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_LDST8_ABS_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_LD_PREL_LO19", Const, 4, ""},
+ {"R_AARCH64_MOVW_SABS_G0", Const, 4, ""},
+ {"R_AARCH64_MOVW_SABS_G1", Const, 4, ""},
+ {"R_AARCH64_MOVW_SABS_G2", Const, 4, ""},
+ {"R_AARCH64_MOVW_UABS_G0", Const, 4, ""},
+ {"R_AARCH64_MOVW_UABS_G0_NC", Const, 4, ""},
+ {"R_AARCH64_MOVW_UABS_G1", Const, 4, ""},
+ {"R_AARCH64_MOVW_UABS_G1_NC", Const, 4, ""},
+ {"R_AARCH64_MOVW_UABS_G2", Const, 4, ""},
+ {"R_AARCH64_MOVW_UABS_G2_NC", Const, 4, ""},
+ {"R_AARCH64_MOVW_UABS_G3", Const, 4, ""},
+ {"R_AARCH64_NONE", Const, 4, ""},
+ {"R_AARCH64_NULL", Const, 4, ""},
+ {"R_AARCH64_P32_ABS16", Const, 4, ""},
+ {"R_AARCH64_P32_ABS32", Const, 4, ""},
+ {"R_AARCH64_P32_ADD_ABS_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_P32_ADR_GOT_PAGE", Const, 4, ""},
+ {"R_AARCH64_P32_ADR_PREL_LO21", Const, 4, ""},
+ {"R_AARCH64_P32_ADR_PREL_PG_HI21", Const, 4, ""},
+ {"R_AARCH64_P32_CALL26", Const, 4, ""},
+ {"R_AARCH64_P32_CONDBR19", Const, 4, ""},
+ {"R_AARCH64_P32_COPY", Const, 4, ""},
+ {"R_AARCH64_P32_GLOB_DAT", Const, 4, ""},
+ {"R_AARCH64_P32_GOT_LD_PREL19", Const, 4, ""},
+ {"R_AARCH64_P32_IRELATIVE", Const, 4, ""},
+ {"R_AARCH64_P32_JUMP26", Const, 4, ""},
+ {"R_AARCH64_P32_JUMP_SLOT", Const, 4, ""},
+ {"R_AARCH64_P32_LD32_GOT_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_P32_LDST128_ABS_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_P32_LDST16_ABS_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_P32_LDST32_ABS_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_P32_LDST64_ABS_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_P32_LDST8_ABS_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_P32_LD_PREL_LO19", Const, 4, ""},
+ {"R_AARCH64_P32_MOVW_SABS_G0", Const, 4, ""},
+ {"R_AARCH64_P32_MOVW_UABS_G0", Const, 4, ""},
+ {"R_AARCH64_P32_MOVW_UABS_G0_NC", Const, 4, ""},
+ {"R_AARCH64_P32_MOVW_UABS_G1", Const, 4, ""},
+ {"R_AARCH64_P32_PREL16", Const, 4, ""},
+ {"R_AARCH64_P32_PREL32", Const, 4, ""},
+ {"R_AARCH64_P32_RELATIVE", Const, 4, ""},
+ {"R_AARCH64_P32_TLSDESC", Const, 4, ""},
+ {"R_AARCH64_P32_TLSDESC_ADD_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_P32_TLSDESC_ADR_PAGE21", Const, 4, ""},
+ {"R_AARCH64_P32_TLSDESC_ADR_PREL21", Const, 4, ""},
+ {"R_AARCH64_P32_TLSDESC_CALL", Const, 4, ""},
+ {"R_AARCH64_P32_TLSDESC_LD32_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_P32_TLSDESC_LD_PREL19", Const, 4, ""},
+ {"R_AARCH64_P32_TLSGD_ADD_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_P32_TLSGD_ADR_PAGE21", Const, 4, ""},
+ {"R_AARCH64_P32_TLSIE_ADR_GOTTPREL_PAGE21", Const, 4, ""},
+ {"R_AARCH64_P32_TLSIE_LD32_GOTTPREL_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_P32_TLSIE_LD_GOTTPREL_PREL19", Const, 4, ""},
+ {"R_AARCH64_P32_TLSLE_ADD_TPREL_HI12", Const, 4, ""},
+ {"R_AARCH64_P32_TLSLE_ADD_TPREL_LO12", Const, 4, ""},
+ {"R_AARCH64_P32_TLSLE_ADD_TPREL_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_P32_TLSLE_MOVW_TPREL_G0", Const, 4, ""},
+ {"R_AARCH64_P32_TLSLE_MOVW_TPREL_G0_NC", Const, 4, ""},
+ {"R_AARCH64_P32_TLSLE_MOVW_TPREL_G1", Const, 4, ""},
+ {"R_AARCH64_P32_TLS_DTPMOD", Const, 4, ""},
+ {"R_AARCH64_P32_TLS_DTPREL", Const, 4, ""},
+ {"R_AARCH64_P32_TLS_TPREL", Const, 4, ""},
+ {"R_AARCH64_P32_TSTBR14", Const, 4, ""},
+ {"R_AARCH64_PREL16", Const, 4, ""},
+ {"R_AARCH64_PREL32", Const, 4, ""},
+ {"R_AARCH64_PREL64", Const, 4, ""},
+ {"R_AARCH64_RELATIVE", Const, 4, ""},
+ {"R_AARCH64_TLSDESC", Const, 4, ""},
+ {"R_AARCH64_TLSDESC_ADD", Const, 4, ""},
+ {"R_AARCH64_TLSDESC_ADD_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_TLSDESC_ADR_PAGE21", Const, 4, ""},
+ {"R_AARCH64_TLSDESC_ADR_PREL21", Const, 4, ""},
+ {"R_AARCH64_TLSDESC_CALL", Const, 4, ""},
+ {"R_AARCH64_TLSDESC_LD64_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_TLSDESC_LDR", Const, 4, ""},
+ {"R_AARCH64_TLSDESC_LD_PREL19", Const, 4, ""},
+ {"R_AARCH64_TLSDESC_OFF_G0_NC", Const, 4, ""},
+ {"R_AARCH64_TLSDESC_OFF_G1", Const, 4, ""},
+ {"R_AARCH64_TLSGD_ADD_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_TLSGD_ADR_PAGE21", Const, 4, ""},
+ {"R_AARCH64_TLSGD_ADR_PREL21", Const, 10, ""},
+ {"R_AARCH64_TLSGD_MOVW_G0_NC", Const, 10, ""},
+ {"R_AARCH64_TLSGD_MOVW_G1", Const, 10, ""},
+ {"R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21", Const, 4, ""},
+ {"R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_TLSIE_LD_GOTTPREL_PREL19", Const, 4, ""},
+ {"R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC", Const, 4, ""},
+ {"R_AARCH64_TLSIE_MOVW_GOTTPREL_G1", Const, 4, ""},
+ {"R_AARCH64_TLSLD_ADR_PAGE21", Const, 10, ""},
+ {"R_AARCH64_TLSLD_ADR_PREL21", Const, 10, ""},
+ {"R_AARCH64_TLSLD_LDST128_DTPREL_LO12", Const, 10, ""},
+ {"R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC", Const, 10, ""},
+ {"R_AARCH64_TLSLE_ADD_TPREL_HI12", Const, 4, ""},
+ {"R_AARCH64_TLSLE_ADD_TPREL_LO12", Const, 4, ""},
+ {"R_AARCH64_TLSLE_ADD_TPREL_LO12_NC", Const, 4, ""},
+ {"R_AARCH64_TLSLE_LDST128_TPREL_LO12", Const, 10, ""},
+ {"R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC", Const, 10, ""},
+ {"R_AARCH64_TLSLE_MOVW_TPREL_G0", Const, 4, ""},
+ {"R_AARCH64_TLSLE_MOVW_TPREL_G0_NC", Const, 4, ""},
+ {"R_AARCH64_TLSLE_MOVW_TPREL_G1", Const, 4, ""},
+ {"R_AARCH64_TLSLE_MOVW_TPREL_G1_NC", Const, 4, ""},
+ {"R_AARCH64_TLSLE_MOVW_TPREL_G2", Const, 4, ""},
+ {"R_AARCH64_TLS_DTPMOD64", Const, 4, ""},
+ {"R_AARCH64_TLS_DTPREL64", Const, 4, ""},
+ {"R_AARCH64_TLS_TPREL64", Const, 4, ""},
+ {"R_AARCH64_TSTBR14", Const, 4, ""},
+ {"R_ALPHA", Type, 0, ""},
+ {"R_ALPHA_BRADDR", Const, 0, ""},
+ {"R_ALPHA_COPY", Const, 0, ""},
+ {"R_ALPHA_GLOB_DAT", Const, 0, ""},
+ {"R_ALPHA_GPDISP", Const, 0, ""},
+ {"R_ALPHA_GPREL32", Const, 0, ""},
+ {"R_ALPHA_GPRELHIGH", Const, 0, ""},
+ {"R_ALPHA_GPRELLOW", Const, 0, ""},
+ {"R_ALPHA_GPVALUE", Const, 0, ""},
+ {"R_ALPHA_HINT", Const, 0, ""},
+ {"R_ALPHA_IMMED_BR_HI32", Const, 0, ""},
+ {"R_ALPHA_IMMED_GP_16", Const, 0, ""},
+ {"R_ALPHA_IMMED_GP_HI32", Const, 0, ""},
+ {"R_ALPHA_IMMED_LO32", Const, 0, ""},
+ {"R_ALPHA_IMMED_SCN_HI32", Const, 0, ""},
+ {"R_ALPHA_JMP_SLOT", Const, 0, ""},
+ {"R_ALPHA_LITERAL", Const, 0, ""},
+ {"R_ALPHA_LITUSE", Const, 0, ""},
+ {"R_ALPHA_NONE", Const, 0, ""},
+ {"R_ALPHA_OP_PRSHIFT", Const, 0, ""},
+ {"R_ALPHA_OP_PSUB", Const, 0, ""},
+ {"R_ALPHA_OP_PUSH", Const, 0, ""},
+ {"R_ALPHA_OP_STORE", Const, 0, ""},
+ {"R_ALPHA_REFLONG", Const, 0, ""},
+ {"R_ALPHA_REFQUAD", Const, 0, ""},
+ {"R_ALPHA_RELATIVE", Const, 0, ""},
+ {"R_ALPHA_SREL16", Const, 0, ""},
+ {"R_ALPHA_SREL32", Const, 0, ""},
+ {"R_ALPHA_SREL64", Const, 0, ""},
+ {"R_ARM", Type, 0, ""},
+ {"R_ARM_ABS12", Const, 0, ""},
+ {"R_ARM_ABS16", Const, 0, ""},
+ {"R_ARM_ABS32", Const, 0, ""},
+ {"R_ARM_ABS32_NOI", Const, 10, ""},
+ {"R_ARM_ABS8", Const, 0, ""},
+ {"R_ARM_ALU_PCREL_15_8", Const, 10, ""},
+ {"R_ARM_ALU_PCREL_23_15", Const, 10, ""},
+ {"R_ARM_ALU_PCREL_7_0", Const, 10, ""},
+ {"R_ARM_ALU_PC_G0", Const, 10, ""},
+ {"R_ARM_ALU_PC_G0_NC", Const, 10, ""},
+ {"R_ARM_ALU_PC_G1", Const, 10, ""},
+ {"R_ARM_ALU_PC_G1_NC", Const, 10, ""},
+ {"R_ARM_ALU_PC_G2", Const, 10, ""},
+ {"R_ARM_ALU_SBREL_19_12_NC", Const, 10, ""},
+ {"R_ARM_ALU_SBREL_27_20_CK", Const, 10, ""},
+ {"R_ARM_ALU_SB_G0", Const, 10, ""},
+ {"R_ARM_ALU_SB_G0_NC", Const, 10, ""},
+ {"R_ARM_ALU_SB_G1", Const, 10, ""},
+ {"R_ARM_ALU_SB_G1_NC", Const, 10, ""},
+ {"R_ARM_ALU_SB_G2", Const, 10, ""},
+ {"R_ARM_AMP_VCALL9", Const, 0, ""},
+ {"R_ARM_BASE_ABS", Const, 10, ""},
+ {"R_ARM_CALL", Const, 10, ""},
+ {"R_ARM_COPY", Const, 0, ""},
+ {"R_ARM_GLOB_DAT", Const, 0, ""},
+ {"R_ARM_GNU_VTENTRY", Const, 0, ""},
+ {"R_ARM_GNU_VTINHERIT", Const, 0, ""},
+ {"R_ARM_GOT32", Const, 0, ""},
+ {"R_ARM_GOTOFF", Const, 0, ""},
+ {"R_ARM_GOTOFF12", Const, 10, ""},
+ {"R_ARM_GOTPC", Const, 0, ""},
+ {"R_ARM_GOTRELAX", Const, 10, ""},
+ {"R_ARM_GOT_ABS", Const, 10, ""},
+ {"R_ARM_GOT_BREL12", Const, 10, ""},
+ {"R_ARM_GOT_PREL", Const, 10, ""},
+ {"R_ARM_IRELATIVE", Const, 10, ""},
+ {"R_ARM_JUMP24", Const, 10, ""},
+ {"R_ARM_JUMP_SLOT", Const, 0, ""},
+ {"R_ARM_LDC_PC_G0", Const, 10, ""},
+ {"R_ARM_LDC_PC_G1", Const, 10, ""},
+ {"R_ARM_LDC_PC_G2", Const, 10, ""},
+ {"R_ARM_LDC_SB_G0", Const, 10, ""},
+ {"R_ARM_LDC_SB_G1", Const, 10, ""},
+ {"R_ARM_LDC_SB_G2", Const, 10, ""},
+ {"R_ARM_LDRS_PC_G0", Const, 10, ""},
+ {"R_ARM_LDRS_PC_G1", Const, 10, ""},
+ {"R_ARM_LDRS_PC_G2", Const, 10, ""},
+ {"R_ARM_LDRS_SB_G0", Const, 10, ""},
+ {"R_ARM_LDRS_SB_G1", Const, 10, ""},
+ {"R_ARM_LDRS_SB_G2", Const, 10, ""},
+ {"R_ARM_LDR_PC_G1", Const, 10, ""},
+ {"R_ARM_LDR_PC_G2", Const, 10, ""},
+ {"R_ARM_LDR_SBREL_11_10_NC", Const, 10, ""},
+ {"R_ARM_LDR_SB_G0", Const, 10, ""},
+ {"R_ARM_LDR_SB_G1", Const, 10, ""},
+ {"R_ARM_LDR_SB_G2", Const, 10, ""},
+ {"R_ARM_ME_TOO", Const, 10, ""},
+ {"R_ARM_MOVT_ABS", Const, 10, ""},
+ {"R_ARM_MOVT_BREL", Const, 10, ""},
+ {"R_ARM_MOVT_PREL", Const, 10, ""},
+ {"R_ARM_MOVW_ABS_NC", Const, 10, ""},
+ {"R_ARM_MOVW_BREL", Const, 10, ""},
+ {"R_ARM_MOVW_BREL_NC", Const, 10, ""},
+ {"R_ARM_MOVW_PREL_NC", Const, 10, ""},
+ {"R_ARM_NONE", Const, 0, ""},
+ {"R_ARM_PC13", Const, 0, ""},
+ {"R_ARM_PC24", Const, 0, ""},
+ {"R_ARM_PLT32", Const, 0, ""},
+ {"R_ARM_PLT32_ABS", Const, 10, ""},
+ {"R_ARM_PREL31", Const, 10, ""},
+ {"R_ARM_PRIVATE_0", Const, 10, ""},
+ {"R_ARM_PRIVATE_1", Const, 10, ""},
+ {"R_ARM_PRIVATE_10", Const, 10, ""},
+ {"R_ARM_PRIVATE_11", Const, 10, ""},
+ {"R_ARM_PRIVATE_12", Const, 10, ""},
+ {"R_ARM_PRIVATE_13", Const, 10, ""},
+ {"R_ARM_PRIVATE_14", Const, 10, ""},
+ {"R_ARM_PRIVATE_15", Const, 10, ""},
+ {"R_ARM_PRIVATE_2", Const, 10, ""},
+ {"R_ARM_PRIVATE_3", Const, 10, ""},
+ {"R_ARM_PRIVATE_4", Const, 10, ""},
+ {"R_ARM_PRIVATE_5", Const, 10, ""},
+ {"R_ARM_PRIVATE_6", Const, 10, ""},
+ {"R_ARM_PRIVATE_7", Const, 10, ""},
+ {"R_ARM_PRIVATE_8", Const, 10, ""},
+ {"R_ARM_PRIVATE_9", Const, 10, ""},
+ {"R_ARM_RABS32", Const, 0, ""},
+ {"R_ARM_RBASE", Const, 0, ""},
+ {"R_ARM_REL32", Const, 0, ""},
+ {"R_ARM_REL32_NOI", Const, 10, ""},
+ {"R_ARM_RELATIVE", Const, 0, ""},
+ {"R_ARM_RPC24", Const, 0, ""},
+ {"R_ARM_RREL32", Const, 0, ""},
+ {"R_ARM_RSBREL32", Const, 0, ""},
+ {"R_ARM_RXPC25", Const, 10, ""},
+ {"R_ARM_SBREL31", Const, 10, ""},
+ {"R_ARM_SBREL32", Const, 0, ""},
+ {"R_ARM_SWI24", Const, 0, ""},
+ {"R_ARM_TARGET1", Const, 10, ""},
+ {"R_ARM_TARGET2", Const, 10, ""},
+ {"R_ARM_THM_ABS5", Const, 0, ""},
+ {"R_ARM_THM_ALU_ABS_G0_NC", Const, 10, ""},
+ {"R_ARM_THM_ALU_ABS_G1_NC", Const, 10, ""},
+ {"R_ARM_THM_ALU_ABS_G2_NC", Const, 10, ""},
+ {"R_ARM_THM_ALU_ABS_G3", Const, 10, ""},
+ {"R_ARM_THM_ALU_PREL_11_0", Const, 10, ""},
+ {"R_ARM_THM_GOT_BREL12", Const, 10, ""},
+ {"R_ARM_THM_JUMP11", Const, 10, ""},
+ {"R_ARM_THM_JUMP19", Const, 10, ""},
+ {"R_ARM_THM_JUMP24", Const, 10, ""},
+ {"R_ARM_THM_JUMP6", Const, 10, ""},
+ {"R_ARM_THM_JUMP8", Const, 10, ""},
+ {"R_ARM_THM_MOVT_ABS", Const, 10, ""},
+ {"R_ARM_THM_MOVT_BREL", Const, 10, ""},
+ {"R_ARM_THM_MOVT_PREL", Const, 10, ""},
+ {"R_ARM_THM_MOVW_ABS_NC", Const, 10, ""},
+ {"R_ARM_THM_MOVW_BREL", Const, 10, ""},
+ {"R_ARM_THM_MOVW_BREL_NC", Const, 10, ""},
+ {"R_ARM_THM_MOVW_PREL_NC", Const, 10, ""},
+ {"R_ARM_THM_PC12", Const, 10, ""},
+ {"R_ARM_THM_PC22", Const, 0, ""},
+ {"R_ARM_THM_PC8", Const, 0, ""},
+ {"R_ARM_THM_RPC22", Const, 0, ""},
+ {"R_ARM_THM_SWI8", Const, 0, ""},
+ {"R_ARM_THM_TLS_CALL", Const, 10, ""},
+ {"R_ARM_THM_TLS_DESCSEQ16", Const, 10, ""},
+ {"R_ARM_THM_TLS_DESCSEQ32", Const, 10, ""},
+ {"R_ARM_THM_XPC22", Const, 0, ""},
+ {"R_ARM_TLS_CALL", Const, 10, ""},
+ {"R_ARM_TLS_DESCSEQ", Const, 10, ""},
+ {"R_ARM_TLS_DTPMOD32", Const, 10, ""},
+ {"R_ARM_TLS_DTPOFF32", Const, 10, ""},
+ {"R_ARM_TLS_GD32", Const, 10, ""},
+ {"R_ARM_TLS_GOTDESC", Const, 10, ""},
+ {"R_ARM_TLS_IE12GP", Const, 10, ""},
+ {"R_ARM_TLS_IE32", Const, 10, ""},
+ {"R_ARM_TLS_LDM32", Const, 10, ""},
+ {"R_ARM_TLS_LDO12", Const, 10, ""},
+ {"R_ARM_TLS_LDO32", Const, 10, ""},
+ {"R_ARM_TLS_LE12", Const, 10, ""},
+ {"R_ARM_TLS_LE32", Const, 10, ""},
+ {"R_ARM_TLS_TPOFF32", Const, 10, ""},
+ {"R_ARM_V4BX", Const, 10, ""},
+ {"R_ARM_XPC25", Const, 0, ""},
+ {"R_INFO", Func, 0, "func(sym uint32, typ uint32) uint64"},
+ {"R_INFO32", Func, 0, "func(sym uint32, typ uint32) uint32"},
+ {"R_LARCH", Type, 19, ""},
+ {"R_LARCH_32", Const, 19, ""},
+ {"R_LARCH_32_PCREL", Const, 20, ""},
+ {"R_LARCH_64", Const, 19, ""},
+ {"R_LARCH_64_PCREL", Const, 22, ""},
+ {"R_LARCH_ABS64_HI12", Const, 20, ""},
+ {"R_LARCH_ABS64_LO20", Const, 20, ""},
+ {"R_LARCH_ABS_HI20", Const, 20, ""},
+ {"R_LARCH_ABS_LO12", Const, 20, ""},
+ {"R_LARCH_ADD16", Const, 19, ""},
+ {"R_LARCH_ADD24", Const, 19, ""},
+ {"R_LARCH_ADD32", Const, 19, ""},
+ {"R_LARCH_ADD6", Const, 22, ""},
+ {"R_LARCH_ADD64", Const, 19, ""},
+ {"R_LARCH_ADD8", Const, 19, ""},
+ {"R_LARCH_ADD_ULEB128", Const, 22, ""},
+ {"R_LARCH_ALIGN", Const, 22, ""},
+ {"R_LARCH_B16", Const, 20, ""},
+ {"R_LARCH_B21", Const, 20, ""},
+ {"R_LARCH_B26", Const, 20, ""},
+ {"R_LARCH_CFA", Const, 22, ""},
+ {"R_LARCH_COPY", Const, 19, ""},
+ {"R_LARCH_DELETE", Const, 22, ""},
+ {"R_LARCH_GNU_VTENTRY", Const, 20, ""},
+ {"R_LARCH_GNU_VTINHERIT", Const, 20, ""},
+ {"R_LARCH_GOT64_HI12", Const, 20, ""},
+ {"R_LARCH_GOT64_LO20", Const, 20, ""},
+ {"R_LARCH_GOT64_PC_HI12", Const, 20, ""},
+ {"R_LARCH_GOT64_PC_LO20", Const, 20, ""},
+ {"R_LARCH_GOT_HI20", Const, 20, ""},
+ {"R_LARCH_GOT_LO12", Const, 20, ""},
+ {"R_LARCH_GOT_PC_HI20", Const, 20, ""},
+ {"R_LARCH_GOT_PC_LO12", Const, 20, ""},
+ {"R_LARCH_IRELATIVE", Const, 19, ""},
+ {"R_LARCH_JUMP_SLOT", Const, 19, ""},
+ {"R_LARCH_MARK_LA", Const, 19, ""},
+ {"R_LARCH_MARK_PCREL", Const, 19, ""},
+ {"R_LARCH_NONE", Const, 19, ""},
+ {"R_LARCH_PCALA64_HI12", Const, 20, ""},
+ {"R_LARCH_PCALA64_LO20", Const, 20, ""},
+ {"R_LARCH_PCALA_HI20", Const, 20, ""},
+ {"R_LARCH_PCALA_LO12", Const, 20, ""},
+ {"R_LARCH_PCREL20_S2", Const, 22, ""},
+ {"R_LARCH_RELATIVE", Const, 19, ""},
+ {"R_LARCH_RELAX", Const, 20, ""},
+ {"R_LARCH_SOP_ADD", Const, 19, ""},
+ {"R_LARCH_SOP_AND", Const, 19, ""},
+ {"R_LARCH_SOP_ASSERT", Const, 19, ""},
+ {"R_LARCH_SOP_IF_ELSE", Const, 19, ""},
+ {"R_LARCH_SOP_NOT", Const, 19, ""},
+ {"R_LARCH_SOP_POP_32_S_0_10_10_16_S2", Const, 19, ""},
+ {"R_LARCH_SOP_POP_32_S_0_5_10_16_S2", Const, 19, ""},
+ {"R_LARCH_SOP_POP_32_S_10_12", Const, 19, ""},
+ {"R_LARCH_SOP_POP_32_S_10_16", Const, 19, ""},
+ {"R_LARCH_SOP_POP_32_S_10_16_S2", Const, 19, ""},
+ {"R_LARCH_SOP_POP_32_S_10_5", Const, 19, ""},
+ {"R_LARCH_SOP_POP_32_S_5_20", Const, 19, ""},
+ {"R_LARCH_SOP_POP_32_U", Const, 19, ""},
+ {"R_LARCH_SOP_POP_32_U_10_12", Const, 19, ""},
+ {"R_LARCH_SOP_PUSH_ABSOLUTE", Const, 19, ""},
+ {"R_LARCH_SOP_PUSH_DUP", Const, 19, ""},
+ {"R_LARCH_SOP_PUSH_GPREL", Const, 19, ""},
+ {"R_LARCH_SOP_PUSH_PCREL", Const, 19, ""},
+ {"R_LARCH_SOP_PUSH_PLT_PCREL", Const, 19, ""},
+ {"R_LARCH_SOP_PUSH_TLS_GD", Const, 19, ""},
+ {"R_LARCH_SOP_PUSH_TLS_GOT", Const, 19, ""},
+ {"R_LARCH_SOP_PUSH_TLS_TPREL", Const, 19, ""},
+ {"R_LARCH_SOP_SL", Const, 19, ""},
+ {"R_LARCH_SOP_SR", Const, 19, ""},
+ {"R_LARCH_SOP_SUB", Const, 19, ""},
+ {"R_LARCH_SUB16", Const, 19, ""},
+ {"R_LARCH_SUB24", Const, 19, ""},
+ {"R_LARCH_SUB32", Const, 19, ""},
+ {"R_LARCH_SUB6", Const, 22, ""},
+ {"R_LARCH_SUB64", Const, 19, ""},
+ {"R_LARCH_SUB8", Const, 19, ""},
+ {"R_LARCH_SUB_ULEB128", Const, 22, ""},
+ {"R_LARCH_TLS_DTPMOD32", Const, 19, ""},
+ {"R_LARCH_TLS_DTPMOD64", Const, 19, ""},
+ {"R_LARCH_TLS_DTPREL32", Const, 19, ""},
+ {"R_LARCH_TLS_DTPREL64", Const, 19, ""},
+ {"R_LARCH_TLS_GD_HI20", Const, 20, ""},
+ {"R_LARCH_TLS_GD_PC_HI20", Const, 20, ""},
+ {"R_LARCH_TLS_IE64_HI12", Const, 20, ""},
+ {"R_LARCH_TLS_IE64_LO20", Const, 20, ""},
+ {"R_LARCH_TLS_IE64_PC_HI12", Const, 20, ""},
+ {"R_LARCH_TLS_IE64_PC_LO20", Const, 20, ""},
+ {"R_LARCH_TLS_IE_HI20", Const, 20, ""},
+ {"R_LARCH_TLS_IE_LO12", Const, 20, ""},
+ {"R_LARCH_TLS_IE_PC_HI20", Const, 20, ""},
+ {"R_LARCH_TLS_IE_PC_LO12", Const, 20, ""},
+ {"R_LARCH_TLS_LD_HI20", Const, 20, ""},
+ {"R_LARCH_TLS_LD_PC_HI20", Const, 20, ""},
+ {"R_LARCH_TLS_LE64_HI12", Const, 20, ""},
+ {"R_LARCH_TLS_LE64_LO20", Const, 20, ""},
+ {"R_LARCH_TLS_LE_HI20", Const, 20, ""},
+ {"R_LARCH_TLS_LE_LO12", Const, 20, ""},
+ {"R_LARCH_TLS_TPREL32", Const, 19, ""},
+ {"R_LARCH_TLS_TPREL64", Const, 19, ""},
+ {"R_MIPS", Type, 6, ""},
+ {"R_MIPS_16", Const, 6, ""},
+ {"R_MIPS_26", Const, 6, ""},
+ {"R_MIPS_32", Const, 6, ""},
+ {"R_MIPS_64", Const, 6, ""},
+ {"R_MIPS_ADD_IMMEDIATE", Const, 6, ""},
+ {"R_MIPS_CALL16", Const, 6, ""},
+ {"R_MIPS_CALL_HI16", Const, 6, ""},
+ {"R_MIPS_CALL_LO16", Const, 6, ""},
+ {"R_MIPS_DELETE", Const, 6, ""},
+ {"R_MIPS_GOT16", Const, 6, ""},
+ {"R_MIPS_GOT_DISP", Const, 6, ""},
+ {"R_MIPS_GOT_HI16", Const, 6, ""},
+ {"R_MIPS_GOT_LO16", Const, 6, ""},
+ {"R_MIPS_GOT_OFST", Const, 6, ""},
+ {"R_MIPS_GOT_PAGE", Const, 6, ""},
+ {"R_MIPS_GPREL16", Const, 6, ""},
+ {"R_MIPS_GPREL32", Const, 6, ""},
+ {"R_MIPS_HI16", Const, 6, ""},
+ {"R_MIPS_HIGHER", Const, 6, ""},
+ {"R_MIPS_HIGHEST", Const, 6, ""},
+ {"R_MIPS_INSERT_A", Const, 6, ""},
+ {"R_MIPS_INSERT_B", Const, 6, ""},
+ {"R_MIPS_JALR", Const, 6, ""},
+ {"R_MIPS_LITERAL", Const, 6, ""},
+ {"R_MIPS_LO16", Const, 6, ""},
+ {"R_MIPS_NONE", Const, 6, ""},
+ {"R_MIPS_PC16", Const, 6, ""},
+ {"R_MIPS_PC32", Const, 22, ""},
+ {"R_MIPS_PJUMP", Const, 6, ""},
+ {"R_MIPS_REL16", Const, 6, ""},
+ {"R_MIPS_REL32", Const, 6, ""},
+ {"R_MIPS_RELGOT", Const, 6, ""},
+ {"R_MIPS_SCN_DISP", Const, 6, ""},
+ {"R_MIPS_SHIFT5", Const, 6, ""},
+ {"R_MIPS_SHIFT6", Const, 6, ""},
+ {"R_MIPS_SUB", Const, 6, ""},
+ {"R_MIPS_TLS_DTPMOD32", Const, 6, ""},
+ {"R_MIPS_TLS_DTPMOD64", Const, 6, ""},
+ {"R_MIPS_TLS_DTPREL32", Const, 6, ""},
+ {"R_MIPS_TLS_DTPREL64", Const, 6, ""},
+ {"R_MIPS_TLS_DTPREL_HI16", Const, 6, ""},
+ {"R_MIPS_TLS_DTPREL_LO16", Const, 6, ""},
+ {"R_MIPS_TLS_GD", Const, 6, ""},
+ {"R_MIPS_TLS_GOTTPREL", Const, 6, ""},
+ {"R_MIPS_TLS_LDM", Const, 6, ""},
+ {"R_MIPS_TLS_TPREL32", Const, 6, ""},
+ {"R_MIPS_TLS_TPREL64", Const, 6, ""},
+ {"R_MIPS_TLS_TPREL_HI16", Const, 6, ""},
+ {"R_MIPS_TLS_TPREL_LO16", Const, 6, ""},
+ {"R_PPC", Type, 0, ""},
+ {"R_PPC64", Type, 5, ""},
+ {"R_PPC64_ADDR14", Const, 5, ""},
+ {"R_PPC64_ADDR14_BRNTAKEN", Const, 5, ""},
+ {"R_PPC64_ADDR14_BRTAKEN", Const, 5, ""},
+ {"R_PPC64_ADDR16", Const, 5, ""},
+ {"R_PPC64_ADDR16_DS", Const, 5, ""},
+ {"R_PPC64_ADDR16_HA", Const, 5, ""},
+ {"R_PPC64_ADDR16_HI", Const, 5, ""},
+ {"R_PPC64_ADDR16_HIGH", Const, 10, ""},
+ {"R_PPC64_ADDR16_HIGHA", Const, 10, ""},
+ {"R_PPC64_ADDR16_HIGHER", Const, 5, ""},
+ {"R_PPC64_ADDR16_HIGHER34", Const, 20, ""},
+ {"R_PPC64_ADDR16_HIGHERA", Const, 5, ""},
+ {"R_PPC64_ADDR16_HIGHERA34", Const, 20, ""},
+ {"R_PPC64_ADDR16_HIGHEST", Const, 5, ""},
+ {"R_PPC64_ADDR16_HIGHEST34", Const, 20, ""},
+ {"R_PPC64_ADDR16_HIGHESTA", Const, 5, ""},
+ {"R_PPC64_ADDR16_HIGHESTA34", Const, 20, ""},
+ {"R_PPC64_ADDR16_LO", Const, 5, ""},
+ {"R_PPC64_ADDR16_LO_DS", Const, 5, ""},
+ {"R_PPC64_ADDR24", Const, 5, ""},
+ {"R_PPC64_ADDR32", Const, 5, ""},
+ {"R_PPC64_ADDR64", Const, 5, ""},
+ {"R_PPC64_ADDR64_LOCAL", Const, 10, ""},
+ {"R_PPC64_COPY", Const, 20, ""},
+ {"R_PPC64_D28", Const, 20, ""},
+ {"R_PPC64_D34", Const, 20, ""},
+ {"R_PPC64_D34_HA30", Const, 20, ""},
+ {"R_PPC64_D34_HI30", Const, 20, ""},
+ {"R_PPC64_D34_LO", Const, 20, ""},
+ {"R_PPC64_DTPMOD64", Const, 5, ""},
+ {"R_PPC64_DTPREL16", Const, 5, ""},
+ {"R_PPC64_DTPREL16_DS", Const, 5, ""},
+ {"R_PPC64_DTPREL16_HA", Const, 5, ""},
+ {"R_PPC64_DTPREL16_HI", Const, 5, ""},
+ {"R_PPC64_DTPREL16_HIGH", Const, 10, ""},
+ {"R_PPC64_DTPREL16_HIGHA", Const, 10, ""},
+ {"R_PPC64_DTPREL16_HIGHER", Const, 5, ""},
+ {"R_PPC64_DTPREL16_HIGHERA", Const, 5, ""},
+ {"R_PPC64_DTPREL16_HIGHEST", Const, 5, ""},
+ {"R_PPC64_DTPREL16_HIGHESTA", Const, 5, ""},
+ {"R_PPC64_DTPREL16_LO", Const, 5, ""},
+ {"R_PPC64_DTPREL16_LO_DS", Const, 5, ""},
+ {"R_PPC64_DTPREL34", Const, 20, ""},
+ {"R_PPC64_DTPREL64", Const, 5, ""},
+ {"R_PPC64_ENTRY", Const, 10, ""},
+ {"R_PPC64_GLOB_DAT", Const, 20, ""},
+ {"R_PPC64_GNU_VTENTRY", Const, 20, ""},
+ {"R_PPC64_GNU_VTINHERIT", Const, 20, ""},
+ {"R_PPC64_GOT16", Const, 5, ""},
+ {"R_PPC64_GOT16_DS", Const, 5, ""},
+ {"R_PPC64_GOT16_HA", Const, 5, ""},
+ {"R_PPC64_GOT16_HI", Const, 5, ""},
+ {"R_PPC64_GOT16_LO", Const, 5, ""},
+ {"R_PPC64_GOT16_LO_DS", Const, 5, ""},
+ {"R_PPC64_GOT_DTPREL16_DS", Const, 5, ""},
+ {"R_PPC64_GOT_DTPREL16_HA", Const, 5, ""},
+ {"R_PPC64_GOT_DTPREL16_HI", Const, 5, ""},
+ {"R_PPC64_GOT_DTPREL16_LO_DS", Const, 5, ""},
+ {"R_PPC64_GOT_DTPREL_PCREL34", Const, 20, ""},
+ {"R_PPC64_GOT_PCREL34", Const, 20, ""},
+ {"R_PPC64_GOT_TLSGD16", Const, 5, ""},
+ {"R_PPC64_GOT_TLSGD16_HA", Const, 5, ""},
+ {"R_PPC64_GOT_TLSGD16_HI", Const, 5, ""},
+ {"R_PPC64_GOT_TLSGD16_LO", Const, 5, ""},
+ {"R_PPC64_GOT_TLSGD_PCREL34", Const, 20, ""},
+ {"R_PPC64_GOT_TLSLD16", Const, 5, ""},
+ {"R_PPC64_GOT_TLSLD16_HA", Const, 5, ""},
+ {"R_PPC64_GOT_TLSLD16_HI", Const, 5, ""},
+ {"R_PPC64_GOT_TLSLD16_LO", Const, 5, ""},
+ {"R_PPC64_GOT_TLSLD_PCREL34", Const, 20, ""},
+ {"R_PPC64_GOT_TPREL16_DS", Const, 5, ""},
+ {"R_PPC64_GOT_TPREL16_HA", Const, 5, ""},
+ {"R_PPC64_GOT_TPREL16_HI", Const, 5, ""},
+ {"R_PPC64_GOT_TPREL16_LO_DS", Const, 5, ""},
+ {"R_PPC64_GOT_TPREL_PCREL34", Const, 20, ""},
+ {"R_PPC64_IRELATIVE", Const, 10, ""},
+ {"R_PPC64_JMP_IREL", Const, 10, ""},
+ {"R_PPC64_JMP_SLOT", Const, 5, ""},
+ {"R_PPC64_NONE", Const, 5, ""},
+ {"R_PPC64_PCREL28", Const, 20, ""},
+ {"R_PPC64_PCREL34", Const, 20, ""},
+ {"R_PPC64_PCREL_OPT", Const, 20, ""},
+ {"R_PPC64_PLT16_HA", Const, 20, ""},
+ {"R_PPC64_PLT16_HI", Const, 20, ""},
+ {"R_PPC64_PLT16_LO", Const, 20, ""},
+ {"R_PPC64_PLT16_LO_DS", Const, 10, ""},
+ {"R_PPC64_PLT32", Const, 20, ""},
+ {"R_PPC64_PLT64", Const, 20, ""},
+ {"R_PPC64_PLTCALL", Const, 20, ""},
+ {"R_PPC64_PLTCALL_NOTOC", Const, 20, ""},
+ {"R_PPC64_PLTGOT16", Const, 10, ""},
+ {"R_PPC64_PLTGOT16_DS", Const, 10, ""},
+ {"R_PPC64_PLTGOT16_HA", Const, 10, ""},
+ {"R_PPC64_PLTGOT16_HI", Const, 10, ""},
+ {"R_PPC64_PLTGOT16_LO", Const, 10, ""},
+ {"R_PPC64_PLTGOT_LO_DS", Const, 10, ""},
+ {"R_PPC64_PLTREL32", Const, 20, ""},
+ {"R_PPC64_PLTREL64", Const, 20, ""},
+ {"R_PPC64_PLTSEQ", Const, 20, ""},
+ {"R_PPC64_PLTSEQ_NOTOC", Const, 20, ""},
+ {"R_PPC64_PLT_PCREL34", Const, 20, ""},
+ {"R_PPC64_PLT_PCREL34_NOTOC", Const, 20, ""},
+ {"R_PPC64_REL14", Const, 5, ""},
+ {"R_PPC64_REL14_BRNTAKEN", Const, 5, ""},
+ {"R_PPC64_REL14_BRTAKEN", Const, 5, ""},
+ {"R_PPC64_REL16", Const, 5, ""},
+ {"R_PPC64_REL16DX_HA", Const, 10, ""},
+ {"R_PPC64_REL16_HA", Const, 5, ""},
+ {"R_PPC64_REL16_HI", Const, 5, ""},
+ {"R_PPC64_REL16_HIGH", Const, 20, ""},
+ {"R_PPC64_REL16_HIGHA", Const, 20, ""},
+ {"R_PPC64_REL16_HIGHER", Const, 20, ""},
+ {"R_PPC64_REL16_HIGHER34", Const, 20, ""},
+ {"R_PPC64_REL16_HIGHERA", Const, 20, ""},
+ {"R_PPC64_REL16_HIGHERA34", Const, 20, ""},
+ {"R_PPC64_REL16_HIGHEST", Const, 20, ""},
+ {"R_PPC64_REL16_HIGHEST34", Const, 20, ""},
+ {"R_PPC64_REL16_HIGHESTA", Const, 20, ""},
+ {"R_PPC64_REL16_HIGHESTA34", Const, 20, ""},
+ {"R_PPC64_REL16_LO", Const, 5, ""},
+ {"R_PPC64_REL24", Const, 5, ""},
+ {"R_PPC64_REL24_NOTOC", Const, 10, ""},
+ {"R_PPC64_REL24_P9NOTOC", Const, 21, ""},
+ {"R_PPC64_REL30", Const, 20, ""},
+ {"R_PPC64_REL32", Const, 5, ""},
+ {"R_PPC64_REL64", Const, 5, ""},
+ {"R_PPC64_RELATIVE", Const, 18, ""},
+ {"R_PPC64_SECTOFF", Const, 20, ""},
+ {"R_PPC64_SECTOFF_DS", Const, 10, ""},
+ {"R_PPC64_SECTOFF_HA", Const, 20, ""},
+ {"R_PPC64_SECTOFF_HI", Const, 20, ""},
+ {"R_PPC64_SECTOFF_LO", Const, 20, ""},
+ {"R_PPC64_SECTOFF_LO_DS", Const, 10, ""},
+ {"R_PPC64_TLS", Const, 5, ""},
+ {"R_PPC64_TLSGD", Const, 5, ""},
+ {"R_PPC64_TLSLD", Const, 5, ""},
+ {"R_PPC64_TOC", Const, 5, ""},
+ {"R_PPC64_TOC16", Const, 5, ""},
+ {"R_PPC64_TOC16_DS", Const, 5, ""},
+ {"R_PPC64_TOC16_HA", Const, 5, ""},
+ {"R_PPC64_TOC16_HI", Const, 5, ""},
+ {"R_PPC64_TOC16_LO", Const, 5, ""},
+ {"R_PPC64_TOC16_LO_DS", Const, 5, ""},
+ {"R_PPC64_TOCSAVE", Const, 10, ""},
+ {"R_PPC64_TPREL16", Const, 5, ""},
+ {"R_PPC64_TPREL16_DS", Const, 5, ""},
+ {"R_PPC64_TPREL16_HA", Const, 5, ""},
+ {"R_PPC64_TPREL16_HI", Const, 5, ""},
+ {"R_PPC64_TPREL16_HIGH", Const, 10, ""},
+ {"R_PPC64_TPREL16_HIGHA", Const, 10, ""},
+ {"R_PPC64_TPREL16_HIGHER", Const, 5, ""},
+ {"R_PPC64_TPREL16_HIGHERA", Const, 5, ""},
+ {"R_PPC64_TPREL16_HIGHEST", Const, 5, ""},
+ {"R_PPC64_TPREL16_HIGHESTA", Const, 5, ""},
+ {"R_PPC64_TPREL16_LO", Const, 5, ""},
+ {"R_PPC64_TPREL16_LO_DS", Const, 5, ""},
+ {"R_PPC64_TPREL34", Const, 20, ""},
+ {"R_PPC64_TPREL64", Const, 5, ""},
+ {"R_PPC64_UADDR16", Const, 20, ""},
+ {"R_PPC64_UADDR32", Const, 20, ""},
+ {"R_PPC64_UADDR64", Const, 20, ""},
+ {"R_PPC_ADDR14", Const, 0, ""},
+ {"R_PPC_ADDR14_BRNTAKEN", Const, 0, ""},
+ {"R_PPC_ADDR14_BRTAKEN", Const, 0, ""},
+ {"R_PPC_ADDR16", Const, 0, ""},
+ {"R_PPC_ADDR16_HA", Const, 0, ""},
+ {"R_PPC_ADDR16_HI", Const, 0, ""},
+ {"R_PPC_ADDR16_LO", Const, 0, ""},
+ {"R_PPC_ADDR24", Const, 0, ""},
+ {"R_PPC_ADDR32", Const, 0, ""},
+ {"R_PPC_COPY", Const, 0, ""},
+ {"R_PPC_DTPMOD32", Const, 0, ""},
+ {"R_PPC_DTPREL16", Const, 0, ""},
+ {"R_PPC_DTPREL16_HA", Const, 0, ""},
+ {"R_PPC_DTPREL16_HI", Const, 0, ""},
+ {"R_PPC_DTPREL16_LO", Const, 0, ""},
+ {"R_PPC_DTPREL32", Const, 0, ""},
+ {"R_PPC_EMB_BIT_FLD", Const, 0, ""},
+ {"R_PPC_EMB_MRKREF", Const, 0, ""},
+ {"R_PPC_EMB_NADDR16", Const, 0, ""},
+ {"R_PPC_EMB_NADDR16_HA", Const, 0, ""},
+ {"R_PPC_EMB_NADDR16_HI", Const, 0, ""},
+ {"R_PPC_EMB_NADDR16_LO", Const, 0, ""},
+ {"R_PPC_EMB_NADDR32", Const, 0, ""},
+ {"R_PPC_EMB_RELSDA", Const, 0, ""},
+ {"R_PPC_EMB_RELSEC16", Const, 0, ""},
+ {"R_PPC_EMB_RELST_HA", Const, 0, ""},
+ {"R_PPC_EMB_RELST_HI", Const, 0, ""},
+ {"R_PPC_EMB_RELST_LO", Const, 0, ""},
+ {"R_PPC_EMB_SDA21", Const, 0, ""},
+ {"R_PPC_EMB_SDA2I16", Const, 0, ""},
+ {"R_PPC_EMB_SDA2REL", Const, 0, ""},
+ {"R_PPC_EMB_SDAI16", Const, 0, ""},
+ {"R_PPC_GLOB_DAT", Const, 0, ""},
+ {"R_PPC_GOT16", Const, 0, ""},
+ {"R_PPC_GOT16_HA", Const, 0, ""},
+ {"R_PPC_GOT16_HI", Const, 0, ""},
+ {"R_PPC_GOT16_LO", Const, 0, ""},
+ {"R_PPC_GOT_TLSGD16", Const, 0, ""},
+ {"R_PPC_GOT_TLSGD16_HA", Const, 0, ""},
+ {"R_PPC_GOT_TLSGD16_HI", Const, 0, ""},
+ {"R_PPC_GOT_TLSGD16_LO", Const, 0, ""},
+ {"R_PPC_GOT_TLSLD16", Const, 0, ""},
+ {"R_PPC_GOT_TLSLD16_HA", Const, 0, ""},
+ {"R_PPC_GOT_TLSLD16_HI", Const, 0, ""},
+ {"R_PPC_GOT_TLSLD16_LO", Const, 0, ""},
+ {"R_PPC_GOT_TPREL16", Const, 0, ""},
+ {"R_PPC_GOT_TPREL16_HA", Const, 0, ""},
+ {"R_PPC_GOT_TPREL16_HI", Const, 0, ""},
+ {"R_PPC_GOT_TPREL16_LO", Const, 0, ""},
+ {"R_PPC_JMP_SLOT", Const, 0, ""},
+ {"R_PPC_LOCAL24PC", Const, 0, ""},
+ {"R_PPC_NONE", Const, 0, ""},
+ {"R_PPC_PLT16_HA", Const, 0, ""},
+ {"R_PPC_PLT16_HI", Const, 0, ""},
+ {"R_PPC_PLT16_LO", Const, 0, ""},
+ {"R_PPC_PLT32", Const, 0, ""},
+ {"R_PPC_PLTREL24", Const, 0, ""},
+ {"R_PPC_PLTREL32", Const, 0, ""},
+ {"R_PPC_REL14", Const, 0, ""},
+ {"R_PPC_REL14_BRNTAKEN", Const, 0, ""},
+ {"R_PPC_REL14_BRTAKEN", Const, 0, ""},
+ {"R_PPC_REL24", Const, 0, ""},
+ {"R_PPC_REL32", Const, 0, ""},
+ {"R_PPC_RELATIVE", Const, 0, ""},
+ {"R_PPC_SDAREL16", Const, 0, ""},
+ {"R_PPC_SECTOFF", Const, 0, ""},
+ {"R_PPC_SECTOFF_HA", Const, 0, ""},
+ {"R_PPC_SECTOFF_HI", Const, 0, ""},
+ {"R_PPC_SECTOFF_LO", Const, 0, ""},
+ {"R_PPC_TLS", Const, 0, ""},
+ {"R_PPC_TPREL16", Const, 0, ""},
+ {"R_PPC_TPREL16_HA", Const, 0, ""},
+ {"R_PPC_TPREL16_HI", Const, 0, ""},
+ {"R_PPC_TPREL16_LO", Const, 0, ""},
+ {"R_PPC_TPREL32", Const, 0, ""},
+ {"R_PPC_UADDR16", Const, 0, ""},
+ {"R_PPC_UADDR32", Const, 0, ""},
+ {"R_RISCV", Type, 11, ""},
+ {"R_RISCV_32", Const, 11, ""},
+ {"R_RISCV_32_PCREL", Const, 12, ""},
+ {"R_RISCV_64", Const, 11, ""},
+ {"R_RISCV_ADD16", Const, 11, ""},
+ {"R_RISCV_ADD32", Const, 11, ""},
+ {"R_RISCV_ADD64", Const, 11, ""},
+ {"R_RISCV_ADD8", Const, 11, ""},
+ {"R_RISCV_ALIGN", Const, 11, ""},
+ {"R_RISCV_BRANCH", Const, 11, ""},
+ {"R_RISCV_CALL", Const, 11, ""},
+ {"R_RISCV_CALL_PLT", Const, 11, ""},
+ {"R_RISCV_COPY", Const, 11, ""},
+ {"R_RISCV_GNU_VTENTRY", Const, 11, ""},
+ {"R_RISCV_GNU_VTINHERIT", Const, 11, ""},
+ {"R_RISCV_GOT_HI20", Const, 11, ""},
+ {"R_RISCV_GPREL_I", Const, 11, ""},
+ {"R_RISCV_GPREL_S", Const, 11, ""},
+ {"R_RISCV_HI20", Const, 11, ""},
+ {"R_RISCV_JAL", Const, 11, ""},
+ {"R_RISCV_JUMP_SLOT", Const, 11, ""},
+ {"R_RISCV_LO12_I", Const, 11, ""},
+ {"R_RISCV_LO12_S", Const, 11, ""},
+ {"R_RISCV_NONE", Const, 11, ""},
+ {"R_RISCV_PCREL_HI20", Const, 11, ""},
+ {"R_RISCV_PCREL_LO12_I", Const, 11, ""},
+ {"R_RISCV_PCREL_LO12_S", Const, 11, ""},
+ {"R_RISCV_RELATIVE", Const, 11, ""},
+ {"R_RISCV_RELAX", Const, 11, ""},
+ {"R_RISCV_RVC_BRANCH", Const, 11, ""},
+ {"R_RISCV_RVC_JUMP", Const, 11, ""},
+ {"R_RISCV_RVC_LUI", Const, 11, ""},
+ {"R_RISCV_SET16", Const, 11, ""},
+ {"R_RISCV_SET32", Const, 11, ""},
+ {"R_RISCV_SET6", Const, 11, ""},
+ {"R_RISCV_SET8", Const, 11, ""},
+ {"R_RISCV_SUB16", Const, 11, ""},
+ {"R_RISCV_SUB32", Const, 11, ""},
+ {"R_RISCV_SUB6", Const, 11, ""},
+ {"R_RISCV_SUB64", Const, 11, ""},
+ {"R_RISCV_SUB8", Const, 11, ""},
+ {"R_RISCV_TLS_DTPMOD32", Const, 11, ""},
+ {"R_RISCV_TLS_DTPMOD64", Const, 11, ""},
+ {"R_RISCV_TLS_DTPREL32", Const, 11, ""},
+ {"R_RISCV_TLS_DTPREL64", Const, 11, ""},
+ {"R_RISCV_TLS_GD_HI20", Const, 11, ""},
+ {"R_RISCV_TLS_GOT_HI20", Const, 11, ""},
+ {"R_RISCV_TLS_TPREL32", Const, 11, ""},
+ {"R_RISCV_TLS_TPREL64", Const, 11, ""},
+ {"R_RISCV_TPREL_ADD", Const, 11, ""},
+ {"R_RISCV_TPREL_HI20", Const, 11, ""},
+ {"R_RISCV_TPREL_I", Const, 11, ""},
+ {"R_RISCV_TPREL_LO12_I", Const, 11, ""},
+ {"R_RISCV_TPREL_LO12_S", Const, 11, ""},
+ {"R_RISCV_TPREL_S", Const, 11, ""},
+ {"R_SPARC", Type, 0, ""},
+ {"R_SPARC_10", Const, 0, ""},
+ {"R_SPARC_11", Const, 0, ""},
+ {"R_SPARC_13", Const, 0, ""},
+ {"R_SPARC_16", Const, 0, ""},
+ {"R_SPARC_22", Const, 0, ""},
+ {"R_SPARC_32", Const, 0, ""},
+ {"R_SPARC_5", Const, 0, ""},
+ {"R_SPARC_6", Const, 0, ""},
+ {"R_SPARC_64", Const, 0, ""},
+ {"R_SPARC_7", Const, 0, ""},
+ {"R_SPARC_8", Const, 0, ""},
+ {"R_SPARC_COPY", Const, 0, ""},
+ {"R_SPARC_DISP16", Const, 0, ""},
+ {"R_SPARC_DISP32", Const, 0, ""},
+ {"R_SPARC_DISP64", Const, 0, ""},
+ {"R_SPARC_DISP8", Const, 0, ""},
+ {"R_SPARC_GLOB_DAT", Const, 0, ""},
+ {"R_SPARC_GLOB_JMP", Const, 0, ""},
+ {"R_SPARC_GOT10", Const, 0, ""},
+ {"R_SPARC_GOT13", Const, 0, ""},
+ {"R_SPARC_GOT22", Const, 0, ""},
+ {"R_SPARC_H44", Const, 0, ""},
+ {"R_SPARC_HH22", Const, 0, ""},
+ {"R_SPARC_HI22", Const, 0, ""},
+ {"R_SPARC_HIPLT22", Const, 0, ""},
+ {"R_SPARC_HIX22", Const, 0, ""},
+ {"R_SPARC_HM10", Const, 0, ""},
+ {"R_SPARC_JMP_SLOT", Const, 0, ""},
+ {"R_SPARC_L44", Const, 0, ""},
+ {"R_SPARC_LM22", Const, 0, ""},
+ {"R_SPARC_LO10", Const, 0, ""},
+ {"R_SPARC_LOPLT10", Const, 0, ""},
+ {"R_SPARC_LOX10", Const, 0, ""},
+ {"R_SPARC_M44", Const, 0, ""},
+ {"R_SPARC_NONE", Const, 0, ""},
+ {"R_SPARC_OLO10", Const, 0, ""},
+ {"R_SPARC_PC10", Const, 0, ""},
+ {"R_SPARC_PC22", Const, 0, ""},
+ {"R_SPARC_PCPLT10", Const, 0, ""},
+ {"R_SPARC_PCPLT22", Const, 0, ""},
+ {"R_SPARC_PCPLT32", Const, 0, ""},
+ {"R_SPARC_PC_HH22", Const, 0, ""},
+ {"R_SPARC_PC_HM10", Const, 0, ""},
+ {"R_SPARC_PC_LM22", Const, 0, ""},
+ {"R_SPARC_PLT32", Const, 0, ""},
+ {"R_SPARC_PLT64", Const, 0, ""},
+ {"R_SPARC_REGISTER", Const, 0, ""},
+ {"R_SPARC_RELATIVE", Const, 0, ""},
+ {"R_SPARC_UA16", Const, 0, ""},
+ {"R_SPARC_UA32", Const, 0, ""},
+ {"R_SPARC_UA64", Const, 0, ""},
+ {"R_SPARC_WDISP16", Const, 0, ""},
+ {"R_SPARC_WDISP19", Const, 0, ""},
+ {"R_SPARC_WDISP22", Const, 0, ""},
+ {"R_SPARC_WDISP30", Const, 0, ""},
+ {"R_SPARC_WPLT30", Const, 0, ""},
+ {"R_SYM32", Func, 0, "func(info uint32) uint32"},
+ {"R_SYM64", Func, 0, "func(info uint64) uint32"},
+ {"R_TYPE32", Func, 0, "func(info uint32) uint32"},
+ {"R_TYPE64", Func, 0, "func(info uint64) uint32"},
+ {"R_X86_64", Type, 0, ""},
+ {"R_X86_64_16", Const, 0, ""},
+ {"R_X86_64_32", Const, 0, ""},
+ {"R_X86_64_32S", Const, 0, ""},
+ {"R_X86_64_64", Const, 0, ""},
+ {"R_X86_64_8", Const, 0, ""},
+ {"R_X86_64_COPY", Const, 0, ""},
+ {"R_X86_64_DTPMOD64", Const, 0, ""},
+ {"R_X86_64_DTPOFF32", Const, 0, ""},
+ {"R_X86_64_DTPOFF64", Const, 0, ""},
+ {"R_X86_64_GLOB_DAT", Const, 0, ""},
+ {"R_X86_64_GOT32", Const, 0, ""},
+ {"R_X86_64_GOT64", Const, 10, ""},
+ {"R_X86_64_GOTOFF64", Const, 10, ""},
+ {"R_X86_64_GOTPC32", Const, 10, ""},
+ {"R_X86_64_GOTPC32_TLSDESC", Const, 10, ""},
+ {"R_X86_64_GOTPC64", Const, 10, ""},
+ {"R_X86_64_GOTPCREL", Const, 0, ""},
+ {"R_X86_64_GOTPCREL64", Const, 10, ""},
+ {"R_X86_64_GOTPCRELX", Const, 10, ""},
+ {"R_X86_64_GOTPLT64", Const, 10, ""},
+ {"R_X86_64_GOTTPOFF", Const, 0, ""},
+ {"R_X86_64_IRELATIVE", Const, 10, ""},
+ {"R_X86_64_JMP_SLOT", Const, 0, ""},
+ {"R_X86_64_NONE", Const, 0, ""},
+ {"R_X86_64_PC16", Const, 0, ""},
+ {"R_X86_64_PC32", Const, 0, ""},
+ {"R_X86_64_PC32_BND", Const, 10, ""},
+ {"R_X86_64_PC64", Const, 10, ""},
+ {"R_X86_64_PC8", Const, 0, ""},
+ {"R_X86_64_PLT32", Const, 0, ""},
+ {"R_X86_64_PLT32_BND", Const, 10, ""},
+ {"R_X86_64_PLTOFF64", Const, 10, ""},
+ {"R_X86_64_RELATIVE", Const, 0, ""},
+ {"R_X86_64_RELATIVE64", Const, 10, ""},
+ {"R_X86_64_REX_GOTPCRELX", Const, 10, ""},
+ {"R_X86_64_SIZE32", Const, 10, ""},
+ {"R_X86_64_SIZE64", Const, 10, ""},
+ {"R_X86_64_TLSDESC", Const, 10, ""},
+ {"R_X86_64_TLSDESC_CALL", Const, 10, ""},
+ {"R_X86_64_TLSGD", Const, 0, ""},
+ {"R_X86_64_TLSLD", Const, 0, ""},
+ {"R_X86_64_TPOFF32", Const, 0, ""},
+ {"R_X86_64_TPOFF64", Const, 0, ""},
+ {"Rel32", Type, 0, ""},
+ {"Rel32.Info", Field, 0, ""},
+ {"Rel32.Off", Field, 0, ""},
+ {"Rel64", Type, 0, ""},
+ {"Rel64.Info", Field, 0, ""},
+ {"Rel64.Off", Field, 0, ""},
+ {"Rela32", Type, 0, ""},
+ {"Rela32.Addend", Field, 0, ""},
+ {"Rela32.Info", Field, 0, ""},
+ {"Rela32.Off", Field, 0, ""},
+ {"Rela64", Type, 0, ""},
+ {"Rela64.Addend", Field, 0, ""},
+ {"Rela64.Info", Field, 0, ""},
+ {"Rela64.Off", Field, 0, ""},
+ {"SHF_ALLOC", Const, 0, ""},
+ {"SHF_COMPRESSED", Const, 6, ""},
+ {"SHF_EXECINSTR", Const, 0, ""},
+ {"SHF_GROUP", Const, 0, ""},
+ {"SHF_INFO_LINK", Const, 0, ""},
+ {"SHF_LINK_ORDER", Const, 0, ""},
+ {"SHF_MASKOS", Const, 0, ""},
+ {"SHF_MASKPROC", Const, 0, ""},
+ {"SHF_MERGE", Const, 0, ""},
+ {"SHF_OS_NONCONFORMING", Const, 0, ""},
+ {"SHF_STRINGS", Const, 0, ""},
+ {"SHF_TLS", Const, 0, ""},
+ {"SHF_WRITE", Const, 0, ""},
+ {"SHN_ABS", Const, 0, ""},
+ {"SHN_COMMON", Const, 0, ""},
+ {"SHN_HIOS", Const, 0, ""},
+ {"SHN_HIPROC", Const, 0, ""},
+ {"SHN_HIRESERVE", Const, 0, ""},
+ {"SHN_LOOS", Const, 0, ""},
+ {"SHN_LOPROC", Const, 0, ""},
+ {"SHN_LORESERVE", Const, 0, ""},
+ {"SHN_UNDEF", Const, 0, ""},
+ {"SHN_XINDEX", Const, 0, ""},
+ {"SHT_DYNAMIC", Const, 0, ""},
+ {"SHT_DYNSYM", Const, 0, ""},
+ {"SHT_FINI_ARRAY", Const, 0, ""},
+ {"SHT_GNU_ATTRIBUTES", Const, 0, ""},
+ {"SHT_GNU_HASH", Const, 0, ""},
+ {"SHT_GNU_LIBLIST", Const, 0, ""},
+ {"SHT_GNU_VERDEF", Const, 0, ""},
+ {"SHT_GNU_VERNEED", Const, 0, ""},
+ {"SHT_GNU_VERSYM", Const, 0, ""},
+ {"SHT_GROUP", Const, 0, ""},
+ {"SHT_HASH", Const, 0, ""},
+ {"SHT_HIOS", Const, 0, ""},
+ {"SHT_HIPROC", Const, 0, ""},
+ {"SHT_HIUSER", Const, 0, ""},
+ {"SHT_INIT_ARRAY", Const, 0, ""},
+ {"SHT_LOOS", Const, 0, ""},
+ {"SHT_LOPROC", Const, 0, ""},
+ {"SHT_LOUSER", Const, 0, ""},
+ {"SHT_MIPS_ABIFLAGS", Const, 17, ""},
+ {"SHT_NOBITS", Const, 0, ""},
+ {"SHT_NOTE", Const, 0, ""},
+ {"SHT_NULL", Const, 0, ""},
+ {"SHT_PREINIT_ARRAY", Const, 0, ""},
+ {"SHT_PROGBITS", Const, 0, ""},
+ {"SHT_REL", Const, 0, ""},
+ {"SHT_RELA", Const, 0, ""},
+ {"SHT_RISCV_ATTRIBUTES", Const, 25, ""},
+ {"SHT_SHLIB", Const, 0, ""},
+ {"SHT_STRTAB", Const, 0, ""},
+ {"SHT_SYMTAB", Const, 0, ""},
+ {"SHT_SYMTAB_SHNDX", Const, 0, ""},
+ {"STB_GLOBAL", Const, 0, ""},
+ {"STB_HIOS", Const, 0, ""},
+ {"STB_HIPROC", Const, 0, ""},
+ {"STB_LOCAL", Const, 0, ""},
+ {"STB_LOOS", Const, 0, ""},
+ {"STB_LOPROC", Const, 0, ""},
+ {"STB_WEAK", Const, 0, ""},
+ {"STT_COMMON", Const, 0, ""},
+ {"STT_FILE", Const, 0, ""},
+ {"STT_FUNC", Const, 0, ""},
+ {"STT_GNU_IFUNC", Const, 23, ""},
+ {"STT_HIOS", Const, 0, ""},
+ {"STT_HIPROC", Const, 0, ""},
+ {"STT_LOOS", Const, 0, ""},
+ {"STT_LOPROC", Const, 0, ""},
+ {"STT_NOTYPE", Const, 0, ""},
+ {"STT_OBJECT", Const, 0, ""},
+ {"STT_RELC", Const, 23, ""},
+ {"STT_SECTION", Const, 0, ""},
+ {"STT_SRELC", Const, 23, ""},
+ {"STT_TLS", Const, 0, ""},
+ {"STV_DEFAULT", Const, 0, ""},
+ {"STV_HIDDEN", Const, 0, ""},
+ {"STV_INTERNAL", Const, 0, ""},
+ {"STV_PROTECTED", Const, 0, ""},
+ {"ST_BIND", Func, 0, "func(info uint8) SymBind"},
+ {"ST_INFO", Func, 0, "func(bind SymBind, typ SymType) uint8"},
+ {"ST_TYPE", Func, 0, "func(info uint8) SymType"},
+ {"ST_VISIBILITY", Func, 0, "func(other uint8) SymVis"},
+ {"Section", Type, 0, ""},
+ {"Section.ReaderAt", Field, 0, ""},
+ {"Section.SectionHeader", Field, 0, ""},
+ {"Section32", Type, 0, ""},
+ {"Section32.Addr", Field, 0, ""},
+ {"Section32.Addralign", Field, 0, ""},
+ {"Section32.Entsize", Field, 0, ""},
+ {"Section32.Flags", Field, 0, ""},
+ {"Section32.Info", Field, 0, ""},
+ {"Section32.Link", Field, 0, ""},
+ {"Section32.Name", Field, 0, ""},
+ {"Section32.Off", Field, 0, ""},
+ {"Section32.Size", Field, 0, ""},
+ {"Section32.Type", Field, 0, ""},
+ {"Section64", Type, 0, ""},
+ {"Section64.Addr", Field, 0, ""},
+ {"Section64.Addralign", Field, 0, ""},
+ {"Section64.Entsize", Field, 0, ""},
+ {"Section64.Flags", Field, 0, ""},
+ {"Section64.Info", Field, 0, ""},
+ {"Section64.Link", Field, 0, ""},
+ {"Section64.Name", Field, 0, ""},
+ {"Section64.Off", Field, 0, ""},
+ {"Section64.Size", Field, 0, ""},
+ {"Section64.Type", Field, 0, ""},
+ {"SectionFlag", Type, 0, ""},
+ {"SectionHeader", Type, 0, ""},
+ {"SectionHeader.Addr", Field, 0, ""},
+ {"SectionHeader.Addralign", Field, 0, ""},
+ {"SectionHeader.Entsize", Field, 0, ""},
+ {"SectionHeader.FileSize", Field, 6, ""},
+ {"SectionHeader.Flags", Field, 0, ""},
+ {"SectionHeader.Info", Field, 0, ""},
+ {"SectionHeader.Link", Field, 0, ""},
+ {"SectionHeader.Name", Field, 0, ""},
+ {"SectionHeader.Offset", Field, 0, ""},
+ {"SectionHeader.Size", Field, 0, ""},
+ {"SectionHeader.Type", Field, 0, ""},
+ {"SectionIndex", Type, 0, ""},
+ {"SectionType", Type, 0, ""},
+ {"Sym32", Type, 0, ""},
+ {"Sym32.Info", Field, 0, ""},
+ {"Sym32.Name", Field, 0, ""},
+ {"Sym32.Other", Field, 0, ""},
+ {"Sym32.Shndx", Field, 0, ""},
+ {"Sym32.Size", Field, 0, ""},
+ {"Sym32.Value", Field, 0, ""},
+ {"Sym32Size", Const, 0, ""},
+ {"Sym64", Type, 0, ""},
+ {"Sym64.Info", Field, 0, ""},
+ {"Sym64.Name", Field, 0, ""},
+ {"Sym64.Other", Field, 0, ""},
+ {"Sym64.Shndx", Field, 0, ""},
+ {"Sym64.Size", Field, 0, ""},
+ {"Sym64.Value", Field, 0, ""},
+ {"Sym64Size", Const, 0, ""},
+ {"SymBind", Type, 0, ""},
+ {"SymType", Type, 0, ""},
+ {"SymVis", Type, 0, ""},
+ {"Symbol", Type, 0, ""},
+ {"Symbol.HasVersion", Field, 24, ""},
+ {"Symbol.Info", Field, 0, ""},
+ {"Symbol.Library", Field, 13, ""},
+ {"Symbol.Name", Field, 0, ""},
+ {"Symbol.Other", Field, 0, ""},
+ {"Symbol.Section", Field, 0, ""},
+ {"Symbol.Size", Field, 0, ""},
+ {"Symbol.Value", Field, 0, ""},
+ {"Symbol.Version", Field, 13, ""},
+ {"Symbol.VersionIndex", Field, 24, ""},
+ {"Type", Type, 0, ""},
+ {"VER_FLG_BASE", Const, 24, ""},
+ {"VER_FLG_INFO", Const, 24, ""},
+ {"VER_FLG_WEAK", Const, 24, ""},
+ {"Version", Type, 0, ""},
+ {"VersionIndex", Type, 24, ""},
+ },
+ "debug/gosym": {
+ {"(*DecodingError).Error", Method, 0, ""},
+ {"(*LineTable).LineToPC", Method, 0, ""},
+ {"(*LineTable).PCToLine", Method, 0, ""},
+ {"(*Sym).BaseName", Method, 0, ""},
+ {"(*Sym).PackageName", Method, 0, ""},
+ {"(*Sym).ReceiverName", Method, 0, ""},
+ {"(*Sym).Static", Method, 0, ""},
+ {"(*Table).LineToPC", Method, 0, ""},
+ {"(*Table).LookupFunc", Method, 0, ""},
+ {"(*Table).LookupSym", Method, 0, ""},
+ {"(*Table).PCToFunc", Method, 0, ""},
+ {"(*Table).PCToLine", Method, 0, ""},
+ {"(*Table).SymByAddr", Method, 0, ""},
+ {"(*UnknownLineError).Error", Method, 0, ""},
+ {"(Func).BaseName", Method, 0, ""},
+ {"(Func).PackageName", Method, 0, ""},
+ {"(Func).ReceiverName", Method, 0, ""},
+ {"(Func).Static", Method, 0, ""},
+ {"(UnknownFileError).Error", Method, 0, ""},
+ {"DecodingError", Type, 0, ""},
+ {"Func", Type, 0, ""},
+ {"Func.End", Field, 0, ""},
+ {"Func.Entry", Field, 0, ""},
+ {"Func.FrameSize", Field, 0, ""},
+ {"Func.LineTable", Field, 0, ""},
+ {"Func.Locals", Field, 0, ""},
+ {"Func.Obj", Field, 0, ""},
+ {"Func.Params", Field, 0, ""},
+ {"Func.Sym", Field, 0, ""},
+ {"LineTable", Type, 0, ""},
+ {"LineTable.Data", Field, 0, ""},
+ {"LineTable.Line", Field, 0, ""},
+ {"LineTable.PC", Field, 0, ""},
+ {"NewLineTable", Func, 0, "func(data []byte, text uint64) *LineTable"},
+ {"NewTable", Func, 0, "func(symtab []byte, pcln *LineTable) (*Table, error)"},
+ {"Obj", Type, 0, ""},
+ {"Obj.Funcs", Field, 0, ""},
+ {"Obj.Paths", Field, 0, ""},
+ {"Sym", Type, 0, ""},
+ {"Sym.Func", Field, 0, ""},
+ {"Sym.GoType", Field, 0, ""},
+ {"Sym.Name", Field, 0, ""},
+ {"Sym.Type", Field, 0, ""},
+ {"Sym.Value", Field, 0, ""},
+ {"Table", Type, 0, ""},
+ {"Table.Files", Field, 0, ""},
+ {"Table.Funcs", Field, 0, ""},
+ {"Table.Objs", Field, 0, ""},
+ {"Table.Syms", Field, 0, ""},
+ {"UnknownFileError", Type, 0, ""},
+ {"UnknownLineError", Type, 0, ""},
+ {"UnknownLineError.File", Field, 0, ""},
+ {"UnknownLineError.Line", Field, 0, ""},
+ },
+ "debug/macho": {
+ {"(*FatFile).Close", Method, 3, ""},
+ {"(*File).Close", Method, 0, ""},
+ {"(*File).DWARF", Method, 0, ""},
+ {"(*File).ImportedLibraries", Method, 0, ""},
+ {"(*File).ImportedSymbols", Method, 0, ""},
+ {"(*File).Section", Method, 0, ""},
+ {"(*File).Segment", Method, 0, ""},
+ {"(*FormatError).Error", Method, 0, ""},
+ {"(*Section).Data", Method, 0, ""},
+ {"(*Section).Open", Method, 0, ""},
+ {"(*Segment).Data", Method, 0, ""},
+ {"(*Segment).Open", Method, 0, ""},
+ {"(Cpu).GoString", Method, 0, ""},
+ {"(Cpu).String", Method, 0, ""},
+ {"(Dylib).Raw", Method, 0, ""},
+ {"(Dysymtab).Raw", Method, 0, ""},
+ {"(FatArch).Close", Method, 3, ""},
+ {"(FatArch).DWARF", Method, 3, ""},
+ {"(FatArch).ImportedLibraries", Method, 3, ""},
+ {"(FatArch).ImportedSymbols", Method, 3, ""},
+ {"(FatArch).Section", Method, 3, ""},
+ {"(FatArch).Segment", Method, 3, ""},
+ {"(LoadBytes).Raw", Method, 0, ""},
+ {"(LoadCmd).GoString", Method, 0, ""},
+ {"(LoadCmd).String", Method, 0, ""},
+ {"(RelocTypeARM).GoString", Method, 10, ""},
+ {"(RelocTypeARM).String", Method, 10, ""},
+ {"(RelocTypeARM64).GoString", Method, 10, ""},
+ {"(RelocTypeARM64).String", Method, 10, ""},
+ {"(RelocTypeGeneric).GoString", Method, 10, ""},
+ {"(RelocTypeGeneric).String", Method, 10, ""},
+ {"(RelocTypeX86_64).GoString", Method, 10, ""},
+ {"(RelocTypeX86_64).String", Method, 10, ""},
+ {"(Rpath).Raw", Method, 10, ""},
+ {"(Section).ReadAt", Method, 0, ""},
+ {"(Segment).Raw", Method, 0, ""},
+ {"(Segment).ReadAt", Method, 0, ""},
+ {"(Symtab).Raw", Method, 0, ""},
+ {"(Type).GoString", Method, 10, ""},
+ {"(Type).String", Method, 10, ""},
+ {"ARM64_RELOC_ADDEND", Const, 10, ""},
+ {"ARM64_RELOC_BRANCH26", Const, 10, ""},
+ {"ARM64_RELOC_GOT_LOAD_PAGE21", Const, 10, ""},
+ {"ARM64_RELOC_GOT_LOAD_PAGEOFF12", Const, 10, ""},
+ {"ARM64_RELOC_PAGE21", Const, 10, ""},
+ {"ARM64_RELOC_PAGEOFF12", Const, 10, ""},
+ {"ARM64_RELOC_POINTER_TO_GOT", Const, 10, ""},
+ {"ARM64_RELOC_SUBTRACTOR", Const, 10, ""},
+ {"ARM64_RELOC_TLVP_LOAD_PAGE21", Const, 10, ""},
+ {"ARM64_RELOC_TLVP_LOAD_PAGEOFF12", Const, 10, ""},
+ {"ARM64_RELOC_UNSIGNED", Const, 10, ""},
+ {"ARM_RELOC_BR24", Const, 10, ""},
+ {"ARM_RELOC_HALF", Const, 10, ""},
+ {"ARM_RELOC_HALF_SECTDIFF", Const, 10, ""},
+ {"ARM_RELOC_LOCAL_SECTDIFF", Const, 10, ""},
+ {"ARM_RELOC_PAIR", Const, 10, ""},
+ {"ARM_RELOC_PB_LA_PTR", Const, 10, ""},
+ {"ARM_RELOC_SECTDIFF", Const, 10, ""},
+ {"ARM_RELOC_VANILLA", Const, 10, ""},
+ {"ARM_THUMB_32BIT_BRANCH", Const, 10, ""},
+ {"ARM_THUMB_RELOC_BR22", Const, 10, ""},
+ {"Cpu", Type, 0, ""},
+ {"Cpu386", Const, 0, ""},
+ {"CpuAmd64", Const, 0, ""},
+ {"CpuArm", Const, 3, ""},
+ {"CpuArm64", Const, 11, ""},
+ {"CpuPpc", Const, 3, ""},
+ {"CpuPpc64", Const, 3, ""},
+ {"Dylib", Type, 0, ""},
+ {"Dylib.CompatVersion", Field, 0, ""},
+ {"Dylib.CurrentVersion", Field, 0, ""},
+ {"Dylib.LoadBytes", Field, 0, ""},
+ {"Dylib.Name", Field, 0, ""},
+ {"Dylib.Time", Field, 0, ""},
+ {"DylibCmd", Type, 0, ""},
+ {"DylibCmd.Cmd", Field, 0, ""},
+ {"DylibCmd.CompatVersion", Field, 0, ""},
+ {"DylibCmd.CurrentVersion", Field, 0, ""},
+ {"DylibCmd.Len", Field, 0, ""},
+ {"DylibCmd.Name", Field, 0, ""},
+ {"DylibCmd.Time", Field, 0, ""},
+ {"Dysymtab", Type, 0, ""},
+ {"Dysymtab.DysymtabCmd", Field, 0, ""},
+ {"Dysymtab.IndirectSyms", Field, 0, ""},
+ {"Dysymtab.LoadBytes", Field, 0, ""},
+ {"DysymtabCmd", Type, 0, ""},
+ {"DysymtabCmd.Cmd", Field, 0, ""},
+ {"DysymtabCmd.Extrefsymoff", Field, 0, ""},
+ {"DysymtabCmd.Extreloff", Field, 0, ""},
+ {"DysymtabCmd.Iextdefsym", Field, 0, ""},
+ {"DysymtabCmd.Ilocalsym", Field, 0, ""},
+ {"DysymtabCmd.Indirectsymoff", Field, 0, ""},
+ {"DysymtabCmd.Iundefsym", Field, 0, ""},
+ {"DysymtabCmd.Len", Field, 0, ""},
+ {"DysymtabCmd.Locreloff", Field, 0, ""},
+ {"DysymtabCmd.Modtaboff", Field, 0, ""},
+ {"DysymtabCmd.Nextdefsym", Field, 0, ""},
+ {"DysymtabCmd.Nextrefsyms", Field, 0, ""},
+ {"DysymtabCmd.Nextrel", Field, 0, ""},
+ {"DysymtabCmd.Nindirectsyms", Field, 0, ""},
+ {"DysymtabCmd.Nlocalsym", Field, 0, ""},
+ {"DysymtabCmd.Nlocrel", Field, 0, ""},
+ {"DysymtabCmd.Nmodtab", Field, 0, ""},
+ {"DysymtabCmd.Ntoc", Field, 0, ""},
+ {"DysymtabCmd.Nundefsym", Field, 0, ""},
+ {"DysymtabCmd.Tocoffset", Field, 0, ""},
+ {"ErrNotFat", Var, 3, ""},
+ {"FatArch", Type, 3, ""},
+ {"FatArch.FatArchHeader", Field, 3, ""},
+ {"FatArch.File", Field, 3, ""},
+ {"FatArchHeader", Type, 3, ""},
+ {"FatArchHeader.Align", Field, 3, ""},
+ {"FatArchHeader.Cpu", Field, 3, ""},
+ {"FatArchHeader.Offset", Field, 3, ""},
+ {"FatArchHeader.Size", Field, 3, ""},
+ {"FatArchHeader.SubCpu", Field, 3, ""},
+ {"FatFile", Type, 3, ""},
+ {"FatFile.Arches", Field, 3, ""},
+ {"FatFile.Magic", Field, 3, ""},
+ {"File", Type, 0, ""},
+ {"File.ByteOrder", Field, 0, ""},
+ {"File.Dysymtab", Field, 0, ""},
+ {"File.FileHeader", Field, 0, ""},
+ {"File.Loads", Field, 0, ""},
+ {"File.Sections", Field, 0, ""},
+ {"File.Symtab", Field, 0, ""},
+ {"FileHeader", Type, 0, ""},
+ {"FileHeader.Cmdsz", Field, 0, ""},
+ {"FileHeader.Cpu", Field, 0, ""},
+ {"FileHeader.Flags", Field, 0, ""},
+ {"FileHeader.Magic", Field, 0, ""},
+ {"FileHeader.Ncmd", Field, 0, ""},
+ {"FileHeader.SubCpu", Field, 0, ""},
+ {"FileHeader.Type", Field, 0, ""},
+ {"FlagAllModsBound", Const, 10, ""},
+ {"FlagAllowStackExecution", Const, 10, ""},
+ {"FlagAppExtensionSafe", Const, 10, ""},
+ {"FlagBindAtLoad", Const, 10, ""},
+ {"FlagBindsToWeak", Const, 10, ""},
+ {"FlagCanonical", Const, 10, ""},
+ {"FlagDeadStrippableDylib", Const, 10, ""},
+ {"FlagDyldLink", Const, 10, ""},
+ {"FlagForceFlat", Const, 10, ""},
+ {"FlagHasTLVDescriptors", Const, 10, ""},
+ {"FlagIncrLink", Const, 10, ""},
+ {"FlagLazyInit", Const, 10, ""},
+ {"FlagNoFixPrebinding", Const, 10, ""},
+ {"FlagNoHeapExecution", Const, 10, ""},
+ {"FlagNoMultiDefs", Const, 10, ""},
+ {"FlagNoReexportedDylibs", Const, 10, ""},
+ {"FlagNoUndefs", Const, 10, ""},
+ {"FlagPIE", Const, 10, ""},
+ {"FlagPrebindable", Const, 10, ""},
+ {"FlagPrebound", Const, 10, ""},
+ {"FlagRootSafe", Const, 10, ""},
+ {"FlagSetuidSafe", Const, 10, ""},
+ {"FlagSplitSegs", Const, 10, ""},
+ {"FlagSubsectionsViaSymbols", Const, 10, ""},
+ {"FlagTwoLevel", Const, 10, ""},
+ {"FlagWeakDefines", Const, 10, ""},
+ {"FormatError", Type, 0, ""},
+ {"GENERIC_RELOC_LOCAL_SECTDIFF", Const, 10, ""},
+ {"GENERIC_RELOC_PAIR", Const, 10, ""},
+ {"GENERIC_RELOC_PB_LA_PTR", Const, 10, ""},
+ {"GENERIC_RELOC_SECTDIFF", Const, 10, ""},
+ {"GENERIC_RELOC_TLV", Const, 10, ""},
+ {"GENERIC_RELOC_VANILLA", Const, 10, ""},
+ {"Load", Type, 0, ""},
+ {"LoadBytes", Type, 0, ""},
+ {"LoadCmd", Type, 0, ""},
+ {"LoadCmdDylib", Const, 0, ""},
+ {"LoadCmdDylinker", Const, 0, ""},
+ {"LoadCmdDysymtab", Const, 0, ""},
+ {"LoadCmdRpath", Const, 10, ""},
+ {"LoadCmdSegment", Const, 0, ""},
+ {"LoadCmdSegment64", Const, 0, ""},
+ {"LoadCmdSymtab", Const, 0, ""},
+ {"LoadCmdThread", Const, 0, ""},
+ {"LoadCmdUnixThread", Const, 0, ""},
+ {"Magic32", Const, 0, ""},
+ {"Magic64", Const, 0, ""},
+ {"MagicFat", Const, 3, ""},
+ {"NewFatFile", Func, 3, "func(r io.ReaderAt) (*FatFile, error)"},
+ {"NewFile", Func, 0, "func(r io.ReaderAt) (*File, error)"},
+ {"Nlist32", Type, 0, ""},
+ {"Nlist32.Desc", Field, 0, ""},
+ {"Nlist32.Name", Field, 0, ""},
+ {"Nlist32.Sect", Field, 0, ""},
+ {"Nlist32.Type", Field, 0, ""},
+ {"Nlist32.Value", Field, 0, ""},
+ {"Nlist64", Type, 0, ""},
+ {"Nlist64.Desc", Field, 0, ""},
+ {"Nlist64.Name", Field, 0, ""},
+ {"Nlist64.Sect", Field, 0, ""},
+ {"Nlist64.Type", Field, 0, ""},
+ {"Nlist64.Value", Field, 0, ""},
+ {"Open", Func, 0, "func(name string) (*File, error)"},
+ {"OpenFat", Func, 3, "func(name string) (*FatFile, error)"},
+ {"Regs386", Type, 0, ""},
+ {"Regs386.AX", Field, 0, ""},
+ {"Regs386.BP", Field, 0, ""},
+ {"Regs386.BX", Field, 0, ""},
+ {"Regs386.CS", Field, 0, ""},
+ {"Regs386.CX", Field, 0, ""},
+ {"Regs386.DI", Field, 0, ""},
+ {"Regs386.DS", Field, 0, ""},
+ {"Regs386.DX", Field, 0, ""},
+ {"Regs386.ES", Field, 0, ""},
+ {"Regs386.FLAGS", Field, 0, ""},
+ {"Regs386.FS", Field, 0, ""},
+ {"Regs386.GS", Field, 0, ""},
+ {"Regs386.IP", Field, 0, ""},
+ {"Regs386.SI", Field, 0, ""},
+ {"Regs386.SP", Field, 0, ""},
+ {"Regs386.SS", Field, 0, ""},
+ {"RegsAMD64", Type, 0, ""},
+ {"RegsAMD64.AX", Field, 0, ""},
+ {"RegsAMD64.BP", Field, 0, ""},
+ {"RegsAMD64.BX", Field, 0, ""},
+ {"RegsAMD64.CS", Field, 0, ""},
+ {"RegsAMD64.CX", Field, 0, ""},
+ {"RegsAMD64.DI", Field, 0, ""},
+ {"RegsAMD64.DX", Field, 0, ""},
+ {"RegsAMD64.FLAGS", Field, 0, ""},
+ {"RegsAMD64.FS", Field, 0, ""},
+ {"RegsAMD64.GS", Field, 0, ""},
+ {"RegsAMD64.IP", Field, 0, ""},
+ {"RegsAMD64.R10", Field, 0, ""},
+ {"RegsAMD64.R11", Field, 0, ""},
+ {"RegsAMD64.R12", Field, 0, ""},
+ {"RegsAMD64.R13", Field, 0, ""},
+ {"RegsAMD64.R14", Field, 0, ""},
+ {"RegsAMD64.R15", Field, 0, ""},
+ {"RegsAMD64.R8", Field, 0, ""},
+ {"RegsAMD64.R9", Field, 0, ""},
+ {"RegsAMD64.SI", Field, 0, ""},
+ {"RegsAMD64.SP", Field, 0, ""},
+ {"Reloc", Type, 10, ""},
+ {"Reloc.Addr", Field, 10, ""},
+ {"Reloc.Extern", Field, 10, ""},
+ {"Reloc.Len", Field, 10, ""},
+ {"Reloc.Pcrel", Field, 10, ""},
+ {"Reloc.Scattered", Field, 10, ""},
+ {"Reloc.Type", Field, 10, ""},
+ {"Reloc.Value", Field, 10, ""},
+ {"RelocTypeARM", Type, 10, ""},
+ {"RelocTypeARM64", Type, 10, ""},
+ {"RelocTypeGeneric", Type, 10, ""},
+ {"RelocTypeX86_64", Type, 10, ""},
+ {"Rpath", Type, 10, ""},
+ {"Rpath.LoadBytes", Field, 10, ""},
+ {"Rpath.Path", Field, 10, ""},
+ {"RpathCmd", Type, 10, ""},
+ {"RpathCmd.Cmd", Field, 10, ""},
+ {"RpathCmd.Len", Field, 10, ""},
+ {"RpathCmd.Path", Field, 10, ""},
+ {"Section", Type, 0, ""},
+ {"Section.ReaderAt", Field, 0, ""},
+ {"Section.Relocs", Field, 10, ""},
+ {"Section.SectionHeader", Field, 0, ""},
+ {"Section32", Type, 0, ""},
+ {"Section32.Addr", Field, 0, ""},
+ {"Section32.Align", Field, 0, ""},
+ {"Section32.Flags", Field, 0, ""},
+ {"Section32.Name", Field, 0, ""},
+ {"Section32.Nreloc", Field, 0, ""},
+ {"Section32.Offset", Field, 0, ""},
+ {"Section32.Reloff", Field, 0, ""},
+ {"Section32.Reserve1", Field, 0, ""},
+ {"Section32.Reserve2", Field, 0, ""},
+ {"Section32.Seg", Field, 0, ""},
+ {"Section32.Size", Field, 0, ""},
+ {"Section64", Type, 0, ""},
+ {"Section64.Addr", Field, 0, ""},
+ {"Section64.Align", Field, 0, ""},
+ {"Section64.Flags", Field, 0, ""},
+ {"Section64.Name", Field, 0, ""},
+ {"Section64.Nreloc", Field, 0, ""},
+ {"Section64.Offset", Field, 0, ""},
+ {"Section64.Reloff", Field, 0, ""},
+ {"Section64.Reserve1", Field, 0, ""},
+ {"Section64.Reserve2", Field, 0, ""},
+ {"Section64.Reserve3", Field, 0, ""},
+ {"Section64.Seg", Field, 0, ""},
+ {"Section64.Size", Field, 0, ""},
+ {"SectionHeader", Type, 0, ""},
+ {"SectionHeader.Addr", Field, 0, ""},
+ {"SectionHeader.Align", Field, 0, ""},
+ {"SectionHeader.Flags", Field, 0, ""},
+ {"SectionHeader.Name", Field, 0, ""},
+ {"SectionHeader.Nreloc", Field, 0, ""},
+ {"SectionHeader.Offset", Field, 0, ""},
+ {"SectionHeader.Reloff", Field, 0, ""},
+ {"SectionHeader.Seg", Field, 0, ""},
+ {"SectionHeader.Size", Field, 0, ""},
+ {"Segment", Type, 0, ""},
+ {"Segment.LoadBytes", Field, 0, ""},
+ {"Segment.ReaderAt", Field, 0, ""},
+ {"Segment.SegmentHeader", Field, 0, ""},
+ {"Segment32", Type, 0, ""},
+ {"Segment32.Addr", Field, 0, ""},
+ {"Segment32.Cmd", Field, 0, ""},
+ {"Segment32.Filesz", Field, 0, ""},
+ {"Segment32.Flag", Field, 0, ""},
+ {"Segment32.Len", Field, 0, ""},
+ {"Segment32.Maxprot", Field, 0, ""},
+ {"Segment32.Memsz", Field, 0, ""},
+ {"Segment32.Name", Field, 0, ""},
+ {"Segment32.Nsect", Field, 0, ""},
+ {"Segment32.Offset", Field, 0, ""},
+ {"Segment32.Prot", Field, 0, ""},
+ {"Segment64", Type, 0, ""},
+ {"Segment64.Addr", Field, 0, ""},
+ {"Segment64.Cmd", Field, 0, ""},
+ {"Segment64.Filesz", Field, 0, ""},
+ {"Segment64.Flag", Field, 0, ""},
+ {"Segment64.Len", Field, 0, ""},
+ {"Segment64.Maxprot", Field, 0, ""},
+ {"Segment64.Memsz", Field, 0, ""},
+ {"Segment64.Name", Field, 0, ""},
+ {"Segment64.Nsect", Field, 0, ""},
+ {"Segment64.Offset", Field, 0, ""},
+ {"Segment64.Prot", Field, 0, ""},
+ {"SegmentHeader", Type, 0, ""},
+ {"SegmentHeader.Addr", Field, 0, ""},
+ {"SegmentHeader.Cmd", Field, 0, ""},
+ {"SegmentHeader.Filesz", Field, 0, ""},
+ {"SegmentHeader.Flag", Field, 0, ""},
+ {"SegmentHeader.Len", Field, 0, ""},
+ {"SegmentHeader.Maxprot", Field, 0, ""},
+ {"SegmentHeader.Memsz", Field, 0, ""},
+ {"SegmentHeader.Name", Field, 0, ""},
+ {"SegmentHeader.Nsect", Field, 0, ""},
+ {"SegmentHeader.Offset", Field, 0, ""},
+ {"SegmentHeader.Prot", Field, 0, ""},
+ {"Symbol", Type, 0, ""},
+ {"Symbol.Desc", Field, 0, ""},
+ {"Symbol.Name", Field, 0, ""},
+ {"Symbol.Sect", Field, 0, ""},
+ {"Symbol.Type", Field, 0, ""},
+ {"Symbol.Value", Field, 0, ""},
+ {"Symtab", Type, 0, ""},
+ {"Symtab.LoadBytes", Field, 0, ""},
+ {"Symtab.Syms", Field, 0, ""},
+ {"Symtab.SymtabCmd", Field, 0, ""},
+ {"SymtabCmd", Type, 0, ""},
+ {"SymtabCmd.Cmd", Field, 0, ""},
+ {"SymtabCmd.Len", Field, 0, ""},
+ {"SymtabCmd.Nsyms", Field, 0, ""},
+ {"SymtabCmd.Stroff", Field, 0, ""},
+ {"SymtabCmd.Strsize", Field, 0, ""},
+ {"SymtabCmd.Symoff", Field, 0, ""},
+ {"Thread", Type, 0, ""},
+ {"Thread.Cmd", Field, 0, ""},
+ {"Thread.Data", Field, 0, ""},
+ {"Thread.Len", Field, 0, ""},
+ {"Thread.Type", Field, 0, ""},
+ {"Type", Type, 0, ""},
+ {"TypeBundle", Const, 3, ""},
+ {"TypeDylib", Const, 3, ""},
+ {"TypeExec", Const, 0, ""},
+ {"TypeObj", Const, 0, ""},
+ {"X86_64_RELOC_BRANCH", Const, 10, ""},
+ {"X86_64_RELOC_GOT", Const, 10, ""},
+ {"X86_64_RELOC_GOT_LOAD", Const, 10, ""},
+ {"X86_64_RELOC_SIGNED", Const, 10, ""},
+ {"X86_64_RELOC_SIGNED_1", Const, 10, ""},
+ {"X86_64_RELOC_SIGNED_2", Const, 10, ""},
+ {"X86_64_RELOC_SIGNED_4", Const, 10, ""},
+ {"X86_64_RELOC_SUBTRACTOR", Const, 10, ""},
+ {"X86_64_RELOC_TLV", Const, 10, ""},
+ {"X86_64_RELOC_UNSIGNED", Const, 10, ""},
+ },
+ "debug/pe": {
+ {"(*COFFSymbol).FullName", Method, 8, ""},
+ {"(*File).COFFSymbolReadSectionDefAux", Method, 19, ""},
+ {"(*File).Close", Method, 0, ""},
+ {"(*File).DWARF", Method, 0, ""},
+ {"(*File).ImportedLibraries", Method, 0, ""},
+ {"(*File).ImportedSymbols", Method, 0, ""},
+ {"(*File).Section", Method, 0, ""},
+ {"(*FormatError).Error", Method, 0, ""},
+ {"(*Section).Data", Method, 0, ""},
+ {"(*Section).Open", Method, 0, ""},
+ {"(Section).ReadAt", Method, 0, ""},
+ {"(StringTable).String", Method, 8, ""},
+ {"COFFSymbol", Type, 1, ""},
+ {"COFFSymbol.Name", Field, 1, ""},
+ {"COFFSymbol.NumberOfAuxSymbols", Field, 1, ""},
+ {"COFFSymbol.SectionNumber", Field, 1, ""},
+ {"COFFSymbol.StorageClass", Field, 1, ""},
+ {"COFFSymbol.Type", Field, 1, ""},
+ {"COFFSymbol.Value", Field, 1, ""},
+ {"COFFSymbolAuxFormat5", Type, 19, ""},
+ {"COFFSymbolAuxFormat5.Checksum", Field, 19, ""},
+ {"COFFSymbolAuxFormat5.NumLineNumbers", Field, 19, ""},
+ {"COFFSymbolAuxFormat5.NumRelocs", Field, 19, ""},
+ {"COFFSymbolAuxFormat5.SecNum", Field, 19, ""},
+ {"COFFSymbolAuxFormat5.Selection", Field, 19, ""},
+ {"COFFSymbolAuxFormat5.Size", Field, 19, ""},
+ {"COFFSymbolSize", Const, 1, ""},
+ {"DataDirectory", Type, 3, ""},
+ {"DataDirectory.Size", Field, 3, ""},
+ {"DataDirectory.VirtualAddress", Field, 3, ""},
+ {"File", Type, 0, ""},
+ {"File.COFFSymbols", Field, 8, ""},
+ {"File.FileHeader", Field, 0, ""},
+ {"File.OptionalHeader", Field, 3, ""},
+ {"File.Sections", Field, 0, ""},
+ {"File.StringTable", Field, 8, ""},
+ {"File.Symbols", Field, 1, ""},
+ {"FileHeader", Type, 0, ""},
+ {"FileHeader.Characteristics", Field, 0, ""},
+ {"FileHeader.Machine", Field, 0, ""},
+ {"FileHeader.NumberOfSections", Field, 0, ""},
+ {"FileHeader.NumberOfSymbols", Field, 0, ""},
+ {"FileHeader.PointerToSymbolTable", Field, 0, ""},
+ {"FileHeader.SizeOfOptionalHeader", Field, 0, ""},
+ {"FileHeader.TimeDateStamp", Field, 0, ""},
+ {"FormatError", Type, 0, ""},
+ {"IMAGE_COMDAT_SELECT_ANY", Const, 19, ""},
+ {"IMAGE_COMDAT_SELECT_ASSOCIATIVE", Const, 19, ""},
+ {"IMAGE_COMDAT_SELECT_EXACT_MATCH", Const, 19, ""},
+ {"IMAGE_COMDAT_SELECT_LARGEST", Const, 19, ""},
+ {"IMAGE_COMDAT_SELECT_NODUPLICATES", Const, 19, ""},
+ {"IMAGE_COMDAT_SELECT_SAME_SIZE", Const, 19, ""},
+ {"IMAGE_DIRECTORY_ENTRY_ARCHITECTURE", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_BASERELOC", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_DEBUG", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_EXCEPTION", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_EXPORT", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_GLOBALPTR", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_IAT", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_IMPORT", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_RESOURCE", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_SECURITY", Const, 11, ""},
+ {"IMAGE_DIRECTORY_ENTRY_TLS", Const, 11, ""},
+ {"IMAGE_DLLCHARACTERISTICS_APPCONTAINER", Const, 15, ""},
+ {"IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE", Const, 15, ""},
+ {"IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY", Const, 15, ""},
+ {"IMAGE_DLLCHARACTERISTICS_GUARD_CF", Const, 15, ""},
+ {"IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA", Const, 15, ""},
+ {"IMAGE_DLLCHARACTERISTICS_NO_BIND", Const, 15, ""},
+ {"IMAGE_DLLCHARACTERISTICS_NO_ISOLATION", Const, 15, ""},
+ {"IMAGE_DLLCHARACTERISTICS_NO_SEH", Const, 15, ""},
+ {"IMAGE_DLLCHARACTERISTICS_NX_COMPAT", Const, 15, ""},
+ {"IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE", Const, 15, ""},
+ {"IMAGE_DLLCHARACTERISTICS_WDM_DRIVER", Const, 15, ""},
+ {"IMAGE_FILE_32BIT_MACHINE", Const, 15, ""},
+ {"IMAGE_FILE_AGGRESIVE_WS_TRIM", Const, 15, ""},
+ {"IMAGE_FILE_BYTES_REVERSED_HI", Const, 15, ""},
+ {"IMAGE_FILE_BYTES_REVERSED_LO", Const, 15, ""},
+ {"IMAGE_FILE_DEBUG_STRIPPED", Const, 15, ""},
+ {"IMAGE_FILE_DLL", Const, 15, ""},
+ {"IMAGE_FILE_EXECUTABLE_IMAGE", Const, 15, ""},
+ {"IMAGE_FILE_LARGE_ADDRESS_AWARE", Const, 15, ""},
+ {"IMAGE_FILE_LINE_NUMS_STRIPPED", Const, 15, ""},
+ {"IMAGE_FILE_LOCAL_SYMS_STRIPPED", Const, 15, ""},
+ {"IMAGE_FILE_MACHINE_AM33", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_AMD64", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_ARM", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_ARM64", Const, 11, ""},
+ {"IMAGE_FILE_MACHINE_ARMNT", Const, 12, ""},
+ {"IMAGE_FILE_MACHINE_EBC", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_I386", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_IA64", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_LOONGARCH32", Const, 19, ""},
+ {"IMAGE_FILE_MACHINE_LOONGARCH64", Const, 19, ""},
+ {"IMAGE_FILE_MACHINE_M32R", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_MIPS16", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_MIPSFPU", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_MIPSFPU16", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_POWERPC", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_POWERPCFP", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_R4000", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_RISCV128", Const, 20, ""},
+ {"IMAGE_FILE_MACHINE_RISCV32", Const, 20, ""},
+ {"IMAGE_FILE_MACHINE_RISCV64", Const, 20, ""},
+ {"IMAGE_FILE_MACHINE_SH3", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_SH3DSP", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_SH4", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_SH5", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_THUMB", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_UNKNOWN", Const, 0, ""},
+ {"IMAGE_FILE_MACHINE_WCEMIPSV2", Const, 0, ""},
+ {"IMAGE_FILE_NET_RUN_FROM_SWAP", Const, 15, ""},
+ {"IMAGE_FILE_RELOCS_STRIPPED", Const, 15, ""},
+ {"IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP", Const, 15, ""},
+ {"IMAGE_FILE_SYSTEM", Const, 15, ""},
+ {"IMAGE_FILE_UP_SYSTEM_ONLY", Const, 15, ""},
+ {"IMAGE_SCN_CNT_CODE", Const, 19, ""},
+ {"IMAGE_SCN_CNT_INITIALIZED_DATA", Const, 19, ""},
+ {"IMAGE_SCN_CNT_UNINITIALIZED_DATA", Const, 19, ""},
+ {"IMAGE_SCN_LNK_COMDAT", Const, 19, ""},
+ {"IMAGE_SCN_MEM_DISCARDABLE", Const, 19, ""},
+ {"IMAGE_SCN_MEM_EXECUTE", Const, 19, ""},
+ {"IMAGE_SCN_MEM_READ", Const, 19, ""},
+ {"IMAGE_SCN_MEM_WRITE", Const, 19, ""},
+ {"IMAGE_SUBSYSTEM_EFI_APPLICATION", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_EFI_ROM", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_NATIVE", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_NATIVE_WINDOWS", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_OS2_CUI", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_POSIX_CUI", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_UNKNOWN", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_WINDOWS_CE_GUI", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_WINDOWS_CUI", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_WINDOWS_GUI", Const, 15, ""},
+ {"IMAGE_SUBSYSTEM_XBOX", Const, 15, ""},
+ {"ImportDirectory", Type, 0, ""},
+ {"ImportDirectory.FirstThunk", Field, 0, ""},
+ {"ImportDirectory.ForwarderChain", Field, 0, ""},
+ {"ImportDirectory.Name", Field, 0, ""},
+ {"ImportDirectory.OriginalFirstThunk", Field, 0, ""},
+ {"ImportDirectory.TimeDateStamp", Field, 0, ""},
+ {"NewFile", Func, 0, "func(r io.ReaderAt) (*File, error)"},
+ {"Open", Func, 0, "func(name string) (*File, error)"},
+ {"OptionalHeader32", Type, 3, ""},
+ {"OptionalHeader32.AddressOfEntryPoint", Field, 3, ""},
+ {"OptionalHeader32.BaseOfCode", Field, 3, ""},
+ {"OptionalHeader32.BaseOfData", Field, 3, ""},
+ {"OptionalHeader32.CheckSum", Field, 3, ""},
+ {"OptionalHeader32.DataDirectory", Field, 3, ""},
+ {"OptionalHeader32.DllCharacteristics", Field, 3, ""},
+ {"OptionalHeader32.FileAlignment", Field, 3, ""},
+ {"OptionalHeader32.ImageBase", Field, 3, ""},
+ {"OptionalHeader32.LoaderFlags", Field, 3, ""},
+ {"OptionalHeader32.Magic", Field, 3, ""},
+ {"OptionalHeader32.MajorImageVersion", Field, 3, ""},
+ {"OptionalHeader32.MajorLinkerVersion", Field, 3, ""},
+ {"OptionalHeader32.MajorOperatingSystemVersion", Field, 3, ""},
+ {"OptionalHeader32.MajorSubsystemVersion", Field, 3, ""},
+ {"OptionalHeader32.MinorImageVersion", Field, 3, ""},
+ {"OptionalHeader32.MinorLinkerVersion", Field, 3, ""},
+ {"OptionalHeader32.MinorOperatingSystemVersion", Field, 3, ""},
+ {"OptionalHeader32.MinorSubsystemVersion", Field, 3, ""},
+ {"OptionalHeader32.NumberOfRvaAndSizes", Field, 3, ""},
+ {"OptionalHeader32.SectionAlignment", Field, 3, ""},
+ {"OptionalHeader32.SizeOfCode", Field, 3, ""},
+ {"OptionalHeader32.SizeOfHeaders", Field, 3, ""},
+ {"OptionalHeader32.SizeOfHeapCommit", Field, 3, ""},
+ {"OptionalHeader32.SizeOfHeapReserve", Field, 3, ""},
+ {"OptionalHeader32.SizeOfImage", Field, 3, ""},
+ {"OptionalHeader32.SizeOfInitializedData", Field, 3, ""},
+ {"OptionalHeader32.SizeOfStackCommit", Field, 3, ""},
+ {"OptionalHeader32.SizeOfStackReserve", Field, 3, ""},
+ {"OptionalHeader32.SizeOfUninitializedData", Field, 3, ""},
+ {"OptionalHeader32.Subsystem", Field, 3, ""},
+ {"OptionalHeader32.Win32VersionValue", Field, 3, ""},
+ {"OptionalHeader64", Type, 3, ""},
+ {"OptionalHeader64.AddressOfEntryPoint", Field, 3, ""},
+ {"OptionalHeader64.BaseOfCode", Field, 3, ""},
+ {"OptionalHeader64.CheckSum", Field, 3, ""},
+ {"OptionalHeader64.DataDirectory", Field, 3, ""},
+ {"OptionalHeader64.DllCharacteristics", Field, 3, ""},
+ {"OptionalHeader64.FileAlignment", Field, 3, ""},
+ {"OptionalHeader64.ImageBase", Field, 3, ""},
+ {"OptionalHeader64.LoaderFlags", Field, 3, ""},
+ {"OptionalHeader64.Magic", Field, 3, ""},
+ {"OptionalHeader64.MajorImageVersion", Field, 3, ""},
+ {"OptionalHeader64.MajorLinkerVersion", Field, 3, ""},
+ {"OptionalHeader64.MajorOperatingSystemVersion", Field, 3, ""},
+ {"OptionalHeader64.MajorSubsystemVersion", Field, 3, ""},
+ {"OptionalHeader64.MinorImageVersion", Field, 3, ""},
+ {"OptionalHeader64.MinorLinkerVersion", Field, 3, ""},
+ {"OptionalHeader64.MinorOperatingSystemVersion", Field, 3, ""},
+ {"OptionalHeader64.MinorSubsystemVersion", Field, 3, ""},
+ {"OptionalHeader64.NumberOfRvaAndSizes", Field, 3, ""},
+ {"OptionalHeader64.SectionAlignment", Field, 3, ""},
+ {"OptionalHeader64.SizeOfCode", Field, 3, ""},
+ {"OptionalHeader64.SizeOfHeaders", Field, 3, ""},
+ {"OptionalHeader64.SizeOfHeapCommit", Field, 3, ""},
+ {"OptionalHeader64.SizeOfHeapReserve", Field, 3, ""},
+ {"OptionalHeader64.SizeOfImage", Field, 3, ""},
+ {"OptionalHeader64.SizeOfInitializedData", Field, 3, ""},
+ {"OptionalHeader64.SizeOfStackCommit", Field, 3, ""},
+ {"OptionalHeader64.SizeOfStackReserve", Field, 3, ""},
+ {"OptionalHeader64.SizeOfUninitializedData", Field, 3, ""},
+ {"OptionalHeader64.Subsystem", Field, 3, ""},
+ {"OptionalHeader64.Win32VersionValue", Field, 3, ""},
+ {"Reloc", Type, 8, ""},
+ {"Reloc.SymbolTableIndex", Field, 8, ""},
+ {"Reloc.Type", Field, 8, ""},
+ {"Reloc.VirtualAddress", Field, 8, ""},
+ {"Section", Type, 0, ""},
+ {"Section.ReaderAt", Field, 0, ""},
+ {"Section.Relocs", Field, 8, ""},
+ {"Section.SectionHeader", Field, 0, ""},
+ {"SectionHeader", Type, 0, ""},
+ {"SectionHeader.Characteristics", Field, 0, ""},
+ {"SectionHeader.Name", Field, 0, ""},
+ {"SectionHeader.NumberOfLineNumbers", Field, 0, ""},
+ {"SectionHeader.NumberOfRelocations", Field, 0, ""},
+ {"SectionHeader.Offset", Field, 0, ""},
+ {"SectionHeader.PointerToLineNumbers", Field, 0, ""},
+ {"SectionHeader.PointerToRelocations", Field, 0, ""},
+ {"SectionHeader.Size", Field, 0, ""},
+ {"SectionHeader.VirtualAddress", Field, 0, ""},
+ {"SectionHeader.VirtualSize", Field, 0, ""},
+ {"SectionHeader32", Type, 0, ""},
+ {"SectionHeader32.Characteristics", Field, 0, ""},
+ {"SectionHeader32.Name", Field, 0, ""},
+ {"SectionHeader32.NumberOfLineNumbers", Field, 0, ""},
+ {"SectionHeader32.NumberOfRelocations", Field, 0, ""},
+ {"SectionHeader32.PointerToLineNumbers", Field, 0, ""},
+ {"SectionHeader32.PointerToRawData", Field, 0, ""},
+ {"SectionHeader32.PointerToRelocations", Field, 0, ""},
+ {"SectionHeader32.SizeOfRawData", Field, 0, ""},
+ {"SectionHeader32.VirtualAddress", Field, 0, ""},
+ {"SectionHeader32.VirtualSize", Field, 0, ""},
+ {"StringTable", Type, 8, ""},
+ {"Symbol", Type, 1, ""},
+ {"Symbol.Name", Field, 1, ""},
+ {"Symbol.SectionNumber", Field, 1, ""},
+ {"Symbol.StorageClass", Field, 1, ""},
+ {"Symbol.Type", Field, 1, ""},
+ {"Symbol.Value", Field, 1, ""},
+ },
+ "debug/plan9obj": {
+ {"(*File).Close", Method, 3, ""},
+ {"(*File).Section", Method, 3, ""},
+ {"(*File).Symbols", Method, 3, ""},
+ {"(*Section).Data", Method, 3, ""},
+ {"(*Section).Open", Method, 3, ""},
+ {"(Section).ReadAt", Method, 3, ""},
+ {"ErrNoSymbols", Var, 18, ""},
+ {"File", Type, 3, ""},
+ {"File.FileHeader", Field, 3, ""},
+ {"File.Sections", Field, 3, ""},
+ {"FileHeader", Type, 3, ""},
+ {"FileHeader.Bss", Field, 3, ""},
+ {"FileHeader.Entry", Field, 3, ""},
+ {"FileHeader.HdrSize", Field, 4, ""},
+ {"FileHeader.LoadAddress", Field, 4, ""},
+ {"FileHeader.Magic", Field, 3, ""},
+ {"FileHeader.PtrSize", Field, 3, ""},
+ {"Magic386", Const, 3, ""},
+ {"Magic64", Const, 3, ""},
+ {"MagicAMD64", Const, 3, ""},
+ {"MagicARM", Const, 3, ""},
+ {"NewFile", Func, 3, "func(r io.ReaderAt) (*File, error)"},
+ {"Open", Func, 3, "func(name string) (*File, error)"},
+ {"Section", Type, 3, ""},
+ {"Section.ReaderAt", Field, 3, ""},
+ {"Section.SectionHeader", Field, 3, ""},
+ {"SectionHeader", Type, 3, ""},
+ {"SectionHeader.Name", Field, 3, ""},
+ {"SectionHeader.Offset", Field, 3, ""},
+ {"SectionHeader.Size", Field, 3, ""},
+ {"Sym", Type, 3, ""},
+ {"Sym.Name", Field, 3, ""},
+ {"Sym.Type", Field, 3, ""},
+ {"Sym.Value", Field, 3, ""},
+ },
+ "embed": {
+ {"(FS).Open", Method, 16, ""},
+ {"(FS).ReadDir", Method, 16, ""},
+ {"(FS).ReadFile", Method, 16, ""},
+ {"FS", Type, 16, ""},
+ },
+ "encoding": {
+ {"BinaryAppender", Type, 24, ""},
+ {"BinaryMarshaler", Type, 2, ""},
+ {"BinaryUnmarshaler", Type, 2, ""},
+ {"TextAppender", Type, 24, ""},
+ {"TextMarshaler", Type, 2, ""},
+ {"TextUnmarshaler", Type, 2, ""},
+ },
+ "encoding/ascii85": {
+ {"(CorruptInputError).Error", Method, 0, ""},
+ {"CorruptInputError", Type, 0, ""},
+ {"Decode", Func, 0, "func(dst []byte, src []byte, flush bool) (ndst int, nsrc int, err error)"},
+ {"Encode", Func, 0, "func(dst []byte, src []byte) int"},
+ {"MaxEncodedLen", Func, 0, "func(n int) int"},
+ {"NewDecoder", Func, 0, "func(r io.Reader) io.Reader"},
+ {"NewEncoder", Func, 0, "func(w io.Writer) io.WriteCloser"},
+ },
+ "encoding/asn1": {
+ {"(BitString).At", Method, 0, ""},
+ {"(BitString).RightAlign", Method, 0, ""},
+ {"(ObjectIdentifier).Equal", Method, 0, ""},
+ {"(ObjectIdentifier).String", Method, 3, ""},
+ {"(StructuralError).Error", Method, 0, ""},
+ {"(SyntaxError).Error", Method, 0, ""},
+ {"BitString", Type, 0, ""},
+ {"BitString.BitLength", Field, 0, ""},
+ {"BitString.Bytes", Field, 0, ""},
+ {"ClassApplication", Const, 6, ""},
+ {"ClassContextSpecific", Const, 6, ""},
+ {"ClassPrivate", Const, 6, ""},
+ {"ClassUniversal", Const, 6, ""},
+ {"Enumerated", Type, 0, ""},
+ {"Flag", Type, 0, ""},
+ {"Marshal", Func, 0, "func(val any) ([]byte, error)"},
+ {"MarshalWithParams", Func, 10, "func(val any, params string) ([]byte, error)"},
+ {"NullBytes", Var, 9, ""},
+ {"NullRawValue", Var, 9, ""},
+ {"ObjectIdentifier", Type, 0, ""},
+ {"RawContent", Type, 0, ""},
+ {"RawValue", Type, 0, ""},
+ {"RawValue.Bytes", Field, 0, ""},
+ {"RawValue.Class", Field, 0, ""},
+ {"RawValue.FullBytes", Field, 0, ""},
+ {"RawValue.IsCompound", Field, 0, ""},
+ {"RawValue.Tag", Field, 0, ""},
+ {"StructuralError", Type, 0, ""},
+ {"StructuralError.Msg", Field, 0, ""},
+ {"SyntaxError", Type, 0, ""},
+ {"SyntaxError.Msg", Field, 0, ""},
+ {"TagBMPString", Const, 14, ""},
+ {"TagBitString", Const, 6, ""},
+ {"TagBoolean", Const, 6, ""},
+ {"TagEnum", Const, 6, ""},
+ {"TagGeneralString", Const, 6, ""},
+ {"TagGeneralizedTime", Const, 6, ""},
+ {"TagIA5String", Const, 6, ""},
+ {"TagInteger", Const, 6, ""},
+ {"TagNull", Const, 9, ""},
+ {"TagNumericString", Const, 10, ""},
+ {"TagOID", Const, 6, ""},
+ {"TagOctetString", Const, 6, ""},
+ {"TagPrintableString", Const, 6, ""},
+ {"TagSequence", Const, 6, ""},
+ {"TagSet", Const, 6, ""},
+ {"TagT61String", Const, 6, ""},
+ {"TagUTCTime", Const, 6, ""},
+ {"TagUTF8String", Const, 6, ""},
+ {"Unmarshal", Func, 0, "func(b []byte, val any) (rest []byte, err error)"},
+ {"UnmarshalWithParams", Func, 0, "func(b []byte, val any, params string) (rest []byte, err error)"},
+ },
+ "encoding/base32": {
+ {"(*Encoding).AppendDecode", Method, 22, ""},
+ {"(*Encoding).AppendEncode", Method, 22, ""},
+ {"(*Encoding).Decode", Method, 0, ""},
+ {"(*Encoding).DecodeString", Method, 0, ""},
+ {"(*Encoding).DecodedLen", Method, 0, ""},
+ {"(*Encoding).Encode", Method, 0, ""},
+ {"(*Encoding).EncodeToString", Method, 0, ""},
+ {"(*Encoding).EncodedLen", Method, 0, ""},
+ {"(CorruptInputError).Error", Method, 0, ""},
+ {"(Encoding).WithPadding", Method, 9, ""},
+ {"CorruptInputError", Type, 0, ""},
+ {"Encoding", Type, 0, ""},
+ {"HexEncoding", Var, 0, ""},
+ {"NewDecoder", Func, 0, "func(enc *Encoding, r io.Reader) io.Reader"},
+ {"NewEncoder", Func, 0, "func(enc *Encoding, w io.Writer) io.WriteCloser"},
+ {"NewEncoding", Func, 0, "func(encoder string) *Encoding"},
+ {"NoPadding", Const, 9, ""},
+ {"StdEncoding", Var, 0, ""},
+ {"StdPadding", Const, 9, ""},
+ },
+ "encoding/base64": {
+ {"(*Encoding).AppendDecode", Method, 22, ""},
+ {"(*Encoding).AppendEncode", Method, 22, ""},
+ {"(*Encoding).Decode", Method, 0, ""},
+ {"(*Encoding).DecodeString", Method, 0, ""},
+ {"(*Encoding).DecodedLen", Method, 0, ""},
+ {"(*Encoding).Encode", Method, 0, ""},
+ {"(*Encoding).EncodeToString", Method, 0, ""},
+ {"(*Encoding).EncodedLen", Method, 0, ""},
+ {"(CorruptInputError).Error", Method, 0, ""},
+ {"(Encoding).Strict", Method, 8, ""},
+ {"(Encoding).WithPadding", Method, 5, ""},
+ {"CorruptInputError", Type, 0, ""},
+ {"Encoding", Type, 0, ""},
+ {"NewDecoder", Func, 0, "func(enc *Encoding, r io.Reader) io.Reader"},
+ {"NewEncoder", Func, 0, "func(enc *Encoding, w io.Writer) io.WriteCloser"},
+ {"NewEncoding", Func, 0, "func(encoder string) *Encoding"},
+ {"NoPadding", Const, 5, ""},
+ {"RawStdEncoding", Var, 5, ""},
+ {"RawURLEncoding", Var, 5, ""},
+ {"StdEncoding", Var, 0, ""},
+ {"StdPadding", Const, 5, ""},
+ {"URLEncoding", Var, 0, ""},
+ },
+ "encoding/binary": {
+ {"Append", Func, 23, "func(buf []byte, order ByteOrder, data any) ([]byte, error)"},
+ {"AppendByteOrder", Type, 19, ""},
+ {"AppendUvarint", Func, 19, "func(buf []byte, x uint64) []byte"},
+ {"AppendVarint", Func, 19, "func(buf []byte, x int64) []byte"},
+ {"BigEndian", Var, 0, ""},
+ {"ByteOrder", Type, 0, ""},
+ {"Decode", Func, 23, "func(buf []byte, order ByteOrder, data any) (int, error)"},
+ {"Encode", Func, 23, "func(buf []byte, order ByteOrder, data any) (int, error)"},
+ {"LittleEndian", Var, 0, ""},
+ {"MaxVarintLen16", Const, 0, ""},
+ {"MaxVarintLen32", Const, 0, ""},
+ {"MaxVarintLen64", Const, 0, ""},
+ {"NativeEndian", Var, 21, ""},
+ {"PutUvarint", Func, 0, "func(buf []byte, x uint64) int"},
+ {"PutVarint", Func, 0, "func(buf []byte, x int64) int"},
+ {"Read", Func, 0, "func(r io.Reader, order ByteOrder, data any) error"},
+ {"ReadUvarint", Func, 0, "func(r io.ByteReader) (uint64, error)"},
+ {"ReadVarint", Func, 0, "func(r io.ByteReader) (int64, error)"},
+ {"Size", Func, 0, "func(v any) int"},
+ {"Uvarint", Func, 0, "func(buf []byte) (uint64, int)"},
+ {"Varint", Func, 0, "func(buf []byte) (int64, int)"},
+ {"Write", Func, 0, "func(w io.Writer, order ByteOrder, data any) error"},
+ },
+ "encoding/csv": {
+ {"(*ParseError).Error", Method, 0, ""},
+ {"(*ParseError).Unwrap", Method, 13, ""},
+ {"(*Reader).FieldPos", Method, 17, ""},
+ {"(*Reader).InputOffset", Method, 19, ""},
+ {"(*Reader).Read", Method, 0, ""},
+ {"(*Reader).ReadAll", Method, 0, ""},
+ {"(*Writer).Error", Method, 1, ""},
+ {"(*Writer).Flush", Method, 0, ""},
+ {"(*Writer).Write", Method, 0, ""},
+ {"(*Writer).WriteAll", Method, 0, ""},
+ {"ErrBareQuote", Var, 0, ""},
+ {"ErrFieldCount", Var, 0, ""},
+ {"ErrQuote", Var, 0, ""},
+ {"ErrTrailingComma", Var, 0, ""},
+ {"NewReader", Func, 0, "func(r io.Reader) *Reader"},
+ {"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
+ {"ParseError", Type, 0, ""},
+ {"ParseError.Column", Field, 0, ""},
+ {"ParseError.Err", Field, 0, ""},
+ {"ParseError.Line", Field, 0, ""},
+ {"ParseError.StartLine", Field, 10, ""},
+ {"Reader", Type, 0, ""},
+ {"Reader.Comma", Field, 0, ""},
+ {"Reader.Comment", Field, 0, ""},
+ {"Reader.FieldsPerRecord", Field, 0, ""},
+ {"Reader.LazyQuotes", Field, 0, ""},
+ {"Reader.ReuseRecord", Field, 9, ""},
+ {"Reader.TrailingComma", Field, 0, ""},
+ {"Reader.TrimLeadingSpace", Field, 0, ""},
+ {"Writer", Type, 0, ""},
+ {"Writer.Comma", Field, 0, ""},
+ {"Writer.UseCRLF", Field, 0, ""},
+ },
+ "encoding/gob": {
+ {"(*Decoder).Decode", Method, 0, ""},
+ {"(*Decoder).DecodeValue", Method, 0, ""},
+ {"(*Encoder).Encode", Method, 0, ""},
+ {"(*Encoder).EncodeValue", Method, 0, ""},
+ {"CommonType", Type, 0, ""},
+ {"CommonType.Id", Field, 0, ""},
+ {"CommonType.Name", Field, 0, ""},
+ {"Decoder", Type, 0, ""},
+ {"Encoder", Type, 0, ""},
+ {"GobDecoder", Type, 0, ""},
+ {"GobEncoder", Type, 0, ""},
+ {"NewDecoder", Func, 0, "func(r io.Reader) *Decoder"},
+ {"NewEncoder", Func, 0, "func(w io.Writer) *Encoder"},
+ {"Register", Func, 0, "func(value any)"},
+ {"RegisterName", Func, 0, "func(name string, value any)"},
+ },
+ "encoding/hex": {
+ {"(InvalidByteError).Error", Method, 0, ""},
+ {"AppendDecode", Func, 22, "func(dst []byte, src []byte) ([]byte, error)"},
+ {"AppendEncode", Func, 22, "func(dst []byte, src []byte) []byte"},
+ {"Decode", Func, 0, "func(dst []byte, src []byte) (int, error)"},
+ {"DecodeString", Func, 0, "func(s string) ([]byte, error)"},
+ {"DecodedLen", Func, 0, "func(x int) int"},
+ {"Dump", Func, 0, "func(data []byte) string"},
+ {"Dumper", Func, 0, "func(w io.Writer) io.WriteCloser"},
+ {"Encode", Func, 0, "func(dst []byte, src []byte) int"},
+ {"EncodeToString", Func, 0, "func(src []byte) string"},
+ {"EncodedLen", Func, 0, "func(n int) int"},
+ {"ErrLength", Var, 0, ""},
+ {"InvalidByteError", Type, 0, ""},
+ {"NewDecoder", Func, 10, "func(r io.Reader) io.Reader"},
+ {"NewEncoder", Func, 10, "func(w io.Writer) io.Writer"},
+ },
+ "encoding/json": {
+ {"(*Decoder).Buffered", Method, 1, ""},
+ {"(*Decoder).Decode", Method, 0, ""},
+ {"(*Decoder).DisallowUnknownFields", Method, 10, ""},
+ {"(*Decoder).InputOffset", Method, 14, ""},
+ {"(*Decoder).More", Method, 5, ""},
+ {"(*Decoder).Token", Method, 5, ""},
+ {"(*Decoder).UseNumber", Method, 1, ""},
+ {"(*Encoder).Encode", Method, 0, ""},
+ {"(*Encoder).SetEscapeHTML", Method, 7, ""},
+ {"(*Encoder).SetIndent", Method, 7, ""},
+ {"(*InvalidUTF8Error).Error", Method, 0, ""},
+ {"(*InvalidUnmarshalError).Error", Method, 0, ""},
+ {"(*MarshalerError).Error", Method, 0, ""},
+ {"(*MarshalerError).Unwrap", Method, 13, ""},
+ {"(*RawMessage).MarshalJSON", Method, 0, ""},
+ {"(*RawMessage).UnmarshalJSON", Method, 0, ""},
+ {"(*SyntaxError).Error", Method, 0, ""},
+ {"(*UnmarshalFieldError).Error", Method, 0, ""},
+ {"(*UnmarshalTypeError).Error", Method, 0, ""},
+ {"(*UnsupportedTypeError).Error", Method, 0, ""},
+ {"(*UnsupportedValueError).Error", Method, 0, ""},
+ {"(Delim).String", Method, 5, ""},
+ {"(Number).Float64", Method, 1, ""},
+ {"(Number).Int64", Method, 1, ""},
+ {"(Number).String", Method, 1, ""},
+ {"(RawMessage).MarshalJSON", Method, 8, ""},
+ {"Compact", Func, 0, "func(dst *bytes.Buffer, src []byte) error"},
+ {"Decoder", Type, 0, ""},
+ {"Delim", Type, 5, ""},
+ {"Encoder", Type, 0, ""},
+ {"HTMLEscape", Func, 0, "func(dst *bytes.Buffer, src []byte)"},
+ {"Indent", Func, 0, "func(dst *bytes.Buffer, src []byte, prefix string, indent string) error"},
+ {"InvalidUTF8Error", Type, 0, ""},
+ {"InvalidUTF8Error.S", Field, 0, ""},
+ {"InvalidUnmarshalError", Type, 0, ""},
+ {"InvalidUnmarshalError.Type", Field, 0, ""},
+ {"Marshal", Func, 0, "func(v any) ([]byte, error)"},
+ {"MarshalIndent", Func, 0, "func(v any, prefix string, indent string) ([]byte, error)"},
+ {"Marshaler", Type, 0, ""},
+ {"MarshalerError", Type, 0, ""},
+ {"MarshalerError.Err", Field, 0, ""},
+ {"MarshalerError.Type", Field, 0, ""},
+ {"NewDecoder", Func, 0, "func(r io.Reader) *Decoder"},
+ {"NewEncoder", Func, 0, "func(w io.Writer) *Encoder"},
+ {"Number", Type, 1, ""},
+ {"RawMessage", Type, 0, ""},
+ {"SyntaxError", Type, 0, ""},
+ {"SyntaxError.Offset", Field, 0, ""},
+ {"Token", Type, 5, ""},
+ {"Unmarshal", Func, 0, "func(data []byte, v any) error"},
+ {"UnmarshalFieldError", Type, 0, ""},
+ {"UnmarshalFieldError.Field", Field, 0, ""},
+ {"UnmarshalFieldError.Key", Field, 0, ""},
+ {"UnmarshalFieldError.Type", Field, 0, ""},
+ {"UnmarshalTypeError", Type, 0, ""},
+ {"UnmarshalTypeError.Field", Field, 8, ""},
+ {"UnmarshalTypeError.Offset", Field, 5, ""},
+ {"UnmarshalTypeError.Struct", Field, 8, ""},
+ {"UnmarshalTypeError.Type", Field, 0, ""},
+ {"UnmarshalTypeError.Value", Field, 0, ""},
+ {"Unmarshaler", Type, 0, ""},
+ {"UnsupportedTypeError", Type, 0, ""},
+ {"UnsupportedTypeError.Type", Field, 0, ""},
+ {"UnsupportedValueError", Type, 0, ""},
+ {"UnsupportedValueError.Str", Field, 0, ""},
+ {"UnsupportedValueError.Value", Field, 0, ""},
+ {"Valid", Func, 9, "func(data []byte) bool"},
+ },
+ "encoding/pem": {
+ {"Block", Type, 0, ""},
+ {"Block.Bytes", Field, 0, ""},
+ {"Block.Headers", Field, 0, ""},
+ {"Block.Type", Field, 0, ""},
+ {"Decode", Func, 0, "func(data []byte) (p *Block, rest []byte)"},
+ {"Encode", Func, 0, "func(out io.Writer, b *Block) error"},
+ {"EncodeToMemory", Func, 0, "func(b *Block) []byte"},
+ },
+ "encoding/xml": {
+ {"(*Decoder).Decode", Method, 0, ""},
+ {"(*Decoder).DecodeElement", Method, 0, ""},
+ {"(*Decoder).InputOffset", Method, 4, ""},
+ {"(*Decoder).InputPos", Method, 19, ""},
+ {"(*Decoder).RawToken", Method, 0, ""},
+ {"(*Decoder).Skip", Method, 0, ""},
+ {"(*Decoder).Token", Method, 0, ""},
+ {"(*Encoder).Close", Method, 20, ""},
+ {"(*Encoder).Encode", Method, 0, ""},
+ {"(*Encoder).EncodeElement", Method, 2, ""},
+ {"(*Encoder).EncodeToken", Method, 2, ""},
+ {"(*Encoder).Flush", Method, 2, ""},
+ {"(*Encoder).Indent", Method, 1, ""},
+ {"(*SyntaxError).Error", Method, 0, ""},
+ {"(*TagPathError).Error", Method, 0, ""},
+ {"(*UnsupportedTypeError).Error", Method, 0, ""},
+ {"(CharData).Copy", Method, 0, ""},
+ {"(Comment).Copy", Method, 0, ""},
+ {"(Directive).Copy", Method, 0, ""},
+ {"(ProcInst).Copy", Method, 0, ""},
+ {"(StartElement).Copy", Method, 0, ""},
+ {"(StartElement).End", Method, 2, ""},
+ {"(UnmarshalError).Error", Method, 0, ""},
+ {"Attr", Type, 0, ""},
+ {"Attr.Name", Field, 0, ""},
+ {"Attr.Value", Field, 0, ""},
+ {"CharData", Type, 0, ""},
+ {"Comment", Type, 0, ""},
+ {"CopyToken", Func, 0, "func(t Token) Token"},
+ {"Decoder", Type, 0, ""},
+ {"Decoder.AutoClose", Field, 0, ""},
+ {"Decoder.CharsetReader", Field, 0, ""},
+ {"Decoder.DefaultSpace", Field, 1, ""},
+ {"Decoder.Entity", Field, 0, ""},
+ {"Decoder.Strict", Field, 0, ""},
+ {"Directive", Type, 0, ""},
+ {"Encoder", Type, 0, ""},
+ {"EndElement", Type, 0, ""},
+ {"EndElement.Name", Field, 0, ""},
+ {"Escape", Func, 0, "func(w io.Writer, s []byte)"},
+ {"EscapeText", Func, 1, "func(w io.Writer, s []byte) error"},
+ {"HTMLAutoClose", Var, 0, ""},
+ {"HTMLEntity", Var, 0, ""},
+ {"Header", Const, 0, ""},
+ {"Marshal", Func, 0, "func(v any) ([]byte, error)"},
+ {"MarshalIndent", Func, 0, "func(v any, prefix string, indent string) ([]byte, error)"},
+ {"Marshaler", Type, 2, ""},
+ {"MarshalerAttr", Type, 2, ""},
+ {"Name", Type, 0, ""},
+ {"Name.Local", Field, 0, ""},
+ {"Name.Space", Field, 0, ""},
+ {"NewDecoder", Func, 0, "func(r io.Reader) *Decoder"},
+ {"NewEncoder", Func, 0, "func(w io.Writer) *Encoder"},
+ {"NewTokenDecoder", Func, 10, "func(t TokenReader) *Decoder"},
+ {"ProcInst", Type, 0, ""},
+ {"ProcInst.Inst", Field, 0, ""},
+ {"ProcInst.Target", Field, 0, ""},
+ {"StartElement", Type, 0, ""},
+ {"StartElement.Attr", Field, 0, ""},
+ {"StartElement.Name", Field, 0, ""},
+ {"SyntaxError", Type, 0, ""},
+ {"SyntaxError.Line", Field, 0, ""},
+ {"SyntaxError.Msg", Field, 0, ""},
+ {"TagPathError", Type, 0, ""},
+ {"TagPathError.Field1", Field, 0, ""},
+ {"TagPathError.Field2", Field, 0, ""},
+ {"TagPathError.Struct", Field, 0, ""},
+ {"TagPathError.Tag1", Field, 0, ""},
+ {"TagPathError.Tag2", Field, 0, ""},
+ {"Token", Type, 0, ""},
+ {"TokenReader", Type, 10, ""},
+ {"Unmarshal", Func, 0, "func(data []byte, v any) error"},
+ {"UnmarshalError", Type, 0, ""},
+ {"Unmarshaler", Type, 2, ""},
+ {"UnmarshalerAttr", Type, 2, ""},
+ {"UnsupportedTypeError", Type, 0, ""},
+ {"UnsupportedTypeError.Type", Field, 0, ""},
+ },
+ "errors": {
+ {"As", Func, 13, "func(err error, target any) bool"},
+ {"ErrUnsupported", Var, 21, ""},
+ {"Is", Func, 13, "func(err error, target error) bool"},
+ {"Join", Func, 20, "func(errs ...error) error"},
+ {"New", Func, 0, "func(text string) error"},
+ {"Unwrap", Func, 13, "func(err error) error"},
+ },
+ "expvar": {
+ {"(*Float).Add", Method, 0, ""},
+ {"(*Float).Set", Method, 0, ""},
+ {"(*Float).String", Method, 0, ""},
+ {"(*Float).Value", Method, 8, ""},
+ {"(*Int).Add", Method, 0, ""},
+ {"(*Int).Set", Method, 0, ""},
+ {"(*Int).String", Method, 0, ""},
+ {"(*Int).Value", Method, 8, ""},
+ {"(*Map).Add", Method, 0, ""},
+ {"(*Map).AddFloat", Method, 0, ""},
+ {"(*Map).Delete", Method, 12, ""},
+ {"(*Map).Do", Method, 0, ""},
+ {"(*Map).Get", Method, 0, ""},
+ {"(*Map).Init", Method, 0, ""},
+ {"(*Map).Set", Method, 0, ""},
+ {"(*Map).String", Method, 0, ""},
+ {"(*String).Set", Method, 0, ""},
+ {"(*String).String", Method, 0, ""},
+ {"(*String).Value", Method, 8, ""},
+ {"(Func).String", Method, 0, ""},
+ {"(Func).Value", Method, 8, ""},
+ {"Do", Func, 0, "func(f func(KeyValue))"},
+ {"Float", Type, 0, ""},
+ {"Func", Type, 0, ""},
+ {"Get", Func, 0, "func(name string) Var"},
+ {"Handler", Func, 8, "func() http.Handler"},
+ {"Int", Type, 0, ""},
+ {"KeyValue", Type, 0, ""},
+ {"KeyValue.Key", Field, 0, ""},
+ {"KeyValue.Value", Field, 0, ""},
+ {"Map", Type, 0, ""},
+ {"NewFloat", Func, 0, "func(name string) *Float"},
+ {"NewInt", Func, 0, "func(name string) *Int"},
+ {"NewMap", Func, 0, "func(name string) *Map"},
+ {"NewString", Func, 0, "func(name string) *String"},
+ {"Publish", Func, 0, "func(name string, v Var)"},
+ {"String", Type, 0, ""},
+ {"Var", Type, 0, ""},
+ },
+ "flag": {
+ {"(*FlagSet).Arg", Method, 0, ""},
+ {"(*FlagSet).Args", Method, 0, ""},
+ {"(*FlagSet).Bool", Method, 0, ""},
+ {"(*FlagSet).BoolFunc", Method, 21, ""},
+ {"(*FlagSet).BoolVar", Method, 0, ""},
+ {"(*FlagSet).Duration", Method, 0, ""},
+ {"(*FlagSet).DurationVar", Method, 0, ""},
+ {"(*FlagSet).ErrorHandling", Method, 10, ""},
+ {"(*FlagSet).Float64", Method, 0, ""},
+ {"(*FlagSet).Float64Var", Method, 0, ""},
+ {"(*FlagSet).Func", Method, 16, ""},
+ {"(*FlagSet).Init", Method, 0, ""},
+ {"(*FlagSet).Int", Method, 0, ""},
+ {"(*FlagSet).Int64", Method, 0, ""},
+ {"(*FlagSet).Int64Var", Method, 0, ""},
+ {"(*FlagSet).IntVar", Method, 0, ""},
+ {"(*FlagSet).Lookup", Method, 0, ""},
+ {"(*FlagSet).NArg", Method, 0, ""},
+ {"(*FlagSet).NFlag", Method, 0, ""},
+ {"(*FlagSet).Name", Method, 10, ""},
+ {"(*FlagSet).Output", Method, 10, ""},
+ {"(*FlagSet).Parse", Method, 0, ""},
+ {"(*FlagSet).Parsed", Method, 0, ""},
+ {"(*FlagSet).PrintDefaults", Method, 0, ""},
+ {"(*FlagSet).Set", Method, 0, ""},
+ {"(*FlagSet).SetOutput", Method, 0, ""},
+ {"(*FlagSet).String", Method, 0, ""},
+ {"(*FlagSet).StringVar", Method, 0, ""},
+ {"(*FlagSet).TextVar", Method, 19, ""},
+ {"(*FlagSet).Uint", Method, 0, ""},
+ {"(*FlagSet).Uint64", Method, 0, ""},
+ {"(*FlagSet).Uint64Var", Method, 0, ""},
+ {"(*FlagSet).UintVar", Method, 0, ""},
+ {"(*FlagSet).Var", Method, 0, ""},
+ {"(*FlagSet).Visit", Method, 0, ""},
+ {"(*FlagSet).VisitAll", Method, 0, ""},
+ {"Arg", Func, 0, "func(i int) string"},
+ {"Args", Func, 0, "func() []string"},
+ {"Bool", Func, 0, "func(name string, value bool, usage string) *bool"},
+ {"BoolFunc", Func, 21, "func(name string, usage string, fn func(string) error)"},
+ {"BoolVar", Func, 0, "func(p *bool, name string, value bool, usage string)"},
+ {"CommandLine", Var, 2, ""},
+ {"ContinueOnError", Const, 0, ""},
+ {"Duration", Func, 0, "func(name string, value time.Duration, usage string) *time.Duration"},
+ {"DurationVar", Func, 0, "func(p *time.Duration, name string, value time.Duration, usage string)"},
+ {"ErrHelp", Var, 0, ""},
+ {"ErrorHandling", Type, 0, ""},
+ {"ExitOnError", Const, 0, ""},
+ {"Flag", Type, 0, ""},
+ {"Flag.DefValue", Field, 0, ""},
+ {"Flag.Name", Field, 0, ""},
+ {"Flag.Usage", Field, 0, ""},
+ {"Flag.Value", Field, 0, ""},
+ {"FlagSet", Type, 0, ""},
+ {"FlagSet.Usage", Field, 0, ""},
+ {"Float64", Func, 0, "func(name string, value float64, usage string) *float64"},
+ {"Float64Var", Func, 0, "func(p *float64, name string, value float64, usage string)"},
+ {"Func", Func, 16, "func(name string, usage string, fn func(string) error)"},
+ {"Getter", Type, 2, ""},
+ {"Int", Func, 0, "func(name string, value int, usage string) *int"},
+ {"Int64", Func, 0, "func(name string, value int64, usage string) *int64"},
+ {"Int64Var", Func, 0, "func(p *int64, name string, value int64, usage string)"},
+ {"IntVar", Func, 0, "func(p *int, name string, value int, usage string)"},
+ {"Lookup", Func, 0, "func(name string) *Flag"},
+ {"NArg", Func, 0, "func() int"},
+ {"NFlag", Func, 0, "func() int"},
+ {"NewFlagSet", Func, 0, "func(name string, errorHandling ErrorHandling) *FlagSet"},
+ {"PanicOnError", Const, 0, ""},
+ {"Parse", Func, 0, "func()"},
+ {"Parsed", Func, 0, "func() bool"},
+ {"PrintDefaults", Func, 0, "func()"},
+ {"Set", Func, 0, "func(name string, value string) error"},
+ {"String", Func, 0, "func(name string, value string, usage string) *string"},
+ {"StringVar", Func, 0, "func(p *string, name string, value string, usage string)"},
+ {"TextVar", Func, 19, "func(p encoding.TextUnmarshaler, name string, value encoding.TextMarshaler, usage string)"},
+ {"Uint", Func, 0, "func(name string, value uint, usage string) *uint"},
+ {"Uint64", Func, 0, "func(name string, value uint64, usage string) *uint64"},
+ {"Uint64Var", Func, 0, "func(p *uint64, name string, value uint64, usage string)"},
+ {"UintVar", Func, 0, "func(p *uint, name string, value uint, usage string)"},
+ {"UnquoteUsage", Func, 5, "func(flag *Flag) (name string, usage string)"},
+ {"Usage", Var, 0, ""},
+ {"Value", Type, 0, ""},
+ {"Var", Func, 0, "func(value Value, name string, usage string)"},
+ {"Visit", Func, 0, "func(fn func(*Flag))"},
+ {"VisitAll", Func, 0, "func(fn func(*Flag))"},
+ },
+ "fmt": {
+ {"Append", Func, 19, "func(b []byte, a ...any) []byte"},
+ {"Appendf", Func, 19, "func(b []byte, format string, a ...any) []byte"},
+ {"Appendln", Func, 19, "func(b []byte, a ...any) []byte"},
+ {"Errorf", Func, 0, "func(format string, a ...any) error"},
+ {"FormatString", Func, 20, "func(state State, verb rune) string"},
+ {"Formatter", Type, 0, ""},
+ {"Fprint", Func, 0, "func(w io.Writer, a ...any) (n int, err error)"},
+ {"Fprintf", Func, 0, "func(w io.Writer, format string, a ...any) (n int, err error)"},
+ {"Fprintln", Func, 0, "func(w io.Writer, a ...any) (n int, err error)"},
+ {"Fscan", Func, 0, "func(r io.Reader, a ...any) (n int, err error)"},
+ {"Fscanf", Func, 0, "func(r io.Reader, format string, a ...any) (n int, err error)"},
+ {"Fscanln", Func, 0, "func(r io.Reader, a ...any) (n int, err error)"},
+ {"GoStringer", Type, 0, ""},
+ {"Print", Func, 0, "func(a ...any) (n int, err error)"},
+ {"Printf", Func, 0, "func(format string, a ...any) (n int, err error)"},
+ {"Println", Func, 0, "func(a ...any) (n int, err error)"},
+ {"Scan", Func, 0, "func(a ...any) (n int, err error)"},
+ {"ScanState", Type, 0, ""},
+ {"Scanf", Func, 0, "func(format string, a ...any) (n int, err error)"},
+ {"Scanln", Func, 0, "func(a ...any) (n int, err error)"},
+ {"Scanner", Type, 0, ""},
+ {"Sprint", Func, 0, "func(a ...any) string"},
+ {"Sprintf", Func, 0, "func(format string, a ...any) string"},
+ {"Sprintln", Func, 0, "func(a ...any) string"},
+ {"Sscan", Func, 0, "func(str string, a ...any) (n int, err error)"},
+ {"Sscanf", Func, 0, "func(str string, format string, a ...any) (n int, err error)"},
+ {"Sscanln", Func, 0, "func(str string, a ...any) (n int, err error)"},
+ {"State", Type, 0, ""},
+ {"Stringer", Type, 0, ""},
+ },
+ "go/ast": {
+ {"(*ArrayType).End", Method, 0, ""},
+ {"(*ArrayType).Pos", Method, 0, ""},
+ {"(*AssignStmt).End", Method, 0, ""},
+ {"(*AssignStmt).Pos", Method, 0, ""},
+ {"(*BadDecl).End", Method, 0, ""},
+ {"(*BadDecl).Pos", Method, 0, ""},
+ {"(*BadExpr).End", Method, 0, ""},
+ {"(*BadExpr).Pos", Method, 0, ""},
+ {"(*BadStmt).End", Method, 0, ""},
+ {"(*BadStmt).Pos", Method, 0, ""},
+ {"(*BasicLit).End", Method, 0, ""},
+ {"(*BasicLit).Pos", Method, 0, ""},
+ {"(*BinaryExpr).End", Method, 0, ""},
+ {"(*BinaryExpr).Pos", Method, 0, ""},
+ {"(*BlockStmt).End", Method, 0, ""},
+ {"(*BlockStmt).Pos", Method, 0, ""},
+ {"(*BranchStmt).End", Method, 0, ""},
+ {"(*BranchStmt).Pos", Method, 0, ""},
+ {"(*CallExpr).End", Method, 0, ""},
+ {"(*CallExpr).Pos", Method, 0, ""},
+ {"(*CaseClause).End", Method, 0, ""},
+ {"(*CaseClause).Pos", Method, 0, ""},
+ {"(*ChanType).End", Method, 0, ""},
+ {"(*ChanType).Pos", Method, 0, ""},
+ {"(*CommClause).End", Method, 0, ""},
+ {"(*CommClause).Pos", Method, 0, ""},
+ {"(*Comment).End", Method, 0, ""},
+ {"(*Comment).Pos", Method, 0, ""},
+ {"(*CommentGroup).End", Method, 0, ""},
+ {"(*CommentGroup).Pos", Method, 0, ""},
+ {"(*CommentGroup).Text", Method, 0, ""},
+ {"(*CompositeLit).End", Method, 0, ""},
+ {"(*CompositeLit).Pos", Method, 0, ""},
+ {"(*DeclStmt).End", Method, 0, ""},
+ {"(*DeclStmt).Pos", Method, 0, ""},
+ {"(*DeferStmt).End", Method, 0, ""},
+ {"(*DeferStmt).Pos", Method, 0, ""},
+ {"(*Ellipsis).End", Method, 0, ""},
+ {"(*Ellipsis).Pos", Method, 0, ""},
+ {"(*EmptyStmt).End", Method, 0, ""},
+ {"(*EmptyStmt).Pos", Method, 0, ""},
+ {"(*ExprStmt).End", Method, 0, ""},
+ {"(*ExprStmt).Pos", Method, 0, ""},
+ {"(*Field).End", Method, 0, ""},
+ {"(*Field).Pos", Method, 0, ""},
+ {"(*FieldList).End", Method, 0, ""},
+ {"(*FieldList).NumFields", Method, 0, ""},
+ {"(*FieldList).Pos", Method, 0, ""},
+ {"(*File).End", Method, 0, ""},
+ {"(*File).Pos", Method, 0, ""},
+ {"(*ForStmt).End", Method, 0, ""},
+ {"(*ForStmt).Pos", Method, 0, ""},
+ {"(*FuncDecl).End", Method, 0, ""},
+ {"(*FuncDecl).Pos", Method, 0, ""},
+ {"(*FuncLit).End", Method, 0, ""},
+ {"(*FuncLit).Pos", Method, 0, ""},
+ {"(*FuncType).End", Method, 0, ""},
+ {"(*FuncType).Pos", Method, 0, ""},
+ {"(*GenDecl).End", Method, 0, ""},
+ {"(*GenDecl).Pos", Method, 0, ""},
+ {"(*GoStmt).End", Method, 0, ""},
+ {"(*GoStmt).Pos", Method, 0, ""},
+ {"(*Ident).End", Method, 0, ""},
+ {"(*Ident).IsExported", Method, 0, ""},
+ {"(*Ident).Pos", Method, 0, ""},
+ {"(*Ident).String", Method, 0, ""},
+ {"(*IfStmt).End", Method, 0, ""},
+ {"(*IfStmt).Pos", Method, 0, ""},
+ {"(*ImportSpec).End", Method, 0, ""},
+ {"(*ImportSpec).Pos", Method, 0, ""},
+ {"(*IncDecStmt).End", Method, 0, ""},
+ {"(*IncDecStmt).Pos", Method, 0, ""},
+ {"(*IndexExpr).End", Method, 0, ""},
+ {"(*IndexExpr).Pos", Method, 0, ""},
+ {"(*IndexListExpr).End", Method, 18, ""},
+ {"(*IndexListExpr).Pos", Method, 18, ""},
+ {"(*InterfaceType).End", Method, 0, ""},
+ {"(*InterfaceType).Pos", Method, 0, ""},
+ {"(*KeyValueExpr).End", Method, 0, ""},
+ {"(*KeyValueExpr).Pos", Method, 0, ""},
+ {"(*LabeledStmt).End", Method, 0, ""},
+ {"(*LabeledStmt).Pos", Method, 0, ""},
+ {"(*MapType).End", Method, 0, ""},
+ {"(*MapType).Pos", Method, 0, ""},
+ {"(*Object).Pos", Method, 0, ""},
+ {"(*Package).End", Method, 0, ""},
+ {"(*Package).Pos", Method, 0, ""},
+ {"(*ParenExpr).End", Method, 0, ""},
+ {"(*ParenExpr).Pos", Method, 0, ""},
+ {"(*RangeStmt).End", Method, 0, ""},
+ {"(*RangeStmt).Pos", Method, 0, ""},
+ {"(*ReturnStmt).End", Method, 0, ""},
+ {"(*ReturnStmt).Pos", Method, 0, ""},
+ {"(*Scope).Insert", Method, 0, ""},
+ {"(*Scope).Lookup", Method, 0, ""},
+ {"(*Scope).String", Method, 0, ""},
+ {"(*SelectStmt).End", Method, 0, ""},
+ {"(*SelectStmt).Pos", Method, 0, ""},
+ {"(*SelectorExpr).End", Method, 0, ""},
+ {"(*SelectorExpr).Pos", Method, 0, ""},
+ {"(*SendStmt).End", Method, 0, ""},
+ {"(*SendStmt).Pos", Method, 0, ""},
+ {"(*SliceExpr).End", Method, 0, ""},
+ {"(*SliceExpr).Pos", Method, 0, ""},
+ {"(*StarExpr).End", Method, 0, ""},
+ {"(*StarExpr).Pos", Method, 0, ""},
+ {"(*StructType).End", Method, 0, ""},
+ {"(*StructType).Pos", Method, 0, ""},
+ {"(*SwitchStmt).End", Method, 0, ""},
+ {"(*SwitchStmt).Pos", Method, 0, ""},
+ {"(*TypeAssertExpr).End", Method, 0, ""},
+ {"(*TypeAssertExpr).Pos", Method, 0, ""},
+ {"(*TypeSpec).End", Method, 0, ""},
+ {"(*TypeSpec).Pos", Method, 0, ""},
+ {"(*TypeSwitchStmt).End", Method, 0, ""},
+ {"(*TypeSwitchStmt).Pos", Method, 0, ""},
+ {"(*UnaryExpr).End", Method, 0, ""},
+ {"(*UnaryExpr).Pos", Method, 0, ""},
+ {"(*ValueSpec).End", Method, 0, ""},
+ {"(*ValueSpec).Pos", Method, 0, ""},
+ {"(CommentMap).Comments", Method, 1, ""},
+ {"(CommentMap).Filter", Method, 1, ""},
+ {"(CommentMap).String", Method, 1, ""},
+ {"(CommentMap).Update", Method, 1, ""},
+ {"(ObjKind).String", Method, 0, ""},
+ {"ArrayType", Type, 0, ""},
+ {"ArrayType.Elt", Field, 0, ""},
+ {"ArrayType.Lbrack", Field, 0, ""},
+ {"ArrayType.Len", Field, 0, ""},
+ {"AssignStmt", Type, 0, ""},
+ {"AssignStmt.Lhs", Field, 0, ""},
+ {"AssignStmt.Rhs", Field, 0, ""},
+ {"AssignStmt.Tok", Field, 0, ""},
+ {"AssignStmt.TokPos", Field, 0, ""},
+ {"Bad", Const, 0, ""},
+ {"BadDecl", Type, 0, ""},
+ {"BadDecl.From", Field, 0, ""},
+ {"BadDecl.To", Field, 0, ""},
+ {"BadExpr", Type, 0, ""},
+ {"BadExpr.From", Field, 0, ""},
+ {"BadExpr.To", Field, 0, ""},
+ {"BadStmt", Type, 0, ""},
+ {"BadStmt.From", Field, 0, ""},
+ {"BadStmt.To", Field, 0, ""},
+ {"BasicLit", Type, 0, ""},
+ {"BasicLit.Kind", Field, 0, ""},
+ {"BasicLit.Value", Field, 0, ""},
+ {"BasicLit.ValuePos", Field, 0, ""},
+ {"BinaryExpr", Type, 0, ""},
+ {"BinaryExpr.Op", Field, 0, ""},
+ {"BinaryExpr.OpPos", Field, 0, ""},
+ {"BinaryExpr.X", Field, 0, ""},
+ {"BinaryExpr.Y", Field, 0, ""},
+ {"BlockStmt", Type, 0, ""},
+ {"BlockStmt.Lbrace", Field, 0, ""},
+ {"BlockStmt.List", Field, 0, ""},
+ {"BlockStmt.Rbrace", Field, 0, ""},
+ {"BranchStmt", Type, 0, ""},
+ {"BranchStmt.Label", Field, 0, ""},
+ {"BranchStmt.Tok", Field, 0, ""},
+ {"BranchStmt.TokPos", Field, 0, ""},
+ {"CallExpr", Type, 0, ""},
+ {"CallExpr.Args", Field, 0, ""},
+ {"CallExpr.Ellipsis", Field, 0, ""},
+ {"CallExpr.Fun", Field, 0, ""},
+ {"CallExpr.Lparen", Field, 0, ""},
+ {"CallExpr.Rparen", Field, 0, ""},
+ {"CaseClause", Type, 0, ""},
+ {"CaseClause.Body", Field, 0, ""},
+ {"CaseClause.Case", Field, 0, ""},
+ {"CaseClause.Colon", Field, 0, ""},
+ {"CaseClause.List", Field, 0, ""},
+ {"ChanDir", Type, 0, ""},
+ {"ChanType", Type, 0, ""},
+ {"ChanType.Arrow", Field, 1, ""},
+ {"ChanType.Begin", Field, 0, ""},
+ {"ChanType.Dir", Field, 0, ""},
+ {"ChanType.Value", Field, 0, ""},
+ {"CommClause", Type, 0, ""},
+ {"CommClause.Body", Field, 0, ""},
+ {"CommClause.Case", Field, 0, ""},
+ {"CommClause.Colon", Field, 0, ""},
+ {"CommClause.Comm", Field, 0, ""},
+ {"Comment", Type, 0, ""},
+ {"Comment.Slash", Field, 0, ""},
+ {"Comment.Text", Field, 0, ""},
+ {"CommentGroup", Type, 0, ""},
+ {"CommentGroup.List", Field, 0, ""},
+ {"CommentMap", Type, 1, ""},
+ {"CompositeLit", Type, 0, ""},
+ {"CompositeLit.Elts", Field, 0, ""},
+ {"CompositeLit.Incomplete", Field, 11, ""},
+ {"CompositeLit.Lbrace", Field, 0, ""},
+ {"CompositeLit.Rbrace", Field, 0, ""},
+ {"CompositeLit.Type", Field, 0, ""},
+ {"Con", Const, 0, ""},
+ {"Decl", Type, 0, ""},
+ {"DeclStmt", Type, 0, ""},
+ {"DeclStmt.Decl", Field, 0, ""},
+ {"DeferStmt", Type, 0, ""},
+ {"DeferStmt.Call", Field, 0, ""},
+ {"DeferStmt.Defer", Field, 0, ""},
+ {"Ellipsis", Type, 0, ""},
+ {"Ellipsis.Ellipsis", Field, 0, ""},
+ {"Ellipsis.Elt", Field, 0, ""},
+ {"EmptyStmt", Type, 0, ""},
+ {"EmptyStmt.Implicit", Field, 5, ""},
+ {"EmptyStmt.Semicolon", Field, 0, ""},
+ {"Expr", Type, 0, ""},
+ {"ExprStmt", Type, 0, ""},
+ {"ExprStmt.X", Field, 0, ""},
+ {"Field", Type, 0, ""},
+ {"Field.Comment", Field, 0, ""},
+ {"Field.Doc", Field, 0, ""},
+ {"Field.Names", Field, 0, ""},
+ {"Field.Tag", Field, 0, ""},
+ {"Field.Type", Field, 0, ""},
+ {"FieldFilter", Type, 0, ""},
+ {"FieldList", Type, 0, ""},
+ {"FieldList.Closing", Field, 0, ""},
+ {"FieldList.List", Field, 0, ""},
+ {"FieldList.Opening", Field, 0, ""},
+ {"File", Type, 0, ""},
+ {"File.Comments", Field, 0, ""},
+ {"File.Decls", Field, 0, ""},
+ {"File.Doc", Field, 0, ""},
+ {"File.FileEnd", Field, 20, ""},
+ {"File.FileStart", Field, 20, ""},
+ {"File.GoVersion", Field, 21, ""},
+ {"File.Imports", Field, 0, ""},
+ {"File.Name", Field, 0, ""},
+ {"File.Package", Field, 0, ""},
+ {"File.Scope", Field, 0, ""},
+ {"File.Unresolved", Field, 0, ""},
+ {"FileExports", Func, 0, "func(src *File) bool"},
+ {"Filter", Type, 0, ""},
+ {"FilterDecl", Func, 0, "func(decl Decl, f Filter) bool"},
+ {"FilterFile", Func, 0, "func(src *File, f Filter) bool"},
+ {"FilterFuncDuplicates", Const, 0, ""},
+ {"FilterImportDuplicates", Const, 0, ""},
+ {"FilterPackage", Func, 0, "func(pkg *Package, f Filter) bool"},
+ {"FilterUnassociatedComments", Const, 0, ""},
+ {"ForStmt", Type, 0, ""},
+ {"ForStmt.Body", Field, 0, ""},
+ {"ForStmt.Cond", Field, 0, ""},
+ {"ForStmt.For", Field, 0, ""},
+ {"ForStmt.Init", Field, 0, ""},
+ {"ForStmt.Post", Field, 0, ""},
+ {"Fprint", Func, 0, "func(w io.Writer, fset *token.FileSet, x any, f FieldFilter) error"},
+ {"Fun", Const, 0, ""},
+ {"FuncDecl", Type, 0, ""},
+ {"FuncDecl.Body", Field, 0, ""},
+ {"FuncDecl.Doc", Field, 0, ""},
+ {"FuncDecl.Name", Field, 0, ""},
+ {"FuncDecl.Recv", Field, 0, ""},
+ {"FuncDecl.Type", Field, 0, ""},
+ {"FuncLit", Type, 0, ""},
+ {"FuncLit.Body", Field, 0, ""},
+ {"FuncLit.Type", Field, 0, ""},
+ {"FuncType", Type, 0, ""},
+ {"FuncType.Func", Field, 0, ""},
+ {"FuncType.Params", Field, 0, ""},
+ {"FuncType.Results", Field, 0, ""},
+ {"FuncType.TypeParams", Field, 18, ""},
+ {"GenDecl", Type, 0, ""},
+ {"GenDecl.Doc", Field, 0, ""},
+ {"GenDecl.Lparen", Field, 0, ""},
+ {"GenDecl.Rparen", Field, 0, ""},
+ {"GenDecl.Specs", Field, 0, ""},
+ {"GenDecl.Tok", Field, 0, ""},
+ {"GenDecl.TokPos", Field, 0, ""},
+ {"GoStmt", Type, 0, ""},
+ {"GoStmt.Call", Field, 0, ""},
+ {"GoStmt.Go", Field, 0, ""},
+ {"Ident", Type, 0, ""},
+ {"Ident.Name", Field, 0, ""},
+ {"Ident.NamePos", Field, 0, ""},
+ {"Ident.Obj", Field, 0, ""},
+ {"IfStmt", Type, 0, ""},
+ {"IfStmt.Body", Field, 0, ""},
+ {"IfStmt.Cond", Field, 0, ""},
+ {"IfStmt.Else", Field, 0, ""},
+ {"IfStmt.If", Field, 0, ""},
+ {"IfStmt.Init", Field, 0, ""},
+ {"ImportSpec", Type, 0, ""},
+ {"ImportSpec.Comment", Field, 0, ""},
+ {"ImportSpec.Doc", Field, 0, ""},
+ {"ImportSpec.EndPos", Field, 0, ""},
+ {"ImportSpec.Name", Field, 0, ""},
+ {"ImportSpec.Path", Field, 0, ""},
+ {"Importer", Type, 0, ""},
+ {"IncDecStmt", Type, 0, ""},
+ {"IncDecStmt.Tok", Field, 0, ""},
+ {"IncDecStmt.TokPos", Field, 0, ""},
+ {"IncDecStmt.X", Field, 0, ""},
+ {"IndexExpr", Type, 0, ""},
+ {"IndexExpr.Index", Field, 0, ""},
+ {"IndexExpr.Lbrack", Field, 0, ""},
+ {"IndexExpr.Rbrack", Field, 0, ""},
+ {"IndexExpr.X", Field, 0, ""},
+ {"IndexListExpr", Type, 18, ""},
+ {"IndexListExpr.Indices", Field, 18, ""},
+ {"IndexListExpr.Lbrack", Field, 18, ""},
+ {"IndexListExpr.Rbrack", Field, 18, ""},
+ {"IndexListExpr.X", Field, 18, ""},
+ {"Inspect", Func, 0, "func(node Node, f func(Node) bool)"},
+ {"InterfaceType", Type, 0, ""},
+ {"InterfaceType.Incomplete", Field, 0, ""},
+ {"InterfaceType.Interface", Field, 0, ""},
+ {"InterfaceType.Methods", Field, 0, ""},
+ {"IsExported", Func, 0, "func(name string) bool"},
+ {"IsGenerated", Func, 21, "func(file *File) bool"},
+ {"KeyValueExpr", Type, 0, ""},
+ {"KeyValueExpr.Colon", Field, 0, ""},
+ {"KeyValueExpr.Key", Field, 0, ""},
+ {"KeyValueExpr.Value", Field, 0, ""},
+ {"LabeledStmt", Type, 0, ""},
+ {"LabeledStmt.Colon", Field, 0, ""},
+ {"LabeledStmt.Label", Field, 0, ""},
+ {"LabeledStmt.Stmt", Field, 0, ""},
+ {"Lbl", Const, 0, ""},
+ {"MapType", Type, 0, ""},
+ {"MapType.Key", Field, 0, ""},
+ {"MapType.Map", Field, 0, ""},
+ {"MapType.Value", Field, 0, ""},
+ {"MergeMode", Type, 0, ""},
+ {"MergePackageFiles", Func, 0, "func(pkg *Package, mode MergeMode) *File"},
+ {"NewCommentMap", Func, 1, "func(fset *token.FileSet, node Node, comments []*CommentGroup) CommentMap"},
+ {"NewIdent", Func, 0, "func(name string) *Ident"},
+ {"NewObj", Func, 0, "func(kind ObjKind, name string) *Object"},
+ {"NewPackage", Func, 0, "func(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error)"},
+ {"NewScope", Func, 0, "func(outer *Scope) *Scope"},
+ {"Node", Type, 0, ""},
+ {"NotNilFilter", Func, 0, "func(_ string, v reflect.Value) bool"},
+ {"ObjKind", Type, 0, ""},
+ {"Object", Type, 0, ""},
+ {"Object.Data", Field, 0, ""},
+ {"Object.Decl", Field, 0, ""},
+ {"Object.Kind", Field, 0, ""},
+ {"Object.Name", Field, 0, ""},
+ {"Object.Type", Field, 0, ""},
+ {"Package", Type, 0, ""},
+ {"Package.Files", Field, 0, ""},
+ {"Package.Imports", Field, 0, ""},
+ {"Package.Name", Field, 0, ""},
+ {"Package.Scope", Field, 0, ""},
+ {"PackageExports", Func, 0, "func(pkg *Package) bool"},
+ {"ParenExpr", Type, 0, ""},
+ {"ParenExpr.Lparen", Field, 0, ""},
+ {"ParenExpr.Rparen", Field, 0, ""},
+ {"ParenExpr.X", Field, 0, ""},
+ {"Pkg", Const, 0, ""},
+ {"Preorder", Func, 23, "func(root Node) iter.Seq[Node]"},
+ {"Print", Func, 0, "func(fset *token.FileSet, x any) error"},
+ {"RECV", Const, 0, ""},
+ {"RangeStmt", Type, 0, ""},
+ {"RangeStmt.Body", Field, 0, ""},
+ {"RangeStmt.For", Field, 0, ""},
+ {"RangeStmt.Key", Field, 0, ""},
+ {"RangeStmt.Range", Field, 20, ""},
+ {"RangeStmt.Tok", Field, 0, ""},
+ {"RangeStmt.TokPos", Field, 0, ""},
+ {"RangeStmt.Value", Field, 0, ""},
+ {"RangeStmt.X", Field, 0, ""},
+ {"ReturnStmt", Type, 0, ""},
+ {"ReturnStmt.Results", Field, 0, ""},
+ {"ReturnStmt.Return", Field, 0, ""},
+ {"SEND", Const, 0, ""},
+ {"Scope", Type, 0, ""},
+ {"Scope.Objects", Field, 0, ""},
+ {"Scope.Outer", Field, 0, ""},
+ {"SelectStmt", Type, 0, ""},
+ {"SelectStmt.Body", Field, 0, ""},
+ {"SelectStmt.Select", Field, 0, ""},
+ {"SelectorExpr", Type, 0, ""},
+ {"SelectorExpr.Sel", Field, 0, ""},
+ {"SelectorExpr.X", Field, 0, ""},
+ {"SendStmt", Type, 0, ""},
+ {"SendStmt.Arrow", Field, 0, ""},
+ {"SendStmt.Chan", Field, 0, ""},
+ {"SendStmt.Value", Field, 0, ""},
+ {"SliceExpr", Type, 0, ""},
+ {"SliceExpr.High", Field, 0, ""},
+ {"SliceExpr.Lbrack", Field, 0, ""},
+ {"SliceExpr.Low", Field, 0, ""},
+ {"SliceExpr.Max", Field, 2, ""},
+ {"SliceExpr.Rbrack", Field, 0, ""},
+ {"SliceExpr.Slice3", Field, 2, ""},
+ {"SliceExpr.X", Field, 0, ""},
+ {"SortImports", Func, 0, "func(fset *token.FileSet, f *File)"},
+ {"Spec", Type, 0, ""},
+ {"StarExpr", Type, 0, ""},
+ {"StarExpr.Star", Field, 0, ""},
+ {"StarExpr.X", Field, 0, ""},
+ {"Stmt", Type, 0, ""},
+ {"StructType", Type, 0, ""},
+ {"StructType.Fields", Field, 0, ""},
+ {"StructType.Incomplete", Field, 0, ""},
+ {"StructType.Struct", Field, 0, ""},
+ {"SwitchStmt", Type, 0, ""},
+ {"SwitchStmt.Body", Field, 0, ""},
+ {"SwitchStmt.Init", Field, 0, ""},
+ {"SwitchStmt.Switch", Field, 0, ""},
+ {"SwitchStmt.Tag", Field, 0, ""},
+ {"Typ", Const, 0, ""},
+ {"TypeAssertExpr", Type, 0, ""},
+ {"TypeAssertExpr.Lparen", Field, 2, ""},
+ {"TypeAssertExpr.Rparen", Field, 2, ""},
+ {"TypeAssertExpr.Type", Field, 0, ""},
+ {"TypeAssertExpr.X", Field, 0, ""},
+ {"TypeSpec", Type, 0, ""},
+ {"TypeSpec.Assign", Field, 9, ""},
+ {"TypeSpec.Comment", Field, 0, ""},
+ {"TypeSpec.Doc", Field, 0, ""},
+ {"TypeSpec.Name", Field, 0, ""},
+ {"TypeSpec.Type", Field, 0, ""},
+ {"TypeSpec.TypeParams", Field, 18, ""},
+ {"TypeSwitchStmt", Type, 0, ""},
+ {"TypeSwitchStmt.Assign", Field, 0, ""},
+ {"TypeSwitchStmt.Body", Field, 0, ""},
+ {"TypeSwitchStmt.Init", Field, 0, ""},
+ {"TypeSwitchStmt.Switch", Field, 0, ""},
+ {"UnaryExpr", Type, 0, ""},
+ {"UnaryExpr.Op", Field, 0, ""},
+ {"UnaryExpr.OpPos", Field, 0, ""},
+ {"UnaryExpr.X", Field, 0, ""},
+ {"Unparen", Func, 22, "func(e Expr) Expr"},
+ {"ValueSpec", Type, 0, ""},
+ {"ValueSpec.Comment", Field, 0, ""},
+ {"ValueSpec.Doc", Field, 0, ""},
+ {"ValueSpec.Names", Field, 0, ""},
+ {"ValueSpec.Type", Field, 0, ""},
+ {"ValueSpec.Values", Field, 0, ""},
+ {"Var", Const, 0, ""},
+ {"Visitor", Type, 0, ""},
+ {"Walk", Func, 0, "func(v Visitor, node Node)"},
+ },
+ "go/build": {
+ {"(*Context).Import", Method, 0, ""},
+ {"(*Context).ImportDir", Method, 0, ""},
+ {"(*Context).MatchFile", Method, 2, ""},
+ {"(*Context).SrcDirs", Method, 0, ""},
+ {"(*MultiplePackageError).Error", Method, 4, ""},
+ {"(*NoGoError).Error", Method, 0, ""},
+ {"(*Package).IsCommand", Method, 0, ""},
+ {"AllowBinary", Const, 0, ""},
+ {"ArchChar", Func, 0, "func(goarch string) (string, error)"},
+ {"Context", Type, 0, ""},
+ {"Context.BuildTags", Field, 0, ""},
+ {"Context.CgoEnabled", Field, 0, ""},
+ {"Context.Compiler", Field, 0, ""},
+ {"Context.Dir", Field, 14, ""},
+ {"Context.GOARCH", Field, 0, ""},
+ {"Context.GOOS", Field, 0, ""},
+ {"Context.GOPATH", Field, 0, ""},
+ {"Context.GOROOT", Field, 0, ""},
+ {"Context.HasSubdir", Field, 0, ""},
+ {"Context.InstallSuffix", Field, 1, ""},
+ {"Context.IsAbsPath", Field, 0, ""},
+ {"Context.IsDir", Field, 0, ""},
+ {"Context.JoinPath", Field, 0, ""},
+ {"Context.OpenFile", Field, 0, ""},
+ {"Context.ReadDir", Field, 0, ""},
+ {"Context.ReleaseTags", Field, 1, ""},
+ {"Context.SplitPathList", Field, 0, ""},
+ {"Context.ToolTags", Field, 17, ""},
+ {"Context.UseAllFiles", Field, 0, ""},
+ {"Default", Var, 0, ""},
+ {"Directive", Type, 21, ""},
+ {"Directive.Pos", Field, 21, ""},
+ {"Directive.Text", Field, 21, ""},
+ {"FindOnly", Const, 0, ""},
+ {"IgnoreVendor", Const, 6, ""},
+ {"Import", Func, 0, "func(path string, srcDir string, mode ImportMode) (*Package, error)"},
+ {"ImportComment", Const, 4, ""},
+ {"ImportDir", Func, 0, "func(dir string, mode ImportMode) (*Package, error)"},
+ {"ImportMode", Type, 0, ""},
+ {"IsLocalImport", Func, 0, "func(path string) bool"},
+ {"MultiplePackageError", Type, 4, ""},
+ {"MultiplePackageError.Dir", Field, 4, ""},
+ {"MultiplePackageError.Files", Field, 4, ""},
+ {"MultiplePackageError.Packages", Field, 4, ""},
+ {"NoGoError", Type, 0, ""},
+ {"NoGoError.Dir", Field, 0, ""},
+ {"Package", Type, 0, ""},
+ {"Package.AllTags", Field, 2, ""},
+ {"Package.BinDir", Field, 0, ""},
+ {"Package.BinaryOnly", Field, 7, ""},
+ {"Package.CFiles", Field, 0, ""},
+ {"Package.CXXFiles", Field, 2, ""},
+ {"Package.CgoCFLAGS", Field, 0, ""},
+ {"Package.CgoCPPFLAGS", Field, 2, ""},
+ {"Package.CgoCXXFLAGS", Field, 2, ""},
+ {"Package.CgoFFLAGS", Field, 7, ""},
+ {"Package.CgoFiles", Field, 0, ""},
+ {"Package.CgoLDFLAGS", Field, 0, ""},
+ {"Package.CgoPkgConfig", Field, 0, ""},
+ {"Package.ConflictDir", Field, 2, ""},
+ {"Package.Dir", Field, 0, ""},
+ {"Package.Directives", Field, 21, ""},
+ {"Package.Doc", Field, 0, ""},
+ {"Package.EmbedPatternPos", Field, 16, ""},
+ {"Package.EmbedPatterns", Field, 16, ""},
+ {"Package.FFiles", Field, 7, ""},
+ {"Package.GoFiles", Field, 0, ""},
+ {"Package.Goroot", Field, 0, ""},
+ {"Package.HFiles", Field, 0, ""},
+ {"Package.IgnoredGoFiles", Field, 1, ""},
+ {"Package.IgnoredOtherFiles", Field, 16, ""},
+ {"Package.ImportComment", Field, 4, ""},
+ {"Package.ImportPath", Field, 0, ""},
+ {"Package.ImportPos", Field, 0, ""},
+ {"Package.Imports", Field, 0, ""},
+ {"Package.InvalidGoFiles", Field, 6, ""},
+ {"Package.MFiles", Field, 3, ""},
+ {"Package.Name", Field, 0, ""},
+ {"Package.PkgObj", Field, 0, ""},
+ {"Package.PkgRoot", Field, 0, ""},
+ {"Package.PkgTargetRoot", Field, 5, ""},
+ {"Package.Root", Field, 0, ""},
+ {"Package.SFiles", Field, 0, ""},
+ {"Package.SrcRoot", Field, 0, ""},
+ {"Package.SwigCXXFiles", Field, 1, ""},
+ {"Package.SwigFiles", Field, 1, ""},
+ {"Package.SysoFiles", Field, 0, ""},
+ {"Package.TestDirectives", Field, 21, ""},
+ {"Package.TestEmbedPatternPos", Field, 16, ""},
+ {"Package.TestEmbedPatterns", Field, 16, ""},
+ {"Package.TestGoFiles", Field, 0, ""},
+ {"Package.TestImportPos", Field, 0, ""},
+ {"Package.TestImports", Field, 0, ""},
+ {"Package.XTestDirectives", Field, 21, ""},
+ {"Package.XTestEmbedPatternPos", Field, 16, ""},
+ {"Package.XTestEmbedPatterns", Field, 16, ""},
+ {"Package.XTestGoFiles", Field, 0, ""},
+ {"Package.XTestImportPos", Field, 0, ""},
+ {"Package.XTestImports", Field, 0, ""},
+ {"ToolDir", Var, 0, ""},
+ },
+ "go/build/constraint": {
+ {"(*AndExpr).Eval", Method, 16, ""},
+ {"(*AndExpr).String", Method, 16, ""},
+ {"(*NotExpr).Eval", Method, 16, ""},
+ {"(*NotExpr).String", Method, 16, ""},
+ {"(*OrExpr).Eval", Method, 16, ""},
+ {"(*OrExpr).String", Method, 16, ""},
+ {"(*SyntaxError).Error", Method, 16, ""},
+ {"(*TagExpr).Eval", Method, 16, ""},
+ {"(*TagExpr).String", Method, 16, ""},
+ {"AndExpr", Type, 16, ""},
+ {"AndExpr.X", Field, 16, ""},
+ {"AndExpr.Y", Field, 16, ""},
+ {"Expr", Type, 16, ""},
+ {"GoVersion", Func, 21, "func(x Expr) string"},
+ {"IsGoBuild", Func, 16, "func(line string) bool"},
+ {"IsPlusBuild", Func, 16, "func(line string) bool"},
+ {"NotExpr", Type, 16, ""},
+ {"NotExpr.X", Field, 16, ""},
+ {"OrExpr", Type, 16, ""},
+ {"OrExpr.X", Field, 16, ""},
+ {"OrExpr.Y", Field, 16, ""},
+ {"Parse", Func, 16, "func(line string) (Expr, error)"},
+ {"PlusBuildLines", Func, 16, "func(x Expr) ([]string, error)"},
+ {"SyntaxError", Type, 16, ""},
+ {"SyntaxError.Err", Field, 16, ""},
+ {"SyntaxError.Offset", Field, 16, ""},
+ {"TagExpr", Type, 16, ""},
+ {"TagExpr.Tag", Field, 16, ""},
+ },
+ "go/constant": {
+ {"(Kind).String", Method, 18, ""},
+ {"BinaryOp", Func, 5, "func(x_ Value, op token.Token, y_ Value) Value"},
+ {"BitLen", Func, 5, "func(x Value) int"},
+ {"Bool", Const, 5, ""},
+ {"BoolVal", Func, 5, "func(x Value) bool"},
+ {"Bytes", Func, 5, "func(x Value) []byte"},
+ {"Compare", Func, 5, "func(x_ Value, op token.Token, y_ Value) bool"},
+ {"Complex", Const, 5, ""},
+ {"Denom", Func, 5, "func(x Value) Value"},
+ {"Float", Const, 5, ""},
+ {"Float32Val", Func, 5, "func(x Value) (float32, bool)"},
+ {"Float64Val", Func, 5, "func(x Value) (float64, bool)"},
+ {"Imag", Func, 5, "func(x Value) Value"},
+ {"Int", Const, 5, ""},
+ {"Int64Val", Func, 5, "func(x Value) (int64, bool)"},
+ {"Kind", Type, 5, ""},
+ {"Make", Func, 13, "func(x any) Value"},
+ {"MakeBool", Func, 5, "func(b bool) Value"},
+ {"MakeFloat64", Func, 5, "func(x float64) Value"},
+ {"MakeFromBytes", Func, 5, "func(bytes []byte) Value"},
+ {"MakeFromLiteral", Func, 5, "func(lit string, tok token.Token, zero uint) Value"},
+ {"MakeImag", Func, 5, "func(x Value) Value"},
+ {"MakeInt64", Func, 5, "func(x int64) Value"},
+ {"MakeString", Func, 5, "func(s string) Value"},
+ {"MakeUint64", Func, 5, "func(x uint64) Value"},
+ {"MakeUnknown", Func, 5, "func() Value"},
+ {"Num", Func, 5, "func(x Value) Value"},
+ {"Real", Func, 5, "func(x Value) Value"},
+ {"Shift", Func, 5, "func(x Value, op token.Token, s uint) Value"},
+ {"Sign", Func, 5, "func(x Value) int"},
+ {"String", Const, 5, ""},
+ {"StringVal", Func, 5, "func(x Value) string"},
+ {"ToComplex", Func, 6, "func(x Value) Value"},
+ {"ToFloat", Func, 6, "func(x Value) Value"},
+ {"ToInt", Func, 6, "func(x Value) Value"},
+ {"Uint64Val", Func, 5, "func(x Value) (uint64, bool)"},
+ {"UnaryOp", Func, 5, "func(op token.Token, y Value, prec uint) Value"},
+ {"Unknown", Const, 5, ""},
+ {"Val", Func, 13, "func(x Value) any"},
+ {"Value", Type, 5, ""},
+ },
+ "go/doc": {
+ {"(*Package).Filter", Method, 0, ""},
+ {"(*Package).HTML", Method, 19, ""},
+ {"(*Package).Markdown", Method, 19, ""},
+ {"(*Package).Parser", Method, 19, ""},
+ {"(*Package).Printer", Method, 19, ""},
+ {"(*Package).Synopsis", Method, 19, ""},
+ {"(*Package).Text", Method, 19, ""},
+ {"AllDecls", Const, 0, ""},
+ {"AllMethods", Const, 0, ""},
+ {"Example", Type, 0, ""},
+ {"Example.Code", Field, 0, ""},
+ {"Example.Comments", Field, 0, ""},
+ {"Example.Doc", Field, 0, ""},
+ {"Example.EmptyOutput", Field, 1, ""},
+ {"Example.Name", Field, 0, ""},
+ {"Example.Order", Field, 1, ""},
+ {"Example.Output", Field, 0, ""},
+ {"Example.Play", Field, 1, ""},
+ {"Example.Suffix", Field, 14, ""},
+ {"Example.Unordered", Field, 7, ""},
+ {"Examples", Func, 0, "func(testFiles ...*ast.File) []*Example"},
+ {"Filter", Type, 0, ""},
+ {"Func", Type, 0, ""},
+ {"Func.Decl", Field, 0, ""},
+ {"Func.Doc", Field, 0, ""},
+ {"Func.Examples", Field, 14, ""},
+ {"Func.Level", Field, 0, ""},
+ {"Func.Name", Field, 0, ""},
+ {"Func.Orig", Field, 0, ""},
+ {"Func.Recv", Field, 0, ""},
+ {"IllegalPrefixes", Var, 1, ""},
+ {"IsPredeclared", Func, 8, "func(s string) bool"},
+ {"Mode", Type, 0, ""},
+ {"New", Func, 0, "func(pkg *ast.Package, importPath string, mode Mode) *Package"},
+ {"NewFromFiles", Func, 14, "func(fset *token.FileSet, files []*ast.File, importPath string, opts ...any) (*Package, error)"},
+ {"Note", Type, 1, ""},
+ {"Note.Body", Field, 1, ""},
+ {"Note.End", Field, 1, ""},
+ {"Note.Pos", Field, 1, ""},
+ {"Note.UID", Field, 1, ""},
+ {"Package", Type, 0, ""},
+ {"Package.Bugs", Field, 0, ""},
+ {"Package.Consts", Field, 0, ""},
+ {"Package.Doc", Field, 0, ""},
+ {"Package.Examples", Field, 14, ""},
+ {"Package.Filenames", Field, 0, ""},
+ {"Package.Funcs", Field, 0, ""},
+ {"Package.ImportPath", Field, 0, ""},
+ {"Package.Imports", Field, 0, ""},
+ {"Package.Name", Field, 0, ""},
+ {"Package.Notes", Field, 1, ""},
+ {"Package.Types", Field, 0, ""},
+ {"Package.Vars", Field, 0, ""},
+ {"PreserveAST", Const, 12, ""},
+ {"Synopsis", Func, 0, "func(text string) string"},
+ {"ToHTML", Func, 0, "func(w io.Writer, text string, words map[string]string)"},
+ {"ToText", Func, 0, "func(w io.Writer, text string, prefix string, codePrefix string, width int)"},
+ {"Type", Type, 0, ""},
+ {"Type.Consts", Field, 0, ""},
+ {"Type.Decl", Field, 0, ""},
+ {"Type.Doc", Field, 0, ""},
+ {"Type.Examples", Field, 14, ""},
+ {"Type.Funcs", Field, 0, ""},
+ {"Type.Methods", Field, 0, ""},
+ {"Type.Name", Field, 0, ""},
+ {"Type.Vars", Field, 0, ""},
+ {"Value", Type, 0, ""},
+ {"Value.Decl", Field, 0, ""},
+ {"Value.Doc", Field, 0, ""},
+ {"Value.Names", Field, 0, ""},
+ },
+ "go/doc/comment": {
+ {"(*DocLink).DefaultURL", Method, 19, ""},
+ {"(*Heading).DefaultID", Method, 19, ""},
+ {"(*List).BlankBefore", Method, 19, ""},
+ {"(*List).BlankBetween", Method, 19, ""},
+ {"(*Parser).Parse", Method, 19, ""},
+ {"(*Printer).Comment", Method, 19, ""},
+ {"(*Printer).HTML", Method, 19, ""},
+ {"(*Printer).Markdown", Method, 19, ""},
+ {"(*Printer).Text", Method, 19, ""},
+ {"Block", Type, 19, ""},
+ {"Code", Type, 19, ""},
+ {"Code.Text", Field, 19, ""},
+ {"DefaultLookupPackage", Func, 19, "func(name string) (importPath string, ok bool)"},
+ {"Doc", Type, 19, ""},
+ {"Doc.Content", Field, 19, ""},
+ {"Doc.Links", Field, 19, ""},
+ {"DocLink", Type, 19, ""},
+ {"DocLink.ImportPath", Field, 19, ""},
+ {"DocLink.Name", Field, 19, ""},
+ {"DocLink.Recv", Field, 19, ""},
+ {"DocLink.Text", Field, 19, ""},
+ {"Heading", Type, 19, ""},
+ {"Heading.Text", Field, 19, ""},
+ {"Italic", Type, 19, ""},
+ {"Link", Type, 19, ""},
+ {"Link.Auto", Field, 19, ""},
+ {"Link.Text", Field, 19, ""},
+ {"Link.URL", Field, 19, ""},
+ {"LinkDef", Type, 19, ""},
+ {"LinkDef.Text", Field, 19, ""},
+ {"LinkDef.URL", Field, 19, ""},
+ {"LinkDef.Used", Field, 19, ""},
+ {"List", Type, 19, ""},
+ {"List.ForceBlankBefore", Field, 19, ""},
+ {"List.ForceBlankBetween", Field, 19, ""},
+ {"List.Items", Field, 19, ""},
+ {"ListItem", Type, 19, ""},
+ {"ListItem.Content", Field, 19, ""},
+ {"ListItem.Number", Field, 19, ""},
+ {"Paragraph", Type, 19, ""},
+ {"Paragraph.Text", Field, 19, ""},
+ {"Parser", Type, 19, ""},
+ {"Parser.LookupPackage", Field, 19, ""},
+ {"Parser.LookupSym", Field, 19, ""},
+ {"Parser.Words", Field, 19, ""},
+ {"Plain", Type, 19, ""},
+ {"Printer", Type, 19, ""},
+ {"Printer.DocLinkBaseURL", Field, 19, ""},
+ {"Printer.DocLinkURL", Field, 19, ""},
+ {"Printer.HeadingID", Field, 19, ""},
+ {"Printer.HeadingLevel", Field, 19, ""},
+ {"Printer.TextCodePrefix", Field, 19, ""},
+ {"Printer.TextPrefix", Field, 19, ""},
+ {"Printer.TextWidth", Field, 19, ""},
+ {"Text", Type, 19, ""},
+ },
+ "go/format": {
+ {"Node", Func, 1, "func(dst io.Writer, fset *token.FileSet, node any) error"},
+ {"Source", Func, 1, "func(src []byte) ([]byte, error)"},
+ },
+ "go/importer": {
+ {"Default", Func, 5, "func() types.Importer"},
+ {"For", Func, 5, "func(compiler string, lookup Lookup) types.Importer"},
+ {"ForCompiler", Func, 12, "func(fset *token.FileSet, compiler string, lookup Lookup) types.Importer"},
+ {"Lookup", Type, 5, ""},
+ },
+ "go/parser": {
+ {"AllErrors", Const, 1, ""},
+ {"DeclarationErrors", Const, 0, ""},
+ {"ImportsOnly", Const, 0, ""},
+ {"Mode", Type, 0, ""},
+ {"PackageClauseOnly", Const, 0, ""},
+ {"ParseComments", Const, 0, ""},
+ {"ParseDir", Func, 0, "func(fset *token.FileSet, path string, filter func(fs.FileInfo) bool, mode Mode) (pkgs map[string]*ast.Package, first error)"},
+ {"ParseExpr", Func, 0, "func(x string) (ast.Expr, error)"},
+ {"ParseExprFrom", Func, 5, "func(fset *token.FileSet, filename string, src any, mode Mode) (expr ast.Expr, err error)"},
+ {"ParseFile", Func, 0, "func(fset *token.FileSet, filename string, src any, mode Mode) (f *ast.File, err error)"},
+ {"SkipObjectResolution", Const, 17, ""},
+ {"SpuriousErrors", Const, 0, ""},
+ {"Trace", Const, 0, ""},
+ },
+ "go/printer": {
+ {"(*Config).Fprint", Method, 0, ""},
+ {"CommentedNode", Type, 0, ""},
+ {"CommentedNode.Comments", Field, 0, ""},
+ {"CommentedNode.Node", Field, 0, ""},
+ {"Config", Type, 0, ""},
+ {"Config.Indent", Field, 1, ""},
+ {"Config.Mode", Field, 0, ""},
+ {"Config.Tabwidth", Field, 0, ""},
+ {"Fprint", Func, 0, "func(output io.Writer, fset *token.FileSet, node any) error"},
+ {"Mode", Type, 0, ""},
+ {"RawFormat", Const, 0, ""},
+ {"SourcePos", Const, 0, ""},
+ {"TabIndent", Const, 0, ""},
+ {"UseSpaces", Const, 0, ""},
+ },
+ "go/scanner": {
+ {"(*ErrorList).Add", Method, 0, ""},
+ {"(*ErrorList).RemoveMultiples", Method, 0, ""},
+ {"(*ErrorList).Reset", Method, 0, ""},
+ {"(*Scanner).Init", Method, 0, ""},
+ {"(*Scanner).Scan", Method, 0, ""},
+ {"(Error).Error", Method, 0, ""},
+ {"(ErrorList).Err", Method, 0, ""},
+ {"(ErrorList).Error", Method, 0, ""},
+ {"(ErrorList).Len", Method, 0, ""},
+ {"(ErrorList).Less", Method, 0, ""},
+ {"(ErrorList).Sort", Method, 0, ""},
+ {"(ErrorList).Swap", Method, 0, ""},
+ {"Error", Type, 0, ""},
+ {"Error.Msg", Field, 0, ""},
+ {"Error.Pos", Field, 0, ""},
+ {"ErrorHandler", Type, 0, ""},
+ {"ErrorList", Type, 0, ""},
+ {"Mode", Type, 0, ""},
+ {"PrintError", Func, 0, "func(w io.Writer, err error)"},
+ {"ScanComments", Const, 0, ""},
+ {"Scanner", Type, 0, ""},
+ {"Scanner.ErrorCount", Field, 0, ""},
+ },
+ "go/token": {
+ {"(*File).AddLine", Method, 0, ""},
+ {"(*File).AddLineColumnInfo", Method, 11, ""},
+ {"(*File).AddLineInfo", Method, 0, ""},
+ {"(*File).Base", Method, 0, ""},
+ {"(*File).Line", Method, 0, ""},
+ {"(*File).LineCount", Method, 0, ""},
+ {"(*File).LineStart", Method, 12, ""},
+ {"(*File).Lines", Method, 21, ""},
+ {"(*File).MergeLine", Method, 2, ""},
+ {"(*File).Name", Method, 0, ""},
+ {"(*File).Offset", Method, 0, ""},
+ {"(*File).Pos", Method, 0, ""},
+ {"(*File).Position", Method, 0, ""},
+ {"(*File).PositionFor", Method, 4, ""},
+ {"(*File).SetLines", Method, 0, ""},
+ {"(*File).SetLinesForContent", Method, 0, ""},
+ {"(*File).Size", Method, 0, ""},
+ {"(*FileSet).AddFile", Method, 0, ""},
+ {"(*FileSet).Base", Method, 0, ""},
+ {"(*FileSet).File", Method, 0, ""},
+ {"(*FileSet).Iterate", Method, 0, ""},
+ {"(*FileSet).Position", Method, 0, ""},
+ {"(*FileSet).PositionFor", Method, 4, ""},
+ {"(*FileSet).Read", Method, 0, ""},
+ {"(*FileSet).RemoveFile", Method, 20, ""},
+ {"(*FileSet).Write", Method, 0, ""},
+ {"(*Position).IsValid", Method, 0, ""},
+ {"(Pos).IsValid", Method, 0, ""},
+ {"(Position).String", Method, 0, ""},
+ {"(Token).IsKeyword", Method, 0, ""},
+ {"(Token).IsLiteral", Method, 0, ""},
+ {"(Token).IsOperator", Method, 0, ""},
+ {"(Token).Precedence", Method, 0, ""},
+ {"(Token).String", Method, 0, ""},
+ {"ADD", Const, 0, ""},
+ {"ADD_ASSIGN", Const, 0, ""},
+ {"AND", Const, 0, ""},
+ {"AND_ASSIGN", Const, 0, ""},
+ {"AND_NOT", Const, 0, ""},
+ {"AND_NOT_ASSIGN", Const, 0, ""},
+ {"ARROW", Const, 0, ""},
+ {"ASSIGN", Const, 0, ""},
+ {"BREAK", Const, 0, ""},
+ {"CASE", Const, 0, ""},
+ {"CHAN", Const, 0, ""},
+ {"CHAR", Const, 0, ""},
+ {"COLON", Const, 0, ""},
+ {"COMMA", Const, 0, ""},
+ {"COMMENT", Const, 0, ""},
+ {"CONST", Const, 0, ""},
+ {"CONTINUE", Const, 0, ""},
+ {"DEC", Const, 0, ""},
+ {"DEFAULT", Const, 0, ""},
+ {"DEFER", Const, 0, ""},
+ {"DEFINE", Const, 0, ""},
+ {"ELLIPSIS", Const, 0, ""},
+ {"ELSE", Const, 0, ""},
+ {"EOF", Const, 0, ""},
+ {"EQL", Const, 0, ""},
+ {"FALLTHROUGH", Const, 0, ""},
+ {"FLOAT", Const, 0, ""},
+ {"FOR", Const, 0, ""},
+ {"FUNC", Const, 0, ""},
+ {"File", Type, 0, ""},
+ {"FileSet", Type, 0, ""},
+ {"GEQ", Const, 0, ""},
+ {"GO", Const, 0, ""},
+ {"GOTO", Const, 0, ""},
+ {"GTR", Const, 0, ""},
+ {"HighestPrec", Const, 0, ""},
+ {"IDENT", Const, 0, ""},
+ {"IF", Const, 0, ""},
+ {"ILLEGAL", Const, 0, ""},
+ {"IMAG", Const, 0, ""},
+ {"IMPORT", Const, 0, ""},
+ {"INC", Const, 0, ""},
+ {"INT", Const, 0, ""},
+ {"INTERFACE", Const, 0, ""},
+ {"IsExported", Func, 13, "func(name string) bool"},
+ {"IsIdentifier", Func, 13, "func(name string) bool"},
+ {"IsKeyword", Func, 13, "func(name string) bool"},
+ {"LAND", Const, 0, ""},
+ {"LBRACE", Const, 0, ""},
+ {"LBRACK", Const, 0, ""},
+ {"LEQ", Const, 0, ""},
+ {"LOR", Const, 0, ""},
+ {"LPAREN", Const, 0, ""},
+ {"LSS", Const, 0, ""},
+ {"Lookup", Func, 0, "func(ident string) Token"},
+ {"LowestPrec", Const, 0, ""},
+ {"MAP", Const, 0, ""},
+ {"MUL", Const, 0, ""},
+ {"MUL_ASSIGN", Const, 0, ""},
+ {"NEQ", Const, 0, ""},
+ {"NOT", Const, 0, ""},
+ {"NewFileSet", Func, 0, "func() *FileSet"},
+ {"NoPos", Const, 0, ""},
+ {"OR", Const, 0, ""},
+ {"OR_ASSIGN", Const, 0, ""},
+ {"PACKAGE", Const, 0, ""},
+ {"PERIOD", Const, 0, ""},
+ {"Pos", Type, 0, ""},
+ {"Position", Type, 0, ""},
+ {"Position.Column", Field, 0, ""},
+ {"Position.Filename", Field, 0, ""},
+ {"Position.Line", Field, 0, ""},
+ {"Position.Offset", Field, 0, ""},
+ {"QUO", Const, 0, ""},
+ {"QUO_ASSIGN", Const, 0, ""},
+ {"RANGE", Const, 0, ""},
+ {"RBRACE", Const, 0, ""},
+ {"RBRACK", Const, 0, ""},
+ {"REM", Const, 0, ""},
+ {"REM_ASSIGN", Const, 0, ""},
+ {"RETURN", Const, 0, ""},
+ {"RPAREN", Const, 0, ""},
+ {"SELECT", Const, 0, ""},
+ {"SEMICOLON", Const, 0, ""},
+ {"SHL", Const, 0, ""},
+ {"SHL_ASSIGN", Const, 0, ""},
+ {"SHR", Const, 0, ""},
+ {"SHR_ASSIGN", Const, 0, ""},
+ {"STRING", Const, 0, ""},
+ {"STRUCT", Const, 0, ""},
+ {"SUB", Const, 0, ""},
+ {"SUB_ASSIGN", Const, 0, ""},
+ {"SWITCH", Const, 0, ""},
+ {"TILDE", Const, 18, ""},
+ {"TYPE", Const, 0, ""},
+ {"Token", Type, 0, ""},
+ {"UnaryPrec", Const, 0, ""},
+ {"VAR", Const, 0, ""},
+ {"XOR", Const, 0, ""},
+ {"XOR_ASSIGN", Const, 0, ""},
+ },
+ "go/types": {
+ {"(*Alias).Obj", Method, 22, ""},
+ {"(*Alias).Origin", Method, 23, ""},
+ {"(*Alias).Rhs", Method, 23, ""},
+ {"(*Alias).SetTypeParams", Method, 23, ""},
+ {"(*Alias).String", Method, 22, ""},
+ {"(*Alias).TypeArgs", Method, 23, ""},
+ {"(*Alias).TypeParams", Method, 23, ""},
+ {"(*Alias).Underlying", Method, 22, ""},
+ {"(*ArgumentError).Error", Method, 18, ""},
+ {"(*ArgumentError).Unwrap", Method, 18, ""},
+ {"(*Array).Elem", Method, 5, ""},
+ {"(*Array).Len", Method, 5, ""},
+ {"(*Array).String", Method, 5, ""},
+ {"(*Array).Underlying", Method, 5, ""},
+ {"(*Basic).Info", Method, 5, ""},
+ {"(*Basic).Kind", Method, 5, ""},
+ {"(*Basic).Name", Method, 5, ""},
+ {"(*Basic).String", Method, 5, ""},
+ {"(*Basic).Underlying", Method, 5, ""},
+ {"(*Builtin).Exported", Method, 5, ""},
+ {"(*Builtin).Id", Method, 5, ""},
+ {"(*Builtin).Name", Method, 5, ""},
+ {"(*Builtin).Parent", Method, 5, ""},
+ {"(*Builtin).Pkg", Method, 5, ""},
+ {"(*Builtin).Pos", Method, 5, ""},
+ {"(*Builtin).String", Method, 5, ""},
+ {"(*Builtin).Type", Method, 5, ""},
+ {"(*Chan).Dir", Method, 5, ""},
+ {"(*Chan).Elem", Method, 5, ""},
+ {"(*Chan).String", Method, 5, ""},
+ {"(*Chan).Underlying", Method, 5, ""},
+ {"(*Checker).Files", Method, 5, ""},
+ {"(*Config).Check", Method, 5, ""},
+ {"(*Const).Exported", Method, 5, ""},
+ {"(*Const).Id", Method, 5, ""},
+ {"(*Const).Name", Method, 5, ""},
+ {"(*Const).Parent", Method, 5, ""},
+ {"(*Const).Pkg", Method, 5, ""},
+ {"(*Const).Pos", Method, 5, ""},
+ {"(*Const).String", Method, 5, ""},
+ {"(*Const).Type", Method, 5, ""},
+ {"(*Const).Val", Method, 5, ""},
+ {"(*Func).Exported", Method, 5, ""},
+ {"(*Func).FullName", Method, 5, ""},
+ {"(*Func).Id", Method, 5, ""},
+ {"(*Func).Name", Method, 5, ""},
+ {"(*Func).Origin", Method, 19, ""},
+ {"(*Func).Parent", Method, 5, ""},
+ {"(*Func).Pkg", Method, 5, ""},
+ {"(*Func).Pos", Method, 5, ""},
+ {"(*Func).Scope", Method, 5, ""},
+ {"(*Func).Signature", Method, 23, ""},
+ {"(*Func).String", Method, 5, ""},
+ {"(*Func).Type", Method, 5, ""},
+ {"(*Info).ObjectOf", Method, 5, ""},
+ {"(*Info).PkgNameOf", Method, 22, ""},
+ {"(*Info).TypeOf", Method, 5, ""},
+ {"(*Initializer).String", Method, 5, ""},
+ {"(*Interface).Complete", Method, 5, ""},
+ {"(*Interface).Embedded", Method, 5, ""},
+ {"(*Interface).EmbeddedType", Method, 11, ""},
+ {"(*Interface).EmbeddedTypes", Method, 24, ""},
+ {"(*Interface).Empty", Method, 5, ""},
+ {"(*Interface).ExplicitMethod", Method, 5, ""},
+ {"(*Interface).ExplicitMethods", Method, 24, ""},
+ {"(*Interface).IsComparable", Method, 18, ""},
+ {"(*Interface).IsImplicit", Method, 18, ""},
+ {"(*Interface).IsMethodSet", Method, 18, ""},
+ {"(*Interface).MarkImplicit", Method, 18, ""},
+ {"(*Interface).Method", Method, 5, ""},
+ {"(*Interface).Methods", Method, 24, ""},
+ {"(*Interface).NumEmbeddeds", Method, 5, ""},
+ {"(*Interface).NumExplicitMethods", Method, 5, ""},
+ {"(*Interface).NumMethods", Method, 5, ""},
+ {"(*Interface).String", Method, 5, ""},
+ {"(*Interface).Underlying", Method, 5, ""},
+ {"(*Label).Exported", Method, 5, ""},
+ {"(*Label).Id", Method, 5, ""},
+ {"(*Label).Name", Method, 5, ""},
+ {"(*Label).Parent", Method, 5, ""},
+ {"(*Label).Pkg", Method, 5, ""},
+ {"(*Label).Pos", Method, 5, ""},
+ {"(*Label).String", Method, 5, ""},
+ {"(*Label).Type", Method, 5, ""},
+ {"(*Map).Elem", Method, 5, ""},
+ {"(*Map).Key", Method, 5, ""},
+ {"(*Map).String", Method, 5, ""},
+ {"(*Map).Underlying", Method, 5, ""},
+ {"(*MethodSet).At", Method, 5, ""},
+ {"(*MethodSet).Len", Method, 5, ""},
+ {"(*MethodSet).Lookup", Method, 5, ""},
+ {"(*MethodSet).Methods", Method, 24, ""},
+ {"(*MethodSet).String", Method, 5, ""},
+ {"(*Named).AddMethod", Method, 5, ""},
+ {"(*Named).Method", Method, 5, ""},
+ {"(*Named).Methods", Method, 24, ""},
+ {"(*Named).NumMethods", Method, 5, ""},
+ {"(*Named).Obj", Method, 5, ""},
+ {"(*Named).Origin", Method, 18, ""},
+ {"(*Named).SetTypeParams", Method, 18, ""},
+ {"(*Named).SetUnderlying", Method, 5, ""},
+ {"(*Named).String", Method, 5, ""},
+ {"(*Named).TypeArgs", Method, 18, ""},
+ {"(*Named).TypeParams", Method, 18, ""},
+ {"(*Named).Underlying", Method, 5, ""},
+ {"(*Nil).Exported", Method, 5, ""},
+ {"(*Nil).Id", Method, 5, ""},
+ {"(*Nil).Name", Method, 5, ""},
+ {"(*Nil).Parent", Method, 5, ""},
+ {"(*Nil).Pkg", Method, 5, ""},
+ {"(*Nil).Pos", Method, 5, ""},
+ {"(*Nil).String", Method, 5, ""},
+ {"(*Nil).Type", Method, 5, ""},
+ {"(*Package).Complete", Method, 5, ""},
+ {"(*Package).GoVersion", Method, 21, ""},
+ {"(*Package).Imports", Method, 5, ""},
+ {"(*Package).MarkComplete", Method, 5, ""},
+ {"(*Package).Name", Method, 5, ""},
+ {"(*Package).Path", Method, 5, ""},
+ {"(*Package).Scope", Method, 5, ""},
+ {"(*Package).SetImports", Method, 5, ""},
+ {"(*Package).SetName", Method, 6, ""},
+ {"(*Package).String", Method, 5, ""},
+ {"(*PkgName).Exported", Method, 5, ""},
+ {"(*PkgName).Id", Method, 5, ""},
+ {"(*PkgName).Imported", Method, 5, ""},
+ {"(*PkgName).Name", Method, 5, ""},
+ {"(*PkgName).Parent", Method, 5, ""},
+ {"(*PkgName).Pkg", Method, 5, ""},
+ {"(*PkgName).Pos", Method, 5, ""},
+ {"(*PkgName).String", Method, 5, ""},
+ {"(*PkgName).Type", Method, 5, ""},
+ {"(*Pointer).Elem", Method, 5, ""},
+ {"(*Pointer).String", Method, 5, ""},
+ {"(*Pointer).Underlying", Method, 5, ""},
+ {"(*Scope).Child", Method, 5, ""},
+ {"(*Scope).Children", Method, 24, ""},
+ {"(*Scope).Contains", Method, 5, ""},
+ {"(*Scope).End", Method, 5, ""},
+ {"(*Scope).Innermost", Method, 5, ""},
+ {"(*Scope).Insert", Method, 5, ""},
+ {"(*Scope).Len", Method, 5, ""},
+ {"(*Scope).Lookup", Method, 5, ""},
+ {"(*Scope).LookupParent", Method, 5, ""},
+ {"(*Scope).Names", Method, 5, ""},
+ {"(*Scope).NumChildren", Method, 5, ""},
+ {"(*Scope).Parent", Method, 5, ""},
+ {"(*Scope).Pos", Method, 5, ""},
+ {"(*Scope).String", Method, 5, ""},
+ {"(*Scope).WriteTo", Method, 5, ""},
+ {"(*Selection).Index", Method, 5, ""},
+ {"(*Selection).Indirect", Method, 5, ""},
+ {"(*Selection).Kind", Method, 5, ""},
+ {"(*Selection).Obj", Method, 5, ""},
+ {"(*Selection).Recv", Method, 5, ""},
+ {"(*Selection).String", Method, 5, ""},
+ {"(*Selection).Type", Method, 5, ""},
+ {"(*Signature).Params", Method, 5, ""},
+ {"(*Signature).Recv", Method, 5, ""},
+ {"(*Signature).RecvTypeParams", Method, 18, ""},
+ {"(*Signature).Results", Method, 5, ""},
+ {"(*Signature).String", Method, 5, ""},
+ {"(*Signature).TypeParams", Method, 18, ""},
+ {"(*Signature).Underlying", Method, 5, ""},
+ {"(*Signature).Variadic", Method, 5, ""},
+ {"(*Slice).Elem", Method, 5, ""},
+ {"(*Slice).String", Method, 5, ""},
+ {"(*Slice).Underlying", Method, 5, ""},
+ {"(*StdSizes).Alignof", Method, 5, ""},
+ {"(*StdSizes).Offsetsof", Method, 5, ""},
+ {"(*StdSizes).Sizeof", Method, 5, ""},
+ {"(*Struct).Field", Method, 5, ""},
+ {"(*Struct).Fields", Method, 24, ""},
+ {"(*Struct).NumFields", Method, 5, ""},
+ {"(*Struct).String", Method, 5, ""},
+ {"(*Struct).Tag", Method, 5, ""},
+ {"(*Struct).Underlying", Method, 5, ""},
+ {"(*Term).String", Method, 18, ""},
+ {"(*Term).Tilde", Method, 18, ""},
+ {"(*Term).Type", Method, 18, ""},
+ {"(*Tuple).At", Method, 5, ""},
+ {"(*Tuple).Len", Method, 5, ""},
+ {"(*Tuple).String", Method, 5, ""},
+ {"(*Tuple).Underlying", Method, 5, ""},
+ {"(*Tuple).Variables", Method, 24, ""},
+ {"(*TypeList).At", Method, 18, ""},
+ {"(*TypeList).Len", Method, 18, ""},
+ {"(*TypeList).Types", Method, 24, ""},
+ {"(*TypeName).Exported", Method, 5, ""},
+ {"(*TypeName).Id", Method, 5, ""},
+ {"(*TypeName).IsAlias", Method, 9, ""},
+ {"(*TypeName).Name", Method, 5, ""},
+ {"(*TypeName).Parent", Method, 5, ""},
+ {"(*TypeName).Pkg", Method, 5, ""},
+ {"(*TypeName).Pos", Method, 5, ""},
+ {"(*TypeName).String", Method, 5, ""},
+ {"(*TypeName).Type", Method, 5, ""},
+ {"(*TypeParam).Constraint", Method, 18, ""},
+ {"(*TypeParam).Index", Method, 18, ""},
+ {"(*TypeParam).Obj", Method, 18, ""},
+ {"(*TypeParam).SetConstraint", Method, 18, ""},
+ {"(*TypeParam).String", Method, 18, ""},
+ {"(*TypeParam).Underlying", Method, 18, ""},
+ {"(*TypeParamList).At", Method, 18, ""},
+ {"(*TypeParamList).Len", Method, 18, ""},
+ {"(*TypeParamList).TypeParams", Method, 24, ""},
+ {"(*Union).Len", Method, 18, ""},
+ {"(*Union).String", Method, 18, ""},
+ {"(*Union).Term", Method, 18, ""},
+ {"(*Union).Terms", Method, 24, ""},
+ {"(*Union).Underlying", Method, 18, ""},
+ {"(*Var).Anonymous", Method, 5, ""},
+ {"(*Var).Embedded", Method, 11, ""},
+ {"(*Var).Exported", Method, 5, ""},
+ {"(*Var).Id", Method, 5, ""},
+ {"(*Var).IsField", Method, 5, ""},
+ {"(*Var).Kind", Method, 25, ""},
+ {"(*Var).Name", Method, 5, ""},
+ {"(*Var).Origin", Method, 19, ""},
+ {"(*Var).Parent", Method, 5, ""},
+ {"(*Var).Pkg", Method, 5, ""},
+ {"(*Var).Pos", Method, 5, ""},
+ {"(*Var).SetKind", Method, 25, ""},
+ {"(*Var).String", Method, 5, ""},
+ {"(*Var).Type", Method, 5, ""},
+ {"(Checker).ObjectOf", Method, 5, ""},
+ {"(Checker).PkgNameOf", Method, 22, ""},
+ {"(Checker).TypeOf", Method, 5, ""},
+ {"(Error).Error", Method, 5, ""},
+ {"(TypeAndValue).Addressable", Method, 5, ""},
+ {"(TypeAndValue).Assignable", Method, 5, ""},
+ {"(TypeAndValue).HasOk", Method, 5, ""},
+ {"(TypeAndValue).IsBuiltin", Method, 5, ""},
+ {"(TypeAndValue).IsNil", Method, 5, ""},
+ {"(TypeAndValue).IsType", Method, 5, ""},
+ {"(TypeAndValue).IsValue", Method, 5, ""},
+ {"(TypeAndValue).IsVoid", Method, 5, ""},
+ {"(VarKind).String", Method, 25, ""},
+ {"Alias", Type, 22, ""},
+ {"ArgumentError", Type, 18, ""},
+ {"ArgumentError.Err", Field, 18, ""},
+ {"ArgumentError.Index", Field, 18, ""},
+ {"Array", Type, 5, ""},
+ {"AssertableTo", Func, 5, "func(V *Interface, T Type) bool"},
+ {"AssignableTo", Func, 5, "func(V Type, T Type) bool"},
+ {"Basic", Type, 5, ""},
+ {"BasicInfo", Type, 5, ""},
+ {"BasicKind", Type, 5, ""},
+ {"Bool", Const, 5, ""},
+ {"Builtin", Type, 5, ""},
+ {"Byte", Const, 5, ""},
+ {"Chan", Type, 5, ""},
+ {"ChanDir", Type, 5, ""},
+ {"CheckExpr", Func, 13, "func(fset *token.FileSet, pkg *Package, pos token.Pos, expr ast.Expr, info *Info) (err error)"},
+ {"Checker", Type, 5, ""},
+ {"Checker.Info", Field, 5, ""},
+ {"Comparable", Func, 5, "func(T Type) bool"},
+ {"Complex128", Const, 5, ""},
+ {"Complex64", Const, 5, ""},
+ {"Config", Type, 5, ""},
+ {"Config.Context", Field, 18, ""},
+ {"Config.DisableUnusedImportCheck", Field, 5, ""},
+ {"Config.Error", Field, 5, ""},
+ {"Config.FakeImportC", Field, 5, ""},
+ {"Config.GoVersion", Field, 18, ""},
+ {"Config.IgnoreFuncBodies", Field, 5, ""},
+ {"Config.Importer", Field, 5, ""},
+ {"Config.Sizes", Field, 5, ""},
+ {"Const", Type, 5, ""},
+ {"Context", Type, 18, ""},
+ {"ConvertibleTo", Func, 5, "func(V Type, T Type) bool"},
+ {"DefPredeclaredTestFuncs", Func, 5, "func()"},
+ {"Default", Func, 8, "func(t Type) Type"},
+ {"Error", Type, 5, ""},
+ {"Error.Fset", Field, 5, ""},
+ {"Error.Msg", Field, 5, ""},
+ {"Error.Pos", Field, 5, ""},
+ {"Error.Soft", Field, 5, ""},
+ {"Eval", Func, 5, "func(fset *token.FileSet, pkg *Package, pos token.Pos, expr string) (_ TypeAndValue, err error)"},
+ {"ExprString", Func, 5, "func(x ast.Expr) string"},
+ {"FieldVal", Const, 5, ""},
+ {"FieldVar", Const, 25, ""},
+ {"Float32", Const, 5, ""},
+ {"Float64", Const, 5, ""},
+ {"Func", Type, 5, ""},
+ {"Id", Func, 5, "func(pkg *Package, name string) string"},
+ {"Identical", Func, 5, "func(x Type, y Type) bool"},
+ {"IdenticalIgnoreTags", Func, 8, "func(x Type, y Type) bool"},
+ {"Implements", Func, 5, "func(V Type, T *Interface) bool"},
+ {"ImportMode", Type, 6, ""},
+ {"Importer", Type, 5, ""},
+ {"ImporterFrom", Type, 6, ""},
+ {"Info", Type, 5, ""},
+ {"Info.Defs", Field, 5, ""},
+ {"Info.FileVersions", Field, 22, ""},
+ {"Info.Implicits", Field, 5, ""},
+ {"Info.InitOrder", Field, 5, ""},
+ {"Info.Instances", Field, 18, ""},
+ {"Info.Scopes", Field, 5, ""},
+ {"Info.Selections", Field, 5, ""},
+ {"Info.Types", Field, 5, ""},
+ {"Info.Uses", Field, 5, ""},
+ {"Initializer", Type, 5, ""},
+ {"Initializer.Lhs", Field, 5, ""},
+ {"Initializer.Rhs", Field, 5, ""},
+ {"Instance", Type, 18, ""},
+ {"Instance.Type", Field, 18, ""},
+ {"Instance.TypeArgs", Field, 18, ""},
+ {"Instantiate", Func, 18, "func(ctxt *Context, orig Type, targs []Type, validate bool) (Type, error)"},
+ {"Int", Const, 5, ""},
+ {"Int16", Const, 5, ""},
+ {"Int32", Const, 5, ""},
+ {"Int64", Const, 5, ""},
+ {"Int8", Const, 5, ""},
+ {"Interface", Type, 5, ""},
+ {"Invalid", Const, 5, ""},
+ {"IsBoolean", Const, 5, ""},
+ {"IsComplex", Const, 5, ""},
+ {"IsConstType", Const, 5, ""},
+ {"IsFloat", Const, 5, ""},
+ {"IsInteger", Const, 5, ""},
+ {"IsInterface", Func, 5, "func(t Type) bool"},
+ {"IsNumeric", Const, 5, ""},
+ {"IsOrdered", Const, 5, ""},
+ {"IsString", Const, 5, ""},
+ {"IsUnsigned", Const, 5, ""},
+ {"IsUntyped", Const, 5, ""},
+ {"Label", Type, 5, ""},
+ {"LocalVar", Const, 25, ""},
+ {"LookupFieldOrMethod", Func, 5, "func(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool)"},
+ {"LookupSelection", Func, 25, ""},
+ {"Map", Type, 5, ""},
+ {"MethodExpr", Const, 5, ""},
+ {"MethodSet", Type, 5, ""},
+ {"MethodVal", Const, 5, ""},
+ {"MissingMethod", Func, 5, "func(V Type, T *Interface, static bool) (method *Func, wrongType bool)"},
+ {"Named", Type, 5, ""},
+ {"NewAlias", Func, 22, "func(obj *TypeName, rhs Type) *Alias"},
+ {"NewArray", Func, 5, "func(elem Type, len int64) *Array"},
+ {"NewChan", Func, 5, "func(dir ChanDir, elem Type) *Chan"},
+ {"NewChecker", Func, 5, "func(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Checker"},
+ {"NewConst", Func, 5, "func(pos token.Pos, pkg *Package, name string, typ Type, val constant.Value) *Const"},
+ {"NewContext", Func, 18, "func() *Context"},
+ {"NewField", Func, 5, "func(pos token.Pos, pkg *Package, name string, typ Type, embedded bool) *Var"},
+ {"NewFunc", Func, 5, "func(pos token.Pos, pkg *Package, name string, sig *Signature) *Func"},
+ {"NewInterface", Func, 5, "func(methods []*Func, embeddeds []*Named) *Interface"},
+ {"NewInterfaceType", Func, 11, "func(methods []*Func, embeddeds []Type) *Interface"},
+ {"NewLabel", Func, 5, "func(pos token.Pos, pkg *Package, name string) *Label"},
+ {"NewMap", Func, 5, "func(key Type, elem Type) *Map"},
+ {"NewMethodSet", Func, 5, "func(T Type) *MethodSet"},
+ {"NewNamed", Func, 5, "func(obj *TypeName, underlying Type, methods []*Func) *Named"},
+ {"NewPackage", Func, 5, "func(path string, name string) *Package"},
+ {"NewParam", Func, 5, "func(pos token.Pos, pkg *Package, name string, typ Type) *Var"},
+ {"NewPkgName", Func, 5, "func(pos token.Pos, pkg *Package, name string, imported *Package) *PkgName"},
+ {"NewPointer", Func, 5, "func(elem Type) *Pointer"},
+ {"NewScope", Func, 5, "func(parent *Scope, pos token.Pos, end token.Pos, comment string) *Scope"},
+ {"NewSignature", Func, 5, "func(recv *Var, params *Tuple, results *Tuple, variadic bool) *Signature"},
+ {"NewSignatureType", Func, 18, "func(recv *Var, recvTypeParams []*TypeParam, typeParams []*TypeParam, params *Tuple, results *Tuple, variadic bool) *Signature"},
+ {"NewSlice", Func, 5, "func(elem Type) *Slice"},
+ {"NewStruct", Func, 5, "func(fields []*Var, tags []string) *Struct"},
+ {"NewTerm", Func, 18, "func(tilde bool, typ Type) *Term"},
+ {"NewTuple", Func, 5, "func(x ...*Var) *Tuple"},
+ {"NewTypeName", Func, 5, "func(pos token.Pos, pkg *Package, name string, typ Type) *TypeName"},
+ {"NewTypeParam", Func, 18, "func(obj *TypeName, constraint Type) *TypeParam"},
+ {"NewUnion", Func, 18, "func(terms []*Term) *Union"},
+ {"NewVar", Func, 5, "func(pos token.Pos, pkg *Package, name string, typ Type) *Var"},
+ {"Nil", Type, 5, ""},
+ {"Object", Type, 5, ""},
+ {"ObjectString", Func, 5, "func(obj Object, qf Qualifier) string"},
+ {"Package", Type, 5, ""},
+ {"PackageVar", Const, 25, ""},
+ {"ParamVar", Const, 25, ""},
+ {"PkgName", Type, 5, ""},
+ {"Pointer", Type, 5, ""},
+ {"Qualifier", Type, 5, ""},
+ {"RecvOnly", Const, 5, ""},
+ {"RecvVar", Const, 25, ""},
+ {"RelativeTo", Func, 5, "func(pkg *Package) Qualifier"},
+ {"ResultVar", Const, 25, ""},
+ {"Rune", Const, 5, ""},
+ {"Satisfies", Func, 20, "func(V Type, T *Interface) bool"},
+ {"Scope", Type, 5, ""},
+ {"Selection", Type, 5, ""},
+ {"SelectionKind", Type, 5, ""},
+ {"SelectionString", Func, 5, "func(s *Selection, qf Qualifier) string"},
+ {"SendOnly", Const, 5, ""},
+ {"SendRecv", Const, 5, ""},
+ {"Signature", Type, 5, ""},
+ {"Sizes", Type, 5, ""},
+ {"SizesFor", Func, 9, "func(compiler string, arch string) Sizes"},
+ {"Slice", Type, 5, ""},
+ {"StdSizes", Type, 5, ""},
+ {"StdSizes.MaxAlign", Field, 5, ""},
+ {"StdSizes.WordSize", Field, 5, ""},
+ {"String", Const, 5, ""},
+ {"Struct", Type, 5, ""},
+ {"Term", Type, 18, ""},
+ {"Tuple", Type, 5, ""},
+ {"Typ", Var, 5, ""},
+ {"Type", Type, 5, ""},
+ {"TypeAndValue", Type, 5, ""},
+ {"TypeAndValue.Type", Field, 5, ""},
+ {"TypeAndValue.Value", Field, 5, ""},
+ {"TypeList", Type, 18, ""},
+ {"TypeName", Type, 5, ""},
+ {"TypeParam", Type, 18, ""},
+ {"TypeParamList", Type, 18, ""},
+ {"TypeString", Func, 5, "func(typ Type, qf Qualifier) string"},
+ {"Uint", Const, 5, ""},
+ {"Uint16", Const, 5, ""},
+ {"Uint32", Const, 5, ""},
+ {"Uint64", Const, 5, ""},
+ {"Uint8", Const, 5, ""},
+ {"Uintptr", Const, 5, ""},
+ {"Unalias", Func, 22, "func(t Type) Type"},
+ {"Union", Type, 18, ""},
+ {"Universe", Var, 5, ""},
+ {"Unsafe", Var, 5, ""},
+ {"UnsafePointer", Const, 5, ""},
+ {"UntypedBool", Const, 5, ""},
+ {"UntypedComplex", Const, 5, ""},
+ {"UntypedFloat", Const, 5, ""},
+ {"UntypedInt", Const, 5, ""},
+ {"UntypedNil", Const, 5, ""},
+ {"UntypedRune", Const, 5, ""},
+ {"UntypedString", Const, 5, ""},
+ {"Var", Type, 5, ""},
+ {"VarKind", Type, 25, ""},
+ {"WriteExpr", Func, 5, "func(buf *bytes.Buffer, x ast.Expr)"},
+ {"WriteSignature", Func, 5, "func(buf *bytes.Buffer, sig *Signature, qf Qualifier)"},
+ {"WriteType", Func, 5, "func(buf *bytes.Buffer, typ Type, qf Qualifier)"},
+ },
+ "go/version": {
+ {"Compare", Func, 22, "func(x string, y string) int"},
+ {"IsValid", Func, 22, "func(x string) bool"},
+ {"Lang", Func, 22, "func(x string) string"},
+ },
+ "hash": {
+ {"Hash", Type, 0, ""},
+ {"Hash32", Type, 0, ""},
+ {"Hash64", Type, 0, ""},
+ },
+ "hash/adler32": {
+ {"Checksum", Func, 0, "func(data []byte) uint32"},
+ {"New", Func, 0, "func() hash.Hash32"},
+ {"Size", Const, 0, ""},
+ },
+ "hash/crc32": {
+ {"Castagnoli", Const, 0, ""},
+ {"Checksum", Func, 0, "func(data []byte, tab *Table) uint32"},
+ {"ChecksumIEEE", Func, 0, "func(data []byte) uint32"},
+ {"IEEE", Const, 0, ""},
+ {"IEEETable", Var, 0, ""},
+ {"Koopman", Const, 0, ""},
+ {"MakeTable", Func, 0, "func(poly uint32) *Table"},
+ {"New", Func, 0, "func(tab *Table) hash.Hash32"},
+ {"NewIEEE", Func, 0, "func() hash.Hash32"},
+ {"Size", Const, 0, ""},
+ {"Table", Type, 0, ""},
+ {"Update", Func, 0, "func(crc uint32, tab *Table, p []byte) uint32"},
+ },
+ "hash/crc64": {
+ {"Checksum", Func, 0, "func(data []byte, tab *Table) uint64"},
+ {"ECMA", Const, 0, ""},
+ {"ISO", Const, 0, ""},
+ {"MakeTable", Func, 0, "func(poly uint64) *Table"},
+ {"New", Func, 0, "func(tab *Table) hash.Hash64"},
+ {"Size", Const, 0, ""},
+ {"Table", Type, 0, ""},
+ {"Update", Func, 0, "func(crc uint64, tab *Table, p []byte) uint64"},
+ },
+ "hash/fnv": {
+ {"New128", Func, 9, "func() hash.Hash"},
+ {"New128a", Func, 9, "func() hash.Hash"},
+ {"New32", Func, 0, "func() hash.Hash32"},
+ {"New32a", Func, 0, "func() hash.Hash32"},
+ {"New64", Func, 0, "func() hash.Hash64"},
+ {"New64a", Func, 0, "func() hash.Hash64"},
+ },
+ "hash/maphash": {
+ {"(*Hash).BlockSize", Method, 14, ""},
+ {"(*Hash).Reset", Method, 14, ""},
+ {"(*Hash).Seed", Method, 14, ""},
+ {"(*Hash).SetSeed", Method, 14, ""},
+ {"(*Hash).Size", Method, 14, ""},
+ {"(*Hash).Sum", Method, 14, ""},
+ {"(*Hash).Sum64", Method, 14, ""},
+ {"(*Hash).Write", Method, 14, ""},
+ {"(*Hash).WriteByte", Method, 14, ""},
+ {"(*Hash).WriteString", Method, 14, ""},
+ {"Bytes", Func, 19, "func(seed Seed, b []byte) uint64"},
+ {"Comparable", Func, 24, "func[T comparable](seed Seed, v T) uint64"},
+ {"Hash", Type, 14, ""},
+ {"MakeSeed", Func, 14, "func() Seed"},
+ {"Seed", Type, 14, ""},
+ {"String", Func, 19, "func(seed Seed, s string) uint64"},
+ {"WriteComparable", Func, 24, "func[T comparable](h *Hash, x T)"},
+ },
+ "html": {
+ {"EscapeString", Func, 0, "func(s string) string"},
+ {"UnescapeString", Func, 0, "func(s string) string"},
+ },
+ "html/template": {
+ {"(*Error).Error", Method, 0, ""},
+ {"(*Template).AddParseTree", Method, 0, ""},
+ {"(*Template).Clone", Method, 0, ""},
+ {"(*Template).DefinedTemplates", Method, 6, ""},
+ {"(*Template).Delims", Method, 0, ""},
+ {"(*Template).Execute", Method, 0, ""},
+ {"(*Template).ExecuteTemplate", Method, 0, ""},
+ {"(*Template).Funcs", Method, 0, ""},
+ {"(*Template).Lookup", Method, 0, ""},
+ {"(*Template).Name", Method, 0, ""},
+ {"(*Template).New", Method, 0, ""},
+ {"(*Template).Option", Method, 5, ""},
+ {"(*Template).Parse", Method, 0, ""},
+ {"(*Template).ParseFS", Method, 16, ""},
+ {"(*Template).ParseFiles", Method, 0, ""},
+ {"(*Template).ParseGlob", Method, 0, ""},
+ {"(*Template).Templates", Method, 0, ""},
+ {"CSS", Type, 0, ""},
+ {"ErrAmbigContext", Const, 0, ""},
+ {"ErrBadHTML", Const, 0, ""},
+ {"ErrBranchEnd", Const, 0, ""},
+ {"ErrEndContext", Const, 0, ""},
+ {"ErrJSTemplate", Const, 21, ""},
+ {"ErrNoSuchTemplate", Const, 0, ""},
+ {"ErrOutputContext", Const, 0, ""},
+ {"ErrPartialCharset", Const, 0, ""},
+ {"ErrPartialEscape", Const, 0, ""},
+ {"ErrPredefinedEscaper", Const, 9, ""},
+ {"ErrRangeLoopReentry", Const, 0, ""},
+ {"ErrSlashAmbig", Const, 0, ""},
+ {"Error", Type, 0, ""},
+ {"Error.Description", Field, 0, ""},
+ {"Error.ErrorCode", Field, 0, ""},
+ {"Error.Line", Field, 0, ""},
+ {"Error.Name", Field, 0, ""},
+ {"Error.Node", Field, 4, ""},
+ {"ErrorCode", Type, 0, ""},
+ {"FuncMap", Type, 0, ""},
+ {"HTML", Type, 0, ""},
+ {"HTMLAttr", Type, 0, ""},
+ {"HTMLEscape", Func, 0, "func(w io.Writer, b []byte)"},
+ {"HTMLEscapeString", Func, 0, "func(s string) string"},
+ {"HTMLEscaper", Func, 0, "func(args ...any) string"},
+ {"IsTrue", Func, 6, "func(val any) (truth bool, ok bool)"},
+ {"JS", Type, 0, ""},
+ {"JSEscape", Func, 0, "func(w io.Writer, b []byte)"},
+ {"JSEscapeString", Func, 0, "func(s string) string"},
+ {"JSEscaper", Func, 0, "func(args ...any) string"},
+ {"JSStr", Type, 0, ""},
+ {"Must", Func, 0, "func(t *Template, err error) *Template"},
+ {"New", Func, 0, "func(name string) *Template"},
+ {"OK", Const, 0, ""},
+ {"ParseFS", Func, 16, "func(fs fs.FS, patterns ...string) (*Template, error)"},
+ {"ParseFiles", Func, 0, "func(filenames ...string) (*Template, error)"},
+ {"ParseGlob", Func, 0, "func(pattern string) (*Template, error)"},
+ {"Srcset", Type, 10, ""},
+ {"Template", Type, 0, ""},
+ {"Template.Tree", Field, 2, ""},
+ {"URL", Type, 0, ""},
+ {"URLQueryEscaper", Func, 0, "func(args ...any) string"},
+ },
+ "image": {
+ {"(*Alpha).AlphaAt", Method, 4, ""},
+ {"(*Alpha).At", Method, 0, ""},
+ {"(*Alpha).Bounds", Method, 0, ""},
+ {"(*Alpha).ColorModel", Method, 0, ""},
+ {"(*Alpha).Opaque", Method, 0, ""},
+ {"(*Alpha).PixOffset", Method, 0, ""},
+ {"(*Alpha).RGBA64At", Method, 17, ""},
+ {"(*Alpha).Set", Method, 0, ""},
+ {"(*Alpha).SetAlpha", Method, 0, ""},
+ {"(*Alpha).SetRGBA64", Method, 17, ""},
+ {"(*Alpha).SubImage", Method, 0, ""},
+ {"(*Alpha16).Alpha16At", Method, 4, ""},
+ {"(*Alpha16).At", Method, 0, ""},
+ {"(*Alpha16).Bounds", Method, 0, ""},
+ {"(*Alpha16).ColorModel", Method, 0, ""},
+ {"(*Alpha16).Opaque", Method, 0, ""},
+ {"(*Alpha16).PixOffset", Method, 0, ""},
+ {"(*Alpha16).RGBA64At", Method, 17, ""},
+ {"(*Alpha16).Set", Method, 0, ""},
+ {"(*Alpha16).SetAlpha16", Method, 0, ""},
+ {"(*Alpha16).SetRGBA64", Method, 17, ""},
+ {"(*Alpha16).SubImage", Method, 0, ""},
+ {"(*CMYK).At", Method, 5, ""},
+ {"(*CMYK).Bounds", Method, 5, ""},
+ {"(*CMYK).CMYKAt", Method, 5, ""},
+ {"(*CMYK).ColorModel", Method, 5, ""},
+ {"(*CMYK).Opaque", Method, 5, ""},
+ {"(*CMYK).PixOffset", Method, 5, ""},
+ {"(*CMYK).RGBA64At", Method, 17, ""},
+ {"(*CMYK).Set", Method, 5, ""},
+ {"(*CMYK).SetCMYK", Method, 5, ""},
+ {"(*CMYK).SetRGBA64", Method, 17, ""},
+ {"(*CMYK).SubImage", Method, 5, ""},
+ {"(*Gray).At", Method, 0, ""},
+ {"(*Gray).Bounds", Method, 0, ""},
+ {"(*Gray).ColorModel", Method, 0, ""},
+ {"(*Gray).GrayAt", Method, 4, ""},
+ {"(*Gray).Opaque", Method, 0, ""},
+ {"(*Gray).PixOffset", Method, 0, ""},
+ {"(*Gray).RGBA64At", Method, 17, ""},
+ {"(*Gray).Set", Method, 0, ""},
+ {"(*Gray).SetGray", Method, 0, ""},
+ {"(*Gray).SetRGBA64", Method, 17, ""},
+ {"(*Gray).SubImage", Method, 0, ""},
+ {"(*Gray16).At", Method, 0, ""},
+ {"(*Gray16).Bounds", Method, 0, ""},
+ {"(*Gray16).ColorModel", Method, 0, ""},
+ {"(*Gray16).Gray16At", Method, 4, ""},
+ {"(*Gray16).Opaque", Method, 0, ""},
+ {"(*Gray16).PixOffset", Method, 0, ""},
+ {"(*Gray16).RGBA64At", Method, 17, ""},
+ {"(*Gray16).Set", Method, 0, ""},
+ {"(*Gray16).SetGray16", Method, 0, ""},
+ {"(*Gray16).SetRGBA64", Method, 17, ""},
+ {"(*Gray16).SubImage", Method, 0, ""},
+ {"(*NRGBA).At", Method, 0, ""},
+ {"(*NRGBA).Bounds", Method, 0, ""},
+ {"(*NRGBA).ColorModel", Method, 0, ""},
+ {"(*NRGBA).NRGBAAt", Method, 4, ""},
+ {"(*NRGBA).Opaque", Method, 0, ""},
+ {"(*NRGBA).PixOffset", Method, 0, ""},
+ {"(*NRGBA).RGBA64At", Method, 17, ""},
+ {"(*NRGBA).Set", Method, 0, ""},
+ {"(*NRGBA).SetNRGBA", Method, 0, ""},
+ {"(*NRGBA).SetRGBA64", Method, 17, ""},
+ {"(*NRGBA).SubImage", Method, 0, ""},
+ {"(*NRGBA64).At", Method, 0, ""},
+ {"(*NRGBA64).Bounds", Method, 0, ""},
+ {"(*NRGBA64).ColorModel", Method, 0, ""},
+ {"(*NRGBA64).NRGBA64At", Method, 4, ""},
+ {"(*NRGBA64).Opaque", Method, 0, ""},
+ {"(*NRGBA64).PixOffset", Method, 0, ""},
+ {"(*NRGBA64).RGBA64At", Method, 17, ""},
+ {"(*NRGBA64).Set", Method, 0, ""},
+ {"(*NRGBA64).SetNRGBA64", Method, 0, ""},
+ {"(*NRGBA64).SetRGBA64", Method, 17, ""},
+ {"(*NRGBA64).SubImage", Method, 0, ""},
+ {"(*NYCbCrA).AOffset", Method, 6, ""},
+ {"(*NYCbCrA).At", Method, 6, ""},
+ {"(*NYCbCrA).Bounds", Method, 6, ""},
+ {"(*NYCbCrA).COffset", Method, 6, ""},
+ {"(*NYCbCrA).ColorModel", Method, 6, ""},
+ {"(*NYCbCrA).NYCbCrAAt", Method, 6, ""},
+ {"(*NYCbCrA).Opaque", Method, 6, ""},
+ {"(*NYCbCrA).RGBA64At", Method, 17, ""},
+ {"(*NYCbCrA).SubImage", Method, 6, ""},
+ {"(*NYCbCrA).YCbCrAt", Method, 6, ""},
+ {"(*NYCbCrA).YOffset", Method, 6, ""},
+ {"(*Paletted).At", Method, 0, ""},
+ {"(*Paletted).Bounds", Method, 0, ""},
+ {"(*Paletted).ColorIndexAt", Method, 0, ""},
+ {"(*Paletted).ColorModel", Method, 0, ""},
+ {"(*Paletted).Opaque", Method, 0, ""},
+ {"(*Paletted).PixOffset", Method, 0, ""},
+ {"(*Paletted).RGBA64At", Method, 17, ""},
+ {"(*Paletted).Set", Method, 0, ""},
+ {"(*Paletted).SetColorIndex", Method, 0, ""},
+ {"(*Paletted).SetRGBA64", Method, 17, ""},
+ {"(*Paletted).SubImage", Method, 0, ""},
+ {"(*RGBA).At", Method, 0, ""},
+ {"(*RGBA).Bounds", Method, 0, ""},
+ {"(*RGBA).ColorModel", Method, 0, ""},
+ {"(*RGBA).Opaque", Method, 0, ""},
+ {"(*RGBA).PixOffset", Method, 0, ""},
+ {"(*RGBA).RGBA64At", Method, 17, ""},
+ {"(*RGBA).RGBAAt", Method, 4, ""},
+ {"(*RGBA).Set", Method, 0, ""},
+ {"(*RGBA).SetRGBA", Method, 0, ""},
+ {"(*RGBA).SetRGBA64", Method, 17, ""},
+ {"(*RGBA).SubImage", Method, 0, ""},
+ {"(*RGBA64).At", Method, 0, ""},
+ {"(*RGBA64).Bounds", Method, 0, ""},
+ {"(*RGBA64).ColorModel", Method, 0, ""},
+ {"(*RGBA64).Opaque", Method, 0, ""},
+ {"(*RGBA64).PixOffset", Method, 0, ""},
+ {"(*RGBA64).RGBA64At", Method, 4, ""},
+ {"(*RGBA64).Set", Method, 0, ""},
+ {"(*RGBA64).SetRGBA64", Method, 0, ""},
+ {"(*RGBA64).SubImage", Method, 0, ""},
+ {"(*Uniform).At", Method, 0, ""},
+ {"(*Uniform).Bounds", Method, 0, ""},
+ {"(*Uniform).ColorModel", Method, 0, ""},
+ {"(*Uniform).Convert", Method, 0, ""},
+ {"(*Uniform).Opaque", Method, 0, ""},
+ {"(*Uniform).RGBA", Method, 0, ""},
+ {"(*Uniform).RGBA64At", Method, 17, ""},
+ {"(*YCbCr).At", Method, 0, ""},
+ {"(*YCbCr).Bounds", Method, 0, ""},
+ {"(*YCbCr).COffset", Method, 0, ""},
+ {"(*YCbCr).ColorModel", Method, 0, ""},
+ {"(*YCbCr).Opaque", Method, 0, ""},
+ {"(*YCbCr).RGBA64At", Method, 17, ""},
+ {"(*YCbCr).SubImage", Method, 0, ""},
+ {"(*YCbCr).YCbCrAt", Method, 4, ""},
+ {"(*YCbCr).YOffset", Method, 0, ""},
+ {"(Point).Add", Method, 0, ""},
+ {"(Point).Div", Method, 0, ""},
+ {"(Point).Eq", Method, 0, ""},
+ {"(Point).In", Method, 0, ""},
+ {"(Point).Mod", Method, 0, ""},
+ {"(Point).Mul", Method, 0, ""},
+ {"(Point).String", Method, 0, ""},
+ {"(Point).Sub", Method, 0, ""},
+ {"(Rectangle).Add", Method, 0, ""},
+ {"(Rectangle).At", Method, 5, ""},
+ {"(Rectangle).Bounds", Method, 5, ""},
+ {"(Rectangle).Canon", Method, 0, ""},
+ {"(Rectangle).ColorModel", Method, 5, ""},
+ {"(Rectangle).Dx", Method, 0, ""},
+ {"(Rectangle).Dy", Method, 0, ""},
+ {"(Rectangle).Empty", Method, 0, ""},
+ {"(Rectangle).Eq", Method, 0, ""},
+ {"(Rectangle).In", Method, 0, ""},
+ {"(Rectangle).Inset", Method, 0, ""},
+ {"(Rectangle).Intersect", Method, 0, ""},
+ {"(Rectangle).Overlaps", Method, 0, ""},
+ {"(Rectangle).RGBA64At", Method, 17, ""},
+ {"(Rectangle).Size", Method, 0, ""},
+ {"(Rectangle).String", Method, 0, ""},
+ {"(Rectangle).Sub", Method, 0, ""},
+ {"(Rectangle).Union", Method, 0, ""},
+ {"(YCbCrSubsampleRatio).String", Method, 0, ""},
+ {"Alpha", Type, 0, ""},
+ {"Alpha.Pix", Field, 0, ""},
+ {"Alpha.Rect", Field, 0, ""},
+ {"Alpha.Stride", Field, 0, ""},
+ {"Alpha16", Type, 0, ""},
+ {"Alpha16.Pix", Field, 0, ""},
+ {"Alpha16.Rect", Field, 0, ""},
+ {"Alpha16.Stride", Field, 0, ""},
+ {"Black", Var, 0, ""},
+ {"CMYK", Type, 5, ""},
+ {"CMYK.Pix", Field, 5, ""},
+ {"CMYK.Rect", Field, 5, ""},
+ {"CMYK.Stride", Field, 5, ""},
+ {"Config", Type, 0, ""},
+ {"Config.ColorModel", Field, 0, ""},
+ {"Config.Height", Field, 0, ""},
+ {"Config.Width", Field, 0, ""},
+ {"Decode", Func, 0, "func(r io.Reader) (Image, string, error)"},
+ {"DecodeConfig", Func, 0, "func(r io.Reader) (Config, string, error)"},
+ {"ErrFormat", Var, 0, ""},
+ {"Gray", Type, 0, ""},
+ {"Gray.Pix", Field, 0, ""},
+ {"Gray.Rect", Field, 0, ""},
+ {"Gray.Stride", Field, 0, ""},
+ {"Gray16", Type, 0, ""},
+ {"Gray16.Pix", Field, 0, ""},
+ {"Gray16.Rect", Field, 0, ""},
+ {"Gray16.Stride", Field, 0, ""},
+ {"Image", Type, 0, ""},
+ {"NRGBA", Type, 0, ""},
+ {"NRGBA.Pix", Field, 0, ""},
+ {"NRGBA.Rect", Field, 0, ""},
+ {"NRGBA.Stride", Field, 0, ""},
+ {"NRGBA64", Type, 0, ""},
+ {"NRGBA64.Pix", Field, 0, ""},
+ {"NRGBA64.Rect", Field, 0, ""},
+ {"NRGBA64.Stride", Field, 0, ""},
+ {"NYCbCrA", Type, 6, ""},
+ {"NYCbCrA.A", Field, 6, ""},
+ {"NYCbCrA.AStride", Field, 6, ""},
+ {"NYCbCrA.YCbCr", Field, 6, ""},
+ {"NewAlpha", Func, 0, "func(r Rectangle) *Alpha"},
+ {"NewAlpha16", Func, 0, "func(r Rectangle) *Alpha16"},
+ {"NewCMYK", Func, 5, "func(r Rectangle) *CMYK"},
+ {"NewGray", Func, 0, "func(r Rectangle) *Gray"},
+ {"NewGray16", Func, 0, "func(r Rectangle) *Gray16"},
+ {"NewNRGBA", Func, 0, "func(r Rectangle) *NRGBA"},
+ {"NewNRGBA64", Func, 0, "func(r Rectangle) *NRGBA64"},
+ {"NewNYCbCrA", Func, 6, "func(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *NYCbCrA"},
+ {"NewPaletted", Func, 0, "func(r Rectangle, p color.Palette) *Paletted"},
+ {"NewRGBA", Func, 0, "func(r Rectangle) *RGBA"},
+ {"NewRGBA64", Func, 0, "func(r Rectangle) *RGBA64"},
+ {"NewUniform", Func, 0, "func(c color.Color) *Uniform"},
+ {"NewYCbCr", Func, 0, "func(r Rectangle, subsampleRatio YCbCrSubsampleRatio) *YCbCr"},
+ {"Opaque", Var, 0, ""},
+ {"Paletted", Type, 0, ""},
+ {"Paletted.Palette", Field, 0, ""},
+ {"Paletted.Pix", Field, 0, ""},
+ {"Paletted.Rect", Field, 0, ""},
+ {"Paletted.Stride", Field, 0, ""},
+ {"PalettedImage", Type, 0, ""},
+ {"Point", Type, 0, ""},
+ {"Point.X", Field, 0, ""},
+ {"Point.Y", Field, 0, ""},
+ {"Pt", Func, 0, "func(X int, Y int) Point"},
+ {"RGBA", Type, 0, ""},
+ {"RGBA.Pix", Field, 0, ""},
+ {"RGBA.Rect", Field, 0, ""},
+ {"RGBA.Stride", Field, 0, ""},
+ {"RGBA64", Type, 0, ""},
+ {"RGBA64.Pix", Field, 0, ""},
+ {"RGBA64.Rect", Field, 0, ""},
+ {"RGBA64.Stride", Field, 0, ""},
+ {"RGBA64Image", Type, 17, ""},
+ {"Rect", Func, 0, "func(x0 int, y0 int, x1 int, y1 int) Rectangle"},
+ {"Rectangle", Type, 0, ""},
+ {"Rectangle.Max", Field, 0, ""},
+ {"Rectangle.Min", Field, 0, ""},
+ {"RegisterFormat", Func, 0, "func(name string, magic string, decode func(io.Reader) (Image, error), decodeConfig func(io.Reader) (Config, error))"},
+ {"Transparent", Var, 0, ""},
+ {"Uniform", Type, 0, ""},
+ {"Uniform.C", Field, 0, ""},
+ {"White", Var, 0, ""},
+ {"YCbCr", Type, 0, ""},
+ {"YCbCr.CStride", Field, 0, ""},
+ {"YCbCr.Cb", Field, 0, ""},
+ {"YCbCr.Cr", Field, 0, ""},
+ {"YCbCr.Rect", Field, 0, ""},
+ {"YCbCr.SubsampleRatio", Field, 0, ""},
+ {"YCbCr.Y", Field, 0, ""},
+ {"YCbCr.YStride", Field, 0, ""},
+ {"YCbCrSubsampleRatio", Type, 0, ""},
+ {"YCbCrSubsampleRatio410", Const, 5, ""},
+ {"YCbCrSubsampleRatio411", Const, 5, ""},
+ {"YCbCrSubsampleRatio420", Const, 0, ""},
+ {"YCbCrSubsampleRatio422", Const, 0, ""},
+ {"YCbCrSubsampleRatio440", Const, 1, ""},
+ {"YCbCrSubsampleRatio444", Const, 0, ""},
+ {"ZP", Var, 0, ""},
+ {"ZR", Var, 0, ""},
+ },
+ "image/color": {
+ {"(Alpha).RGBA", Method, 0, ""},
+ {"(Alpha16).RGBA", Method, 0, ""},
+ {"(CMYK).RGBA", Method, 5, ""},
+ {"(Gray).RGBA", Method, 0, ""},
+ {"(Gray16).RGBA", Method, 0, ""},
+ {"(NRGBA).RGBA", Method, 0, ""},
+ {"(NRGBA64).RGBA", Method, 0, ""},
+ {"(NYCbCrA).RGBA", Method, 6, ""},
+ {"(Palette).Convert", Method, 0, ""},
+ {"(Palette).Index", Method, 0, ""},
+ {"(RGBA).RGBA", Method, 0, ""},
+ {"(RGBA64).RGBA", Method, 0, ""},
+ {"(YCbCr).RGBA", Method, 0, ""},
+ {"Alpha", Type, 0, ""},
+ {"Alpha.A", Field, 0, ""},
+ {"Alpha16", Type, 0, ""},
+ {"Alpha16.A", Field, 0, ""},
+ {"Alpha16Model", Var, 0, ""},
+ {"AlphaModel", Var, 0, ""},
+ {"Black", Var, 0, ""},
+ {"CMYK", Type, 5, ""},
+ {"CMYK.C", Field, 5, ""},
+ {"CMYK.K", Field, 5, ""},
+ {"CMYK.M", Field, 5, ""},
+ {"CMYK.Y", Field, 5, ""},
+ {"CMYKModel", Var, 5, ""},
+ {"CMYKToRGB", Func, 5, "func(c uint8, m uint8, y uint8, k uint8) (uint8, uint8, uint8)"},
+ {"Color", Type, 0, ""},
+ {"Gray", Type, 0, ""},
+ {"Gray.Y", Field, 0, ""},
+ {"Gray16", Type, 0, ""},
+ {"Gray16.Y", Field, 0, ""},
+ {"Gray16Model", Var, 0, ""},
+ {"GrayModel", Var, 0, ""},
+ {"Model", Type, 0, ""},
+ {"ModelFunc", Func, 0, "func(f func(Color) Color) Model"},
+ {"NRGBA", Type, 0, ""},
+ {"NRGBA.A", Field, 0, ""},
+ {"NRGBA.B", Field, 0, ""},
+ {"NRGBA.G", Field, 0, ""},
+ {"NRGBA.R", Field, 0, ""},
+ {"NRGBA64", Type, 0, ""},
+ {"NRGBA64.A", Field, 0, ""},
+ {"NRGBA64.B", Field, 0, ""},
+ {"NRGBA64.G", Field, 0, ""},
+ {"NRGBA64.R", Field, 0, ""},
+ {"NRGBA64Model", Var, 0, ""},
+ {"NRGBAModel", Var, 0, ""},
+ {"NYCbCrA", Type, 6, ""},
+ {"NYCbCrA.A", Field, 6, ""},
+ {"NYCbCrA.YCbCr", Field, 6, ""},
+ {"NYCbCrAModel", Var, 6, ""},
+ {"Opaque", Var, 0, ""},
+ {"Palette", Type, 0, ""},
+ {"RGBA", Type, 0, ""},
+ {"RGBA.A", Field, 0, ""},
+ {"RGBA.B", Field, 0, ""},
+ {"RGBA.G", Field, 0, ""},
+ {"RGBA.R", Field, 0, ""},
+ {"RGBA64", Type, 0, ""},
+ {"RGBA64.A", Field, 0, ""},
+ {"RGBA64.B", Field, 0, ""},
+ {"RGBA64.G", Field, 0, ""},
+ {"RGBA64.R", Field, 0, ""},
+ {"RGBA64Model", Var, 0, ""},
+ {"RGBAModel", Var, 0, ""},
+ {"RGBToCMYK", Func, 5, "func(r uint8, g uint8, b uint8) (uint8, uint8, uint8, uint8)"},
+ {"RGBToYCbCr", Func, 0, "func(r uint8, g uint8, b uint8) (uint8, uint8, uint8)"},
+ {"Transparent", Var, 0, ""},
+ {"White", Var, 0, ""},
+ {"YCbCr", Type, 0, ""},
+ {"YCbCr.Cb", Field, 0, ""},
+ {"YCbCr.Cr", Field, 0, ""},
+ {"YCbCr.Y", Field, 0, ""},
+ {"YCbCrModel", Var, 0, ""},
+ {"YCbCrToRGB", Func, 0, "func(y uint8, cb uint8, cr uint8) (uint8, uint8, uint8)"},
+ },
+ "image/color/palette": {
+ {"Plan9", Var, 2, ""},
+ {"WebSafe", Var, 2, ""},
+ },
+ "image/draw": {
+ {"(Op).Draw", Method, 2, ""},
+ {"Draw", Func, 0, "func(dst Image, r image.Rectangle, src image.Image, sp image.Point, op Op)"},
+ {"DrawMask", Func, 0, "func(dst Image, r image.Rectangle, src image.Image, sp image.Point, mask image.Image, mp image.Point, op Op)"},
+ {"Drawer", Type, 2, ""},
+ {"FloydSteinberg", Var, 2, ""},
+ {"Image", Type, 0, ""},
+ {"Op", Type, 0, ""},
+ {"Over", Const, 0, ""},
+ {"Quantizer", Type, 2, ""},
+ {"RGBA64Image", Type, 17, ""},
+ {"Src", Const, 0, ""},
+ },
+ "image/gif": {
+ {"Decode", Func, 0, "func(r io.Reader) (image.Image, error)"},
+ {"DecodeAll", Func, 0, "func(r io.Reader) (*GIF, error)"},
+ {"DecodeConfig", Func, 0, "func(r io.Reader) (image.Config, error)"},
+ {"DisposalBackground", Const, 5, ""},
+ {"DisposalNone", Const, 5, ""},
+ {"DisposalPrevious", Const, 5, ""},
+ {"Encode", Func, 2, "func(w io.Writer, m image.Image, o *Options) error"},
+ {"EncodeAll", Func, 2, "func(w io.Writer, g *GIF) error"},
+ {"GIF", Type, 0, ""},
+ {"GIF.BackgroundIndex", Field, 5, ""},
+ {"GIF.Config", Field, 5, ""},
+ {"GIF.Delay", Field, 0, ""},
+ {"GIF.Disposal", Field, 5, ""},
+ {"GIF.Image", Field, 0, ""},
+ {"GIF.LoopCount", Field, 0, ""},
+ {"Options", Type, 2, ""},
+ {"Options.Drawer", Field, 2, ""},
+ {"Options.NumColors", Field, 2, ""},
+ {"Options.Quantizer", Field, 2, ""},
+ },
+ "image/jpeg": {
+ {"(FormatError).Error", Method, 0, ""},
+ {"(UnsupportedError).Error", Method, 0, ""},
+ {"Decode", Func, 0, "func(r io.Reader) (image.Image, error)"},
+ {"DecodeConfig", Func, 0, "func(r io.Reader) (image.Config, error)"},
+ {"DefaultQuality", Const, 0, ""},
+ {"Encode", Func, 0, "func(w io.Writer, m image.Image, o *Options) error"},
+ {"FormatError", Type, 0, ""},
+ {"Options", Type, 0, ""},
+ {"Options.Quality", Field, 0, ""},
+ {"Reader", Type, 0, ""},
+ {"UnsupportedError", Type, 0, ""},
+ },
+ "image/png": {
+ {"(*Encoder).Encode", Method, 4, ""},
+ {"(FormatError).Error", Method, 0, ""},
+ {"(UnsupportedError).Error", Method, 0, ""},
+ {"BestCompression", Const, 4, ""},
+ {"BestSpeed", Const, 4, ""},
+ {"CompressionLevel", Type, 4, ""},
+ {"Decode", Func, 0, "func(r io.Reader) (image.Image, error)"},
+ {"DecodeConfig", Func, 0, "func(r io.Reader) (image.Config, error)"},
+ {"DefaultCompression", Const, 4, ""},
+ {"Encode", Func, 0, "func(w io.Writer, m image.Image) error"},
+ {"Encoder", Type, 4, ""},
+ {"Encoder.BufferPool", Field, 9, ""},
+ {"Encoder.CompressionLevel", Field, 4, ""},
+ {"EncoderBuffer", Type, 9, ""},
+ {"EncoderBufferPool", Type, 9, ""},
+ {"FormatError", Type, 0, ""},
+ {"NoCompression", Const, 4, ""},
+ {"UnsupportedError", Type, 0, ""},
+ },
+ "index/suffixarray": {
+ {"(*Index).Bytes", Method, 0, ""},
+ {"(*Index).FindAllIndex", Method, 0, ""},
+ {"(*Index).Lookup", Method, 0, ""},
+ {"(*Index).Read", Method, 0, ""},
+ {"(*Index).Write", Method, 0, ""},
+ {"Index", Type, 0, ""},
+ {"New", Func, 0, "func(data []byte) *Index"},
+ },
+ "io": {
+ {"(*LimitedReader).Read", Method, 0, ""},
+ {"(*OffsetWriter).Seek", Method, 20, ""},
+ {"(*OffsetWriter).Write", Method, 20, ""},
+ {"(*OffsetWriter).WriteAt", Method, 20, ""},
+ {"(*PipeReader).Close", Method, 0, ""},
+ {"(*PipeReader).CloseWithError", Method, 0, ""},
+ {"(*PipeReader).Read", Method, 0, ""},
+ {"(*PipeWriter).Close", Method, 0, ""},
+ {"(*PipeWriter).CloseWithError", Method, 0, ""},
+ {"(*PipeWriter).Write", Method, 0, ""},
+ {"(*SectionReader).Outer", Method, 22, ""},
+ {"(*SectionReader).Read", Method, 0, ""},
+ {"(*SectionReader).ReadAt", Method, 0, ""},
+ {"(*SectionReader).Seek", Method, 0, ""},
+ {"(*SectionReader).Size", Method, 0, ""},
+ {"ByteReader", Type, 0, ""},
+ {"ByteScanner", Type, 0, ""},
+ {"ByteWriter", Type, 1, ""},
+ {"Closer", Type, 0, ""},
+ {"Copy", Func, 0, "func(dst Writer, src Reader) (written int64, err error)"},
+ {"CopyBuffer", Func, 5, "func(dst Writer, src Reader, buf []byte) (written int64, err error)"},
+ {"CopyN", Func, 0, "func(dst Writer, src Reader, n int64) (written int64, err error)"},
+ {"Discard", Var, 16, ""},
+ {"EOF", Var, 0, ""},
+ {"ErrClosedPipe", Var, 0, ""},
+ {"ErrNoProgress", Var, 1, ""},
+ {"ErrShortBuffer", Var, 0, ""},
+ {"ErrShortWrite", Var, 0, ""},
+ {"ErrUnexpectedEOF", Var, 0, ""},
+ {"LimitReader", Func, 0, "func(r Reader, n int64) Reader"},
+ {"LimitedReader", Type, 0, ""},
+ {"LimitedReader.N", Field, 0, ""},
+ {"LimitedReader.R", Field, 0, ""},
+ {"MultiReader", Func, 0, "func(readers ...Reader) Reader"},
+ {"MultiWriter", Func, 0, "func(writers ...Writer) Writer"},
+ {"NewOffsetWriter", Func, 20, "func(w WriterAt, off int64) *OffsetWriter"},
+ {"NewSectionReader", Func, 0, "func(r ReaderAt, off int64, n int64) *SectionReader"},
+ {"NopCloser", Func, 16, "func(r Reader) ReadCloser"},
+ {"OffsetWriter", Type, 20, ""},
+ {"Pipe", Func, 0, "func() (*PipeReader, *PipeWriter)"},
+ {"PipeReader", Type, 0, ""},
+ {"PipeWriter", Type, 0, ""},
+ {"ReadAll", Func, 16, "func(r Reader) ([]byte, error)"},
+ {"ReadAtLeast", Func, 0, "func(r Reader, buf []byte, min int) (n int, err error)"},
+ {"ReadCloser", Type, 0, ""},
+ {"ReadFull", Func, 0, "func(r Reader, buf []byte) (n int, err error)"},
+ {"ReadSeekCloser", Type, 16, ""},
+ {"ReadSeeker", Type, 0, ""},
+ {"ReadWriteCloser", Type, 0, ""},
+ {"ReadWriteSeeker", Type, 0, ""},
+ {"ReadWriter", Type, 0, ""},
+ {"Reader", Type, 0, ""},
+ {"ReaderAt", Type, 0, ""},
+ {"ReaderFrom", Type, 0, ""},
+ {"RuneReader", Type, 0, ""},
+ {"RuneScanner", Type, 0, ""},
+ {"SectionReader", Type, 0, ""},
+ {"SeekCurrent", Const, 7, ""},
+ {"SeekEnd", Const, 7, ""},
+ {"SeekStart", Const, 7, ""},
+ {"Seeker", Type, 0, ""},
+ {"StringWriter", Type, 12, ""},
+ {"TeeReader", Func, 0, "func(r Reader, w Writer) Reader"},
+ {"WriteCloser", Type, 0, ""},
+ {"WriteSeeker", Type, 0, ""},
+ {"WriteString", Func, 0, "func(w Writer, s string) (n int, err error)"},
+ {"Writer", Type, 0, ""},
+ {"WriterAt", Type, 0, ""},
+ {"WriterTo", Type, 0, ""},
+ },
+ "io/fs": {
+ {"(*PathError).Error", Method, 16, ""},
+ {"(*PathError).Timeout", Method, 16, ""},
+ {"(*PathError).Unwrap", Method, 16, ""},
+ {"(FileMode).IsDir", Method, 16, ""},
+ {"(FileMode).IsRegular", Method, 16, ""},
+ {"(FileMode).Perm", Method, 16, ""},
+ {"(FileMode).String", Method, 16, ""},
+ {"(FileMode).Type", Method, 16, ""},
+ {"DirEntry", Type, 16, ""},
+ {"ErrClosed", Var, 16, ""},
+ {"ErrExist", Var, 16, ""},
+ {"ErrInvalid", Var, 16, ""},
+ {"ErrNotExist", Var, 16, ""},
+ {"ErrPermission", Var, 16, ""},
+ {"FS", Type, 16, ""},
+ {"File", Type, 16, ""},
+ {"FileInfo", Type, 16, ""},
+ {"FileInfoToDirEntry", Func, 17, "func(info FileInfo) DirEntry"},
+ {"FileMode", Type, 16, ""},
+ {"FormatDirEntry", Func, 21, "func(dir DirEntry) string"},
+ {"FormatFileInfo", Func, 21, "func(info FileInfo) string"},
+ {"Glob", Func, 16, "func(fsys FS, pattern string) (matches []string, err error)"},
+ {"GlobFS", Type, 16, ""},
+ {"Lstat", Func, 25, ""},
+ {"ModeAppend", Const, 16, ""},
+ {"ModeCharDevice", Const, 16, ""},
+ {"ModeDevice", Const, 16, ""},
+ {"ModeDir", Const, 16, ""},
+ {"ModeExclusive", Const, 16, ""},
+ {"ModeIrregular", Const, 16, ""},
+ {"ModeNamedPipe", Const, 16, ""},
+ {"ModePerm", Const, 16, ""},
+ {"ModeSetgid", Const, 16, ""},
+ {"ModeSetuid", Const, 16, ""},
+ {"ModeSocket", Const, 16, ""},
+ {"ModeSticky", Const, 16, ""},
+ {"ModeSymlink", Const, 16, ""},
+ {"ModeTemporary", Const, 16, ""},
+ {"ModeType", Const, 16, ""},
+ {"PathError", Type, 16, ""},
+ {"PathError.Err", Field, 16, ""},
+ {"PathError.Op", Field, 16, ""},
+ {"PathError.Path", Field, 16, ""},
+ {"ReadDir", Func, 16, "func(fsys FS, name string) ([]DirEntry, error)"},
+ {"ReadDirFS", Type, 16, ""},
+ {"ReadDirFile", Type, 16, ""},
+ {"ReadFile", Func, 16, "func(fsys FS, name string) ([]byte, error)"},
+ {"ReadFileFS", Type, 16, ""},
+ {"ReadLink", Func, 25, ""},
+ {"ReadLinkFS", Type, 25, ""},
+ {"SkipAll", Var, 20, ""},
+ {"SkipDir", Var, 16, ""},
+ {"Stat", Func, 16, "func(fsys FS, name string) (FileInfo, error)"},
+ {"StatFS", Type, 16, ""},
+ {"Sub", Func, 16, "func(fsys FS, dir string) (FS, error)"},
+ {"SubFS", Type, 16, ""},
+ {"ValidPath", Func, 16, "func(name string) bool"},
+ {"WalkDir", Func, 16, "func(fsys FS, root string, fn WalkDirFunc) error"},
+ {"WalkDirFunc", Type, 16, ""},
+ },
+ "io/ioutil": {
+ {"Discard", Var, 0, ""},
+ {"NopCloser", Func, 0, "func(r io.Reader) io.ReadCloser"},
+ {"ReadAll", Func, 0, "func(r io.Reader) ([]byte, error)"},
+ {"ReadDir", Func, 0, "func(dirname string) ([]fs.FileInfo, error)"},
+ {"ReadFile", Func, 0, "func(filename string) ([]byte, error)"},
+ {"TempDir", Func, 0, "func(dir string, pattern string) (name string, err error)"},
+ {"TempFile", Func, 0, "func(dir string, pattern string) (f *os.File, err error)"},
+ {"WriteFile", Func, 0, "func(filename string, data []byte, perm fs.FileMode) error"},
+ },
+ "iter": {
+ {"Pull", Func, 23, "func[V any](seq Seq[V]) (next func() (V, bool), stop func())"},
+ {"Pull2", Func, 23, "func[K, V any](seq Seq2[K, V]) (next func() (K, V, bool), stop func())"},
+ {"Seq", Type, 23, ""},
+ {"Seq2", Type, 23, ""},
+ },
+ "log": {
+ {"(*Logger).Fatal", Method, 0, ""},
+ {"(*Logger).Fatalf", Method, 0, ""},
+ {"(*Logger).Fatalln", Method, 0, ""},
+ {"(*Logger).Flags", Method, 0, ""},
+ {"(*Logger).Output", Method, 0, ""},
+ {"(*Logger).Panic", Method, 0, ""},
+ {"(*Logger).Panicf", Method, 0, ""},
+ {"(*Logger).Panicln", Method, 0, ""},
+ {"(*Logger).Prefix", Method, 0, ""},
+ {"(*Logger).Print", Method, 0, ""},
+ {"(*Logger).Printf", Method, 0, ""},
+ {"(*Logger).Println", Method, 0, ""},
+ {"(*Logger).SetFlags", Method, 0, ""},
+ {"(*Logger).SetOutput", Method, 5, ""},
+ {"(*Logger).SetPrefix", Method, 0, ""},
+ {"(*Logger).Writer", Method, 12, ""},
+ {"Default", Func, 16, "func() *Logger"},
+ {"Fatal", Func, 0, "func(v ...any)"},
+ {"Fatalf", Func, 0, "func(format string, v ...any)"},
+ {"Fatalln", Func, 0, "func(v ...any)"},
+ {"Flags", Func, 0, "func() int"},
+ {"LUTC", Const, 5, ""},
+ {"Ldate", Const, 0, ""},
+ {"Llongfile", Const, 0, ""},
+ {"Lmicroseconds", Const, 0, ""},
+ {"Lmsgprefix", Const, 14, ""},
+ {"Logger", Type, 0, ""},
+ {"Lshortfile", Const, 0, ""},
+ {"LstdFlags", Const, 0, ""},
+ {"Ltime", Const, 0, ""},
+ {"New", Func, 0, "func(out io.Writer, prefix string, flag int) *Logger"},
+ {"Output", Func, 5, "func(calldepth int, s string) error"},
+ {"Panic", Func, 0, "func(v ...any)"},
+ {"Panicf", Func, 0, "func(format string, v ...any)"},
+ {"Panicln", Func, 0, "func(v ...any)"},
+ {"Prefix", Func, 0, "func() string"},
+ {"Print", Func, 0, "func(v ...any)"},
+ {"Printf", Func, 0, "func(format string, v ...any)"},
+ {"Println", Func, 0, "func(v ...any)"},
+ {"SetFlags", Func, 0, "func(flag int)"},
+ {"SetOutput", Func, 0, "func(w io.Writer)"},
+ {"SetPrefix", Func, 0, "func(prefix string)"},
+ {"Writer", Func, 13, "func() io.Writer"},
+ },
+ "log/slog": {
+ {"(*JSONHandler).Enabled", Method, 21, ""},
+ {"(*JSONHandler).Handle", Method, 21, ""},
+ {"(*JSONHandler).WithAttrs", Method, 21, ""},
+ {"(*JSONHandler).WithGroup", Method, 21, ""},
+ {"(*Level).UnmarshalJSON", Method, 21, ""},
+ {"(*Level).UnmarshalText", Method, 21, ""},
+ {"(*LevelVar).AppendText", Method, 24, ""},
+ {"(*LevelVar).Level", Method, 21, ""},
+ {"(*LevelVar).MarshalText", Method, 21, ""},
+ {"(*LevelVar).Set", Method, 21, ""},
+ {"(*LevelVar).String", Method, 21, ""},
+ {"(*LevelVar).UnmarshalText", Method, 21, ""},
+ {"(*Logger).Debug", Method, 21, ""},
+ {"(*Logger).DebugContext", Method, 21, ""},
+ {"(*Logger).Enabled", Method, 21, ""},
+ {"(*Logger).Error", Method, 21, ""},
+ {"(*Logger).ErrorContext", Method, 21, ""},
+ {"(*Logger).Handler", Method, 21, ""},
+ {"(*Logger).Info", Method, 21, ""},
+ {"(*Logger).InfoContext", Method, 21, ""},
+ {"(*Logger).Log", Method, 21, ""},
+ {"(*Logger).LogAttrs", Method, 21, ""},
+ {"(*Logger).Warn", Method, 21, ""},
+ {"(*Logger).WarnContext", Method, 21, ""},
+ {"(*Logger).With", Method, 21, ""},
+ {"(*Logger).WithGroup", Method, 21, ""},
+ {"(*Record).Add", Method, 21, ""},
+ {"(*Record).AddAttrs", Method, 21, ""},
+ {"(*TextHandler).Enabled", Method, 21, ""},
+ {"(*TextHandler).Handle", Method, 21, ""},
+ {"(*TextHandler).WithAttrs", Method, 21, ""},
+ {"(*TextHandler).WithGroup", Method, 21, ""},
+ {"(Attr).Equal", Method, 21, ""},
+ {"(Attr).String", Method, 21, ""},
+ {"(Kind).String", Method, 21, ""},
+ {"(Level).AppendText", Method, 24, ""},
+ {"(Level).Level", Method, 21, ""},
+ {"(Level).MarshalJSON", Method, 21, ""},
+ {"(Level).MarshalText", Method, 21, ""},
+ {"(Level).String", Method, 21, ""},
+ {"(Record).Attrs", Method, 21, ""},
+ {"(Record).Clone", Method, 21, ""},
+ {"(Record).NumAttrs", Method, 21, ""},
+ {"(Value).Any", Method, 21, ""},
+ {"(Value).Bool", Method, 21, ""},
+ {"(Value).Duration", Method, 21, ""},
+ {"(Value).Equal", Method, 21, ""},
+ {"(Value).Float64", Method, 21, ""},
+ {"(Value).Group", Method, 21, ""},
+ {"(Value).Int64", Method, 21, ""},
+ {"(Value).Kind", Method, 21, ""},
+ {"(Value).LogValuer", Method, 21, ""},
+ {"(Value).Resolve", Method, 21, ""},
+ {"(Value).String", Method, 21, ""},
+ {"(Value).Time", Method, 21, ""},
+ {"(Value).Uint64", Method, 21, ""},
+ {"Any", Func, 21, "func(key string, value any) Attr"},
+ {"AnyValue", Func, 21, "func(v any) Value"},
+ {"Attr", Type, 21, ""},
+ {"Attr.Key", Field, 21, ""},
+ {"Attr.Value", Field, 21, ""},
+ {"Bool", Func, 21, "func(key string, v bool) Attr"},
+ {"BoolValue", Func, 21, "func(v bool) Value"},
+ {"Debug", Func, 21, "func(msg string, args ...any)"},
+ {"DebugContext", Func, 21, "func(ctx context.Context, msg string, args ...any)"},
+ {"Default", Func, 21, "func() *Logger"},
+ {"DiscardHandler", Var, 24, ""},
+ {"Duration", Func, 21, "func(key string, v time.Duration) Attr"},
+ {"DurationValue", Func, 21, "func(v time.Duration) Value"},
+ {"Error", Func, 21, "func(msg string, args ...any)"},
+ {"ErrorContext", Func, 21, "func(ctx context.Context, msg string, args ...any)"},
+ {"Float64", Func, 21, "func(key string, v float64) Attr"},
+ {"Float64Value", Func, 21, "func(v float64) Value"},
+ {"Group", Func, 21, "func(key string, args ...any) Attr"},
+ {"GroupValue", Func, 21, "func(as ...Attr) Value"},
+ {"Handler", Type, 21, ""},
+ {"HandlerOptions", Type, 21, ""},
+ {"HandlerOptions.AddSource", Field, 21, ""},
+ {"HandlerOptions.Level", Field, 21, ""},
+ {"HandlerOptions.ReplaceAttr", Field, 21, ""},
+ {"Info", Func, 21, "func(msg string, args ...any)"},
+ {"InfoContext", Func, 21, "func(ctx context.Context, msg string, args ...any)"},
+ {"Int", Func, 21, "func(key string, value int) Attr"},
+ {"Int64", Func, 21, "func(key string, value int64) Attr"},
+ {"Int64Value", Func, 21, "func(v int64) Value"},
+ {"IntValue", Func, 21, "func(v int) Value"},
+ {"JSONHandler", Type, 21, ""},
+ {"Kind", Type, 21, ""},
+ {"KindAny", Const, 21, ""},
+ {"KindBool", Const, 21, ""},
+ {"KindDuration", Const, 21, ""},
+ {"KindFloat64", Const, 21, ""},
+ {"KindGroup", Const, 21, ""},
+ {"KindInt64", Const, 21, ""},
+ {"KindLogValuer", Const, 21, ""},
+ {"KindString", Const, 21, ""},
+ {"KindTime", Const, 21, ""},
+ {"KindUint64", Const, 21, ""},
+ {"Level", Type, 21, ""},
+ {"LevelDebug", Const, 21, ""},
+ {"LevelError", Const, 21, ""},
+ {"LevelInfo", Const, 21, ""},
+ {"LevelKey", Const, 21, ""},
+ {"LevelVar", Type, 21, ""},
+ {"LevelWarn", Const, 21, ""},
+ {"Leveler", Type, 21, ""},
+ {"Log", Func, 21, "func(ctx context.Context, level Level, msg string, args ...any)"},
+ {"LogAttrs", Func, 21, "func(ctx context.Context, level Level, msg string, attrs ...Attr)"},
+ {"LogValuer", Type, 21, ""},
+ {"Logger", Type, 21, ""},
+ {"MessageKey", Const, 21, ""},
+ {"New", Func, 21, "func(h Handler) *Logger"},
+ {"NewJSONHandler", Func, 21, "func(w io.Writer, opts *HandlerOptions) *JSONHandler"},
+ {"NewLogLogger", Func, 21, "func(h Handler, level Level) *log.Logger"},
+ {"NewRecord", Func, 21, "func(t time.Time, level Level, msg string, pc uintptr) Record"},
+ {"NewTextHandler", Func, 21, "func(w io.Writer, opts *HandlerOptions) *TextHandler"},
+ {"Record", Type, 21, ""},
+ {"Record.Level", Field, 21, ""},
+ {"Record.Message", Field, 21, ""},
+ {"Record.PC", Field, 21, ""},
+ {"Record.Time", Field, 21, ""},
+ {"SetDefault", Func, 21, "func(l *Logger)"},
+ {"SetLogLoggerLevel", Func, 22, "func(level Level) (oldLevel Level)"},
+ {"Source", Type, 21, ""},
+ {"Source.File", Field, 21, ""},
+ {"Source.Function", Field, 21, ""},
+ {"Source.Line", Field, 21, ""},
+ {"SourceKey", Const, 21, ""},
+ {"String", Func, 21, "func(key string, value string) Attr"},
+ {"StringValue", Func, 21, "func(value string) Value"},
+ {"TextHandler", Type, 21, ""},
+ {"Time", Func, 21, "func(key string, v time.Time) Attr"},
+ {"TimeKey", Const, 21, ""},
+ {"TimeValue", Func, 21, "func(v time.Time) Value"},
+ {"Uint64", Func, 21, "func(key string, v uint64) Attr"},
+ {"Uint64Value", Func, 21, "func(v uint64) Value"},
+ {"Value", Type, 21, ""},
+ {"Warn", Func, 21, "func(msg string, args ...any)"},
+ {"WarnContext", Func, 21, "func(ctx context.Context, msg string, args ...any)"},
+ {"With", Func, 21, "func(args ...any) *Logger"},
+ },
+ "log/syslog": {
+ {"(*Writer).Alert", Method, 0, ""},
+ {"(*Writer).Close", Method, 0, ""},
+ {"(*Writer).Crit", Method, 0, ""},
+ {"(*Writer).Debug", Method, 0, ""},
+ {"(*Writer).Emerg", Method, 0, ""},
+ {"(*Writer).Err", Method, 0, ""},
+ {"(*Writer).Info", Method, 0, ""},
+ {"(*Writer).Notice", Method, 0, ""},
+ {"(*Writer).Warning", Method, 0, ""},
+ {"(*Writer).Write", Method, 0, ""},
+ {"Dial", Func, 0, "func(network string, raddr string, priority Priority, tag string) (*Writer, error)"},
+ {"LOG_ALERT", Const, 0, ""},
+ {"LOG_AUTH", Const, 1, ""},
+ {"LOG_AUTHPRIV", Const, 1, ""},
+ {"LOG_CRIT", Const, 0, ""},
+ {"LOG_CRON", Const, 1, ""},
+ {"LOG_DAEMON", Const, 1, ""},
+ {"LOG_DEBUG", Const, 0, ""},
+ {"LOG_EMERG", Const, 0, ""},
+ {"LOG_ERR", Const, 0, ""},
+ {"LOG_FTP", Const, 1, ""},
+ {"LOG_INFO", Const, 0, ""},
+ {"LOG_KERN", Const, 1, ""},
+ {"LOG_LOCAL0", Const, 1, ""},
+ {"LOG_LOCAL1", Const, 1, ""},
+ {"LOG_LOCAL2", Const, 1, ""},
+ {"LOG_LOCAL3", Const, 1, ""},
+ {"LOG_LOCAL4", Const, 1, ""},
+ {"LOG_LOCAL5", Const, 1, ""},
+ {"LOG_LOCAL6", Const, 1, ""},
+ {"LOG_LOCAL7", Const, 1, ""},
+ {"LOG_LPR", Const, 1, ""},
+ {"LOG_MAIL", Const, 1, ""},
+ {"LOG_NEWS", Const, 1, ""},
+ {"LOG_NOTICE", Const, 0, ""},
+ {"LOG_SYSLOG", Const, 1, ""},
+ {"LOG_USER", Const, 1, ""},
+ {"LOG_UUCP", Const, 1, ""},
+ {"LOG_WARNING", Const, 0, ""},
+ {"New", Func, 0, "func(priority Priority, tag string) (*Writer, error)"},
+ {"NewLogger", Func, 0, "func(p Priority, logFlag int) (*log.Logger, error)"},
+ {"Priority", Type, 0, ""},
+ {"Writer", Type, 0, ""},
+ },
+ "maps": {
+ {"All", Func, 23, "func[Map ~map[K]V, K comparable, V any](m Map) iter.Seq2[K, V]"},
+ {"Clone", Func, 21, "func[M ~map[K]V, K comparable, V any](m M) M"},
+ {"Collect", Func, 23, "func[K comparable, V any](seq iter.Seq2[K, V]) map[K]V"},
+ {"Copy", Func, 21, "func[M1 ~map[K]V, M2 ~map[K]V, K comparable, V any](dst M1, src M2)"},
+ {"DeleteFunc", Func, 21, "func[M ~map[K]V, K comparable, V any](m M, del func(K, V) bool)"},
+ {"Equal", Func, 21, "func[M1, M2 ~map[K]V, K, V comparable](m1 M1, m2 M2) bool"},
+ {"EqualFunc", Func, 21, "func[M1 ~map[K]V1, M2 ~map[K]V2, K comparable, V1, V2 any](m1 M1, m2 M2, eq func(V1, V2) bool) bool"},
+ {"Insert", Func, 23, "func[Map ~map[K]V, K comparable, V any](m Map, seq iter.Seq2[K, V])"},
+ {"Keys", Func, 23, "func[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[K]"},
+ {"Values", Func, 23, "func[Map ~map[K]V, K comparable, V any](m Map) iter.Seq[V]"},
+ },
+ "math": {
+ {"Abs", Func, 0, "func(x float64) float64"},
+ {"Acos", Func, 0, "func(x float64) float64"},
+ {"Acosh", Func, 0, "func(x float64) float64"},
+ {"Asin", Func, 0, "func(x float64) float64"},
+ {"Asinh", Func, 0, "func(x float64) float64"},
+ {"Atan", Func, 0, "func(x float64) float64"},
+ {"Atan2", Func, 0, "func(y float64, x float64) float64"},
+ {"Atanh", Func, 0, "func(x float64) float64"},
+ {"Cbrt", Func, 0, "func(x float64) float64"},
+ {"Ceil", Func, 0, "func(x float64) float64"},
+ {"Copysign", Func, 0, "func(f float64, sign float64) float64"},
+ {"Cos", Func, 0, "func(x float64) float64"},
+ {"Cosh", Func, 0, "func(x float64) float64"},
+ {"Dim", Func, 0, "func(x float64, y float64) float64"},
+ {"E", Const, 0, ""},
+ {"Erf", Func, 0, "func(x float64) float64"},
+ {"Erfc", Func, 0, "func(x float64) float64"},
+ {"Erfcinv", Func, 10, "func(x float64) float64"},
+ {"Erfinv", Func, 10, "func(x float64) float64"},
+ {"Exp", Func, 0, "func(x float64) float64"},
+ {"Exp2", Func, 0, "func(x float64) float64"},
+ {"Expm1", Func, 0, "func(x float64) float64"},
+ {"FMA", Func, 14, "func(x float64, y float64, z float64) float64"},
+ {"Float32bits", Func, 0, "func(f float32) uint32"},
+ {"Float32frombits", Func, 0, "func(b uint32) float32"},
+ {"Float64bits", Func, 0, "func(f float64) uint64"},
+ {"Float64frombits", Func, 0, "func(b uint64) float64"},
+ {"Floor", Func, 0, "func(x float64) float64"},
+ {"Frexp", Func, 0, "func(f float64) (frac float64, exp int)"},
+ {"Gamma", Func, 0, "func(x float64) float64"},
+ {"Hypot", Func, 0, "func(p float64, q float64) float64"},
+ {"Ilogb", Func, 0, "func(x float64) int"},
+ {"Inf", Func, 0, "func(sign int) float64"},
+ {"IsInf", Func, 0, "func(f float64, sign int) bool"},
+ {"IsNaN", Func, 0, "func(f float64) (is bool)"},
+ {"J0", Func, 0, "func(x float64) float64"},
+ {"J1", Func, 0, "func(x float64) float64"},
+ {"Jn", Func, 0, "func(n int, x float64) float64"},
+ {"Ldexp", Func, 0, "func(frac float64, exp int) float64"},
+ {"Lgamma", Func, 0, "func(x float64) (lgamma float64, sign int)"},
+ {"Ln10", Const, 0, ""},
+ {"Ln2", Const, 0, ""},
+ {"Log", Func, 0, "func(x float64) float64"},
+ {"Log10", Func, 0, "func(x float64) float64"},
+ {"Log10E", Const, 0, ""},
+ {"Log1p", Func, 0, "func(x float64) float64"},
+ {"Log2", Func, 0, "func(x float64) float64"},
+ {"Log2E", Const, 0, ""},
+ {"Logb", Func, 0, "func(x float64) float64"},
+ {"Max", Func, 0, "func(x float64, y float64) float64"},
+ {"MaxFloat32", Const, 0, ""},
+ {"MaxFloat64", Const, 0, ""},
+ {"MaxInt", Const, 17, ""},
+ {"MaxInt16", Const, 0, ""},
+ {"MaxInt32", Const, 0, ""},
+ {"MaxInt64", Const, 0, ""},
+ {"MaxInt8", Const, 0, ""},
+ {"MaxUint", Const, 17, ""},
+ {"MaxUint16", Const, 0, ""},
+ {"MaxUint32", Const, 0, ""},
+ {"MaxUint64", Const, 0, ""},
+ {"MaxUint8", Const, 0, ""},
+ {"Min", Func, 0, "func(x float64, y float64) float64"},
+ {"MinInt", Const, 17, ""},
+ {"MinInt16", Const, 0, ""},
+ {"MinInt32", Const, 0, ""},
+ {"MinInt64", Const, 0, ""},
+ {"MinInt8", Const, 0, ""},
+ {"Mod", Func, 0, "func(x float64, y float64) float64"},
+ {"Modf", Func, 0, "func(f float64) (int float64, frac float64)"},
+ {"NaN", Func, 0, "func() float64"},
+ {"Nextafter", Func, 0, "func(x float64, y float64) (r float64)"},
+ {"Nextafter32", Func, 4, "func(x float32, y float32) (r float32)"},
+ {"Phi", Const, 0, ""},
+ {"Pi", Const, 0, ""},
+ {"Pow", Func, 0, "func(x float64, y float64) float64"},
+ {"Pow10", Func, 0, "func(n int) float64"},
+ {"Remainder", Func, 0, "func(x float64, y float64) float64"},
+ {"Round", Func, 10, "func(x float64) float64"},
+ {"RoundToEven", Func, 10, "func(x float64) float64"},
+ {"Signbit", Func, 0, "func(x float64) bool"},
+ {"Sin", Func, 0, "func(x float64) float64"},
+ {"Sincos", Func, 0, "func(x float64) (sin float64, cos float64)"},
+ {"Sinh", Func, 0, "func(x float64) float64"},
+ {"SmallestNonzeroFloat32", Const, 0, ""},
+ {"SmallestNonzeroFloat64", Const, 0, ""},
+ {"Sqrt", Func, 0, "func(x float64) float64"},
+ {"Sqrt2", Const, 0, ""},
+ {"SqrtE", Const, 0, ""},
+ {"SqrtPhi", Const, 0, ""},
+ {"SqrtPi", Const, 0, ""},
+ {"Tan", Func, 0, "func(x float64) float64"},
+ {"Tanh", Func, 0, "func(x float64) float64"},
+ {"Trunc", Func, 0, "func(x float64) float64"},
+ {"Y0", Func, 0, "func(x float64) float64"},
+ {"Y1", Func, 0, "func(x float64) float64"},
+ {"Yn", Func, 0, "func(n int, x float64) float64"},
+ },
+ "math/big": {
+ {"(*Float).Abs", Method, 5, ""},
+ {"(*Float).Acc", Method, 5, ""},
+ {"(*Float).Add", Method, 5, ""},
+ {"(*Float).Append", Method, 5, ""},
+ {"(*Float).AppendText", Method, 24, ""},
+ {"(*Float).Cmp", Method, 5, ""},
+ {"(*Float).Copy", Method, 5, ""},
+ {"(*Float).Float32", Method, 5, ""},
+ {"(*Float).Float64", Method, 5, ""},
+ {"(*Float).Format", Method, 5, ""},
+ {"(*Float).GobDecode", Method, 7, ""},
+ {"(*Float).GobEncode", Method, 7, ""},
+ {"(*Float).Int", Method, 5, ""},
+ {"(*Float).Int64", Method, 5, ""},
+ {"(*Float).IsInf", Method, 5, ""},
+ {"(*Float).IsInt", Method, 5, ""},
+ {"(*Float).MantExp", Method, 5, ""},
+ {"(*Float).MarshalText", Method, 6, ""},
+ {"(*Float).MinPrec", Method, 5, ""},
+ {"(*Float).Mode", Method, 5, ""},
+ {"(*Float).Mul", Method, 5, ""},
+ {"(*Float).Neg", Method, 5, ""},
+ {"(*Float).Parse", Method, 5, ""},
+ {"(*Float).Prec", Method, 5, ""},
+ {"(*Float).Quo", Method, 5, ""},
+ {"(*Float).Rat", Method, 5, ""},
+ {"(*Float).Scan", Method, 8, ""},
+ {"(*Float).Set", Method, 5, ""},
+ {"(*Float).SetFloat64", Method, 5, ""},
+ {"(*Float).SetInf", Method, 5, ""},
+ {"(*Float).SetInt", Method, 5, ""},
+ {"(*Float).SetInt64", Method, 5, ""},
+ {"(*Float).SetMantExp", Method, 5, ""},
+ {"(*Float).SetMode", Method, 5, ""},
+ {"(*Float).SetPrec", Method, 5, ""},
+ {"(*Float).SetRat", Method, 5, ""},
+ {"(*Float).SetString", Method, 5, ""},
+ {"(*Float).SetUint64", Method, 5, ""},
+ {"(*Float).Sign", Method, 5, ""},
+ {"(*Float).Signbit", Method, 5, ""},
+ {"(*Float).Sqrt", Method, 10, ""},
+ {"(*Float).String", Method, 5, ""},
+ {"(*Float).Sub", Method, 5, ""},
+ {"(*Float).Text", Method, 5, ""},
+ {"(*Float).Uint64", Method, 5, ""},
+ {"(*Float).UnmarshalText", Method, 6, ""},
+ {"(*Int).Abs", Method, 0, ""},
+ {"(*Int).Add", Method, 0, ""},
+ {"(*Int).And", Method, 0, ""},
+ {"(*Int).AndNot", Method, 0, ""},
+ {"(*Int).Append", Method, 6, ""},
+ {"(*Int).AppendText", Method, 24, ""},
+ {"(*Int).Binomial", Method, 0, ""},
+ {"(*Int).Bit", Method, 0, ""},
+ {"(*Int).BitLen", Method, 0, ""},
+ {"(*Int).Bits", Method, 0, ""},
+ {"(*Int).Bytes", Method, 0, ""},
+ {"(*Int).Cmp", Method, 0, ""},
+ {"(*Int).CmpAbs", Method, 10, ""},
+ {"(*Int).Div", Method, 0, ""},
+ {"(*Int).DivMod", Method, 0, ""},
+ {"(*Int).Exp", Method, 0, ""},
+ {"(*Int).FillBytes", Method, 15, ""},
+ {"(*Int).Float64", Method, 21, ""},
+ {"(*Int).Format", Method, 0, ""},
+ {"(*Int).GCD", Method, 0, ""},
+ {"(*Int).GobDecode", Method, 0, ""},
+ {"(*Int).GobEncode", Method, 0, ""},
+ {"(*Int).Int64", Method, 0, ""},
+ {"(*Int).IsInt64", Method, 9, ""},
+ {"(*Int).IsUint64", Method, 9, ""},
+ {"(*Int).Lsh", Method, 0, ""},
+ {"(*Int).MarshalJSON", Method, 1, ""},
+ {"(*Int).MarshalText", Method, 3, ""},
+ {"(*Int).Mod", Method, 0, ""},
+ {"(*Int).ModInverse", Method, 0, ""},
+ {"(*Int).ModSqrt", Method, 5, ""},
+ {"(*Int).Mul", Method, 0, ""},
+ {"(*Int).MulRange", Method, 0, ""},
+ {"(*Int).Neg", Method, 0, ""},
+ {"(*Int).Not", Method, 0, ""},
+ {"(*Int).Or", Method, 0, ""},
+ {"(*Int).ProbablyPrime", Method, 0, ""},
+ {"(*Int).Quo", Method, 0, ""},
+ {"(*Int).QuoRem", Method, 0, ""},
+ {"(*Int).Rand", Method, 0, ""},
+ {"(*Int).Rem", Method, 0, ""},
+ {"(*Int).Rsh", Method, 0, ""},
+ {"(*Int).Scan", Method, 0, ""},
+ {"(*Int).Set", Method, 0, ""},
+ {"(*Int).SetBit", Method, 0, ""},
+ {"(*Int).SetBits", Method, 0, ""},
+ {"(*Int).SetBytes", Method, 0, ""},
+ {"(*Int).SetInt64", Method, 0, ""},
+ {"(*Int).SetString", Method, 0, ""},
+ {"(*Int).SetUint64", Method, 1, ""},
+ {"(*Int).Sign", Method, 0, ""},
+ {"(*Int).Sqrt", Method, 8, ""},
+ {"(*Int).String", Method, 0, ""},
+ {"(*Int).Sub", Method, 0, ""},
+ {"(*Int).Text", Method, 6, ""},
+ {"(*Int).TrailingZeroBits", Method, 13, ""},
+ {"(*Int).Uint64", Method, 1, ""},
+ {"(*Int).UnmarshalJSON", Method, 1, ""},
+ {"(*Int).UnmarshalText", Method, 3, ""},
+ {"(*Int).Xor", Method, 0, ""},
+ {"(*Rat).Abs", Method, 0, ""},
+ {"(*Rat).Add", Method, 0, ""},
+ {"(*Rat).AppendText", Method, 24, ""},
+ {"(*Rat).Cmp", Method, 0, ""},
+ {"(*Rat).Denom", Method, 0, ""},
+ {"(*Rat).Float32", Method, 4, ""},
+ {"(*Rat).Float64", Method, 1, ""},
+ {"(*Rat).FloatPrec", Method, 22, ""},
+ {"(*Rat).FloatString", Method, 0, ""},
+ {"(*Rat).GobDecode", Method, 0, ""},
+ {"(*Rat).GobEncode", Method, 0, ""},
+ {"(*Rat).Inv", Method, 0, ""},
+ {"(*Rat).IsInt", Method, 0, ""},
+ {"(*Rat).MarshalText", Method, 3, ""},
+ {"(*Rat).Mul", Method, 0, ""},
+ {"(*Rat).Neg", Method, 0, ""},
+ {"(*Rat).Num", Method, 0, ""},
+ {"(*Rat).Quo", Method, 0, ""},
+ {"(*Rat).RatString", Method, 0, ""},
+ {"(*Rat).Scan", Method, 0, ""},
+ {"(*Rat).Set", Method, 0, ""},
+ {"(*Rat).SetFloat64", Method, 1, ""},
+ {"(*Rat).SetFrac", Method, 0, ""},
+ {"(*Rat).SetFrac64", Method, 0, ""},
+ {"(*Rat).SetInt", Method, 0, ""},
+ {"(*Rat).SetInt64", Method, 0, ""},
+ {"(*Rat).SetString", Method, 0, ""},
+ {"(*Rat).SetUint64", Method, 13, ""},
+ {"(*Rat).Sign", Method, 0, ""},
+ {"(*Rat).String", Method, 0, ""},
+ {"(*Rat).Sub", Method, 0, ""},
+ {"(*Rat).UnmarshalText", Method, 3, ""},
+ {"(Accuracy).String", Method, 5, ""},
+ {"(ErrNaN).Error", Method, 5, ""},
+ {"(RoundingMode).String", Method, 5, ""},
+ {"Above", Const, 5, ""},
+ {"Accuracy", Type, 5, ""},
+ {"AwayFromZero", Const, 5, ""},
+ {"Below", Const, 5, ""},
+ {"ErrNaN", Type, 5, ""},
+ {"Exact", Const, 5, ""},
+ {"Float", Type, 5, ""},
+ {"Int", Type, 0, ""},
+ {"Jacobi", Func, 5, "func(x *Int, y *Int) int"},
+ {"MaxBase", Const, 0, ""},
+ {"MaxExp", Const, 5, ""},
+ {"MaxPrec", Const, 5, ""},
+ {"MinExp", Const, 5, ""},
+ {"NewFloat", Func, 5, "func(x float64) *Float"},
+ {"NewInt", Func, 0, "func(x int64) *Int"},
+ {"NewRat", Func, 0, "func(a int64, b int64) *Rat"},
+ {"ParseFloat", Func, 5, "func(s string, base int, prec uint, mode RoundingMode) (f *Float, b int, err error)"},
+ {"Rat", Type, 0, ""},
+ {"RoundingMode", Type, 5, ""},
+ {"ToNearestAway", Const, 5, ""},
+ {"ToNearestEven", Const, 5, ""},
+ {"ToNegativeInf", Const, 5, ""},
+ {"ToPositiveInf", Const, 5, ""},
+ {"ToZero", Const, 5, ""},
+ {"Word", Type, 0, ""},
+ },
+ "math/bits": {
+ {"Add", Func, 12, "func(x uint, y uint, carry uint) (sum uint, carryOut uint)"},
+ {"Add32", Func, 12, "func(x uint32, y uint32, carry uint32) (sum uint32, carryOut uint32)"},
+ {"Add64", Func, 12, "func(x uint64, y uint64, carry uint64) (sum uint64, carryOut uint64)"},
+ {"Div", Func, 12, "func(hi uint, lo uint, y uint) (quo uint, rem uint)"},
+ {"Div32", Func, 12, "func(hi uint32, lo uint32, y uint32) (quo uint32, rem uint32)"},
+ {"Div64", Func, 12, "func(hi uint64, lo uint64, y uint64) (quo uint64, rem uint64)"},
+ {"LeadingZeros", Func, 9, "func(x uint) int"},
+ {"LeadingZeros16", Func, 9, "func(x uint16) int"},
+ {"LeadingZeros32", Func, 9, "func(x uint32) int"},
+ {"LeadingZeros64", Func, 9, "func(x uint64) int"},
+ {"LeadingZeros8", Func, 9, "func(x uint8) int"},
+ {"Len", Func, 9, "func(x uint) int"},
+ {"Len16", Func, 9, "func(x uint16) (n int)"},
+ {"Len32", Func, 9, "func(x uint32) (n int)"},
+ {"Len64", Func, 9, "func(x uint64) (n int)"},
+ {"Len8", Func, 9, "func(x uint8) int"},
+ {"Mul", Func, 12, "func(x uint, y uint) (hi uint, lo uint)"},
+ {"Mul32", Func, 12, "func(x uint32, y uint32) (hi uint32, lo uint32)"},
+ {"Mul64", Func, 12, "func(x uint64, y uint64) (hi uint64, lo uint64)"},
+ {"OnesCount", Func, 9, "func(x uint) int"},
+ {"OnesCount16", Func, 9, "func(x uint16) int"},
+ {"OnesCount32", Func, 9, "func(x uint32) int"},
+ {"OnesCount64", Func, 9, "func(x uint64) int"},
+ {"OnesCount8", Func, 9, "func(x uint8) int"},
+ {"Rem", Func, 14, "func(hi uint, lo uint, y uint) uint"},
+ {"Rem32", Func, 14, "func(hi uint32, lo uint32, y uint32) uint32"},
+ {"Rem64", Func, 14, "func(hi uint64, lo uint64, y uint64) uint64"},
+ {"Reverse", Func, 9, "func(x uint) uint"},
+ {"Reverse16", Func, 9, "func(x uint16) uint16"},
+ {"Reverse32", Func, 9, "func(x uint32) uint32"},
+ {"Reverse64", Func, 9, "func(x uint64) uint64"},
+ {"Reverse8", Func, 9, "func(x uint8) uint8"},
+ {"ReverseBytes", Func, 9, "func(x uint) uint"},
+ {"ReverseBytes16", Func, 9, "func(x uint16) uint16"},
+ {"ReverseBytes32", Func, 9, "func(x uint32) uint32"},
+ {"ReverseBytes64", Func, 9, "func(x uint64) uint64"},
+ {"RotateLeft", Func, 9, "func(x uint, k int) uint"},
+ {"RotateLeft16", Func, 9, "func(x uint16, k int) uint16"},
+ {"RotateLeft32", Func, 9, "func(x uint32, k int) uint32"},
+ {"RotateLeft64", Func, 9, "func(x uint64, k int) uint64"},
+ {"RotateLeft8", Func, 9, "func(x uint8, k int) uint8"},
+ {"Sub", Func, 12, "func(x uint, y uint, borrow uint) (diff uint, borrowOut uint)"},
+ {"Sub32", Func, 12, "func(x uint32, y uint32, borrow uint32) (diff uint32, borrowOut uint32)"},
+ {"Sub64", Func, 12, "func(x uint64, y uint64, borrow uint64) (diff uint64, borrowOut uint64)"},
+ {"TrailingZeros", Func, 9, "func(x uint) int"},
+ {"TrailingZeros16", Func, 9, "func(x uint16) int"},
+ {"TrailingZeros32", Func, 9, "func(x uint32) int"},
+ {"TrailingZeros64", Func, 9, "func(x uint64) int"},
+ {"TrailingZeros8", Func, 9, "func(x uint8) int"},
+ {"UintSize", Const, 9, ""},
+ },
+ "math/cmplx": {
+ {"Abs", Func, 0, "func(x complex128) float64"},
+ {"Acos", Func, 0, "func(x complex128) complex128"},
+ {"Acosh", Func, 0, "func(x complex128) complex128"},
+ {"Asin", Func, 0, "func(x complex128) complex128"},
+ {"Asinh", Func, 0, "func(x complex128) complex128"},
+ {"Atan", Func, 0, "func(x complex128) complex128"},
+ {"Atanh", Func, 0, "func(x complex128) complex128"},
+ {"Conj", Func, 0, "func(x complex128) complex128"},
+ {"Cos", Func, 0, "func(x complex128) complex128"},
+ {"Cosh", Func, 0, "func(x complex128) complex128"},
+ {"Cot", Func, 0, "func(x complex128) complex128"},
+ {"Exp", Func, 0, "func(x complex128) complex128"},
+ {"Inf", Func, 0, "func() complex128"},
+ {"IsInf", Func, 0, "func(x complex128) bool"},
+ {"IsNaN", Func, 0, "func(x complex128) bool"},
+ {"Log", Func, 0, "func(x complex128) complex128"},
+ {"Log10", Func, 0, "func(x complex128) complex128"},
+ {"NaN", Func, 0, "func() complex128"},
+ {"Phase", Func, 0, "func(x complex128) float64"},
+ {"Polar", Func, 0, "func(x complex128) (r float64, θ float64)"},
+ {"Pow", Func, 0, "func(x complex128, y complex128) complex128"},
+ {"Rect", Func, 0, "func(r float64, θ float64) complex128"},
+ {"Sin", Func, 0, "func(x complex128) complex128"},
+ {"Sinh", Func, 0, "func(x complex128) complex128"},
+ {"Sqrt", Func, 0, "func(x complex128) complex128"},
+ {"Tan", Func, 0, "func(x complex128) complex128"},
+ {"Tanh", Func, 0, "func(x complex128) complex128"},
+ },
+ "math/rand": {
+ {"(*Rand).ExpFloat64", Method, 0, ""},
+ {"(*Rand).Float32", Method, 0, ""},
+ {"(*Rand).Float64", Method, 0, ""},
+ {"(*Rand).Int", Method, 0, ""},
+ {"(*Rand).Int31", Method, 0, ""},
+ {"(*Rand).Int31n", Method, 0, ""},
+ {"(*Rand).Int63", Method, 0, ""},
+ {"(*Rand).Int63n", Method, 0, ""},
+ {"(*Rand).Intn", Method, 0, ""},
+ {"(*Rand).NormFloat64", Method, 0, ""},
+ {"(*Rand).Perm", Method, 0, ""},
+ {"(*Rand).Read", Method, 6, ""},
+ {"(*Rand).Seed", Method, 0, ""},
+ {"(*Rand).Shuffle", Method, 10, ""},
+ {"(*Rand).Uint32", Method, 0, ""},
+ {"(*Rand).Uint64", Method, 8, ""},
+ {"(*Zipf).Uint64", Method, 0, ""},
+ {"ExpFloat64", Func, 0, "func() float64"},
+ {"Float32", Func, 0, "func() float32"},
+ {"Float64", Func, 0, "func() float64"},
+ {"Int", Func, 0, "func() int"},
+ {"Int31", Func, 0, "func() int32"},
+ {"Int31n", Func, 0, "func(n int32) int32"},
+ {"Int63", Func, 0, "func() int64"},
+ {"Int63n", Func, 0, "func(n int64) int64"},
+ {"Intn", Func, 0, "func(n int) int"},
+ {"New", Func, 0, "func(src Source) *Rand"},
+ {"NewSource", Func, 0, "func(seed int64) Source"},
+ {"NewZipf", Func, 0, "func(r *Rand, s float64, v float64, imax uint64) *Zipf"},
+ {"NormFloat64", Func, 0, "func() float64"},
+ {"Perm", Func, 0, "func(n int) []int"},
+ {"Rand", Type, 0, ""},
+ {"Read", Func, 6, "func(p []byte) (n int, err error)"},
+ {"Seed", Func, 0, "func(seed int64)"},
+ {"Shuffle", Func, 10, "func(n int, swap func(i int, j int))"},
+ {"Source", Type, 0, ""},
+ {"Source64", Type, 8, ""},
+ {"Uint32", Func, 0, "func() uint32"},
+ {"Uint64", Func, 8, "func() uint64"},
+ {"Zipf", Type, 0, ""},
+ },
+ "math/rand/v2": {
+ {"(*ChaCha8).AppendBinary", Method, 24, ""},
+ {"(*ChaCha8).MarshalBinary", Method, 22, ""},
+ {"(*ChaCha8).Read", Method, 23, ""},
+ {"(*ChaCha8).Seed", Method, 22, ""},
+ {"(*ChaCha8).Uint64", Method, 22, ""},
+ {"(*ChaCha8).UnmarshalBinary", Method, 22, ""},
+ {"(*PCG).AppendBinary", Method, 24, ""},
+ {"(*PCG).MarshalBinary", Method, 22, ""},
+ {"(*PCG).Seed", Method, 22, ""},
+ {"(*PCG).Uint64", Method, 22, ""},
+ {"(*PCG).UnmarshalBinary", Method, 22, ""},
+ {"(*Rand).ExpFloat64", Method, 22, ""},
+ {"(*Rand).Float32", Method, 22, ""},
+ {"(*Rand).Float64", Method, 22, ""},
+ {"(*Rand).Int", Method, 22, ""},
+ {"(*Rand).Int32", Method, 22, ""},
+ {"(*Rand).Int32N", Method, 22, ""},
+ {"(*Rand).Int64", Method, 22, ""},
+ {"(*Rand).Int64N", Method, 22, ""},
+ {"(*Rand).IntN", Method, 22, ""},
+ {"(*Rand).NormFloat64", Method, 22, ""},
+ {"(*Rand).Perm", Method, 22, ""},
+ {"(*Rand).Shuffle", Method, 22, ""},
+ {"(*Rand).Uint", Method, 23, ""},
+ {"(*Rand).Uint32", Method, 22, ""},
+ {"(*Rand).Uint32N", Method, 22, ""},
+ {"(*Rand).Uint64", Method, 22, ""},
+ {"(*Rand).Uint64N", Method, 22, ""},
+ {"(*Rand).UintN", Method, 22, ""},
+ {"(*Zipf).Uint64", Method, 22, ""},
+ {"ChaCha8", Type, 22, ""},
+ {"ExpFloat64", Func, 22, "func() float64"},
+ {"Float32", Func, 22, "func() float32"},
+ {"Float64", Func, 22, "func() float64"},
+ {"Int", Func, 22, "func() int"},
+ {"Int32", Func, 22, "func() int32"},
+ {"Int32N", Func, 22, "func(n int32) int32"},
+ {"Int64", Func, 22, "func() int64"},
+ {"Int64N", Func, 22, "func(n int64) int64"},
+ {"IntN", Func, 22, "func(n int) int"},
+ {"N", Func, 22, "func[Int intType](n Int) Int"},
+ {"New", Func, 22, "func(src Source) *Rand"},
+ {"NewChaCha8", Func, 22, "func(seed [32]byte) *ChaCha8"},
+ {"NewPCG", Func, 22, "func(seed1 uint64, seed2 uint64) *PCG"},
+ {"NewZipf", Func, 22, "func(r *Rand, s float64, v float64, imax uint64) *Zipf"},
+ {"NormFloat64", Func, 22, "func() float64"},
+ {"PCG", Type, 22, ""},
+ {"Perm", Func, 22, "func(n int) []int"},
+ {"Rand", Type, 22, ""},
+ {"Shuffle", Func, 22, "func(n int, swap func(i int, j int))"},
+ {"Source", Type, 22, ""},
+ {"Uint", Func, 23, "func() uint"},
+ {"Uint32", Func, 22, "func() uint32"},
+ {"Uint32N", Func, 22, "func(n uint32) uint32"},
+ {"Uint64", Func, 22, "func() uint64"},
+ {"Uint64N", Func, 22, "func(n uint64) uint64"},
+ {"UintN", Func, 22, "func(n uint) uint"},
+ {"Zipf", Type, 22, ""},
+ },
+ "mime": {
+ {"(*WordDecoder).Decode", Method, 5, ""},
+ {"(*WordDecoder).DecodeHeader", Method, 5, ""},
+ {"(WordEncoder).Encode", Method, 5, ""},
+ {"AddExtensionType", Func, 0, "func(ext string, typ string) error"},
+ {"BEncoding", Const, 5, ""},
+ {"ErrInvalidMediaParameter", Var, 9, ""},
+ {"ExtensionsByType", Func, 5, "func(typ string) ([]string, error)"},
+ {"FormatMediaType", Func, 0, "func(t string, param map[string]string) string"},
+ {"ParseMediaType", Func, 0, "func(v string) (mediatype string, params map[string]string, err error)"},
+ {"QEncoding", Const, 5, ""},
+ {"TypeByExtension", Func, 0, "func(ext string) string"},
+ {"WordDecoder", Type, 5, ""},
+ {"WordDecoder.CharsetReader", Field, 5, ""},
+ {"WordEncoder", Type, 5, ""},
+ },
+ "mime/multipart": {
+ {"(*FileHeader).Open", Method, 0, ""},
+ {"(*Form).RemoveAll", Method, 0, ""},
+ {"(*Part).Close", Method, 0, ""},
+ {"(*Part).FileName", Method, 0, ""},
+ {"(*Part).FormName", Method, 0, ""},
+ {"(*Part).Read", Method, 0, ""},
+ {"(*Reader).NextPart", Method, 0, ""},
+ {"(*Reader).NextRawPart", Method, 14, ""},
+ {"(*Reader).ReadForm", Method, 0, ""},
+ {"(*Writer).Boundary", Method, 0, ""},
+ {"(*Writer).Close", Method, 0, ""},
+ {"(*Writer).CreateFormField", Method, 0, ""},
+ {"(*Writer).CreateFormFile", Method, 0, ""},
+ {"(*Writer).CreatePart", Method, 0, ""},
+ {"(*Writer).FormDataContentType", Method, 0, ""},
+ {"(*Writer).SetBoundary", Method, 1, ""},
+ {"(*Writer).WriteField", Method, 0, ""},
+ {"ErrMessageTooLarge", Var, 9, ""},
+ {"File", Type, 0, ""},
+ {"FileContentDisposition", Func, 25, ""},
+ {"FileHeader", Type, 0, ""},
+ {"FileHeader.Filename", Field, 0, ""},
+ {"FileHeader.Header", Field, 0, ""},
+ {"FileHeader.Size", Field, 9, ""},
+ {"Form", Type, 0, ""},
+ {"Form.File", Field, 0, ""},
+ {"Form.Value", Field, 0, ""},
+ {"NewReader", Func, 0, "func(r io.Reader, boundary string) *Reader"},
+ {"NewWriter", Func, 0, "func(w io.Writer) *Writer"},
+ {"Part", Type, 0, ""},
+ {"Part.Header", Field, 0, ""},
+ {"Reader", Type, 0, ""},
+ {"Writer", Type, 0, ""},
+ },
+ "mime/quotedprintable": {
+ {"(*Reader).Read", Method, 5, ""},
+ {"(*Writer).Close", Method, 5, ""},
+ {"(*Writer).Write", Method, 5, ""},
+ {"NewReader", Func, 5, "func(r io.Reader) *Reader"},
+ {"NewWriter", Func, 5, "func(w io.Writer) *Writer"},
+ {"Reader", Type, 5, ""},
+ {"Writer", Type, 5, ""},
+ {"Writer.Binary", Field, 5, ""},
+ },
+ "net": {
+ {"(*AddrError).Error", Method, 0, ""},
+ {"(*AddrError).Temporary", Method, 0, ""},
+ {"(*AddrError).Timeout", Method, 0, ""},
+ {"(*Buffers).Read", Method, 8, ""},
+ {"(*Buffers).WriteTo", Method, 8, ""},
+ {"(*DNSConfigError).Error", Method, 0, ""},
+ {"(*DNSConfigError).Temporary", Method, 0, ""},
+ {"(*DNSConfigError).Timeout", Method, 0, ""},
+ {"(*DNSConfigError).Unwrap", Method, 13, ""},
+ {"(*DNSError).Error", Method, 0, ""},
+ {"(*DNSError).Temporary", Method, 0, ""},
+ {"(*DNSError).Timeout", Method, 0, ""},
+ {"(*DNSError).Unwrap", Method, 23, ""},
+ {"(*Dialer).Dial", Method, 1, ""},
+ {"(*Dialer).DialContext", Method, 7, ""},
+ {"(*Dialer).MultipathTCP", Method, 21, ""},
+ {"(*Dialer).SetMultipathTCP", Method, 21, ""},
+ {"(*IP).UnmarshalText", Method, 2, ""},
+ {"(*IPAddr).Network", Method, 0, ""},
+ {"(*IPAddr).String", Method, 0, ""},
+ {"(*IPConn).Close", Method, 0, ""},
+ {"(*IPConn).File", Method, 0, ""},
+ {"(*IPConn).LocalAddr", Method, 0, ""},
+ {"(*IPConn).Read", Method, 0, ""},
+ {"(*IPConn).ReadFrom", Method, 0, ""},
+ {"(*IPConn).ReadFromIP", Method, 0, ""},
+ {"(*IPConn).ReadMsgIP", Method, 1, ""},
+ {"(*IPConn).RemoteAddr", Method, 0, ""},
+ {"(*IPConn).SetDeadline", Method, 0, ""},
+ {"(*IPConn).SetReadBuffer", Method, 0, ""},
+ {"(*IPConn).SetReadDeadline", Method, 0, ""},
+ {"(*IPConn).SetWriteBuffer", Method, 0, ""},
+ {"(*IPConn).SetWriteDeadline", Method, 0, ""},
+ {"(*IPConn).SyscallConn", Method, 9, ""},
+ {"(*IPConn).Write", Method, 0, ""},
+ {"(*IPConn).WriteMsgIP", Method, 1, ""},
+ {"(*IPConn).WriteTo", Method, 0, ""},
+ {"(*IPConn).WriteToIP", Method, 0, ""},
+ {"(*IPNet).Contains", Method, 0, ""},
+ {"(*IPNet).Network", Method, 0, ""},
+ {"(*IPNet).String", Method, 0, ""},
+ {"(*Interface).Addrs", Method, 0, ""},
+ {"(*Interface).MulticastAddrs", Method, 0, ""},
+ {"(*ListenConfig).Listen", Method, 11, ""},
+ {"(*ListenConfig).ListenPacket", Method, 11, ""},
+ {"(*ListenConfig).MultipathTCP", Method, 21, ""},
+ {"(*ListenConfig).SetMultipathTCP", Method, 21, ""},
+ {"(*OpError).Error", Method, 0, ""},
+ {"(*OpError).Temporary", Method, 0, ""},
+ {"(*OpError).Timeout", Method, 0, ""},
+ {"(*OpError).Unwrap", Method, 13, ""},
+ {"(*ParseError).Error", Method, 0, ""},
+ {"(*ParseError).Temporary", Method, 17, ""},
+ {"(*ParseError).Timeout", Method, 17, ""},
+ {"(*Resolver).LookupAddr", Method, 8, ""},
+ {"(*Resolver).LookupCNAME", Method, 8, ""},
+ {"(*Resolver).LookupHost", Method, 8, ""},
+ {"(*Resolver).LookupIP", Method, 15, ""},
+ {"(*Resolver).LookupIPAddr", Method, 8, ""},
+ {"(*Resolver).LookupMX", Method, 8, ""},
+ {"(*Resolver).LookupNS", Method, 8, ""},
+ {"(*Resolver).LookupNetIP", Method, 18, ""},
+ {"(*Resolver).LookupPort", Method, 8, ""},
+ {"(*Resolver).LookupSRV", Method, 8, ""},
+ {"(*Resolver).LookupTXT", Method, 8, ""},
+ {"(*TCPAddr).AddrPort", Method, 18, ""},
+ {"(*TCPAddr).Network", Method, 0, ""},
+ {"(*TCPAddr).String", Method, 0, ""},
+ {"(*TCPConn).Close", Method, 0, ""},
+ {"(*TCPConn).CloseRead", Method, 0, ""},
+ {"(*TCPConn).CloseWrite", Method, 0, ""},
+ {"(*TCPConn).File", Method, 0, ""},
+ {"(*TCPConn).LocalAddr", Method, 0, ""},
+ {"(*TCPConn).MultipathTCP", Method, 21, ""},
+ {"(*TCPConn).Read", Method, 0, ""},
+ {"(*TCPConn).ReadFrom", Method, 0, ""},
+ {"(*TCPConn).RemoteAddr", Method, 0, ""},
+ {"(*TCPConn).SetDeadline", Method, 0, ""},
+ {"(*TCPConn).SetKeepAlive", Method, 0, ""},
+ {"(*TCPConn).SetKeepAliveConfig", Method, 23, ""},
+ {"(*TCPConn).SetKeepAlivePeriod", Method, 2, ""},
+ {"(*TCPConn).SetLinger", Method, 0, ""},
+ {"(*TCPConn).SetNoDelay", Method, 0, ""},
+ {"(*TCPConn).SetReadBuffer", Method, 0, ""},
+ {"(*TCPConn).SetReadDeadline", Method, 0, ""},
+ {"(*TCPConn).SetWriteBuffer", Method, 0, ""},
+ {"(*TCPConn).SetWriteDeadline", Method, 0, ""},
+ {"(*TCPConn).SyscallConn", Method, 9, ""},
+ {"(*TCPConn).Write", Method, 0, ""},
+ {"(*TCPConn).WriteTo", Method, 22, ""},
+ {"(*TCPListener).Accept", Method, 0, ""},
+ {"(*TCPListener).AcceptTCP", Method, 0, ""},
+ {"(*TCPListener).Addr", Method, 0, ""},
+ {"(*TCPListener).Close", Method, 0, ""},
+ {"(*TCPListener).File", Method, 0, ""},
+ {"(*TCPListener).SetDeadline", Method, 0, ""},
+ {"(*TCPListener).SyscallConn", Method, 10, ""},
+ {"(*UDPAddr).AddrPort", Method, 18, ""},
+ {"(*UDPAddr).Network", Method, 0, ""},
+ {"(*UDPAddr).String", Method, 0, ""},
+ {"(*UDPConn).Close", Method, 0, ""},
+ {"(*UDPConn).File", Method, 0, ""},
+ {"(*UDPConn).LocalAddr", Method, 0, ""},
+ {"(*UDPConn).Read", Method, 0, ""},
+ {"(*UDPConn).ReadFrom", Method, 0, ""},
+ {"(*UDPConn).ReadFromUDP", Method, 0, ""},
+ {"(*UDPConn).ReadFromUDPAddrPort", Method, 18, ""},
+ {"(*UDPConn).ReadMsgUDP", Method, 1, ""},
+ {"(*UDPConn).ReadMsgUDPAddrPort", Method, 18, ""},
+ {"(*UDPConn).RemoteAddr", Method, 0, ""},
+ {"(*UDPConn).SetDeadline", Method, 0, ""},
+ {"(*UDPConn).SetReadBuffer", Method, 0, ""},
+ {"(*UDPConn).SetReadDeadline", Method, 0, ""},
+ {"(*UDPConn).SetWriteBuffer", Method, 0, ""},
+ {"(*UDPConn).SetWriteDeadline", Method, 0, ""},
+ {"(*UDPConn).SyscallConn", Method, 9, ""},
+ {"(*UDPConn).Write", Method, 0, ""},
+ {"(*UDPConn).WriteMsgUDP", Method, 1, ""},
+ {"(*UDPConn).WriteMsgUDPAddrPort", Method, 18, ""},
+ {"(*UDPConn).WriteTo", Method, 0, ""},
+ {"(*UDPConn).WriteToUDP", Method, 0, ""},
+ {"(*UDPConn).WriteToUDPAddrPort", Method, 18, ""},
+ {"(*UnixAddr).Network", Method, 0, ""},
+ {"(*UnixAddr).String", Method, 0, ""},
+ {"(*UnixConn).Close", Method, 0, ""},
+ {"(*UnixConn).CloseRead", Method, 1, ""},
+ {"(*UnixConn).CloseWrite", Method, 1, ""},
+ {"(*UnixConn).File", Method, 0, ""},
+ {"(*UnixConn).LocalAddr", Method, 0, ""},
+ {"(*UnixConn).Read", Method, 0, ""},
+ {"(*UnixConn).ReadFrom", Method, 0, ""},
+ {"(*UnixConn).ReadFromUnix", Method, 0, ""},
+ {"(*UnixConn).ReadMsgUnix", Method, 0, ""},
+ {"(*UnixConn).RemoteAddr", Method, 0, ""},
+ {"(*UnixConn).SetDeadline", Method, 0, ""},
+ {"(*UnixConn).SetReadBuffer", Method, 0, ""},
+ {"(*UnixConn).SetReadDeadline", Method, 0, ""},
+ {"(*UnixConn).SetWriteBuffer", Method, 0, ""},
+ {"(*UnixConn).SetWriteDeadline", Method, 0, ""},
+ {"(*UnixConn).SyscallConn", Method, 9, ""},
+ {"(*UnixConn).Write", Method, 0, ""},
+ {"(*UnixConn).WriteMsgUnix", Method, 0, ""},
+ {"(*UnixConn).WriteTo", Method, 0, ""},
+ {"(*UnixConn).WriteToUnix", Method, 0, ""},
+ {"(*UnixListener).Accept", Method, 0, ""},
+ {"(*UnixListener).AcceptUnix", Method, 0, ""},
+ {"(*UnixListener).Addr", Method, 0, ""},
+ {"(*UnixListener).Close", Method, 0, ""},
+ {"(*UnixListener).File", Method, 0, ""},
+ {"(*UnixListener).SetDeadline", Method, 0, ""},
+ {"(*UnixListener).SetUnlinkOnClose", Method, 8, ""},
+ {"(*UnixListener).SyscallConn", Method, 10, ""},
+ {"(Flags).String", Method, 0, ""},
+ {"(HardwareAddr).String", Method, 0, ""},
+ {"(IP).AppendText", Method, 24, ""},
+ {"(IP).DefaultMask", Method, 0, ""},
+ {"(IP).Equal", Method, 0, ""},
+ {"(IP).IsGlobalUnicast", Method, 0, ""},
+ {"(IP).IsInterfaceLocalMulticast", Method, 0, ""},
+ {"(IP).IsLinkLocalMulticast", Method, 0, ""},
+ {"(IP).IsLinkLocalUnicast", Method, 0, ""},
+ {"(IP).IsLoopback", Method, 0, ""},
+ {"(IP).IsMulticast", Method, 0, ""},
+ {"(IP).IsPrivate", Method, 17, ""},
+ {"(IP).IsUnspecified", Method, 0, ""},
+ {"(IP).MarshalText", Method, 2, ""},
+ {"(IP).Mask", Method, 0, ""},
+ {"(IP).String", Method, 0, ""},
+ {"(IP).To16", Method, 0, ""},
+ {"(IP).To4", Method, 0, ""},
+ {"(IPMask).Size", Method, 0, ""},
+ {"(IPMask).String", Method, 0, ""},
+ {"(InvalidAddrError).Error", Method, 0, ""},
+ {"(InvalidAddrError).Temporary", Method, 0, ""},
+ {"(InvalidAddrError).Timeout", Method, 0, ""},
+ {"(UnknownNetworkError).Error", Method, 0, ""},
+ {"(UnknownNetworkError).Temporary", Method, 0, ""},
+ {"(UnknownNetworkError).Timeout", Method, 0, ""},
+ {"Addr", Type, 0, ""},
+ {"AddrError", Type, 0, ""},
+ {"AddrError.Addr", Field, 0, ""},
+ {"AddrError.Err", Field, 0, ""},
+ {"Buffers", Type, 8, ""},
+ {"CIDRMask", Func, 0, "func(ones int, bits int) IPMask"},
+ {"Conn", Type, 0, ""},
+ {"DNSConfigError", Type, 0, ""},
+ {"DNSConfigError.Err", Field, 0, ""},
+ {"DNSError", Type, 0, ""},
+ {"DNSError.Err", Field, 0, ""},
+ {"DNSError.IsNotFound", Field, 13, ""},
+ {"DNSError.IsTemporary", Field, 6, ""},
+ {"DNSError.IsTimeout", Field, 0, ""},
+ {"DNSError.Name", Field, 0, ""},
+ {"DNSError.Server", Field, 0, ""},
+ {"DNSError.UnwrapErr", Field, 23, ""},
+ {"DefaultResolver", Var, 8, ""},
+ {"Dial", Func, 0, "func(network string, address string) (Conn, error)"},
+ {"DialIP", Func, 0, "func(network string, laddr *IPAddr, raddr *IPAddr) (*IPConn, error)"},
+ {"DialTCP", Func, 0, "func(network string, laddr *TCPAddr, raddr *TCPAddr) (*TCPConn, error)"},
+ {"DialTimeout", Func, 0, "func(network string, address string, timeout time.Duration) (Conn, error)"},
+ {"DialUDP", Func, 0, "func(network string, laddr *UDPAddr, raddr *UDPAddr) (*UDPConn, error)"},
+ {"DialUnix", Func, 0, "func(network string, laddr *UnixAddr, raddr *UnixAddr) (*UnixConn, error)"},
+ {"Dialer", Type, 1, ""},
+ {"Dialer.Cancel", Field, 6, ""},
+ {"Dialer.Control", Field, 11, ""},
+ {"Dialer.ControlContext", Field, 20, ""},
+ {"Dialer.Deadline", Field, 1, ""},
+ {"Dialer.DualStack", Field, 2, ""},
+ {"Dialer.FallbackDelay", Field, 5, ""},
+ {"Dialer.KeepAlive", Field, 3, ""},
+ {"Dialer.KeepAliveConfig", Field, 23, ""},
+ {"Dialer.LocalAddr", Field, 1, ""},
+ {"Dialer.Resolver", Field, 8, ""},
+ {"Dialer.Timeout", Field, 1, ""},
+ {"ErrClosed", Var, 16, ""},
+ {"ErrWriteToConnected", Var, 0, ""},
+ {"Error", Type, 0, ""},
+ {"FileConn", Func, 0, "func(f *os.File) (c Conn, err error)"},
+ {"FileListener", Func, 0, "func(f *os.File) (ln Listener, err error)"},
+ {"FilePacketConn", Func, 0, "func(f *os.File) (c PacketConn, err error)"},
+ {"FlagBroadcast", Const, 0, ""},
+ {"FlagLoopback", Const, 0, ""},
+ {"FlagMulticast", Const, 0, ""},
+ {"FlagPointToPoint", Const, 0, ""},
+ {"FlagRunning", Const, 20, ""},
+ {"FlagUp", Const, 0, ""},
+ {"Flags", Type, 0, ""},
+ {"HardwareAddr", Type, 0, ""},
+ {"IP", Type, 0, ""},
+ {"IPAddr", Type, 0, ""},
+ {"IPAddr.IP", Field, 0, ""},
+ {"IPAddr.Zone", Field, 1, ""},
+ {"IPConn", Type, 0, ""},
+ {"IPMask", Type, 0, ""},
+ {"IPNet", Type, 0, ""},
+ {"IPNet.IP", Field, 0, ""},
+ {"IPNet.Mask", Field, 0, ""},
+ {"IPv4", Func, 0, "func(a byte, b byte, c byte, d byte) IP"},
+ {"IPv4Mask", Func, 0, "func(a byte, b byte, c byte, d byte) IPMask"},
+ {"IPv4allrouter", Var, 0, ""},
+ {"IPv4allsys", Var, 0, ""},
+ {"IPv4bcast", Var, 0, ""},
+ {"IPv4len", Const, 0, ""},
+ {"IPv4zero", Var, 0, ""},
+ {"IPv6interfacelocalallnodes", Var, 0, ""},
+ {"IPv6len", Const, 0, ""},
+ {"IPv6linklocalallnodes", Var, 0, ""},
+ {"IPv6linklocalallrouters", Var, 0, ""},
+ {"IPv6loopback", Var, 0, ""},
+ {"IPv6unspecified", Var, 0, ""},
+ {"IPv6zero", Var, 0, ""},
+ {"Interface", Type, 0, ""},
+ {"Interface.Flags", Field, 0, ""},
+ {"Interface.HardwareAddr", Field, 0, ""},
+ {"Interface.Index", Field, 0, ""},
+ {"Interface.MTU", Field, 0, ""},
+ {"Interface.Name", Field, 0, ""},
+ {"InterfaceAddrs", Func, 0, "func() ([]Addr, error)"},
+ {"InterfaceByIndex", Func, 0, "func(index int) (*Interface, error)"},
+ {"InterfaceByName", Func, 0, "func(name string) (*Interface, error)"},
+ {"Interfaces", Func, 0, "func() ([]Interface, error)"},
+ {"InvalidAddrError", Type, 0, ""},
+ {"JoinHostPort", Func, 0, "func(host string, port string) string"},
+ {"KeepAliveConfig", Type, 23, ""},
+ {"KeepAliveConfig.Count", Field, 23, ""},
+ {"KeepAliveConfig.Enable", Field, 23, ""},
+ {"KeepAliveConfig.Idle", Field, 23, ""},
+ {"KeepAliveConfig.Interval", Field, 23, ""},
+ {"Listen", Func, 0, "func(network string, address string) (Listener, error)"},
+ {"ListenConfig", Type, 11, ""},
+ {"ListenConfig.Control", Field, 11, ""},
+ {"ListenConfig.KeepAlive", Field, 13, ""},
+ {"ListenConfig.KeepAliveConfig", Field, 23, ""},
+ {"ListenIP", Func, 0, "func(network string, laddr *IPAddr) (*IPConn, error)"},
+ {"ListenMulticastUDP", Func, 0, "func(network string, ifi *Interface, gaddr *UDPAddr) (*UDPConn, error)"},
+ {"ListenPacket", Func, 0, "func(network string, address string) (PacketConn, error)"},
+ {"ListenTCP", Func, 0, "func(network string, laddr *TCPAddr) (*TCPListener, error)"},
+ {"ListenUDP", Func, 0, "func(network string, laddr *UDPAddr) (*UDPConn, error)"},
+ {"ListenUnix", Func, 0, "func(network string, laddr *UnixAddr) (*UnixListener, error)"},
+ {"ListenUnixgram", Func, 0, "func(network string, laddr *UnixAddr) (*UnixConn, error)"},
+ {"Listener", Type, 0, ""},
+ {"LookupAddr", Func, 0, "func(addr string) (names []string, err error)"},
+ {"LookupCNAME", Func, 0, "func(host string) (cname string, err error)"},
+ {"LookupHost", Func, 0, "func(host string) (addrs []string, err error)"},
+ {"LookupIP", Func, 0, "func(host string) ([]IP, error)"},
+ {"LookupMX", Func, 0, "func(name string) ([]*MX, error)"},
+ {"LookupNS", Func, 1, "func(name string) ([]*NS, error)"},
+ {"LookupPort", Func, 0, "func(network string, service string) (port int, err error)"},
+ {"LookupSRV", Func, 0, "func(service string, proto string, name string) (cname string, addrs []*SRV, err error)"},
+ {"LookupTXT", Func, 0, "func(name string) ([]string, error)"},
+ {"MX", Type, 0, ""},
+ {"MX.Host", Field, 0, ""},
+ {"MX.Pref", Field, 0, ""},
+ {"NS", Type, 1, ""},
+ {"NS.Host", Field, 1, ""},
+ {"OpError", Type, 0, ""},
+ {"OpError.Addr", Field, 0, ""},
+ {"OpError.Err", Field, 0, ""},
+ {"OpError.Net", Field, 0, ""},
+ {"OpError.Op", Field, 0, ""},
+ {"OpError.Source", Field, 5, ""},
+ {"PacketConn", Type, 0, ""},
+ {"ParseCIDR", Func, 0, "func(s string) (IP, *IPNet, error)"},
+ {"ParseError", Type, 0, ""},
+ {"ParseError.Text", Field, 0, ""},
+ {"ParseError.Type", Field, 0, ""},
+ {"ParseIP", Func, 0, "func(s string) IP"},
+ {"ParseMAC", Func, 0, "func(s string) (hw HardwareAddr, err error)"},
+ {"Pipe", Func, 0, "func() (Conn, Conn)"},
+ {"ResolveIPAddr", Func, 0, "func(network string, address string) (*IPAddr, error)"},
+ {"ResolveTCPAddr", Func, 0, "func(network string, address string) (*TCPAddr, error)"},
+ {"ResolveUDPAddr", Func, 0, "func(network string, address string) (*UDPAddr, error)"},
+ {"ResolveUnixAddr", Func, 0, "func(network string, address string) (*UnixAddr, error)"},
+ {"Resolver", Type, 8, ""},
+ {"Resolver.Dial", Field, 9, ""},
+ {"Resolver.PreferGo", Field, 8, ""},
+ {"Resolver.StrictErrors", Field, 9, ""},
+ {"SRV", Type, 0, ""},
+ {"SRV.Port", Field, 0, ""},
+ {"SRV.Priority", Field, 0, ""},
+ {"SRV.Target", Field, 0, ""},
+ {"SRV.Weight", Field, 0, ""},
+ {"SplitHostPort", Func, 0, "func(hostport string) (host string, port string, err error)"},
+ {"TCPAddr", Type, 0, ""},
+ {"TCPAddr.IP", Field, 0, ""},
+ {"TCPAddr.Port", Field, 0, ""},
+ {"TCPAddr.Zone", Field, 1, ""},
+ {"TCPAddrFromAddrPort", Func, 18, "func(addr netip.AddrPort) *TCPAddr"},
+ {"TCPConn", Type, 0, ""},
+ {"TCPListener", Type, 0, ""},
+ {"UDPAddr", Type, 0, ""},
+ {"UDPAddr.IP", Field, 0, ""},
+ {"UDPAddr.Port", Field, 0, ""},
+ {"UDPAddr.Zone", Field, 1, ""},
+ {"UDPAddrFromAddrPort", Func, 18, "func(addr netip.AddrPort) *UDPAddr"},
+ {"UDPConn", Type, 0, ""},
+ {"UnixAddr", Type, 0, ""},
+ {"UnixAddr.Name", Field, 0, ""},
+ {"UnixAddr.Net", Field, 0, ""},
+ {"UnixConn", Type, 0, ""},
+ {"UnixListener", Type, 0, ""},
+ {"UnknownNetworkError", Type, 0, ""},
+ },
+ "net/http": {
+ {"(*Client).CloseIdleConnections", Method, 12, ""},
+ {"(*Client).Do", Method, 0, ""},
+ {"(*Client).Get", Method, 0, ""},
+ {"(*Client).Head", Method, 0, ""},
+ {"(*Client).Post", Method, 0, ""},
+ {"(*Client).PostForm", Method, 0, ""},
+ {"(*Cookie).String", Method, 0, ""},
+ {"(*Cookie).Valid", Method, 18, ""},
+ {"(*MaxBytesError).Error", Method, 19, ""},
+ {"(*ProtocolError).Error", Method, 0, ""},
+ {"(*ProtocolError).Is", Method, 21, ""},
+ {"(*Protocols).SetHTTP1", Method, 24, ""},
+ {"(*Protocols).SetHTTP2", Method, 24, ""},
+ {"(*Protocols).SetUnencryptedHTTP2", Method, 24, ""},
+ {"(*Request).AddCookie", Method, 0, ""},
+ {"(*Request).BasicAuth", Method, 4, ""},
+ {"(*Request).Clone", Method, 13, ""},
+ {"(*Request).Context", Method, 7, ""},
+ {"(*Request).Cookie", Method, 0, ""},
+ {"(*Request).Cookies", Method, 0, ""},
+ {"(*Request).CookiesNamed", Method, 23, ""},
+ {"(*Request).FormFile", Method, 0, ""},
+ {"(*Request).FormValue", Method, 0, ""},
+ {"(*Request).MultipartReader", Method, 0, ""},
+ {"(*Request).ParseForm", Method, 0, ""},
+ {"(*Request).ParseMultipartForm", Method, 0, ""},
+ {"(*Request).PathValue", Method, 22, ""},
+ {"(*Request).PostFormValue", Method, 1, ""},
+ {"(*Request).ProtoAtLeast", Method, 0, ""},
+ {"(*Request).Referer", Method, 0, ""},
+ {"(*Request).SetBasicAuth", Method, 0, ""},
+ {"(*Request).SetPathValue", Method, 22, ""},
+ {"(*Request).UserAgent", Method, 0, ""},
+ {"(*Request).WithContext", Method, 7, ""},
+ {"(*Request).Write", Method, 0, ""},
+ {"(*Request).WriteProxy", Method, 0, ""},
+ {"(*Response).Cookies", Method, 0, ""},
+ {"(*Response).Location", Method, 0, ""},
+ {"(*Response).ProtoAtLeast", Method, 0, ""},
+ {"(*Response).Write", Method, 0, ""},
+ {"(*ResponseController).EnableFullDuplex", Method, 21, ""},
+ {"(*ResponseController).Flush", Method, 20, ""},
+ {"(*ResponseController).Hijack", Method, 20, ""},
+ {"(*ResponseController).SetReadDeadline", Method, 20, ""},
+ {"(*ResponseController).SetWriteDeadline", Method, 20, ""},
+ {"(*ServeMux).Handle", Method, 0, ""},
+ {"(*ServeMux).HandleFunc", Method, 0, ""},
+ {"(*ServeMux).Handler", Method, 1, ""},
+ {"(*ServeMux).ServeHTTP", Method, 0, ""},
+ {"(*Server).Close", Method, 8, ""},
+ {"(*Server).ListenAndServe", Method, 0, ""},
+ {"(*Server).ListenAndServeTLS", Method, 0, ""},
+ {"(*Server).RegisterOnShutdown", Method, 9, ""},
+ {"(*Server).Serve", Method, 0, ""},
+ {"(*Server).ServeTLS", Method, 9, ""},
+ {"(*Server).SetKeepAlivesEnabled", Method, 3, ""},
+ {"(*Server).Shutdown", Method, 8, ""},
+ {"(*Transport).CancelRequest", Method, 1, ""},
+ {"(*Transport).Clone", Method, 13, ""},
+ {"(*Transport).CloseIdleConnections", Method, 0, ""},
+ {"(*Transport).RegisterProtocol", Method, 0, ""},
+ {"(*Transport).RoundTrip", Method, 0, ""},
+ {"(ConnState).String", Method, 3, ""},
+ {"(Dir).Open", Method, 0, ""},
+ {"(HandlerFunc).ServeHTTP", Method, 0, ""},
+ {"(Header).Add", Method, 0, ""},
+ {"(Header).Clone", Method, 13, ""},
+ {"(Header).Del", Method, 0, ""},
+ {"(Header).Get", Method, 0, ""},
+ {"(Header).Set", Method, 0, ""},
+ {"(Header).Values", Method, 14, ""},
+ {"(Header).Write", Method, 0, ""},
+ {"(Header).WriteSubset", Method, 0, ""},
+ {"(Protocols).HTTP1", Method, 24, ""},
+ {"(Protocols).HTTP2", Method, 24, ""},
+ {"(Protocols).String", Method, 24, ""},
+ {"(Protocols).UnencryptedHTTP2", Method, 24, ""},
+ {"AllowQuerySemicolons", Func, 17, "func(h Handler) Handler"},
+ {"CanonicalHeaderKey", Func, 0, "func(s string) string"},
+ {"Client", Type, 0, ""},
+ {"Client.CheckRedirect", Field, 0, ""},
+ {"Client.Jar", Field, 0, ""},
+ {"Client.Timeout", Field, 3, ""},
+ {"Client.Transport", Field, 0, ""},
+ {"CloseNotifier", Type, 1, ""},
+ {"ConnState", Type, 3, ""},
+ {"Cookie", Type, 0, ""},
+ {"Cookie.Domain", Field, 0, ""},
+ {"Cookie.Expires", Field, 0, ""},
+ {"Cookie.HttpOnly", Field, 0, ""},
+ {"Cookie.MaxAge", Field, 0, ""},
+ {"Cookie.Name", Field, 0, ""},
+ {"Cookie.Partitioned", Field, 23, ""},
+ {"Cookie.Path", Field, 0, ""},
+ {"Cookie.Quoted", Field, 23, ""},
+ {"Cookie.Raw", Field, 0, ""},
+ {"Cookie.RawExpires", Field, 0, ""},
+ {"Cookie.SameSite", Field, 11, ""},
+ {"Cookie.Secure", Field, 0, ""},
+ {"Cookie.Unparsed", Field, 0, ""},
+ {"Cookie.Value", Field, 0, ""},
+ {"CookieJar", Type, 0, ""},
+ {"DefaultClient", Var, 0, ""},
+ {"DefaultMaxHeaderBytes", Const, 0, ""},
+ {"DefaultMaxIdleConnsPerHost", Const, 0, ""},
+ {"DefaultServeMux", Var, 0, ""},
+ {"DefaultTransport", Var, 0, ""},
+ {"DetectContentType", Func, 0, "func(data []byte) string"},
+ {"Dir", Type, 0, ""},
+ {"ErrAbortHandler", Var, 8, ""},
+ {"ErrBodyNotAllowed", Var, 0, ""},
+ {"ErrBodyReadAfterClose", Var, 0, ""},
+ {"ErrContentLength", Var, 0, ""},
+ {"ErrHandlerTimeout", Var, 0, ""},
+ {"ErrHeaderTooLong", Var, 0, ""},
+ {"ErrHijacked", Var, 0, ""},
+ {"ErrLineTooLong", Var, 0, ""},
+ {"ErrMissingBoundary", Var, 0, ""},
+ {"ErrMissingContentLength", Var, 0, ""},
+ {"ErrMissingFile", Var, 0, ""},
+ {"ErrNoCookie", Var, 0, ""},
+ {"ErrNoLocation", Var, 0, ""},
+ {"ErrNotMultipart", Var, 0, ""},
+ {"ErrNotSupported", Var, 0, ""},
+ {"ErrSchemeMismatch", Var, 21, ""},
+ {"ErrServerClosed", Var, 8, ""},
+ {"ErrShortBody", Var, 0, ""},
+ {"ErrSkipAltProtocol", Var, 6, ""},
+ {"ErrUnexpectedTrailer", Var, 0, ""},
+ {"ErrUseLastResponse", Var, 7, ""},
+ {"ErrWriteAfterFlush", Var, 0, ""},
+ {"Error", Func, 0, "func(w ResponseWriter, error string, code int)"},
+ {"FS", Func, 16, "func(fsys fs.FS) FileSystem"},
+ {"File", Type, 0, ""},
+ {"FileServer", Func, 0, "func(root FileSystem) Handler"},
+ {"FileServerFS", Func, 22, "func(root fs.FS) Handler"},
+ {"FileSystem", Type, 0, ""},
+ {"Flusher", Type, 0, ""},
+ {"Get", Func, 0, "func(url string) (resp *Response, err error)"},
+ {"HTTP2Config", Type, 24, ""},
+ {"HTTP2Config.CountError", Field, 24, ""},
+ {"HTTP2Config.MaxConcurrentStreams", Field, 24, ""},
+ {"HTTP2Config.MaxDecoderHeaderTableSize", Field, 24, ""},
+ {"HTTP2Config.MaxEncoderHeaderTableSize", Field, 24, ""},
+ {"HTTP2Config.MaxReadFrameSize", Field, 24, ""},
+ {"HTTP2Config.MaxReceiveBufferPerConnection", Field, 24, ""},
+ {"HTTP2Config.MaxReceiveBufferPerStream", Field, 24, ""},
+ {"HTTP2Config.PermitProhibitedCipherSuites", Field, 24, ""},
+ {"HTTP2Config.PingTimeout", Field, 24, ""},
+ {"HTTP2Config.SendPingTimeout", Field, 24, ""},
+ {"HTTP2Config.WriteByteTimeout", Field, 24, ""},
+ {"Handle", Func, 0, "func(pattern string, handler Handler)"},
+ {"HandleFunc", Func, 0, "func(pattern string, handler func(ResponseWriter, *Request))"},
+ {"Handler", Type, 0, ""},
+ {"HandlerFunc", Type, 0, ""},
+ {"Head", Func, 0, "func(url string) (resp *Response, err error)"},
+ {"Header", Type, 0, ""},
+ {"Hijacker", Type, 0, ""},
+ {"ListenAndServe", Func, 0, "func(addr string, handler Handler) error"},
+ {"ListenAndServeTLS", Func, 0, "func(addr string, certFile string, keyFile string, handler Handler) error"},
+ {"LocalAddrContextKey", Var, 7, ""},
+ {"MaxBytesError", Type, 19, ""},
+ {"MaxBytesError.Limit", Field, 19, ""},
+ {"MaxBytesHandler", Func, 18, "func(h Handler, n int64) Handler"},
+ {"MaxBytesReader", Func, 0, "func(w ResponseWriter, r io.ReadCloser, n int64) io.ReadCloser"},
+ {"MethodConnect", Const, 6, ""},
+ {"MethodDelete", Const, 6, ""},
+ {"MethodGet", Const, 6, ""},
+ {"MethodHead", Const, 6, ""},
+ {"MethodOptions", Const, 6, ""},
+ {"MethodPatch", Const, 6, ""},
+ {"MethodPost", Const, 6, ""},
+ {"MethodPut", Const, 6, ""},
+ {"MethodTrace", Const, 6, ""},
+ {"NewFileTransport", Func, 0, "func(fs FileSystem) RoundTripper"},
+ {"NewFileTransportFS", Func, 22, "func(fsys fs.FS) RoundTripper"},
+ {"NewRequest", Func, 0, "func(method string, url string, body io.Reader) (*Request, error)"},
+ {"NewRequestWithContext", Func, 13, "func(ctx context.Context, method string, url string, body io.Reader) (*Request, error)"},
+ {"NewResponseController", Func, 20, "func(rw ResponseWriter) *ResponseController"},
+ {"NewServeMux", Func, 0, "func() *ServeMux"},
+ {"NoBody", Var, 8, ""},
+ {"NotFound", Func, 0, "func(w ResponseWriter, r *Request)"},
+ {"NotFoundHandler", Func, 0, "func() Handler"},
+ {"ParseCookie", Func, 23, "func(line string) ([]*Cookie, error)"},
+ {"ParseHTTPVersion", Func, 0, "func(vers string) (major int, minor int, ok bool)"},
+ {"ParseSetCookie", Func, 23, "func(line string) (*Cookie, error)"},
+ {"ParseTime", Func, 1, "func(text string) (t time.Time, err error)"},
+ {"Post", Func, 0, "func(url string, contentType string, body io.Reader) (resp *Response, err error)"},
+ {"PostForm", Func, 0, "func(url string, data url.Values) (resp *Response, err error)"},
+ {"ProtocolError", Type, 0, ""},
+ {"ProtocolError.ErrorString", Field, 0, ""},
+ {"Protocols", Type, 24, ""},
+ {"ProxyFromEnvironment", Func, 0, "func(req *Request) (*url.URL, error)"},
+ {"ProxyURL", Func, 0, "func(fixedURL *url.URL) func(*Request) (*url.URL, error)"},
+ {"PushOptions", Type, 8, ""},
+ {"PushOptions.Header", Field, 8, ""},
+ {"PushOptions.Method", Field, 8, ""},
+ {"Pusher", Type, 8, ""},
+ {"ReadRequest", Func, 0, "func(b *bufio.Reader) (*Request, error)"},
+ {"ReadResponse", Func, 0, "func(r *bufio.Reader, req *Request) (*Response, error)"},
+ {"Redirect", Func, 0, "func(w ResponseWriter, r *Request, url string, code int)"},
+ {"RedirectHandler", Func, 0, "func(url string, code int) Handler"},
+ {"Request", Type, 0, ""},
+ {"Request.Body", Field, 0, ""},
+ {"Request.Cancel", Field, 5, ""},
+ {"Request.Close", Field, 0, ""},
+ {"Request.ContentLength", Field, 0, ""},
+ {"Request.Form", Field, 0, ""},
+ {"Request.GetBody", Field, 8, ""},
+ {"Request.Header", Field, 0, ""},
+ {"Request.Host", Field, 0, ""},
+ {"Request.Method", Field, 0, ""},
+ {"Request.MultipartForm", Field, 0, ""},
+ {"Request.Pattern", Field, 23, ""},
+ {"Request.PostForm", Field, 1, ""},
+ {"Request.Proto", Field, 0, ""},
+ {"Request.ProtoMajor", Field, 0, ""},
+ {"Request.ProtoMinor", Field, 0, ""},
+ {"Request.RemoteAddr", Field, 0, ""},
+ {"Request.RequestURI", Field, 0, ""},
+ {"Request.Response", Field, 7, ""},
+ {"Request.TLS", Field, 0, ""},
+ {"Request.Trailer", Field, 0, ""},
+ {"Request.TransferEncoding", Field, 0, ""},
+ {"Request.URL", Field, 0, ""},
+ {"Response", Type, 0, ""},
+ {"Response.Body", Field, 0, ""},
+ {"Response.Close", Field, 0, ""},
+ {"Response.ContentLength", Field, 0, ""},
+ {"Response.Header", Field, 0, ""},
+ {"Response.Proto", Field, 0, ""},
+ {"Response.ProtoMajor", Field, 0, ""},
+ {"Response.ProtoMinor", Field, 0, ""},
+ {"Response.Request", Field, 0, ""},
+ {"Response.Status", Field, 0, ""},
+ {"Response.StatusCode", Field, 0, ""},
+ {"Response.TLS", Field, 3, ""},
+ {"Response.Trailer", Field, 0, ""},
+ {"Response.TransferEncoding", Field, 0, ""},
+ {"Response.Uncompressed", Field, 7, ""},
+ {"ResponseController", Type, 20, ""},
+ {"ResponseWriter", Type, 0, ""},
+ {"RoundTripper", Type, 0, ""},
+ {"SameSite", Type, 11, ""},
+ {"SameSiteDefaultMode", Const, 11, ""},
+ {"SameSiteLaxMode", Const, 11, ""},
+ {"SameSiteNoneMode", Const, 13, ""},
+ {"SameSiteStrictMode", Const, 11, ""},
+ {"Serve", Func, 0, "func(l net.Listener, handler Handler) error"},
+ {"ServeContent", Func, 0, "func(w ResponseWriter, req *Request, name string, modtime time.Time, content io.ReadSeeker)"},
+ {"ServeFile", Func, 0, "func(w ResponseWriter, r *Request, name string)"},
+ {"ServeFileFS", Func, 22, "func(w ResponseWriter, r *Request, fsys fs.FS, name string)"},
+ {"ServeMux", Type, 0, ""},
+ {"ServeTLS", Func, 9, "func(l net.Listener, handler Handler, certFile string, keyFile string) error"},
+ {"Server", Type, 0, ""},
+ {"Server.Addr", Field, 0, ""},
+ {"Server.BaseContext", Field, 13, ""},
+ {"Server.ConnContext", Field, 13, ""},
+ {"Server.ConnState", Field, 3, ""},
+ {"Server.DisableGeneralOptionsHandler", Field, 20, ""},
+ {"Server.ErrorLog", Field, 3, ""},
+ {"Server.HTTP2", Field, 24, ""},
+ {"Server.Handler", Field, 0, ""},
+ {"Server.IdleTimeout", Field, 8, ""},
+ {"Server.MaxHeaderBytes", Field, 0, ""},
+ {"Server.Protocols", Field, 24, ""},
+ {"Server.ReadHeaderTimeout", Field, 8, ""},
+ {"Server.ReadTimeout", Field, 0, ""},
+ {"Server.TLSConfig", Field, 0, ""},
+ {"Server.TLSNextProto", Field, 1, ""},
+ {"Server.WriteTimeout", Field, 0, ""},
+ {"ServerContextKey", Var, 7, ""},
+ {"SetCookie", Func, 0, "func(w ResponseWriter, cookie *Cookie)"},
+ {"StateActive", Const, 3, ""},
+ {"StateClosed", Const, 3, ""},
+ {"StateHijacked", Const, 3, ""},
+ {"StateIdle", Const, 3, ""},
+ {"StateNew", Const, 3, ""},
+ {"StatusAccepted", Const, 0, ""},
+ {"StatusAlreadyReported", Const, 7, ""},
+ {"StatusBadGateway", Const, 0, ""},
+ {"StatusBadRequest", Const, 0, ""},
+ {"StatusConflict", Const, 0, ""},
+ {"StatusContinue", Const, 0, ""},
+ {"StatusCreated", Const, 0, ""},
+ {"StatusEarlyHints", Const, 13, ""},
+ {"StatusExpectationFailed", Const, 0, ""},
+ {"StatusFailedDependency", Const, 7, ""},
+ {"StatusForbidden", Const, 0, ""},
+ {"StatusFound", Const, 0, ""},
+ {"StatusGatewayTimeout", Const, 0, ""},
+ {"StatusGone", Const, 0, ""},
+ {"StatusHTTPVersionNotSupported", Const, 0, ""},
+ {"StatusIMUsed", Const, 7, ""},
+ {"StatusInsufficientStorage", Const, 7, ""},
+ {"StatusInternalServerError", Const, 0, ""},
+ {"StatusLengthRequired", Const, 0, ""},
+ {"StatusLocked", Const, 7, ""},
+ {"StatusLoopDetected", Const, 7, ""},
+ {"StatusMethodNotAllowed", Const, 0, ""},
+ {"StatusMisdirectedRequest", Const, 11, ""},
+ {"StatusMovedPermanently", Const, 0, ""},
+ {"StatusMultiStatus", Const, 7, ""},
+ {"StatusMultipleChoices", Const, 0, ""},
+ {"StatusNetworkAuthenticationRequired", Const, 6, ""},
+ {"StatusNoContent", Const, 0, ""},
+ {"StatusNonAuthoritativeInfo", Const, 0, ""},
+ {"StatusNotAcceptable", Const, 0, ""},
+ {"StatusNotExtended", Const, 7, ""},
+ {"StatusNotFound", Const, 0, ""},
+ {"StatusNotImplemented", Const, 0, ""},
+ {"StatusNotModified", Const, 0, ""},
+ {"StatusOK", Const, 0, ""},
+ {"StatusPartialContent", Const, 0, ""},
+ {"StatusPaymentRequired", Const, 0, ""},
+ {"StatusPermanentRedirect", Const, 7, ""},
+ {"StatusPreconditionFailed", Const, 0, ""},
+ {"StatusPreconditionRequired", Const, 6, ""},
+ {"StatusProcessing", Const, 7, ""},
+ {"StatusProxyAuthRequired", Const, 0, ""},
+ {"StatusRequestEntityTooLarge", Const, 0, ""},
+ {"StatusRequestHeaderFieldsTooLarge", Const, 6, ""},
+ {"StatusRequestTimeout", Const, 0, ""},
+ {"StatusRequestURITooLong", Const, 0, ""},
+ {"StatusRequestedRangeNotSatisfiable", Const, 0, ""},
+ {"StatusResetContent", Const, 0, ""},
+ {"StatusSeeOther", Const, 0, ""},
+ {"StatusServiceUnavailable", Const, 0, ""},
+ {"StatusSwitchingProtocols", Const, 0, ""},
+ {"StatusTeapot", Const, 0, ""},
+ {"StatusTemporaryRedirect", Const, 0, ""},
+ {"StatusText", Func, 0, "func(code int) string"},
+ {"StatusTooEarly", Const, 12, ""},
+ {"StatusTooManyRequests", Const, 6, ""},
+ {"StatusUnauthorized", Const, 0, ""},
+ {"StatusUnavailableForLegalReasons", Const, 6, ""},
+ {"StatusUnprocessableEntity", Const, 7, ""},
+ {"StatusUnsupportedMediaType", Const, 0, ""},
+ {"StatusUpgradeRequired", Const, 7, ""},
+ {"StatusUseProxy", Const, 0, ""},
+ {"StatusVariantAlsoNegotiates", Const, 7, ""},
+ {"StripPrefix", Func, 0, "func(prefix string, h Handler) Handler"},
+ {"TimeFormat", Const, 0, ""},
+ {"TimeoutHandler", Func, 0, "func(h Handler, dt time.Duration, msg string) Handler"},
+ {"TrailerPrefix", Const, 8, ""},
+ {"Transport", Type, 0, ""},
+ {"Transport.Dial", Field, 0, ""},
+ {"Transport.DialContext", Field, 7, ""},
+ {"Transport.DialTLS", Field, 4, ""},
+ {"Transport.DialTLSContext", Field, 14, ""},
+ {"Transport.DisableCompression", Field, 0, ""},
+ {"Transport.DisableKeepAlives", Field, 0, ""},
+ {"Transport.ExpectContinueTimeout", Field, 6, ""},
+ {"Transport.ForceAttemptHTTP2", Field, 13, ""},
+ {"Transport.GetProxyConnectHeader", Field, 16, ""},
+ {"Transport.HTTP2", Field, 24, ""},
+ {"Transport.IdleConnTimeout", Field, 7, ""},
+ {"Transport.MaxConnsPerHost", Field, 11, ""},
+ {"Transport.MaxIdleConns", Field, 7, ""},
+ {"Transport.MaxIdleConnsPerHost", Field, 0, ""},
+ {"Transport.MaxResponseHeaderBytes", Field, 7, ""},
+ {"Transport.OnProxyConnectResponse", Field, 20, ""},
+ {"Transport.Protocols", Field, 24, ""},
+ {"Transport.Proxy", Field, 0, ""},
+ {"Transport.ProxyConnectHeader", Field, 8, ""},
+ {"Transport.ReadBufferSize", Field, 13, ""},
+ {"Transport.ResponseHeaderTimeout", Field, 1, ""},
+ {"Transport.TLSClientConfig", Field, 0, ""},
+ {"Transport.TLSHandshakeTimeout", Field, 3, ""},
+ {"Transport.TLSNextProto", Field, 6, ""},
+ {"Transport.WriteBufferSize", Field, 13, ""},
+ },
+ "net/http/cgi": {
+ {"(*Handler).ServeHTTP", Method, 0, ""},
+ {"Handler", Type, 0, ""},
+ {"Handler.Args", Field, 0, ""},
+ {"Handler.Dir", Field, 0, ""},
+ {"Handler.Env", Field, 0, ""},
+ {"Handler.InheritEnv", Field, 0, ""},
+ {"Handler.Logger", Field, 0, ""},
+ {"Handler.Path", Field, 0, ""},
+ {"Handler.PathLocationHandler", Field, 0, ""},
+ {"Handler.Root", Field, 0, ""},
+ {"Handler.Stderr", Field, 7, ""},
+ {"Request", Func, 0, "func() (*http.Request, error)"},
+ {"RequestFromMap", Func, 0, "func(params map[string]string) (*http.Request, error)"},
+ {"Serve", Func, 0, "func(handler http.Handler) error"},
+ },
+ "net/http/cookiejar": {
+ {"(*Jar).Cookies", Method, 1, ""},
+ {"(*Jar).SetCookies", Method, 1, ""},
+ {"Jar", Type, 1, ""},
+ {"New", Func, 1, "func(o *Options) (*Jar, error)"},
+ {"Options", Type, 1, ""},
+ {"Options.PublicSuffixList", Field, 1, ""},
+ {"PublicSuffixList", Type, 1, ""},
+ },
+ "net/http/fcgi": {
+ {"ErrConnClosed", Var, 5, ""},
+ {"ErrRequestAborted", Var, 5, ""},
+ {"ProcessEnv", Func, 9, "func(r *http.Request) map[string]string"},
+ {"Serve", Func, 0, "func(l net.Listener, handler http.Handler) error"},
+ },
+ "net/http/httptest": {
+ {"(*ResponseRecorder).Flush", Method, 0, ""},
+ {"(*ResponseRecorder).Header", Method, 0, ""},
+ {"(*ResponseRecorder).Result", Method, 7, ""},
+ {"(*ResponseRecorder).Write", Method, 0, ""},
+ {"(*ResponseRecorder).WriteHeader", Method, 0, ""},
+ {"(*ResponseRecorder).WriteString", Method, 6, ""},
+ {"(*Server).Certificate", Method, 9, ""},
+ {"(*Server).Client", Method, 9, ""},
+ {"(*Server).Close", Method, 0, ""},
+ {"(*Server).CloseClientConnections", Method, 0, ""},
+ {"(*Server).Start", Method, 0, ""},
+ {"(*Server).StartTLS", Method, 0, ""},
+ {"DefaultRemoteAddr", Const, 0, ""},
+ {"NewRecorder", Func, 0, "func() *ResponseRecorder"},
+ {"NewRequest", Func, 7, "func(method string, target string, body io.Reader) *http.Request"},
+ {"NewRequestWithContext", Func, 23, "func(ctx context.Context, method string, target string, body io.Reader) *http.Request"},
+ {"NewServer", Func, 0, "func(handler http.Handler) *Server"},
+ {"NewTLSServer", Func, 0, "func(handler http.Handler) *Server"},
+ {"NewUnstartedServer", Func, 0, "func(handler http.Handler) *Server"},
+ {"ResponseRecorder", Type, 0, ""},
+ {"ResponseRecorder.Body", Field, 0, ""},
+ {"ResponseRecorder.Code", Field, 0, ""},
+ {"ResponseRecorder.Flushed", Field, 0, ""},
+ {"ResponseRecorder.HeaderMap", Field, 0, ""},
+ {"Server", Type, 0, ""},
+ {"Server.Config", Field, 0, ""},
+ {"Server.EnableHTTP2", Field, 14, ""},
+ {"Server.Listener", Field, 0, ""},
+ {"Server.TLS", Field, 0, ""},
+ {"Server.URL", Field, 0, ""},
+ },
+ "net/http/httptrace": {
+ {"ClientTrace", Type, 7, ""},
+ {"ClientTrace.ConnectDone", Field, 7, ""},
+ {"ClientTrace.ConnectStart", Field, 7, ""},
+ {"ClientTrace.DNSDone", Field, 7, ""},
+ {"ClientTrace.DNSStart", Field, 7, ""},
+ {"ClientTrace.GetConn", Field, 7, ""},
+ {"ClientTrace.Got100Continue", Field, 7, ""},
+ {"ClientTrace.Got1xxResponse", Field, 11, ""},
+ {"ClientTrace.GotConn", Field, 7, ""},
+ {"ClientTrace.GotFirstResponseByte", Field, 7, ""},
+ {"ClientTrace.PutIdleConn", Field, 7, ""},
+ {"ClientTrace.TLSHandshakeDone", Field, 8, ""},
+ {"ClientTrace.TLSHandshakeStart", Field, 8, ""},
+ {"ClientTrace.Wait100Continue", Field, 7, ""},
+ {"ClientTrace.WroteHeaderField", Field, 11, ""},
+ {"ClientTrace.WroteHeaders", Field, 7, ""},
+ {"ClientTrace.WroteRequest", Field, 7, ""},
+ {"ContextClientTrace", Func, 7, "func(ctx context.Context) *ClientTrace"},
+ {"DNSDoneInfo", Type, 7, ""},
+ {"DNSDoneInfo.Addrs", Field, 7, ""},
+ {"DNSDoneInfo.Coalesced", Field, 7, ""},
+ {"DNSDoneInfo.Err", Field, 7, ""},
+ {"DNSStartInfo", Type, 7, ""},
+ {"DNSStartInfo.Host", Field, 7, ""},
+ {"GotConnInfo", Type, 7, ""},
+ {"GotConnInfo.Conn", Field, 7, ""},
+ {"GotConnInfo.IdleTime", Field, 7, ""},
+ {"GotConnInfo.Reused", Field, 7, ""},
+ {"GotConnInfo.WasIdle", Field, 7, ""},
+ {"WithClientTrace", Func, 7, "func(ctx context.Context, trace *ClientTrace) context.Context"},
+ {"WroteRequestInfo", Type, 7, ""},
+ {"WroteRequestInfo.Err", Field, 7, ""},
+ },
+ "net/http/httputil": {
+ {"(*ClientConn).Close", Method, 0, ""},
+ {"(*ClientConn).Do", Method, 0, ""},
+ {"(*ClientConn).Hijack", Method, 0, ""},
+ {"(*ClientConn).Pending", Method, 0, ""},
+ {"(*ClientConn).Read", Method, 0, ""},
+ {"(*ClientConn).Write", Method, 0, ""},
+ {"(*ProxyRequest).SetURL", Method, 20, ""},
+ {"(*ProxyRequest).SetXForwarded", Method, 20, ""},
+ {"(*ReverseProxy).ServeHTTP", Method, 0, ""},
+ {"(*ServerConn).Close", Method, 0, ""},
+ {"(*ServerConn).Hijack", Method, 0, ""},
+ {"(*ServerConn).Pending", Method, 0, ""},
+ {"(*ServerConn).Read", Method, 0, ""},
+ {"(*ServerConn).Write", Method, 0, ""},
+ {"BufferPool", Type, 6, ""},
+ {"ClientConn", Type, 0, ""},
+ {"DumpRequest", Func, 0, "func(req *http.Request, body bool) ([]byte, error)"},
+ {"DumpRequestOut", Func, 0, "func(req *http.Request, body bool) ([]byte, error)"},
+ {"DumpResponse", Func, 0, "func(resp *http.Response, body bool) ([]byte, error)"},
+ {"ErrClosed", Var, 0, ""},
+ {"ErrLineTooLong", Var, 0, ""},
+ {"ErrPersistEOF", Var, 0, ""},
+ {"ErrPipeline", Var, 0, ""},
+ {"NewChunkedReader", Func, 0, "func(r io.Reader) io.Reader"},
+ {"NewChunkedWriter", Func, 0, "func(w io.Writer) io.WriteCloser"},
+ {"NewClientConn", Func, 0, "func(c net.Conn, r *bufio.Reader) *ClientConn"},
+ {"NewProxyClientConn", Func, 0, "func(c net.Conn, r *bufio.Reader) *ClientConn"},
+ {"NewServerConn", Func, 0, "func(c net.Conn, r *bufio.Reader) *ServerConn"},
+ {"NewSingleHostReverseProxy", Func, 0, "func(target *url.URL) *ReverseProxy"},
+ {"ProxyRequest", Type, 20, ""},
+ {"ProxyRequest.In", Field, 20, ""},
+ {"ProxyRequest.Out", Field, 20, ""},
+ {"ReverseProxy", Type, 0, ""},
+ {"ReverseProxy.BufferPool", Field, 6, ""},
+ {"ReverseProxy.Director", Field, 0, ""},
+ {"ReverseProxy.ErrorHandler", Field, 11, ""},
+ {"ReverseProxy.ErrorLog", Field, 4, ""},
+ {"ReverseProxy.FlushInterval", Field, 0, ""},
+ {"ReverseProxy.ModifyResponse", Field, 8, ""},
+ {"ReverseProxy.Rewrite", Field, 20, ""},
+ {"ReverseProxy.Transport", Field, 0, ""},
+ {"ServerConn", Type, 0, ""},
+ },
+ "net/http/pprof": {
+ {"Cmdline", Func, 0, "func(w http.ResponseWriter, r *http.Request)"},
+ {"Handler", Func, 0, "func(name string) http.Handler"},
+ {"Index", Func, 0, "func(w http.ResponseWriter, r *http.Request)"},
+ {"Profile", Func, 0, "func(w http.ResponseWriter, r *http.Request)"},
+ {"Symbol", Func, 0, "func(w http.ResponseWriter, r *http.Request)"},
+ {"Trace", Func, 5, "func(w http.ResponseWriter, r *http.Request)"},
+ },
+ "net/mail": {
+ {"(*Address).String", Method, 0, ""},
+ {"(*AddressParser).Parse", Method, 5, ""},
+ {"(*AddressParser).ParseList", Method, 5, ""},
+ {"(Header).AddressList", Method, 0, ""},
+ {"(Header).Date", Method, 0, ""},
+ {"(Header).Get", Method, 0, ""},
+ {"Address", Type, 0, ""},
+ {"Address.Address", Field, 0, ""},
+ {"Address.Name", Field, 0, ""},
+ {"AddressParser", Type, 5, ""},
+ {"AddressParser.WordDecoder", Field, 5, ""},
+ {"ErrHeaderNotPresent", Var, 0, ""},
+ {"Header", Type, 0, ""},
+ {"Message", Type, 0, ""},
+ {"Message.Body", Field, 0, ""},
+ {"Message.Header", Field, 0, ""},
+ {"ParseAddress", Func, 1, "func(address string) (*Address, error)"},
+ {"ParseAddressList", Func, 1, "func(list string) ([]*Address, error)"},
+ {"ParseDate", Func, 8, "func(date string) (time.Time, error)"},
+ {"ReadMessage", Func, 0, "func(r io.Reader) (msg *Message, err error)"},
+ },
+ "net/netip": {
+ {"(*Addr).UnmarshalBinary", Method, 18, ""},
+ {"(*Addr).UnmarshalText", Method, 18, ""},
+ {"(*AddrPort).UnmarshalBinary", Method, 18, ""},
+ {"(*AddrPort).UnmarshalText", Method, 18, ""},
+ {"(*Prefix).UnmarshalBinary", Method, 18, ""},
+ {"(*Prefix).UnmarshalText", Method, 18, ""},
+ {"(Addr).AppendBinary", Method, 24, ""},
+ {"(Addr).AppendText", Method, 24, ""},
+ {"(Addr).AppendTo", Method, 18, ""},
+ {"(Addr).As16", Method, 18, ""},
+ {"(Addr).As4", Method, 18, ""},
+ {"(Addr).AsSlice", Method, 18, ""},
+ {"(Addr).BitLen", Method, 18, ""},
+ {"(Addr).Compare", Method, 18, ""},
+ {"(Addr).Is4", Method, 18, ""},
+ {"(Addr).Is4In6", Method, 18, ""},
+ {"(Addr).Is6", Method, 18, ""},
+ {"(Addr).IsGlobalUnicast", Method, 18, ""},
+ {"(Addr).IsInterfaceLocalMulticast", Method, 18, ""},
+ {"(Addr).IsLinkLocalMulticast", Method, 18, ""},
+ {"(Addr).IsLinkLocalUnicast", Method, 18, ""},
+ {"(Addr).IsLoopback", Method, 18, ""},
+ {"(Addr).IsMulticast", Method, 18, ""},
+ {"(Addr).IsPrivate", Method, 18, ""},
+ {"(Addr).IsUnspecified", Method, 18, ""},
+ {"(Addr).IsValid", Method, 18, ""},
+ {"(Addr).Less", Method, 18, ""},
+ {"(Addr).MarshalBinary", Method, 18, ""},
+ {"(Addr).MarshalText", Method, 18, ""},
+ {"(Addr).Next", Method, 18, ""},
+ {"(Addr).Prefix", Method, 18, ""},
+ {"(Addr).Prev", Method, 18, ""},
+ {"(Addr).String", Method, 18, ""},
+ {"(Addr).StringExpanded", Method, 18, ""},
+ {"(Addr).Unmap", Method, 18, ""},
+ {"(Addr).WithZone", Method, 18, ""},
+ {"(Addr).Zone", Method, 18, ""},
+ {"(AddrPort).Addr", Method, 18, ""},
+ {"(AddrPort).AppendBinary", Method, 24, ""},
+ {"(AddrPort).AppendText", Method, 24, ""},
+ {"(AddrPort).AppendTo", Method, 18, ""},
+ {"(AddrPort).Compare", Method, 22, ""},
+ {"(AddrPort).IsValid", Method, 18, ""},
+ {"(AddrPort).MarshalBinary", Method, 18, ""},
+ {"(AddrPort).MarshalText", Method, 18, ""},
+ {"(AddrPort).Port", Method, 18, ""},
+ {"(AddrPort).String", Method, 18, ""},
+ {"(Prefix).Addr", Method, 18, ""},
+ {"(Prefix).AppendBinary", Method, 24, ""},
+ {"(Prefix).AppendText", Method, 24, ""},
+ {"(Prefix).AppendTo", Method, 18, ""},
+ {"(Prefix).Bits", Method, 18, ""},
+ {"(Prefix).Contains", Method, 18, ""},
+ {"(Prefix).IsSingleIP", Method, 18, ""},
+ {"(Prefix).IsValid", Method, 18, ""},
+ {"(Prefix).MarshalBinary", Method, 18, ""},
+ {"(Prefix).MarshalText", Method, 18, ""},
+ {"(Prefix).Masked", Method, 18, ""},
+ {"(Prefix).Overlaps", Method, 18, ""},
+ {"(Prefix).String", Method, 18, ""},
+ {"Addr", Type, 18, ""},
+ {"AddrFrom16", Func, 18, "func(addr [16]byte) Addr"},
+ {"AddrFrom4", Func, 18, "func(addr [4]byte) Addr"},
+ {"AddrFromSlice", Func, 18, "func(slice []byte) (ip Addr, ok bool)"},
+ {"AddrPort", Type, 18, ""},
+ {"AddrPortFrom", Func, 18, "func(ip Addr, port uint16) AddrPort"},
+ {"IPv4Unspecified", Func, 18, "func() Addr"},
+ {"IPv6LinkLocalAllNodes", Func, 18, "func() Addr"},
+ {"IPv6LinkLocalAllRouters", Func, 20, "func() Addr"},
+ {"IPv6Loopback", Func, 20, "func() Addr"},
+ {"IPv6Unspecified", Func, 18, "func() Addr"},
+ {"MustParseAddr", Func, 18, "func(s string) Addr"},
+ {"MustParseAddrPort", Func, 18, "func(s string) AddrPort"},
+ {"MustParsePrefix", Func, 18, "func(s string) Prefix"},
+ {"ParseAddr", Func, 18, "func(s string) (Addr, error)"},
+ {"ParseAddrPort", Func, 18, "func(s string) (AddrPort, error)"},
+ {"ParsePrefix", Func, 18, "func(s string) (Prefix, error)"},
+ {"Prefix", Type, 18, ""},
+ {"PrefixFrom", Func, 18, "func(ip Addr, bits int) Prefix"},
+ },
+ "net/rpc": {
+ {"(*Client).Call", Method, 0, ""},
+ {"(*Client).Close", Method, 0, ""},
+ {"(*Client).Go", Method, 0, ""},
+ {"(*Server).Accept", Method, 0, ""},
+ {"(*Server).HandleHTTP", Method, 0, ""},
+ {"(*Server).Register", Method, 0, ""},
+ {"(*Server).RegisterName", Method, 0, ""},
+ {"(*Server).ServeCodec", Method, 0, ""},
+ {"(*Server).ServeConn", Method, 0, ""},
+ {"(*Server).ServeHTTP", Method, 0, ""},
+ {"(*Server).ServeRequest", Method, 0, ""},
+ {"(ServerError).Error", Method, 0, ""},
+ {"Accept", Func, 0, "func(lis net.Listener)"},
+ {"Call", Type, 0, ""},
+ {"Call.Args", Field, 0, ""},
+ {"Call.Done", Field, 0, ""},
+ {"Call.Error", Field, 0, ""},
+ {"Call.Reply", Field, 0, ""},
+ {"Call.ServiceMethod", Field, 0, ""},
+ {"Client", Type, 0, ""},
+ {"ClientCodec", Type, 0, ""},
+ {"DefaultDebugPath", Const, 0, ""},
+ {"DefaultRPCPath", Const, 0, ""},
+ {"DefaultServer", Var, 0, ""},
+ {"Dial", Func, 0, "func(network string, address string) (*Client, error)"},
+ {"DialHTTP", Func, 0, "func(network string, address string) (*Client, error)"},
+ {"DialHTTPPath", Func, 0, "func(network string, address string, path string) (*Client, error)"},
+ {"ErrShutdown", Var, 0, ""},
+ {"HandleHTTP", Func, 0, "func()"},
+ {"NewClient", Func, 0, "func(conn io.ReadWriteCloser) *Client"},
+ {"NewClientWithCodec", Func, 0, "func(codec ClientCodec) *Client"},
+ {"NewServer", Func, 0, "func() *Server"},
+ {"Register", Func, 0, "func(rcvr any) error"},
+ {"RegisterName", Func, 0, "func(name string, rcvr any) error"},
+ {"Request", Type, 0, ""},
+ {"Request.Seq", Field, 0, ""},
+ {"Request.ServiceMethod", Field, 0, ""},
+ {"Response", Type, 0, ""},
+ {"Response.Error", Field, 0, ""},
+ {"Response.Seq", Field, 0, ""},
+ {"Response.ServiceMethod", Field, 0, ""},
+ {"ServeCodec", Func, 0, "func(codec ServerCodec)"},
+ {"ServeConn", Func, 0, "func(conn io.ReadWriteCloser)"},
+ {"ServeRequest", Func, 0, "func(codec ServerCodec) error"},
+ {"Server", Type, 0, ""},
+ {"ServerCodec", Type, 0, ""},
+ {"ServerError", Type, 0, ""},
+ },
+ "net/rpc/jsonrpc": {
+ {"Dial", Func, 0, "func(network string, address string) (*rpc.Client, error)"},
+ {"NewClient", Func, 0, "func(conn io.ReadWriteCloser) *rpc.Client"},
+ {"NewClientCodec", Func, 0, "func(conn io.ReadWriteCloser) rpc.ClientCodec"},
+ {"NewServerCodec", Func, 0, "func(conn io.ReadWriteCloser) rpc.ServerCodec"},
+ {"ServeConn", Func, 0, "func(conn io.ReadWriteCloser)"},
+ },
+ "net/smtp": {
+ {"(*Client).Auth", Method, 0, ""},
+ {"(*Client).Close", Method, 2, ""},
+ {"(*Client).Data", Method, 0, ""},
+ {"(*Client).Extension", Method, 0, ""},
+ {"(*Client).Hello", Method, 1, ""},
+ {"(*Client).Mail", Method, 0, ""},
+ {"(*Client).Noop", Method, 10, ""},
+ {"(*Client).Quit", Method, 0, ""},
+ {"(*Client).Rcpt", Method, 0, ""},
+ {"(*Client).Reset", Method, 0, ""},
+ {"(*Client).StartTLS", Method, 0, ""},
+ {"(*Client).TLSConnectionState", Method, 5, ""},
+ {"(*Client).Verify", Method, 0, ""},
+ {"Auth", Type, 0, ""},
+ {"CRAMMD5Auth", Func, 0, "func(username string, secret string) Auth"},
+ {"Client", Type, 0, ""},
+ {"Client.Text", Field, 0, ""},
+ {"Dial", Func, 0, "func(addr string) (*Client, error)"},
+ {"NewClient", Func, 0, "func(conn net.Conn, host string) (*Client, error)"},
+ {"PlainAuth", Func, 0, "func(identity string, username string, password string, host string) Auth"},
+ {"SendMail", Func, 0, "func(addr string, a Auth, from string, to []string, msg []byte) error"},
+ {"ServerInfo", Type, 0, ""},
+ {"ServerInfo.Auth", Field, 0, ""},
+ {"ServerInfo.Name", Field, 0, ""},
+ {"ServerInfo.TLS", Field, 0, ""},
+ },
+ "net/textproto": {
+ {"(*Conn).Close", Method, 0, ""},
+ {"(*Conn).Cmd", Method, 0, ""},
+ {"(*Conn).DotReader", Method, 0, ""},
+ {"(*Conn).DotWriter", Method, 0, ""},
+ {"(*Conn).EndRequest", Method, 0, ""},
+ {"(*Conn).EndResponse", Method, 0, ""},
+ {"(*Conn).Next", Method, 0, ""},
+ {"(*Conn).PrintfLine", Method, 0, ""},
+ {"(*Conn).ReadCodeLine", Method, 0, ""},
+ {"(*Conn).ReadContinuedLine", Method, 0, ""},
+ {"(*Conn).ReadContinuedLineBytes", Method, 0, ""},
+ {"(*Conn).ReadDotBytes", Method, 0, ""},
+ {"(*Conn).ReadDotLines", Method, 0, ""},
+ {"(*Conn).ReadLine", Method, 0, ""},
+ {"(*Conn).ReadLineBytes", Method, 0, ""},
+ {"(*Conn).ReadMIMEHeader", Method, 0, ""},
+ {"(*Conn).ReadResponse", Method, 0, ""},
+ {"(*Conn).StartRequest", Method, 0, ""},
+ {"(*Conn).StartResponse", Method, 0, ""},
+ {"(*Error).Error", Method, 0, ""},
+ {"(*Pipeline).EndRequest", Method, 0, ""},
+ {"(*Pipeline).EndResponse", Method, 0, ""},
+ {"(*Pipeline).Next", Method, 0, ""},
+ {"(*Pipeline).StartRequest", Method, 0, ""},
+ {"(*Pipeline).StartResponse", Method, 0, ""},
+ {"(*Reader).DotReader", Method, 0, ""},
+ {"(*Reader).ReadCodeLine", Method, 0, ""},
+ {"(*Reader).ReadContinuedLine", Method, 0, ""},
+ {"(*Reader).ReadContinuedLineBytes", Method, 0, ""},
+ {"(*Reader).ReadDotBytes", Method, 0, ""},
+ {"(*Reader).ReadDotLines", Method, 0, ""},
+ {"(*Reader).ReadLine", Method, 0, ""},
+ {"(*Reader).ReadLineBytes", Method, 0, ""},
+ {"(*Reader).ReadMIMEHeader", Method, 0, ""},
+ {"(*Reader).ReadResponse", Method, 0, ""},
+ {"(*Writer).DotWriter", Method, 0, ""},
+ {"(*Writer).PrintfLine", Method, 0, ""},
+ {"(MIMEHeader).Add", Method, 0, ""},
+ {"(MIMEHeader).Del", Method, 0, ""},
+ {"(MIMEHeader).Get", Method, 0, ""},
+ {"(MIMEHeader).Set", Method, 0, ""},
+ {"(MIMEHeader).Values", Method, 14, ""},
+ {"(ProtocolError).Error", Method, 0, ""},
+ {"CanonicalMIMEHeaderKey", Func, 0, "func(s string) string"},
+ {"Conn", Type, 0, ""},
+ {"Conn.Pipeline", Field, 0, ""},
+ {"Conn.Reader", Field, 0, ""},
+ {"Conn.Writer", Field, 0, ""},
+ {"Dial", Func, 0, "func(network string, addr string) (*Conn, error)"},
+ {"Error", Type, 0, ""},
+ {"Error.Code", Field, 0, ""},
+ {"Error.Msg", Field, 0, ""},
+ {"MIMEHeader", Type, 0, ""},
+ {"NewConn", Func, 0, "func(conn io.ReadWriteCloser) *Conn"},
+ {"NewReader", Func, 0, "func(r *bufio.Reader) *Reader"},
+ {"NewWriter", Func, 0, "func(w *bufio.Writer) *Writer"},
+ {"Pipeline", Type, 0, ""},
+ {"ProtocolError", Type, 0, ""},
+ {"Reader", Type, 0, ""},
+ {"Reader.R", Field, 0, ""},
+ {"TrimBytes", Func, 1, "func(b []byte) []byte"},
+ {"TrimString", Func, 1, "func(s string) string"},
+ {"Writer", Type, 0, ""},
+ {"Writer.W", Field, 0, ""},
+ },
+ "net/url": {
+ {"(*Error).Error", Method, 0, ""},
+ {"(*Error).Temporary", Method, 6, ""},
+ {"(*Error).Timeout", Method, 6, ""},
+ {"(*Error).Unwrap", Method, 13, ""},
+ {"(*URL).AppendBinary", Method, 24, ""},
+ {"(*URL).EscapedFragment", Method, 15, ""},
+ {"(*URL).EscapedPath", Method, 5, ""},
+ {"(*URL).Hostname", Method, 8, ""},
+ {"(*URL).IsAbs", Method, 0, ""},
+ {"(*URL).JoinPath", Method, 19, ""},
+ {"(*URL).MarshalBinary", Method, 8, ""},
+ {"(*URL).Parse", Method, 0, ""},
+ {"(*URL).Port", Method, 8, ""},
+ {"(*URL).Query", Method, 0, ""},
+ {"(*URL).Redacted", Method, 15, ""},
+ {"(*URL).RequestURI", Method, 0, ""},
+ {"(*URL).ResolveReference", Method, 0, ""},
+ {"(*URL).String", Method, 0, ""},
+ {"(*URL).UnmarshalBinary", Method, 8, ""},
+ {"(*Userinfo).Password", Method, 0, ""},
+ {"(*Userinfo).String", Method, 0, ""},
+ {"(*Userinfo).Username", Method, 0, ""},
+ {"(EscapeError).Error", Method, 0, ""},
+ {"(InvalidHostError).Error", Method, 6, ""},
+ {"(Values).Add", Method, 0, ""},
+ {"(Values).Del", Method, 0, ""},
+ {"(Values).Encode", Method, 0, ""},
+ {"(Values).Get", Method, 0, ""},
+ {"(Values).Has", Method, 17, ""},
+ {"(Values).Set", Method, 0, ""},
+ {"Error", Type, 0, ""},
+ {"Error.Err", Field, 0, ""},
+ {"Error.Op", Field, 0, ""},
+ {"Error.URL", Field, 0, ""},
+ {"EscapeError", Type, 0, ""},
+ {"InvalidHostError", Type, 6, ""},
+ {"JoinPath", Func, 19, "func(base string, elem ...string) (result string, err error)"},
+ {"Parse", Func, 0, "func(rawURL string) (*URL, error)"},
+ {"ParseQuery", Func, 0, "func(query string) (Values, error)"},
+ {"ParseRequestURI", Func, 0, "func(rawURL string) (*URL, error)"},
+ {"PathEscape", Func, 8, "func(s string) string"},
+ {"PathUnescape", Func, 8, "func(s string) (string, error)"},
+ {"QueryEscape", Func, 0, "func(s string) string"},
+ {"QueryUnescape", Func, 0, "func(s string) (string, error)"},
+ {"URL", Type, 0, ""},
+ {"URL.ForceQuery", Field, 7, ""},
+ {"URL.Fragment", Field, 0, ""},
+ {"URL.Host", Field, 0, ""},
+ {"URL.OmitHost", Field, 19, ""},
+ {"URL.Opaque", Field, 0, ""},
+ {"URL.Path", Field, 0, ""},
+ {"URL.RawFragment", Field, 15, ""},
+ {"URL.RawPath", Field, 5, ""},
+ {"URL.RawQuery", Field, 0, ""},
+ {"URL.Scheme", Field, 0, ""},
+ {"URL.User", Field, 0, ""},
+ {"User", Func, 0, "func(username string) *Userinfo"},
+ {"UserPassword", Func, 0, "func(username string, password string) *Userinfo"},
+ {"Userinfo", Type, 0, ""},
+ {"Values", Type, 0, ""},
+ },
+ "os": {
+ {"(*File).Chdir", Method, 0, ""},
+ {"(*File).Chmod", Method, 0, ""},
+ {"(*File).Chown", Method, 0, ""},
+ {"(*File).Close", Method, 0, ""},
+ {"(*File).Fd", Method, 0, ""},
+ {"(*File).Name", Method, 0, ""},
+ {"(*File).Read", Method, 0, ""},
+ {"(*File).ReadAt", Method, 0, ""},
+ {"(*File).ReadDir", Method, 16, ""},
+ {"(*File).ReadFrom", Method, 15, ""},
+ {"(*File).Readdir", Method, 0, ""},
+ {"(*File).Readdirnames", Method, 0, ""},
+ {"(*File).Seek", Method, 0, ""},
+ {"(*File).SetDeadline", Method, 10, ""},
+ {"(*File).SetReadDeadline", Method, 10, ""},
+ {"(*File).SetWriteDeadline", Method, 10, ""},
+ {"(*File).Stat", Method, 0, ""},
+ {"(*File).Sync", Method, 0, ""},
+ {"(*File).SyscallConn", Method, 12, ""},
+ {"(*File).Truncate", Method, 0, ""},
+ {"(*File).Write", Method, 0, ""},
+ {"(*File).WriteAt", Method, 0, ""},
+ {"(*File).WriteString", Method, 0, ""},
+ {"(*File).WriteTo", Method, 22, ""},
+ {"(*LinkError).Error", Method, 0, ""},
+ {"(*LinkError).Unwrap", Method, 13, ""},
+ {"(*PathError).Error", Method, 0, ""},
+ {"(*PathError).Timeout", Method, 10, ""},
+ {"(*PathError).Unwrap", Method, 13, ""},
+ {"(*Process).Kill", Method, 0, ""},
+ {"(*Process).Release", Method, 0, ""},
+ {"(*Process).Signal", Method, 0, ""},
+ {"(*Process).Wait", Method, 0, ""},
+ {"(*ProcessState).ExitCode", Method, 12, ""},
+ {"(*ProcessState).Exited", Method, 0, ""},
+ {"(*ProcessState).Pid", Method, 0, ""},
+ {"(*ProcessState).String", Method, 0, ""},
+ {"(*ProcessState).Success", Method, 0, ""},
+ {"(*ProcessState).Sys", Method, 0, ""},
+ {"(*ProcessState).SysUsage", Method, 0, ""},
+ {"(*ProcessState).SystemTime", Method, 0, ""},
+ {"(*ProcessState).UserTime", Method, 0, ""},
+ {"(*Root).Chmod", Method, 25, ""},
+ {"(*Root).Chown", Method, 25, ""},
+ {"(*Root).Chtimes", Method, 25, ""},
+ {"(*Root).Close", Method, 24, ""},
+ {"(*Root).Create", Method, 24, ""},
+ {"(*Root).FS", Method, 24, ""},
+ {"(*Root).Lchown", Method, 25, ""},
+ {"(*Root).Link", Method, 25, ""},
+ {"(*Root).Lstat", Method, 24, ""},
+ {"(*Root).Mkdir", Method, 24, ""},
+ {"(*Root).Name", Method, 24, ""},
+ {"(*Root).Open", Method, 24, ""},
+ {"(*Root).OpenFile", Method, 24, ""},
+ {"(*Root).OpenRoot", Method, 24, ""},
+ {"(*Root).Readlink", Method, 25, ""},
+ {"(*Root).Remove", Method, 24, ""},
+ {"(*Root).Rename", Method, 25, ""},
+ {"(*Root).Stat", Method, 24, ""},
+ {"(*Root).Symlink", Method, 25, ""},
+ {"(*SyscallError).Error", Method, 0, ""},
+ {"(*SyscallError).Timeout", Method, 10, ""},
+ {"(*SyscallError).Unwrap", Method, 13, ""},
+ {"(FileMode).IsDir", Method, 0, ""},
+ {"(FileMode).IsRegular", Method, 1, ""},
+ {"(FileMode).Perm", Method, 0, ""},
+ {"(FileMode).String", Method, 0, ""},
+ {"Args", Var, 0, ""},
+ {"Chdir", Func, 0, "func(dir string) error"},
+ {"Chmod", Func, 0, "func(name string, mode FileMode) error"},
+ {"Chown", Func, 0, "func(name string, uid int, gid int) error"},
+ {"Chtimes", Func, 0, "func(name string, atime time.Time, mtime time.Time) error"},
+ {"Clearenv", Func, 0, "func()"},
+ {"CopyFS", Func, 23, "func(dir string, fsys fs.FS) error"},
+ {"Create", Func, 0, "func(name string) (*File, error)"},
+ {"CreateTemp", Func, 16, "func(dir string, pattern string) (*File, error)"},
+ {"DevNull", Const, 0, ""},
+ {"DirEntry", Type, 16, ""},
+ {"DirFS", Func, 16, "func(dir string) fs.FS"},
+ {"Environ", Func, 0, "func() []string"},
+ {"ErrClosed", Var, 8, ""},
+ {"ErrDeadlineExceeded", Var, 15, ""},
+ {"ErrExist", Var, 0, ""},
+ {"ErrInvalid", Var, 0, ""},
+ {"ErrNoDeadline", Var, 10, ""},
+ {"ErrNotExist", Var, 0, ""},
+ {"ErrPermission", Var, 0, ""},
+ {"ErrProcessDone", Var, 16, ""},
+ {"Executable", Func, 8, "func() (string, error)"},
+ {"Exit", Func, 0, "func(code int)"},
+ {"Expand", Func, 0, "func(s string, mapping func(string) string) string"},
+ {"ExpandEnv", Func, 0, "func(s string) string"},
+ {"File", Type, 0, ""},
+ {"FileInfo", Type, 0, ""},
+ {"FileMode", Type, 0, ""},
+ {"FindProcess", Func, 0, "func(pid int) (*Process, error)"},
+ {"Getegid", Func, 0, "func() int"},
+ {"Getenv", Func, 0, "func(key string) string"},
+ {"Geteuid", Func, 0, "func() int"},
+ {"Getgid", Func, 0, "func() int"},
+ {"Getgroups", Func, 0, "func() ([]int, error)"},
+ {"Getpagesize", Func, 0, "func() int"},
+ {"Getpid", Func, 0, "func() int"},
+ {"Getppid", Func, 0, "func() int"},
+ {"Getuid", Func, 0, "func() int"},
+ {"Getwd", Func, 0, "func() (dir string, err error)"},
+ {"Hostname", Func, 0, "func() (name string, err error)"},
+ {"Interrupt", Var, 0, ""},
+ {"IsExist", Func, 0, "func(err error) bool"},
+ {"IsNotExist", Func, 0, "func(err error) bool"},
+ {"IsPathSeparator", Func, 0, "func(c uint8) bool"},
+ {"IsPermission", Func, 0, "func(err error) bool"},
+ {"IsTimeout", Func, 10, "func(err error) bool"},
+ {"Kill", Var, 0, ""},
+ {"Lchown", Func, 0, "func(name string, uid int, gid int) error"},
+ {"Link", Func, 0, "func(oldname string, newname string) error"},
+ {"LinkError", Type, 0, ""},
+ {"LinkError.Err", Field, 0, ""},
+ {"LinkError.New", Field, 0, ""},
+ {"LinkError.Old", Field, 0, ""},
+ {"LinkError.Op", Field, 0, ""},
+ {"LookupEnv", Func, 5, "func(key string) (string, bool)"},
+ {"Lstat", Func, 0, "func(name string) (FileInfo, error)"},
+ {"Mkdir", Func, 0, "func(name string, perm FileMode) error"},
+ {"MkdirAll", Func, 0, "func(path string, perm FileMode) error"},
+ {"MkdirTemp", Func, 16, "func(dir string, pattern string) (string, error)"},
+ {"ModeAppend", Const, 0, ""},
+ {"ModeCharDevice", Const, 0, ""},
+ {"ModeDevice", Const, 0, ""},
+ {"ModeDir", Const, 0, ""},
+ {"ModeExclusive", Const, 0, ""},
+ {"ModeIrregular", Const, 11, ""},
+ {"ModeNamedPipe", Const, 0, ""},
+ {"ModePerm", Const, 0, ""},
+ {"ModeSetgid", Const, 0, ""},
+ {"ModeSetuid", Const, 0, ""},
+ {"ModeSocket", Const, 0, ""},
+ {"ModeSticky", Const, 0, ""},
+ {"ModeSymlink", Const, 0, ""},
+ {"ModeTemporary", Const, 0, ""},
+ {"ModeType", Const, 0, ""},
+ {"NewFile", Func, 0, "func(fd uintptr, name string) *File"},
+ {"NewSyscallError", Func, 0, "func(syscall string, err error) error"},
+ {"O_APPEND", Const, 0, ""},
+ {"O_CREATE", Const, 0, ""},
+ {"O_EXCL", Const, 0, ""},
+ {"O_RDONLY", Const, 0, ""},
+ {"O_RDWR", Const, 0, ""},
+ {"O_SYNC", Const, 0, ""},
+ {"O_TRUNC", Const, 0, ""},
+ {"O_WRONLY", Const, 0, ""},
+ {"Open", Func, 0, "func(name string) (*File, error)"},
+ {"OpenFile", Func, 0, "func(name string, flag int, perm FileMode) (*File, error)"},
+ {"OpenInRoot", Func, 24, "func(dir string, name string) (*File, error)"},
+ {"OpenRoot", Func, 24, "func(name string) (*Root, error)"},
+ {"PathError", Type, 0, ""},
+ {"PathError.Err", Field, 0, ""},
+ {"PathError.Op", Field, 0, ""},
+ {"PathError.Path", Field, 0, ""},
+ {"PathListSeparator", Const, 0, ""},
+ {"PathSeparator", Const, 0, ""},
+ {"Pipe", Func, 0, "func() (r *File, w *File, err error)"},
+ {"ProcAttr", Type, 0, ""},
+ {"ProcAttr.Dir", Field, 0, ""},
+ {"ProcAttr.Env", Field, 0, ""},
+ {"ProcAttr.Files", Field, 0, ""},
+ {"ProcAttr.Sys", Field, 0, ""},
+ {"Process", Type, 0, ""},
+ {"Process.Pid", Field, 0, ""},
+ {"ProcessState", Type, 0, ""},
+ {"ReadDir", Func, 16, "func(name string) ([]DirEntry, error)"},
+ {"ReadFile", Func, 16, "func(name string) ([]byte, error)"},
+ {"Readlink", Func, 0, "func(name string) (string, error)"},
+ {"Remove", Func, 0, "func(name string) error"},
+ {"RemoveAll", Func, 0, "func(path string) error"},
+ {"Rename", Func, 0, "func(oldpath string, newpath string) error"},
+ {"Root", Type, 24, ""},
+ {"SEEK_CUR", Const, 0, ""},
+ {"SEEK_END", Const, 0, ""},
+ {"SEEK_SET", Const, 0, ""},
+ {"SameFile", Func, 0, "func(fi1 FileInfo, fi2 FileInfo) bool"},
+ {"Setenv", Func, 0, "func(key string, value string) error"},
+ {"Signal", Type, 0, ""},
+ {"StartProcess", Func, 0, "func(name string, argv []string, attr *ProcAttr) (*Process, error)"},
+ {"Stat", Func, 0, "func(name string) (FileInfo, error)"},
+ {"Stderr", Var, 0, ""},
+ {"Stdin", Var, 0, ""},
+ {"Stdout", Var, 0, ""},
+ {"Symlink", Func, 0, "func(oldname string, newname string) error"},
+ {"SyscallError", Type, 0, ""},
+ {"SyscallError.Err", Field, 0, ""},
+ {"SyscallError.Syscall", Field, 0, ""},
+ {"TempDir", Func, 0, "func() string"},
+ {"Truncate", Func, 0, "func(name string, size int64) error"},
+ {"Unsetenv", Func, 4, "func(key string) error"},
+ {"UserCacheDir", Func, 11, "func() (string, error)"},
+ {"UserConfigDir", Func, 13, "func() (string, error)"},
+ {"UserHomeDir", Func, 12, "func() (string, error)"},
+ {"WriteFile", Func, 16, "func(name string, data []byte, perm FileMode) error"},
+ },
+ "os/exec": {
+ {"(*Cmd).CombinedOutput", Method, 0, ""},
+ {"(*Cmd).Environ", Method, 19, ""},
+ {"(*Cmd).Output", Method, 0, ""},
+ {"(*Cmd).Run", Method, 0, ""},
+ {"(*Cmd).Start", Method, 0, ""},
+ {"(*Cmd).StderrPipe", Method, 0, ""},
+ {"(*Cmd).StdinPipe", Method, 0, ""},
+ {"(*Cmd).StdoutPipe", Method, 0, ""},
+ {"(*Cmd).String", Method, 13, ""},
+ {"(*Cmd).Wait", Method, 0, ""},
+ {"(*Error).Error", Method, 0, ""},
+ {"(*Error).Unwrap", Method, 13, ""},
+ {"(*ExitError).Error", Method, 0, ""},
+ {"(ExitError).ExitCode", Method, 12, ""},
+ {"(ExitError).Exited", Method, 0, ""},
+ {"(ExitError).Pid", Method, 0, ""},
+ {"(ExitError).String", Method, 0, ""},
+ {"(ExitError).Success", Method, 0, ""},
+ {"(ExitError).Sys", Method, 0, ""},
+ {"(ExitError).SysUsage", Method, 0, ""},
+ {"(ExitError).SystemTime", Method, 0, ""},
+ {"(ExitError).UserTime", Method, 0, ""},
+ {"Cmd", Type, 0, ""},
+ {"Cmd.Args", Field, 0, ""},
+ {"Cmd.Cancel", Field, 20, ""},
+ {"Cmd.Dir", Field, 0, ""},
+ {"Cmd.Env", Field, 0, ""},
+ {"Cmd.Err", Field, 19, ""},
+ {"Cmd.ExtraFiles", Field, 0, ""},
+ {"Cmd.Path", Field, 0, ""},
+ {"Cmd.Process", Field, 0, ""},
+ {"Cmd.ProcessState", Field, 0, ""},
+ {"Cmd.Stderr", Field, 0, ""},
+ {"Cmd.Stdin", Field, 0, ""},
+ {"Cmd.Stdout", Field, 0, ""},
+ {"Cmd.SysProcAttr", Field, 0, ""},
+ {"Cmd.WaitDelay", Field, 20, ""},
+ {"Command", Func, 0, "func(name string, arg ...string) *Cmd"},
+ {"CommandContext", Func, 7, "func(ctx context.Context, name string, arg ...string) *Cmd"},
+ {"ErrDot", Var, 19, ""},
+ {"ErrNotFound", Var, 0, ""},
+ {"ErrWaitDelay", Var, 20, ""},
+ {"Error", Type, 0, ""},
+ {"Error.Err", Field, 0, ""},
+ {"Error.Name", Field, 0, ""},
+ {"ExitError", Type, 0, ""},
+ {"ExitError.ProcessState", Field, 0, ""},
+ {"ExitError.Stderr", Field, 6, ""},
+ {"LookPath", Func, 0, "func(file string) (string, error)"},
+ },
+ "os/signal": {
+ {"Ignore", Func, 5, "func(sig ...os.Signal)"},
+ {"Ignored", Func, 11, "func(sig os.Signal) bool"},
+ {"Notify", Func, 0, "func(c chan<- os.Signal, sig ...os.Signal)"},
+ {"NotifyContext", Func, 16, "func(parent context.Context, signals ...os.Signal) (ctx context.Context, stop context.CancelFunc)"},
+ {"Reset", Func, 5, "func(sig ...os.Signal)"},
+ {"Stop", Func, 1, "func(c chan<- os.Signal)"},
+ },
+ "os/user": {
+ {"(*User).GroupIds", Method, 7, ""},
+ {"(UnknownGroupError).Error", Method, 7, ""},
+ {"(UnknownGroupIdError).Error", Method, 7, ""},
+ {"(UnknownUserError).Error", Method, 0, ""},
+ {"(UnknownUserIdError).Error", Method, 0, ""},
+ {"Current", Func, 0, "func() (*User, error)"},
+ {"Group", Type, 7, ""},
+ {"Group.Gid", Field, 7, ""},
+ {"Group.Name", Field, 7, ""},
+ {"Lookup", Func, 0, "func(username string) (*User, error)"},
+ {"LookupGroup", Func, 7, "func(name string) (*Group, error)"},
+ {"LookupGroupId", Func, 7, "func(gid string) (*Group, error)"},
+ {"LookupId", Func, 0, "func(uid string) (*User, error)"},
+ {"UnknownGroupError", Type, 7, ""},
+ {"UnknownGroupIdError", Type, 7, ""},
+ {"UnknownUserError", Type, 0, ""},
+ {"UnknownUserIdError", Type, 0, ""},
+ {"User", Type, 0, ""},
+ {"User.Gid", Field, 0, ""},
+ {"User.HomeDir", Field, 0, ""},
+ {"User.Name", Field, 0, ""},
+ {"User.Uid", Field, 0, ""},
+ {"User.Username", Field, 0, ""},
+ },
+ "path": {
+ {"Base", Func, 0, "func(path string) string"},
+ {"Clean", Func, 0, "func(path string) string"},
+ {"Dir", Func, 0, "func(path string) string"},
+ {"ErrBadPattern", Var, 0, ""},
+ {"Ext", Func, 0, "func(path string) string"},
+ {"IsAbs", Func, 0, "func(path string) bool"},
+ {"Join", Func, 0, "func(elem ...string) string"},
+ {"Match", Func, 0, "func(pattern string, name string) (matched bool, err error)"},
+ {"Split", Func, 0, "func(path string) (dir string, file string)"},
+ },
+ "path/filepath": {
+ {"Abs", Func, 0, "func(path string) (string, error)"},
+ {"Base", Func, 0, "func(path string) string"},
+ {"Clean", Func, 0, "func(path string) string"},
+ {"Dir", Func, 0, "func(path string) string"},
+ {"ErrBadPattern", Var, 0, ""},
+ {"EvalSymlinks", Func, 0, "func(path string) (string, error)"},
+ {"Ext", Func, 0, "func(path string) string"},
+ {"FromSlash", Func, 0, "func(path string) string"},
+ {"Glob", Func, 0, "func(pattern string) (matches []string, err error)"},
+ {"HasPrefix", Func, 0, "func(p string, prefix string) bool"},
+ {"IsAbs", Func, 0, "func(path string) bool"},
+ {"IsLocal", Func, 20, "func(path string) bool"},
+ {"Join", Func, 0, "func(elem ...string) string"},
+ {"ListSeparator", Const, 0, ""},
+ {"Localize", Func, 23, "func(path string) (string, error)"},
+ {"Match", Func, 0, "func(pattern string, name string) (matched bool, err error)"},
+ {"Rel", Func, 0, "func(basepath string, targpath string) (string, error)"},
+ {"Separator", Const, 0, ""},
+ {"SkipAll", Var, 20, ""},
+ {"SkipDir", Var, 0, ""},
+ {"Split", Func, 0, "func(path string) (dir string, file string)"},
+ {"SplitList", Func, 0, "func(path string) []string"},
+ {"ToSlash", Func, 0, "func(path string) string"},
+ {"VolumeName", Func, 0, "func(path string) string"},
+ {"Walk", Func, 0, "func(root string, fn WalkFunc) error"},
+ {"WalkDir", Func, 16, "func(root string, fn fs.WalkDirFunc) error"},
+ {"WalkFunc", Type, 0, ""},
+ },
+ "plugin": {
+ {"(*Plugin).Lookup", Method, 8, ""},
+ {"Open", Func, 8, "func(path string) (*Plugin, error)"},
+ {"Plugin", Type, 8, ""},
+ {"Symbol", Type, 8, ""},
+ },
+ "reflect": {
+ {"(*MapIter).Key", Method, 12, ""},
+ {"(*MapIter).Next", Method, 12, ""},
+ {"(*MapIter).Reset", Method, 18, ""},
+ {"(*MapIter).Value", Method, 12, ""},
+ {"(*ValueError).Error", Method, 0, ""},
+ {"(ChanDir).String", Method, 0, ""},
+ {"(Kind).String", Method, 0, ""},
+ {"(Method).IsExported", Method, 17, ""},
+ {"(StructField).IsExported", Method, 17, ""},
+ {"(StructTag).Get", Method, 0, ""},
+ {"(StructTag).Lookup", Method, 7, ""},
+ {"(Value).Addr", Method, 0, ""},
+ {"(Value).Bool", Method, 0, ""},
+ {"(Value).Bytes", Method, 0, ""},
+ {"(Value).Call", Method, 0, ""},
+ {"(Value).CallSlice", Method, 0, ""},
+ {"(Value).CanAddr", Method, 0, ""},
+ {"(Value).CanComplex", Method, 18, ""},
+ {"(Value).CanConvert", Method, 17, ""},
+ {"(Value).CanFloat", Method, 18, ""},
+ {"(Value).CanInt", Method, 18, ""},
+ {"(Value).CanInterface", Method, 0, ""},
+ {"(Value).CanSet", Method, 0, ""},
+ {"(Value).CanUint", Method, 18, ""},
+ {"(Value).Cap", Method, 0, ""},
+ {"(Value).Clear", Method, 21, ""},
+ {"(Value).Close", Method, 0, ""},
+ {"(Value).Comparable", Method, 20, ""},
+ {"(Value).Complex", Method, 0, ""},
+ {"(Value).Convert", Method, 1, ""},
+ {"(Value).Elem", Method, 0, ""},
+ {"(Value).Equal", Method, 20, ""},
+ {"(Value).Field", Method, 0, ""},
+ {"(Value).FieldByIndex", Method, 0, ""},
+ {"(Value).FieldByIndexErr", Method, 18, ""},
+ {"(Value).FieldByName", Method, 0, ""},
+ {"(Value).FieldByNameFunc", Method, 0, ""},
+ {"(Value).Float", Method, 0, ""},
+ {"(Value).Grow", Method, 20, ""},
+ {"(Value).Index", Method, 0, ""},
+ {"(Value).Int", Method, 0, ""},
+ {"(Value).Interface", Method, 0, ""},
+ {"(Value).InterfaceData", Method, 0, ""},
+ {"(Value).IsNil", Method, 0, ""},
+ {"(Value).IsValid", Method, 0, ""},
+ {"(Value).IsZero", Method, 13, ""},
+ {"(Value).Kind", Method, 0, ""},
+ {"(Value).Len", Method, 0, ""},
+ {"(Value).MapIndex", Method, 0, ""},
+ {"(Value).MapKeys", Method, 0, ""},
+ {"(Value).MapRange", Method, 12, ""},
+ {"(Value).Method", Method, 0, ""},
+ {"(Value).MethodByName", Method, 0, ""},
+ {"(Value).NumField", Method, 0, ""},
+ {"(Value).NumMethod", Method, 0, ""},
+ {"(Value).OverflowComplex", Method, 0, ""},
+ {"(Value).OverflowFloat", Method, 0, ""},
+ {"(Value).OverflowInt", Method, 0, ""},
+ {"(Value).OverflowUint", Method, 0, ""},
+ {"(Value).Pointer", Method, 0, ""},
+ {"(Value).Recv", Method, 0, ""},
+ {"(Value).Send", Method, 0, ""},
+ {"(Value).Seq", Method, 23, ""},
+ {"(Value).Seq2", Method, 23, ""},
+ {"(Value).Set", Method, 0, ""},
+ {"(Value).SetBool", Method, 0, ""},
+ {"(Value).SetBytes", Method, 0, ""},
+ {"(Value).SetCap", Method, 2, ""},
+ {"(Value).SetComplex", Method, 0, ""},
+ {"(Value).SetFloat", Method, 0, ""},
+ {"(Value).SetInt", Method, 0, ""},
+ {"(Value).SetIterKey", Method, 18, ""},
+ {"(Value).SetIterValue", Method, 18, ""},
+ {"(Value).SetLen", Method, 0, ""},
+ {"(Value).SetMapIndex", Method, 0, ""},
+ {"(Value).SetPointer", Method, 0, ""},
+ {"(Value).SetString", Method, 0, ""},
+ {"(Value).SetUint", Method, 0, ""},
+ {"(Value).SetZero", Method, 20, ""},
+ {"(Value).Slice", Method, 0, ""},
+ {"(Value).Slice3", Method, 2, ""},
+ {"(Value).String", Method, 0, ""},
+ {"(Value).TryRecv", Method, 0, ""},
+ {"(Value).TrySend", Method, 0, ""},
+ {"(Value).Type", Method, 0, ""},
+ {"(Value).Uint", Method, 0, ""},
+ {"(Value).UnsafeAddr", Method, 0, ""},
+ {"(Value).UnsafePointer", Method, 18, ""},
+ {"Append", Func, 0, "func(s Value, x ...Value) Value"},
+ {"AppendSlice", Func, 0, "func(s Value, t Value) Value"},
+ {"Array", Const, 0, ""},
+ {"ArrayOf", Func, 5, "func(length int, elem Type) Type"},
+ {"Bool", Const, 0, ""},
+ {"BothDir", Const, 0, ""},
+ {"Chan", Const, 0, ""},
+ {"ChanDir", Type, 0, ""},
+ {"ChanOf", Func, 1, "func(dir ChanDir, t Type) Type"},
+ {"Complex128", Const, 0, ""},
+ {"Complex64", Const, 0, ""},
+ {"Copy", Func, 0, "func(dst Value, src Value) int"},
+ {"DeepEqual", Func, 0, "func(x any, y any) bool"},
+ {"Float32", Const, 0, ""},
+ {"Float64", Const, 0, ""},
+ {"Func", Const, 0, ""},
+ {"FuncOf", Func, 5, "func(in []Type, out []Type, variadic bool) Type"},
+ {"Indirect", Func, 0, "func(v Value) Value"},
+ {"Int", Const, 0, ""},
+ {"Int16", Const, 0, ""},
+ {"Int32", Const, 0, ""},
+ {"Int64", Const, 0, ""},
+ {"Int8", Const, 0, ""},
+ {"Interface", Const, 0, ""},
+ {"Invalid", Const, 0, ""},
+ {"Kind", Type, 0, ""},
+ {"MakeChan", Func, 0, "func(typ Type, buffer int) Value"},
+ {"MakeFunc", Func, 1, "func(typ Type, fn func(args []Value) (results []Value)) Value"},
+ {"MakeMap", Func, 0, "func(typ Type) Value"},
+ {"MakeMapWithSize", Func, 9, "func(typ Type, n int) Value"},
+ {"MakeSlice", Func, 0, "func(typ Type, len int, cap int) Value"},
+ {"Map", Const, 0, ""},
+ {"MapIter", Type, 12, ""},
+ {"MapOf", Func, 1, "func(key Type, elem Type) Type"},
+ {"Method", Type, 0, ""},
+ {"Method.Func", Field, 0, ""},
+ {"Method.Index", Field, 0, ""},
+ {"Method.Name", Field, 0, ""},
+ {"Method.PkgPath", Field, 0, ""},
+ {"Method.Type", Field, 0, ""},
+ {"New", Func, 0, "func(typ Type) Value"},
+ {"NewAt", Func, 0, "func(typ Type, p unsafe.Pointer) Value"},
+ {"Pointer", Const, 18, ""},
+ {"PointerTo", Func, 18, "func(t Type) Type"},
+ {"Ptr", Const, 0, ""},
+ {"PtrTo", Func, 0, "func(t Type) Type"},
+ {"RecvDir", Const, 0, ""},
+ {"Select", Func, 1, "func(cases []SelectCase) (chosen int, recv Value, recvOK bool)"},
+ {"SelectCase", Type, 1, ""},
+ {"SelectCase.Chan", Field, 1, ""},
+ {"SelectCase.Dir", Field, 1, ""},
+ {"SelectCase.Send", Field, 1, ""},
+ {"SelectDefault", Const, 1, ""},
+ {"SelectDir", Type, 1, ""},
+ {"SelectRecv", Const, 1, ""},
+ {"SelectSend", Const, 1, ""},
+ {"SendDir", Const, 0, ""},
+ {"Slice", Const, 0, ""},
+ {"SliceAt", Func, 23, "func(typ Type, p unsafe.Pointer, n int) Value"},
+ {"SliceHeader", Type, 0, ""},
+ {"SliceHeader.Cap", Field, 0, ""},
+ {"SliceHeader.Data", Field, 0, ""},
+ {"SliceHeader.Len", Field, 0, ""},
+ {"SliceOf", Func, 1, "func(t Type) Type"},
+ {"String", Const, 0, ""},
+ {"StringHeader", Type, 0, ""},
+ {"StringHeader.Data", Field, 0, ""},
+ {"StringHeader.Len", Field, 0, ""},
+ {"Struct", Const, 0, ""},
+ {"StructField", Type, 0, ""},
+ {"StructField.Anonymous", Field, 0, ""},
+ {"StructField.Index", Field, 0, ""},
+ {"StructField.Name", Field, 0, ""},
+ {"StructField.Offset", Field, 0, ""},
+ {"StructField.PkgPath", Field, 0, ""},
+ {"StructField.Tag", Field, 0, ""},
+ {"StructField.Type", Field, 0, ""},
+ {"StructOf", Func, 7, "func(fields []StructField) Type"},
+ {"StructTag", Type, 0, ""},
+ {"Swapper", Func, 8, "func(slice any) func(i int, j int)"},
+ {"Type", Type, 0, ""},
+ {"TypeFor", Func, 22, "func[T any]() Type"},
+ {"TypeOf", Func, 0, "func(i any) Type"},
+ {"Uint", Const, 0, ""},
+ {"Uint16", Const, 0, ""},
+ {"Uint32", Const, 0, ""},
+ {"Uint64", Const, 0, ""},
+ {"Uint8", Const, 0, ""},
+ {"Uintptr", Const, 0, ""},
+ {"UnsafePointer", Const, 0, ""},
+ {"Value", Type, 0, ""},
+ {"ValueError", Type, 0, ""},
+ {"ValueError.Kind", Field, 0, ""},
+ {"ValueError.Method", Field, 0, ""},
+ {"ValueOf", Func, 0, "func(i any) Value"},
+ {"VisibleFields", Func, 17, "func(t Type) []StructField"},
+ {"Zero", Func, 0, "func(typ Type) Value"},
+ },
+ "regexp": {
+ {"(*Regexp).AppendText", Method, 24, ""},
+ {"(*Regexp).Copy", Method, 6, ""},
+ {"(*Regexp).Expand", Method, 0, ""},
+ {"(*Regexp).ExpandString", Method, 0, ""},
+ {"(*Regexp).Find", Method, 0, ""},
+ {"(*Regexp).FindAll", Method, 0, ""},
+ {"(*Regexp).FindAllIndex", Method, 0, ""},
+ {"(*Regexp).FindAllString", Method, 0, ""},
+ {"(*Regexp).FindAllStringIndex", Method, 0, ""},
+ {"(*Regexp).FindAllStringSubmatch", Method, 0, ""},
+ {"(*Regexp).FindAllStringSubmatchIndex", Method, 0, ""},
+ {"(*Regexp).FindAllSubmatch", Method, 0, ""},
+ {"(*Regexp).FindAllSubmatchIndex", Method, 0, ""},
+ {"(*Regexp).FindIndex", Method, 0, ""},
+ {"(*Regexp).FindReaderIndex", Method, 0, ""},
+ {"(*Regexp).FindReaderSubmatchIndex", Method, 0, ""},
+ {"(*Regexp).FindString", Method, 0, ""},
+ {"(*Regexp).FindStringIndex", Method, 0, ""},
+ {"(*Regexp).FindStringSubmatch", Method, 0, ""},
+ {"(*Regexp).FindStringSubmatchIndex", Method, 0, ""},
+ {"(*Regexp).FindSubmatch", Method, 0, ""},
+ {"(*Regexp).FindSubmatchIndex", Method, 0, ""},
+ {"(*Regexp).LiteralPrefix", Method, 0, ""},
+ {"(*Regexp).Longest", Method, 1, ""},
+ {"(*Regexp).MarshalText", Method, 21, ""},
+ {"(*Regexp).Match", Method, 0, ""},
+ {"(*Regexp).MatchReader", Method, 0, ""},
+ {"(*Regexp).MatchString", Method, 0, ""},
+ {"(*Regexp).NumSubexp", Method, 0, ""},
+ {"(*Regexp).ReplaceAll", Method, 0, ""},
+ {"(*Regexp).ReplaceAllFunc", Method, 0, ""},
+ {"(*Regexp).ReplaceAllLiteral", Method, 0, ""},
+ {"(*Regexp).ReplaceAllLiteralString", Method, 0, ""},
+ {"(*Regexp).ReplaceAllString", Method, 0, ""},
+ {"(*Regexp).ReplaceAllStringFunc", Method, 0, ""},
+ {"(*Regexp).Split", Method, 1, ""},
+ {"(*Regexp).String", Method, 0, ""},
+ {"(*Regexp).SubexpIndex", Method, 15, ""},
+ {"(*Regexp).SubexpNames", Method, 0, ""},
+ {"(*Regexp).UnmarshalText", Method, 21, ""},
+ {"Compile", Func, 0, "func(expr string) (*Regexp, error)"},
+ {"CompilePOSIX", Func, 0, "func(expr string) (*Regexp, error)"},
+ {"Match", Func, 0, "func(pattern string, b []byte) (matched bool, err error)"},
+ {"MatchReader", Func, 0, "func(pattern string, r io.RuneReader) (matched bool, err error)"},
+ {"MatchString", Func, 0, "func(pattern string, s string) (matched bool, err error)"},
+ {"MustCompile", Func, 0, "func(str string) *Regexp"},
+ {"MustCompilePOSIX", Func, 0, "func(str string) *Regexp"},
+ {"QuoteMeta", Func, 0, "func(s string) string"},
+ {"Regexp", Type, 0, ""},
+ },
+ "regexp/syntax": {
+ {"(*Error).Error", Method, 0, ""},
+ {"(*Inst).MatchEmptyWidth", Method, 0, ""},
+ {"(*Inst).MatchRune", Method, 0, ""},
+ {"(*Inst).MatchRunePos", Method, 3, ""},
+ {"(*Inst).String", Method, 0, ""},
+ {"(*Prog).Prefix", Method, 0, ""},
+ {"(*Prog).StartCond", Method, 0, ""},
+ {"(*Prog).String", Method, 0, ""},
+ {"(*Regexp).CapNames", Method, 0, ""},
+ {"(*Regexp).Equal", Method, 0, ""},
+ {"(*Regexp).MaxCap", Method, 0, ""},
+ {"(*Regexp).Simplify", Method, 0, ""},
+ {"(*Regexp).String", Method, 0, ""},
+ {"(ErrorCode).String", Method, 0, ""},
+ {"(InstOp).String", Method, 3, ""},
+ {"(Op).String", Method, 11, ""},
+ {"ClassNL", Const, 0, ""},
+ {"Compile", Func, 0, "func(re *Regexp) (*Prog, error)"},
+ {"DotNL", Const, 0, ""},
+ {"EmptyBeginLine", Const, 0, ""},
+ {"EmptyBeginText", Const, 0, ""},
+ {"EmptyEndLine", Const, 0, ""},
+ {"EmptyEndText", Const, 0, ""},
+ {"EmptyNoWordBoundary", Const, 0, ""},
+ {"EmptyOp", Type, 0, ""},
+ {"EmptyOpContext", Func, 0, "func(r1 rune, r2 rune) EmptyOp"},
+ {"EmptyWordBoundary", Const, 0, ""},
+ {"ErrInternalError", Const, 0, ""},
+ {"ErrInvalidCharClass", Const, 0, ""},
+ {"ErrInvalidCharRange", Const, 0, ""},
+ {"ErrInvalidEscape", Const, 0, ""},
+ {"ErrInvalidNamedCapture", Const, 0, ""},
+ {"ErrInvalidPerlOp", Const, 0, ""},
+ {"ErrInvalidRepeatOp", Const, 0, ""},
+ {"ErrInvalidRepeatSize", Const, 0, ""},
+ {"ErrInvalidUTF8", Const, 0, ""},
+ {"ErrLarge", Const, 20, ""},
+ {"ErrMissingBracket", Const, 0, ""},
+ {"ErrMissingParen", Const, 0, ""},
+ {"ErrMissingRepeatArgument", Const, 0, ""},
+ {"ErrNestingDepth", Const, 19, ""},
+ {"ErrTrailingBackslash", Const, 0, ""},
+ {"ErrUnexpectedParen", Const, 1, ""},
+ {"Error", Type, 0, ""},
+ {"Error.Code", Field, 0, ""},
+ {"Error.Expr", Field, 0, ""},
+ {"ErrorCode", Type, 0, ""},
+ {"Flags", Type, 0, ""},
+ {"FoldCase", Const, 0, ""},
+ {"Inst", Type, 0, ""},
+ {"Inst.Arg", Field, 0, ""},
+ {"Inst.Op", Field, 0, ""},
+ {"Inst.Out", Field, 0, ""},
+ {"Inst.Rune", Field, 0, ""},
+ {"InstAlt", Const, 0, ""},
+ {"InstAltMatch", Const, 0, ""},
+ {"InstCapture", Const, 0, ""},
+ {"InstEmptyWidth", Const, 0, ""},
+ {"InstFail", Const, 0, ""},
+ {"InstMatch", Const, 0, ""},
+ {"InstNop", Const, 0, ""},
+ {"InstOp", Type, 0, ""},
+ {"InstRune", Const, 0, ""},
+ {"InstRune1", Const, 0, ""},
+ {"InstRuneAny", Const, 0, ""},
+ {"InstRuneAnyNotNL", Const, 0, ""},
+ {"IsWordChar", Func, 0, "func(r rune) bool"},
+ {"Literal", Const, 0, ""},
+ {"MatchNL", Const, 0, ""},
+ {"NonGreedy", Const, 0, ""},
+ {"OneLine", Const, 0, ""},
+ {"Op", Type, 0, ""},
+ {"OpAlternate", Const, 0, ""},
+ {"OpAnyChar", Const, 0, ""},
+ {"OpAnyCharNotNL", Const, 0, ""},
+ {"OpBeginLine", Const, 0, ""},
+ {"OpBeginText", Const, 0, ""},
+ {"OpCapture", Const, 0, ""},
+ {"OpCharClass", Const, 0, ""},
+ {"OpConcat", Const, 0, ""},
+ {"OpEmptyMatch", Const, 0, ""},
+ {"OpEndLine", Const, 0, ""},
+ {"OpEndText", Const, 0, ""},
+ {"OpLiteral", Const, 0, ""},
+ {"OpNoMatch", Const, 0, ""},
+ {"OpNoWordBoundary", Const, 0, ""},
+ {"OpPlus", Const, 0, ""},
+ {"OpQuest", Const, 0, ""},
+ {"OpRepeat", Const, 0, ""},
+ {"OpStar", Const, 0, ""},
+ {"OpWordBoundary", Const, 0, ""},
+ {"POSIX", Const, 0, ""},
+ {"Parse", Func, 0, "func(s string, flags Flags) (*Regexp, error)"},
+ {"Perl", Const, 0, ""},
+ {"PerlX", Const, 0, ""},
+ {"Prog", Type, 0, ""},
+ {"Prog.Inst", Field, 0, ""},
+ {"Prog.NumCap", Field, 0, ""},
+ {"Prog.Start", Field, 0, ""},
+ {"Regexp", Type, 0, ""},
+ {"Regexp.Cap", Field, 0, ""},
+ {"Regexp.Flags", Field, 0, ""},
+ {"Regexp.Max", Field, 0, ""},
+ {"Regexp.Min", Field, 0, ""},
+ {"Regexp.Name", Field, 0, ""},
+ {"Regexp.Op", Field, 0, ""},
+ {"Regexp.Rune", Field, 0, ""},
+ {"Regexp.Rune0", Field, 0, ""},
+ {"Regexp.Sub", Field, 0, ""},
+ {"Regexp.Sub0", Field, 0, ""},
+ {"Simple", Const, 0, ""},
+ {"UnicodeGroups", Const, 0, ""},
+ {"WasDollar", Const, 0, ""},
+ },
+ "runtime": {
+ {"(*BlockProfileRecord).Stack", Method, 1, ""},
+ {"(*Frames).Next", Method, 7, ""},
+ {"(*Func).Entry", Method, 0, ""},
+ {"(*Func).FileLine", Method, 0, ""},
+ {"(*Func).Name", Method, 0, ""},
+ {"(*MemProfileRecord).InUseBytes", Method, 0, ""},
+ {"(*MemProfileRecord).InUseObjects", Method, 0, ""},
+ {"(*MemProfileRecord).Stack", Method, 0, ""},
+ {"(*PanicNilError).Error", Method, 21, ""},
+ {"(*PanicNilError).RuntimeError", Method, 21, ""},
+ {"(*Pinner).Pin", Method, 21, ""},
+ {"(*Pinner).Unpin", Method, 21, ""},
+ {"(*StackRecord).Stack", Method, 0, ""},
+ {"(*TypeAssertionError).Error", Method, 0, ""},
+ {"(*TypeAssertionError).RuntimeError", Method, 0, ""},
+ {"(Cleanup).Stop", Method, 24, ""},
+ {"AddCleanup", Func, 24, "func[T, S any](ptr *T, cleanup func(S), arg S) Cleanup"},
+ {"BlockProfile", Func, 1, "func(p []BlockProfileRecord) (n int, ok bool)"},
+ {"BlockProfileRecord", Type, 1, ""},
+ {"BlockProfileRecord.Count", Field, 1, ""},
+ {"BlockProfileRecord.Cycles", Field, 1, ""},
+ {"BlockProfileRecord.StackRecord", Field, 1, ""},
+ {"Breakpoint", Func, 0, "func()"},
+ {"CPUProfile", Func, 0, "func() []byte"},
+ {"Caller", Func, 0, "func(skip int) (pc uintptr, file string, line int, ok bool)"},
+ {"Callers", Func, 0, "func(skip int, pc []uintptr) int"},
+ {"CallersFrames", Func, 7, "func(callers []uintptr) *Frames"},
+ {"Cleanup", Type, 24, ""},
+ {"Compiler", Const, 0, ""},
+ {"Error", Type, 0, ""},
+ {"Frame", Type, 7, ""},
+ {"Frame.Entry", Field, 7, ""},
+ {"Frame.File", Field, 7, ""},
+ {"Frame.Func", Field, 7, ""},
+ {"Frame.Function", Field, 7, ""},
+ {"Frame.Line", Field, 7, ""},
+ {"Frame.PC", Field, 7, ""},
+ {"Frames", Type, 7, ""},
+ {"Func", Type, 0, ""},
+ {"FuncForPC", Func, 0, "func(pc uintptr) *Func"},
+ {"GC", Func, 0, "func()"},
+ {"GOARCH", Const, 0, ""},
+ {"GOMAXPROCS", Func, 0, "func(n int) int"},
+ {"GOOS", Const, 0, ""},
+ {"GOROOT", Func, 0, "func() string"},
+ {"Goexit", Func, 0, "func()"},
+ {"GoroutineProfile", Func, 0, "func(p []StackRecord) (n int, ok bool)"},
+ {"Gosched", Func, 0, "func()"},
+ {"KeepAlive", Func, 7, "func(x any)"},
+ {"LockOSThread", Func, 0, "func()"},
+ {"MemProfile", Func, 0, "func(p []MemProfileRecord, inuseZero bool) (n int, ok bool)"},
+ {"MemProfileRate", Var, 0, ""},
+ {"MemProfileRecord", Type, 0, ""},
+ {"MemProfileRecord.AllocBytes", Field, 0, ""},
+ {"MemProfileRecord.AllocObjects", Field, 0, ""},
+ {"MemProfileRecord.FreeBytes", Field, 0, ""},
+ {"MemProfileRecord.FreeObjects", Field, 0, ""},
+ {"MemProfileRecord.Stack0", Field, 0, ""},
+ {"MemStats", Type, 0, ""},
+ {"MemStats.Alloc", Field, 0, ""},
+ {"MemStats.BuckHashSys", Field, 0, ""},
+ {"MemStats.BySize", Field, 0, ""},
+ {"MemStats.DebugGC", Field, 0, ""},
+ {"MemStats.EnableGC", Field, 0, ""},
+ {"MemStats.Frees", Field, 0, ""},
+ {"MemStats.GCCPUFraction", Field, 5, ""},
+ {"MemStats.GCSys", Field, 2, ""},
+ {"MemStats.HeapAlloc", Field, 0, ""},
+ {"MemStats.HeapIdle", Field, 0, ""},
+ {"MemStats.HeapInuse", Field, 0, ""},
+ {"MemStats.HeapObjects", Field, 0, ""},
+ {"MemStats.HeapReleased", Field, 0, ""},
+ {"MemStats.HeapSys", Field, 0, ""},
+ {"MemStats.LastGC", Field, 0, ""},
+ {"MemStats.Lookups", Field, 0, ""},
+ {"MemStats.MCacheInuse", Field, 0, ""},
+ {"MemStats.MCacheSys", Field, 0, ""},
+ {"MemStats.MSpanInuse", Field, 0, ""},
+ {"MemStats.MSpanSys", Field, 0, ""},
+ {"MemStats.Mallocs", Field, 0, ""},
+ {"MemStats.NextGC", Field, 0, ""},
+ {"MemStats.NumForcedGC", Field, 8, ""},
+ {"MemStats.NumGC", Field, 0, ""},
+ {"MemStats.OtherSys", Field, 2, ""},
+ {"MemStats.PauseEnd", Field, 4, ""},
+ {"MemStats.PauseNs", Field, 0, ""},
+ {"MemStats.PauseTotalNs", Field, 0, ""},
+ {"MemStats.StackInuse", Field, 0, ""},
+ {"MemStats.StackSys", Field, 0, ""},
+ {"MemStats.Sys", Field, 0, ""},
+ {"MemStats.TotalAlloc", Field, 0, ""},
+ {"MutexProfile", Func, 8, "func(p []BlockProfileRecord) (n int, ok bool)"},
+ {"NumCPU", Func, 0, "func() int"},
+ {"NumCgoCall", Func, 0, "func() int64"},
+ {"NumGoroutine", Func, 0, "func() int"},
+ {"PanicNilError", Type, 21, ""},
+ {"Pinner", Type, 21, ""},
+ {"ReadMemStats", Func, 0, "func(m *MemStats)"},
+ {"ReadTrace", Func, 5, "func() []byte"},
+ {"SetBlockProfileRate", Func, 1, "func(rate int)"},
+ {"SetCPUProfileRate", Func, 0, "func(hz int)"},
+ {"SetCgoTraceback", Func, 7, "func(version int, traceback unsafe.Pointer, context unsafe.Pointer, symbolizer unsafe.Pointer)"},
+ {"SetFinalizer", Func, 0, "func(obj any, finalizer any)"},
+ {"SetMutexProfileFraction", Func, 8, "func(rate int) int"},
+ {"Stack", Func, 0, "func(buf []byte, all bool) int"},
+ {"StackRecord", Type, 0, ""},
+ {"StackRecord.Stack0", Field, 0, ""},
+ {"StartTrace", Func, 5, "func() error"},
+ {"StopTrace", Func, 5, "func()"},
+ {"ThreadCreateProfile", Func, 0, "func(p []StackRecord) (n int, ok bool)"},
+ {"TypeAssertionError", Type, 0, ""},
+ {"UnlockOSThread", Func, 0, "func()"},
+ {"Version", Func, 0, "func() string"},
+ },
+ "runtime/cgo": {
+ {"(Handle).Delete", Method, 17, ""},
+ {"(Handle).Value", Method, 17, ""},
+ {"Handle", Type, 17, ""},
+ {"Incomplete", Type, 20, ""},
+ {"NewHandle", Func, 17, ""},
+ },
+ "runtime/coverage": {
+ {"ClearCounters", Func, 20, "func() error"},
+ {"WriteCounters", Func, 20, "func(w io.Writer) error"},
+ {"WriteCountersDir", Func, 20, "func(dir string) error"},
+ {"WriteMeta", Func, 20, "func(w io.Writer) error"},
+ {"WriteMetaDir", Func, 20, "func(dir string) error"},
+ },
+ "runtime/debug": {
+ {"(*BuildInfo).String", Method, 18, ""},
+ {"BuildInfo", Type, 12, ""},
+ {"BuildInfo.Deps", Field, 12, ""},
+ {"BuildInfo.GoVersion", Field, 18, ""},
+ {"BuildInfo.Main", Field, 12, ""},
+ {"BuildInfo.Path", Field, 12, ""},
+ {"BuildInfo.Settings", Field, 18, ""},
+ {"BuildSetting", Type, 18, ""},
+ {"BuildSetting.Key", Field, 18, ""},
+ {"BuildSetting.Value", Field, 18, ""},
+ {"CrashOptions", Type, 23, ""},
+ {"FreeOSMemory", Func, 1, "func()"},
+ {"GCStats", Type, 1, ""},
+ {"GCStats.LastGC", Field, 1, ""},
+ {"GCStats.NumGC", Field, 1, ""},
+ {"GCStats.Pause", Field, 1, ""},
+ {"GCStats.PauseEnd", Field, 4, ""},
+ {"GCStats.PauseQuantiles", Field, 1, ""},
+ {"GCStats.PauseTotal", Field, 1, ""},
+ {"Module", Type, 12, ""},
+ {"Module.Path", Field, 12, ""},
+ {"Module.Replace", Field, 12, ""},
+ {"Module.Sum", Field, 12, ""},
+ {"Module.Version", Field, 12, ""},
+ {"ParseBuildInfo", Func, 18, "func(data string) (bi *BuildInfo, err error)"},
+ {"PrintStack", Func, 0, "func()"},
+ {"ReadBuildInfo", Func, 12, "func() (info *BuildInfo, ok bool)"},
+ {"ReadGCStats", Func, 1, "func(stats *GCStats)"},
+ {"SetCrashOutput", Func, 23, "func(f *os.File, opts CrashOptions) error"},
+ {"SetGCPercent", Func, 1, "func(percent int) int"},
+ {"SetMaxStack", Func, 2, "func(bytes int) int"},
+ {"SetMaxThreads", Func, 2, "func(threads int) int"},
+ {"SetMemoryLimit", Func, 19, "func(limit int64) int64"},
+ {"SetPanicOnFault", Func, 3, "func(enabled bool) bool"},
+ {"SetTraceback", Func, 6, "func(level string)"},
+ {"Stack", Func, 0, "func() []byte"},
+ {"WriteHeapDump", Func, 3, "func(fd uintptr)"},
+ },
+ "runtime/metrics": {
+ {"(Value).Float64", Method, 16, ""},
+ {"(Value).Float64Histogram", Method, 16, ""},
+ {"(Value).Kind", Method, 16, ""},
+ {"(Value).Uint64", Method, 16, ""},
+ {"All", Func, 16, "func() []Description"},
+ {"Description", Type, 16, ""},
+ {"Description.Cumulative", Field, 16, ""},
+ {"Description.Description", Field, 16, ""},
+ {"Description.Kind", Field, 16, ""},
+ {"Description.Name", Field, 16, ""},
+ {"Float64Histogram", Type, 16, ""},
+ {"Float64Histogram.Buckets", Field, 16, ""},
+ {"Float64Histogram.Counts", Field, 16, ""},
+ {"KindBad", Const, 16, ""},
+ {"KindFloat64", Const, 16, ""},
+ {"KindFloat64Histogram", Const, 16, ""},
+ {"KindUint64", Const, 16, ""},
+ {"Read", Func, 16, "func(m []Sample)"},
+ {"Sample", Type, 16, ""},
+ {"Sample.Name", Field, 16, ""},
+ {"Sample.Value", Field, 16, ""},
+ {"Value", Type, 16, ""},
+ {"ValueKind", Type, 16, ""},
+ },
+ "runtime/pprof": {
+ {"(*Profile).Add", Method, 0, ""},
+ {"(*Profile).Count", Method, 0, ""},
+ {"(*Profile).Name", Method, 0, ""},
+ {"(*Profile).Remove", Method, 0, ""},
+ {"(*Profile).WriteTo", Method, 0, ""},
+ {"Do", Func, 9, "func(ctx context.Context, labels LabelSet, f func(context.Context))"},
+ {"ForLabels", Func, 9, "func(ctx context.Context, f func(key string, value string) bool)"},
+ {"Label", Func, 9, "func(ctx context.Context, key string) (string, bool)"},
+ {"LabelSet", Type, 9, ""},
+ {"Labels", Func, 9, "func(args ...string) LabelSet"},
+ {"Lookup", Func, 0, "func(name string) *Profile"},
+ {"NewProfile", Func, 0, "func(name string) *Profile"},
+ {"Profile", Type, 0, ""},
+ {"Profiles", Func, 0, "func() []*Profile"},
+ {"SetGoroutineLabels", Func, 9, "func(ctx context.Context)"},
+ {"StartCPUProfile", Func, 0, "func(w io.Writer) error"},
+ {"StopCPUProfile", Func, 0, "func()"},
+ {"WithLabels", Func, 9, "func(ctx context.Context, labels LabelSet) context.Context"},
+ {"WriteHeapProfile", Func, 0, "func(w io.Writer) error"},
+ },
+ "runtime/trace": {
+ {"(*Region).End", Method, 11, ""},
+ {"(*Task).End", Method, 11, ""},
+ {"IsEnabled", Func, 11, "func() bool"},
+ {"Log", Func, 11, "func(ctx context.Context, category string, message string)"},
+ {"Logf", Func, 11, "func(ctx context.Context, category string, format string, args ...any)"},
+ {"NewTask", Func, 11, "func(pctx context.Context, taskType string) (ctx context.Context, task *Task)"},
+ {"Region", Type, 11, ""},
+ {"Start", Func, 5, "func(w io.Writer) error"},
+ {"StartRegion", Func, 11, "func(ctx context.Context, regionType string) *Region"},
+ {"Stop", Func, 5, "func()"},
+ {"Task", Type, 11, ""},
+ {"WithRegion", Func, 11, "func(ctx context.Context, regionType string, fn func())"},
+ },
+ "slices": {
+ {"All", Func, 23, "func[Slice ~[]E, E any](s Slice) iter.Seq2[int, E]"},
+ {"AppendSeq", Func, 23, "func[Slice ~[]E, E any](s Slice, seq iter.Seq[E]) Slice"},
+ {"Backward", Func, 23, "func[Slice ~[]E, E any](s Slice) iter.Seq2[int, E]"},
+ {"BinarySearch", Func, 21, "func[S ~[]E, E cmp.Ordered](x S, target E) (int, bool)"},
+ {"BinarySearchFunc", Func, 21, "func[S ~[]E, E, T any](x S, target T, cmp func(E, T) int) (int, bool)"},
+ {"Chunk", Func, 23, "func[Slice ~[]E, E any](s Slice, n int) iter.Seq[Slice]"},
+ {"Clip", Func, 21, "func[S ~[]E, E any](s S) S"},
+ {"Clone", Func, 21, "func[S ~[]E, E any](s S) S"},
+ {"Collect", Func, 23, "func[E any](seq iter.Seq[E]) []E"},
+ {"Compact", Func, 21, "func[S ~[]E, E comparable](s S) S"},
+ {"CompactFunc", Func, 21, "func[S ~[]E, E any](s S, eq func(E, E) bool) S"},
+ {"Compare", Func, 21, "func[S ~[]E, E cmp.Ordered](s1 S, s2 S) int"},
+ {"CompareFunc", Func, 21, "func[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, cmp func(E1, E2) int) int"},
+ {"Concat", Func, 22, "func[S ~[]E, E any](slices ...S) S"},
+ {"Contains", Func, 21, "func[S ~[]E, E comparable](s S, v E) bool"},
+ {"ContainsFunc", Func, 21, "func[S ~[]E, E any](s S, f func(E) bool) bool"},
+ {"Delete", Func, 21, "func[S ~[]E, E any](s S, i int, j int) S"},
+ {"DeleteFunc", Func, 21, "func[S ~[]E, E any](s S, del func(E) bool) S"},
+ {"Equal", Func, 21, "func[S ~[]E, E comparable](s1 S, s2 S) bool"},
+ {"EqualFunc", Func, 21, "func[S1 ~[]E1, S2 ~[]E2, E1, E2 any](s1 S1, s2 S2, eq func(E1, E2) bool) bool"},
+ {"Grow", Func, 21, "func[S ~[]E, E any](s S, n int) S"},
+ {"Index", Func, 21, "func[S ~[]E, E comparable](s S, v E) int"},
+ {"IndexFunc", Func, 21, "func[S ~[]E, E any](s S, f func(E) bool) int"},
+ {"Insert", Func, 21, "func[S ~[]E, E any](s S, i int, v ...E) S"},
+ {"IsSorted", Func, 21, "func[S ~[]E, E cmp.Ordered](x S) bool"},
+ {"IsSortedFunc", Func, 21, "func[S ~[]E, E any](x S, cmp func(a E, b E) int) bool"},
+ {"Max", Func, 21, "func[S ~[]E, E cmp.Ordered](x S) E"},
+ {"MaxFunc", Func, 21, "func[S ~[]E, E any](x S, cmp func(a E, b E) int) E"},
+ {"Min", Func, 21, "func[S ~[]E, E cmp.Ordered](x S) E"},
+ {"MinFunc", Func, 21, "func[S ~[]E, E any](x S, cmp func(a E, b E) int) E"},
+ {"Repeat", Func, 23, "func[S ~[]E, E any](x S, count int) S"},
+ {"Replace", Func, 21, "func[S ~[]E, E any](s S, i int, j int, v ...E) S"},
+ {"Reverse", Func, 21, "func[S ~[]E, E any](s S)"},
+ {"Sort", Func, 21, "func[S ~[]E, E cmp.Ordered](x S)"},
+ {"SortFunc", Func, 21, "func[S ~[]E, E any](x S, cmp func(a E, b E) int)"},
+ {"SortStableFunc", Func, 21, "func[S ~[]E, E any](x S, cmp func(a E, b E) int)"},
+ {"Sorted", Func, 23, "func[E cmp.Ordered](seq iter.Seq[E]) []E"},
+ {"SortedFunc", Func, 23, "func[E any](seq iter.Seq[E], cmp func(E, E) int) []E"},
+ {"SortedStableFunc", Func, 23, "func[E any](seq iter.Seq[E], cmp func(E, E) int) []E"},
+ {"Values", Func, 23, "func[Slice ~[]E, E any](s Slice) iter.Seq[E]"},
+ },
+ "sort": {
+ {"(Float64Slice).Len", Method, 0, ""},
+ {"(Float64Slice).Less", Method, 0, ""},
+ {"(Float64Slice).Search", Method, 0, ""},
+ {"(Float64Slice).Sort", Method, 0, ""},
+ {"(Float64Slice).Swap", Method, 0, ""},
+ {"(IntSlice).Len", Method, 0, ""},
+ {"(IntSlice).Less", Method, 0, ""},
+ {"(IntSlice).Search", Method, 0, ""},
+ {"(IntSlice).Sort", Method, 0, ""},
+ {"(IntSlice).Swap", Method, 0, ""},
+ {"(StringSlice).Len", Method, 0, ""},
+ {"(StringSlice).Less", Method, 0, ""},
+ {"(StringSlice).Search", Method, 0, ""},
+ {"(StringSlice).Sort", Method, 0, ""},
+ {"(StringSlice).Swap", Method, 0, ""},
+ {"Find", Func, 19, "func(n int, cmp func(int) int) (i int, found bool)"},
+ {"Float64Slice", Type, 0, ""},
+ {"Float64s", Func, 0, "func(x []float64)"},
+ {"Float64sAreSorted", Func, 0, "func(x []float64) bool"},
+ {"IntSlice", Type, 0, ""},
+ {"Interface", Type, 0, ""},
+ {"Ints", Func, 0, "func(x []int)"},
+ {"IntsAreSorted", Func, 0, "func(x []int) bool"},
+ {"IsSorted", Func, 0, "func(data Interface) bool"},
+ {"Reverse", Func, 1, "func(data Interface) Interface"},
+ {"Search", Func, 0, "func(n int, f func(int) bool) int"},
+ {"SearchFloat64s", Func, 0, "func(a []float64, x float64) int"},
+ {"SearchInts", Func, 0, "func(a []int, x int) int"},
+ {"SearchStrings", Func, 0, "func(a []string, x string) int"},
+ {"Slice", Func, 8, "func(x any, less func(i int, j int) bool)"},
+ {"SliceIsSorted", Func, 8, "func(x any, less func(i int, j int) bool) bool"},
+ {"SliceStable", Func, 8, "func(x any, less func(i int, j int) bool)"},
+ {"Sort", Func, 0, "func(data Interface)"},
+ {"Stable", Func, 2, "func(data Interface)"},
+ {"StringSlice", Type, 0, ""},
+ {"Strings", Func, 0, "func(x []string)"},
+ {"StringsAreSorted", Func, 0, "func(x []string) bool"},
+ },
+ "strconv": {
+ {"(*NumError).Error", Method, 0, ""},
+ {"(*NumError).Unwrap", Method, 14, ""},
+ {"AppendBool", Func, 0, "func(dst []byte, b bool) []byte"},
+ {"AppendFloat", Func, 0, "func(dst []byte, f float64, fmt byte, prec int, bitSize int) []byte"},
+ {"AppendInt", Func, 0, "func(dst []byte, i int64, base int) []byte"},
+ {"AppendQuote", Func, 0, "func(dst []byte, s string) []byte"},
+ {"AppendQuoteRune", Func, 0, "func(dst []byte, r rune) []byte"},
+ {"AppendQuoteRuneToASCII", Func, 0, "func(dst []byte, r rune) []byte"},
+ {"AppendQuoteRuneToGraphic", Func, 6, "func(dst []byte, r rune) []byte"},
+ {"AppendQuoteToASCII", Func, 0, "func(dst []byte, s string) []byte"},
+ {"AppendQuoteToGraphic", Func, 6, "func(dst []byte, s string) []byte"},
+ {"AppendUint", Func, 0, "func(dst []byte, i uint64, base int) []byte"},
+ {"Atoi", Func, 0, "func(s string) (int, error)"},
+ {"CanBackquote", Func, 0, "func(s string) bool"},
+ {"ErrRange", Var, 0, ""},
+ {"ErrSyntax", Var, 0, ""},
+ {"FormatBool", Func, 0, "func(b bool) string"},
+ {"FormatComplex", Func, 15, "func(c complex128, fmt byte, prec int, bitSize int) string"},
+ {"FormatFloat", Func, 0, "func(f float64, fmt byte, prec int, bitSize int) string"},
+ {"FormatInt", Func, 0, "func(i int64, base int) string"},
+ {"FormatUint", Func, 0, "func(i uint64, base int) string"},
+ {"IntSize", Const, 0, ""},
+ {"IsGraphic", Func, 6, "func(r rune) bool"},
+ {"IsPrint", Func, 0, "func(r rune) bool"},
+ {"Itoa", Func, 0, "func(i int) string"},
+ {"NumError", Type, 0, ""},
+ {"NumError.Err", Field, 0, ""},
+ {"NumError.Func", Field, 0, ""},
+ {"NumError.Num", Field, 0, ""},
+ {"ParseBool", Func, 0, "func(str string) (bool, error)"},
+ {"ParseComplex", Func, 15, "func(s string, bitSize int) (complex128, error)"},
+ {"ParseFloat", Func, 0, "func(s string, bitSize int) (float64, error)"},
+ {"ParseInt", Func, 0, "func(s string, base int, bitSize int) (i int64, err error)"},
+ {"ParseUint", Func, 0, "func(s string, base int, bitSize int) (uint64, error)"},
+ {"Quote", Func, 0, "func(s string) string"},
+ {"QuoteRune", Func, 0, "func(r rune) string"},
+ {"QuoteRuneToASCII", Func, 0, "func(r rune) string"},
+ {"QuoteRuneToGraphic", Func, 6, "func(r rune) string"},
+ {"QuoteToASCII", Func, 0, "func(s string) string"},
+ {"QuoteToGraphic", Func, 6, "func(s string) string"},
+ {"QuotedPrefix", Func, 17, "func(s string) (string, error)"},
+ {"Unquote", Func, 0, "func(s string) (string, error)"},
+ {"UnquoteChar", Func, 0, "func(s string, quote byte) (value rune, multibyte bool, tail string, err error)"},
+ },
+ "strings": {
+ {"(*Builder).Cap", Method, 12, ""},
+ {"(*Builder).Grow", Method, 10, ""},
+ {"(*Builder).Len", Method, 10, ""},
+ {"(*Builder).Reset", Method, 10, ""},
+ {"(*Builder).String", Method, 10, ""},
+ {"(*Builder).Write", Method, 10, ""},
+ {"(*Builder).WriteByte", Method, 10, ""},
+ {"(*Builder).WriteRune", Method, 10, ""},
+ {"(*Builder).WriteString", Method, 10, ""},
+ {"(*Reader).Len", Method, 0, ""},
+ {"(*Reader).Read", Method, 0, ""},
+ {"(*Reader).ReadAt", Method, 0, ""},
+ {"(*Reader).ReadByte", Method, 0, ""},
+ {"(*Reader).ReadRune", Method, 0, ""},
+ {"(*Reader).Reset", Method, 7, ""},
+ {"(*Reader).Seek", Method, 0, ""},
+ {"(*Reader).Size", Method, 5, ""},
+ {"(*Reader).UnreadByte", Method, 0, ""},
+ {"(*Reader).UnreadRune", Method, 0, ""},
+ {"(*Reader).WriteTo", Method, 1, ""},
+ {"(*Replacer).Replace", Method, 0, ""},
+ {"(*Replacer).WriteString", Method, 0, ""},
+ {"Builder", Type, 10, ""},
+ {"Clone", Func, 18, "func(s string) string"},
+ {"Compare", Func, 5, "func(a string, b string) int"},
+ {"Contains", Func, 0, "func(s string, substr string) bool"},
+ {"ContainsAny", Func, 0, "func(s string, chars string) bool"},
+ {"ContainsFunc", Func, 21, "func(s string, f func(rune) bool) bool"},
+ {"ContainsRune", Func, 0, "func(s string, r rune) bool"},
+ {"Count", Func, 0, "func(s string, substr string) int"},
+ {"Cut", Func, 18, "func(s string, sep string) (before string, after string, found bool)"},
+ {"CutPrefix", Func, 20, "func(s string, prefix string) (after string, found bool)"},
+ {"CutSuffix", Func, 20, "func(s string, suffix string) (before string, found bool)"},
+ {"EqualFold", Func, 0, "func(s string, t string) bool"},
+ {"Fields", Func, 0, "func(s string) []string"},
+ {"FieldsFunc", Func, 0, "func(s string, f func(rune) bool) []string"},
+ {"FieldsFuncSeq", Func, 24, "func(s string, f func(rune) bool) iter.Seq[string]"},
+ {"FieldsSeq", Func, 24, "func(s string) iter.Seq[string]"},
+ {"HasPrefix", Func, 0, "func(s string, prefix string) bool"},
+ {"HasSuffix", Func, 0, "func(s string, suffix string) bool"},
+ {"Index", Func, 0, "func(s string, substr string) int"},
+ {"IndexAny", Func, 0, "func(s string, chars string) int"},
+ {"IndexByte", Func, 2, "func(s string, c byte) int"},
+ {"IndexFunc", Func, 0, "func(s string, f func(rune) bool) int"},
+ {"IndexRune", Func, 0, "func(s string, r rune) int"},
+ {"Join", Func, 0, "func(elems []string, sep string) string"},
+ {"LastIndex", Func, 0, "func(s string, substr string) int"},
+ {"LastIndexAny", Func, 0, "func(s string, chars string) int"},
+ {"LastIndexByte", Func, 5, "func(s string, c byte) int"},
+ {"LastIndexFunc", Func, 0, "func(s string, f func(rune) bool) int"},
+ {"Lines", Func, 24, "func(s string) iter.Seq[string]"},
+ {"Map", Func, 0, "func(mapping func(rune) rune, s string) string"},
+ {"NewReader", Func, 0, "func(s string) *Reader"},
+ {"NewReplacer", Func, 0, "func(oldnew ...string) *Replacer"},
+ {"Reader", Type, 0, ""},
+ {"Repeat", Func, 0, "func(s string, count int) string"},
+ {"Replace", Func, 0, "func(s string, old string, new string, n int) string"},
+ {"ReplaceAll", Func, 12, "func(s string, old string, new string) string"},
+ {"Replacer", Type, 0, ""},
+ {"Split", Func, 0, "func(s string, sep string) []string"},
+ {"SplitAfter", Func, 0, "func(s string, sep string) []string"},
+ {"SplitAfterN", Func, 0, "func(s string, sep string, n int) []string"},
+ {"SplitAfterSeq", Func, 24, "func(s string, sep string) iter.Seq[string]"},
+ {"SplitN", Func, 0, "func(s string, sep string, n int) []string"},
+ {"SplitSeq", Func, 24, "func(s string, sep string) iter.Seq[string]"},
+ {"Title", Func, 0, "func(s string) string"},
+ {"ToLower", Func, 0, "func(s string) string"},
+ {"ToLowerSpecial", Func, 0, "func(c unicode.SpecialCase, s string) string"},
+ {"ToTitle", Func, 0, "func(s string) string"},
+ {"ToTitleSpecial", Func, 0, "func(c unicode.SpecialCase, s string) string"},
+ {"ToUpper", Func, 0, "func(s string) string"},
+ {"ToUpperSpecial", Func, 0, "func(c unicode.SpecialCase, s string) string"},
+ {"ToValidUTF8", Func, 13, "func(s string, replacement string) string"},
+ {"Trim", Func, 0, "func(s string, cutset string) string"},
+ {"TrimFunc", Func, 0, "func(s string, f func(rune) bool) string"},
+ {"TrimLeft", Func, 0, "func(s string, cutset string) string"},
+ {"TrimLeftFunc", Func, 0, "func(s string, f func(rune) bool) string"},
+ {"TrimPrefix", Func, 1, "func(s string, prefix string) string"},
+ {"TrimRight", Func, 0, "func(s string, cutset string) string"},
+ {"TrimRightFunc", Func, 0, "func(s string, f func(rune) bool) string"},
+ {"TrimSpace", Func, 0, "func(s string) string"},
+ {"TrimSuffix", Func, 1, "func(s string, suffix string) string"},
+ },
+ "structs": {
+ {"HostLayout", Type, 23, ""},
+ },
+ "sync": {
+ {"(*Cond).Broadcast", Method, 0, ""},
+ {"(*Cond).Signal", Method, 0, ""},
+ {"(*Cond).Wait", Method, 0, ""},
+ {"(*Map).Clear", Method, 23, ""},
+ {"(*Map).CompareAndDelete", Method, 20, ""},
+ {"(*Map).CompareAndSwap", Method, 20, ""},
+ {"(*Map).Delete", Method, 9, ""},
+ {"(*Map).Load", Method, 9, ""},
+ {"(*Map).LoadAndDelete", Method, 15, ""},
+ {"(*Map).LoadOrStore", Method, 9, ""},
+ {"(*Map).Range", Method, 9, ""},
+ {"(*Map).Store", Method, 9, ""},
+ {"(*Map).Swap", Method, 20, ""},
+ {"(*Mutex).Lock", Method, 0, ""},
+ {"(*Mutex).TryLock", Method, 18, ""},
+ {"(*Mutex).Unlock", Method, 0, ""},
+ {"(*Once).Do", Method, 0, ""},
+ {"(*Pool).Get", Method, 3, ""},
+ {"(*Pool).Put", Method, 3, ""},
+ {"(*RWMutex).Lock", Method, 0, ""},
+ {"(*RWMutex).RLock", Method, 0, ""},
+ {"(*RWMutex).RLocker", Method, 0, ""},
+ {"(*RWMutex).RUnlock", Method, 0, ""},
+ {"(*RWMutex).TryLock", Method, 18, ""},
+ {"(*RWMutex).TryRLock", Method, 18, ""},
+ {"(*RWMutex).Unlock", Method, 0, ""},
+ {"(*WaitGroup).Add", Method, 0, ""},
+ {"(*WaitGroup).Done", Method, 0, ""},
+ {"(*WaitGroup).Go", Method, 25, ""},
+ {"(*WaitGroup).Wait", Method, 0, ""},
+ {"Cond", Type, 0, ""},
+ {"Cond.L", Field, 0, ""},
+ {"Locker", Type, 0, ""},
+ {"Map", Type, 9, ""},
+ {"Mutex", Type, 0, ""},
+ {"NewCond", Func, 0, "func(l Locker) *Cond"},
+ {"Once", Type, 0, ""},
+ {"OnceFunc", Func, 21, "func(f func()) func()"},
+ {"OnceValue", Func, 21, "func[T any](f func() T) func() T"},
+ {"OnceValues", Func, 21, "func[T1, T2 any](f func() (T1, T2)) func() (T1, T2)"},
+ {"Pool", Type, 3, ""},
+ {"Pool.New", Field, 3, ""},
+ {"RWMutex", Type, 0, ""},
+ {"WaitGroup", Type, 0, ""},
+ },
+ "sync/atomic": {
+ {"(*Bool).CompareAndSwap", Method, 19, ""},
+ {"(*Bool).Load", Method, 19, ""},
+ {"(*Bool).Store", Method, 19, ""},
+ {"(*Bool).Swap", Method, 19, ""},
+ {"(*Int32).Add", Method, 19, ""},
+ {"(*Int32).And", Method, 23, ""},
+ {"(*Int32).CompareAndSwap", Method, 19, ""},
+ {"(*Int32).Load", Method, 19, ""},
+ {"(*Int32).Or", Method, 23, ""},
+ {"(*Int32).Store", Method, 19, ""},
+ {"(*Int32).Swap", Method, 19, ""},
+ {"(*Int64).Add", Method, 19, ""},
+ {"(*Int64).And", Method, 23, ""},
+ {"(*Int64).CompareAndSwap", Method, 19, ""},
+ {"(*Int64).Load", Method, 19, ""},
+ {"(*Int64).Or", Method, 23, ""},
+ {"(*Int64).Store", Method, 19, ""},
+ {"(*Int64).Swap", Method, 19, ""},
+ {"(*Pointer).CompareAndSwap", Method, 19, ""},
+ {"(*Pointer).Load", Method, 19, ""},
+ {"(*Pointer).Store", Method, 19, ""},
+ {"(*Pointer).Swap", Method, 19, ""},
+ {"(*Uint32).Add", Method, 19, ""},
+ {"(*Uint32).And", Method, 23, ""},
+ {"(*Uint32).CompareAndSwap", Method, 19, ""},
+ {"(*Uint32).Load", Method, 19, ""},
+ {"(*Uint32).Or", Method, 23, ""},
+ {"(*Uint32).Store", Method, 19, ""},
+ {"(*Uint32).Swap", Method, 19, ""},
+ {"(*Uint64).Add", Method, 19, ""},
+ {"(*Uint64).And", Method, 23, ""},
+ {"(*Uint64).CompareAndSwap", Method, 19, ""},
+ {"(*Uint64).Load", Method, 19, ""},
+ {"(*Uint64).Or", Method, 23, ""},
+ {"(*Uint64).Store", Method, 19, ""},
+ {"(*Uint64).Swap", Method, 19, ""},
+ {"(*Uintptr).Add", Method, 19, ""},
+ {"(*Uintptr).And", Method, 23, ""},
+ {"(*Uintptr).CompareAndSwap", Method, 19, ""},
+ {"(*Uintptr).Load", Method, 19, ""},
+ {"(*Uintptr).Or", Method, 23, ""},
+ {"(*Uintptr).Store", Method, 19, ""},
+ {"(*Uintptr).Swap", Method, 19, ""},
+ {"(*Value).CompareAndSwap", Method, 17, ""},
+ {"(*Value).Load", Method, 4, ""},
+ {"(*Value).Store", Method, 4, ""},
+ {"(*Value).Swap", Method, 17, ""},
+ {"AddInt32", Func, 0, "func(addr *int32, delta int32) (new int32)"},
+ {"AddInt64", Func, 0, "func(addr *int64, delta int64) (new int64)"},
+ {"AddUint32", Func, 0, "func(addr *uint32, delta uint32) (new uint32)"},
+ {"AddUint64", Func, 0, "func(addr *uint64, delta uint64) (new uint64)"},
+ {"AddUintptr", Func, 0, "func(addr *uintptr, delta uintptr) (new uintptr)"},
+ {"AndInt32", Func, 23, "func(addr *int32, mask int32) (old int32)"},
+ {"AndInt64", Func, 23, "func(addr *int64, mask int64) (old int64)"},
+ {"AndUint32", Func, 23, "func(addr *uint32, mask uint32) (old uint32)"},
+ {"AndUint64", Func, 23, "func(addr *uint64, mask uint64) (old uint64)"},
+ {"AndUintptr", Func, 23, "func(addr *uintptr, mask uintptr) (old uintptr)"},
+ {"Bool", Type, 19, ""},
+ {"CompareAndSwapInt32", Func, 0, "func(addr *int32, old int32, new int32) (swapped bool)"},
+ {"CompareAndSwapInt64", Func, 0, "func(addr *int64, old int64, new int64) (swapped bool)"},
+ {"CompareAndSwapPointer", Func, 0, "func(addr *unsafe.Pointer, old unsafe.Pointer, new unsafe.Pointer) (swapped bool)"},
+ {"CompareAndSwapUint32", Func, 0, "func(addr *uint32, old uint32, new uint32) (swapped bool)"},
+ {"CompareAndSwapUint64", Func, 0, "func(addr *uint64, old uint64, new uint64) (swapped bool)"},
+ {"CompareAndSwapUintptr", Func, 0, "func(addr *uintptr, old uintptr, new uintptr) (swapped bool)"},
+ {"Int32", Type, 19, ""},
+ {"Int64", Type, 19, ""},
+ {"LoadInt32", Func, 0, "func(addr *int32) (val int32)"},
+ {"LoadInt64", Func, 0, "func(addr *int64) (val int64)"},
+ {"LoadPointer", Func, 0, "func(addr *unsafe.Pointer) (val unsafe.Pointer)"},
+ {"LoadUint32", Func, 0, "func(addr *uint32) (val uint32)"},
+ {"LoadUint64", Func, 0, "func(addr *uint64) (val uint64)"},
+ {"LoadUintptr", Func, 0, "func(addr *uintptr) (val uintptr)"},
+ {"OrInt32", Func, 23, "func(addr *int32, mask int32) (old int32)"},
+ {"OrInt64", Func, 23, "func(addr *int64, mask int64) (old int64)"},
+ {"OrUint32", Func, 23, "func(addr *uint32, mask uint32) (old uint32)"},
+ {"OrUint64", Func, 23, "func(addr *uint64, mask uint64) (old uint64)"},
+ {"OrUintptr", Func, 23, "func(addr *uintptr, mask uintptr) (old uintptr)"},
+ {"Pointer", Type, 19, ""},
+ {"StoreInt32", Func, 0, "func(addr *int32, val int32)"},
+ {"StoreInt64", Func, 0, "func(addr *int64, val int64)"},
+ {"StorePointer", Func, 0, "func(addr *unsafe.Pointer, val unsafe.Pointer)"},
+ {"StoreUint32", Func, 0, "func(addr *uint32, val uint32)"},
+ {"StoreUint64", Func, 0, "func(addr *uint64, val uint64)"},
+ {"StoreUintptr", Func, 0, "func(addr *uintptr, val uintptr)"},
+ {"SwapInt32", Func, 2, "func(addr *int32, new int32) (old int32)"},
+ {"SwapInt64", Func, 2, "func(addr *int64, new int64) (old int64)"},
+ {"SwapPointer", Func, 2, "func(addr *unsafe.Pointer, new unsafe.Pointer) (old unsafe.Pointer)"},
+ {"SwapUint32", Func, 2, "func(addr *uint32, new uint32) (old uint32)"},
+ {"SwapUint64", Func, 2, "func(addr *uint64, new uint64) (old uint64)"},
+ {"SwapUintptr", Func, 2, "func(addr *uintptr, new uintptr) (old uintptr)"},
+ {"Uint32", Type, 19, ""},
+ {"Uint64", Type, 19, ""},
+ {"Uintptr", Type, 19, ""},
+ {"Value", Type, 4, ""},
+ },
+ "syscall": {
+ {"(*Cmsghdr).SetLen", Method, 0, ""},
+ {"(*DLL).FindProc", Method, 0, ""},
+ {"(*DLL).MustFindProc", Method, 0, ""},
+ {"(*DLL).Release", Method, 0, ""},
+ {"(*DLLError).Error", Method, 0, ""},
+ {"(*DLLError).Unwrap", Method, 16, ""},
+ {"(*Filetime).Nanoseconds", Method, 0, ""},
+ {"(*Iovec).SetLen", Method, 0, ""},
+ {"(*LazyDLL).Handle", Method, 0, ""},
+ {"(*LazyDLL).Load", Method, 0, ""},
+ {"(*LazyDLL).NewProc", Method, 0, ""},
+ {"(*LazyProc).Addr", Method, 0, ""},
+ {"(*LazyProc).Call", Method, 0, ""},
+ {"(*LazyProc).Find", Method, 0, ""},
+ {"(*Msghdr).SetControllen", Method, 0, ""},
+ {"(*Proc).Addr", Method, 0, ""},
+ {"(*Proc).Call", Method, 0, ""},
+ {"(*PtraceRegs).PC", Method, 0, ""},
+ {"(*PtraceRegs).SetPC", Method, 0, ""},
+ {"(*RawSockaddrAny).Sockaddr", Method, 0, ""},
+ {"(*SID).Copy", Method, 0, ""},
+ {"(*SID).Len", Method, 0, ""},
+ {"(*SID).LookupAccount", Method, 0, ""},
+ {"(*SID).String", Method, 0, ""},
+ {"(*Timespec).Nano", Method, 0, ""},
+ {"(*Timespec).Unix", Method, 0, ""},
+ {"(*Timeval).Nano", Method, 0, ""},
+ {"(*Timeval).Nanoseconds", Method, 0, ""},
+ {"(*Timeval).Unix", Method, 0, ""},
+ {"(Errno).Error", Method, 0, ""},
+ {"(Errno).Is", Method, 13, ""},
+ {"(Errno).Temporary", Method, 0, ""},
+ {"(Errno).Timeout", Method, 0, ""},
+ {"(Signal).Signal", Method, 0, ""},
+ {"(Signal).String", Method, 0, ""},
+ {"(Token).Close", Method, 0, ""},
+ {"(Token).GetTokenPrimaryGroup", Method, 0, ""},
+ {"(Token).GetTokenUser", Method, 0, ""},
+ {"(Token).GetUserProfileDirectory", Method, 0, ""},
+ {"(WaitStatus).Continued", Method, 0, ""},
+ {"(WaitStatus).CoreDump", Method, 0, ""},
+ {"(WaitStatus).ExitStatus", Method, 0, ""},
+ {"(WaitStatus).Exited", Method, 0, ""},
+ {"(WaitStatus).Signal", Method, 0, ""},
+ {"(WaitStatus).Signaled", Method, 0, ""},
+ {"(WaitStatus).StopSignal", Method, 0, ""},
+ {"(WaitStatus).Stopped", Method, 0, ""},
+ {"(WaitStatus).TrapCause", Method, 0, ""},
+ {"AF_ALG", Const, 0, ""},
+ {"AF_APPLETALK", Const, 0, ""},
+ {"AF_ARP", Const, 0, ""},
+ {"AF_ASH", Const, 0, ""},
+ {"AF_ATM", Const, 0, ""},
+ {"AF_ATMPVC", Const, 0, ""},
+ {"AF_ATMSVC", Const, 0, ""},
+ {"AF_AX25", Const, 0, ""},
+ {"AF_BLUETOOTH", Const, 0, ""},
+ {"AF_BRIDGE", Const, 0, ""},
+ {"AF_CAIF", Const, 0, ""},
+ {"AF_CAN", Const, 0, ""},
+ {"AF_CCITT", Const, 0, ""},
+ {"AF_CHAOS", Const, 0, ""},
+ {"AF_CNT", Const, 0, ""},
+ {"AF_COIP", Const, 0, ""},
+ {"AF_DATAKIT", Const, 0, ""},
+ {"AF_DECnet", Const, 0, ""},
+ {"AF_DLI", Const, 0, ""},
+ {"AF_E164", Const, 0, ""},
+ {"AF_ECMA", Const, 0, ""},
+ {"AF_ECONET", Const, 0, ""},
+ {"AF_ENCAP", Const, 1, ""},
+ {"AF_FILE", Const, 0, ""},
+ {"AF_HYLINK", Const, 0, ""},
+ {"AF_IEEE80211", Const, 0, ""},
+ {"AF_IEEE802154", Const, 0, ""},
+ {"AF_IMPLINK", Const, 0, ""},
+ {"AF_INET", Const, 0, ""},
+ {"AF_INET6", Const, 0, ""},
+ {"AF_INET6_SDP", Const, 3, ""},
+ {"AF_INET_SDP", Const, 3, ""},
+ {"AF_IPX", Const, 0, ""},
+ {"AF_IRDA", Const, 0, ""},
+ {"AF_ISDN", Const, 0, ""},
+ {"AF_ISO", Const, 0, ""},
+ {"AF_IUCV", Const, 0, ""},
+ {"AF_KEY", Const, 0, ""},
+ {"AF_LAT", Const, 0, ""},
+ {"AF_LINK", Const, 0, ""},
+ {"AF_LLC", Const, 0, ""},
+ {"AF_LOCAL", Const, 0, ""},
+ {"AF_MAX", Const, 0, ""},
+ {"AF_MPLS", Const, 1, ""},
+ {"AF_NATM", Const, 0, ""},
+ {"AF_NDRV", Const, 0, ""},
+ {"AF_NETBEUI", Const, 0, ""},
+ {"AF_NETBIOS", Const, 0, ""},
+ {"AF_NETGRAPH", Const, 0, ""},
+ {"AF_NETLINK", Const, 0, ""},
+ {"AF_NETROM", Const, 0, ""},
+ {"AF_NS", Const, 0, ""},
+ {"AF_OROUTE", Const, 1, ""},
+ {"AF_OSI", Const, 0, ""},
+ {"AF_PACKET", Const, 0, ""},
+ {"AF_PHONET", Const, 0, ""},
+ {"AF_PPP", Const, 0, ""},
+ {"AF_PPPOX", Const, 0, ""},
+ {"AF_PUP", Const, 0, ""},
+ {"AF_RDS", Const, 0, ""},
+ {"AF_RESERVED_36", Const, 0, ""},
+ {"AF_ROSE", Const, 0, ""},
+ {"AF_ROUTE", Const, 0, ""},
+ {"AF_RXRPC", Const, 0, ""},
+ {"AF_SCLUSTER", Const, 0, ""},
+ {"AF_SECURITY", Const, 0, ""},
+ {"AF_SIP", Const, 0, ""},
+ {"AF_SLOW", Const, 0, ""},
+ {"AF_SNA", Const, 0, ""},
+ {"AF_SYSTEM", Const, 0, ""},
+ {"AF_TIPC", Const, 0, ""},
+ {"AF_UNIX", Const, 0, ""},
+ {"AF_UNSPEC", Const, 0, ""},
+ {"AF_UTUN", Const, 16, ""},
+ {"AF_VENDOR00", Const, 0, ""},
+ {"AF_VENDOR01", Const, 0, ""},
+ {"AF_VENDOR02", Const, 0, ""},
+ {"AF_VENDOR03", Const, 0, ""},
+ {"AF_VENDOR04", Const, 0, ""},
+ {"AF_VENDOR05", Const, 0, ""},
+ {"AF_VENDOR06", Const, 0, ""},
+ {"AF_VENDOR07", Const, 0, ""},
+ {"AF_VENDOR08", Const, 0, ""},
+ {"AF_VENDOR09", Const, 0, ""},
+ {"AF_VENDOR10", Const, 0, ""},
+ {"AF_VENDOR11", Const, 0, ""},
+ {"AF_VENDOR12", Const, 0, ""},
+ {"AF_VENDOR13", Const, 0, ""},
+ {"AF_VENDOR14", Const, 0, ""},
+ {"AF_VENDOR15", Const, 0, ""},
+ {"AF_VENDOR16", Const, 0, ""},
+ {"AF_VENDOR17", Const, 0, ""},
+ {"AF_VENDOR18", Const, 0, ""},
+ {"AF_VENDOR19", Const, 0, ""},
+ {"AF_VENDOR20", Const, 0, ""},
+ {"AF_VENDOR21", Const, 0, ""},
+ {"AF_VENDOR22", Const, 0, ""},
+ {"AF_VENDOR23", Const, 0, ""},
+ {"AF_VENDOR24", Const, 0, ""},
+ {"AF_VENDOR25", Const, 0, ""},
+ {"AF_VENDOR26", Const, 0, ""},
+ {"AF_VENDOR27", Const, 0, ""},
+ {"AF_VENDOR28", Const, 0, ""},
+ {"AF_VENDOR29", Const, 0, ""},
+ {"AF_VENDOR30", Const, 0, ""},
+ {"AF_VENDOR31", Const, 0, ""},
+ {"AF_VENDOR32", Const, 0, ""},
+ {"AF_VENDOR33", Const, 0, ""},
+ {"AF_VENDOR34", Const, 0, ""},
+ {"AF_VENDOR35", Const, 0, ""},
+ {"AF_VENDOR36", Const, 0, ""},
+ {"AF_VENDOR37", Const, 0, ""},
+ {"AF_VENDOR38", Const, 0, ""},
+ {"AF_VENDOR39", Const, 0, ""},
+ {"AF_VENDOR40", Const, 0, ""},
+ {"AF_VENDOR41", Const, 0, ""},
+ {"AF_VENDOR42", Const, 0, ""},
+ {"AF_VENDOR43", Const, 0, ""},
+ {"AF_VENDOR44", Const, 0, ""},
+ {"AF_VENDOR45", Const, 0, ""},
+ {"AF_VENDOR46", Const, 0, ""},
+ {"AF_VENDOR47", Const, 0, ""},
+ {"AF_WANPIPE", Const, 0, ""},
+ {"AF_X25", Const, 0, ""},
+ {"AI_CANONNAME", Const, 1, ""},
+ {"AI_NUMERICHOST", Const, 1, ""},
+ {"AI_PASSIVE", Const, 1, ""},
+ {"APPLICATION_ERROR", Const, 0, ""},
+ {"ARPHRD_ADAPT", Const, 0, ""},
+ {"ARPHRD_APPLETLK", Const, 0, ""},
+ {"ARPHRD_ARCNET", Const, 0, ""},
+ {"ARPHRD_ASH", Const, 0, ""},
+ {"ARPHRD_ATM", Const, 0, ""},
+ {"ARPHRD_AX25", Const, 0, ""},
+ {"ARPHRD_BIF", Const, 0, ""},
+ {"ARPHRD_CHAOS", Const, 0, ""},
+ {"ARPHRD_CISCO", Const, 0, ""},
+ {"ARPHRD_CSLIP", Const, 0, ""},
+ {"ARPHRD_CSLIP6", Const, 0, ""},
+ {"ARPHRD_DDCMP", Const, 0, ""},
+ {"ARPHRD_DLCI", Const, 0, ""},
+ {"ARPHRD_ECONET", Const, 0, ""},
+ {"ARPHRD_EETHER", Const, 0, ""},
+ {"ARPHRD_ETHER", Const, 0, ""},
+ {"ARPHRD_EUI64", Const, 0, ""},
+ {"ARPHRD_FCAL", Const, 0, ""},
+ {"ARPHRD_FCFABRIC", Const, 0, ""},
+ {"ARPHRD_FCPL", Const, 0, ""},
+ {"ARPHRD_FCPP", Const, 0, ""},
+ {"ARPHRD_FDDI", Const, 0, ""},
+ {"ARPHRD_FRAD", Const, 0, ""},
+ {"ARPHRD_FRELAY", Const, 1, ""},
+ {"ARPHRD_HDLC", Const, 0, ""},
+ {"ARPHRD_HIPPI", Const, 0, ""},
+ {"ARPHRD_HWX25", Const, 0, ""},
+ {"ARPHRD_IEEE1394", Const, 0, ""},
+ {"ARPHRD_IEEE802", Const, 0, ""},
+ {"ARPHRD_IEEE80211", Const, 0, ""},
+ {"ARPHRD_IEEE80211_PRISM", Const, 0, ""},
+ {"ARPHRD_IEEE80211_RADIOTAP", Const, 0, ""},
+ {"ARPHRD_IEEE802154", Const, 0, ""},
+ {"ARPHRD_IEEE802154_PHY", Const, 0, ""},
+ {"ARPHRD_IEEE802_TR", Const, 0, ""},
+ {"ARPHRD_INFINIBAND", Const, 0, ""},
+ {"ARPHRD_IPDDP", Const, 0, ""},
+ {"ARPHRD_IPGRE", Const, 0, ""},
+ {"ARPHRD_IRDA", Const, 0, ""},
+ {"ARPHRD_LAPB", Const, 0, ""},
+ {"ARPHRD_LOCALTLK", Const, 0, ""},
+ {"ARPHRD_LOOPBACK", Const, 0, ""},
+ {"ARPHRD_METRICOM", Const, 0, ""},
+ {"ARPHRD_NETROM", Const, 0, ""},
+ {"ARPHRD_NONE", Const, 0, ""},
+ {"ARPHRD_PIMREG", Const, 0, ""},
+ {"ARPHRD_PPP", Const, 0, ""},
+ {"ARPHRD_PRONET", Const, 0, ""},
+ {"ARPHRD_RAWHDLC", Const, 0, ""},
+ {"ARPHRD_ROSE", Const, 0, ""},
+ {"ARPHRD_RSRVD", Const, 0, ""},
+ {"ARPHRD_SIT", Const, 0, ""},
+ {"ARPHRD_SKIP", Const, 0, ""},
+ {"ARPHRD_SLIP", Const, 0, ""},
+ {"ARPHRD_SLIP6", Const, 0, ""},
+ {"ARPHRD_STRIP", Const, 1, ""},
+ {"ARPHRD_TUNNEL", Const, 0, ""},
+ {"ARPHRD_TUNNEL6", Const, 0, ""},
+ {"ARPHRD_VOID", Const, 0, ""},
+ {"ARPHRD_X25", Const, 0, ""},
+ {"AUTHTYPE_CLIENT", Const, 0, ""},
+ {"AUTHTYPE_SERVER", Const, 0, ""},
+ {"Accept", Func, 0, "func(fd int) (nfd int, sa Sockaddr, err error)"},
+ {"Accept4", Func, 1, "func(fd int, flags int) (nfd int, sa Sockaddr, err error)"},
+ {"AcceptEx", Func, 0, ""},
+ {"Access", Func, 0, "func(path string, mode uint32) (err error)"},
+ {"Acct", Func, 0, "func(path string) (err error)"},
+ {"AddrinfoW", Type, 1, ""},
+ {"AddrinfoW.Addr", Field, 1, ""},
+ {"AddrinfoW.Addrlen", Field, 1, ""},
+ {"AddrinfoW.Canonname", Field, 1, ""},
+ {"AddrinfoW.Family", Field, 1, ""},
+ {"AddrinfoW.Flags", Field, 1, ""},
+ {"AddrinfoW.Next", Field, 1, ""},
+ {"AddrinfoW.Protocol", Field, 1, ""},
+ {"AddrinfoW.Socktype", Field, 1, ""},
+ {"Adjtime", Func, 0, ""},
+ {"Adjtimex", Func, 0, "func(buf *Timex) (state int, err error)"},
+ {"AllThreadsSyscall", Func, 16, "func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err Errno)"},
+ {"AllThreadsSyscall6", Func, 16, "func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, err Errno)"},
+ {"AttachLsf", Func, 0, "func(fd int, i []SockFilter) error"},
+ {"B0", Const, 0, ""},
+ {"B1000000", Const, 0, ""},
+ {"B110", Const, 0, ""},
+ {"B115200", Const, 0, ""},
+ {"B1152000", Const, 0, ""},
+ {"B1200", Const, 0, ""},
+ {"B134", Const, 0, ""},
+ {"B14400", Const, 1, ""},
+ {"B150", Const, 0, ""},
+ {"B1500000", Const, 0, ""},
+ {"B1800", Const, 0, ""},
+ {"B19200", Const, 0, ""},
+ {"B200", Const, 0, ""},
+ {"B2000000", Const, 0, ""},
+ {"B230400", Const, 0, ""},
+ {"B2400", Const, 0, ""},
+ {"B2500000", Const, 0, ""},
+ {"B28800", Const, 1, ""},
+ {"B300", Const, 0, ""},
+ {"B3000000", Const, 0, ""},
+ {"B3500000", Const, 0, ""},
+ {"B38400", Const, 0, ""},
+ {"B4000000", Const, 0, ""},
+ {"B460800", Const, 0, ""},
+ {"B4800", Const, 0, ""},
+ {"B50", Const, 0, ""},
+ {"B500000", Const, 0, ""},
+ {"B57600", Const, 0, ""},
+ {"B576000", Const, 0, ""},
+ {"B600", Const, 0, ""},
+ {"B7200", Const, 1, ""},
+ {"B75", Const, 0, ""},
+ {"B76800", Const, 1, ""},
+ {"B921600", Const, 0, ""},
+ {"B9600", Const, 0, ""},
+ {"BASE_PROTOCOL", Const, 2, ""},
+ {"BIOCFEEDBACK", Const, 0, ""},
+ {"BIOCFLUSH", Const, 0, ""},
+ {"BIOCGBLEN", Const, 0, ""},
+ {"BIOCGDIRECTION", Const, 0, ""},
+ {"BIOCGDIRFILT", Const, 1, ""},
+ {"BIOCGDLT", Const, 0, ""},
+ {"BIOCGDLTLIST", Const, 0, ""},
+ {"BIOCGETBUFMODE", Const, 0, ""},
+ {"BIOCGETIF", Const, 0, ""},
+ {"BIOCGETZMAX", Const, 0, ""},
+ {"BIOCGFEEDBACK", Const, 1, ""},
+ {"BIOCGFILDROP", Const, 1, ""},
+ {"BIOCGHDRCMPLT", Const, 0, ""},
+ {"BIOCGRSIG", Const, 0, ""},
+ {"BIOCGRTIMEOUT", Const, 0, ""},
+ {"BIOCGSEESENT", Const, 0, ""},
+ {"BIOCGSTATS", Const, 0, ""},
+ {"BIOCGSTATSOLD", Const, 1, ""},
+ {"BIOCGTSTAMP", Const, 1, ""},
+ {"BIOCIMMEDIATE", Const, 0, ""},
+ {"BIOCLOCK", Const, 0, ""},
+ {"BIOCPROMISC", Const, 0, ""},
+ {"BIOCROTZBUF", Const, 0, ""},
+ {"BIOCSBLEN", Const, 0, ""},
+ {"BIOCSDIRECTION", Const, 0, ""},
+ {"BIOCSDIRFILT", Const, 1, ""},
+ {"BIOCSDLT", Const, 0, ""},
+ {"BIOCSETBUFMODE", Const, 0, ""},
+ {"BIOCSETF", Const, 0, ""},
+ {"BIOCSETFNR", Const, 0, ""},
+ {"BIOCSETIF", Const, 0, ""},
+ {"BIOCSETWF", Const, 0, ""},
+ {"BIOCSETZBUF", Const, 0, ""},
+ {"BIOCSFEEDBACK", Const, 1, ""},
+ {"BIOCSFILDROP", Const, 1, ""},
+ {"BIOCSHDRCMPLT", Const, 0, ""},
+ {"BIOCSRSIG", Const, 0, ""},
+ {"BIOCSRTIMEOUT", Const, 0, ""},
+ {"BIOCSSEESENT", Const, 0, ""},
+ {"BIOCSTCPF", Const, 1, ""},
+ {"BIOCSTSTAMP", Const, 1, ""},
+ {"BIOCSUDPF", Const, 1, ""},
+ {"BIOCVERSION", Const, 0, ""},
+ {"BPF_A", Const, 0, ""},
+ {"BPF_ABS", Const, 0, ""},
+ {"BPF_ADD", Const, 0, ""},
+ {"BPF_ALIGNMENT", Const, 0, ""},
+ {"BPF_ALIGNMENT32", Const, 1, ""},
+ {"BPF_ALU", Const, 0, ""},
+ {"BPF_AND", Const, 0, ""},
+ {"BPF_B", Const, 0, ""},
+ {"BPF_BUFMODE_BUFFER", Const, 0, ""},
+ {"BPF_BUFMODE_ZBUF", Const, 0, ""},
+ {"BPF_DFLTBUFSIZE", Const, 1, ""},
+ {"BPF_DIRECTION_IN", Const, 1, ""},
+ {"BPF_DIRECTION_OUT", Const, 1, ""},
+ {"BPF_DIV", Const, 0, ""},
+ {"BPF_H", Const, 0, ""},
+ {"BPF_IMM", Const, 0, ""},
+ {"BPF_IND", Const, 0, ""},
+ {"BPF_JA", Const, 0, ""},
+ {"BPF_JEQ", Const, 0, ""},
+ {"BPF_JGE", Const, 0, ""},
+ {"BPF_JGT", Const, 0, ""},
+ {"BPF_JMP", Const, 0, ""},
+ {"BPF_JSET", Const, 0, ""},
+ {"BPF_K", Const, 0, ""},
+ {"BPF_LD", Const, 0, ""},
+ {"BPF_LDX", Const, 0, ""},
+ {"BPF_LEN", Const, 0, ""},
+ {"BPF_LSH", Const, 0, ""},
+ {"BPF_MAJOR_VERSION", Const, 0, ""},
+ {"BPF_MAXBUFSIZE", Const, 0, ""},
+ {"BPF_MAXINSNS", Const, 0, ""},
+ {"BPF_MEM", Const, 0, ""},
+ {"BPF_MEMWORDS", Const, 0, ""},
+ {"BPF_MINBUFSIZE", Const, 0, ""},
+ {"BPF_MINOR_VERSION", Const, 0, ""},
+ {"BPF_MISC", Const, 0, ""},
+ {"BPF_MSH", Const, 0, ""},
+ {"BPF_MUL", Const, 0, ""},
+ {"BPF_NEG", Const, 0, ""},
+ {"BPF_OR", Const, 0, ""},
+ {"BPF_RELEASE", Const, 0, ""},
+ {"BPF_RET", Const, 0, ""},
+ {"BPF_RSH", Const, 0, ""},
+ {"BPF_ST", Const, 0, ""},
+ {"BPF_STX", Const, 0, ""},
+ {"BPF_SUB", Const, 0, ""},
+ {"BPF_TAX", Const, 0, ""},
+ {"BPF_TXA", Const, 0, ""},
+ {"BPF_T_BINTIME", Const, 1, ""},
+ {"BPF_T_BINTIME_FAST", Const, 1, ""},
+ {"BPF_T_BINTIME_MONOTONIC", Const, 1, ""},
+ {"BPF_T_BINTIME_MONOTONIC_FAST", Const, 1, ""},
+ {"BPF_T_FAST", Const, 1, ""},
+ {"BPF_T_FLAG_MASK", Const, 1, ""},
+ {"BPF_T_FORMAT_MASK", Const, 1, ""},
+ {"BPF_T_MICROTIME", Const, 1, ""},
+ {"BPF_T_MICROTIME_FAST", Const, 1, ""},
+ {"BPF_T_MICROTIME_MONOTONIC", Const, 1, ""},
+ {"BPF_T_MICROTIME_MONOTONIC_FAST", Const, 1, ""},
+ {"BPF_T_MONOTONIC", Const, 1, ""},
+ {"BPF_T_MONOTONIC_FAST", Const, 1, ""},
+ {"BPF_T_NANOTIME", Const, 1, ""},
+ {"BPF_T_NANOTIME_FAST", Const, 1, ""},
+ {"BPF_T_NANOTIME_MONOTONIC", Const, 1, ""},
+ {"BPF_T_NANOTIME_MONOTONIC_FAST", Const, 1, ""},
+ {"BPF_T_NONE", Const, 1, ""},
+ {"BPF_T_NORMAL", Const, 1, ""},
+ {"BPF_W", Const, 0, ""},
+ {"BPF_X", Const, 0, ""},
+ {"BRKINT", Const, 0, ""},
+ {"Bind", Func, 0, "func(fd int, sa Sockaddr) (err error)"},
+ {"BindToDevice", Func, 0, "func(fd int, device string) (err error)"},
+ {"BpfBuflen", Func, 0, ""},
+ {"BpfDatalink", Func, 0, ""},
+ {"BpfHdr", Type, 0, ""},
+ {"BpfHdr.Caplen", Field, 0, ""},
+ {"BpfHdr.Datalen", Field, 0, ""},
+ {"BpfHdr.Hdrlen", Field, 0, ""},
+ {"BpfHdr.Pad_cgo_0", Field, 0, ""},
+ {"BpfHdr.Tstamp", Field, 0, ""},
+ {"BpfHeadercmpl", Func, 0, ""},
+ {"BpfInsn", Type, 0, ""},
+ {"BpfInsn.Code", Field, 0, ""},
+ {"BpfInsn.Jf", Field, 0, ""},
+ {"BpfInsn.Jt", Field, 0, ""},
+ {"BpfInsn.K", Field, 0, ""},
+ {"BpfInterface", Func, 0, ""},
+ {"BpfJump", Func, 0, ""},
+ {"BpfProgram", Type, 0, ""},
+ {"BpfProgram.Insns", Field, 0, ""},
+ {"BpfProgram.Len", Field, 0, ""},
+ {"BpfProgram.Pad_cgo_0", Field, 0, ""},
+ {"BpfStat", Type, 0, ""},
+ {"BpfStat.Capt", Field, 2, ""},
+ {"BpfStat.Drop", Field, 0, ""},
+ {"BpfStat.Padding", Field, 2, ""},
+ {"BpfStat.Recv", Field, 0, ""},
+ {"BpfStats", Func, 0, ""},
+ {"BpfStmt", Func, 0, ""},
+ {"BpfTimeout", Func, 0, ""},
+ {"BpfTimeval", Type, 2, ""},
+ {"BpfTimeval.Sec", Field, 2, ""},
+ {"BpfTimeval.Usec", Field, 2, ""},
+ {"BpfVersion", Type, 0, ""},
+ {"BpfVersion.Major", Field, 0, ""},
+ {"BpfVersion.Minor", Field, 0, ""},
+ {"BpfZbuf", Type, 0, ""},
+ {"BpfZbuf.Bufa", Field, 0, ""},
+ {"BpfZbuf.Bufb", Field, 0, ""},
+ {"BpfZbuf.Buflen", Field, 0, ""},
+ {"BpfZbufHeader", Type, 0, ""},
+ {"BpfZbufHeader.Kernel_gen", Field, 0, ""},
+ {"BpfZbufHeader.Kernel_len", Field, 0, ""},
+ {"BpfZbufHeader.User_gen", Field, 0, ""},
+ {"BpfZbufHeader.X_bzh_pad", Field, 0, ""},
+ {"ByHandleFileInformation", Type, 0, ""},
+ {"ByHandleFileInformation.CreationTime", Field, 0, ""},
+ {"ByHandleFileInformation.FileAttributes", Field, 0, ""},
+ {"ByHandleFileInformation.FileIndexHigh", Field, 0, ""},
+ {"ByHandleFileInformation.FileIndexLow", Field, 0, ""},
+ {"ByHandleFileInformation.FileSizeHigh", Field, 0, ""},
+ {"ByHandleFileInformation.FileSizeLow", Field, 0, ""},
+ {"ByHandleFileInformation.LastAccessTime", Field, 0, ""},
+ {"ByHandleFileInformation.LastWriteTime", Field, 0, ""},
+ {"ByHandleFileInformation.NumberOfLinks", Field, 0, ""},
+ {"ByHandleFileInformation.VolumeSerialNumber", Field, 0, ""},
+ {"BytePtrFromString", Func, 1, "func(s string) (*byte, error)"},
+ {"ByteSliceFromString", Func, 1, "func(s string) ([]byte, error)"},
+ {"CCR0_FLUSH", Const, 1, ""},
+ {"CERT_CHAIN_POLICY_AUTHENTICODE", Const, 0, ""},
+ {"CERT_CHAIN_POLICY_AUTHENTICODE_TS", Const, 0, ""},
+ {"CERT_CHAIN_POLICY_BASE", Const, 0, ""},
+ {"CERT_CHAIN_POLICY_BASIC_CONSTRAINTS", Const, 0, ""},
+ {"CERT_CHAIN_POLICY_EV", Const, 0, ""},
+ {"CERT_CHAIN_POLICY_MICROSOFT_ROOT", Const, 0, ""},
+ {"CERT_CHAIN_POLICY_NT_AUTH", Const, 0, ""},
+ {"CERT_CHAIN_POLICY_SSL", Const, 0, ""},
+ {"CERT_E_CN_NO_MATCH", Const, 0, ""},
+ {"CERT_E_EXPIRED", Const, 0, ""},
+ {"CERT_E_PURPOSE", Const, 0, ""},
+ {"CERT_E_ROLE", Const, 0, ""},
+ {"CERT_E_UNTRUSTEDROOT", Const, 0, ""},
+ {"CERT_STORE_ADD_ALWAYS", Const, 0, ""},
+ {"CERT_STORE_DEFER_CLOSE_UNTIL_LAST_FREE_FLAG", Const, 0, ""},
+ {"CERT_STORE_PROV_MEMORY", Const, 0, ""},
+ {"CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT", Const, 0, ""},
+ {"CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT", Const, 0, ""},
+ {"CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT", Const, 0, ""},
+ {"CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT", Const, 0, ""},
+ {"CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT", Const, 0, ""},
+ {"CERT_TRUST_INVALID_BASIC_CONSTRAINTS", Const, 0, ""},
+ {"CERT_TRUST_INVALID_EXTENSION", Const, 0, ""},
+ {"CERT_TRUST_INVALID_NAME_CONSTRAINTS", Const, 0, ""},
+ {"CERT_TRUST_INVALID_POLICY_CONSTRAINTS", Const, 0, ""},
+ {"CERT_TRUST_IS_CYCLIC", Const, 0, ""},
+ {"CERT_TRUST_IS_EXPLICIT_DISTRUST", Const, 0, ""},
+ {"CERT_TRUST_IS_NOT_SIGNATURE_VALID", Const, 0, ""},
+ {"CERT_TRUST_IS_NOT_TIME_VALID", Const, 0, ""},
+ {"CERT_TRUST_IS_NOT_VALID_FOR_USAGE", Const, 0, ""},
+ {"CERT_TRUST_IS_OFFLINE_REVOCATION", Const, 0, ""},
+ {"CERT_TRUST_IS_REVOKED", Const, 0, ""},
+ {"CERT_TRUST_IS_UNTRUSTED_ROOT", Const, 0, ""},
+ {"CERT_TRUST_NO_ERROR", Const, 0, ""},
+ {"CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY", Const, 0, ""},
+ {"CERT_TRUST_REVOCATION_STATUS_UNKNOWN", Const, 0, ""},
+ {"CFLUSH", Const, 1, ""},
+ {"CLOCAL", Const, 0, ""},
+ {"CLONE_CHILD_CLEARTID", Const, 2, ""},
+ {"CLONE_CHILD_SETTID", Const, 2, ""},
+ {"CLONE_CLEAR_SIGHAND", Const, 20, ""},
+ {"CLONE_CSIGNAL", Const, 3, ""},
+ {"CLONE_DETACHED", Const, 2, ""},
+ {"CLONE_FILES", Const, 2, ""},
+ {"CLONE_FS", Const, 2, ""},
+ {"CLONE_INTO_CGROUP", Const, 20, ""},
+ {"CLONE_IO", Const, 2, ""},
+ {"CLONE_NEWCGROUP", Const, 20, ""},
+ {"CLONE_NEWIPC", Const, 2, ""},
+ {"CLONE_NEWNET", Const, 2, ""},
+ {"CLONE_NEWNS", Const, 2, ""},
+ {"CLONE_NEWPID", Const, 2, ""},
+ {"CLONE_NEWTIME", Const, 20, ""},
+ {"CLONE_NEWUSER", Const, 2, ""},
+ {"CLONE_NEWUTS", Const, 2, ""},
+ {"CLONE_PARENT", Const, 2, ""},
+ {"CLONE_PARENT_SETTID", Const, 2, ""},
+ {"CLONE_PID", Const, 3, ""},
+ {"CLONE_PIDFD", Const, 20, ""},
+ {"CLONE_PTRACE", Const, 2, ""},
+ {"CLONE_SETTLS", Const, 2, ""},
+ {"CLONE_SIGHAND", Const, 2, ""},
+ {"CLONE_SYSVSEM", Const, 2, ""},
+ {"CLONE_THREAD", Const, 2, ""},
+ {"CLONE_UNTRACED", Const, 2, ""},
+ {"CLONE_VFORK", Const, 2, ""},
+ {"CLONE_VM", Const, 2, ""},
+ {"CPUID_CFLUSH", Const, 1, ""},
+ {"CREAD", Const, 0, ""},
+ {"CREATE_ALWAYS", Const, 0, ""},
+ {"CREATE_NEW", Const, 0, ""},
+ {"CREATE_NEW_PROCESS_GROUP", Const, 1, ""},
+ {"CREATE_UNICODE_ENVIRONMENT", Const, 0, ""},
+ {"CRYPT_DEFAULT_CONTAINER_OPTIONAL", Const, 0, ""},
+ {"CRYPT_DELETEKEYSET", Const, 0, ""},
+ {"CRYPT_MACHINE_KEYSET", Const, 0, ""},
+ {"CRYPT_NEWKEYSET", Const, 0, ""},
+ {"CRYPT_SILENT", Const, 0, ""},
+ {"CRYPT_VERIFYCONTEXT", Const, 0, ""},
+ {"CS5", Const, 0, ""},
+ {"CS6", Const, 0, ""},
+ {"CS7", Const, 0, ""},
+ {"CS8", Const, 0, ""},
+ {"CSIZE", Const, 0, ""},
+ {"CSTART", Const, 1, ""},
+ {"CSTATUS", Const, 1, ""},
+ {"CSTOP", Const, 1, ""},
+ {"CSTOPB", Const, 0, ""},
+ {"CSUSP", Const, 1, ""},
+ {"CTL_MAXNAME", Const, 0, ""},
+ {"CTL_NET", Const, 0, ""},
+ {"CTL_QUERY", Const, 1, ""},
+ {"CTRL_BREAK_EVENT", Const, 1, ""},
+ {"CTRL_CLOSE_EVENT", Const, 14, ""},
+ {"CTRL_C_EVENT", Const, 1, ""},
+ {"CTRL_LOGOFF_EVENT", Const, 14, ""},
+ {"CTRL_SHUTDOWN_EVENT", Const, 14, ""},
+ {"CancelIo", Func, 0, ""},
+ {"CancelIoEx", Func, 1, ""},
+ {"CertAddCertificateContextToStore", Func, 0, ""},
+ {"CertChainContext", Type, 0, ""},
+ {"CertChainContext.ChainCount", Field, 0, ""},
+ {"CertChainContext.Chains", Field, 0, ""},
+ {"CertChainContext.HasRevocationFreshnessTime", Field, 0, ""},
+ {"CertChainContext.LowerQualityChainCount", Field, 0, ""},
+ {"CertChainContext.LowerQualityChains", Field, 0, ""},
+ {"CertChainContext.RevocationFreshnessTime", Field, 0, ""},
+ {"CertChainContext.Size", Field, 0, ""},
+ {"CertChainContext.TrustStatus", Field, 0, ""},
+ {"CertChainElement", Type, 0, ""},
+ {"CertChainElement.ApplicationUsage", Field, 0, ""},
+ {"CertChainElement.CertContext", Field, 0, ""},
+ {"CertChainElement.ExtendedErrorInfo", Field, 0, ""},
+ {"CertChainElement.IssuanceUsage", Field, 0, ""},
+ {"CertChainElement.RevocationInfo", Field, 0, ""},
+ {"CertChainElement.Size", Field, 0, ""},
+ {"CertChainElement.TrustStatus", Field, 0, ""},
+ {"CertChainPara", Type, 0, ""},
+ {"CertChainPara.CacheResync", Field, 0, ""},
+ {"CertChainPara.CheckRevocationFreshnessTime", Field, 0, ""},
+ {"CertChainPara.RequestedUsage", Field, 0, ""},
+ {"CertChainPara.RequstedIssuancePolicy", Field, 0, ""},
+ {"CertChainPara.RevocationFreshnessTime", Field, 0, ""},
+ {"CertChainPara.Size", Field, 0, ""},
+ {"CertChainPara.URLRetrievalTimeout", Field, 0, ""},
+ {"CertChainPolicyPara", Type, 0, ""},
+ {"CertChainPolicyPara.ExtraPolicyPara", Field, 0, ""},
+ {"CertChainPolicyPara.Flags", Field, 0, ""},
+ {"CertChainPolicyPara.Size", Field, 0, ""},
+ {"CertChainPolicyStatus", Type, 0, ""},
+ {"CertChainPolicyStatus.ChainIndex", Field, 0, ""},
+ {"CertChainPolicyStatus.ElementIndex", Field, 0, ""},
+ {"CertChainPolicyStatus.Error", Field, 0, ""},
+ {"CertChainPolicyStatus.ExtraPolicyStatus", Field, 0, ""},
+ {"CertChainPolicyStatus.Size", Field, 0, ""},
+ {"CertCloseStore", Func, 0, ""},
+ {"CertContext", Type, 0, ""},
+ {"CertContext.CertInfo", Field, 0, ""},
+ {"CertContext.EncodedCert", Field, 0, ""},
+ {"CertContext.EncodingType", Field, 0, ""},
+ {"CertContext.Length", Field, 0, ""},
+ {"CertContext.Store", Field, 0, ""},
+ {"CertCreateCertificateContext", Func, 0, ""},
+ {"CertEnhKeyUsage", Type, 0, ""},
+ {"CertEnhKeyUsage.Length", Field, 0, ""},
+ {"CertEnhKeyUsage.UsageIdentifiers", Field, 0, ""},
+ {"CertEnumCertificatesInStore", Func, 0, ""},
+ {"CertFreeCertificateChain", Func, 0, ""},
+ {"CertFreeCertificateContext", Func, 0, ""},
+ {"CertGetCertificateChain", Func, 0, ""},
+ {"CertInfo", Type, 11, ""},
+ {"CertOpenStore", Func, 0, ""},
+ {"CertOpenSystemStore", Func, 0, ""},
+ {"CertRevocationCrlInfo", Type, 11, ""},
+ {"CertRevocationInfo", Type, 0, ""},
+ {"CertRevocationInfo.CrlInfo", Field, 0, ""},
+ {"CertRevocationInfo.FreshnessTime", Field, 0, ""},
+ {"CertRevocationInfo.HasFreshnessTime", Field, 0, ""},
+ {"CertRevocationInfo.OidSpecificInfo", Field, 0, ""},
+ {"CertRevocationInfo.RevocationOid", Field, 0, ""},
+ {"CertRevocationInfo.RevocationResult", Field, 0, ""},
+ {"CertRevocationInfo.Size", Field, 0, ""},
+ {"CertSimpleChain", Type, 0, ""},
+ {"CertSimpleChain.Elements", Field, 0, ""},
+ {"CertSimpleChain.HasRevocationFreshnessTime", Field, 0, ""},
+ {"CertSimpleChain.NumElements", Field, 0, ""},
+ {"CertSimpleChain.RevocationFreshnessTime", Field, 0, ""},
+ {"CertSimpleChain.Size", Field, 0, ""},
+ {"CertSimpleChain.TrustListInfo", Field, 0, ""},
+ {"CertSimpleChain.TrustStatus", Field, 0, ""},
+ {"CertTrustListInfo", Type, 11, ""},
+ {"CertTrustStatus", Type, 0, ""},
+ {"CertTrustStatus.ErrorStatus", Field, 0, ""},
+ {"CertTrustStatus.InfoStatus", Field, 0, ""},
+ {"CertUsageMatch", Type, 0, ""},
+ {"CertUsageMatch.Type", Field, 0, ""},
+ {"CertUsageMatch.Usage", Field, 0, ""},
+ {"CertVerifyCertificateChainPolicy", Func, 0, ""},
+ {"Chdir", Func, 0, "func(path string) (err error)"},
+ {"CheckBpfVersion", Func, 0, ""},
+ {"Chflags", Func, 0, ""},
+ {"Chmod", Func, 0, "func(path string, mode uint32) (err error)"},
+ {"Chown", Func, 0, "func(path string, uid int, gid int) (err error)"},
+ {"Chroot", Func, 0, "func(path string) (err error)"},
+ {"Clearenv", Func, 0, "func()"},
+ {"Close", Func, 0, "func(fd int) (err error)"},
+ {"CloseHandle", Func, 0, ""},
+ {"CloseOnExec", Func, 0, "func(fd int)"},
+ {"Closesocket", Func, 0, ""},
+ {"CmsgLen", Func, 0, "func(datalen int) int"},
+ {"CmsgSpace", Func, 0, "func(datalen int) int"},
+ {"Cmsghdr", Type, 0, ""},
+ {"Cmsghdr.Len", Field, 0, ""},
+ {"Cmsghdr.Level", Field, 0, ""},
+ {"Cmsghdr.Type", Field, 0, ""},
+ {"Cmsghdr.X__cmsg_data", Field, 0, ""},
+ {"CommandLineToArgv", Func, 0, ""},
+ {"ComputerName", Func, 0, ""},
+ {"Conn", Type, 9, ""},
+ {"Connect", Func, 0, "func(fd int, sa Sockaddr) (err error)"},
+ {"ConnectEx", Func, 1, ""},
+ {"ConvertSidToStringSid", Func, 0, ""},
+ {"ConvertStringSidToSid", Func, 0, ""},
+ {"CopySid", Func, 0, ""},
+ {"Creat", Func, 0, "func(path string, mode uint32) (fd int, err error)"},
+ {"CreateDirectory", Func, 0, ""},
+ {"CreateFile", Func, 0, ""},
+ {"CreateFileMapping", Func, 0, ""},
+ {"CreateHardLink", Func, 4, ""},
+ {"CreateIoCompletionPort", Func, 0, ""},
+ {"CreatePipe", Func, 0, ""},
+ {"CreateProcess", Func, 0, ""},
+ {"CreateProcessAsUser", Func, 10, ""},
+ {"CreateSymbolicLink", Func, 4, ""},
+ {"CreateToolhelp32Snapshot", Func, 4, ""},
+ {"Credential", Type, 0, ""},
+ {"Credential.Gid", Field, 0, ""},
+ {"Credential.Groups", Field, 0, ""},
+ {"Credential.NoSetGroups", Field, 9, ""},
+ {"Credential.Uid", Field, 0, ""},
+ {"CryptAcquireContext", Func, 0, ""},
+ {"CryptGenRandom", Func, 0, ""},
+ {"CryptReleaseContext", Func, 0, ""},
+ {"DIOCBSFLUSH", Const, 1, ""},
+ {"DIOCOSFPFLUSH", Const, 1, ""},
+ {"DLL", Type, 0, ""},
+ {"DLL.Handle", Field, 0, ""},
+ {"DLL.Name", Field, 0, ""},
+ {"DLLError", Type, 0, ""},
+ {"DLLError.Err", Field, 0, ""},
+ {"DLLError.Msg", Field, 0, ""},
+ {"DLLError.ObjName", Field, 0, ""},
+ {"DLT_A429", Const, 0, ""},
+ {"DLT_A653_ICM", Const, 0, ""},
+ {"DLT_AIRONET_HEADER", Const, 0, ""},
+ {"DLT_AOS", Const, 1, ""},
+ {"DLT_APPLE_IP_OVER_IEEE1394", Const, 0, ""},
+ {"DLT_ARCNET", Const, 0, ""},
+ {"DLT_ARCNET_LINUX", Const, 0, ""},
+ {"DLT_ATM_CLIP", Const, 0, ""},
+ {"DLT_ATM_RFC1483", Const, 0, ""},
+ {"DLT_AURORA", Const, 0, ""},
+ {"DLT_AX25", Const, 0, ""},
+ {"DLT_AX25_KISS", Const, 0, ""},
+ {"DLT_BACNET_MS_TP", Const, 0, ""},
+ {"DLT_BLUETOOTH_HCI_H4", Const, 0, ""},
+ {"DLT_BLUETOOTH_HCI_H4_WITH_PHDR", Const, 0, ""},
+ {"DLT_CAN20B", Const, 0, ""},
+ {"DLT_CAN_SOCKETCAN", Const, 1, ""},
+ {"DLT_CHAOS", Const, 0, ""},
+ {"DLT_CHDLC", Const, 0, ""},
+ {"DLT_CISCO_IOS", Const, 0, ""},
+ {"DLT_C_HDLC", Const, 0, ""},
+ {"DLT_C_HDLC_WITH_DIR", Const, 0, ""},
+ {"DLT_DBUS", Const, 1, ""},
+ {"DLT_DECT", Const, 1, ""},
+ {"DLT_DOCSIS", Const, 0, ""},
+ {"DLT_DVB_CI", Const, 1, ""},
+ {"DLT_ECONET", Const, 0, ""},
+ {"DLT_EN10MB", Const, 0, ""},
+ {"DLT_EN3MB", Const, 0, ""},
+ {"DLT_ENC", Const, 0, ""},
+ {"DLT_ERF", Const, 0, ""},
+ {"DLT_ERF_ETH", Const, 0, ""},
+ {"DLT_ERF_POS", Const, 0, ""},
+ {"DLT_FC_2", Const, 1, ""},
+ {"DLT_FC_2_WITH_FRAME_DELIMS", Const, 1, ""},
+ {"DLT_FDDI", Const, 0, ""},
+ {"DLT_FLEXRAY", Const, 0, ""},
+ {"DLT_FRELAY", Const, 0, ""},
+ {"DLT_FRELAY_WITH_DIR", Const, 0, ""},
+ {"DLT_GCOM_SERIAL", Const, 0, ""},
+ {"DLT_GCOM_T1E1", Const, 0, ""},
+ {"DLT_GPF_F", Const, 0, ""},
+ {"DLT_GPF_T", Const, 0, ""},
+ {"DLT_GPRS_LLC", Const, 0, ""},
+ {"DLT_GSMTAP_ABIS", Const, 1, ""},
+ {"DLT_GSMTAP_UM", Const, 1, ""},
+ {"DLT_HDLC", Const, 1, ""},
+ {"DLT_HHDLC", Const, 0, ""},
+ {"DLT_HIPPI", Const, 1, ""},
+ {"DLT_IBM_SN", Const, 0, ""},
+ {"DLT_IBM_SP", Const, 0, ""},
+ {"DLT_IEEE802", Const, 0, ""},
+ {"DLT_IEEE802_11", Const, 0, ""},
+ {"DLT_IEEE802_11_RADIO", Const, 0, ""},
+ {"DLT_IEEE802_11_RADIO_AVS", Const, 0, ""},
+ {"DLT_IEEE802_15_4", Const, 0, ""},
+ {"DLT_IEEE802_15_4_LINUX", Const, 0, ""},
+ {"DLT_IEEE802_15_4_NOFCS", Const, 1, ""},
+ {"DLT_IEEE802_15_4_NONASK_PHY", Const, 0, ""},
+ {"DLT_IEEE802_16_MAC_CPS", Const, 0, ""},
+ {"DLT_IEEE802_16_MAC_CPS_RADIO", Const, 0, ""},
+ {"DLT_IPFILTER", Const, 0, ""},
+ {"DLT_IPMB", Const, 0, ""},
+ {"DLT_IPMB_LINUX", Const, 0, ""},
+ {"DLT_IPNET", Const, 1, ""},
+ {"DLT_IPOIB", Const, 1, ""},
+ {"DLT_IPV4", Const, 1, ""},
+ {"DLT_IPV6", Const, 1, ""},
+ {"DLT_IP_OVER_FC", Const, 0, ""},
+ {"DLT_JUNIPER_ATM1", Const, 0, ""},
+ {"DLT_JUNIPER_ATM2", Const, 0, ""},
+ {"DLT_JUNIPER_ATM_CEMIC", Const, 1, ""},
+ {"DLT_JUNIPER_CHDLC", Const, 0, ""},
+ {"DLT_JUNIPER_ES", Const, 0, ""},
+ {"DLT_JUNIPER_ETHER", Const, 0, ""},
+ {"DLT_JUNIPER_FIBRECHANNEL", Const, 1, ""},
+ {"DLT_JUNIPER_FRELAY", Const, 0, ""},
+ {"DLT_JUNIPER_GGSN", Const, 0, ""},
+ {"DLT_JUNIPER_ISM", Const, 0, ""},
+ {"DLT_JUNIPER_MFR", Const, 0, ""},
+ {"DLT_JUNIPER_MLFR", Const, 0, ""},
+ {"DLT_JUNIPER_MLPPP", Const, 0, ""},
+ {"DLT_JUNIPER_MONITOR", Const, 0, ""},
+ {"DLT_JUNIPER_PIC_PEER", Const, 0, ""},
+ {"DLT_JUNIPER_PPP", Const, 0, ""},
+ {"DLT_JUNIPER_PPPOE", Const, 0, ""},
+ {"DLT_JUNIPER_PPPOE_ATM", Const, 0, ""},
+ {"DLT_JUNIPER_SERVICES", Const, 0, ""},
+ {"DLT_JUNIPER_SRX_E2E", Const, 1, ""},
+ {"DLT_JUNIPER_ST", Const, 0, ""},
+ {"DLT_JUNIPER_VP", Const, 0, ""},
+ {"DLT_JUNIPER_VS", Const, 1, ""},
+ {"DLT_LAPB_WITH_DIR", Const, 0, ""},
+ {"DLT_LAPD", Const, 0, ""},
+ {"DLT_LIN", Const, 0, ""},
+ {"DLT_LINUX_EVDEV", Const, 1, ""},
+ {"DLT_LINUX_IRDA", Const, 0, ""},
+ {"DLT_LINUX_LAPD", Const, 0, ""},
+ {"DLT_LINUX_PPP_WITHDIRECTION", Const, 0, ""},
+ {"DLT_LINUX_SLL", Const, 0, ""},
+ {"DLT_LOOP", Const, 0, ""},
+ {"DLT_LTALK", Const, 0, ""},
+ {"DLT_MATCHING_MAX", Const, 1, ""},
+ {"DLT_MATCHING_MIN", Const, 1, ""},
+ {"DLT_MFR", Const, 0, ""},
+ {"DLT_MOST", Const, 0, ""},
+ {"DLT_MPEG_2_TS", Const, 1, ""},
+ {"DLT_MPLS", Const, 1, ""},
+ {"DLT_MTP2", Const, 0, ""},
+ {"DLT_MTP2_WITH_PHDR", Const, 0, ""},
+ {"DLT_MTP3", Const, 0, ""},
+ {"DLT_MUX27010", Const, 1, ""},
+ {"DLT_NETANALYZER", Const, 1, ""},
+ {"DLT_NETANALYZER_TRANSPARENT", Const, 1, ""},
+ {"DLT_NFC_LLCP", Const, 1, ""},
+ {"DLT_NFLOG", Const, 1, ""},
+ {"DLT_NG40", Const, 1, ""},
+ {"DLT_NULL", Const, 0, ""},
+ {"DLT_PCI_EXP", Const, 0, ""},
+ {"DLT_PFLOG", Const, 0, ""},
+ {"DLT_PFSYNC", Const, 0, ""},
+ {"DLT_PPI", Const, 0, ""},
+ {"DLT_PPP", Const, 0, ""},
+ {"DLT_PPP_BSDOS", Const, 0, ""},
+ {"DLT_PPP_ETHER", Const, 0, ""},
+ {"DLT_PPP_PPPD", Const, 0, ""},
+ {"DLT_PPP_SERIAL", Const, 0, ""},
+ {"DLT_PPP_WITH_DIR", Const, 0, ""},
+ {"DLT_PPP_WITH_DIRECTION", Const, 0, ""},
+ {"DLT_PRISM_HEADER", Const, 0, ""},
+ {"DLT_PRONET", Const, 0, ""},
+ {"DLT_RAIF1", Const, 0, ""},
+ {"DLT_RAW", Const, 0, ""},
+ {"DLT_RAWAF_MASK", Const, 1, ""},
+ {"DLT_RIO", Const, 0, ""},
+ {"DLT_SCCP", Const, 0, ""},
+ {"DLT_SITA", Const, 0, ""},
+ {"DLT_SLIP", Const, 0, ""},
+ {"DLT_SLIP_BSDOS", Const, 0, ""},
+ {"DLT_STANAG_5066_D_PDU", Const, 1, ""},
+ {"DLT_SUNATM", Const, 0, ""},
+ {"DLT_SYMANTEC_FIREWALL", Const, 0, ""},
+ {"DLT_TZSP", Const, 0, ""},
+ {"DLT_USB", Const, 0, ""},
+ {"DLT_USB_LINUX", Const, 0, ""},
+ {"DLT_USB_LINUX_MMAPPED", Const, 1, ""},
+ {"DLT_USER0", Const, 0, ""},
+ {"DLT_USER1", Const, 0, ""},
+ {"DLT_USER10", Const, 0, ""},
+ {"DLT_USER11", Const, 0, ""},
+ {"DLT_USER12", Const, 0, ""},
+ {"DLT_USER13", Const, 0, ""},
+ {"DLT_USER14", Const, 0, ""},
+ {"DLT_USER15", Const, 0, ""},
+ {"DLT_USER2", Const, 0, ""},
+ {"DLT_USER3", Const, 0, ""},
+ {"DLT_USER4", Const, 0, ""},
+ {"DLT_USER5", Const, 0, ""},
+ {"DLT_USER6", Const, 0, ""},
+ {"DLT_USER7", Const, 0, ""},
+ {"DLT_USER8", Const, 0, ""},
+ {"DLT_USER9", Const, 0, ""},
+ {"DLT_WIHART", Const, 1, ""},
+ {"DLT_X2E_SERIAL", Const, 0, ""},
+ {"DLT_X2E_XORAYA", Const, 0, ""},
+ {"DNSMXData", Type, 0, ""},
+ {"DNSMXData.NameExchange", Field, 0, ""},
+ {"DNSMXData.Pad", Field, 0, ""},
+ {"DNSMXData.Preference", Field, 0, ""},
+ {"DNSPTRData", Type, 0, ""},
+ {"DNSPTRData.Host", Field, 0, ""},
+ {"DNSRecord", Type, 0, ""},
+ {"DNSRecord.Data", Field, 0, ""},
+ {"DNSRecord.Dw", Field, 0, ""},
+ {"DNSRecord.Length", Field, 0, ""},
+ {"DNSRecord.Name", Field, 0, ""},
+ {"DNSRecord.Next", Field, 0, ""},
+ {"DNSRecord.Reserved", Field, 0, ""},
+ {"DNSRecord.Ttl", Field, 0, ""},
+ {"DNSRecord.Type", Field, 0, ""},
+ {"DNSSRVData", Type, 0, ""},
+ {"DNSSRVData.Pad", Field, 0, ""},
+ {"DNSSRVData.Port", Field, 0, ""},
+ {"DNSSRVData.Priority", Field, 0, ""},
+ {"DNSSRVData.Target", Field, 0, ""},
+ {"DNSSRVData.Weight", Field, 0, ""},
+ {"DNSTXTData", Type, 0, ""},
+ {"DNSTXTData.StringArray", Field, 0, ""},
+ {"DNSTXTData.StringCount", Field, 0, ""},
+ {"DNS_INFO_NO_RECORDS", Const, 4, ""},
+ {"DNS_TYPE_A", Const, 0, ""},
+ {"DNS_TYPE_A6", Const, 0, ""},
+ {"DNS_TYPE_AAAA", Const, 0, ""},
+ {"DNS_TYPE_ADDRS", Const, 0, ""},
+ {"DNS_TYPE_AFSDB", Const, 0, ""},
+ {"DNS_TYPE_ALL", Const, 0, ""},
+ {"DNS_TYPE_ANY", Const, 0, ""},
+ {"DNS_TYPE_ATMA", Const, 0, ""},
+ {"DNS_TYPE_AXFR", Const, 0, ""},
+ {"DNS_TYPE_CERT", Const, 0, ""},
+ {"DNS_TYPE_CNAME", Const, 0, ""},
+ {"DNS_TYPE_DHCID", Const, 0, ""},
+ {"DNS_TYPE_DNAME", Const, 0, ""},
+ {"DNS_TYPE_DNSKEY", Const, 0, ""},
+ {"DNS_TYPE_DS", Const, 0, ""},
+ {"DNS_TYPE_EID", Const, 0, ""},
+ {"DNS_TYPE_GID", Const, 0, ""},
+ {"DNS_TYPE_GPOS", Const, 0, ""},
+ {"DNS_TYPE_HINFO", Const, 0, ""},
+ {"DNS_TYPE_ISDN", Const, 0, ""},
+ {"DNS_TYPE_IXFR", Const, 0, ""},
+ {"DNS_TYPE_KEY", Const, 0, ""},
+ {"DNS_TYPE_KX", Const, 0, ""},
+ {"DNS_TYPE_LOC", Const, 0, ""},
+ {"DNS_TYPE_MAILA", Const, 0, ""},
+ {"DNS_TYPE_MAILB", Const, 0, ""},
+ {"DNS_TYPE_MB", Const, 0, ""},
+ {"DNS_TYPE_MD", Const, 0, ""},
+ {"DNS_TYPE_MF", Const, 0, ""},
+ {"DNS_TYPE_MG", Const, 0, ""},
+ {"DNS_TYPE_MINFO", Const, 0, ""},
+ {"DNS_TYPE_MR", Const, 0, ""},
+ {"DNS_TYPE_MX", Const, 0, ""},
+ {"DNS_TYPE_NAPTR", Const, 0, ""},
+ {"DNS_TYPE_NBSTAT", Const, 0, ""},
+ {"DNS_TYPE_NIMLOC", Const, 0, ""},
+ {"DNS_TYPE_NS", Const, 0, ""},
+ {"DNS_TYPE_NSAP", Const, 0, ""},
+ {"DNS_TYPE_NSAPPTR", Const, 0, ""},
+ {"DNS_TYPE_NSEC", Const, 0, ""},
+ {"DNS_TYPE_NULL", Const, 0, ""},
+ {"DNS_TYPE_NXT", Const, 0, ""},
+ {"DNS_TYPE_OPT", Const, 0, ""},
+ {"DNS_TYPE_PTR", Const, 0, ""},
+ {"DNS_TYPE_PX", Const, 0, ""},
+ {"DNS_TYPE_RP", Const, 0, ""},
+ {"DNS_TYPE_RRSIG", Const, 0, ""},
+ {"DNS_TYPE_RT", Const, 0, ""},
+ {"DNS_TYPE_SIG", Const, 0, ""},
+ {"DNS_TYPE_SINK", Const, 0, ""},
+ {"DNS_TYPE_SOA", Const, 0, ""},
+ {"DNS_TYPE_SRV", Const, 0, ""},
+ {"DNS_TYPE_TEXT", Const, 0, ""},
+ {"DNS_TYPE_TKEY", Const, 0, ""},
+ {"DNS_TYPE_TSIG", Const, 0, ""},
+ {"DNS_TYPE_UID", Const, 0, ""},
+ {"DNS_TYPE_UINFO", Const, 0, ""},
+ {"DNS_TYPE_UNSPEC", Const, 0, ""},
+ {"DNS_TYPE_WINS", Const, 0, ""},
+ {"DNS_TYPE_WINSR", Const, 0, ""},
+ {"DNS_TYPE_WKS", Const, 0, ""},
+ {"DNS_TYPE_X25", Const, 0, ""},
+ {"DT_BLK", Const, 0, ""},
+ {"DT_CHR", Const, 0, ""},
+ {"DT_DIR", Const, 0, ""},
+ {"DT_FIFO", Const, 0, ""},
+ {"DT_LNK", Const, 0, ""},
+ {"DT_REG", Const, 0, ""},
+ {"DT_SOCK", Const, 0, ""},
+ {"DT_UNKNOWN", Const, 0, ""},
+ {"DT_WHT", Const, 0, ""},
+ {"DUPLICATE_CLOSE_SOURCE", Const, 0, ""},
+ {"DUPLICATE_SAME_ACCESS", Const, 0, ""},
+ {"DeleteFile", Func, 0, ""},
+ {"DetachLsf", Func, 0, "func(fd int) error"},
+ {"DeviceIoControl", Func, 4, ""},
+ {"Dirent", Type, 0, ""},
+ {"Dirent.Fileno", Field, 0, ""},
+ {"Dirent.Ino", Field, 0, ""},
+ {"Dirent.Name", Field, 0, ""},
+ {"Dirent.Namlen", Field, 0, ""},
+ {"Dirent.Off", Field, 0, ""},
+ {"Dirent.Pad0", Field, 12, ""},
+ {"Dirent.Pad1", Field, 12, ""},
+ {"Dirent.Pad_cgo_0", Field, 0, ""},
+ {"Dirent.Reclen", Field, 0, ""},
+ {"Dirent.Seekoff", Field, 0, ""},
+ {"Dirent.Type", Field, 0, ""},
+ {"Dirent.X__d_padding", Field, 3, ""},
+ {"DnsNameCompare", Func, 4, ""},
+ {"DnsQuery", Func, 0, ""},
+ {"DnsRecordListFree", Func, 0, ""},
+ {"DnsSectionAdditional", Const, 4, ""},
+ {"DnsSectionAnswer", Const, 4, ""},
+ {"DnsSectionAuthority", Const, 4, ""},
+ {"DnsSectionQuestion", Const, 4, ""},
+ {"Dup", Func, 0, "func(oldfd int) (fd int, err error)"},
+ {"Dup2", Func, 0, "func(oldfd int, newfd int) (err error)"},
+ {"Dup3", Func, 2, "func(oldfd int, newfd int, flags int) (err error)"},
+ {"DuplicateHandle", Func, 0, ""},
+ {"E2BIG", Const, 0, ""},
+ {"EACCES", Const, 0, ""},
+ {"EADDRINUSE", Const, 0, ""},
+ {"EADDRNOTAVAIL", Const, 0, ""},
+ {"EADV", Const, 0, ""},
+ {"EAFNOSUPPORT", Const, 0, ""},
+ {"EAGAIN", Const, 0, ""},
+ {"EALREADY", Const, 0, ""},
+ {"EAUTH", Const, 0, ""},
+ {"EBADARCH", Const, 0, ""},
+ {"EBADE", Const, 0, ""},
+ {"EBADEXEC", Const, 0, ""},
+ {"EBADF", Const, 0, ""},
+ {"EBADFD", Const, 0, ""},
+ {"EBADMACHO", Const, 0, ""},
+ {"EBADMSG", Const, 0, ""},
+ {"EBADR", Const, 0, ""},
+ {"EBADRPC", Const, 0, ""},
+ {"EBADRQC", Const, 0, ""},
+ {"EBADSLT", Const, 0, ""},
+ {"EBFONT", Const, 0, ""},
+ {"EBUSY", Const, 0, ""},
+ {"ECANCELED", Const, 0, ""},
+ {"ECAPMODE", Const, 1, ""},
+ {"ECHILD", Const, 0, ""},
+ {"ECHO", Const, 0, ""},
+ {"ECHOCTL", Const, 0, ""},
+ {"ECHOE", Const, 0, ""},
+ {"ECHOK", Const, 0, ""},
+ {"ECHOKE", Const, 0, ""},
+ {"ECHONL", Const, 0, ""},
+ {"ECHOPRT", Const, 0, ""},
+ {"ECHRNG", Const, 0, ""},
+ {"ECOMM", Const, 0, ""},
+ {"ECONNABORTED", Const, 0, ""},
+ {"ECONNREFUSED", Const, 0, ""},
+ {"ECONNRESET", Const, 0, ""},
+ {"EDEADLK", Const, 0, ""},
+ {"EDEADLOCK", Const, 0, ""},
+ {"EDESTADDRREQ", Const, 0, ""},
+ {"EDEVERR", Const, 0, ""},
+ {"EDOM", Const, 0, ""},
+ {"EDOOFUS", Const, 0, ""},
+ {"EDOTDOT", Const, 0, ""},
+ {"EDQUOT", Const, 0, ""},
+ {"EEXIST", Const, 0, ""},
+ {"EFAULT", Const, 0, ""},
+ {"EFBIG", Const, 0, ""},
+ {"EFER_LMA", Const, 1, ""},
+ {"EFER_LME", Const, 1, ""},
+ {"EFER_NXE", Const, 1, ""},
+ {"EFER_SCE", Const, 1, ""},
+ {"EFTYPE", Const, 0, ""},
+ {"EHOSTDOWN", Const, 0, ""},
+ {"EHOSTUNREACH", Const, 0, ""},
+ {"EHWPOISON", Const, 0, ""},
+ {"EIDRM", Const, 0, ""},
+ {"EILSEQ", Const, 0, ""},
+ {"EINPROGRESS", Const, 0, ""},
+ {"EINTR", Const, 0, ""},
+ {"EINVAL", Const, 0, ""},
+ {"EIO", Const, 0, ""},
+ {"EIPSEC", Const, 1, ""},
+ {"EISCONN", Const, 0, ""},
+ {"EISDIR", Const, 0, ""},
+ {"EISNAM", Const, 0, ""},
+ {"EKEYEXPIRED", Const, 0, ""},
+ {"EKEYREJECTED", Const, 0, ""},
+ {"EKEYREVOKED", Const, 0, ""},
+ {"EL2HLT", Const, 0, ""},
+ {"EL2NSYNC", Const, 0, ""},
+ {"EL3HLT", Const, 0, ""},
+ {"EL3RST", Const, 0, ""},
+ {"ELAST", Const, 0, ""},
+ {"ELF_NGREG", Const, 0, ""},
+ {"ELF_PRARGSZ", Const, 0, ""},
+ {"ELIBACC", Const, 0, ""},
+ {"ELIBBAD", Const, 0, ""},
+ {"ELIBEXEC", Const, 0, ""},
+ {"ELIBMAX", Const, 0, ""},
+ {"ELIBSCN", Const, 0, ""},
+ {"ELNRNG", Const, 0, ""},
+ {"ELOOP", Const, 0, ""},
+ {"EMEDIUMTYPE", Const, 0, ""},
+ {"EMFILE", Const, 0, ""},
+ {"EMLINK", Const, 0, ""},
+ {"EMSGSIZE", Const, 0, ""},
+ {"EMT_TAGOVF", Const, 1, ""},
+ {"EMULTIHOP", Const, 0, ""},
+ {"EMUL_ENABLED", Const, 1, ""},
+ {"EMUL_LINUX", Const, 1, ""},
+ {"EMUL_LINUX32", Const, 1, ""},
+ {"EMUL_MAXID", Const, 1, ""},
+ {"EMUL_NATIVE", Const, 1, ""},
+ {"ENAMETOOLONG", Const, 0, ""},
+ {"ENAVAIL", Const, 0, ""},
+ {"ENDRUNDISC", Const, 1, ""},
+ {"ENEEDAUTH", Const, 0, ""},
+ {"ENETDOWN", Const, 0, ""},
+ {"ENETRESET", Const, 0, ""},
+ {"ENETUNREACH", Const, 0, ""},
+ {"ENFILE", Const, 0, ""},
+ {"ENOANO", Const, 0, ""},
+ {"ENOATTR", Const, 0, ""},
+ {"ENOBUFS", Const, 0, ""},
+ {"ENOCSI", Const, 0, ""},
+ {"ENODATA", Const, 0, ""},
+ {"ENODEV", Const, 0, ""},
+ {"ENOENT", Const, 0, ""},
+ {"ENOEXEC", Const, 0, ""},
+ {"ENOKEY", Const, 0, ""},
+ {"ENOLCK", Const, 0, ""},
+ {"ENOLINK", Const, 0, ""},
+ {"ENOMEDIUM", Const, 0, ""},
+ {"ENOMEM", Const, 0, ""},
+ {"ENOMSG", Const, 0, ""},
+ {"ENONET", Const, 0, ""},
+ {"ENOPKG", Const, 0, ""},
+ {"ENOPOLICY", Const, 0, ""},
+ {"ENOPROTOOPT", Const, 0, ""},
+ {"ENOSPC", Const, 0, ""},
+ {"ENOSR", Const, 0, ""},
+ {"ENOSTR", Const, 0, ""},
+ {"ENOSYS", Const, 0, ""},
+ {"ENOTBLK", Const, 0, ""},
+ {"ENOTCAPABLE", Const, 0, ""},
+ {"ENOTCONN", Const, 0, ""},
+ {"ENOTDIR", Const, 0, ""},
+ {"ENOTEMPTY", Const, 0, ""},
+ {"ENOTNAM", Const, 0, ""},
+ {"ENOTRECOVERABLE", Const, 0, ""},
+ {"ENOTSOCK", Const, 0, ""},
+ {"ENOTSUP", Const, 0, ""},
+ {"ENOTTY", Const, 0, ""},
+ {"ENOTUNIQ", Const, 0, ""},
+ {"ENXIO", Const, 0, ""},
+ {"EN_SW_CTL_INF", Const, 1, ""},
+ {"EN_SW_CTL_PREC", Const, 1, ""},
+ {"EN_SW_CTL_ROUND", Const, 1, ""},
+ {"EN_SW_DATACHAIN", Const, 1, ""},
+ {"EN_SW_DENORM", Const, 1, ""},
+ {"EN_SW_INVOP", Const, 1, ""},
+ {"EN_SW_OVERFLOW", Const, 1, ""},
+ {"EN_SW_PRECLOSS", Const, 1, ""},
+ {"EN_SW_UNDERFLOW", Const, 1, ""},
+ {"EN_SW_ZERODIV", Const, 1, ""},
+ {"EOPNOTSUPP", Const, 0, ""},
+ {"EOVERFLOW", Const, 0, ""},
+ {"EOWNERDEAD", Const, 0, ""},
+ {"EPERM", Const, 0, ""},
+ {"EPFNOSUPPORT", Const, 0, ""},
+ {"EPIPE", Const, 0, ""},
+ {"EPOLLERR", Const, 0, ""},
+ {"EPOLLET", Const, 0, ""},
+ {"EPOLLHUP", Const, 0, ""},
+ {"EPOLLIN", Const, 0, ""},
+ {"EPOLLMSG", Const, 0, ""},
+ {"EPOLLONESHOT", Const, 0, ""},
+ {"EPOLLOUT", Const, 0, ""},
+ {"EPOLLPRI", Const, 0, ""},
+ {"EPOLLRDBAND", Const, 0, ""},
+ {"EPOLLRDHUP", Const, 0, ""},
+ {"EPOLLRDNORM", Const, 0, ""},
+ {"EPOLLWRBAND", Const, 0, ""},
+ {"EPOLLWRNORM", Const, 0, ""},
+ {"EPOLL_CLOEXEC", Const, 0, ""},
+ {"EPOLL_CTL_ADD", Const, 0, ""},
+ {"EPOLL_CTL_DEL", Const, 0, ""},
+ {"EPOLL_CTL_MOD", Const, 0, ""},
+ {"EPOLL_NONBLOCK", Const, 0, ""},
+ {"EPROCLIM", Const, 0, ""},
+ {"EPROCUNAVAIL", Const, 0, ""},
+ {"EPROGMISMATCH", Const, 0, ""},
+ {"EPROGUNAVAIL", Const, 0, ""},
+ {"EPROTO", Const, 0, ""},
+ {"EPROTONOSUPPORT", Const, 0, ""},
+ {"EPROTOTYPE", Const, 0, ""},
+ {"EPWROFF", Const, 0, ""},
+ {"EQFULL", Const, 16, ""},
+ {"ERANGE", Const, 0, ""},
+ {"EREMCHG", Const, 0, ""},
+ {"EREMOTE", Const, 0, ""},
+ {"EREMOTEIO", Const, 0, ""},
+ {"ERESTART", Const, 0, ""},
+ {"ERFKILL", Const, 0, ""},
+ {"EROFS", Const, 0, ""},
+ {"ERPCMISMATCH", Const, 0, ""},
+ {"ERROR_ACCESS_DENIED", Const, 0, ""},
+ {"ERROR_ALREADY_EXISTS", Const, 0, ""},
+ {"ERROR_BROKEN_PIPE", Const, 0, ""},
+ {"ERROR_BUFFER_OVERFLOW", Const, 0, ""},
+ {"ERROR_DIR_NOT_EMPTY", Const, 8, ""},
+ {"ERROR_ENVVAR_NOT_FOUND", Const, 0, ""},
+ {"ERROR_FILE_EXISTS", Const, 0, ""},
+ {"ERROR_FILE_NOT_FOUND", Const, 0, ""},
+ {"ERROR_HANDLE_EOF", Const, 2, ""},
+ {"ERROR_INSUFFICIENT_BUFFER", Const, 0, ""},
+ {"ERROR_IO_PENDING", Const, 0, ""},
+ {"ERROR_MOD_NOT_FOUND", Const, 0, ""},
+ {"ERROR_MORE_DATA", Const, 3, ""},
+ {"ERROR_NETNAME_DELETED", Const, 3, ""},
+ {"ERROR_NOT_FOUND", Const, 1, ""},
+ {"ERROR_NO_MORE_FILES", Const, 0, ""},
+ {"ERROR_OPERATION_ABORTED", Const, 0, ""},
+ {"ERROR_PATH_NOT_FOUND", Const, 0, ""},
+ {"ERROR_PRIVILEGE_NOT_HELD", Const, 4, ""},
+ {"ERROR_PROC_NOT_FOUND", Const, 0, ""},
+ {"ESHLIBVERS", Const, 0, ""},
+ {"ESHUTDOWN", Const, 0, ""},
+ {"ESOCKTNOSUPPORT", Const, 0, ""},
+ {"ESPIPE", Const, 0, ""},
+ {"ESRCH", Const, 0, ""},
+ {"ESRMNT", Const, 0, ""},
+ {"ESTALE", Const, 0, ""},
+ {"ESTRPIPE", Const, 0, ""},
+ {"ETHERCAP_JUMBO_MTU", Const, 1, ""},
+ {"ETHERCAP_VLAN_HWTAGGING", Const, 1, ""},
+ {"ETHERCAP_VLAN_MTU", Const, 1, ""},
+ {"ETHERMIN", Const, 1, ""},
+ {"ETHERMTU", Const, 1, ""},
+ {"ETHERMTU_JUMBO", Const, 1, ""},
+ {"ETHERTYPE_8023", Const, 1, ""},
+ {"ETHERTYPE_AARP", Const, 1, ""},
+ {"ETHERTYPE_ACCTON", Const, 1, ""},
+ {"ETHERTYPE_AEONIC", Const, 1, ""},
+ {"ETHERTYPE_ALPHA", Const, 1, ""},
+ {"ETHERTYPE_AMBER", Const, 1, ""},
+ {"ETHERTYPE_AMOEBA", Const, 1, ""},
+ {"ETHERTYPE_AOE", Const, 1, ""},
+ {"ETHERTYPE_APOLLO", Const, 1, ""},
+ {"ETHERTYPE_APOLLODOMAIN", Const, 1, ""},
+ {"ETHERTYPE_APPLETALK", Const, 1, ""},
+ {"ETHERTYPE_APPLITEK", Const, 1, ""},
+ {"ETHERTYPE_ARGONAUT", Const, 1, ""},
+ {"ETHERTYPE_ARP", Const, 1, ""},
+ {"ETHERTYPE_AT", Const, 1, ""},
+ {"ETHERTYPE_ATALK", Const, 1, ""},
+ {"ETHERTYPE_ATOMIC", Const, 1, ""},
+ {"ETHERTYPE_ATT", Const, 1, ""},
+ {"ETHERTYPE_ATTSTANFORD", Const, 1, ""},
+ {"ETHERTYPE_AUTOPHON", Const, 1, ""},
+ {"ETHERTYPE_AXIS", Const, 1, ""},
+ {"ETHERTYPE_BCLOOP", Const, 1, ""},
+ {"ETHERTYPE_BOFL", Const, 1, ""},
+ {"ETHERTYPE_CABLETRON", Const, 1, ""},
+ {"ETHERTYPE_CHAOS", Const, 1, ""},
+ {"ETHERTYPE_COMDESIGN", Const, 1, ""},
+ {"ETHERTYPE_COMPUGRAPHIC", Const, 1, ""},
+ {"ETHERTYPE_COUNTERPOINT", Const, 1, ""},
+ {"ETHERTYPE_CRONUS", Const, 1, ""},
+ {"ETHERTYPE_CRONUSVLN", Const, 1, ""},
+ {"ETHERTYPE_DCA", Const, 1, ""},
+ {"ETHERTYPE_DDE", Const, 1, ""},
+ {"ETHERTYPE_DEBNI", Const, 1, ""},
+ {"ETHERTYPE_DECAM", Const, 1, ""},
+ {"ETHERTYPE_DECCUST", Const, 1, ""},
+ {"ETHERTYPE_DECDIAG", Const, 1, ""},
+ {"ETHERTYPE_DECDNS", Const, 1, ""},
+ {"ETHERTYPE_DECDTS", Const, 1, ""},
+ {"ETHERTYPE_DECEXPER", Const, 1, ""},
+ {"ETHERTYPE_DECLAST", Const, 1, ""},
+ {"ETHERTYPE_DECLTM", Const, 1, ""},
+ {"ETHERTYPE_DECMUMPS", Const, 1, ""},
+ {"ETHERTYPE_DECNETBIOS", Const, 1, ""},
+ {"ETHERTYPE_DELTACON", Const, 1, ""},
+ {"ETHERTYPE_DIDDLE", Const, 1, ""},
+ {"ETHERTYPE_DLOG1", Const, 1, ""},
+ {"ETHERTYPE_DLOG2", Const, 1, ""},
+ {"ETHERTYPE_DN", Const, 1, ""},
+ {"ETHERTYPE_DOGFIGHT", Const, 1, ""},
+ {"ETHERTYPE_DSMD", Const, 1, ""},
+ {"ETHERTYPE_ECMA", Const, 1, ""},
+ {"ETHERTYPE_ENCRYPT", Const, 1, ""},
+ {"ETHERTYPE_ES", Const, 1, ""},
+ {"ETHERTYPE_EXCELAN", Const, 1, ""},
+ {"ETHERTYPE_EXPERDATA", Const, 1, ""},
+ {"ETHERTYPE_FLIP", Const, 1, ""},
+ {"ETHERTYPE_FLOWCONTROL", Const, 1, ""},
+ {"ETHERTYPE_FRARP", Const, 1, ""},
+ {"ETHERTYPE_GENDYN", Const, 1, ""},
+ {"ETHERTYPE_HAYES", Const, 1, ""},
+ {"ETHERTYPE_HIPPI_FP", Const, 1, ""},
+ {"ETHERTYPE_HITACHI", Const, 1, ""},
+ {"ETHERTYPE_HP", Const, 1, ""},
+ {"ETHERTYPE_IEEEPUP", Const, 1, ""},
+ {"ETHERTYPE_IEEEPUPAT", Const, 1, ""},
+ {"ETHERTYPE_IMLBL", Const, 1, ""},
+ {"ETHERTYPE_IMLBLDIAG", Const, 1, ""},
+ {"ETHERTYPE_IP", Const, 1, ""},
+ {"ETHERTYPE_IPAS", Const, 1, ""},
+ {"ETHERTYPE_IPV6", Const, 1, ""},
+ {"ETHERTYPE_IPX", Const, 1, ""},
+ {"ETHERTYPE_IPXNEW", Const, 1, ""},
+ {"ETHERTYPE_KALPANA", Const, 1, ""},
+ {"ETHERTYPE_LANBRIDGE", Const, 1, ""},
+ {"ETHERTYPE_LANPROBE", Const, 1, ""},
+ {"ETHERTYPE_LAT", Const, 1, ""},
+ {"ETHERTYPE_LBACK", Const, 1, ""},
+ {"ETHERTYPE_LITTLE", Const, 1, ""},
+ {"ETHERTYPE_LLDP", Const, 1, ""},
+ {"ETHERTYPE_LOGICRAFT", Const, 1, ""},
+ {"ETHERTYPE_LOOPBACK", Const, 1, ""},
+ {"ETHERTYPE_MATRA", Const, 1, ""},
+ {"ETHERTYPE_MAX", Const, 1, ""},
+ {"ETHERTYPE_MERIT", Const, 1, ""},
+ {"ETHERTYPE_MICP", Const, 1, ""},
+ {"ETHERTYPE_MOPDL", Const, 1, ""},
+ {"ETHERTYPE_MOPRC", Const, 1, ""},
+ {"ETHERTYPE_MOTOROLA", Const, 1, ""},
+ {"ETHERTYPE_MPLS", Const, 1, ""},
+ {"ETHERTYPE_MPLS_MCAST", Const, 1, ""},
+ {"ETHERTYPE_MUMPS", Const, 1, ""},
+ {"ETHERTYPE_NBPCC", Const, 1, ""},
+ {"ETHERTYPE_NBPCLAIM", Const, 1, ""},
+ {"ETHERTYPE_NBPCLREQ", Const, 1, ""},
+ {"ETHERTYPE_NBPCLRSP", Const, 1, ""},
+ {"ETHERTYPE_NBPCREQ", Const, 1, ""},
+ {"ETHERTYPE_NBPCRSP", Const, 1, ""},
+ {"ETHERTYPE_NBPDG", Const, 1, ""},
+ {"ETHERTYPE_NBPDGB", Const, 1, ""},
+ {"ETHERTYPE_NBPDLTE", Const, 1, ""},
+ {"ETHERTYPE_NBPRAR", Const, 1, ""},
+ {"ETHERTYPE_NBPRAS", Const, 1, ""},
+ {"ETHERTYPE_NBPRST", Const, 1, ""},
+ {"ETHERTYPE_NBPSCD", Const, 1, ""},
+ {"ETHERTYPE_NBPVCD", Const, 1, ""},
+ {"ETHERTYPE_NBS", Const, 1, ""},
+ {"ETHERTYPE_NCD", Const, 1, ""},
+ {"ETHERTYPE_NESTAR", Const, 1, ""},
+ {"ETHERTYPE_NETBEUI", Const, 1, ""},
+ {"ETHERTYPE_NOVELL", Const, 1, ""},
+ {"ETHERTYPE_NS", Const, 1, ""},
+ {"ETHERTYPE_NSAT", Const, 1, ""},
+ {"ETHERTYPE_NSCOMPAT", Const, 1, ""},
+ {"ETHERTYPE_NTRAILER", Const, 1, ""},
+ {"ETHERTYPE_OS9", Const, 1, ""},
+ {"ETHERTYPE_OS9NET", Const, 1, ""},
+ {"ETHERTYPE_PACER", Const, 1, ""},
+ {"ETHERTYPE_PAE", Const, 1, ""},
+ {"ETHERTYPE_PCS", Const, 1, ""},
+ {"ETHERTYPE_PLANNING", Const, 1, ""},
+ {"ETHERTYPE_PPP", Const, 1, ""},
+ {"ETHERTYPE_PPPOE", Const, 1, ""},
+ {"ETHERTYPE_PPPOEDISC", Const, 1, ""},
+ {"ETHERTYPE_PRIMENTS", Const, 1, ""},
+ {"ETHERTYPE_PUP", Const, 1, ""},
+ {"ETHERTYPE_PUPAT", Const, 1, ""},
+ {"ETHERTYPE_QINQ", Const, 1, ""},
+ {"ETHERTYPE_RACAL", Const, 1, ""},
+ {"ETHERTYPE_RATIONAL", Const, 1, ""},
+ {"ETHERTYPE_RAWFR", Const, 1, ""},
+ {"ETHERTYPE_RCL", Const, 1, ""},
+ {"ETHERTYPE_RDP", Const, 1, ""},
+ {"ETHERTYPE_RETIX", Const, 1, ""},
+ {"ETHERTYPE_REVARP", Const, 1, ""},
+ {"ETHERTYPE_SCA", Const, 1, ""},
+ {"ETHERTYPE_SECTRA", Const, 1, ""},
+ {"ETHERTYPE_SECUREDATA", Const, 1, ""},
+ {"ETHERTYPE_SGITW", Const, 1, ""},
+ {"ETHERTYPE_SG_BOUNCE", Const, 1, ""},
+ {"ETHERTYPE_SG_DIAG", Const, 1, ""},
+ {"ETHERTYPE_SG_NETGAMES", Const, 1, ""},
+ {"ETHERTYPE_SG_RESV", Const, 1, ""},
+ {"ETHERTYPE_SIMNET", Const, 1, ""},
+ {"ETHERTYPE_SLOW", Const, 1, ""},
+ {"ETHERTYPE_SLOWPROTOCOLS", Const, 1, ""},
+ {"ETHERTYPE_SNA", Const, 1, ""},
+ {"ETHERTYPE_SNMP", Const, 1, ""},
+ {"ETHERTYPE_SONIX", Const, 1, ""},
+ {"ETHERTYPE_SPIDER", Const, 1, ""},
+ {"ETHERTYPE_SPRITE", Const, 1, ""},
+ {"ETHERTYPE_STP", Const, 1, ""},
+ {"ETHERTYPE_TALARIS", Const, 1, ""},
+ {"ETHERTYPE_TALARISMC", Const, 1, ""},
+ {"ETHERTYPE_TCPCOMP", Const, 1, ""},
+ {"ETHERTYPE_TCPSM", Const, 1, ""},
+ {"ETHERTYPE_TEC", Const, 1, ""},
+ {"ETHERTYPE_TIGAN", Const, 1, ""},
+ {"ETHERTYPE_TRAIL", Const, 1, ""},
+ {"ETHERTYPE_TRANSETHER", Const, 1, ""},
+ {"ETHERTYPE_TYMSHARE", Const, 1, ""},
+ {"ETHERTYPE_UBBST", Const, 1, ""},
+ {"ETHERTYPE_UBDEBUG", Const, 1, ""},
+ {"ETHERTYPE_UBDIAGLOOP", Const, 1, ""},
+ {"ETHERTYPE_UBDL", Const, 1, ""},
+ {"ETHERTYPE_UBNIU", Const, 1, ""},
+ {"ETHERTYPE_UBNMC", Const, 1, ""},
+ {"ETHERTYPE_VALID", Const, 1, ""},
+ {"ETHERTYPE_VARIAN", Const, 1, ""},
+ {"ETHERTYPE_VAXELN", Const, 1, ""},
+ {"ETHERTYPE_VEECO", Const, 1, ""},
+ {"ETHERTYPE_VEXP", Const, 1, ""},
+ {"ETHERTYPE_VGLAB", Const, 1, ""},
+ {"ETHERTYPE_VINES", Const, 1, ""},
+ {"ETHERTYPE_VINESECHO", Const, 1, ""},
+ {"ETHERTYPE_VINESLOOP", Const, 1, ""},
+ {"ETHERTYPE_VITAL", Const, 1, ""},
+ {"ETHERTYPE_VLAN", Const, 1, ""},
+ {"ETHERTYPE_VLTLMAN", Const, 1, ""},
+ {"ETHERTYPE_VPROD", Const, 1, ""},
+ {"ETHERTYPE_VURESERVED", Const, 1, ""},
+ {"ETHERTYPE_WATERLOO", Const, 1, ""},
+ {"ETHERTYPE_WELLFLEET", Const, 1, ""},
+ {"ETHERTYPE_X25", Const, 1, ""},
+ {"ETHERTYPE_X75", Const, 1, ""},
+ {"ETHERTYPE_XNSSM", Const, 1, ""},
+ {"ETHERTYPE_XTP", Const, 1, ""},
+ {"ETHER_ADDR_LEN", Const, 1, ""},
+ {"ETHER_ALIGN", Const, 1, ""},
+ {"ETHER_CRC_LEN", Const, 1, ""},
+ {"ETHER_CRC_POLY_BE", Const, 1, ""},
+ {"ETHER_CRC_POLY_LE", Const, 1, ""},
+ {"ETHER_HDR_LEN", Const, 1, ""},
+ {"ETHER_MAX_DIX_LEN", Const, 1, ""},
+ {"ETHER_MAX_LEN", Const, 1, ""},
+ {"ETHER_MAX_LEN_JUMBO", Const, 1, ""},
+ {"ETHER_MIN_LEN", Const, 1, ""},
+ {"ETHER_PPPOE_ENCAP_LEN", Const, 1, ""},
+ {"ETHER_TYPE_LEN", Const, 1, ""},
+ {"ETHER_VLAN_ENCAP_LEN", Const, 1, ""},
+ {"ETH_P_1588", Const, 0, ""},
+ {"ETH_P_8021Q", Const, 0, ""},
+ {"ETH_P_802_2", Const, 0, ""},
+ {"ETH_P_802_3", Const, 0, ""},
+ {"ETH_P_AARP", Const, 0, ""},
+ {"ETH_P_ALL", Const, 0, ""},
+ {"ETH_P_AOE", Const, 0, ""},
+ {"ETH_P_ARCNET", Const, 0, ""},
+ {"ETH_P_ARP", Const, 0, ""},
+ {"ETH_P_ATALK", Const, 0, ""},
+ {"ETH_P_ATMFATE", Const, 0, ""},
+ {"ETH_P_ATMMPOA", Const, 0, ""},
+ {"ETH_P_AX25", Const, 0, ""},
+ {"ETH_P_BPQ", Const, 0, ""},
+ {"ETH_P_CAIF", Const, 0, ""},
+ {"ETH_P_CAN", Const, 0, ""},
+ {"ETH_P_CONTROL", Const, 0, ""},
+ {"ETH_P_CUST", Const, 0, ""},
+ {"ETH_P_DDCMP", Const, 0, ""},
+ {"ETH_P_DEC", Const, 0, ""},
+ {"ETH_P_DIAG", Const, 0, ""},
+ {"ETH_P_DNA_DL", Const, 0, ""},
+ {"ETH_P_DNA_RC", Const, 0, ""},
+ {"ETH_P_DNA_RT", Const, 0, ""},
+ {"ETH_P_DSA", Const, 0, ""},
+ {"ETH_P_ECONET", Const, 0, ""},
+ {"ETH_P_EDSA", Const, 0, ""},
+ {"ETH_P_FCOE", Const, 0, ""},
+ {"ETH_P_FIP", Const, 0, ""},
+ {"ETH_P_HDLC", Const, 0, ""},
+ {"ETH_P_IEEE802154", Const, 0, ""},
+ {"ETH_P_IEEEPUP", Const, 0, ""},
+ {"ETH_P_IEEEPUPAT", Const, 0, ""},
+ {"ETH_P_IP", Const, 0, ""},
+ {"ETH_P_IPV6", Const, 0, ""},
+ {"ETH_P_IPX", Const, 0, ""},
+ {"ETH_P_IRDA", Const, 0, ""},
+ {"ETH_P_LAT", Const, 0, ""},
+ {"ETH_P_LINK_CTL", Const, 0, ""},
+ {"ETH_P_LOCALTALK", Const, 0, ""},
+ {"ETH_P_LOOP", Const, 0, ""},
+ {"ETH_P_MOBITEX", Const, 0, ""},
+ {"ETH_P_MPLS_MC", Const, 0, ""},
+ {"ETH_P_MPLS_UC", Const, 0, ""},
+ {"ETH_P_PAE", Const, 0, ""},
+ {"ETH_P_PAUSE", Const, 0, ""},
+ {"ETH_P_PHONET", Const, 0, ""},
+ {"ETH_P_PPPTALK", Const, 0, ""},
+ {"ETH_P_PPP_DISC", Const, 0, ""},
+ {"ETH_P_PPP_MP", Const, 0, ""},
+ {"ETH_P_PPP_SES", Const, 0, ""},
+ {"ETH_P_PUP", Const, 0, ""},
+ {"ETH_P_PUPAT", Const, 0, ""},
+ {"ETH_P_RARP", Const, 0, ""},
+ {"ETH_P_SCA", Const, 0, ""},
+ {"ETH_P_SLOW", Const, 0, ""},
+ {"ETH_P_SNAP", Const, 0, ""},
+ {"ETH_P_TEB", Const, 0, ""},
+ {"ETH_P_TIPC", Const, 0, ""},
+ {"ETH_P_TRAILER", Const, 0, ""},
+ {"ETH_P_TR_802_2", Const, 0, ""},
+ {"ETH_P_WAN_PPP", Const, 0, ""},
+ {"ETH_P_WCCP", Const, 0, ""},
+ {"ETH_P_X25", Const, 0, ""},
+ {"ETIME", Const, 0, ""},
+ {"ETIMEDOUT", Const, 0, ""},
+ {"ETOOMANYREFS", Const, 0, ""},
+ {"ETXTBSY", Const, 0, ""},
+ {"EUCLEAN", Const, 0, ""},
+ {"EUNATCH", Const, 0, ""},
+ {"EUSERS", Const, 0, ""},
+ {"EVFILT_AIO", Const, 0, ""},
+ {"EVFILT_FS", Const, 0, ""},
+ {"EVFILT_LIO", Const, 0, ""},
+ {"EVFILT_MACHPORT", Const, 0, ""},
+ {"EVFILT_PROC", Const, 0, ""},
+ {"EVFILT_READ", Const, 0, ""},
+ {"EVFILT_SIGNAL", Const, 0, ""},
+ {"EVFILT_SYSCOUNT", Const, 0, ""},
+ {"EVFILT_THREADMARKER", Const, 0, ""},
+ {"EVFILT_TIMER", Const, 0, ""},
+ {"EVFILT_USER", Const, 0, ""},
+ {"EVFILT_VM", Const, 0, ""},
+ {"EVFILT_VNODE", Const, 0, ""},
+ {"EVFILT_WRITE", Const, 0, ""},
+ {"EV_ADD", Const, 0, ""},
+ {"EV_CLEAR", Const, 0, ""},
+ {"EV_DELETE", Const, 0, ""},
+ {"EV_DISABLE", Const, 0, ""},
+ {"EV_DISPATCH", Const, 0, ""},
+ {"EV_DROP", Const, 3, ""},
+ {"EV_ENABLE", Const, 0, ""},
+ {"EV_EOF", Const, 0, ""},
+ {"EV_ERROR", Const, 0, ""},
+ {"EV_FLAG0", Const, 0, ""},
+ {"EV_FLAG1", Const, 0, ""},
+ {"EV_ONESHOT", Const, 0, ""},
+ {"EV_OOBAND", Const, 0, ""},
+ {"EV_POLL", Const, 0, ""},
+ {"EV_RECEIPT", Const, 0, ""},
+ {"EV_SYSFLAGS", Const, 0, ""},
+ {"EWINDOWS", Const, 0, ""},
+ {"EWOULDBLOCK", Const, 0, ""},
+ {"EXDEV", Const, 0, ""},
+ {"EXFULL", Const, 0, ""},
+ {"EXTA", Const, 0, ""},
+ {"EXTB", Const, 0, ""},
+ {"EXTPROC", Const, 0, ""},
+ {"Environ", Func, 0, "func() []string"},
+ {"EpollCreate", Func, 0, "func(size int) (fd int, err error)"},
+ {"EpollCreate1", Func, 0, "func(flag int) (fd int, err error)"},
+ {"EpollCtl", Func, 0, "func(epfd int, op int, fd int, event *EpollEvent) (err error)"},
+ {"EpollEvent", Type, 0, ""},
+ {"EpollEvent.Events", Field, 0, ""},
+ {"EpollEvent.Fd", Field, 0, ""},
+ {"EpollEvent.Pad", Field, 0, ""},
+ {"EpollEvent.PadFd", Field, 0, ""},
+ {"EpollWait", Func, 0, "func(epfd int, events []EpollEvent, msec int) (n int, err error)"},
+ {"Errno", Type, 0, ""},
+ {"EscapeArg", Func, 0, ""},
+ {"Exchangedata", Func, 0, ""},
+ {"Exec", Func, 0, "func(argv0 string, argv []string, envv []string) (err error)"},
+ {"Exit", Func, 0, "func(code int)"},
+ {"ExitProcess", Func, 0, ""},
+ {"FD_CLOEXEC", Const, 0, ""},
+ {"FD_SETSIZE", Const, 0, ""},
+ {"FILE_ACTION_ADDED", Const, 0, ""},
+ {"FILE_ACTION_MODIFIED", Const, 0, ""},
+ {"FILE_ACTION_REMOVED", Const, 0, ""},
+ {"FILE_ACTION_RENAMED_NEW_NAME", Const, 0, ""},
+ {"FILE_ACTION_RENAMED_OLD_NAME", Const, 0, ""},
+ {"FILE_APPEND_DATA", Const, 0, ""},
+ {"FILE_ATTRIBUTE_ARCHIVE", Const, 0, ""},
+ {"FILE_ATTRIBUTE_DIRECTORY", Const, 0, ""},
+ {"FILE_ATTRIBUTE_HIDDEN", Const, 0, ""},
+ {"FILE_ATTRIBUTE_NORMAL", Const, 0, ""},
+ {"FILE_ATTRIBUTE_READONLY", Const, 0, ""},
+ {"FILE_ATTRIBUTE_REPARSE_POINT", Const, 4, ""},
+ {"FILE_ATTRIBUTE_SYSTEM", Const, 0, ""},
+ {"FILE_BEGIN", Const, 0, ""},
+ {"FILE_CURRENT", Const, 0, ""},
+ {"FILE_END", Const, 0, ""},
+ {"FILE_FLAG_BACKUP_SEMANTICS", Const, 0, ""},
+ {"FILE_FLAG_OPEN_REPARSE_POINT", Const, 4, ""},
+ {"FILE_FLAG_OVERLAPPED", Const, 0, ""},
+ {"FILE_LIST_DIRECTORY", Const, 0, ""},
+ {"FILE_MAP_COPY", Const, 0, ""},
+ {"FILE_MAP_EXECUTE", Const, 0, ""},
+ {"FILE_MAP_READ", Const, 0, ""},
+ {"FILE_MAP_WRITE", Const, 0, ""},
+ {"FILE_NOTIFY_CHANGE_ATTRIBUTES", Const, 0, ""},
+ {"FILE_NOTIFY_CHANGE_CREATION", Const, 0, ""},
+ {"FILE_NOTIFY_CHANGE_DIR_NAME", Const, 0, ""},
+ {"FILE_NOTIFY_CHANGE_FILE_NAME", Const, 0, ""},
+ {"FILE_NOTIFY_CHANGE_LAST_ACCESS", Const, 0, ""},
+ {"FILE_NOTIFY_CHANGE_LAST_WRITE", Const, 0, ""},
+ {"FILE_NOTIFY_CHANGE_SIZE", Const, 0, ""},
+ {"FILE_SHARE_DELETE", Const, 0, ""},
+ {"FILE_SHARE_READ", Const, 0, ""},
+ {"FILE_SHARE_WRITE", Const, 0, ""},
+ {"FILE_SKIP_COMPLETION_PORT_ON_SUCCESS", Const, 2, ""},
+ {"FILE_SKIP_SET_EVENT_ON_HANDLE", Const, 2, ""},
+ {"FILE_TYPE_CHAR", Const, 0, ""},
+ {"FILE_TYPE_DISK", Const, 0, ""},
+ {"FILE_TYPE_PIPE", Const, 0, ""},
+ {"FILE_TYPE_REMOTE", Const, 0, ""},
+ {"FILE_TYPE_UNKNOWN", Const, 0, ""},
+ {"FILE_WRITE_ATTRIBUTES", Const, 0, ""},
+ {"FLUSHO", Const, 0, ""},
+ {"FORMAT_MESSAGE_ALLOCATE_BUFFER", Const, 0, ""},
+ {"FORMAT_MESSAGE_ARGUMENT_ARRAY", Const, 0, ""},
+ {"FORMAT_MESSAGE_FROM_HMODULE", Const, 0, ""},
+ {"FORMAT_MESSAGE_FROM_STRING", Const, 0, ""},
+ {"FORMAT_MESSAGE_FROM_SYSTEM", Const, 0, ""},
+ {"FORMAT_MESSAGE_IGNORE_INSERTS", Const, 0, ""},
+ {"FORMAT_MESSAGE_MAX_WIDTH_MASK", Const, 0, ""},
+ {"FSCTL_GET_REPARSE_POINT", Const, 4, ""},
+ {"F_ADDFILESIGS", Const, 0, ""},
+ {"F_ADDSIGS", Const, 0, ""},
+ {"F_ALLOCATEALL", Const, 0, ""},
+ {"F_ALLOCATECONTIG", Const, 0, ""},
+ {"F_CANCEL", Const, 0, ""},
+ {"F_CHKCLEAN", Const, 0, ""},
+ {"F_CLOSEM", Const, 1, ""},
+ {"F_DUP2FD", Const, 0, ""},
+ {"F_DUP2FD_CLOEXEC", Const, 1, ""},
+ {"F_DUPFD", Const, 0, ""},
+ {"F_DUPFD_CLOEXEC", Const, 0, ""},
+ {"F_EXLCK", Const, 0, ""},
+ {"F_FINDSIGS", Const, 16, ""},
+ {"F_FLUSH_DATA", Const, 0, ""},
+ {"F_FREEZE_FS", Const, 0, ""},
+ {"F_FSCTL", Const, 1, ""},
+ {"F_FSDIRMASK", Const, 1, ""},
+ {"F_FSIN", Const, 1, ""},
+ {"F_FSINOUT", Const, 1, ""},
+ {"F_FSOUT", Const, 1, ""},
+ {"F_FSPRIV", Const, 1, ""},
+ {"F_FSVOID", Const, 1, ""},
+ {"F_FULLFSYNC", Const, 0, ""},
+ {"F_GETCODEDIR", Const, 16, ""},
+ {"F_GETFD", Const, 0, ""},
+ {"F_GETFL", Const, 0, ""},
+ {"F_GETLEASE", Const, 0, ""},
+ {"F_GETLK", Const, 0, ""},
+ {"F_GETLK64", Const, 0, ""},
+ {"F_GETLKPID", Const, 0, ""},
+ {"F_GETNOSIGPIPE", Const, 0, ""},
+ {"F_GETOWN", Const, 0, ""},
+ {"F_GETOWN_EX", Const, 0, ""},
+ {"F_GETPATH", Const, 0, ""},
+ {"F_GETPATH_MTMINFO", Const, 0, ""},
+ {"F_GETPIPE_SZ", Const, 0, ""},
+ {"F_GETPROTECTIONCLASS", Const, 0, ""},
+ {"F_GETPROTECTIONLEVEL", Const, 16, ""},
+ {"F_GETSIG", Const, 0, ""},
+ {"F_GLOBAL_NOCACHE", Const, 0, ""},
+ {"F_LOCK", Const, 0, ""},
+ {"F_LOG2PHYS", Const, 0, ""},
+ {"F_LOG2PHYS_EXT", Const, 0, ""},
+ {"F_MARKDEPENDENCY", Const, 0, ""},
+ {"F_MAXFD", Const, 1, ""},
+ {"F_NOCACHE", Const, 0, ""},
+ {"F_NODIRECT", Const, 0, ""},
+ {"F_NOTIFY", Const, 0, ""},
+ {"F_OGETLK", Const, 0, ""},
+ {"F_OK", Const, 0, ""},
+ {"F_OSETLK", Const, 0, ""},
+ {"F_OSETLKW", Const, 0, ""},
+ {"F_PARAM_MASK", Const, 1, ""},
+ {"F_PARAM_MAX", Const, 1, ""},
+ {"F_PATHPKG_CHECK", Const, 0, ""},
+ {"F_PEOFPOSMODE", Const, 0, ""},
+ {"F_PREALLOCATE", Const, 0, ""},
+ {"F_RDADVISE", Const, 0, ""},
+ {"F_RDAHEAD", Const, 0, ""},
+ {"F_RDLCK", Const, 0, ""},
+ {"F_READAHEAD", Const, 0, ""},
+ {"F_READBOOTSTRAP", Const, 0, ""},
+ {"F_SETBACKINGSTORE", Const, 0, ""},
+ {"F_SETFD", Const, 0, ""},
+ {"F_SETFL", Const, 0, ""},
+ {"F_SETLEASE", Const, 0, ""},
+ {"F_SETLK", Const, 0, ""},
+ {"F_SETLK64", Const, 0, ""},
+ {"F_SETLKW", Const, 0, ""},
+ {"F_SETLKW64", Const, 0, ""},
+ {"F_SETLKWTIMEOUT", Const, 16, ""},
+ {"F_SETLK_REMOTE", Const, 0, ""},
+ {"F_SETNOSIGPIPE", Const, 0, ""},
+ {"F_SETOWN", Const, 0, ""},
+ {"F_SETOWN_EX", Const, 0, ""},
+ {"F_SETPIPE_SZ", Const, 0, ""},
+ {"F_SETPROTECTIONCLASS", Const, 0, ""},
+ {"F_SETSIG", Const, 0, ""},
+ {"F_SETSIZE", Const, 0, ""},
+ {"F_SHLCK", Const, 0, ""},
+ {"F_SINGLE_WRITER", Const, 16, ""},
+ {"F_TEST", Const, 0, ""},
+ {"F_THAW_FS", Const, 0, ""},
+ {"F_TLOCK", Const, 0, ""},
+ {"F_TRANSCODEKEY", Const, 16, ""},
+ {"F_ULOCK", Const, 0, ""},
+ {"F_UNLCK", Const, 0, ""},
+ {"F_UNLCKSYS", Const, 0, ""},
+ {"F_VOLPOSMODE", Const, 0, ""},
+ {"F_WRITEBOOTSTRAP", Const, 0, ""},
+ {"F_WRLCK", Const, 0, ""},
+ {"Faccessat", Func, 0, "func(dirfd int, path string, mode uint32, flags int) (err error)"},
+ {"Fallocate", Func, 0, "func(fd int, mode uint32, off int64, len int64) (err error)"},
+ {"Fbootstraptransfer_t", Type, 0, ""},
+ {"Fbootstraptransfer_t.Buffer", Field, 0, ""},
+ {"Fbootstraptransfer_t.Length", Field, 0, ""},
+ {"Fbootstraptransfer_t.Offset", Field, 0, ""},
+ {"Fchdir", Func, 0, "func(fd int) (err error)"},
+ {"Fchflags", Func, 0, ""},
+ {"Fchmod", Func, 0, "func(fd int, mode uint32) (err error)"},
+ {"Fchmodat", Func, 0, "func(dirfd int, path string, mode uint32, flags int) error"},
+ {"Fchown", Func, 0, "func(fd int, uid int, gid int) (err error)"},
+ {"Fchownat", Func, 0, "func(dirfd int, path string, uid int, gid int, flags int) (err error)"},
+ {"FcntlFlock", Func, 3, "func(fd uintptr, cmd int, lk *Flock_t) error"},
+ {"FdSet", Type, 0, ""},
+ {"FdSet.Bits", Field, 0, ""},
+ {"FdSet.X__fds_bits", Field, 0, ""},
+ {"Fdatasync", Func, 0, "func(fd int) (err error)"},
+ {"FileNotifyInformation", Type, 0, ""},
+ {"FileNotifyInformation.Action", Field, 0, ""},
+ {"FileNotifyInformation.FileName", Field, 0, ""},
+ {"FileNotifyInformation.FileNameLength", Field, 0, ""},
+ {"FileNotifyInformation.NextEntryOffset", Field, 0, ""},
+ {"Filetime", Type, 0, ""},
+ {"Filetime.HighDateTime", Field, 0, ""},
+ {"Filetime.LowDateTime", Field, 0, ""},
+ {"FindClose", Func, 0, ""},
+ {"FindFirstFile", Func, 0, ""},
+ {"FindNextFile", Func, 0, ""},
+ {"Flock", Func, 0, "func(fd int, how int) (err error)"},
+ {"Flock_t", Type, 0, ""},
+ {"Flock_t.Len", Field, 0, ""},
+ {"Flock_t.Pad_cgo_0", Field, 0, ""},
+ {"Flock_t.Pad_cgo_1", Field, 3, ""},
+ {"Flock_t.Pid", Field, 0, ""},
+ {"Flock_t.Start", Field, 0, ""},
+ {"Flock_t.Sysid", Field, 0, ""},
+ {"Flock_t.Type", Field, 0, ""},
+ {"Flock_t.Whence", Field, 0, ""},
+ {"FlushBpf", Func, 0, ""},
+ {"FlushFileBuffers", Func, 0, ""},
+ {"FlushViewOfFile", Func, 0, ""},
+ {"ForkExec", Func, 0, "func(argv0 string, argv []string, attr *ProcAttr) (pid int, err error)"},
+ {"ForkLock", Var, 0, ""},
+ {"FormatMessage", Func, 0, ""},
+ {"Fpathconf", Func, 0, ""},
+ {"FreeAddrInfoW", Func, 1, ""},
+ {"FreeEnvironmentStrings", Func, 0, ""},
+ {"FreeLibrary", Func, 0, ""},
+ {"Fsid", Type, 0, ""},
+ {"Fsid.Val", Field, 0, ""},
+ {"Fsid.X__fsid_val", Field, 2, ""},
+ {"Fsid.X__val", Field, 0, ""},
+ {"Fstat", Func, 0, "func(fd int, stat *Stat_t) (err error)"},
+ {"Fstatat", Func, 12, ""},
+ {"Fstatfs", Func, 0, "func(fd int, buf *Statfs_t) (err error)"},
+ {"Fstore_t", Type, 0, ""},
+ {"Fstore_t.Bytesalloc", Field, 0, ""},
+ {"Fstore_t.Flags", Field, 0, ""},
+ {"Fstore_t.Length", Field, 0, ""},
+ {"Fstore_t.Offset", Field, 0, ""},
+ {"Fstore_t.Posmode", Field, 0, ""},
+ {"Fsync", Func, 0, "func(fd int) (err error)"},
+ {"Ftruncate", Func, 0, "func(fd int, length int64) (err error)"},
+ {"FullPath", Func, 4, ""},
+ {"Futimes", Func, 0, "func(fd int, tv []Timeval) (err error)"},
+ {"Futimesat", Func, 0, "func(dirfd int, path string, tv []Timeval) (err error)"},
+ {"GENERIC_ALL", Const, 0, ""},
+ {"GENERIC_EXECUTE", Const, 0, ""},
+ {"GENERIC_READ", Const, 0, ""},
+ {"GENERIC_WRITE", Const, 0, ""},
+ {"GUID", Type, 1, ""},
+ {"GUID.Data1", Field, 1, ""},
+ {"GUID.Data2", Field, 1, ""},
+ {"GUID.Data3", Field, 1, ""},
+ {"GUID.Data4", Field, 1, ""},
+ {"GetAcceptExSockaddrs", Func, 0, ""},
+ {"GetAdaptersInfo", Func, 0, ""},
+ {"GetAddrInfoW", Func, 1, ""},
+ {"GetCommandLine", Func, 0, ""},
+ {"GetComputerName", Func, 0, ""},
+ {"GetConsoleMode", Func, 1, ""},
+ {"GetCurrentDirectory", Func, 0, ""},
+ {"GetCurrentProcess", Func, 0, ""},
+ {"GetEnvironmentStrings", Func, 0, ""},
+ {"GetEnvironmentVariable", Func, 0, ""},
+ {"GetExitCodeProcess", Func, 0, ""},
+ {"GetFileAttributes", Func, 0, ""},
+ {"GetFileAttributesEx", Func, 0, ""},
+ {"GetFileExInfoStandard", Const, 0, ""},
+ {"GetFileExMaxInfoLevel", Const, 0, ""},
+ {"GetFileInformationByHandle", Func, 0, ""},
+ {"GetFileType", Func, 0, ""},
+ {"GetFullPathName", Func, 0, ""},
+ {"GetHostByName", Func, 0, ""},
+ {"GetIfEntry", Func, 0, ""},
+ {"GetLastError", Func, 0, ""},
+ {"GetLengthSid", Func, 0, ""},
+ {"GetLongPathName", Func, 0, ""},
+ {"GetProcAddress", Func, 0, ""},
+ {"GetProcessTimes", Func, 0, ""},
+ {"GetProtoByName", Func, 0, ""},
+ {"GetQueuedCompletionStatus", Func, 0, ""},
+ {"GetServByName", Func, 0, ""},
+ {"GetShortPathName", Func, 0, ""},
+ {"GetStartupInfo", Func, 0, ""},
+ {"GetStdHandle", Func, 0, ""},
+ {"GetSystemTimeAsFileTime", Func, 0, ""},
+ {"GetTempPath", Func, 0, ""},
+ {"GetTimeZoneInformation", Func, 0, ""},
+ {"GetTokenInformation", Func, 0, ""},
+ {"GetUserNameEx", Func, 0, ""},
+ {"GetUserProfileDirectory", Func, 0, ""},
+ {"GetVersion", Func, 0, ""},
+ {"Getcwd", Func, 0, "func(buf []byte) (n int, err error)"},
+ {"Getdents", Func, 0, "func(fd int, buf []byte) (n int, err error)"},
+ {"Getdirentries", Func, 0, ""},
+ {"Getdtablesize", Func, 0, ""},
+ {"Getegid", Func, 0, "func() (egid int)"},
+ {"Getenv", Func, 0, "func(key string) (value string, found bool)"},
+ {"Geteuid", Func, 0, "func() (euid int)"},
+ {"Getfsstat", Func, 0, ""},
+ {"Getgid", Func, 0, "func() (gid int)"},
+ {"Getgroups", Func, 0, "func() (gids []int, err error)"},
+ {"Getpagesize", Func, 0, "func() int"},
+ {"Getpeername", Func, 0, "func(fd int) (sa Sockaddr, err error)"},
+ {"Getpgid", Func, 0, "func(pid int) (pgid int, err error)"},
+ {"Getpgrp", Func, 0, "func() (pid int)"},
+ {"Getpid", Func, 0, "func() (pid int)"},
+ {"Getppid", Func, 0, "func() (ppid int)"},
+ {"Getpriority", Func, 0, "func(which int, who int) (prio int, err error)"},
+ {"Getrlimit", Func, 0, "func(resource int, rlim *Rlimit) (err error)"},
+ {"Getrusage", Func, 0, "func(who int, rusage *Rusage) (err error)"},
+ {"Getsid", Func, 0, ""},
+ {"Getsockname", Func, 0, "func(fd int) (sa Sockaddr, err error)"},
+ {"Getsockopt", Func, 1, ""},
+ {"GetsockoptByte", Func, 0, ""},
+ {"GetsockoptICMPv6Filter", Func, 2, "func(fd int, level int, opt int) (*ICMPv6Filter, error)"},
+ {"GetsockoptIPMreq", Func, 0, "func(fd int, level int, opt int) (*IPMreq, error)"},
+ {"GetsockoptIPMreqn", Func, 0, "func(fd int, level int, opt int) (*IPMreqn, error)"},
+ {"GetsockoptIPv6MTUInfo", Func, 2, "func(fd int, level int, opt int) (*IPv6MTUInfo, error)"},
+ {"GetsockoptIPv6Mreq", Func, 0, "func(fd int, level int, opt int) (*IPv6Mreq, error)"},
+ {"GetsockoptInet4Addr", Func, 0, "func(fd int, level int, opt int) (value [4]byte, err error)"},
+ {"GetsockoptInt", Func, 0, "func(fd int, level int, opt int) (value int, err error)"},
+ {"GetsockoptUcred", Func, 1, "func(fd int, level int, opt int) (*Ucred, error)"},
+ {"Gettid", Func, 0, "func() (tid int)"},
+ {"Gettimeofday", Func, 0, "func(tv *Timeval) (err error)"},
+ {"Getuid", Func, 0, "func() (uid int)"},
+ {"Getwd", Func, 0, "func() (wd string, err error)"},
+ {"Getxattr", Func, 1, "func(path string, attr string, dest []byte) (sz int, err error)"},
+ {"HANDLE_FLAG_INHERIT", Const, 0, ""},
+ {"HKEY_CLASSES_ROOT", Const, 0, ""},
+ {"HKEY_CURRENT_CONFIG", Const, 0, ""},
+ {"HKEY_CURRENT_USER", Const, 0, ""},
+ {"HKEY_DYN_DATA", Const, 0, ""},
+ {"HKEY_LOCAL_MACHINE", Const, 0, ""},
+ {"HKEY_PERFORMANCE_DATA", Const, 0, ""},
+ {"HKEY_USERS", Const, 0, ""},
+ {"HUPCL", Const, 0, ""},
+ {"Handle", Type, 0, ""},
+ {"Hostent", Type, 0, ""},
+ {"Hostent.AddrList", Field, 0, ""},
+ {"Hostent.AddrType", Field, 0, ""},
+ {"Hostent.Aliases", Field, 0, ""},
+ {"Hostent.Length", Field, 0, ""},
+ {"Hostent.Name", Field, 0, ""},
+ {"ICANON", Const, 0, ""},
+ {"ICMP6_FILTER", Const, 2, ""},
+ {"ICMPV6_FILTER", Const, 2, ""},
+ {"ICMPv6Filter", Type, 2, ""},
+ {"ICMPv6Filter.Data", Field, 2, ""},
+ {"ICMPv6Filter.Filt", Field, 2, ""},
+ {"ICRNL", Const, 0, ""},
+ {"IEXTEN", Const, 0, ""},
+ {"IFAN_ARRIVAL", Const, 1, ""},
+ {"IFAN_DEPARTURE", Const, 1, ""},
+ {"IFA_ADDRESS", Const, 0, ""},
+ {"IFA_ANYCAST", Const, 0, ""},
+ {"IFA_BROADCAST", Const, 0, ""},
+ {"IFA_CACHEINFO", Const, 0, ""},
+ {"IFA_F_DADFAILED", Const, 0, ""},
+ {"IFA_F_DEPRECATED", Const, 0, ""},
+ {"IFA_F_HOMEADDRESS", Const, 0, ""},
+ {"IFA_F_NODAD", Const, 0, ""},
+ {"IFA_F_OPTIMISTIC", Const, 0, ""},
+ {"IFA_F_PERMANENT", Const, 0, ""},
+ {"IFA_F_SECONDARY", Const, 0, ""},
+ {"IFA_F_TEMPORARY", Const, 0, ""},
+ {"IFA_F_TENTATIVE", Const, 0, ""},
+ {"IFA_LABEL", Const, 0, ""},
+ {"IFA_LOCAL", Const, 0, ""},
+ {"IFA_MAX", Const, 0, ""},
+ {"IFA_MULTICAST", Const, 0, ""},
+ {"IFA_ROUTE", Const, 1, ""},
+ {"IFA_UNSPEC", Const, 0, ""},
+ {"IFF_ALLMULTI", Const, 0, ""},
+ {"IFF_ALTPHYS", Const, 0, ""},
+ {"IFF_AUTOMEDIA", Const, 0, ""},
+ {"IFF_BROADCAST", Const, 0, ""},
+ {"IFF_CANTCHANGE", Const, 0, ""},
+ {"IFF_CANTCONFIG", Const, 1, ""},
+ {"IFF_DEBUG", Const, 0, ""},
+ {"IFF_DRV_OACTIVE", Const, 0, ""},
+ {"IFF_DRV_RUNNING", Const, 0, ""},
+ {"IFF_DYING", Const, 0, ""},
+ {"IFF_DYNAMIC", Const, 0, ""},
+ {"IFF_LINK0", Const, 0, ""},
+ {"IFF_LINK1", Const, 0, ""},
+ {"IFF_LINK2", Const, 0, ""},
+ {"IFF_LOOPBACK", Const, 0, ""},
+ {"IFF_MASTER", Const, 0, ""},
+ {"IFF_MONITOR", Const, 0, ""},
+ {"IFF_MULTICAST", Const, 0, ""},
+ {"IFF_NOARP", Const, 0, ""},
+ {"IFF_NOTRAILERS", Const, 0, ""},
+ {"IFF_NO_PI", Const, 0, ""},
+ {"IFF_OACTIVE", Const, 0, ""},
+ {"IFF_ONE_QUEUE", Const, 0, ""},
+ {"IFF_POINTOPOINT", Const, 0, ""},
+ {"IFF_POINTTOPOINT", Const, 0, ""},
+ {"IFF_PORTSEL", Const, 0, ""},
+ {"IFF_PPROMISC", Const, 0, ""},
+ {"IFF_PROMISC", Const, 0, ""},
+ {"IFF_RENAMING", Const, 0, ""},
+ {"IFF_RUNNING", Const, 0, ""},
+ {"IFF_SIMPLEX", Const, 0, ""},
+ {"IFF_SLAVE", Const, 0, ""},
+ {"IFF_SMART", Const, 0, ""},
+ {"IFF_STATICARP", Const, 0, ""},
+ {"IFF_TAP", Const, 0, ""},
+ {"IFF_TUN", Const, 0, ""},
+ {"IFF_TUN_EXCL", Const, 0, ""},
+ {"IFF_UP", Const, 0, ""},
+ {"IFF_VNET_HDR", Const, 0, ""},
+ {"IFLA_ADDRESS", Const, 0, ""},
+ {"IFLA_BROADCAST", Const, 0, ""},
+ {"IFLA_COST", Const, 0, ""},
+ {"IFLA_IFALIAS", Const, 0, ""},
+ {"IFLA_IFNAME", Const, 0, ""},
+ {"IFLA_LINK", Const, 0, ""},
+ {"IFLA_LINKINFO", Const, 0, ""},
+ {"IFLA_LINKMODE", Const, 0, ""},
+ {"IFLA_MAP", Const, 0, ""},
+ {"IFLA_MASTER", Const, 0, ""},
+ {"IFLA_MAX", Const, 0, ""},
+ {"IFLA_MTU", Const, 0, ""},
+ {"IFLA_NET_NS_PID", Const, 0, ""},
+ {"IFLA_OPERSTATE", Const, 0, ""},
+ {"IFLA_PRIORITY", Const, 0, ""},
+ {"IFLA_PROTINFO", Const, 0, ""},
+ {"IFLA_QDISC", Const, 0, ""},
+ {"IFLA_STATS", Const, 0, ""},
+ {"IFLA_TXQLEN", Const, 0, ""},
+ {"IFLA_UNSPEC", Const, 0, ""},
+ {"IFLA_WEIGHT", Const, 0, ""},
+ {"IFLA_WIRELESS", Const, 0, ""},
+ {"IFNAMSIZ", Const, 0, ""},
+ {"IFT_1822", Const, 0, ""},
+ {"IFT_A12MPPSWITCH", Const, 0, ""},
+ {"IFT_AAL2", Const, 0, ""},
+ {"IFT_AAL5", Const, 0, ""},
+ {"IFT_ADSL", Const, 0, ""},
+ {"IFT_AFLANE8023", Const, 0, ""},
+ {"IFT_AFLANE8025", Const, 0, ""},
+ {"IFT_ARAP", Const, 0, ""},
+ {"IFT_ARCNET", Const, 0, ""},
+ {"IFT_ARCNETPLUS", Const, 0, ""},
+ {"IFT_ASYNC", Const, 0, ""},
+ {"IFT_ATM", Const, 0, ""},
+ {"IFT_ATMDXI", Const, 0, ""},
+ {"IFT_ATMFUNI", Const, 0, ""},
+ {"IFT_ATMIMA", Const, 0, ""},
+ {"IFT_ATMLOGICAL", Const, 0, ""},
+ {"IFT_ATMRADIO", Const, 0, ""},
+ {"IFT_ATMSUBINTERFACE", Const, 0, ""},
+ {"IFT_ATMVCIENDPT", Const, 0, ""},
+ {"IFT_ATMVIRTUAL", Const, 0, ""},
+ {"IFT_BGPPOLICYACCOUNTING", Const, 0, ""},
+ {"IFT_BLUETOOTH", Const, 1, ""},
+ {"IFT_BRIDGE", Const, 0, ""},
+ {"IFT_BSC", Const, 0, ""},
+ {"IFT_CARP", Const, 0, ""},
+ {"IFT_CCTEMUL", Const, 0, ""},
+ {"IFT_CELLULAR", Const, 0, ""},
+ {"IFT_CEPT", Const, 0, ""},
+ {"IFT_CES", Const, 0, ""},
+ {"IFT_CHANNEL", Const, 0, ""},
+ {"IFT_CNR", Const, 0, ""},
+ {"IFT_COFFEE", Const, 0, ""},
+ {"IFT_COMPOSITELINK", Const, 0, ""},
+ {"IFT_DCN", Const, 0, ""},
+ {"IFT_DIGITALPOWERLINE", Const, 0, ""},
+ {"IFT_DIGITALWRAPPEROVERHEADCHANNEL", Const, 0, ""},
+ {"IFT_DLSW", Const, 0, ""},
+ {"IFT_DOCSCABLEDOWNSTREAM", Const, 0, ""},
+ {"IFT_DOCSCABLEMACLAYER", Const, 0, ""},
+ {"IFT_DOCSCABLEUPSTREAM", Const, 0, ""},
+ {"IFT_DOCSCABLEUPSTREAMCHANNEL", Const, 1, ""},
+ {"IFT_DS0", Const, 0, ""},
+ {"IFT_DS0BUNDLE", Const, 0, ""},
+ {"IFT_DS1FDL", Const, 0, ""},
+ {"IFT_DS3", Const, 0, ""},
+ {"IFT_DTM", Const, 0, ""},
+ {"IFT_DUMMY", Const, 1, ""},
+ {"IFT_DVBASILN", Const, 0, ""},
+ {"IFT_DVBASIOUT", Const, 0, ""},
+ {"IFT_DVBRCCDOWNSTREAM", Const, 0, ""},
+ {"IFT_DVBRCCMACLAYER", Const, 0, ""},
+ {"IFT_DVBRCCUPSTREAM", Const, 0, ""},
+ {"IFT_ECONET", Const, 1, ""},
+ {"IFT_ENC", Const, 0, ""},
+ {"IFT_EON", Const, 0, ""},
+ {"IFT_EPLRS", Const, 0, ""},
+ {"IFT_ESCON", Const, 0, ""},
+ {"IFT_ETHER", Const, 0, ""},
+ {"IFT_FAITH", Const, 0, ""},
+ {"IFT_FAST", Const, 0, ""},
+ {"IFT_FASTETHER", Const, 0, ""},
+ {"IFT_FASTETHERFX", Const, 0, ""},
+ {"IFT_FDDI", Const, 0, ""},
+ {"IFT_FIBRECHANNEL", Const, 0, ""},
+ {"IFT_FRAMERELAYINTERCONNECT", Const, 0, ""},
+ {"IFT_FRAMERELAYMPI", Const, 0, ""},
+ {"IFT_FRDLCIENDPT", Const, 0, ""},
+ {"IFT_FRELAY", Const, 0, ""},
+ {"IFT_FRELAYDCE", Const, 0, ""},
+ {"IFT_FRF16MFRBUNDLE", Const, 0, ""},
+ {"IFT_FRFORWARD", Const, 0, ""},
+ {"IFT_G703AT2MB", Const, 0, ""},
+ {"IFT_G703AT64K", Const, 0, ""},
+ {"IFT_GIF", Const, 0, ""},
+ {"IFT_GIGABITETHERNET", Const, 0, ""},
+ {"IFT_GR303IDT", Const, 0, ""},
+ {"IFT_GR303RDT", Const, 0, ""},
+ {"IFT_H323GATEKEEPER", Const, 0, ""},
+ {"IFT_H323PROXY", Const, 0, ""},
+ {"IFT_HDH1822", Const, 0, ""},
+ {"IFT_HDLC", Const, 0, ""},
+ {"IFT_HDSL2", Const, 0, ""},
+ {"IFT_HIPERLAN2", Const, 0, ""},
+ {"IFT_HIPPI", Const, 0, ""},
+ {"IFT_HIPPIINTERFACE", Const, 0, ""},
+ {"IFT_HOSTPAD", Const, 0, ""},
+ {"IFT_HSSI", Const, 0, ""},
+ {"IFT_HY", Const, 0, ""},
+ {"IFT_IBM370PARCHAN", Const, 0, ""},
+ {"IFT_IDSL", Const, 0, ""},
+ {"IFT_IEEE1394", Const, 0, ""},
+ {"IFT_IEEE80211", Const, 0, ""},
+ {"IFT_IEEE80212", Const, 0, ""},
+ {"IFT_IEEE8023ADLAG", Const, 0, ""},
+ {"IFT_IFGSN", Const, 0, ""},
+ {"IFT_IMT", Const, 0, ""},
+ {"IFT_INFINIBAND", Const, 1, ""},
+ {"IFT_INTERLEAVE", Const, 0, ""},
+ {"IFT_IP", Const, 0, ""},
+ {"IFT_IPFORWARD", Const, 0, ""},
+ {"IFT_IPOVERATM", Const, 0, ""},
+ {"IFT_IPOVERCDLC", Const, 0, ""},
+ {"IFT_IPOVERCLAW", Const, 0, ""},
+ {"IFT_IPSWITCH", Const, 0, ""},
+ {"IFT_IPXIP", Const, 0, ""},
+ {"IFT_ISDN", Const, 0, ""},
+ {"IFT_ISDNBASIC", Const, 0, ""},
+ {"IFT_ISDNPRIMARY", Const, 0, ""},
+ {"IFT_ISDNS", Const, 0, ""},
+ {"IFT_ISDNU", Const, 0, ""},
+ {"IFT_ISO88022LLC", Const, 0, ""},
+ {"IFT_ISO88023", Const, 0, ""},
+ {"IFT_ISO88024", Const, 0, ""},
+ {"IFT_ISO88025", Const, 0, ""},
+ {"IFT_ISO88025CRFPINT", Const, 0, ""},
+ {"IFT_ISO88025DTR", Const, 0, ""},
+ {"IFT_ISO88025FIBER", Const, 0, ""},
+ {"IFT_ISO88026", Const, 0, ""},
+ {"IFT_ISUP", Const, 0, ""},
+ {"IFT_L2VLAN", Const, 0, ""},
+ {"IFT_L3IPVLAN", Const, 0, ""},
+ {"IFT_L3IPXVLAN", Const, 0, ""},
+ {"IFT_LAPB", Const, 0, ""},
+ {"IFT_LAPD", Const, 0, ""},
+ {"IFT_LAPF", Const, 0, ""},
+ {"IFT_LINEGROUP", Const, 1, ""},
+ {"IFT_LOCALTALK", Const, 0, ""},
+ {"IFT_LOOP", Const, 0, ""},
+ {"IFT_MEDIAMAILOVERIP", Const, 0, ""},
+ {"IFT_MFSIGLINK", Const, 0, ""},
+ {"IFT_MIOX25", Const, 0, ""},
+ {"IFT_MODEM", Const, 0, ""},
+ {"IFT_MPC", Const, 0, ""},
+ {"IFT_MPLS", Const, 0, ""},
+ {"IFT_MPLSTUNNEL", Const, 0, ""},
+ {"IFT_MSDSL", Const, 0, ""},
+ {"IFT_MVL", Const, 0, ""},
+ {"IFT_MYRINET", Const, 0, ""},
+ {"IFT_NFAS", Const, 0, ""},
+ {"IFT_NSIP", Const, 0, ""},
+ {"IFT_OPTICALCHANNEL", Const, 0, ""},
+ {"IFT_OPTICALTRANSPORT", Const, 0, ""},
+ {"IFT_OTHER", Const, 0, ""},
+ {"IFT_P10", Const, 0, ""},
+ {"IFT_P80", Const, 0, ""},
+ {"IFT_PARA", Const, 0, ""},
+ {"IFT_PDP", Const, 0, ""},
+ {"IFT_PFLOG", Const, 0, ""},
+ {"IFT_PFLOW", Const, 1, ""},
+ {"IFT_PFSYNC", Const, 0, ""},
+ {"IFT_PLC", Const, 0, ""},
+ {"IFT_PON155", Const, 1, ""},
+ {"IFT_PON622", Const, 1, ""},
+ {"IFT_POS", Const, 0, ""},
+ {"IFT_PPP", Const, 0, ""},
+ {"IFT_PPPMULTILINKBUNDLE", Const, 0, ""},
+ {"IFT_PROPATM", Const, 1, ""},
+ {"IFT_PROPBWAP2MP", Const, 0, ""},
+ {"IFT_PROPCNLS", Const, 0, ""},
+ {"IFT_PROPDOCSWIRELESSDOWNSTREAM", Const, 0, ""},
+ {"IFT_PROPDOCSWIRELESSMACLAYER", Const, 0, ""},
+ {"IFT_PROPDOCSWIRELESSUPSTREAM", Const, 0, ""},
+ {"IFT_PROPMUX", Const, 0, ""},
+ {"IFT_PROPVIRTUAL", Const, 0, ""},
+ {"IFT_PROPWIRELESSP2P", Const, 0, ""},
+ {"IFT_PTPSERIAL", Const, 0, ""},
+ {"IFT_PVC", Const, 0, ""},
+ {"IFT_Q2931", Const, 1, ""},
+ {"IFT_QLLC", Const, 0, ""},
+ {"IFT_RADIOMAC", Const, 0, ""},
+ {"IFT_RADSL", Const, 0, ""},
+ {"IFT_REACHDSL", Const, 0, ""},
+ {"IFT_RFC1483", Const, 0, ""},
+ {"IFT_RS232", Const, 0, ""},
+ {"IFT_RSRB", Const, 0, ""},
+ {"IFT_SDLC", Const, 0, ""},
+ {"IFT_SDSL", Const, 0, ""},
+ {"IFT_SHDSL", Const, 0, ""},
+ {"IFT_SIP", Const, 0, ""},
+ {"IFT_SIPSIG", Const, 1, ""},
+ {"IFT_SIPTG", Const, 1, ""},
+ {"IFT_SLIP", Const, 0, ""},
+ {"IFT_SMDSDXI", Const, 0, ""},
+ {"IFT_SMDSICIP", Const, 0, ""},
+ {"IFT_SONET", Const, 0, ""},
+ {"IFT_SONETOVERHEADCHANNEL", Const, 0, ""},
+ {"IFT_SONETPATH", Const, 0, ""},
+ {"IFT_SONETVT", Const, 0, ""},
+ {"IFT_SRP", Const, 0, ""},
+ {"IFT_SS7SIGLINK", Const, 0, ""},
+ {"IFT_STACKTOSTACK", Const, 0, ""},
+ {"IFT_STARLAN", Const, 0, ""},
+ {"IFT_STF", Const, 0, ""},
+ {"IFT_T1", Const, 0, ""},
+ {"IFT_TDLC", Const, 0, ""},
+ {"IFT_TELINK", Const, 1, ""},
+ {"IFT_TERMPAD", Const, 0, ""},
+ {"IFT_TR008", Const, 0, ""},
+ {"IFT_TRANSPHDLC", Const, 0, ""},
+ {"IFT_TUNNEL", Const, 0, ""},
+ {"IFT_ULTRA", Const, 0, ""},
+ {"IFT_USB", Const, 0, ""},
+ {"IFT_V11", Const, 0, ""},
+ {"IFT_V35", Const, 0, ""},
+ {"IFT_V36", Const, 0, ""},
+ {"IFT_V37", Const, 0, ""},
+ {"IFT_VDSL", Const, 0, ""},
+ {"IFT_VIRTUALIPADDRESS", Const, 0, ""},
+ {"IFT_VIRTUALTG", Const, 1, ""},
+ {"IFT_VOICEDID", Const, 1, ""},
+ {"IFT_VOICEEM", Const, 0, ""},
+ {"IFT_VOICEEMFGD", Const, 1, ""},
+ {"IFT_VOICEENCAP", Const, 0, ""},
+ {"IFT_VOICEFGDEANA", Const, 1, ""},
+ {"IFT_VOICEFXO", Const, 0, ""},
+ {"IFT_VOICEFXS", Const, 0, ""},
+ {"IFT_VOICEOVERATM", Const, 0, ""},
+ {"IFT_VOICEOVERCABLE", Const, 1, ""},
+ {"IFT_VOICEOVERFRAMERELAY", Const, 0, ""},
+ {"IFT_VOICEOVERIP", Const, 0, ""},
+ {"IFT_X213", Const, 0, ""},
+ {"IFT_X25", Const, 0, ""},
+ {"IFT_X25DDN", Const, 0, ""},
+ {"IFT_X25HUNTGROUP", Const, 0, ""},
+ {"IFT_X25MLP", Const, 0, ""},
+ {"IFT_X25PLE", Const, 0, ""},
+ {"IFT_XETHER", Const, 0, ""},
+ {"IGNBRK", Const, 0, ""},
+ {"IGNCR", Const, 0, ""},
+ {"IGNORE", Const, 0, ""},
+ {"IGNPAR", Const, 0, ""},
+ {"IMAXBEL", Const, 0, ""},
+ {"INFINITE", Const, 0, ""},
+ {"INLCR", Const, 0, ""},
+ {"INPCK", Const, 0, ""},
+ {"INVALID_FILE_ATTRIBUTES", Const, 0, ""},
+ {"IN_ACCESS", Const, 0, ""},
+ {"IN_ALL_EVENTS", Const, 0, ""},
+ {"IN_ATTRIB", Const, 0, ""},
+ {"IN_CLASSA_HOST", Const, 0, ""},
+ {"IN_CLASSA_MAX", Const, 0, ""},
+ {"IN_CLASSA_NET", Const, 0, ""},
+ {"IN_CLASSA_NSHIFT", Const, 0, ""},
+ {"IN_CLASSB_HOST", Const, 0, ""},
+ {"IN_CLASSB_MAX", Const, 0, ""},
+ {"IN_CLASSB_NET", Const, 0, ""},
+ {"IN_CLASSB_NSHIFT", Const, 0, ""},
+ {"IN_CLASSC_HOST", Const, 0, ""},
+ {"IN_CLASSC_NET", Const, 0, ""},
+ {"IN_CLASSC_NSHIFT", Const, 0, ""},
+ {"IN_CLASSD_HOST", Const, 0, ""},
+ {"IN_CLASSD_NET", Const, 0, ""},
+ {"IN_CLASSD_NSHIFT", Const, 0, ""},
+ {"IN_CLOEXEC", Const, 0, ""},
+ {"IN_CLOSE", Const, 0, ""},
+ {"IN_CLOSE_NOWRITE", Const, 0, ""},
+ {"IN_CLOSE_WRITE", Const, 0, ""},
+ {"IN_CREATE", Const, 0, ""},
+ {"IN_DELETE", Const, 0, ""},
+ {"IN_DELETE_SELF", Const, 0, ""},
+ {"IN_DONT_FOLLOW", Const, 0, ""},
+ {"IN_EXCL_UNLINK", Const, 0, ""},
+ {"IN_IGNORED", Const, 0, ""},
+ {"IN_ISDIR", Const, 0, ""},
+ {"IN_LINKLOCALNETNUM", Const, 0, ""},
+ {"IN_LOOPBACKNET", Const, 0, ""},
+ {"IN_MASK_ADD", Const, 0, ""},
+ {"IN_MODIFY", Const, 0, ""},
+ {"IN_MOVE", Const, 0, ""},
+ {"IN_MOVED_FROM", Const, 0, ""},
+ {"IN_MOVED_TO", Const, 0, ""},
+ {"IN_MOVE_SELF", Const, 0, ""},
+ {"IN_NONBLOCK", Const, 0, ""},
+ {"IN_ONESHOT", Const, 0, ""},
+ {"IN_ONLYDIR", Const, 0, ""},
+ {"IN_OPEN", Const, 0, ""},
+ {"IN_Q_OVERFLOW", Const, 0, ""},
+ {"IN_RFC3021_HOST", Const, 1, ""},
+ {"IN_RFC3021_MASK", Const, 1, ""},
+ {"IN_RFC3021_NET", Const, 1, ""},
+ {"IN_RFC3021_NSHIFT", Const, 1, ""},
+ {"IN_UNMOUNT", Const, 0, ""},
+ {"IOC_IN", Const, 1, ""},
+ {"IOC_INOUT", Const, 1, ""},
+ {"IOC_OUT", Const, 1, ""},
+ {"IOC_VENDOR", Const, 3, ""},
+ {"IOC_WS2", Const, 1, ""},
+ {"IO_REPARSE_TAG_SYMLINK", Const, 4, ""},
+ {"IPMreq", Type, 0, ""},
+ {"IPMreq.Interface", Field, 0, ""},
+ {"IPMreq.Multiaddr", Field, 0, ""},
+ {"IPMreqn", Type, 0, ""},
+ {"IPMreqn.Address", Field, 0, ""},
+ {"IPMreqn.Ifindex", Field, 0, ""},
+ {"IPMreqn.Multiaddr", Field, 0, ""},
+ {"IPPROTO_3PC", Const, 0, ""},
+ {"IPPROTO_ADFS", Const, 0, ""},
+ {"IPPROTO_AH", Const, 0, ""},
+ {"IPPROTO_AHIP", Const, 0, ""},
+ {"IPPROTO_APES", Const, 0, ""},
+ {"IPPROTO_ARGUS", Const, 0, ""},
+ {"IPPROTO_AX25", Const, 0, ""},
+ {"IPPROTO_BHA", Const, 0, ""},
+ {"IPPROTO_BLT", Const, 0, ""},
+ {"IPPROTO_BRSATMON", Const, 0, ""},
+ {"IPPROTO_CARP", Const, 0, ""},
+ {"IPPROTO_CFTP", Const, 0, ""},
+ {"IPPROTO_CHAOS", Const, 0, ""},
+ {"IPPROTO_CMTP", Const, 0, ""},
+ {"IPPROTO_COMP", Const, 0, ""},
+ {"IPPROTO_CPHB", Const, 0, ""},
+ {"IPPROTO_CPNX", Const, 0, ""},
+ {"IPPROTO_DCCP", Const, 0, ""},
+ {"IPPROTO_DDP", Const, 0, ""},
+ {"IPPROTO_DGP", Const, 0, ""},
+ {"IPPROTO_DIVERT", Const, 0, ""},
+ {"IPPROTO_DIVERT_INIT", Const, 3, ""},
+ {"IPPROTO_DIVERT_RESP", Const, 3, ""},
+ {"IPPROTO_DONE", Const, 0, ""},
+ {"IPPROTO_DSTOPTS", Const, 0, ""},
+ {"IPPROTO_EGP", Const, 0, ""},
+ {"IPPROTO_EMCON", Const, 0, ""},
+ {"IPPROTO_ENCAP", Const, 0, ""},
+ {"IPPROTO_EON", Const, 0, ""},
+ {"IPPROTO_ESP", Const, 0, ""},
+ {"IPPROTO_ETHERIP", Const, 0, ""},
+ {"IPPROTO_FRAGMENT", Const, 0, ""},
+ {"IPPROTO_GGP", Const, 0, ""},
+ {"IPPROTO_GMTP", Const, 0, ""},
+ {"IPPROTO_GRE", Const, 0, ""},
+ {"IPPROTO_HELLO", Const, 0, ""},
+ {"IPPROTO_HMP", Const, 0, ""},
+ {"IPPROTO_HOPOPTS", Const, 0, ""},
+ {"IPPROTO_ICMP", Const, 0, ""},
+ {"IPPROTO_ICMPV6", Const, 0, ""},
+ {"IPPROTO_IDP", Const, 0, ""},
+ {"IPPROTO_IDPR", Const, 0, ""},
+ {"IPPROTO_IDRP", Const, 0, ""},
+ {"IPPROTO_IGMP", Const, 0, ""},
+ {"IPPROTO_IGP", Const, 0, ""},
+ {"IPPROTO_IGRP", Const, 0, ""},
+ {"IPPROTO_IL", Const, 0, ""},
+ {"IPPROTO_INLSP", Const, 0, ""},
+ {"IPPROTO_INP", Const, 0, ""},
+ {"IPPROTO_IP", Const, 0, ""},
+ {"IPPROTO_IPCOMP", Const, 0, ""},
+ {"IPPROTO_IPCV", Const, 0, ""},
+ {"IPPROTO_IPEIP", Const, 0, ""},
+ {"IPPROTO_IPIP", Const, 0, ""},
+ {"IPPROTO_IPPC", Const, 0, ""},
+ {"IPPROTO_IPV4", Const, 0, ""},
+ {"IPPROTO_IPV6", Const, 0, ""},
+ {"IPPROTO_IPV6_ICMP", Const, 1, ""},
+ {"IPPROTO_IRTP", Const, 0, ""},
+ {"IPPROTO_KRYPTOLAN", Const, 0, ""},
+ {"IPPROTO_LARP", Const, 0, ""},
+ {"IPPROTO_LEAF1", Const, 0, ""},
+ {"IPPROTO_LEAF2", Const, 0, ""},
+ {"IPPROTO_MAX", Const, 0, ""},
+ {"IPPROTO_MAXID", Const, 0, ""},
+ {"IPPROTO_MEAS", Const, 0, ""},
+ {"IPPROTO_MH", Const, 1, ""},
+ {"IPPROTO_MHRP", Const, 0, ""},
+ {"IPPROTO_MICP", Const, 0, ""},
+ {"IPPROTO_MOBILE", Const, 0, ""},
+ {"IPPROTO_MPLS", Const, 1, ""},
+ {"IPPROTO_MTP", Const, 0, ""},
+ {"IPPROTO_MUX", Const, 0, ""},
+ {"IPPROTO_ND", Const, 0, ""},
+ {"IPPROTO_NHRP", Const, 0, ""},
+ {"IPPROTO_NONE", Const, 0, ""},
+ {"IPPROTO_NSP", Const, 0, ""},
+ {"IPPROTO_NVPII", Const, 0, ""},
+ {"IPPROTO_OLD_DIVERT", Const, 0, ""},
+ {"IPPROTO_OSPFIGP", Const, 0, ""},
+ {"IPPROTO_PFSYNC", Const, 0, ""},
+ {"IPPROTO_PGM", Const, 0, ""},
+ {"IPPROTO_PIGP", Const, 0, ""},
+ {"IPPROTO_PIM", Const, 0, ""},
+ {"IPPROTO_PRM", Const, 0, ""},
+ {"IPPROTO_PUP", Const, 0, ""},
+ {"IPPROTO_PVP", Const, 0, ""},
+ {"IPPROTO_RAW", Const, 0, ""},
+ {"IPPROTO_RCCMON", Const, 0, ""},
+ {"IPPROTO_RDP", Const, 0, ""},
+ {"IPPROTO_ROUTING", Const, 0, ""},
+ {"IPPROTO_RSVP", Const, 0, ""},
+ {"IPPROTO_RVD", Const, 0, ""},
+ {"IPPROTO_SATEXPAK", Const, 0, ""},
+ {"IPPROTO_SATMON", Const, 0, ""},
+ {"IPPROTO_SCCSP", Const, 0, ""},
+ {"IPPROTO_SCTP", Const, 0, ""},
+ {"IPPROTO_SDRP", Const, 0, ""},
+ {"IPPROTO_SEND", Const, 1, ""},
+ {"IPPROTO_SEP", Const, 0, ""},
+ {"IPPROTO_SKIP", Const, 0, ""},
+ {"IPPROTO_SPACER", Const, 0, ""},
+ {"IPPROTO_SRPC", Const, 0, ""},
+ {"IPPROTO_ST", Const, 0, ""},
+ {"IPPROTO_SVMTP", Const, 0, ""},
+ {"IPPROTO_SWIPE", Const, 0, ""},
+ {"IPPROTO_TCF", Const, 0, ""},
+ {"IPPROTO_TCP", Const, 0, ""},
+ {"IPPROTO_TLSP", Const, 0, ""},
+ {"IPPROTO_TP", Const, 0, ""},
+ {"IPPROTO_TPXX", Const, 0, ""},
+ {"IPPROTO_TRUNK1", Const, 0, ""},
+ {"IPPROTO_TRUNK2", Const, 0, ""},
+ {"IPPROTO_TTP", Const, 0, ""},
+ {"IPPROTO_UDP", Const, 0, ""},
+ {"IPPROTO_UDPLITE", Const, 0, ""},
+ {"IPPROTO_VINES", Const, 0, ""},
+ {"IPPROTO_VISA", Const, 0, ""},
+ {"IPPROTO_VMTP", Const, 0, ""},
+ {"IPPROTO_VRRP", Const, 1, ""},
+ {"IPPROTO_WBEXPAK", Const, 0, ""},
+ {"IPPROTO_WBMON", Const, 0, ""},
+ {"IPPROTO_WSN", Const, 0, ""},
+ {"IPPROTO_XNET", Const, 0, ""},
+ {"IPPROTO_XTP", Const, 0, ""},
+ {"IPV6_2292DSTOPTS", Const, 0, ""},
+ {"IPV6_2292HOPLIMIT", Const, 0, ""},
+ {"IPV6_2292HOPOPTS", Const, 0, ""},
+ {"IPV6_2292NEXTHOP", Const, 0, ""},
+ {"IPV6_2292PKTINFO", Const, 0, ""},
+ {"IPV6_2292PKTOPTIONS", Const, 0, ""},
+ {"IPV6_2292RTHDR", Const, 0, ""},
+ {"IPV6_ADDRFORM", Const, 0, ""},
+ {"IPV6_ADD_MEMBERSHIP", Const, 0, ""},
+ {"IPV6_AUTHHDR", Const, 0, ""},
+ {"IPV6_AUTH_LEVEL", Const, 1, ""},
+ {"IPV6_AUTOFLOWLABEL", Const, 0, ""},
+ {"IPV6_BINDANY", Const, 0, ""},
+ {"IPV6_BINDV6ONLY", Const, 0, ""},
+ {"IPV6_BOUND_IF", Const, 0, ""},
+ {"IPV6_CHECKSUM", Const, 0, ""},
+ {"IPV6_DEFAULT_MULTICAST_HOPS", Const, 0, ""},
+ {"IPV6_DEFAULT_MULTICAST_LOOP", Const, 0, ""},
+ {"IPV6_DEFHLIM", Const, 0, ""},
+ {"IPV6_DONTFRAG", Const, 0, ""},
+ {"IPV6_DROP_MEMBERSHIP", Const, 0, ""},
+ {"IPV6_DSTOPTS", Const, 0, ""},
+ {"IPV6_ESP_NETWORK_LEVEL", Const, 1, ""},
+ {"IPV6_ESP_TRANS_LEVEL", Const, 1, ""},
+ {"IPV6_FAITH", Const, 0, ""},
+ {"IPV6_FLOWINFO_MASK", Const, 0, ""},
+ {"IPV6_FLOWLABEL_MASK", Const, 0, ""},
+ {"IPV6_FRAGTTL", Const, 0, ""},
+ {"IPV6_FW_ADD", Const, 0, ""},
+ {"IPV6_FW_DEL", Const, 0, ""},
+ {"IPV6_FW_FLUSH", Const, 0, ""},
+ {"IPV6_FW_GET", Const, 0, ""},
+ {"IPV6_FW_ZERO", Const, 0, ""},
+ {"IPV6_HLIMDEC", Const, 0, ""},
+ {"IPV6_HOPLIMIT", Const, 0, ""},
+ {"IPV6_HOPOPTS", Const, 0, ""},
+ {"IPV6_IPCOMP_LEVEL", Const, 1, ""},
+ {"IPV6_IPSEC_POLICY", Const, 0, ""},
+ {"IPV6_JOIN_ANYCAST", Const, 0, ""},
+ {"IPV6_JOIN_GROUP", Const, 0, ""},
+ {"IPV6_LEAVE_ANYCAST", Const, 0, ""},
+ {"IPV6_LEAVE_GROUP", Const, 0, ""},
+ {"IPV6_MAXHLIM", Const, 0, ""},
+ {"IPV6_MAXOPTHDR", Const, 0, ""},
+ {"IPV6_MAXPACKET", Const, 0, ""},
+ {"IPV6_MAX_GROUP_SRC_FILTER", Const, 0, ""},
+ {"IPV6_MAX_MEMBERSHIPS", Const, 0, ""},
+ {"IPV6_MAX_SOCK_SRC_FILTER", Const, 0, ""},
+ {"IPV6_MIN_MEMBERSHIPS", Const, 0, ""},
+ {"IPV6_MMTU", Const, 0, ""},
+ {"IPV6_MSFILTER", Const, 0, ""},
+ {"IPV6_MTU", Const, 0, ""},
+ {"IPV6_MTU_DISCOVER", Const, 0, ""},
+ {"IPV6_MULTICAST_HOPS", Const, 0, ""},
+ {"IPV6_MULTICAST_IF", Const, 0, ""},
+ {"IPV6_MULTICAST_LOOP", Const, 0, ""},
+ {"IPV6_NEXTHOP", Const, 0, ""},
+ {"IPV6_OPTIONS", Const, 1, ""},
+ {"IPV6_PATHMTU", Const, 0, ""},
+ {"IPV6_PIPEX", Const, 1, ""},
+ {"IPV6_PKTINFO", Const, 0, ""},
+ {"IPV6_PMTUDISC_DO", Const, 0, ""},
+ {"IPV6_PMTUDISC_DONT", Const, 0, ""},
+ {"IPV6_PMTUDISC_PROBE", Const, 0, ""},
+ {"IPV6_PMTUDISC_WANT", Const, 0, ""},
+ {"IPV6_PORTRANGE", Const, 0, ""},
+ {"IPV6_PORTRANGE_DEFAULT", Const, 0, ""},
+ {"IPV6_PORTRANGE_HIGH", Const, 0, ""},
+ {"IPV6_PORTRANGE_LOW", Const, 0, ""},
+ {"IPV6_PREFER_TEMPADDR", Const, 0, ""},
+ {"IPV6_RECVDSTOPTS", Const, 0, ""},
+ {"IPV6_RECVDSTPORT", Const, 3, ""},
+ {"IPV6_RECVERR", Const, 0, ""},
+ {"IPV6_RECVHOPLIMIT", Const, 0, ""},
+ {"IPV6_RECVHOPOPTS", Const, 0, ""},
+ {"IPV6_RECVPATHMTU", Const, 0, ""},
+ {"IPV6_RECVPKTINFO", Const, 0, ""},
+ {"IPV6_RECVRTHDR", Const, 0, ""},
+ {"IPV6_RECVTCLASS", Const, 0, ""},
+ {"IPV6_ROUTER_ALERT", Const, 0, ""},
+ {"IPV6_RTABLE", Const, 1, ""},
+ {"IPV6_RTHDR", Const, 0, ""},
+ {"IPV6_RTHDRDSTOPTS", Const, 0, ""},
+ {"IPV6_RTHDR_LOOSE", Const, 0, ""},
+ {"IPV6_RTHDR_STRICT", Const, 0, ""},
+ {"IPV6_RTHDR_TYPE_0", Const, 0, ""},
+ {"IPV6_RXDSTOPTS", Const, 0, ""},
+ {"IPV6_RXHOPOPTS", Const, 0, ""},
+ {"IPV6_SOCKOPT_RESERVED1", Const, 0, ""},
+ {"IPV6_TCLASS", Const, 0, ""},
+ {"IPV6_UNICAST_HOPS", Const, 0, ""},
+ {"IPV6_USE_MIN_MTU", Const, 0, ""},
+ {"IPV6_V6ONLY", Const, 0, ""},
+ {"IPV6_VERSION", Const, 0, ""},
+ {"IPV6_VERSION_MASK", Const, 0, ""},
+ {"IPV6_XFRM_POLICY", Const, 0, ""},
+ {"IP_ADD_MEMBERSHIP", Const, 0, ""},
+ {"IP_ADD_SOURCE_MEMBERSHIP", Const, 0, ""},
+ {"IP_AUTH_LEVEL", Const, 1, ""},
+ {"IP_BINDANY", Const, 0, ""},
+ {"IP_BLOCK_SOURCE", Const, 0, ""},
+ {"IP_BOUND_IF", Const, 0, ""},
+ {"IP_DEFAULT_MULTICAST_LOOP", Const, 0, ""},
+ {"IP_DEFAULT_MULTICAST_TTL", Const, 0, ""},
+ {"IP_DF", Const, 0, ""},
+ {"IP_DIVERTFL", Const, 3, ""},
+ {"IP_DONTFRAG", Const, 0, ""},
+ {"IP_DROP_MEMBERSHIP", Const, 0, ""},
+ {"IP_DROP_SOURCE_MEMBERSHIP", Const, 0, ""},
+ {"IP_DUMMYNET3", Const, 0, ""},
+ {"IP_DUMMYNET_CONFIGURE", Const, 0, ""},
+ {"IP_DUMMYNET_DEL", Const, 0, ""},
+ {"IP_DUMMYNET_FLUSH", Const, 0, ""},
+ {"IP_DUMMYNET_GET", Const, 0, ""},
+ {"IP_EF", Const, 1, ""},
+ {"IP_ERRORMTU", Const, 1, ""},
+ {"IP_ESP_NETWORK_LEVEL", Const, 1, ""},
+ {"IP_ESP_TRANS_LEVEL", Const, 1, ""},
+ {"IP_FAITH", Const, 0, ""},
+ {"IP_FREEBIND", Const, 0, ""},
+ {"IP_FW3", Const, 0, ""},
+ {"IP_FW_ADD", Const, 0, ""},
+ {"IP_FW_DEL", Const, 0, ""},
+ {"IP_FW_FLUSH", Const, 0, ""},
+ {"IP_FW_GET", Const, 0, ""},
+ {"IP_FW_NAT_CFG", Const, 0, ""},
+ {"IP_FW_NAT_DEL", Const, 0, ""},
+ {"IP_FW_NAT_GET_CONFIG", Const, 0, ""},
+ {"IP_FW_NAT_GET_LOG", Const, 0, ""},
+ {"IP_FW_RESETLOG", Const, 0, ""},
+ {"IP_FW_TABLE_ADD", Const, 0, ""},
+ {"IP_FW_TABLE_DEL", Const, 0, ""},
+ {"IP_FW_TABLE_FLUSH", Const, 0, ""},
+ {"IP_FW_TABLE_GETSIZE", Const, 0, ""},
+ {"IP_FW_TABLE_LIST", Const, 0, ""},
+ {"IP_FW_ZERO", Const, 0, ""},
+ {"IP_HDRINCL", Const, 0, ""},
+ {"IP_IPCOMP_LEVEL", Const, 1, ""},
+ {"IP_IPSECFLOWINFO", Const, 1, ""},
+ {"IP_IPSEC_LOCAL_AUTH", Const, 1, ""},
+ {"IP_IPSEC_LOCAL_CRED", Const, 1, ""},
+ {"IP_IPSEC_LOCAL_ID", Const, 1, ""},
+ {"IP_IPSEC_POLICY", Const, 0, ""},
+ {"IP_IPSEC_REMOTE_AUTH", Const, 1, ""},
+ {"IP_IPSEC_REMOTE_CRED", Const, 1, ""},
+ {"IP_IPSEC_REMOTE_ID", Const, 1, ""},
+ {"IP_MAXPACKET", Const, 0, ""},
+ {"IP_MAX_GROUP_SRC_FILTER", Const, 0, ""},
+ {"IP_MAX_MEMBERSHIPS", Const, 0, ""},
+ {"IP_MAX_SOCK_MUTE_FILTER", Const, 0, ""},
+ {"IP_MAX_SOCK_SRC_FILTER", Const, 0, ""},
+ {"IP_MAX_SOURCE_FILTER", Const, 0, ""},
+ {"IP_MF", Const, 0, ""},
+ {"IP_MINFRAGSIZE", Const, 1, ""},
+ {"IP_MINTTL", Const, 0, ""},
+ {"IP_MIN_MEMBERSHIPS", Const, 0, ""},
+ {"IP_MSFILTER", Const, 0, ""},
+ {"IP_MSS", Const, 0, ""},
+ {"IP_MTU", Const, 0, ""},
+ {"IP_MTU_DISCOVER", Const, 0, ""},
+ {"IP_MULTICAST_IF", Const, 0, ""},
+ {"IP_MULTICAST_IFINDEX", Const, 0, ""},
+ {"IP_MULTICAST_LOOP", Const, 0, ""},
+ {"IP_MULTICAST_TTL", Const, 0, ""},
+ {"IP_MULTICAST_VIF", Const, 0, ""},
+ {"IP_NAT__XXX", Const, 0, ""},
+ {"IP_OFFMASK", Const, 0, ""},
+ {"IP_OLD_FW_ADD", Const, 0, ""},
+ {"IP_OLD_FW_DEL", Const, 0, ""},
+ {"IP_OLD_FW_FLUSH", Const, 0, ""},
+ {"IP_OLD_FW_GET", Const, 0, ""},
+ {"IP_OLD_FW_RESETLOG", Const, 0, ""},
+ {"IP_OLD_FW_ZERO", Const, 0, ""},
+ {"IP_ONESBCAST", Const, 0, ""},
+ {"IP_OPTIONS", Const, 0, ""},
+ {"IP_ORIGDSTADDR", Const, 0, ""},
+ {"IP_PASSSEC", Const, 0, ""},
+ {"IP_PIPEX", Const, 1, ""},
+ {"IP_PKTINFO", Const, 0, ""},
+ {"IP_PKTOPTIONS", Const, 0, ""},
+ {"IP_PMTUDISC", Const, 0, ""},
+ {"IP_PMTUDISC_DO", Const, 0, ""},
+ {"IP_PMTUDISC_DONT", Const, 0, ""},
+ {"IP_PMTUDISC_PROBE", Const, 0, ""},
+ {"IP_PMTUDISC_WANT", Const, 0, ""},
+ {"IP_PORTRANGE", Const, 0, ""},
+ {"IP_PORTRANGE_DEFAULT", Const, 0, ""},
+ {"IP_PORTRANGE_HIGH", Const, 0, ""},
+ {"IP_PORTRANGE_LOW", Const, 0, ""},
+ {"IP_RECVDSTADDR", Const, 0, ""},
+ {"IP_RECVDSTPORT", Const, 1, ""},
+ {"IP_RECVERR", Const, 0, ""},
+ {"IP_RECVIF", Const, 0, ""},
+ {"IP_RECVOPTS", Const, 0, ""},
+ {"IP_RECVORIGDSTADDR", Const, 0, ""},
+ {"IP_RECVPKTINFO", Const, 0, ""},
+ {"IP_RECVRETOPTS", Const, 0, ""},
+ {"IP_RECVRTABLE", Const, 1, ""},
+ {"IP_RECVTOS", Const, 0, ""},
+ {"IP_RECVTTL", Const, 0, ""},
+ {"IP_RETOPTS", Const, 0, ""},
+ {"IP_RF", Const, 0, ""},
+ {"IP_ROUTER_ALERT", Const, 0, ""},
+ {"IP_RSVP_OFF", Const, 0, ""},
+ {"IP_RSVP_ON", Const, 0, ""},
+ {"IP_RSVP_VIF_OFF", Const, 0, ""},
+ {"IP_RSVP_VIF_ON", Const, 0, ""},
+ {"IP_RTABLE", Const, 1, ""},
+ {"IP_SENDSRCADDR", Const, 0, ""},
+ {"IP_STRIPHDR", Const, 0, ""},
+ {"IP_TOS", Const, 0, ""},
+ {"IP_TRAFFIC_MGT_BACKGROUND", Const, 0, ""},
+ {"IP_TRANSPARENT", Const, 0, ""},
+ {"IP_TTL", Const, 0, ""},
+ {"IP_UNBLOCK_SOURCE", Const, 0, ""},
+ {"IP_XFRM_POLICY", Const, 0, ""},
+ {"IPv6MTUInfo", Type, 2, ""},
+ {"IPv6MTUInfo.Addr", Field, 2, ""},
+ {"IPv6MTUInfo.Mtu", Field, 2, ""},
+ {"IPv6Mreq", Type, 0, ""},
+ {"IPv6Mreq.Interface", Field, 0, ""},
+ {"IPv6Mreq.Multiaddr", Field, 0, ""},
+ {"ISIG", Const, 0, ""},
+ {"ISTRIP", Const, 0, ""},
+ {"IUCLC", Const, 0, ""},
+ {"IUTF8", Const, 0, ""},
+ {"IXANY", Const, 0, ""},
+ {"IXOFF", Const, 0, ""},
+ {"IXON", Const, 0, ""},
+ {"IfAddrmsg", Type, 0, ""},
+ {"IfAddrmsg.Family", Field, 0, ""},
+ {"IfAddrmsg.Flags", Field, 0, ""},
+ {"IfAddrmsg.Index", Field, 0, ""},
+ {"IfAddrmsg.Prefixlen", Field, 0, ""},
+ {"IfAddrmsg.Scope", Field, 0, ""},
+ {"IfAnnounceMsghdr", Type, 1, ""},
+ {"IfAnnounceMsghdr.Hdrlen", Field, 2, ""},
+ {"IfAnnounceMsghdr.Index", Field, 1, ""},
+ {"IfAnnounceMsghdr.Msglen", Field, 1, ""},
+ {"IfAnnounceMsghdr.Name", Field, 1, ""},
+ {"IfAnnounceMsghdr.Type", Field, 1, ""},
+ {"IfAnnounceMsghdr.Version", Field, 1, ""},
+ {"IfAnnounceMsghdr.What", Field, 1, ""},
+ {"IfData", Type, 0, ""},
+ {"IfData.Addrlen", Field, 0, ""},
+ {"IfData.Baudrate", Field, 0, ""},
+ {"IfData.Capabilities", Field, 2, ""},
+ {"IfData.Collisions", Field, 0, ""},
+ {"IfData.Datalen", Field, 0, ""},
+ {"IfData.Epoch", Field, 0, ""},
+ {"IfData.Hdrlen", Field, 0, ""},
+ {"IfData.Hwassist", Field, 0, ""},
+ {"IfData.Ibytes", Field, 0, ""},
+ {"IfData.Ierrors", Field, 0, ""},
+ {"IfData.Imcasts", Field, 0, ""},
+ {"IfData.Ipackets", Field, 0, ""},
+ {"IfData.Iqdrops", Field, 0, ""},
+ {"IfData.Lastchange", Field, 0, ""},
+ {"IfData.Link_state", Field, 0, ""},
+ {"IfData.Mclpool", Field, 2, ""},
+ {"IfData.Metric", Field, 0, ""},
+ {"IfData.Mtu", Field, 0, ""},
+ {"IfData.Noproto", Field, 0, ""},
+ {"IfData.Obytes", Field, 0, ""},
+ {"IfData.Oerrors", Field, 0, ""},
+ {"IfData.Omcasts", Field, 0, ""},
+ {"IfData.Opackets", Field, 0, ""},
+ {"IfData.Pad", Field, 2, ""},
+ {"IfData.Pad_cgo_0", Field, 2, ""},
+ {"IfData.Pad_cgo_1", Field, 2, ""},
+ {"IfData.Physical", Field, 0, ""},
+ {"IfData.Recvquota", Field, 0, ""},
+ {"IfData.Recvtiming", Field, 0, ""},
+ {"IfData.Reserved1", Field, 0, ""},
+ {"IfData.Reserved2", Field, 0, ""},
+ {"IfData.Spare_char1", Field, 0, ""},
+ {"IfData.Spare_char2", Field, 0, ""},
+ {"IfData.Type", Field, 0, ""},
+ {"IfData.Typelen", Field, 0, ""},
+ {"IfData.Unused1", Field, 0, ""},
+ {"IfData.Unused2", Field, 0, ""},
+ {"IfData.Xmitquota", Field, 0, ""},
+ {"IfData.Xmittiming", Field, 0, ""},
+ {"IfInfomsg", Type, 0, ""},
+ {"IfInfomsg.Change", Field, 0, ""},
+ {"IfInfomsg.Family", Field, 0, ""},
+ {"IfInfomsg.Flags", Field, 0, ""},
+ {"IfInfomsg.Index", Field, 0, ""},
+ {"IfInfomsg.Type", Field, 0, ""},
+ {"IfInfomsg.X__ifi_pad", Field, 0, ""},
+ {"IfMsghdr", Type, 0, ""},
+ {"IfMsghdr.Addrs", Field, 0, ""},
+ {"IfMsghdr.Data", Field, 0, ""},
+ {"IfMsghdr.Flags", Field, 0, ""},
+ {"IfMsghdr.Hdrlen", Field, 2, ""},
+ {"IfMsghdr.Index", Field, 0, ""},
+ {"IfMsghdr.Msglen", Field, 0, ""},
+ {"IfMsghdr.Pad1", Field, 2, ""},
+ {"IfMsghdr.Pad2", Field, 2, ""},
+ {"IfMsghdr.Pad_cgo_0", Field, 0, ""},
+ {"IfMsghdr.Pad_cgo_1", Field, 2, ""},
+ {"IfMsghdr.Tableid", Field, 2, ""},
+ {"IfMsghdr.Type", Field, 0, ""},
+ {"IfMsghdr.Version", Field, 0, ""},
+ {"IfMsghdr.Xflags", Field, 2, ""},
+ {"IfaMsghdr", Type, 0, ""},
+ {"IfaMsghdr.Addrs", Field, 0, ""},
+ {"IfaMsghdr.Flags", Field, 0, ""},
+ {"IfaMsghdr.Hdrlen", Field, 2, ""},
+ {"IfaMsghdr.Index", Field, 0, ""},
+ {"IfaMsghdr.Metric", Field, 0, ""},
+ {"IfaMsghdr.Msglen", Field, 0, ""},
+ {"IfaMsghdr.Pad1", Field, 2, ""},
+ {"IfaMsghdr.Pad2", Field, 2, ""},
+ {"IfaMsghdr.Pad_cgo_0", Field, 0, ""},
+ {"IfaMsghdr.Tableid", Field, 2, ""},
+ {"IfaMsghdr.Type", Field, 0, ""},
+ {"IfaMsghdr.Version", Field, 0, ""},
+ {"IfmaMsghdr", Type, 0, ""},
+ {"IfmaMsghdr.Addrs", Field, 0, ""},
+ {"IfmaMsghdr.Flags", Field, 0, ""},
+ {"IfmaMsghdr.Index", Field, 0, ""},
+ {"IfmaMsghdr.Msglen", Field, 0, ""},
+ {"IfmaMsghdr.Pad_cgo_0", Field, 0, ""},
+ {"IfmaMsghdr.Type", Field, 0, ""},
+ {"IfmaMsghdr.Version", Field, 0, ""},
+ {"IfmaMsghdr2", Type, 0, ""},
+ {"IfmaMsghdr2.Addrs", Field, 0, ""},
+ {"IfmaMsghdr2.Flags", Field, 0, ""},
+ {"IfmaMsghdr2.Index", Field, 0, ""},
+ {"IfmaMsghdr2.Msglen", Field, 0, ""},
+ {"IfmaMsghdr2.Pad_cgo_0", Field, 0, ""},
+ {"IfmaMsghdr2.Refcount", Field, 0, ""},
+ {"IfmaMsghdr2.Type", Field, 0, ""},
+ {"IfmaMsghdr2.Version", Field, 0, ""},
+ {"ImplementsGetwd", Const, 0, ""},
+ {"Inet4Pktinfo", Type, 0, ""},
+ {"Inet4Pktinfo.Addr", Field, 0, ""},
+ {"Inet4Pktinfo.Ifindex", Field, 0, ""},
+ {"Inet4Pktinfo.Spec_dst", Field, 0, ""},
+ {"Inet6Pktinfo", Type, 0, ""},
+ {"Inet6Pktinfo.Addr", Field, 0, ""},
+ {"Inet6Pktinfo.Ifindex", Field, 0, ""},
+ {"InotifyAddWatch", Func, 0, "func(fd int, pathname string, mask uint32) (watchdesc int, err error)"},
+ {"InotifyEvent", Type, 0, ""},
+ {"InotifyEvent.Cookie", Field, 0, ""},
+ {"InotifyEvent.Len", Field, 0, ""},
+ {"InotifyEvent.Mask", Field, 0, ""},
+ {"InotifyEvent.Name", Field, 0, ""},
+ {"InotifyEvent.Wd", Field, 0, ""},
+ {"InotifyInit", Func, 0, "func() (fd int, err error)"},
+ {"InotifyInit1", Func, 0, "func(flags int) (fd int, err error)"},
+ {"InotifyRmWatch", Func, 0, "func(fd int, watchdesc uint32) (success int, err error)"},
+ {"InterfaceAddrMessage", Type, 0, ""},
+ {"InterfaceAddrMessage.Data", Field, 0, ""},
+ {"InterfaceAddrMessage.Header", Field, 0, ""},
+ {"InterfaceAnnounceMessage", Type, 1, ""},
+ {"InterfaceAnnounceMessage.Header", Field, 1, ""},
+ {"InterfaceInfo", Type, 0, ""},
+ {"InterfaceInfo.Address", Field, 0, ""},
+ {"InterfaceInfo.BroadcastAddress", Field, 0, ""},
+ {"InterfaceInfo.Flags", Field, 0, ""},
+ {"InterfaceInfo.Netmask", Field, 0, ""},
+ {"InterfaceMessage", Type, 0, ""},
+ {"InterfaceMessage.Data", Field, 0, ""},
+ {"InterfaceMessage.Header", Field, 0, ""},
+ {"InterfaceMulticastAddrMessage", Type, 0, ""},
+ {"InterfaceMulticastAddrMessage.Data", Field, 0, ""},
+ {"InterfaceMulticastAddrMessage.Header", Field, 0, ""},
+ {"InvalidHandle", Const, 0, ""},
+ {"Ioperm", Func, 0, "func(from int, num int, on int) (err error)"},
+ {"Iopl", Func, 0, "func(level int) (err error)"},
+ {"Iovec", Type, 0, ""},
+ {"Iovec.Base", Field, 0, ""},
+ {"Iovec.Len", Field, 0, ""},
+ {"IpAdapterInfo", Type, 0, ""},
+ {"IpAdapterInfo.AdapterName", Field, 0, ""},
+ {"IpAdapterInfo.Address", Field, 0, ""},
+ {"IpAdapterInfo.AddressLength", Field, 0, ""},
+ {"IpAdapterInfo.ComboIndex", Field, 0, ""},
+ {"IpAdapterInfo.CurrentIpAddress", Field, 0, ""},
+ {"IpAdapterInfo.Description", Field, 0, ""},
+ {"IpAdapterInfo.DhcpEnabled", Field, 0, ""},
+ {"IpAdapterInfo.DhcpServer", Field, 0, ""},
+ {"IpAdapterInfo.GatewayList", Field, 0, ""},
+ {"IpAdapterInfo.HaveWins", Field, 0, ""},
+ {"IpAdapterInfo.Index", Field, 0, ""},
+ {"IpAdapterInfo.IpAddressList", Field, 0, ""},
+ {"IpAdapterInfo.LeaseExpires", Field, 0, ""},
+ {"IpAdapterInfo.LeaseObtained", Field, 0, ""},
+ {"IpAdapterInfo.Next", Field, 0, ""},
+ {"IpAdapterInfo.PrimaryWinsServer", Field, 0, ""},
+ {"IpAdapterInfo.SecondaryWinsServer", Field, 0, ""},
+ {"IpAdapterInfo.Type", Field, 0, ""},
+ {"IpAddrString", Type, 0, ""},
+ {"IpAddrString.Context", Field, 0, ""},
+ {"IpAddrString.IpAddress", Field, 0, ""},
+ {"IpAddrString.IpMask", Field, 0, ""},
+ {"IpAddrString.Next", Field, 0, ""},
+ {"IpAddressString", Type, 0, ""},
+ {"IpAddressString.String", Field, 0, ""},
+ {"IpMaskString", Type, 0, ""},
+ {"IpMaskString.String", Field, 2, ""},
+ {"Issetugid", Func, 0, ""},
+ {"KEY_ALL_ACCESS", Const, 0, ""},
+ {"KEY_CREATE_LINK", Const, 0, ""},
+ {"KEY_CREATE_SUB_KEY", Const, 0, ""},
+ {"KEY_ENUMERATE_SUB_KEYS", Const, 0, ""},
+ {"KEY_EXECUTE", Const, 0, ""},
+ {"KEY_NOTIFY", Const, 0, ""},
+ {"KEY_QUERY_VALUE", Const, 0, ""},
+ {"KEY_READ", Const, 0, ""},
+ {"KEY_SET_VALUE", Const, 0, ""},
+ {"KEY_WOW64_32KEY", Const, 0, ""},
+ {"KEY_WOW64_64KEY", Const, 0, ""},
+ {"KEY_WRITE", Const, 0, ""},
+ {"Kevent", Func, 0, ""},
+ {"Kevent_t", Type, 0, ""},
+ {"Kevent_t.Data", Field, 0, ""},
+ {"Kevent_t.Fflags", Field, 0, ""},
+ {"Kevent_t.Filter", Field, 0, ""},
+ {"Kevent_t.Flags", Field, 0, ""},
+ {"Kevent_t.Ident", Field, 0, ""},
+ {"Kevent_t.Pad_cgo_0", Field, 2, ""},
+ {"Kevent_t.Udata", Field, 0, ""},
+ {"Kill", Func, 0, "func(pid int, sig Signal) (err error)"},
+ {"Klogctl", Func, 0, "func(typ int, buf []byte) (n int, err error)"},
+ {"Kqueue", Func, 0, ""},
+ {"LANG_ENGLISH", Const, 0, ""},
+ {"LAYERED_PROTOCOL", Const, 2, ""},
+ {"LCNT_OVERLOAD_FLUSH", Const, 1, ""},
+ {"LINUX_REBOOT_CMD_CAD_OFF", Const, 0, ""},
+ {"LINUX_REBOOT_CMD_CAD_ON", Const, 0, ""},
+ {"LINUX_REBOOT_CMD_HALT", Const, 0, ""},
+ {"LINUX_REBOOT_CMD_KEXEC", Const, 0, ""},
+ {"LINUX_REBOOT_CMD_POWER_OFF", Const, 0, ""},
+ {"LINUX_REBOOT_CMD_RESTART", Const, 0, ""},
+ {"LINUX_REBOOT_CMD_RESTART2", Const, 0, ""},
+ {"LINUX_REBOOT_CMD_SW_SUSPEND", Const, 0, ""},
+ {"LINUX_REBOOT_MAGIC1", Const, 0, ""},
+ {"LINUX_REBOOT_MAGIC2", Const, 0, ""},
+ {"LOCK_EX", Const, 0, ""},
+ {"LOCK_NB", Const, 0, ""},
+ {"LOCK_SH", Const, 0, ""},
+ {"LOCK_UN", Const, 0, ""},
+ {"LazyDLL", Type, 0, ""},
+ {"LazyDLL.Name", Field, 0, ""},
+ {"LazyProc", Type, 0, ""},
+ {"LazyProc.Name", Field, 0, ""},
+ {"Lchown", Func, 0, "func(path string, uid int, gid int) (err error)"},
+ {"Linger", Type, 0, ""},
+ {"Linger.Linger", Field, 0, ""},
+ {"Linger.Onoff", Field, 0, ""},
+ {"Link", Func, 0, "func(oldpath string, newpath string) (err error)"},
+ {"Listen", Func, 0, "func(s int, n int) (err error)"},
+ {"Listxattr", Func, 1, "func(path string, dest []byte) (sz int, err error)"},
+ {"LoadCancelIoEx", Func, 1, ""},
+ {"LoadConnectEx", Func, 1, ""},
+ {"LoadCreateSymbolicLink", Func, 4, ""},
+ {"LoadDLL", Func, 0, ""},
+ {"LoadGetAddrInfo", Func, 1, ""},
+ {"LoadLibrary", Func, 0, ""},
+ {"LoadSetFileCompletionNotificationModes", Func, 2, ""},
+ {"LocalFree", Func, 0, ""},
+ {"Log2phys_t", Type, 0, ""},
+ {"Log2phys_t.Contigbytes", Field, 0, ""},
+ {"Log2phys_t.Devoffset", Field, 0, ""},
+ {"Log2phys_t.Flags", Field, 0, ""},
+ {"LookupAccountName", Func, 0, ""},
+ {"LookupAccountSid", Func, 0, ""},
+ {"LookupSID", Func, 0, ""},
+ {"LsfJump", Func, 0, "func(code int, k int, jt int, jf int) *SockFilter"},
+ {"LsfSocket", Func, 0, "func(ifindex int, proto int) (int, error)"},
+ {"LsfStmt", Func, 0, "func(code int, k int) *SockFilter"},
+ {"Lstat", Func, 0, "func(path string, stat *Stat_t) (err error)"},
+ {"MADV_AUTOSYNC", Const, 1, ""},
+ {"MADV_CAN_REUSE", Const, 0, ""},
+ {"MADV_CORE", Const, 1, ""},
+ {"MADV_DOFORK", Const, 0, ""},
+ {"MADV_DONTFORK", Const, 0, ""},
+ {"MADV_DONTNEED", Const, 0, ""},
+ {"MADV_FREE", Const, 0, ""},
+ {"MADV_FREE_REUSABLE", Const, 0, ""},
+ {"MADV_FREE_REUSE", Const, 0, ""},
+ {"MADV_HUGEPAGE", Const, 0, ""},
+ {"MADV_HWPOISON", Const, 0, ""},
+ {"MADV_MERGEABLE", Const, 0, ""},
+ {"MADV_NOCORE", Const, 1, ""},
+ {"MADV_NOHUGEPAGE", Const, 0, ""},
+ {"MADV_NORMAL", Const, 0, ""},
+ {"MADV_NOSYNC", Const, 1, ""},
+ {"MADV_PROTECT", Const, 1, ""},
+ {"MADV_RANDOM", Const, 0, ""},
+ {"MADV_REMOVE", Const, 0, ""},
+ {"MADV_SEQUENTIAL", Const, 0, ""},
+ {"MADV_SPACEAVAIL", Const, 3, ""},
+ {"MADV_UNMERGEABLE", Const, 0, ""},
+ {"MADV_WILLNEED", Const, 0, ""},
+ {"MADV_ZERO_WIRED_PAGES", Const, 0, ""},
+ {"MAP_32BIT", Const, 0, ""},
+ {"MAP_ALIGNED_SUPER", Const, 3, ""},
+ {"MAP_ALIGNMENT_16MB", Const, 3, ""},
+ {"MAP_ALIGNMENT_1TB", Const, 3, ""},
+ {"MAP_ALIGNMENT_256TB", Const, 3, ""},
+ {"MAP_ALIGNMENT_4GB", Const, 3, ""},
+ {"MAP_ALIGNMENT_64KB", Const, 3, ""},
+ {"MAP_ALIGNMENT_64PB", Const, 3, ""},
+ {"MAP_ALIGNMENT_MASK", Const, 3, ""},
+ {"MAP_ALIGNMENT_SHIFT", Const, 3, ""},
+ {"MAP_ANON", Const, 0, ""},
+ {"MAP_ANONYMOUS", Const, 0, ""},
+ {"MAP_COPY", Const, 0, ""},
+ {"MAP_DENYWRITE", Const, 0, ""},
+ {"MAP_EXECUTABLE", Const, 0, ""},
+ {"MAP_FILE", Const, 0, ""},
+ {"MAP_FIXED", Const, 0, ""},
+ {"MAP_FLAGMASK", Const, 3, ""},
+ {"MAP_GROWSDOWN", Const, 0, ""},
+ {"MAP_HASSEMAPHORE", Const, 0, ""},
+ {"MAP_HUGETLB", Const, 0, ""},
+ {"MAP_INHERIT", Const, 3, ""},
+ {"MAP_INHERIT_COPY", Const, 3, ""},
+ {"MAP_INHERIT_DEFAULT", Const, 3, ""},
+ {"MAP_INHERIT_DONATE_COPY", Const, 3, ""},
+ {"MAP_INHERIT_NONE", Const, 3, ""},
+ {"MAP_INHERIT_SHARE", Const, 3, ""},
+ {"MAP_JIT", Const, 0, ""},
+ {"MAP_LOCKED", Const, 0, ""},
+ {"MAP_NOCACHE", Const, 0, ""},
+ {"MAP_NOCORE", Const, 1, ""},
+ {"MAP_NOEXTEND", Const, 0, ""},
+ {"MAP_NONBLOCK", Const, 0, ""},
+ {"MAP_NORESERVE", Const, 0, ""},
+ {"MAP_NOSYNC", Const, 1, ""},
+ {"MAP_POPULATE", Const, 0, ""},
+ {"MAP_PREFAULT_READ", Const, 1, ""},
+ {"MAP_PRIVATE", Const, 0, ""},
+ {"MAP_RENAME", Const, 0, ""},
+ {"MAP_RESERVED0080", Const, 0, ""},
+ {"MAP_RESERVED0100", Const, 1, ""},
+ {"MAP_SHARED", Const, 0, ""},
+ {"MAP_STACK", Const, 0, ""},
+ {"MAP_TRYFIXED", Const, 3, ""},
+ {"MAP_TYPE", Const, 0, ""},
+ {"MAP_WIRED", Const, 3, ""},
+ {"MAXIMUM_REPARSE_DATA_BUFFER_SIZE", Const, 4, ""},
+ {"MAXLEN_IFDESCR", Const, 0, ""},
+ {"MAXLEN_PHYSADDR", Const, 0, ""},
+ {"MAX_ADAPTER_ADDRESS_LENGTH", Const, 0, ""},
+ {"MAX_ADAPTER_DESCRIPTION_LENGTH", Const, 0, ""},
+ {"MAX_ADAPTER_NAME_LENGTH", Const, 0, ""},
+ {"MAX_COMPUTERNAME_LENGTH", Const, 0, ""},
+ {"MAX_INTERFACE_NAME_LEN", Const, 0, ""},
+ {"MAX_LONG_PATH", Const, 0, ""},
+ {"MAX_PATH", Const, 0, ""},
+ {"MAX_PROTOCOL_CHAIN", Const, 2, ""},
+ {"MCL_CURRENT", Const, 0, ""},
+ {"MCL_FUTURE", Const, 0, ""},
+ {"MNT_DETACH", Const, 0, ""},
+ {"MNT_EXPIRE", Const, 0, ""},
+ {"MNT_FORCE", Const, 0, ""},
+ {"MSG_BCAST", Const, 1, ""},
+ {"MSG_CMSG_CLOEXEC", Const, 0, ""},
+ {"MSG_COMPAT", Const, 0, ""},
+ {"MSG_CONFIRM", Const, 0, ""},
+ {"MSG_CONTROLMBUF", Const, 1, ""},
+ {"MSG_CTRUNC", Const, 0, ""},
+ {"MSG_DONTROUTE", Const, 0, ""},
+ {"MSG_DONTWAIT", Const, 0, ""},
+ {"MSG_EOF", Const, 0, ""},
+ {"MSG_EOR", Const, 0, ""},
+ {"MSG_ERRQUEUE", Const, 0, ""},
+ {"MSG_FASTOPEN", Const, 1, ""},
+ {"MSG_FIN", Const, 0, ""},
+ {"MSG_FLUSH", Const, 0, ""},
+ {"MSG_HAVEMORE", Const, 0, ""},
+ {"MSG_HOLD", Const, 0, ""},
+ {"MSG_IOVUSRSPACE", Const, 1, ""},
+ {"MSG_LENUSRSPACE", Const, 1, ""},
+ {"MSG_MCAST", Const, 1, ""},
+ {"MSG_MORE", Const, 0, ""},
+ {"MSG_NAMEMBUF", Const, 1, ""},
+ {"MSG_NBIO", Const, 0, ""},
+ {"MSG_NEEDSA", Const, 0, ""},
+ {"MSG_NOSIGNAL", Const, 0, ""},
+ {"MSG_NOTIFICATION", Const, 0, ""},
+ {"MSG_OOB", Const, 0, ""},
+ {"MSG_PEEK", Const, 0, ""},
+ {"MSG_PROXY", Const, 0, ""},
+ {"MSG_RCVMORE", Const, 0, ""},
+ {"MSG_RST", Const, 0, ""},
+ {"MSG_SEND", Const, 0, ""},
+ {"MSG_SYN", Const, 0, ""},
+ {"MSG_TRUNC", Const, 0, ""},
+ {"MSG_TRYHARD", Const, 0, ""},
+ {"MSG_USERFLAGS", Const, 1, ""},
+ {"MSG_WAITALL", Const, 0, ""},
+ {"MSG_WAITFORONE", Const, 0, ""},
+ {"MSG_WAITSTREAM", Const, 0, ""},
+ {"MS_ACTIVE", Const, 0, ""},
+ {"MS_ASYNC", Const, 0, ""},
+ {"MS_BIND", Const, 0, ""},
+ {"MS_DEACTIVATE", Const, 0, ""},
+ {"MS_DIRSYNC", Const, 0, ""},
+ {"MS_INVALIDATE", Const, 0, ""},
+ {"MS_I_VERSION", Const, 0, ""},
+ {"MS_KERNMOUNT", Const, 0, ""},
+ {"MS_KILLPAGES", Const, 0, ""},
+ {"MS_MANDLOCK", Const, 0, ""},
+ {"MS_MGC_MSK", Const, 0, ""},
+ {"MS_MGC_VAL", Const, 0, ""},
+ {"MS_MOVE", Const, 0, ""},
+ {"MS_NOATIME", Const, 0, ""},
+ {"MS_NODEV", Const, 0, ""},
+ {"MS_NODIRATIME", Const, 0, ""},
+ {"MS_NOEXEC", Const, 0, ""},
+ {"MS_NOSUID", Const, 0, ""},
+ {"MS_NOUSER", Const, 0, ""},
+ {"MS_POSIXACL", Const, 0, ""},
+ {"MS_PRIVATE", Const, 0, ""},
+ {"MS_RDONLY", Const, 0, ""},
+ {"MS_REC", Const, 0, ""},
+ {"MS_RELATIME", Const, 0, ""},
+ {"MS_REMOUNT", Const, 0, ""},
+ {"MS_RMT_MASK", Const, 0, ""},
+ {"MS_SHARED", Const, 0, ""},
+ {"MS_SILENT", Const, 0, ""},
+ {"MS_SLAVE", Const, 0, ""},
+ {"MS_STRICTATIME", Const, 0, ""},
+ {"MS_SYNC", Const, 0, ""},
+ {"MS_SYNCHRONOUS", Const, 0, ""},
+ {"MS_UNBINDABLE", Const, 0, ""},
+ {"Madvise", Func, 0, "func(b []byte, advice int) (err error)"},
+ {"MapViewOfFile", Func, 0, ""},
+ {"MaxTokenInfoClass", Const, 0, ""},
+ {"Mclpool", Type, 2, ""},
+ {"Mclpool.Alive", Field, 2, ""},
+ {"Mclpool.Cwm", Field, 2, ""},
+ {"Mclpool.Grown", Field, 2, ""},
+ {"Mclpool.Hwm", Field, 2, ""},
+ {"Mclpool.Lwm", Field, 2, ""},
+ {"MibIfRow", Type, 0, ""},
+ {"MibIfRow.AdminStatus", Field, 0, ""},
+ {"MibIfRow.Descr", Field, 0, ""},
+ {"MibIfRow.DescrLen", Field, 0, ""},
+ {"MibIfRow.InDiscards", Field, 0, ""},
+ {"MibIfRow.InErrors", Field, 0, ""},
+ {"MibIfRow.InNUcastPkts", Field, 0, ""},
+ {"MibIfRow.InOctets", Field, 0, ""},
+ {"MibIfRow.InUcastPkts", Field, 0, ""},
+ {"MibIfRow.InUnknownProtos", Field, 0, ""},
+ {"MibIfRow.Index", Field, 0, ""},
+ {"MibIfRow.LastChange", Field, 0, ""},
+ {"MibIfRow.Mtu", Field, 0, ""},
+ {"MibIfRow.Name", Field, 0, ""},
+ {"MibIfRow.OperStatus", Field, 0, ""},
+ {"MibIfRow.OutDiscards", Field, 0, ""},
+ {"MibIfRow.OutErrors", Field, 0, ""},
+ {"MibIfRow.OutNUcastPkts", Field, 0, ""},
+ {"MibIfRow.OutOctets", Field, 0, ""},
+ {"MibIfRow.OutQLen", Field, 0, ""},
+ {"MibIfRow.OutUcastPkts", Field, 0, ""},
+ {"MibIfRow.PhysAddr", Field, 0, ""},
+ {"MibIfRow.PhysAddrLen", Field, 0, ""},
+ {"MibIfRow.Speed", Field, 0, ""},
+ {"MibIfRow.Type", Field, 0, ""},
+ {"Mkdir", Func, 0, "func(path string, mode uint32) (err error)"},
+ {"Mkdirat", Func, 0, "func(dirfd int, path string, mode uint32) (err error)"},
+ {"Mkfifo", Func, 0, "func(path string, mode uint32) (err error)"},
+ {"Mknod", Func, 0, "func(path string, mode uint32, dev int) (err error)"},
+ {"Mknodat", Func, 0, "func(dirfd int, path string, mode uint32, dev int) (err error)"},
+ {"Mlock", Func, 0, "func(b []byte) (err error)"},
+ {"Mlockall", Func, 0, "func(flags int) (err error)"},
+ {"Mmap", Func, 0, "func(fd int, offset int64, length int, prot int, flags int) (data []byte, err error)"},
+ {"Mount", Func, 0, "func(source string, target string, fstype string, flags uintptr, data string) (err error)"},
+ {"MoveFile", Func, 0, ""},
+ {"Mprotect", Func, 0, "func(b []byte, prot int) (err error)"},
+ {"Msghdr", Type, 0, ""},
+ {"Msghdr.Control", Field, 0, ""},
+ {"Msghdr.Controllen", Field, 0, ""},
+ {"Msghdr.Flags", Field, 0, ""},
+ {"Msghdr.Iov", Field, 0, ""},
+ {"Msghdr.Iovlen", Field, 0, ""},
+ {"Msghdr.Name", Field, 0, ""},
+ {"Msghdr.Namelen", Field, 0, ""},
+ {"Msghdr.Pad_cgo_0", Field, 0, ""},
+ {"Msghdr.Pad_cgo_1", Field, 0, ""},
+ {"Munlock", Func, 0, "func(b []byte) (err error)"},
+ {"Munlockall", Func, 0, "func() (err error)"},
+ {"Munmap", Func, 0, "func(b []byte) (err error)"},
+ {"MustLoadDLL", Func, 0, ""},
+ {"NAME_MAX", Const, 0, ""},
+ {"NETLINK_ADD_MEMBERSHIP", Const, 0, ""},
+ {"NETLINK_AUDIT", Const, 0, ""},
+ {"NETLINK_BROADCAST_ERROR", Const, 0, ""},
+ {"NETLINK_CONNECTOR", Const, 0, ""},
+ {"NETLINK_DNRTMSG", Const, 0, ""},
+ {"NETLINK_DROP_MEMBERSHIP", Const, 0, ""},
+ {"NETLINK_ECRYPTFS", Const, 0, ""},
+ {"NETLINK_FIB_LOOKUP", Const, 0, ""},
+ {"NETLINK_FIREWALL", Const, 0, ""},
+ {"NETLINK_GENERIC", Const, 0, ""},
+ {"NETLINK_INET_DIAG", Const, 0, ""},
+ {"NETLINK_IP6_FW", Const, 0, ""},
+ {"NETLINK_ISCSI", Const, 0, ""},
+ {"NETLINK_KOBJECT_UEVENT", Const, 0, ""},
+ {"NETLINK_NETFILTER", Const, 0, ""},
+ {"NETLINK_NFLOG", Const, 0, ""},
+ {"NETLINK_NO_ENOBUFS", Const, 0, ""},
+ {"NETLINK_PKTINFO", Const, 0, ""},
+ {"NETLINK_RDMA", Const, 0, ""},
+ {"NETLINK_ROUTE", Const, 0, ""},
+ {"NETLINK_SCSITRANSPORT", Const, 0, ""},
+ {"NETLINK_SELINUX", Const, 0, ""},
+ {"NETLINK_UNUSED", Const, 0, ""},
+ {"NETLINK_USERSOCK", Const, 0, ""},
+ {"NETLINK_XFRM", Const, 0, ""},
+ {"NET_RT_DUMP", Const, 0, ""},
+ {"NET_RT_DUMP2", Const, 0, ""},
+ {"NET_RT_FLAGS", Const, 0, ""},
+ {"NET_RT_IFLIST", Const, 0, ""},
+ {"NET_RT_IFLIST2", Const, 0, ""},
+ {"NET_RT_IFLISTL", Const, 1, ""},
+ {"NET_RT_IFMALIST", Const, 0, ""},
+ {"NET_RT_MAXID", Const, 0, ""},
+ {"NET_RT_OIFLIST", Const, 1, ""},
+ {"NET_RT_OOIFLIST", Const, 1, ""},
+ {"NET_RT_STAT", Const, 0, ""},
+ {"NET_RT_STATS", Const, 1, ""},
+ {"NET_RT_TABLE", Const, 1, ""},
+ {"NET_RT_TRASH", Const, 0, ""},
+ {"NLA_ALIGNTO", Const, 0, ""},
+ {"NLA_F_NESTED", Const, 0, ""},
+ {"NLA_F_NET_BYTEORDER", Const, 0, ""},
+ {"NLA_HDRLEN", Const, 0, ""},
+ {"NLMSG_ALIGNTO", Const, 0, ""},
+ {"NLMSG_DONE", Const, 0, ""},
+ {"NLMSG_ERROR", Const, 0, ""},
+ {"NLMSG_HDRLEN", Const, 0, ""},
+ {"NLMSG_MIN_TYPE", Const, 0, ""},
+ {"NLMSG_NOOP", Const, 0, ""},
+ {"NLMSG_OVERRUN", Const, 0, ""},
+ {"NLM_F_ACK", Const, 0, ""},
+ {"NLM_F_APPEND", Const, 0, ""},
+ {"NLM_F_ATOMIC", Const, 0, ""},
+ {"NLM_F_CREATE", Const, 0, ""},
+ {"NLM_F_DUMP", Const, 0, ""},
+ {"NLM_F_ECHO", Const, 0, ""},
+ {"NLM_F_EXCL", Const, 0, ""},
+ {"NLM_F_MATCH", Const, 0, ""},
+ {"NLM_F_MULTI", Const, 0, ""},
+ {"NLM_F_REPLACE", Const, 0, ""},
+ {"NLM_F_REQUEST", Const, 0, ""},
+ {"NLM_F_ROOT", Const, 0, ""},
+ {"NOFLSH", Const, 0, ""},
+ {"NOTE_ABSOLUTE", Const, 0, ""},
+ {"NOTE_ATTRIB", Const, 0, ""},
+ {"NOTE_BACKGROUND", Const, 16, ""},
+ {"NOTE_CHILD", Const, 0, ""},
+ {"NOTE_CRITICAL", Const, 16, ""},
+ {"NOTE_DELETE", Const, 0, ""},
+ {"NOTE_EOF", Const, 1, ""},
+ {"NOTE_EXEC", Const, 0, ""},
+ {"NOTE_EXIT", Const, 0, ""},
+ {"NOTE_EXITSTATUS", Const, 0, ""},
+ {"NOTE_EXIT_CSERROR", Const, 16, ""},
+ {"NOTE_EXIT_DECRYPTFAIL", Const, 16, ""},
+ {"NOTE_EXIT_DETAIL", Const, 16, ""},
+ {"NOTE_EXIT_DETAIL_MASK", Const, 16, ""},
+ {"NOTE_EXIT_MEMORY", Const, 16, ""},
+ {"NOTE_EXIT_REPARENTED", Const, 16, ""},
+ {"NOTE_EXTEND", Const, 0, ""},
+ {"NOTE_FFAND", Const, 0, ""},
+ {"NOTE_FFCOPY", Const, 0, ""},
+ {"NOTE_FFCTRLMASK", Const, 0, ""},
+ {"NOTE_FFLAGSMASK", Const, 0, ""},
+ {"NOTE_FFNOP", Const, 0, ""},
+ {"NOTE_FFOR", Const, 0, ""},
+ {"NOTE_FORK", Const, 0, ""},
+ {"NOTE_LEEWAY", Const, 16, ""},
+ {"NOTE_LINK", Const, 0, ""},
+ {"NOTE_LOWAT", Const, 0, ""},
+ {"NOTE_NONE", Const, 0, ""},
+ {"NOTE_NSECONDS", Const, 0, ""},
+ {"NOTE_PCTRLMASK", Const, 0, ""},
+ {"NOTE_PDATAMASK", Const, 0, ""},
+ {"NOTE_REAP", Const, 0, ""},
+ {"NOTE_RENAME", Const, 0, ""},
+ {"NOTE_RESOURCEEND", Const, 0, ""},
+ {"NOTE_REVOKE", Const, 0, ""},
+ {"NOTE_SECONDS", Const, 0, ""},
+ {"NOTE_SIGNAL", Const, 0, ""},
+ {"NOTE_TRACK", Const, 0, ""},
+ {"NOTE_TRACKERR", Const, 0, ""},
+ {"NOTE_TRIGGER", Const, 0, ""},
+ {"NOTE_TRUNCATE", Const, 1, ""},
+ {"NOTE_USECONDS", Const, 0, ""},
+ {"NOTE_VM_ERROR", Const, 0, ""},
+ {"NOTE_VM_PRESSURE", Const, 0, ""},
+ {"NOTE_VM_PRESSURE_SUDDEN_TERMINATE", Const, 0, ""},
+ {"NOTE_VM_PRESSURE_TERMINATE", Const, 0, ""},
+ {"NOTE_WRITE", Const, 0, ""},
+ {"NameCanonical", Const, 0, ""},
+ {"NameCanonicalEx", Const, 0, ""},
+ {"NameDisplay", Const, 0, ""},
+ {"NameDnsDomain", Const, 0, ""},
+ {"NameFullyQualifiedDN", Const, 0, ""},
+ {"NameSamCompatible", Const, 0, ""},
+ {"NameServicePrincipal", Const, 0, ""},
+ {"NameUniqueId", Const, 0, ""},
+ {"NameUnknown", Const, 0, ""},
+ {"NameUserPrincipal", Const, 0, ""},
+ {"Nanosleep", Func, 0, "func(time *Timespec, leftover *Timespec) (err error)"},
+ {"NetApiBufferFree", Func, 0, ""},
+ {"NetGetJoinInformation", Func, 2, ""},
+ {"NetSetupDomainName", Const, 2, ""},
+ {"NetSetupUnjoined", Const, 2, ""},
+ {"NetSetupUnknownStatus", Const, 2, ""},
+ {"NetSetupWorkgroupName", Const, 2, ""},
+ {"NetUserGetInfo", Func, 0, ""},
+ {"NetlinkMessage", Type, 0, ""},
+ {"NetlinkMessage.Data", Field, 0, ""},
+ {"NetlinkMessage.Header", Field, 0, ""},
+ {"NetlinkRIB", Func, 0, "func(proto int, family int) ([]byte, error)"},
+ {"NetlinkRouteAttr", Type, 0, ""},
+ {"NetlinkRouteAttr.Attr", Field, 0, ""},
+ {"NetlinkRouteAttr.Value", Field, 0, ""},
+ {"NetlinkRouteRequest", Type, 0, ""},
+ {"NetlinkRouteRequest.Data", Field, 0, ""},
+ {"NetlinkRouteRequest.Header", Field, 0, ""},
+ {"NewCallback", Func, 0, ""},
+ {"NewCallbackCDecl", Func, 3, ""},
+ {"NewLazyDLL", Func, 0, ""},
+ {"NlAttr", Type, 0, ""},
+ {"NlAttr.Len", Field, 0, ""},
+ {"NlAttr.Type", Field, 0, ""},
+ {"NlMsgerr", Type, 0, ""},
+ {"NlMsgerr.Error", Field, 0, ""},
+ {"NlMsgerr.Msg", Field, 0, ""},
+ {"NlMsghdr", Type, 0, ""},
+ {"NlMsghdr.Flags", Field, 0, ""},
+ {"NlMsghdr.Len", Field, 0, ""},
+ {"NlMsghdr.Pid", Field, 0, ""},
+ {"NlMsghdr.Seq", Field, 0, ""},
+ {"NlMsghdr.Type", Field, 0, ""},
+ {"NsecToFiletime", Func, 0, ""},
+ {"NsecToTimespec", Func, 0, "func(nsec int64) Timespec"},
+ {"NsecToTimeval", Func, 0, "func(nsec int64) Timeval"},
+ {"Ntohs", Func, 0, ""},
+ {"OCRNL", Const, 0, ""},
+ {"OFDEL", Const, 0, ""},
+ {"OFILL", Const, 0, ""},
+ {"OFIOGETBMAP", Const, 1, ""},
+ {"OID_PKIX_KP_SERVER_AUTH", Var, 0, ""},
+ {"OID_SERVER_GATED_CRYPTO", Var, 0, ""},
+ {"OID_SGC_NETSCAPE", Var, 0, ""},
+ {"OLCUC", Const, 0, ""},
+ {"ONLCR", Const, 0, ""},
+ {"ONLRET", Const, 0, ""},
+ {"ONOCR", Const, 0, ""},
+ {"ONOEOT", Const, 1, ""},
+ {"OPEN_ALWAYS", Const, 0, ""},
+ {"OPEN_EXISTING", Const, 0, ""},
+ {"OPOST", Const, 0, ""},
+ {"O_ACCMODE", Const, 0, ""},
+ {"O_ALERT", Const, 0, ""},
+ {"O_ALT_IO", Const, 1, ""},
+ {"O_APPEND", Const, 0, ""},
+ {"O_ASYNC", Const, 0, ""},
+ {"O_CLOEXEC", Const, 0, ""},
+ {"O_CREAT", Const, 0, ""},
+ {"O_DIRECT", Const, 0, ""},
+ {"O_DIRECTORY", Const, 0, ""},
+ {"O_DP_GETRAWENCRYPTED", Const, 16, ""},
+ {"O_DSYNC", Const, 0, ""},
+ {"O_EVTONLY", Const, 0, ""},
+ {"O_EXCL", Const, 0, ""},
+ {"O_EXEC", Const, 0, ""},
+ {"O_EXLOCK", Const, 0, ""},
+ {"O_FSYNC", Const, 0, ""},
+ {"O_LARGEFILE", Const, 0, ""},
+ {"O_NDELAY", Const, 0, ""},
+ {"O_NOATIME", Const, 0, ""},
+ {"O_NOCTTY", Const, 0, ""},
+ {"O_NOFOLLOW", Const, 0, ""},
+ {"O_NONBLOCK", Const, 0, ""},
+ {"O_NOSIGPIPE", Const, 1, ""},
+ {"O_POPUP", Const, 0, ""},
+ {"O_RDONLY", Const, 0, ""},
+ {"O_RDWR", Const, 0, ""},
+ {"O_RSYNC", Const, 0, ""},
+ {"O_SHLOCK", Const, 0, ""},
+ {"O_SYMLINK", Const, 0, ""},
+ {"O_SYNC", Const, 0, ""},
+ {"O_TRUNC", Const, 0, ""},
+ {"O_TTY_INIT", Const, 0, ""},
+ {"O_WRONLY", Const, 0, ""},
+ {"Open", Func, 0, "func(path string, mode int, perm uint32) (fd int, err error)"},
+ {"OpenCurrentProcessToken", Func, 0, ""},
+ {"OpenProcess", Func, 0, ""},
+ {"OpenProcessToken", Func, 0, ""},
+ {"Openat", Func, 0, "func(dirfd int, path string, flags int, mode uint32) (fd int, err error)"},
+ {"Overlapped", Type, 0, ""},
+ {"Overlapped.HEvent", Field, 0, ""},
+ {"Overlapped.Internal", Field, 0, ""},
+ {"Overlapped.InternalHigh", Field, 0, ""},
+ {"Overlapped.Offset", Field, 0, ""},
+ {"Overlapped.OffsetHigh", Field, 0, ""},
+ {"PACKET_ADD_MEMBERSHIP", Const, 0, ""},
+ {"PACKET_BROADCAST", Const, 0, ""},
+ {"PACKET_DROP_MEMBERSHIP", Const, 0, ""},
+ {"PACKET_FASTROUTE", Const, 0, ""},
+ {"PACKET_HOST", Const, 0, ""},
+ {"PACKET_LOOPBACK", Const, 0, ""},
+ {"PACKET_MR_ALLMULTI", Const, 0, ""},
+ {"PACKET_MR_MULTICAST", Const, 0, ""},
+ {"PACKET_MR_PROMISC", Const, 0, ""},
+ {"PACKET_MULTICAST", Const, 0, ""},
+ {"PACKET_OTHERHOST", Const, 0, ""},
+ {"PACKET_OUTGOING", Const, 0, ""},
+ {"PACKET_RECV_OUTPUT", Const, 0, ""},
+ {"PACKET_RX_RING", Const, 0, ""},
+ {"PACKET_STATISTICS", Const, 0, ""},
+ {"PAGE_EXECUTE_READ", Const, 0, ""},
+ {"PAGE_EXECUTE_READWRITE", Const, 0, ""},
+ {"PAGE_EXECUTE_WRITECOPY", Const, 0, ""},
+ {"PAGE_READONLY", Const, 0, ""},
+ {"PAGE_READWRITE", Const, 0, ""},
+ {"PAGE_WRITECOPY", Const, 0, ""},
+ {"PARENB", Const, 0, ""},
+ {"PARMRK", Const, 0, ""},
+ {"PARODD", Const, 0, ""},
+ {"PENDIN", Const, 0, ""},
+ {"PFL_HIDDEN", Const, 2, ""},
+ {"PFL_MATCHES_PROTOCOL_ZERO", Const, 2, ""},
+ {"PFL_MULTIPLE_PROTO_ENTRIES", Const, 2, ""},
+ {"PFL_NETWORKDIRECT_PROVIDER", Const, 2, ""},
+ {"PFL_RECOMMENDED_PROTO_ENTRY", Const, 2, ""},
+ {"PF_FLUSH", Const, 1, ""},
+ {"PKCS_7_ASN_ENCODING", Const, 0, ""},
+ {"PMC5_PIPELINE_FLUSH", Const, 1, ""},
+ {"PRIO_PGRP", Const, 2, ""},
+ {"PRIO_PROCESS", Const, 2, ""},
+ {"PRIO_USER", Const, 2, ""},
+ {"PRI_IOFLUSH", Const, 1, ""},
+ {"PROCESS_QUERY_INFORMATION", Const, 0, ""},
+ {"PROCESS_TERMINATE", Const, 2, ""},
+ {"PROT_EXEC", Const, 0, ""},
+ {"PROT_GROWSDOWN", Const, 0, ""},
+ {"PROT_GROWSUP", Const, 0, ""},
+ {"PROT_NONE", Const, 0, ""},
+ {"PROT_READ", Const, 0, ""},
+ {"PROT_WRITE", Const, 0, ""},
+ {"PROV_DH_SCHANNEL", Const, 0, ""},
+ {"PROV_DSS", Const, 0, ""},
+ {"PROV_DSS_DH", Const, 0, ""},
+ {"PROV_EC_ECDSA_FULL", Const, 0, ""},
+ {"PROV_EC_ECDSA_SIG", Const, 0, ""},
+ {"PROV_EC_ECNRA_FULL", Const, 0, ""},
+ {"PROV_EC_ECNRA_SIG", Const, 0, ""},
+ {"PROV_FORTEZZA", Const, 0, ""},
+ {"PROV_INTEL_SEC", Const, 0, ""},
+ {"PROV_MS_EXCHANGE", Const, 0, ""},
+ {"PROV_REPLACE_OWF", Const, 0, ""},
+ {"PROV_RNG", Const, 0, ""},
+ {"PROV_RSA_AES", Const, 0, ""},
+ {"PROV_RSA_FULL", Const, 0, ""},
+ {"PROV_RSA_SCHANNEL", Const, 0, ""},
+ {"PROV_RSA_SIG", Const, 0, ""},
+ {"PROV_SPYRUS_LYNKS", Const, 0, ""},
+ {"PROV_SSL", Const, 0, ""},
+ {"PR_CAPBSET_DROP", Const, 0, ""},
+ {"PR_CAPBSET_READ", Const, 0, ""},
+ {"PR_CLEAR_SECCOMP_FILTER", Const, 0, ""},
+ {"PR_ENDIAN_BIG", Const, 0, ""},
+ {"PR_ENDIAN_LITTLE", Const, 0, ""},
+ {"PR_ENDIAN_PPC_LITTLE", Const, 0, ""},
+ {"PR_FPEMU_NOPRINT", Const, 0, ""},
+ {"PR_FPEMU_SIGFPE", Const, 0, ""},
+ {"PR_FP_EXC_ASYNC", Const, 0, ""},
+ {"PR_FP_EXC_DISABLED", Const, 0, ""},
+ {"PR_FP_EXC_DIV", Const, 0, ""},
+ {"PR_FP_EXC_INV", Const, 0, ""},
+ {"PR_FP_EXC_NONRECOV", Const, 0, ""},
+ {"PR_FP_EXC_OVF", Const, 0, ""},
+ {"PR_FP_EXC_PRECISE", Const, 0, ""},
+ {"PR_FP_EXC_RES", Const, 0, ""},
+ {"PR_FP_EXC_SW_ENABLE", Const, 0, ""},
+ {"PR_FP_EXC_UND", Const, 0, ""},
+ {"PR_GET_DUMPABLE", Const, 0, ""},
+ {"PR_GET_ENDIAN", Const, 0, ""},
+ {"PR_GET_FPEMU", Const, 0, ""},
+ {"PR_GET_FPEXC", Const, 0, ""},
+ {"PR_GET_KEEPCAPS", Const, 0, ""},
+ {"PR_GET_NAME", Const, 0, ""},
+ {"PR_GET_PDEATHSIG", Const, 0, ""},
+ {"PR_GET_SECCOMP", Const, 0, ""},
+ {"PR_GET_SECCOMP_FILTER", Const, 0, ""},
+ {"PR_GET_SECUREBITS", Const, 0, ""},
+ {"PR_GET_TIMERSLACK", Const, 0, ""},
+ {"PR_GET_TIMING", Const, 0, ""},
+ {"PR_GET_TSC", Const, 0, ""},
+ {"PR_GET_UNALIGN", Const, 0, ""},
+ {"PR_MCE_KILL", Const, 0, ""},
+ {"PR_MCE_KILL_CLEAR", Const, 0, ""},
+ {"PR_MCE_KILL_DEFAULT", Const, 0, ""},
+ {"PR_MCE_KILL_EARLY", Const, 0, ""},
+ {"PR_MCE_KILL_GET", Const, 0, ""},
+ {"PR_MCE_KILL_LATE", Const, 0, ""},
+ {"PR_MCE_KILL_SET", Const, 0, ""},
+ {"PR_SECCOMP_FILTER_EVENT", Const, 0, ""},
+ {"PR_SECCOMP_FILTER_SYSCALL", Const, 0, ""},
+ {"PR_SET_DUMPABLE", Const, 0, ""},
+ {"PR_SET_ENDIAN", Const, 0, ""},
+ {"PR_SET_FPEMU", Const, 0, ""},
+ {"PR_SET_FPEXC", Const, 0, ""},
+ {"PR_SET_KEEPCAPS", Const, 0, ""},
+ {"PR_SET_NAME", Const, 0, ""},
+ {"PR_SET_PDEATHSIG", Const, 0, ""},
+ {"PR_SET_PTRACER", Const, 0, ""},
+ {"PR_SET_SECCOMP", Const, 0, ""},
+ {"PR_SET_SECCOMP_FILTER", Const, 0, ""},
+ {"PR_SET_SECUREBITS", Const, 0, ""},
+ {"PR_SET_TIMERSLACK", Const, 0, ""},
+ {"PR_SET_TIMING", Const, 0, ""},
+ {"PR_SET_TSC", Const, 0, ""},
+ {"PR_SET_UNALIGN", Const, 0, ""},
+ {"PR_TASK_PERF_EVENTS_DISABLE", Const, 0, ""},
+ {"PR_TASK_PERF_EVENTS_ENABLE", Const, 0, ""},
+ {"PR_TIMING_STATISTICAL", Const, 0, ""},
+ {"PR_TIMING_TIMESTAMP", Const, 0, ""},
+ {"PR_TSC_ENABLE", Const, 0, ""},
+ {"PR_TSC_SIGSEGV", Const, 0, ""},
+ {"PR_UNALIGN_NOPRINT", Const, 0, ""},
+ {"PR_UNALIGN_SIGBUS", Const, 0, ""},
+ {"PTRACE_ARCH_PRCTL", Const, 0, ""},
+ {"PTRACE_ATTACH", Const, 0, ""},
+ {"PTRACE_CONT", Const, 0, ""},
+ {"PTRACE_DETACH", Const, 0, ""},
+ {"PTRACE_EVENT_CLONE", Const, 0, ""},
+ {"PTRACE_EVENT_EXEC", Const, 0, ""},
+ {"PTRACE_EVENT_EXIT", Const, 0, ""},
+ {"PTRACE_EVENT_FORK", Const, 0, ""},
+ {"PTRACE_EVENT_VFORK", Const, 0, ""},
+ {"PTRACE_EVENT_VFORK_DONE", Const, 0, ""},
+ {"PTRACE_GETCRUNCHREGS", Const, 0, ""},
+ {"PTRACE_GETEVENTMSG", Const, 0, ""},
+ {"PTRACE_GETFPREGS", Const, 0, ""},
+ {"PTRACE_GETFPXREGS", Const, 0, ""},
+ {"PTRACE_GETHBPREGS", Const, 0, ""},
+ {"PTRACE_GETREGS", Const, 0, ""},
+ {"PTRACE_GETREGSET", Const, 0, ""},
+ {"PTRACE_GETSIGINFO", Const, 0, ""},
+ {"PTRACE_GETVFPREGS", Const, 0, ""},
+ {"PTRACE_GETWMMXREGS", Const, 0, ""},
+ {"PTRACE_GET_THREAD_AREA", Const, 0, ""},
+ {"PTRACE_KILL", Const, 0, ""},
+ {"PTRACE_OLDSETOPTIONS", Const, 0, ""},
+ {"PTRACE_O_MASK", Const, 0, ""},
+ {"PTRACE_O_TRACECLONE", Const, 0, ""},
+ {"PTRACE_O_TRACEEXEC", Const, 0, ""},
+ {"PTRACE_O_TRACEEXIT", Const, 0, ""},
+ {"PTRACE_O_TRACEFORK", Const, 0, ""},
+ {"PTRACE_O_TRACESYSGOOD", Const, 0, ""},
+ {"PTRACE_O_TRACEVFORK", Const, 0, ""},
+ {"PTRACE_O_TRACEVFORKDONE", Const, 0, ""},
+ {"PTRACE_PEEKDATA", Const, 0, ""},
+ {"PTRACE_PEEKTEXT", Const, 0, ""},
+ {"PTRACE_PEEKUSR", Const, 0, ""},
+ {"PTRACE_POKEDATA", Const, 0, ""},
+ {"PTRACE_POKETEXT", Const, 0, ""},
+ {"PTRACE_POKEUSR", Const, 0, ""},
+ {"PTRACE_SETCRUNCHREGS", Const, 0, ""},
+ {"PTRACE_SETFPREGS", Const, 0, ""},
+ {"PTRACE_SETFPXREGS", Const, 0, ""},
+ {"PTRACE_SETHBPREGS", Const, 0, ""},
+ {"PTRACE_SETOPTIONS", Const, 0, ""},
+ {"PTRACE_SETREGS", Const, 0, ""},
+ {"PTRACE_SETREGSET", Const, 0, ""},
+ {"PTRACE_SETSIGINFO", Const, 0, ""},
+ {"PTRACE_SETVFPREGS", Const, 0, ""},
+ {"PTRACE_SETWMMXREGS", Const, 0, ""},
+ {"PTRACE_SET_SYSCALL", Const, 0, ""},
+ {"PTRACE_SET_THREAD_AREA", Const, 0, ""},
+ {"PTRACE_SINGLEBLOCK", Const, 0, ""},
+ {"PTRACE_SINGLESTEP", Const, 0, ""},
+ {"PTRACE_SYSCALL", Const, 0, ""},
+ {"PTRACE_SYSEMU", Const, 0, ""},
+ {"PTRACE_SYSEMU_SINGLESTEP", Const, 0, ""},
+ {"PTRACE_TRACEME", Const, 0, ""},
+ {"PT_ATTACH", Const, 0, ""},
+ {"PT_ATTACHEXC", Const, 0, ""},
+ {"PT_CONTINUE", Const, 0, ""},
+ {"PT_DATA_ADDR", Const, 0, ""},
+ {"PT_DENY_ATTACH", Const, 0, ""},
+ {"PT_DETACH", Const, 0, ""},
+ {"PT_FIRSTMACH", Const, 0, ""},
+ {"PT_FORCEQUOTA", Const, 0, ""},
+ {"PT_KILL", Const, 0, ""},
+ {"PT_MASK", Const, 1, ""},
+ {"PT_READ_D", Const, 0, ""},
+ {"PT_READ_I", Const, 0, ""},
+ {"PT_READ_U", Const, 0, ""},
+ {"PT_SIGEXC", Const, 0, ""},
+ {"PT_STEP", Const, 0, ""},
+ {"PT_TEXT_ADDR", Const, 0, ""},
+ {"PT_TEXT_END_ADDR", Const, 0, ""},
+ {"PT_THUPDATE", Const, 0, ""},
+ {"PT_TRACE_ME", Const, 0, ""},
+ {"PT_WRITE_D", Const, 0, ""},
+ {"PT_WRITE_I", Const, 0, ""},
+ {"PT_WRITE_U", Const, 0, ""},
+ {"ParseDirent", Func, 0, "func(buf []byte, max int, names []string) (consumed int, count int, newnames []string)"},
+ {"ParseNetlinkMessage", Func, 0, "func(b []byte) ([]NetlinkMessage, error)"},
+ {"ParseNetlinkRouteAttr", Func, 0, "func(m *NetlinkMessage) ([]NetlinkRouteAttr, error)"},
+ {"ParseRoutingMessage", Func, 0, ""},
+ {"ParseRoutingSockaddr", Func, 0, ""},
+ {"ParseSocketControlMessage", Func, 0, "func(b []byte) ([]SocketControlMessage, error)"},
+ {"ParseUnixCredentials", Func, 0, "func(m *SocketControlMessage) (*Ucred, error)"},
+ {"ParseUnixRights", Func, 0, "func(m *SocketControlMessage) ([]int, error)"},
+ {"PathMax", Const, 0, ""},
+ {"Pathconf", Func, 0, ""},
+ {"Pause", Func, 0, "func() (err error)"},
+ {"Pipe", Func, 0, "func(p []int) error"},
+ {"Pipe2", Func, 1, "func(p []int, flags int) error"},
+ {"PivotRoot", Func, 0, "func(newroot string, putold string) (err error)"},
+ {"Pointer", Type, 11, ""},
+ {"PostQueuedCompletionStatus", Func, 0, ""},
+ {"Pread", Func, 0, "func(fd int, p []byte, offset int64) (n int, err error)"},
+ {"Proc", Type, 0, ""},
+ {"Proc.Dll", Field, 0, ""},
+ {"Proc.Name", Field, 0, ""},
+ {"ProcAttr", Type, 0, ""},
+ {"ProcAttr.Dir", Field, 0, ""},
+ {"ProcAttr.Env", Field, 0, ""},
+ {"ProcAttr.Files", Field, 0, ""},
+ {"ProcAttr.Sys", Field, 0, ""},
+ {"Process32First", Func, 4, ""},
+ {"Process32Next", Func, 4, ""},
+ {"ProcessEntry32", Type, 4, ""},
+ {"ProcessEntry32.DefaultHeapID", Field, 4, ""},
+ {"ProcessEntry32.ExeFile", Field, 4, ""},
+ {"ProcessEntry32.Flags", Field, 4, ""},
+ {"ProcessEntry32.ModuleID", Field, 4, ""},
+ {"ProcessEntry32.ParentProcessID", Field, 4, ""},
+ {"ProcessEntry32.PriClassBase", Field, 4, ""},
+ {"ProcessEntry32.ProcessID", Field, 4, ""},
+ {"ProcessEntry32.Size", Field, 4, ""},
+ {"ProcessEntry32.Threads", Field, 4, ""},
+ {"ProcessEntry32.Usage", Field, 4, ""},
+ {"ProcessInformation", Type, 0, ""},
+ {"ProcessInformation.Process", Field, 0, ""},
+ {"ProcessInformation.ProcessId", Field, 0, ""},
+ {"ProcessInformation.Thread", Field, 0, ""},
+ {"ProcessInformation.ThreadId", Field, 0, ""},
+ {"Protoent", Type, 0, ""},
+ {"Protoent.Aliases", Field, 0, ""},
+ {"Protoent.Name", Field, 0, ""},
+ {"Protoent.Proto", Field, 0, ""},
+ {"PtraceAttach", Func, 0, "func(pid int) (err error)"},
+ {"PtraceCont", Func, 0, "func(pid int, signal int) (err error)"},
+ {"PtraceDetach", Func, 0, "func(pid int) (err error)"},
+ {"PtraceGetEventMsg", Func, 0, "func(pid int) (msg uint, err error)"},
+ {"PtraceGetRegs", Func, 0, "func(pid int, regsout *PtraceRegs) (err error)"},
+ {"PtracePeekData", Func, 0, "func(pid int, addr uintptr, out []byte) (count int, err error)"},
+ {"PtracePeekText", Func, 0, "func(pid int, addr uintptr, out []byte) (count int, err error)"},
+ {"PtracePokeData", Func, 0, "func(pid int, addr uintptr, data []byte) (count int, err error)"},
+ {"PtracePokeText", Func, 0, "func(pid int, addr uintptr, data []byte) (count int, err error)"},
+ {"PtraceRegs", Type, 0, ""},
+ {"PtraceRegs.Cs", Field, 0, ""},
+ {"PtraceRegs.Ds", Field, 0, ""},
+ {"PtraceRegs.Eax", Field, 0, ""},
+ {"PtraceRegs.Ebp", Field, 0, ""},
+ {"PtraceRegs.Ebx", Field, 0, ""},
+ {"PtraceRegs.Ecx", Field, 0, ""},
+ {"PtraceRegs.Edi", Field, 0, ""},
+ {"PtraceRegs.Edx", Field, 0, ""},
+ {"PtraceRegs.Eflags", Field, 0, ""},
+ {"PtraceRegs.Eip", Field, 0, ""},
+ {"PtraceRegs.Es", Field, 0, ""},
+ {"PtraceRegs.Esi", Field, 0, ""},
+ {"PtraceRegs.Esp", Field, 0, ""},
+ {"PtraceRegs.Fs", Field, 0, ""},
+ {"PtraceRegs.Fs_base", Field, 0, ""},
+ {"PtraceRegs.Gs", Field, 0, ""},
+ {"PtraceRegs.Gs_base", Field, 0, ""},
+ {"PtraceRegs.Orig_eax", Field, 0, ""},
+ {"PtraceRegs.Orig_rax", Field, 0, ""},
+ {"PtraceRegs.R10", Field, 0, ""},
+ {"PtraceRegs.R11", Field, 0, ""},
+ {"PtraceRegs.R12", Field, 0, ""},
+ {"PtraceRegs.R13", Field, 0, ""},
+ {"PtraceRegs.R14", Field, 0, ""},
+ {"PtraceRegs.R15", Field, 0, ""},
+ {"PtraceRegs.R8", Field, 0, ""},
+ {"PtraceRegs.R9", Field, 0, ""},
+ {"PtraceRegs.Rax", Field, 0, ""},
+ {"PtraceRegs.Rbp", Field, 0, ""},
+ {"PtraceRegs.Rbx", Field, 0, ""},
+ {"PtraceRegs.Rcx", Field, 0, ""},
+ {"PtraceRegs.Rdi", Field, 0, ""},
+ {"PtraceRegs.Rdx", Field, 0, ""},
+ {"PtraceRegs.Rip", Field, 0, ""},
+ {"PtraceRegs.Rsi", Field, 0, ""},
+ {"PtraceRegs.Rsp", Field, 0, ""},
+ {"PtraceRegs.Ss", Field, 0, ""},
+ {"PtraceRegs.Uregs", Field, 0, ""},
+ {"PtraceRegs.Xcs", Field, 0, ""},
+ {"PtraceRegs.Xds", Field, 0, ""},
+ {"PtraceRegs.Xes", Field, 0, ""},
+ {"PtraceRegs.Xfs", Field, 0, ""},
+ {"PtraceRegs.Xgs", Field, 0, ""},
+ {"PtraceRegs.Xss", Field, 0, ""},
+ {"PtraceSetOptions", Func, 0, "func(pid int, options int) (err error)"},
+ {"PtraceSetRegs", Func, 0, "func(pid int, regs *PtraceRegs) (err error)"},
+ {"PtraceSingleStep", Func, 0, "func(pid int) (err error)"},
+ {"PtraceSyscall", Func, 1, "func(pid int, signal int) (err error)"},
+ {"Pwrite", Func, 0, "func(fd int, p []byte, offset int64) (n int, err error)"},
+ {"REG_BINARY", Const, 0, ""},
+ {"REG_DWORD", Const, 0, ""},
+ {"REG_DWORD_BIG_ENDIAN", Const, 0, ""},
+ {"REG_DWORD_LITTLE_ENDIAN", Const, 0, ""},
+ {"REG_EXPAND_SZ", Const, 0, ""},
+ {"REG_FULL_RESOURCE_DESCRIPTOR", Const, 0, ""},
+ {"REG_LINK", Const, 0, ""},
+ {"REG_MULTI_SZ", Const, 0, ""},
+ {"REG_NONE", Const, 0, ""},
+ {"REG_QWORD", Const, 0, ""},
+ {"REG_QWORD_LITTLE_ENDIAN", Const, 0, ""},
+ {"REG_RESOURCE_LIST", Const, 0, ""},
+ {"REG_RESOURCE_REQUIREMENTS_LIST", Const, 0, ""},
+ {"REG_SZ", Const, 0, ""},
+ {"RLIMIT_AS", Const, 0, ""},
+ {"RLIMIT_CORE", Const, 0, ""},
+ {"RLIMIT_CPU", Const, 0, ""},
+ {"RLIMIT_CPU_USAGE_MONITOR", Const, 16, ""},
+ {"RLIMIT_DATA", Const, 0, ""},
+ {"RLIMIT_FSIZE", Const, 0, ""},
+ {"RLIMIT_NOFILE", Const, 0, ""},
+ {"RLIMIT_STACK", Const, 0, ""},
+ {"RLIM_INFINITY", Const, 0, ""},
+ {"RTAX_ADVMSS", Const, 0, ""},
+ {"RTAX_AUTHOR", Const, 0, ""},
+ {"RTAX_BRD", Const, 0, ""},
+ {"RTAX_CWND", Const, 0, ""},
+ {"RTAX_DST", Const, 0, ""},
+ {"RTAX_FEATURES", Const, 0, ""},
+ {"RTAX_FEATURE_ALLFRAG", Const, 0, ""},
+ {"RTAX_FEATURE_ECN", Const, 0, ""},
+ {"RTAX_FEATURE_SACK", Const, 0, ""},
+ {"RTAX_FEATURE_TIMESTAMP", Const, 0, ""},
+ {"RTAX_GATEWAY", Const, 0, ""},
+ {"RTAX_GENMASK", Const, 0, ""},
+ {"RTAX_HOPLIMIT", Const, 0, ""},
+ {"RTAX_IFA", Const, 0, ""},
+ {"RTAX_IFP", Const, 0, ""},
+ {"RTAX_INITCWND", Const, 0, ""},
+ {"RTAX_INITRWND", Const, 0, ""},
+ {"RTAX_LABEL", Const, 1, ""},
+ {"RTAX_LOCK", Const, 0, ""},
+ {"RTAX_MAX", Const, 0, ""},
+ {"RTAX_MTU", Const, 0, ""},
+ {"RTAX_NETMASK", Const, 0, ""},
+ {"RTAX_REORDERING", Const, 0, ""},
+ {"RTAX_RTO_MIN", Const, 0, ""},
+ {"RTAX_RTT", Const, 0, ""},
+ {"RTAX_RTTVAR", Const, 0, ""},
+ {"RTAX_SRC", Const, 1, ""},
+ {"RTAX_SRCMASK", Const, 1, ""},
+ {"RTAX_SSTHRESH", Const, 0, ""},
+ {"RTAX_TAG", Const, 1, ""},
+ {"RTAX_UNSPEC", Const, 0, ""},
+ {"RTAX_WINDOW", Const, 0, ""},
+ {"RTA_ALIGNTO", Const, 0, ""},
+ {"RTA_AUTHOR", Const, 0, ""},
+ {"RTA_BRD", Const, 0, ""},
+ {"RTA_CACHEINFO", Const, 0, ""},
+ {"RTA_DST", Const, 0, ""},
+ {"RTA_FLOW", Const, 0, ""},
+ {"RTA_GATEWAY", Const, 0, ""},
+ {"RTA_GENMASK", Const, 0, ""},
+ {"RTA_IFA", Const, 0, ""},
+ {"RTA_IFP", Const, 0, ""},
+ {"RTA_IIF", Const, 0, ""},
+ {"RTA_LABEL", Const, 1, ""},
+ {"RTA_MAX", Const, 0, ""},
+ {"RTA_METRICS", Const, 0, ""},
+ {"RTA_MULTIPATH", Const, 0, ""},
+ {"RTA_NETMASK", Const, 0, ""},
+ {"RTA_OIF", Const, 0, ""},
+ {"RTA_PREFSRC", Const, 0, ""},
+ {"RTA_PRIORITY", Const, 0, ""},
+ {"RTA_SRC", Const, 0, ""},
+ {"RTA_SRCMASK", Const, 1, ""},
+ {"RTA_TABLE", Const, 0, ""},
+ {"RTA_TAG", Const, 1, ""},
+ {"RTA_UNSPEC", Const, 0, ""},
+ {"RTCF_DIRECTSRC", Const, 0, ""},
+ {"RTCF_DOREDIRECT", Const, 0, ""},
+ {"RTCF_LOG", Const, 0, ""},
+ {"RTCF_MASQ", Const, 0, ""},
+ {"RTCF_NAT", Const, 0, ""},
+ {"RTCF_VALVE", Const, 0, ""},
+ {"RTF_ADDRCLASSMASK", Const, 0, ""},
+ {"RTF_ADDRCONF", Const, 0, ""},
+ {"RTF_ALLONLINK", Const, 0, ""},
+ {"RTF_ANNOUNCE", Const, 1, ""},
+ {"RTF_BLACKHOLE", Const, 0, ""},
+ {"RTF_BROADCAST", Const, 0, ""},
+ {"RTF_CACHE", Const, 0, ""},
+ {"RTF_CLONED", Const, 1, ""},
+ {"RTF_CLONING", Const, 0, ""},
+ {"RTF_CONDEMNED", Const, 0, ""},
+ {"RTF_DEFAULT", Const, 0, ""},
+ {"RTF_DELCLONE", Const, 0, ""},
+ {"RTF_DONE", Const, 0, ""},
+ {"RTF_DYNAMIC", Const, 0, ""},
+ {"RTF_FLOW", Const, 0, ""},
+ {"RTF_FMASK", Const, 0, ""},
+ {"RTF_GATEWAY", Const, 0, ""},
+ {"RTF_GWFLAG_COMPAT", Const, 3, ""},
+ {"RTF_HOST", Const, 0, ""},
+ {"RTF_IFREF", Const, 0, ""},
+ {"RTF_IFSCOPE", Const, 0, ""},
+ {"RTF_INTERFACE", Const, 0, ""},
+ {"RTF_IRTT", Const, 0, ""},
+ {"RTF_LINKRT", Const, 0, ""},
+ {"RTF_LLDATA", Const, 0, ""},
+ {"RTF_LLINFO", Const, 0, ""},
+ {"RTF_LOCAL", Const, 0, ""},
+ {"RTF_MASK", Const, 1, ""},
+ {"RTF_MODIFIED", Const, 0, ""},
+ {"RTF_MPATH", Const, 1, ""},
+ {"RTF_MPLS", Const, 1, ""},
+ {"RTF_MSS", Const, 0, ""},
+ {"RTF_MTU", Const, 0, ""},
+ {"RTF_MULTICAST", Const, 0, ""},
+ {"RTF_NAT", Const, 0, ""},
+ {"RTF_NOFORWARD", Const, 0, ""},
+ {"RTF_NONEXTHOP", Const, 0, ""},
+ {"RTF_NOPMTUDISC", Const, 0, ""},
+ {"RTF_PERMANENT_ARP", Const, 1, ""},
+ {"RTF_PINNED", Const, 0, ""},
+ {"RTF_POLICY", Const, 0, ""},
+ {"RTF_PRCLONING", Const, 0, ""},
+ {"RTF_PROTO1", Const, 0, ""},
+ {"RTF_PROTO2", Const, 0, ""},
+ {"RTF_PROTO3", Const, 0, ""},
+ {"RTF_PROXY", Const, 16, ""},
+ {"RTF_REINSTATE", Const, 0, ""},
+ {"RTF_REJECT", Const, 0, ""},
+ {"RTF_RNH_LOCKED", Const, 0, ""},
+ {"RTF_ROUTER", Const, 16, ""},
+ {"RTF_SOURCE", Const, 1, ""},
+ {"RTF_SRC", Const, 1, ""},
+ {"RTF_STATIC", Const, 0, ""},
+ {"RTF_STICKY", Const, 0, ""},
+ {"RTF_THROW", Const, 0, ""},
+ {"RTF_TUNNEL", Const, 1, ""},
+ {"RTF_UP", Const, 0, ""},
+ {"RTF_USETRAILERS", Const, 1, ""},
+ {"RTF_WASCLONED", Const, 0, ""},
+ {"RTF_WINDOW", Const, 0, ""},
+ {"RTF_XRESOLVE", Const, 0, ""},
+ {"RTM_ADD", Const, 0, ""},
+ {"RTM_BASE", Const, 0, ""},
+ {"RTM_CHANGE", Const, 0, ""},
+ {"RTM_CHGADDR", Const, 1, ""},
+ {"RTM_DELACTION", Const, 0, ""},
+ {"RTM_DELADDR", Const, 0, ""},
+ {"RTM_DELADDRLABEL", Const, 0, ""},
+ {"RTM_DELETE", Const, 0, ""},
+ {"RTM_DELLINK", Const, 0, ""},
+ {"RTM_DELMADDR", Const, 0, ""},
+ {"RTM_DELNEIGH", Const, 0, ""},
+ {"RTM_DELQDISC", Const, 0, ""},
+ {"RTM_DELROUTE", Const, 0, ""},
+ {"RTM_DELRULE", Const, 0, ""},
+ {"RTM_DELTCLASS", Const, 0, ""},
+ {"RTM_DELTFILTER", Const, 0, ""},
+ {"RTM_DESYNC", Const, 1, ""},
+ {"RTM_F_CLONED", Const, 0, ""},
+ {"RTM_F_EQUALIZE", Const, 0, ""},
+ {"RTM_F_NOTIFY", Const, 0, ""},
+ {"RTM_F_PREFIX", Const, 0, ""},
+ {"RTM_GET", Const, 0, ""},
+ {"RTM_GET2", Const, 0, ""},
+ {"RTM_GETACTION", Const, 0, ""},
+ {"RTM_GETADDR", Const, 0, ""},
+ {"RTM_GETADDRLABEL", Const, 0, ""},
+ {"RTM_GETANYCAST", Const, 0, ""},
+ {"RTM_GETDCB", Const, 0, ""},
+ {"RTM_GETLINK", Const, 0, ""},
+ {"RTM_GETMULTICAST", Const, 0, ""},
+ {"RTM_GETNEIGH", Const, 0, ""},
+ {"RTM_GETNEIGHTBL", Const, 0, ""},
+ {"RTM_GETQDISC", Const, 0, ""},
+ {"RTM_GETROUTE", Const, 0, ""},
+ {"RTM_GETRULE", Const, 0, ""},
+ {"RTM_GETTCLASS", Const, 0, ""},
+ {"RTM_GETTFILTER", Const, 0, ""},
+ {"RTM_IEEE80211", Const, 0, ""},
+ {"RTM_IFANNOUNCE", Const, 0, ""},
+ {"RTM_IFINFO", Const, 0, ""},
+ {"RTM_IFINFO2", Const, 0, ""},
+ {"RTM_LLINFO_UPD", Const, 1, ""},
+ {"RTM_LOCK", Const, 0, ""},
+ {"RTM_LOSING", Const, 0, ""},
+ {"RTM_MAX", Const, 0, ""},
+ {"RTM_MAXSIZE", Const, 1, ""},
+ {"RTM_MISS", Const, 0, ""},
+ {"RTM_NEWACTION", Const, 0, ""},
+ {"RTM_NEWADDR", Const, 0, ""},
+ {"RTM_NEWADDRLABEL", Const, 0, ""},
+ {"RTM_NEWLINK", Const, 0, ""},
+ {"RTM_NEWMADDR", Const, 0, ""},
+ {"RTM_NEWMADDR2", Const, 0, ""},
+ {"RTM_NEWNDUSEROPT", Const, 0, ""},
+ {"RTM_NEWNEIGH", Const, 0, ""},
+ {"RTM_NEWNEIGHTBL", Const, 0, ""},
+ {"RTM_NEWPREFIX", Const, 0, ""},
+ {"RTM_NEWQDISC", Const, 0, ""},
+ {"RTM_NEWROUTE", Const, 0, ""},
+ {"RTM_NEWRULE", Const, 0, ""},
+ {"RTM_NEWTCLASS", Const, 0, ""},
+ {"RTM_NEWTFILTER", Const, 0, ""},
+ {"RTM_NR_FAMILIES", Const, 0, ""},
+ {"RTM_NR_MSGTYPES", Const, 0, ""},
+ {"RTM_OIFINFO", Const, 1, ""},
+ {"RTM_OLDADD", Const, 0, ""},
+ {"RTM_OLDDEL", Const, 0, ""},
+ {"RTM_OOIFINFO", Const, 1, ""},
+ {"RTM_REDIRECT", Const, 0, ""},
+ {"RTM_RESOLVE", Const, 0, ""},
+ {"RTM_RTTUNIT", Const, 0, ""},
+ {"RTM_SETDCB", Const, 0, ""},
+ {"RTM_SETGATE", Const, 1, ""},
+ {"RTM_SETLINK", Const, 0, ""},
+ {"RTM_SETNEIGHTBL", Const, 0, ""},
+ {"RTM_VERSION", Const, 0, ""},
+ {"RTNH_ALIGNTO", Const, 0, ""},
+ {"RTNH_F_DEAD", Const, 0, ""},
+ {"RTNH_F_ONLINK", Const, 0, ""},
+ {"RTNH_F_PERVASIVE", Const, 0, ""},
+ {"RTNLGRP_IPV4_IFADDR", Const, 1, ""},
+ {"RTNLGRP_IPV4_MROUTE", Const, 1, ""},
+ {"RTNLGRP_IPV4_ROUTE", Const, 1, ""},
+ {"RTNLGRP_IPV4_RULE", Const, 1, ""},
+ {"RTNLGRP_IPV6_IFADDR", Const, 1, ""},
+ {"RTNLGRP_IPV6_IFINFO", Const, 1, ""},
+ {"RTNLGRP_IPV6_MROUTE", Const, 1, ""},
+ {"RTNLGRP_IPV6_PREFIX", Const, 1, ""},
+ {"RTNLGRP_IPV6_ROUTE", Const, 1, ""},
+ {"RTNLGRP_IPV6_RULE", Const, 1, ""},
+ {"RTNLGRP_LINK", Const, 1, ""},
+ {"RTNLGRP_ND_USEROPT", Const, 1, ""},
+ {"RTNLGRP_NEIGH", Const, 1, ""},
+ {"RTNLGRP_NONE", Const, 1, ""},
+ {"RTNLGRP_NOTIFY", Const, 1, ""},
+ {"RTNLGRP_TC", Const, 1, ""},
+ {"RTN_ANYCAST", Const, 0, ""},
+ {"RTN_BLACKHOLE", Const, 0, ""},
+ {"RTN_BROADCAST", Const, 0, ""},
+ {"RTN_LOCAL", Const, 0, ""},
+ {"RTN_MAX", Const, 0, ""},
+ {"RTN_MULTICAST", Const, 0, ""},
+ {"RTN_NAT", Const, 0, ""},
+ {"RTN_PROHIBIT", Const, 0, ""},
+ {"RTN_THROW", Const, 0, ""},
+ {"RTN_UNICAST", Const, 0, ""},
+ {"RTN_UNREACHABLE", Const, 0, ""},
+ {"RTN_UNSPEC", Const, 0, ""},
+ {"RTN_XRESOLVE", Const, 0, ""},
+ {"RTPROT_BIRD", Const, 0, ""},
+ {"RTPROT_BOOT", Const, 0, ""},
+ {"RTPROT_DHCP", Const, 0, ""},
+ {"RTPROT_DNROUTED", Const, 0, ""},
+ {"RTPROT_GATED", Const, 0, ""},
+ {"RTPROT_KERNEL", Const, 0, ""},
+ {"RTPROT_MRT", Const, 0, ""},
+ {"RTPROT_NTK", Const, 0, ""},
+ {"RTPROT_RA", Const, 0, ""},
+ {"RTPROT_REDIRECT", Const, 0, ""},
+ {"RTPROT_STATIC", Const, 0, ""},
+ {"RTPROT_UNSPEC", Const, 0, ""},
+ {"RTPROT_XORP", Const, 0, ""},
+ {"RTPROT_ZEBRA", Const, 0, ""},
+ {"RTV_EXPIRE", Const, 0, ""},
+ {"RTV_HOPCOUNT", Const, 0, ""},
+ {"RTV_MTU", Const, 0, ""},
+ {"RTV_RPIPE", Const, 0, ""},
+ {"RTV_RTT", Const, 0, ""},
+ {"RTV_RTTVAR", Const, 0, ""},
+ {"RTV_SPIPE", Const, 0, ""},
+ {"RTV_SSTHRESH", Const, 0, ""},
+ {"RTV_WEIGHT", Const, 0, ""},
+ {"RT_CACHING_CONTEXT", Const, 1, ""},
+ {"RT_CLASS_DEFAULT", Const, 0, ""},
+ {"RT_CLASS_LOCAL", Const, 0, ""},
+ {"RT_CLASS_MAIN", Const, 0, ""},
+ {"RT_CLASS_MAX", Const, 0, ""},
+ {"RT_CLASS_UNSPEC", Const, 0, ""},
+ {"RT_DEFAULT_FIB", Const, 1, ""},
+ {"RT_NORTREF", Const, 1, ""},
+ {"RT_SCOPE_HOST", Const, 0, ""},
+ {"RT_SCOPE_LINK", Const, 0, ""},
+ {"RT_SCOPE_NOWHERE", Const, 0, ""},
+ {"RT_SCOPE_SITE", Const, 0, ""},
+ {"RT_SCOPE_UNIVERSE", Const, 0, ""},
+ {"RT_TABLEID_MAX", Const, 1, ""},
+ {"RT_TABLE_COMPAT", Const, 0, ""},
+ {"RT_TABLE_DEFAULT", Const, 0, ""},
+ {"RT_TABLE_LOCAL", Const, 0, ""},
+ {"RT_TABLE_MAIN", Const, 0, ""},
+ {"RT_TABLE_MAX", Const, 0, ""},
+ {"RT_TABLE_UNSPEC", Const, 0, ""},
+ {"RUSAGE_CHILDREN", Const, 0, ""},
+ {"RUSAGE_SELF", Const, 0, ""},
+ {"RUSAGE_THREAD", Const, 0, ""},
+ {"Radvisory_t", Type, 0, ""},
+ {"Radvisory_t.Count", Field, 0, ""},
+ {"Radvisory_t.Offset", Field, 0, ""},
+ {"Radvisory_t.Pad_cgo_0", Field, 0, ""},
+ {"RawConn", Type, 9, ""},
+ {"RawSockaddr", Type, 0, ""},
+ {"RawSockaddr.Data", Field, 0, ""},
+ {"RawSockaddr.Family", Field, 0, ""},
+ {"RawSockaddr.Len", Field, 0, ""},
+ {"RawSockaddrAny", Type, 0, ""},
+ {"RawSockaddrAny.Addr", Field, 0, ""},
+ {"RawSockaddrAny.Pad", Field, 0, ""},
+ {"RawSockaddrDatalink", Type, 0, ""},
+ {"RawSockaddrDatalink.Alen", Field, 0, ""},
+ {"RawSockaddrDatalink.Data", Field, 0, ""},
+ {"RawSockaddrDatalink.Family", Field, 0, ""},
+ {"RawSockaddrDatalink.Index", Field, 0, ""},
+ {"RawSockaddrDatalink.Len", Field, 0, ""},
+ {"RawSockaddrDatalink.Nlen", Field, 0, ""},
+ {"RawSockaddrDatalink.Pad_cgo_0", Field, 2, ""},
+ {"RawSockaddrDatalink.Slen", Field, 0, ""},
+ {"RawSockaddrDatalink.Type", Field, 0, ""},
+ {"RawSockaddrInet4", Type, 0, ""},
+ {"RawSockaddrInet4.Addr", Field, 0, ""},
+ {"RawSockaddrInet4.Family", Field, 0, ""},
+ {"RawSockaddrInet4.Len", Field, 0, ""},
+ {"RawSockaddrInet4.Port", Field, 0, ""},
+ {"RawSockaddrInet4.Zero", Field, 0, ""},
+ {"RawSockaddrInet6", Type, 0, ""},
+ {"RawSockaddrInet6.Addr", Field, 0, ""},
+ {"RawSockaddrInet6.Family", Field, 0, ""},
+ {"RawSockaddrInet6.Flowinfo", Field, 0, ""},
+ {"RawSockaddrInet6.Len", Field, 0, ""},
+ {"RawSockaddrInet6.Port", Field, 0, ""},
+ {"RawSockaddrInet6.Scope_id", Field, 0, ""},
+ {"RawSockaddrLinklayer", Type, 0, ""},
+ {"RawSockaddrLinklayer.Addr", Field, 0, ""},
+ {"RawSockaddrLinklayer.Family", Field, 0, ""},
+ {"RawSockaddrLinklayer.Halen", Field, 0, ""},
+ {"RawSockaddrLinklayer.Hatype", Field, 0, ""},
+ {"RawSockaddrLinklayer.Ifindex", Field, 0, ""},
+ {"RawSockaddrLinklayer.Pkttype", Field, 0, ""},
+ {"RawSockaddrLinklayer.Protocol", Field, 0, ""},
+ {"RawSockaddrNetlink", Type, 0, ""},
+ {"RawSockaddrNetlink.Family", Field, 0, ""},
+ {"RawSockaddrNetlink.Groups", Field, 0, ""},
+ {"RawSockaddrNetlink.Pad", Field, 0, ""},
+ {"RawSockaddrNetlink.Pid", Field, 0, ""},
+ {"RawSockaddrUnix", Type, 0, ""},
+ {"RawSockaddrUnix.Family", Field, 0, ""},
+ {"RawSockaddrUnix.Len", Field, 0, ""},
+ {"RawSockaddrUnix.Pad_cgo_0", Field, 2, ""},
+ {"RawSockaddrUnix.Path", Field, 0, ""},
+ {"RawSyscall", Func, 0, "func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err Errno)"},
+ {"RawSyscall6", Func, 0, "func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, err Errno)"},
+ {"Read", Func, 0, "func(fd int, p []byte) (n int, err error)"},
+ {"ReadConsole", Func, 1, ""},
+ {"ReadDirectoryChanges", Func, 0, ""},
+ {"ReadDirent", Func, 0, "func(fd int, buf []byte) (n int, err error)"},
+ {"ReadFile", Func, 0, ""},
+ {"Readlink", Func, 0, "func(path string, buf []byte) (n int, err error)"},
+ {"Reboot", Func, 0, "func(cmd int) (err error)"},
+ {"Recvfrom", Func, 0, "func(fd int, p []byte, flags int) (n int, from Sockaddr, err error)"},
+ {"Recvmsg", Func, 0, "func(fd int, p []byte, oob []byte, flags int) (n int, oobn int, recvflags int, from Sockaddr, err error)"},
+ {"RegCloseKey", Func, 0, ""},
+ {"RegEnumKeyEx", Func, 0, ""},
+ {"RegOpenKeyEx", Func, 0, ""},
+ {"RegQueryInfoKey", Func, 0, ""},
+ {"RegQueryValueEx", Func, 0, ""},
+ {"RemoveDirectory", Func, 0, ""},
+ {"Removexattr", Func, 1, "func(path string, attr string) (err error)"},
+ {"Rename", Func, 0, "func(oldpath string, newpath string) (err error)"},
+ {"Renameat", Func, 0, "func(olddirfd int, oldpath string, newdirfd int, newpath string) (err error)"},
+ {"Revoke", Func, 0, ""},
+ {"Rlimit", Type, 0, ""},
+ {"Rlimit.Cur", Field, 0, ""},
+ {"Rlimit.Max", Field, 0, ""},
+ {"Rmdir", Func, 0, "func(path string) error"},
+ {"RouteMessage", Type, 0, ""},
+ {"RouteMessage.Data", Field, 0, ""},
+ {"RouteMessage.Header", Field, 0, ""},
+ {"RouteRIB", Func, 0, ""},
+ {"RoutingMessage", Type, 0, ""},
+ {"RtAttr", Type, 0, ""},
+ {"RtAttr.Len", Field, 0, ""},
+ {"RtAttr.Type", Field, 0, ""},
+ {"RtGenmsg", Type, 0, ""},
+ {"RtGenmsg.Family", Field, 0, ""},
+ {"RtMetrics", Type, 0, ""},
+ {"RtMetrics.Expire", Field, 0, ""},
+ {"RtMetrics.Filler", Field, 0, ""},
+ {"RtMetrics.Hopcount", Field, 0, ""},
+ {"RtMetrics.Locks", Field, 0, ""},
+ {"RtMetrics.Mtu", Field, 0, ""},
+ {"RtMetrics.Pad", Field, 3, ""},
+ {"RtMetrics.Pksent", Field, 0, ""},
+ {"RtMetrics.Recvpipe", Field, 0, ""},
+ {"RtMetrics.Refcnt", Field, 2, ""},
+ {"RtMetrics.Rtt", Field, 0, ""},
+ {"RtMetrics.Rttvar", Field, 0, ""},
+ {"RtMetrics.Sendpipe", Field, 0, ""},
+ {"RtMetrics.Ssthresh", Field, 0, ""},
+ {"RtMetrics.Weight", Field, 0, ""},
+ {"RtMsg", Type, 0, ""},
+ {"RtMsg.Dst_len", Field, 0, ""},
+ {"RtMsg.Family", Field, 0, ""},
+ {"RtMsg.Flags", Field, 0, ""},
+ {"RtMsg.Protocol", Field, 0, ""},
+ {"RtMsg.Scope", Field, 0, ""},
+ {"RtMsg.Src_len", Field, 0, ""},
+ {"RtMsg.Table", Field, 0, ""},
+ {"RtMsg.Tos", Field, 0, ""},
+ {"RtMsg.Type", Field, 0, ""},
+ {"RtMsghdr", Type, 0, ""},
+ {"RtMsghdr.Addrs", Field, 0, ""},
+ {"RtMsghdr.Errno", Field, 0, ""},
+ {"RtMsghdr.Flags", Field, 0, ""},
+ {"RtMsghdr.Fmask", Field, 0, ""},
+ {"RtMsghdr.Hdrlen", Field, 2, ""},
+ {"RtMsghdr.Index", Field, 0, ""},
+ {"RtMsghdr.Inits", Field, 0, ""},
+ {"RtMsghdr.Mpls", Field, 2, ""},
+ {"RtMsghdr.Msglen", Field, 0, ""},
+ {"RtMsghdr.Pad_cgo_0", Field, 0, ""},
+ {"RtMsghdr.Pad_cgo_1", Field, 2, ""},
+ {"RtMsghdr.Pid", Field, 0, ""},
+ {"RtMsghdr.Priority", Field, 2, ""},
+ {"RtMsghdr.Rmx", Field, 0, ""},
+ {"RtMsghdr.Seq", Field, 0, ""},
+ {"RtMsghdr.Tableid", Field, 2, ""},
+ {"RtMsghdr.Type", Field, 0, ""},
+ {"RtMsghdr.Use", Field, 0, ""},
+ {"RtMsghdr.Version", Field, 0, ""},
+ {"RtNexthop", Type, 0, ""},
+ {"RtNexthop.Flags", Field, 0, ""},
+ {"RtNexthop.Hops", Field, 0, ""},
+ {"RtNexthop.Ifindex", Field, 0, ""},
+ {"RtNexthop.Len", Field, 0, ""},
+ {"Rusage", Type, 0, ""},
+ {"Rusage.CreationTime", Field, 0, ""},
+ {"Rusage.ExitTime", Field, 0, ""},
+ {"Rusage.Idrss", Field, 0, ""},
+ {"Rusage.Inblock", Field, 0, ""},
+ {"Rusage.Isrss", Field, 0, ""},
+ {"Rusage.Ixrss", Field, 0, ""},
+ {"Rusage.KernelTime", Field, 0, ""},
+ {"Rusage.Majflt", Field, 0, ""},
+ {"Rusage.Maxrss", Field, 0, ""},
+ {"Rusage.Minflt", Field, 0, ""},
+ {"Rusage.Msgrcv", Field, 0, ""},
+ {"Rusage.Msgsnd", Field, 0, ""},
+ {"Rusage.Nivcsw", Field, 0, ""},
+ {"Rusage.Nsignals", Field, 0, ""},
+ {"Rusage.Nswap", Field, 0, ""},
+ {"Rusage.Nvcsw", Field, 0, ""},
+ {"Rusage.Oublock", Field, 0, ""},
+ {"Rusage.Stime", Field, 0, ""},
+ {"Rusage.UserTime", Field, 0, ""},
+ {"Rusage.Utime", Field, 0, ""},
+ {"SCM_BINTIME", Const, 0, ""},
+ {"SCM_CREDENTIALS", Const, 0, ""},
+ {"SCM_CREDS", Const, 0, ""},
+ {"SCM_RIGHTS", Const, 0, ""},
+ {"SCM_TIMESTAMP", Const, 0, ""},
+ {"SCM_TIMESTAMPING", Const, 0, ""},
+ {"SCM_TIMESTAMPNS", Const, 0, ""},
+ {"SCM_TIMESTAMP_MONOTONIC", Const, 0, ""},
+ {"SHUT_RD", Const, 0, ""},
+ {"SHUT_RDWR", Const, 0, ""},
+ {"SHUT_WR", Const, 0, ""},
+ {"SID", Type, 0, ""},
+ {"SIDAndAttributes", Type, 0, ""},
+ {"SIDAndAttributes.Attributes", Field, 0, ""},
+ {"SIDAndAttributes.Sid", Field, 0, ""},
+ {"SIGABRT", Const, 0, ""},
+ {"SIGALRM", Const, 0, ""},
+ {"SIGBUS", Const, 0, ""},
+ {"SIGCHLD", Const, 0, ""},
+ {"SIGCLD", Const, 0, ""},
+ {"SIGCONT", Const, 0, ""},
+ {"SIGEMT", Const, 0, ""},
+ {"SIGFPE", Const, 0, ""},
+ {"SIGHUP", Const, 0, ""},
+ {"SIGILL", Const, 0, ""},
+ {"SIGINFO", Const, 0, ""},
+ {"SIGINT", Const, 0, ""},
+ {"SIGIO", Const, 0, ""},
+ {"SIGIOT", Const, 0, ""},
+ {"SIGKILL", Const, 0, ""},
+ {"SIGLIBRT", Const, 1, ""},
+ {"SIGLWP", Const, 0, ""},
+ {"SIGPIPE", Const, 0, ""},
+ {"SIGPOLL", Const, 0, ""},
+ {"SIGPROF", Const, 0, ""},
+ {"SIGPWR", Const, 0, ""},
+ {"SIGQUIT", Const, 0, ""},
+ {"SIGSEGV", Const, 0, ""},
+ {"SIGSTKFLT", Const, 0, ""},
+ {"SIGSTOP", Const, 0, ""},
+ {"SIGSYS", Const, 0, ""},
+ {"SIGTERM", Const, 0, ""},
+ {"SIGTHR", Const, 0, ""},
+ {"SIGTRAP", Const, 0, ""},
+ {"SIGTSTP", Const, 0, ""},
+ {"SIGTTIN", Const, 0, ""},
+ {"SIGTTOU", Const, 0, ""},
+ {"SIGUNUSED", Const, 0, ""},
+ {"SIGURG", Const, 0, ""},
+ {"SIGUSR1", Const, 0, ""},
+ {"SIGUSR2", Const, 0, ""},
+ {"SIGVTALRM", Const, 0, ""},
+ {"SIGWINCH", Const, 0, ""},
+ {"SIGXCPU", Const, 0, ""},
+ {"SIGXFSZ", Const, 0, ""},
+ {"SIOCADDDLCI", Const, 0, ""},
+ {"SIOCADDMULTI", Const, 0, ""},
+ {"SIOCADDRT", Const, 0, ""},
+ {"SIOCAIFADDR", Const, 0, ""},
+ {"SIOCAIFGROUP", Const, 0, ""},
+ {"SIOCALIFADDR", Const, 0, ""},
+ {"SIOCARPIPLL", Const, 0, ""},
+ {"SIOCATMARK", Const, 0, ""},
+ {"SIOCAUTOADDR", Const, 0, ""},
+ {"SIOCAUTONETMASK", Const, 0, ""},
+ {"SIOCBRDGADD", Const, 1, ""},
+ {"SIOCBRDGADDS", Const, 1, ""},
+ {"SIOCBRDGARL", Const, 1, ""},
+ {"SIOCBRDGDADDR", Const, 1, ""},
+ {"SIOCBRDGDEL", Const, 1, ""},
+ {"SIOCBRDGDELS", Const, 1, ""},
+ {"SIOCBRDGFLUSH", Const, 1, ""},
+ {"SIOCBRDGFRL", Const, 1, ""},
+ {"SIOCBRDGGCACHE", Const, 1, ""},
+ {"SIOCBRDGGFD", Const, 1, ""},
+ {"SIOCBRDGGHT", Const, 1, ""},
+ {"SIOCBRDGGIFFLGS", Const, 1, ""},
+ {"SIOCBRDGGMA", Const, 1, ""},
+ {"SIOCBRDGGPARAM", Const, 1, ""},
+ {"SIOCBRDGGPRI", Const, 1, ""},
+ {"SIOCBRDGGRL", Const, 1, ""},
+ {"SIOCBRDGGSIFS", Const, 1, ""},
+ {"SIOCBRDGGTO", Const, 1, ""},
+ {"SIOCBRDGIFS", Const, 1, ""},
+ {"SIOCBRDGRTS", Const, 1, ""},
+ {"SIOCBRDGSADDR", Const, 1, ""},
+ {"SIOCBRDGSCACHE", Const, 1, ""},
+ {"SIOCBRDGSFD", Const, 1, ""},
+ {"SIOCBRDGSHT", Const, 1, ""},
+ {"SIOCBRDGSIFCOST", Const, 1, ""},
+ {"SIOCBRDGSIFFLGS", Const, 1, ""},
+ {"SIOCBRDGSIFPRIO", Const, 1, ""},
+ {"SIOCBRDGSMA", Const, 1, ""},
+ {"SIOCBRDGSPRI", Const, 1, ""},
+ {"SIOCBRDGSPROTO", Const, 1, ""},
+ {"SIOCBRDGSTO", Const, 1, ""},
+ {"SIOCBRDGSTXHC", Const, 1, ""},
+ {"SIOCDARP", Const, 0, ""},
+ {"SIOCDELDLCI", Const, 0, ""},
+ {"SIOCDELMULTI", Const, 0, ""},
+ {"SIOCDELRT", Const, 0, ""},
+ {"SIOCDEVPRIVATE", Const, 0, ""},
+ {"SIOCDIFADDR", Const, 0, ""},
+ {"SIOCDIFGROUP", Const, 0, ""},
+ {"SIOCDIFPHYADDR", Const, 0, ""},
+ {"SIOCDLIFADDR", Const, 0, ""},
+ {"SIOCDRARP", Const, 0, ""},
+ {"SIOCGARP", Const, 0, ""},
+ {"SIOCGDRVSPEC", Const, 0, ""},
+ {"SIOCGETKALIVE", Const, 1, ""},
+ {"SIOCGETLABEL", Const, 1, ""},
+ {"SIOCGETPFLOW", Const, 1, ""},
+ {"SIOCGETPFSYNC", Const, 1, ""},
+ {"SIOCGETSGCNT", Const, 0, ""},
+ {"SIOCGETVIFCNT", Const, 0, ""},
+ {"SIOCGETVLAN", Const, 0, ""},
+ {"SIOCGHIWAT", Const, 0, ""},
+ {"SIOCGIFADDR", Const, 0, ""},
+ {"SIOCGIFADDRPREF", Const, 1, ""},
+ {"SIOCGIFALIAS", Const, 1, ""},
+ {"SIOCGIFALTMTU", Const, 0, ""},
+ {"SIOCGIFASYNCMAP", Const, 0, ""},
+ {"SIOCGIFBOND", Const, 0, ""},
+ {"SIOCGIFBR", Const, 0, ""},
+ {"SIOCGIFBRDADDR", Const, 0, ""},
+ {"SIOCGIFCAP", Const, 0, ""},
+ {"SIOCGIFCONF", Const, 0, ""},
+ {"SIOCGIFCOUNT", Const, 0, ""},
+ {"SIOCGIFDATA", Const, 1, ""},
+ {"SIOCGIFDESCR", Const, 0, ""},
+ {"SIOCGIFDEVMTU", Const, 0, ""},
+ {"SIOCGIFDLT", Const, 1, ""},
+ {"SIOCGIFDSTADDR", Const, 0, ""},
+ {"SIOCGIFENCAP", Const, 0, ""},
+ {"SIOCGIFFIB", Const, 1, ""},
+ {"SIOCGIFFLAGS", Const, 0, ""},
+ {"SIOCGIFGATTR", Const, 1, ""},
+ {"SIOCGIFGENERIC", Const, 0, ""},
+ {"SIOCGIFGMEMB", Const, 0, ""},
+ {"SIOCGIFGROUP", Const, 0, ""},
+ {"SIOCGIFHARDMTU", Const, 3, ""},
+ {"SIOCGIFHWADDR", Const, 0, ""},
+ {"SIOCGIFINDEX", Const, 0, ""},
+ {"SIOCGIFKPI", Const, 0, ""},
+ {"SIOCGIFMAC", Const, 0, ""},
+ {"SIOCGIFMAP", Const, 0, ""},
+ {"SIOCGIFMEDIA", Const, 0, ""},
+ {"SIOCGIFMEM", Const, 0, ""},
+ {"SIOCGIFMETRIC", Const, 0, ""},
+ {"SIOCGIFMTU", Const, 0, ""},
+ {"SIOCGIFNAME", Const, 0, ""},
+ {"SIOCGIFNETMASK", Const, 0, ""},
+ {"SIOCGIFPDSTADDR", Const, 0, ""},
+ {"SIOCGIFPFLAGS", Const, 0, ""},
+ {"SIOCGIFPHYS", Const, 0, ""},
+ {"SIOCGIFPRIORITY", Const, 1, ""},
+ {"SIOCGIFPSRCADDR", Const, 0, ""},
+ {"SIOCGIFRDOMAIN", Const, 1, ""},
+ {"SIOCGIFRTLABEL", Const, 1, ""},
+ {"SIOCGIFSLAVE", Const, 0, ""},
+ {"SIOCGIFSTATUS", Const, 0, ""},
+ {"SIOCGIFTIMESLOT", Const, 1, ""},
+ {"SIOCGIFTXQLEN", Const, 0, ""},
+ {"SIOCGIFVLAN", Const, 0, ""},
+ {"SIOCGIFWAKEFLAGS", Const, 0, ""},
+ {"SIOCGIFXFLAGS", Const, 1, ""},
+ {"SIOCGLIFADDR", Const, 0, ""},
+ {"SIOCGLIFPHYADDR", Const, 0, ""},
+ {"SIOCGLIFPHYRTABLE", Const, 1, ""},
+ {"SIOCGLIFPHYTTL", Const, 3, ""},
+ {"SIOCGLINKSTR", Const, 1, ""},
+ {"SIOCGLOWAT", Const, 0, ""},
+ {"SIOCGPGRP", Const, 0, ""},
+ {"SIOCGPRIVATE_0", Const, 0, ""},
+ {"SIOCGPRIVATE_1", Const, 0, ""},
+ {"SIOCGRARP", Const, 0, ""},
+ {"SIOCGSPPPPARAMS", Const, 3, ""},
+ {"SIOCGSTAMP", Const, 0, ""},
+ {"SIOCGSTAMPNS", Const, 0, ""},
+ {"SIOCGVH", Const, 1, ""},
+ {"SIOCGVNETID", Const, 3, ""},
+ {"SIOCIFCREATE", Const, 0, ""},
+ {"SIOCIFCREATE2", Const, 0, ""},
+ {"SIOCIFDESTROY", Const, 0, ""},
+ {"SIOCIFGCLONERS", Const, 0, ""},
+ {"SIOCINITIFADDR", Const, 1, ""},
+ {"SIOCPROTOPRIVATE", Const, 0, ""},
+ {"SIOCRSLVMULTI", Const, 0, ""},
+ {"SIOCRTMSG", Const, 0, ""},
+ {"SIOCSARP", Const, 0, ""},
+ {"SIOCSDRVSPEC", Const, 0, ""},
+ {"SIOCSETKALIVE", Const, 1, ""},
+ {"SIOCSETLABEL", Const, 1, ""},
+ {"SIOCSETPFLOW", Const, 1, ""},
+ {"SIOCSETPFSYNC", Const, 1, ""},
+ {"SIOCSETVLAN", Const, 0, ""},
+ {"SIOCSHIWAT", Const, 0, ""},
+ {"SIOCSIFADDR", Const, 0, ""},
+ {"SIOCSIFADDRPREF", Const, 1, ""},
+ {"SIOCSIFALTMTU", Const, 0, ""},
+ {"SIOCSIFASYNCMAP", Const, 0, ""},
+ {"SIOCSIFBOND", Const, 0, ""},
+ {"SIOCSIFBR", Const, 0, ""},
+ {"SIOCSIFBRDADDR", Const, 0, ""},
+ {"SIOCSIFCAP", Const, 0, ""},
+ {"SIOCSIFDESCR", Const, 0, ""},
+ {"SIOCSIFDSTADDR", Const, 0, ""},
+ {"SIOCSIFENCAP", Const, 0, ""},
+ {"SIOCSIFFIB", Const, 1, ""},
+ {"SIOCSIFFLAGS", Const, 0, ""},
+ {"SIOCSIFGATTR", Const, 1, ""},
+ {"SIOCSIFGENERIC", Const, 0, ""},
+ {"SIOCSIFHWADDR", Const, 0, ""},
+ {"SIOCSIFHWBROADCAST", Const, 0, ""},
+ {"SIOCSIFKPI", Const, 0, ""},
+ {"SIOCSIFLINK", Const, 0, ""},
+ {"SIOCSIFLLADDR", Const, 0, ""},
+ {"SIOCSIFMAC", Const, 0, ""},
+ {"SIOCSIFMAP", Const, 0, ""},
+ {"SIOCSIFMEDIA", Const, 0, ""},
+ {"SIOCSIFMEM", Const, 0, ""},
+ {"SIOCSIFMETRIC", Const, 0, ""},
+ {"SIOCSIFMTU", Const, 0, ""},
+ {"SIOCSIFNAME", Const, 0, ""},
+ {"SIOCSIFNETMASK", Const, 0, ""},
+ {"SIOCSIFPFLAGS", Const, 0, ""},
+ {"SIOCSIFPHYADDR", Const, 0, ""},
+ {"SIOCSIFPHYS", Const, 0, ""},
+ {"SIOCSIFPRIORITY", Const, 1, ""},
+ {"SIOCSIFRDOMAIN", Const, 1, ""},
+ {"SIOCSIFRTLABEL", Const, 1, ""},
+ {"SIOCSIFRVNET", Const, 0, ""},
+ {"SIOCSIFSLAVE", Const, 0, ""},
+ {"SIOCSIFTIMESLOT", Const, 1, ""},
+ {"SIOCSIFTXQLEN", Const, 0, ""},
+ {"SIOCSIFVLAN", Const, 0, ""},
+ {"SIOCSIFVNET", Const, 0, ""},
+ {"SIOCSIFXFLAGS", Const, 1, ""},
+ {"SIOCSLIFPHYADDR", Const, 0, ""},
+ {"SIOCSLIFPHYRTABLE", Const, 1, ""},
+ {"SIOCSLIFPHYTTL", Const, 3, ""},
+ {"SIOCSLINKSTR", Const, 1, ""},
+ {"SIOCSLOWAT", Const, 0, ""},
+ {"SIOCSPGRP", Const, 0, ""},
+ {"SIOCSRARP", Const, 0, ""},
+ {"SIOCSSPPPPARAMS", Const, 3, ""},
+ {"SIOCSVH", Const, 1, ""},
+ {"SIOCSVNETID", Const, 3, ""},
+ {"SIOCZIFDATA", Const, 1, ""},
+ {"SIO_GET_EXTENSION_FUNCTION_POINTER", Const, 1, ""},
+ {"SIO_GET_INTERFACE_LIST", Const, 0, ""},
+ {"SIO_KEEPALIVE_VALS", Const, 3, ""},
+ {"SIO_UDP_CONNRESET", Const, 4, ""},
+ {"SOCK_CLOEXEC", Const, 0, ""},
+ {"SOCK_DCCP", Const, 0, ""},
+ {"SOCK_DGRAM", Const, 0, ""},
+ {"SOCK_FLAGS_MASK", Const, 1, ""},
+ {"SOCK_MAXADDRLEN", Const, 0, ""},
+ {"SOCK_NONBLOCK", Const, 0, ""},
+ {"SOCK_NOSIGPIPE", Const, 1, ""},
+ {"SOCK_PACKET", Const, 0, ""},
+ {"SOCK_RAW", Const, 0, ""},
+ {"SOCK_RDM", Const, 0, ""},
+ {"SOCK_SEQPACKET", Const, 0, ""},
+ {"SOCK_STREAM", Const, 0, ""},
+ {"SOL_AAL", Const, 0, ""},
+ {"SOL_ATM", Const, 0, ""},
+ {"SOL_DECNET", Const, 0, ""},
+ {"SOL_ICMPV6", Const, 0, ""},
+ {"SOL_IP", Const, 0, ""},
+ {"SOL_IPV6", Const, 0, ""},
+ {"SOL_IRDA", Const, 0, ""},
+ {"SOL_PACKET", Const, 0, ""},
+ {"SOL_RAW", Const, 0, ""},
+ {"SOL_SOCKET", Const, 0, ""},
+ {"SOL_TCP", Const, 0, ""},
+ {"SOL_X25", Const, 0, ""},
+ {"SOMAXCONN", Const, 0, ""},
+ {"SO_ACCEPTCONN", Const, 0, ""},
+ {"SO_ACCEPTFILTER", Const, 0, ""},
+ {"SO_ATTACH_FILTER", Const, 0, ""},
+ {"SO_BINDANY", Const, 1, ""},
+ {"SO_BINDTODEVICE", Const, 0, ""},
+ {"SO_BINTIME", Const, 0, ""},
+ {"SO_BROADCAST", Const, 0, ""},
+ {"SO_BSDCOMPAT", Const, 0, ""},
+ {"SO_DEBUG", Const, 0, ""},
+ {"SO_DETACH_FILTER", Const, 0, ""},
+ {"SO_DOMAIN", Const, 0, ""},
+ {"SO_DONTROUTE", Const, 0, ""},
+ {"SO_DONTTRUNC", Const, 0, ""},
+ {"SO_ERROR", Const, 0, ""},
+ {"SO_KEEPALIVE", Const, 0, ""},
+ {"SO_LABEL", Const, 0, ""},
+ {"SO_LINGER", Const, 0, ""},
+ {"SO_LINGER_SEC", Const, 0, ""},
+ {"SO_LISTENINCQLEN", Const, 0, ""},
+ {"SO_LISTENQLEN", Const, 0, ""},
+ {"SO_LISTENQLIMIT", Const, 0, ""},
+ {"SO_MARK", Const, 0, ""},
+ {"SO_NETPROC", Const, 1, ""},
+ {"SO_NKE", Const, 0, ""},
+ {"SO_NOADDRERR", Const, 0, ""},
+ {"SO_NOHEADER", Const, 1, ""},
+ {"SO_NOSIGPIPE", Const, 0, ""},
+ {"SO_NOTIFYCONFLICT", Const, 0, ""},
+ {"SO_NO_CHECK", Const, 0, ""},
+ {"SO_NO_DDP", Const, 0, ""},
+ {"SO_NO_OFFLOAD", Const, 0, ""},
+ {"SO_NP_EXTENSIONS", Const, 0, ""},
+ {"SO_NREAD", Const, 0, ""},
+ {"SO_NUMRCVPKT", Const, 16, ""},
+ {"SO_NWRITE", Const, 0, ""},
+ {"SO_OOBINLINE", Const, 0, ""},
+ {"SO_OVERFLOWED", Const, 1, ""},
+ {"SO_PASSCRED", Const, 0, ""},
+ {"SO_PASSSEC", Const, 0, ""},
+ {"SO_PEERCRED", Const, 0, ""},
+ {"SO_PEERLABEL", Const, 0, ""},
+ {"SO_PEERNAME", Const, 0, ""},
+ {"SO_PEERSEC", Const, 0, ""},
+ {"SO_PRIORITY", Const, 0, ""},
+ {"SO_PROTOCOL", Const, 0, ""},
+ {"SO_PROTOTYPE", Const, 1, ""},
+ {"SO_RANDOMPORT", Const, 0, ""},
+ {"SO_RCVBUF", Const, 0, ""},
+ {"SO_RCVBUFFORCE", Const, 0, ""},
+ {"SO_RCVLOWAT", Const, 0, ""},
+ {"SO_RCVTIMEO", Const, 0, ""},
+ {"SO_RESTRICTIONS", Const, 0, ""},
+ {"SO_RESTRICT_DENYIN", Const, 0, ""},
+ {"SO_RESTRICT_DENYOUT", Const, 0, ""},
+ {"SO_RESTRICT_DENYSET", Const, 0, ""},
+ {"SO_REUSEADDR", Const, 0, ""},
+ {"SO_REUSEPORT", Const, 0, ""},
+ {"SO_REUSESHAREUID", Const, 0, ""},
+ {"SO_RTABLE", Const, 1, ""},
+ {"SO_RXQ_OVFL", Const, 0, ""},
+ {"SO_SECURITY_AUTHENTICATION", Const, 0, ""},
+ {"SO_SECURITY_ENCRYPTION_NETWORK", Const, 0, ""},
+ {"SO_SECURITY_ENCRYPTION_TRANSPORT", Const, 0, ""},
+ {"SO_SETFIB", Const, 0, ""},
+ {"SO_SNDBUF", Const, 0, ""},
+ {"SO_SNDBUFFORCE", Const, 0, ""},
+ {"SO_SNDLOWAT", Const, 0, ""},
+ {"SO_SNDTIMEO", Const, 0, ""},
+ {"SO_SPLICE", Const, 1, ""},
+ {"SO_TIMESTAMP", Const, 0, ""},
+ {"SO_TIMESTAMPING", Const, 0, ""},
+ {"SO_TIMESTAMPNS", Const, 0, ""},
+ {"SO_TIMESTAMP_MONOTONIC", Const, 0, ""},
+ {"SO_TYPE", Const, 0, ""},
+ {"SO_UPCALLCLOSEWAIT", Const, 0, ""},
+ {"SO_UPDATE_ACCEPT_CONTEXT", Const, 0, ""},
+ {"SO_UPDATE_CONNECT_CONTEXT", Const, 1, ""},
+ {"SO_USELOOPBACK", Const, 0, ""},
+ {"SO_USER_COOKIE", Const, 1, ""},
+ {"SO_VENDOR", Const, 3, ""},
+ {"SO_WANTMORE", Const, 0, ""},
+ {"SO_WANTOOBFLAG", Const, 0, ""},
+ {"SSLExtraCertChainPolicyPara", Type, 0, ""},
+ {"SSLExtraCertChainPolicyPara.AuthType", Field, 0, ""},
+ {"SSLExtraCertChainPolicyPara.Checks", Field, 0, ""},
+ {"SSLExtraCertChainPolicyPara.ServerName", Field, 0, ""},
+ {"SSLExtraCertChainPolicyPara.Size", Field, 0, ""},
+ {"STANDARD_RIGHTS_ALL", Const, 0, ""},
+ {"STANDARD_RIGHTS_EXECUTE", Const, 0, ""},
+ {"STANDARD_RIGHTS_READ", Const, 0, ""},
+ {"STANDARD_RIGHTS_REQUIRED", Const, 0, ""},
+ {"STANDARD_RIGHTS_WRITE", Const, 0, ""},
+ {"STARTF_USESHOWWINDOW", Const, 0, ""},
+ {"STARTF_USESTDHANDLES", Const, 0, ""},
+ {"STD_ERROR_HANDLE", Const, 0, ""},
+ {"STD_INPUT_HANDLE", Const, 0, ""},
+ {"STD_OUTPUT_HANDLE", Const, 0, ""},
+ {"SUBLANG_ENGLISH_US", Const, 0, ""},
+ {"SW_FORCEMINIMIZE", Const, 0, ""},
+ {"SW_HIDE", Const, 0, ""},
+ {"SW_MAXIMIZE", Const, 0, ""},
+ {"SW_MINIMIZE", Const, 0, ""},
+ {"SW_NORMAL", Const, 0, ""},
+ {"SW_RESTORE", Const, 0, ""},
+ {"SW_SHOW", Const, 0, ""},
+ {"SW_SHOWDEFAULT", Const, 0, ""},
+ {"SW_SHOWMAXIMIZED", Const, 0, ""},
+ {"SW_SHOWMINIMIZED", Const, 0, ""},
+ {"SW_SHOWMINNOACTIVE", Const, 0, ""},
+ {"SW_SHOWNA", Const, 0, ""},
+ {"SW_SHOWNOACTIVATE", Const, 0, ""},
+ {"SW_SHOWNORMAL", Const, 0, ""},
+ {"SYMBOLIC_LINK_FLAG_DIRECTORY", Const, 4, ""},
+ {"SYNCHRONIZE", Const, 0, ""},
+ {"SYSCTL_VERSION", Const, 1, ""},
+ {"SYSCTL_VERS_0", Const, 1, ""},
+ {"SYSCTL_VERS_1", Const, 1, ""},
+ {"SYSCTL_VERS_MASK", Const, 1, ""},
+ {"SYS_ABORT2", Const, 0, ""},
+ {"SYS_ACCEPT", Const, 0, ""},
+ {"SYS_ACCEPT4", Const, 0, ""},
+ {"SYS_ACCEPT_NOCANCEL", Const, 0, ""},
+ {"SYS_ACCESS", Const, 0, ""},
+ {"SYS_ACCESS_EXTENDED", Const, 0, ""},
+ {"SYS_ACCT", Const, 0, ""},
+ {"SYS_ADD_KEY", Const, 0, ""},
+ {"SYS_ADD_PROFIL", Const, 0, ""},
+ {"SYS_ADJFREQ", Const, 1, ""},
+ {"SYS_ADJTIME", Const, 0, ""},
+ {"SYS_ADJTIMEX", Const, 0, ""},
+ {"SYS_AFS_SYSCALL", Const, 0, ""},
+ {"SYS_AIO_CANCEL", Const, 0, ""},
+ {"SYS_AIO_ERROR", Const, 0, ""},
+ {"SYS_AIO_FSYNC", Const, 0, ""},
+ {"SYS_AIO_MLOCK", Const, 14, ""},
+ {"SYS_AIO_READ", Const, 0, ""},
+ {"SYS_AIO_RETURN", Const, 0, ""},
+ {"SYS_AIO_SUSPEND", Const, 0, ""},
+ {"SYS_AIO_SUSPEND_NOCANCEL", Const, 0, ""},
+ {"SYS_AIO_WAITCOMPLETE", Const, 14, ""},
+ {"SYS_AIO_WRITE", Const, 0, ""},
+ {"SYS_ALARM", Const, 0, ""},
+ {"SYS_ARCH_PRCTL", Const, 0, ""},
+ {"SYS_ARM_FADVISE64_64", Const, 0, ""},
+ {"SYS_ARM_SYNC_FILE_RANGE", Const, 0, ""},
+ {"SYS_ATGETMSG", Const, 0, ""},
+ {"SYS_ATPGETREQ", Const, 0, ""},
+ {"SYS_ATPGETRSP", Const, 0, ""},
+ {"SYS_ATPSNDREQ", Const, 0, ""},
+ {"SYS_ATPSNDRSP", Const, 0, ""},
+ {"SYS_ATPUTMSG", Const, 0, ""},
+ {"SYS_ATSOCKET", Const, 0, ""},
+ {"SYS_AUDIT", Const, 0, ""},
+ {"SYS_AUDITCTL", Const, 0, ""},
+ {"SYS_AUDITON", Const, 0, ""},
+ {"SYS_AUDIT_SESSION_JOIN", Const, 0, ""},
+ {"SYS_AUDIT_SESSION_PORT", Const, 0, ""},
+ {"SYS_AUDIT_SESSION_SELF", Const, 0, ""},
+ {"SYS_BDFLUSH", Const, 0, ""},
+ {"SYS_BIND", Const, 0, ""},
+ {"SYS_BINDAT", Const, 3, ""},
+ {"SYS_BREAK", Const, 0, ""},
+ {"SYS_BRK", Const, 0, ""},
+ {"SYS_BSDTHREAD_CREATE", Const, 0, ""},
+ {"SYS_BSDTHREAD_REGISTER", Const, 0, ""},
+ {"SYS_BSDTHREAD_TERMINATE", Const, 0, ""},
+ {"SYS_CAPGET", Const, 0, ""},
+ {"SYS_CAPSET", Const, 0, ""},
+ {"SYS_CAP_ENTER", Const, 0, ""},
+ {"SYS_CAP_FCNTLS_GET", Const, 1, ""},
+ {"SYS_CAP_FCNTLS_LIMIT", Const, 1, ""},
+ {"SYS_CAP_GETMODE", Const, 0, ""},
+ {"SYS_CAP_GETRIGHTS", Const, 0, ""},
+ {"SYS_CAP_IOCTLS_GET", Const, 1, ""},
+ {"SYS_CAP_IOCTLS_LIMIT", Const, 1, ""},
+ {"SYS_CAP_NEW", Const, 0, ""},
+ {"SYS_CAP_RIGHTS_GET", Const, 1, ""},
+ {"SYS_CAP_RIGHTS_LIMIT", Const, 1, ""},
+ {"SYS_CHDIR", Const, 0, ""},
+ {"SYS_CHFLAGS", Const, 0, ""},
+ {"SYS_CHFLAGSAT", Const, 3, ""},
+ {"SYS_CHMOD", Const, 0, ""},
+ {"SYS_CHMOD_EXTENDED", Const, 0, ""},
+ {"SYS_CHOWN", Const, 0, ""},
+ {"SYS_CHOWN32", Const, 0, ""},
+ {"SYS_CHROOT", Const, 0, ""},
+ {"SYS_CHUD", Const, 0, ""},
+ {"SYS_CLOCK_ADJTIME", Const, 0, ""},
+ {"SYS_CLOCK_GETCPUCLOCKID2", Const, 1, ""},
+ {"SYS_CLOCK_GETRES", Const, 0, ""},
+ {"SYS_CLOCK_GETTIME", Const, 0, ""},
+ {"SYS_CLOCK_NANOSLEEP", Const, 0, ""},
+ {"SYS_CLOCK_SETTIME", Const, 0, ""},
+ {"SYS_CLONE", Const, 0, ""},
+ {"SYS_CLOSE", Const, 0, ""},
+ {"SYS_CLOSEFROM", Const, 0, ""},
+ {"SYS_CLOSE_NOCANCEL", Const, 0, ""},
+ {"SYS_CONNECT", Const, 0, ""},
+ {"SYS_CONNECTAT", Const, 3, ""},
+ {"SYS_CONNECT_NOCANCEL", Const, 0, ""},
+ {"SYS_COPYFILE", Const, 0, ""},
+ {"SYS_CPUSET", Const, 0, ""},
+ {"SYS_CPUSET_GETAFFINITY", Const, 0, ""},
+ {"SYS_CPUSET_GETID", Const, 0, ""},
+ {"SYS_CPUSET_SETAFFINITY", Const, 0, ""},
+ {"SYS_CPUSET_SETID", Const, 0, ""},
+ {"SYS_CREAT", Const, 0, ""},
+ {"SYS_CREATE_MODULE", Const, 0, ""},
+ {"SYS_CSOPS", Const, 0, ""},
+ {"SYS_CSOPS_AUDITTOKEN", Const, 16, ""},
+ {"SYS_DELETE", Const, 0, ""},
+ {"SYS_DELETE_MODULE", Const, 0, ""},
+ {"SYS_DUP", Const, 0, ""},
+ {"SYS_DUP2", Const, 0, ""},
+ {"SYS_DUP3", Const, 0, ""},
+ {"SYS_EACCESS", Const, 0, ""},
+ {"SYS_EPOLL_CREATE", Const, 0, ""},
+ {"SYS_EPOLL_CREATE1", Const, 0, ""},
+ {"SYS_EPOLL_CTL", Const, 0, ""},
+ {"SYS_EPOLL_CTL_OLD", Const, 0, ""},
+ {"SYS_EPOLL_PWAIT", Const, 0, ""},
+ {"SYS_EPOLL_WAIT", Const, 0, ""},
+ {"SYS_EPOLL_WAIT_OLD", Const, 0, ""},
+ {"SYS_EVENTFD", Const, 0, ""},
+ {"SYS_EVENTFD2", Const, 0, ""},
+ {"SYS_EXCHANGEDATA", Const, 0, ""},
+ {"SYS_EXECVE", Const, 0, ""},
+ {"SYS_EXIT", Const, 0, ""},
+ {"SYS_EXIT_GROUP", Const, 0, ""},
+ {"SYS_EXTATTRCTL", Const, 0, ""},
+ {"SYS_EXTATTR_DELETE_FD", Const, 0, ""},
+ {"SYS_EXTATTR_DELETE_FILE", Const, 0, ""},
+ {"SYS_EXTATTR_DELETE_LINK", Const, 0, ""},
+ {"SYS_EXTATTR_GET_FD", Const, 0, ""},
+ {"SYS_EXTATTR_GET_FILE", Const, 0, ""},
+ {"SYS_EXTATTR_GET_LINK", Const, 0, ""},
+ {"SYS_EXTATTR_LIST_FD", Const, 0, ""},
+ {"SYS_EXTATTR_LIST_FILE", Const, 0, ""},
+ {"SYS_EXTATTR_LIST_LINK", Const, 0, ""},
+ {"SYS_EXTATTR_SET_FD", Const, 0, ""},
+ {"SYS_EXTATTR_SET_FILE", Const, 0, ""},
+ {"SYS_EXTATTR_SET_LINK", Const, 0, ""},
+ {"SYS_FACCESSAT", Const, 0, ""},
+ {"SYS_FADVISE64", Const, 0, ""},
+ {"SYS_FADVISE64_64", Const, 0, ""},
+ {"SYS_FALLOCATE", Const, 0, ""},
+ {"SYS_FANOTIFY_INIT", Const, 0, ""},
+ {"SYS_FANOTIFY_MARK", Const, 0, ""},
+ {"SYS_FCHDIR", Const, 0, ""},
+ {"SYS_FCHFLAGS", Const, 0, ""},
+ {"SYS_FCHMOD", Const, 0, ""},
+ {"SYS_FCHMODAT", Const, 0, ""},
+ {"SYS_FCHMOD_EXTENDED", Const, 0, ""},
+ {"SYS_FCHOWN", Const, 0, ""},
+ {"SYS_FCHOWN32", Const, 0, ""},
+ {"SYS_FCHOWNAT", Const, 0, ""},
+ {"SYS_FCHROOT", Const, 1, ""},
+ {"SYS_FCNTL", Const, 0, ""},
+ {"SYS_FCNTL64", Const, 0, ""},
+ {"SYS_FCNTL_NOCANCEL", Const, 0, ""},
+ {"SYS_FDATASYNC", Const, 0, ""},
+ {"SYS_FEXECVE", Const, 0, ""},
+ {"SYS_FFCLOCK_GETCOUNTER", Const, 0, ""},
+ {"SYS_FFCLOCK_GETESTIMATE", Const, 0, ""},
+ {"SYS_FFCLOCK_SETESTIMATE", Const, 0, ""},
+ {"SYS_FFSCTL", Const, 0, ""},
+ {"SYS_FGETATTRLIST", Const, 0, ""},
+ {"SYS_FGETXATTR", Const, 0, ""},
+ {"SYS_FHOPEN", Const, 0, ""},
+ {"SYS_FHSTAT", Const, 0, ""},
+ {"SYS_FHSTATFS", Const, 0, ""},
+ {"SYS_FILEPORT_MAKEFD", Const, 0, ""},
+ {"SYS_FILEPORT_MAKEPORT", Const, 0, ""},
+ {"SYS_FKTRACE", Const, 1, ""},
+ {"SYS_FLISTXATTR", Const, 0, ""},
+ {"SYS_FLOCK", Const, 0, ""},
+ {"SYS_FORK", Const, 0, ""},
+ {"SYS_FPATHCONF", Const, 0, ""},
+ {"SYS_FREEBSD6_FTRUNCATE", Const, 0, ""},
+ {"SYS_FREEBSD6_LSEEK", Const, 0, ""},
+ {"SYS_FREEBSD6_MMAP", Const, 0, ""},
+ {"SYS_FREEBSD6_PREAD", Const, 0, ""},
+ {"SYS_FREEBSD6_PWRITE", Const, 0, ""},
+ {"SYS_FREEBSD6_TRUNCATE", Const, 0, ""},
+ {"SYS_FREMOVEXATTR", Const, 0, ""},
+ {"SYS_FSCTL", Const, 0, ""},
+ {"SYS_FSETATTRLIST", Const, 0, ""},
+ {"SYS_FSETXATTR", Const, 0, ""},
+ {"SYS_FSGETPATH", Const, 0, ""},
+ {"SYS_FSTAT", Const, 0, ""},
+ {"SYS_FSTAT64", Const, 0, ""},
+ {"SYS_FSTAT64_EXTENDED", Const, 0, ""},
+ {"SYS_FSTATAT", Const, 0, ""},
+ {"SYS_FSTATAT64", Const, 0, ""},
+ {"SYS_FSTATFS", Const, 0, ""},
+ {"SYS_FSTATFS64", Const, 0, ""},
+ {"SYS_FSTATV", Const, 0, ""},
+ {"SYS_FSTATVFS1", Const, 1, ""},
+ {"SYS_FSTAT_EXTENDED", Const, 0, ""},
+ {"SYS_FSYNC", Const, 0, ""},
+ {"SYS_FSYNC_NOCANCEL", Const, 0, ""},
+ {"SYS_FSYNC_RANGE", Const, 1, ""},
+ {"SYS_FTIME", Const, 0, ""},
+ {"SYS_FTRUNCATE", Const, 0, ""},
+ {"SYS_FTRUNCATE64", Const, 0, ""},
+ {"SYS_FUTEX", Const, 0, ""},
+ {"SYS_FUTIMENS", Const, 1, ""},
+ {"SYS_FUTIMES", Const, 0, ""},
+ {"SYS_FUTIMESAT", Const, 0, ""},
+ {"SYS_GETATTRLIST", Const, 0, ""},
+ {"SYS_GETAUDIT", Const, 0, ""},
+ {"SYS_GETAUDIT_ADDR", Const, 0, ""},
+ {"SYS_GETAUID", Const, 0, ""},
+ {"SYS_GETCONTEXT", Const, 0, ""},
+ {"SYS_GETCPU", Const, 0, ""},
+ {"SYS_GETCWD", Const, 0, ""},
+ {"SYS_GETDENTS", Const, 0, ""},
+ {"SYS_GETDENTS64", Const, 0, ""},
+ {"SYS_GETDIRENTRIES", Const, 0, ""},
+ {"SYS_GETDIRENTRIES64", Const, 0, ""},
+ {"SYS_GETDIRENTRIESATTR", Const, 0, ""},
+ {"SYS_GETDTABLECOUNT", Const, 1, ""},
+ {"SYS_GETDTABLESIZE", Const, 0, ""},
+ {"SYS_GETEGID", Const, 0, ""},
+ {"SYS_GETEGID32", Const, 0, ""},
+ {"SYS_GETEUID", Const, 0, ""},
+ {"SYS_GETEUID32", Const, 0, ""},
+ {"SYS_GETFH", Const, 0, ""},
+ {"SYS_GETFSSTAT", Const, 0, ""},
+ {"SYS_GETFSSTAT64", Const, 0, ""},
+ {"SYS_GETGID", Const, 0, ""},
+ {"SYS_GETGID32", Const, 0, ""},
+ {"SYS_GETGROUPS", Const, 0, ""},
+ {"SYS_GETGROUPS32", Const, 0, ""},
+ {"SYS_GETHOSTUUID", Const, 0, ""},
+ {"SYS_GETITIMER", Const, 0, ""},
+ {"SYS_GETLCID", Const, 0, ""},
+ {"SYS_GETLOGIN", Const, 0, ""},
+ {"SYS_GETLOGINCLASS", Const, 0, ""},
+ {"SYS_GETPEERNAME", Const, 0, ""},
+ {"SYS_GETPGID", Const, 0, ""},
+ {"SYS_GETPGRP", Const, 0, ""},
+ {"SYS_GETPID", Const, 0, ""},
+ {"SYS_GETPMSG", Const, 0, ""},
+ {"SYS_GETPPID", Const, 0, ""},
+ {"SYS_GETPRIORITY", Const, 0, ""},
+ {"SYS_GETRESGID", Const, 0, ""},
+ {"SYS_GETRESGID32", Const, 0, ""},
+ {"SYS_GETRESUID", Const, 0, ""},
+ {"SYS_GETRESUID32", Const, 0, ""},
+ {"SYS_GETRLIMIT", Const, 0, ""},
+ {"SYS_GETRTABLE", Const, 1, ""},
+ {"SYS_GETRUSAGE", Const, 0, ""},
+ {"SYS_GETSGROUPS", Const, 0, ""},
+ {"SYS_GETSID", Const, 0, ""},
+ {"SYS_GETSOCKNAME", Const, 0, ""},
+ {"SYS_GETSOCKOPT", Const, 0, ""},
+ {"SYS_GETTHRID", Const, 1, ""},
+ {"SYS_GETTID", Const, 0, ""},
+ {"SYS_GETTIMEOFDAY", Const, 0, ""},
+ {"SYS_GETUID", Const, 0, ""},
+ {"SYS_GETUID32", Const, 0, ""},
+ {"SYS_GETVFSSTAT", Const, 1, ""},
+ {"SYS_GETWGROUPS", Const, 0, ""},
+ {"SYS_GETXATTR", Const, 0, ""},
+ {"SYS_GET_KERNEL_SYMS", Const, 0, ""},
+ {"SYS_GET_MEMPOLICY", Const, 0, ""},
+ {"SYS_GET_ROBUST_LIST", Const, 0, ""},
+ {"SYS_GET_THREAD_AREA", Const, 0, ""},
+ {"SYS_GSSD_SYSCALL", Const, 14, ""},
+ {"SYS_GTTY", Const, 0, ""},
+ {"SYS_IDENTITYSVC", Const, 0, ""},
+ {"SYS_IDLE", Const, 0, ""},
+ {"SYS_INITGROUPS", Const, 0, ""},
+ {"SYS_INIT_MODULE", Const, 0, ""},
+ {"SYS_INOTIFY_ADD_WATCH", Const, 0, ""},
+ {"SYS_INOTIFY_INIT", Const, 0, ""},
+ {"SYS_INOTIFY_INIT1", Const, 0, ""},
+ {"SYS_INOTIFY_RM_WATCH", Const, 0, ""},
+ {"SYS_IOCTL", Const, 0, ""},
+ {"SYS_IOPERM", Const, 0, ""},
+ {"SYS_IOPL", Const, 0, ""},
+ {"SYS_IOPOLICYSYS", Const, 0, ""},
+ {"SYS_IOPRIO_GET", Const, 0, ""},
+ {"SYS_IOPRIO_SET", Const, 0, ""},
+ {"SYS_IO_CANCEL", Const, 0, ""},
+ {"SYS_IO_DESTROY", Const, 0, ""},
+ {"SYS_IO_GETEVENTS", Const, 0, ""},
+ {"SYS_IO_SETUP", Const, 0, ""},
+ {"SYS_IO_SUBMIT", Const, 0, ""},
+ {"SYS_IPC", Const, 0, ""},
+ {"SYS_ISSETUGID", Const, 0, ""},
+ {"SYS_JAIL", Const, 0, ""},
+ {"SYS_JAIL_ATTACH", Const, 0, ""},
+ {"SYS_JAIL_GET", Const, 0, ""},
+ {"SYS_JAIL_REMOVE", Const, 0, ""},
+ {"SYS_JAIL_SET", Const, 0, ""},
+ {"SYS_KAS_INFO", Const, 16, ""},
+ {"SYS_KDEBUG_TRACE", Const, 0, ""},
+ {"SYS_KENV", Const, 0, ""},
+ {"SYS_KEVENT", Const, 0, ""},
+ {"SYS_KEVENT64", Const, 0, ""},
+ {"SYS_KEXEC_LOAD", Const, 0, ""},
+ {"SYS_KEYCTL", Const, 0, ""},
+ {"SYS_KILL", Const, 0, ""},
+ {"SYS_KLDFIND", Const, 0, ""},
+ {"SYS_KLDFIRSTMOD", Const, 0, ""},
+ {"SYS_KLDLOAD", Const, 0, ""},
+ {"SYS_KLDNEXT", Const, 0, ""},
+ {"SYS_KLDSTAT", Const, 0, ""},
+ {"SYS_KLDSYM", Const, 0, ""},
+ {"SYS_KLDUNLOAD", Const, 0, ""},
+ {"SYS_KLDUNLOADF", Const, 0, ""},
+ {"SYS_KMQ_NOTIFY", Const, 14, ""},
+ {"SYS_KMQ_OPEN", Const, 14, ""},
+ {"SYS_KMQ_SETATTR", Const, 14, ""},
+ {"SYS_KMQ_TIMEDRECEIVE", Const, 14, ""},
+ {"SYS_KMQ_TIMEDSEND", Const, 14, ""},
+ {"SYS_KMQ_UNLINK", Const, 14, ""},
+ {"SYS_KQUEUE", Const, 0, ""},
+ {"SYS_KQUEUE1", Const, 1, ""},
+ {"SYS_KSEM_CLOSE", Const, 14, ""},
+ {"SYS_KSEM_DESTROY", Const, 14, ""},
+ {"SYS_KSEM_GETVALUE", Const, 14, ""},
+ {"SYS_KSEM_INIT", Const, 14, ""},
+ {"SYS_KSEM_OPEN", Const, 14, ""},
+ {"SYS_KSEM_POST", Const, 14, ""},
+ {"SYS_KSEM_TIMEDWAIT", Const, 14, ""},
+ {"SYS_KSEM_TRYWAIT", Const, 14, ""},
+ {"SYS_KSEM_UNLINK", Const, 14, ""},
+ {"SYS_KSEM_WAIT", Const, 14, ""},
+ {"SYS_KTIMER_CREATE", Const, 0, ""},
+ {"SYS_KTIMER_DELETE", Const, 0, ""},
+ {"SYS_KTIMER_GETOVERRUN", Const, 0, ""},
+ {"SYS_KTIMER_GETTIME", Const, 0, ""},
+ {"SYS_KTIMER_SETTIME", Const, 0, ""},
+ {"SYS_KTRACE", Const, 0, ""},
+ {"SYS_LCHFLAGS", Const, 0, ""},
+ {"SYS_LCHMOD", Const, 0, ""},
+ {"SYS_LCHOWN", Const, 0, ""},
+ {"SYS_LCHOWN32", Const, 0, ""},
+ {"SYS_LEDGER", Const, 16, ""},
+ {"SYS_LGETFH", Const, 0, ""},
+ {"SYS_LGETXATTR", Const, 0, ""},
+ {"SYS_LINK", Const, 0, ""},
+ {"SYS_LINKAT", Const, 0, ""},
+ {"SYS_LIO_LISTIO", Const, 0, ""},
+ {"SYS_LISTEN", Const, 0, ""},
+ {"SYS_LISTXATTR", Const, 0, ""},
+ {"SYS_LLISTXATTR", Const, 0, ""},
+ {"SYS_LOCK", Const, 0, ""},
+ {"SYS_LOOKUP_DCOOKIE", Const, 0, ""},
+ {"SYS_LPATHCONF", Const, 0, ""},
+ {"SYS_LREMOVEXATTR", Const, 0, ""},
+ {"SYS_LSEEK", Const, 0, ""},
+ {"SYS_LSETXATTR", Const, 0, ""},
+ {"SYS_LSTAT", Const, 0, ""},
+ {"SYS_LSTAT64", Const, 0, ""},
+ {"SYS_LSTAT64_EXTENDED", Const, 0, ""},
+ {"SYS_LSTATV", Const, 0, ""},
+ {"SYS_LSTAT_EXTENDED", Const, 0, ""},
+ {"SYS_LUTIMES", Const, 0, ""},
+ {"SYS_MAC_SYSCALL", Const, 0, ""},
+ {"SYS_MADVISE", Const, 0, ""},
+ {"SYS_MADVISE1", Const, 0, ""},
+ {"SYS_MAXSYSCALL", Const, 0, ""},
+ {"SYS_MBIND", Const, 0, ""},
+ {"SYS_MIGRATE_PAGES", Const, 0, ""},
+ {"SYS_MINCORE", Const, 0, ""},
+ {"SYS_MINHERIT", Const, 0, ""},
+ {"SYS_MKCOMPLEX", Const, 0, ""},
+ {"SYS_MKDIR", Const, 0, ""},
+ {"SYS_MKDIRAT", Const, 0, ""},
+ {"SYS_MKDIR_EXTENDED", Const, 0, ""},
+ {"SYS_MKFIFO", Const, 0, ""},
+ {"SYS_MKFIFOAT", Const, 0, ""},
+ {"SYS_MKFIFO_EXTENDED", Const, 0, ""},
+ {"SYS_MKNOD", Const, 0, ""},
+ {"SYS_MKNODAT", Const, 0, ""},
+ {"SYS_MLOCK", Const, 0, ""},
+ {"SYS_MLOCKALL", Const, 0, ""},
+ {"SYS_MMAP", Const, 0, ""},
+ {"SYS_MMAP2", Const, 0, ""},
+ {"SYS_MODCTL", Const, 1, ""},
+ {"SYS_MODFIND", Const, 0, ""},
+ {"SYS_MODFNEXT", Const, 0, ""},
+ {"SYS_MODIFY_LDT", Const, 0, ""},
+ {"SYS_MODNEXT", Const, 0, ""},
+ {"SYS_MODSTAT", Const, 0, ""},
+ {"SYS_MODWATCH", Const, 0, ""},
+ {"SYS_MOUNT", Const, 0, ""},
+ {"SYS_MOVE_PAGES", Const, 0, ""},
+ {"SYS_MPROTECT", Const, 0, ""},
+ {"SYS_MPX", Const, 0, ""},
+ {"SYS_MQUERY", Const, 1, ""},
+ {"SYS_MQ_GETSETATTR", Const, 0, ""},
+ {"SYS_MQ_NOTIFY", Const, 0, ""},
+ {"SYS_MQ_OPEN", Const, 0, ""},
+ {"SYS_MQ_TIMEDRECEIVE", Const, 0, ""},
+ {"SYS_MQ_TIMEDSEND", Const, 0, ""},
+ {"SYS_MQ_UNLINK", Const, 0, ""},
+ {"SYS_MREMAP", Const, 0, ""},
+ {"SYS_MSGCTL", Const, 0, ""},
+ {"SYS_MSGGET", Const, 0, ""},
+ {"SYS_MSGRCV", Const, 0, ""},
+ {"SYS_MSGRCV_NOCANCEL", Const, 0, ""},
+ {"SYS_MSGSND", Const, 0, ""},
+ {"SYS_MSGSND_NOCANCEL", Const, 0, ""},
+ {"SYS_MSGSYS", Const, 0, ""},
+ {"SYS_MSYNC", Const, 0, ""},
+ {"SYS_MSYNC_NOCANCEL", Const, 0, ""},
+ {"SYS_MUNLOCK", Const, 0, ""},
+ {"SYS_MUNLOCKALL", Const, 0, ""},
+ {"SYS_MUNMAP", Const, 0, ""},
+ {"SYS_NAME_TO_HANDLE_AT", Const, 0, ""},
+ {"SYS_NANOSLEEP", Const, 0, ""},
+ {"SYS_NEWFSTATAT", Const, 0, ""},
+ {"SYS_NFSCLNT", Const, 0, ""},
+ {"SYS_NFSSERVCTL", Const, 0, ""},
+ {"SYS_NFSSVC", Const, 0, ""},
+ {"SYS_NFSTAT", Const, 0, ""},
+ {"SYS_NICE", Const, 0, ""},
+ {"SYS_NLM_SYSCALL", Const, 14, ""},
+ {"SYS_NLSTAT", Const, 0, ""},
+ {"SYS_NMOUNT", Const, 0, ""},
+ {"SYS_NSTAT", Const, 0, ""},
+ {"SYS_NTP_ADJTIME", Const, 0, ""},
+ {"SYS_NTP_GETTIME", Const, 0, ""},
+ {"SYS_NUMA_GETAFFINITY", Const, 14, ""},
+ {"SYS_NUMA_SETAFFINITY", Const, 14, ""},
+ {"SYS_OABI_SYSCALL_BASE", Const, 0, ""},
+ {"SYS_OBREAK", Const, 0, ""},
+ {"SYS_OLDFSTAT", Const, 0, ""},
+ {"SYS_OLDLSTAT", Const, 0, ""},
+ {"SYS_OLDOLDUNAME", Const, 0, ""},
+ {"SYS_OLDSTAT", Const, 0, ""},
+ {"SYS_OLDUNAME", Const, 0, ""},
+ {"SYS_OPEN", Const, 0, ""},
+ {"SYS_OPENAT", Const, 0, ""},
+ {"SYS_OPENBSD_POLL", Const, 0, ""},
+ {"SYS_OPEN_BY_HANDLE_AT", Const, 0, ""},
+ {"SYS_OPEN_DPROTECTED_NP", Const, 16, ""},
+ {"SYS_OPEN_EXTENDED", Const, 0, ""},
+ {"SYS_OPEN_NOCANCEL", Const, 0, ""},
+ {"SYS_OVADVISE", Const, 0, ""},
+ {"SYS_PACCEPT", Const, 1, ""},
+ {"SYS_PATHCONF", Const, 0, ""},
+ {"SYS_PAUSE", Const, 0, ""},
+ {"SYS_PCICONFIG_IOBASE", Const, 0, ""},
+ {"SYS_PCICONFIG_READ", Const, 0, ""},
+ {"SYS_PCICONFIG_WRITE", Const, 0, ""},
+ {"SYS_PDFORK", Const, 0, ""},
+ {"SYS_PDGETPID", Const, 0, ""},
+ {"SYS_PDKILL", Const, 0, ""},
+ {"SYS_PERF_EVENT_OPEN", Const, 0, ""},
+ {"SYS_PERSONALITY", Const, 0, ""},
+ {"SYS_PID_HIBERNATE", Const, 0, ""},
+ {"SYS_PID_RESUME", Const, 0, ""},
+ {"SYS_PID_SHUTDOWN_SOCKETS", Const, 0, ""},
+ {"SYS_PID_SUSPEND", Const, 0, ""},
+ {"SYS_PIPE", Const, 0, ""},
+ {"SYS_PIPE2", Const, 0, ""},
+ {"SYS_PIVOT_ROOT", Const, 0, ""},
+ {"SYS_PMC_CONTROL", Const, 1, ""},
+ {"SYS_PMC_GET_INFO", Const, 1, ""},
+ {"SYS_POLL", Const, 0, ""},
+ {"SYS_POLLTS", Const, 1, ""},
+ {"SYS_POLL_NOCANCEL", Const, 0, ""},
+ {"SYS_POSIX_FADVISE", Const, 0, ""},
+ {"SYS_POSIX_FALLOCATE", Const, 0, ""},
+ {"SYS_POSIX_OPENPT", Const, 0, ""},
+ {"SYS_POSIX_SPAWN", Const, 0, ""},
+ {"SYS_PPOLL", Const, 0, ""},
+ {"SYS_PRCTL", Const, 0, ""},
+ {"SYS_PREAD", Const, 0, ""},
+ {"SYS_PREAD64", Const, 0, ""},
+ {"SYS_PREADV", Const, 0, ""},
+ {"SYS_PREAD_NOCANCEL", Const, 0, ""},
+ {"SYS_PRLIMIT64", Const, 0, ""},
+ {"SYS_PROCCTL", Const, 3, ""},
+ {"SYS_PROCESS_POLICY", Const, 0, ""},
+ {"SYS_PROCESS_VM_READV", Const, 0, ""},
+ {"SYS_PROCESS_VM_WRITEV", Const, 0, ""},
+ {"SYS_PROC_INFO", Const, 0, ""},
+ {"SYS_PROF", Const, 0, ""},
+ {"SYS_PROFIL", Const, 0, ""},
+ {"SYS_PSELECT", Const, 0, ""},
+ {"SYS_PSELECT6", Const, 0, ""},
+ {"SYS_PSET_ASSIGN", Const, 1, ""},
+ {"SYS_PSET_CREATE", Const, 1, ""},
+ {"SYS_PSET_DESTROY", Const, 1, ""},
+ {"SYS_PSYNCH_CVBROAD", Const, 0, ""},
+ {"SYS_PSYNCH_CVCLRPREPOST", Const, 0, ""},
+ {"SYS_PSYNCH_CVSIGNAL", Const, 0, ""},
+ {"SYS_PSYNCH_CVWAIT", Const, 0, ""},
+ {"SYS_PSYNCH_MUTEXDROP", Const, 0, ""},
+ {"SYS_PSYNCH_MUTEXWAIT", Const, 0, ""},
+ {"SYS_PSYNCH_RW_DOWNGRADE", Const, 0, ""},
+ {"SYS_PSYNCH_RW_LONGRDLOCK", Const, 0, ""},
+ {"SYS_PSYNCH_RW_RDLOCK", Const, 0, ""},
+ {"SYS_PSYNCH_RW_UNLOCK", Const, 0, ""},
+ {"SYS_PSYNCH_RW_UNLOCK2", Const, 0, ""},
+ {"SYS_PSYNCH_RW_UPGRADE", Const, 0, ""},
+ {"SYS_PSYNCH_RW_WRLOCK", Const, 0, ""},
+ {"SYS_PSYNCH_RW_YIELDWRLOCK", Const, 0, ""},
+ {"SYS_PTRACE", Const, 0, ""},
+ {"SYS_PUTPMSG", Const, 0, ""},
+ {"SYS_PWRITE", Const, 0, ""},
+ {"SYS_PWRITE64", Const, 0, ""},
+ {"SYS_PWRITEV", Const, 0, ""},
+ {"SYS_PWRITE_NOCANCEL", Const, 0, ""},
+ {"SYS_QUERY_MODULE", Const, 0, ""},
+ {"SYS_QUOTACTL", Const, 0, ""},
+ {"SYS_RASCTL", Const, 1, ""},
+ {"SYS_RCTL_ADD_RULE", Const, 0, ""},
+ {"SYS_RCTL_GET_LIMITS", Const, 0, ""},
+ {"SYS_RCTL_GET_RACCT", Const, 0, ""},
+ {"SYS_RCTL_GET_RULES", Const, 0, ""},
+ {"SYS_RCTL_REMOVE_RULE", Const, 0, ""},
+ {"SYS_READ", Const, 0, ""},
+ {"SYS_READAHEAD", Const, 0, ""},
+ {"SYS_READDIR", Const, 0, ""},
+ {"SYS_READLINK", Const, 0, ""},
+ {"SYS_READLINKAT", Const, 0, ""},
+ {"SYS_READV", Const, 0, ""},
+ {"SYS_READV_NOCANCEL", Const, 0, ""},
+ {"SYS_READ_NOCANCEL", Const, 0, ""},
+ {"SYS_REBOOT", Const, 0, ""},
+ {"SYS_RECV", Const, 0, ""},
+ {"SYS_RECVFROM", Const, 0, ""},
+ {"SYS_RECVFROM_NOCANCEL", Const, 0, ""},
+ {"SYS_RECVMMSG", Const, 0, ""},
+ {"SYS_RECVMSG", Const, 0, ""},
+ {"SYS_RECVMSG_NOCANCEL", Const, 0, ""},
+ {"SYS_REMAP_FILE_PAGES", Const, 0, ""},
+ {"SYS_REMOVEXATTR", Const, 0, ""},
+ {"SYS_RENAME", Const, 0, ""},
+ {"SYS_RENAMEAT", Const, 0, ""},
+ {"SYS_REQUEST_KEY", Const, 0, ""},
+ {"SYS_RESTART_SYSCALL", Const, 0, ""},
+ {"SYS_REVOKE", Const, 0, ""},
+ {"SYS_RFORK", Const, 0, ""},
+ {"SYS_RMDIR", Const, 0, ""},
+ {"SYS_RTPRIO", Const, 0, ""},
+ {"SYS_RTPRIO_THREAD", Const, 0, ""},
+ {"SYS_RT_SIGACTION", Const, 0, ""},
+ {"SYS_RT_SIGPENDING", Const, 0, ""},
+ {"SYS_RT_SIGPROCMASK", Const, 0, ""},
+ {"SYS_RT_SIGQUEUEINFO", Const, 0, ""},
+ {"SYS_RT_SIGRETURN", Const, 0, ""},
+ {"SYS_RT_SIGSUSPEND", Const, 0, ""},
+ {"SYS_RT_SIGTIMEDWAIT", Const, 0, ""},
+ {"SYS_RT_TGSIGQUEUEINFO", Const, 0, ""},
+ {"SYS_SBRK", Const, 0, ""},
+ {"SYS_SCHED_GETAFFINITY", Const, 0, ""},
+ {"SYS_SCHED_GETPARAM", Const, 0, ""},
+ {"SYS_SCHED_GETSCHEDULER", Const, 0, ""},
+ {"SYS_SCHED_GET_PRIORITY_MAX", Const, 0, ""},
+ {"SYS_SCHED_GET_PRIORITY_MIN", Const, 0, ""},
+ {"SYS_SCHED_RR_GET_INTERVAL", Const, 0, ""},
+ {"SYS_SCHED_SETAFFINITY", Const, 0, ""},
+ {"SYS_SCHED_SETPARAM", Const, 0, ""},
+ {"SYS_SCHED_SETSCHEDULER", Const, 0, ""},
+ {"SYS_SCHED_YIELD", Const, 0, ""},
+ {"SYS_SCTP_GENERIC_RECVMSG", Const, 0, ""},
+ {"SYS_SCTP_GENERIC_SENDMSG", Const, 0, ""},
+ {"SYS_SCTP_GENERIC_SENDMSG_IOV", Const, 0, ""},
+ {"SYS_SCTP_PEELOFF", Const, 0, ""},
+ {"SYS_SEARCHFS", Const, 0, ""},
+ {"SYS_SECURITY", Const, 0, ""},
+ {"SYS_SELECT", Const, 0, ""},
+ {"SYS_SELECT_NOCANCEL", Const, 0, ""},
+ {"SYS_SEMCONFIG", Const, 1, ""},
+ {"SYS_SEMCTL", Const, 0, ""},
+ {"SYS_SEMGET", Const, 0, ""},
+ {"SYS_SEMOP", Const, 0, ""},
+ {"SYS_SEMSYS", Const, 0, ""},
+ {"SYS_SEMTIMEDOP", Const, 0, ""},
+ {"SYS_SEM_CLOSE", Const, 0, ""},
+ {"SYS_SEM_DESTROY", Const, 0, ""},
+ {"SYS_SEM_GETVALUE", Const, 0, ""},
+ {"SYS_SEM_INIT", Const, 0, ""},
+ {"SYS_SEM_OPEN", Const, 0, ""},
+ {"SYS_SEM_POST", Const, 0, ""},
+ {"SYS_SEM_TRYWAIT", Const, 0, ""},
+ {"SYS_SEM_UNLINK", Const, 0, ""},
+ {"SYS_SEM_WAIT", Const, 0, ""},
+ {"SYS_SEM_WAIT_NOCANCEL", Const, 0, ""},
+ {"SYS_SEND", Const, 0, ""},
+ {"SYS_SENDFILE", Const, 0, ""},
+ {"SYS_SENDFILE64", Const, 0, ""},
+ {"SYS_SENDMMSG", Const, 0, ""},
+ {"SYS_SENDMSG", Const, 0, ""},
+ {"SYS_SENDMSG_NOCANCEL", Const, 0, ""},
+ {"SYS_SENDTO", Const, 0, ""},
+ {"SYS_SENDTO_NOCANCEL", Const, 0, ""},
+ {"SYS_SETATTRLIST", Const, 0, ""},
+ {"SYS_SETAUDIT", Const, 0, ""},
+ {"SYS_SETAUDIT_ADDR", Const, 0, ""},
+ {"SYS_SETAUID", Const, 0, ""},
+ {"SYS_SETCONTEXT", Const, 0, ""},
+ {"SYS_SETDOMAINNAME", Const, 0, ""},
+ {"SYS_SETEGID", Const, 0, ""},
+ {"SYS_SETEUID", Const, 0, ""},
+ {"SYS_SETFIB", Const, 0, ""},
+ {"SYS_SETFSGID", Const, 0, ""},
+ {"SYS_SETFSGID32", Const, 0, ""},
+ {"SYS_SETFSUID", Const, 0, ""},
+ {"SYS_SETFSUID32", Const, 0, ""},
+ {"SYS_SETGID", Const, 0, ""},
+ {"SYS_SETGID32", Const, 0, ""},
+ {"SYS_SETGROUPS", Const, 0, ""},
+ {"SYS_SETGROUPS32", Const, 0, ""},
+ {"SYS_SETHOSTNAME", Const, 0, ""},
+ {"SYS_SETITIMER", Const, 0, ""},
+ {"SYS_SETLCID", Const, 0, ""},
+ {"SYS_SETLOGIN", Const, 0, ""},
+ {"SYS_SETLOGINCLASS", Const, 0, ""},
+ {"SYS_SETNS", Const, 0, ""},
+ {"SYS_SETPGID", Const, 0, ""},
+ {"SYS_SETPRIORITY", Const, 0, ""},
+ {"SYS_SETPRIVEXEC", Const, 0, ""},
+ {"SYS_SETREGID", Const, 0, ""},
+ {"SYS_SETREGID32", Const, 0, ""},
+ {"SYS_SETRESGID", Const, 0, ""},
+ {"SYS_SETRESGID32", Const, 0, ""},
+ {"SYS_SETRESUID", Const, 0, ""},
+ {"SYS_SETRESUID32", Const, 0, ""},
+ {"SYS_SETREUID", Const, 0, ""},
+ {"SYS_SETREUID32", Const, 0, ""},
+ {"SYS_SETRLIMIT", Const, 0, ""},
+ {"SYS_SETRTABLE", Const, 1, ""},
+ {"SYS_SETSGROUPS", Const, 0, ""},
+ {"SYS_SETSID", Const, 0, ""},
+ {"SYS_SETSOCKOPT", Const, 0, ""},
+ {"SYS_SETTID", Const, 0, ""},
+ {"SYS_SETTID_WITH_PID", Const, 0, ""},
+ {"SYS_SETTIMEOFDAY", Const, 0, ""},
+ {"SYS_SETUID", Const, 0, ""},
+ {"SYS_SETUID32", Const, 0, ""},
+ {"SYS_SETWGROUPS", Const, 0, ""},
+ {"SYS_SETXATTR", Const, 0, ""},
+ {"SYS_SET_MEMPOLICY", Const, 0, ""},
+ {"SYS_SET_ROBUST_LIST", Const, 0, ""},
+ {"SYS_SET_THREAD_AREA", Const, 0, ""},
+ {"SYS_SET_TID_ADDRESS", Const, 0, ""},
+ {"SYS_SGETMASK", Const, 0, ""},
+ {"SYS_SHARED_REGION_CHECK_NP", Const, 0, ""},
+ {"SYS_SHARED_REGION_MAP_AND_SLIDE_NP", Const, 0, ""},
+ {"SYS_SHMAT", Const, 0, ""},
+ {"SYS_SHMCTL", Const, 0, ""},
+ {"SYS_SHMDT", Const, 0, ""},
+ {"SYS_SHMGET", Const, 0, ""},
+ {"SYS_SHMSYS", Const, 0, ""},
+ {"SYS_SHM_OPEN", Const, 0, ""},
+ {"SYS_SHM_UNLINK", Const, 0, ""},
+ {"SYS_SHUTDOWN", Const, 0, ""},
+ {"SYS_SIGACTION", Const, 0, ""},
+ {"SYS_SIGALTSTACK", Const, 0, ""},
+ {"SYS_SIGNAL", Const, 0, ""},
+ {"SYS_SIGNALFD", Const, 0, ""},
+ {"SYS_SIGNALFD4", Const, 0, ""},
+ {"SYS_SIGPENDING", Const, 0, ""},
+ {"SYS_SIGPROCMASK", Const, 0, ""},
+ {"SYS_SIGQUEUE", Const, 0, ""},
+ {"SYS_SIGQUEUEINFO", Const, 1, ""},
+ {"SYS_SIGRETURN", Const, 0, ""},
+ {"SYS_SIGSUSPEND", Const, 0, ""},
+ {"SYS_SIGSUSPEND_NOCANCEL", Const, 0, ""},
+ {"SYS_SIGTIMEDWAIT", Const, 0, ""},
+ {"SYS_SIGWAIT", Const, 0, ""},
+ {"SYS_SIGWAITINFO", Const, 0, ""},
+ {"SYS_SOCKET", Const, 0, ""},
+ {"SYS_SOCKETCALL", Const, 0, ""},
+ {"SYS_SOCKETPAIR", Const, 0, ""},
+ {"SYS_SPLICE", Const, 0, ""},
+ {"SYS_SSETMASK", Const, 0, ""},
+ {"SYS_SSTK", Const, 0, ""},
+ {"SYS_STACK_SNAPSHOT", Const, 0, ""},
+ {"SYS_STAT", Const, 0, ""},
+ {"SYS_STAT64", Const, 0, ""},
+ {"SYS_STAT64_EXTENDED", Const, 0, ""},
+ {"SYS_STATFS", Const, 0, ""},
+ {"SYS_STATFS64", Const, 0, ""},
+ {"SYS_STATV", Const, 0, ""},
+ {"SYS_STATVFS1", Const, 1, ""},
+ {"SYS_STAT_EXTENDED", Const, 0, ""},
+ {"SYS_STIME", Const, 0, ""},
+ {"SYS_STTY", Const, 0, ""},
+ {"SYS_SWAPCONTEXT", Const, 0, ""},
+ {"SYS_SWAPCTL", Const, 1, ""},
+ {"SYS_SWAPOFF", Const, 0, ""},
+ {"SYS_SWAPON", Const, 0, ""},
+ {"SYS_SYMLINK", Const, 0, ""},
+ {"SYS_SYMLINKAT", Const, 0, ""},
+ {"SYS_SYNC", Const, 0, ""},
+ {"SYS_SYNCFS", Const, 0, ""},
+ {"SYS_SYNC_FILE_RANGE", Const, 0, ""},
+ {"SYS_SYSARCH", Const, 0, ""},
+ {"SYS_SYSCALL", Const, 0, ""},
+ {"SYS_SYSCALL_BASE", Const, 0, ""},
+ {"SYS_SYSFS", Const, 0, ""},
+ {"SYS_SYSINFO", Const, 0, ""},
+ {"SYS_SYSLOG", Const, 0, ""},
+ {"SYS_TEE", Const, 0, ""},
+ {"SYS_TGKILL", Const, 0, ""},
+ {"SYS_THREAD_SELFID", Const, 0, ""},
+ {"SYS_THR_CREATE", Const, 0, ""},
+ {"SYS_THR_EXIT", Const, 0, ""},
+ {"SYS_THR_KILL", Const, 0, ""},
+ {"SYS_THR_KILL2", Const, 0, ""},
+ {"SYS_THR_NEW", Const, 0, ""},
+ {"SYS_THR_SELF", Const, 0, ""},
+ {"SYS_THR_SET_NAME", Const, 0, ""},
+ {"SYS_THR_SUSPEND", Const, 0, ""},
+ {"SYS_THR_WAKE", Const, 0, ""},
+ {"SYS_TIME", Const, 0, ""},
+ {"SYS_TIMERFD_CREATE", Const, 0, ""},
+ {"SYS_TIMERFD_GETTIME", Const, 0, ""},
+ {"SYS_TIMERFD_SETTIME", Const, 0, ""},
+ {"SYS_TIMER_CREATE", Const, 0, ""},
+ {"SYS_TIMER_DELETE", Const, 0, ""},
+ {"SYS_TIMER_GETOVERRUN", Const, 0, ""},
+ {"SYS_TIMER_GETTIME", Const, 0, ""},
+ {"SYS_TIMER_SETTIME", Const, 0, ""},
+ {"SYS_TIMES", Const, 0, ""},
+ {"SYS_TKILL", Const, 0, ""},
+ {"SYS_TRUNCATE", Const, 0, ""},
+ {"SYS_TRUNCATE64", Const, 0, ""},
+ {"SYS_TUXCALL", Const, 0, ""},
+ {"SYS_UGETRLIMIT", Const, 0, ""},
+ {"SYS_ULIMIT", Const, 0, ""},
+ {"SYS_UMASK", Const, 0, ""},
+ {"SYS_UMASK_EXTENDED", Const, 0, ""},
+ {"SYS_UMOUNT", Const, 0, ""},
+ {"SYS_UMOUNT2", Const, 0, ""},
+ {"SYS_UNAME", Const, 0, ""},
+ {"SYS_UNDELETE", Const, 0, ""},
+ {"SYS_UNLINK", Const, 0, ""},
+ {"SYS_UNLINKAT", Const, 0, ""},
+ {"SYS_UNMOUNT", Const, 0, ""},
+ {"SYS_UNSHARE", Const, 0, ""},
+ {"SYS_USELIB", Const, 0, ""},
+ {"SYS_USTAT", Const, 0, ""},
+ {"SYS_UTIME", Const, 0, ""},
+ {"SYS_UTIMENSAT", Const, 0, ""},
+ {"SYS_UTIMES", Const, 0, ""},
+ {"SYS_UTRACE", Const, 0, ""},
+ {"SYS_UUIDGEN", Const, 0, ""},
+ {"SYS_VADVISE", Const, 1, ""},
+ {"SYS_VFORK", Const, 0, ""},
+ {"SYS_VHANGUP", Const, 0, ""},
+ {"SYS_VM86", Const, 0, ""},
+ {"SYS_VM86OLD", Const, 0, ""},
+ {"SYS_VMSPLICE", Const, 0, ""},
+ {"SYS_VM_PRESSURE_MONITOR", Const, 0, ""},
+ {"SYS_VSERVER", Const, 0, ""},
+ {"SYS_WAIT4", Const, 0, ""},
+ {"SYS_WAIT4_NOCANCEL", Const, 0, ""},
+ {"SYS_WAIT6", Const, 1, ""},
+ {"SYS_WAITEVENT", Const, 0, ""},
+ {"SYS_WAITID", Const, 0, ""},
+ {"SYS_WAITID_NOCANCEL", Const, 0, ""},
+ {"SYS_WAITPID", Const, 0, ""},
+ {"SYS_WATCHEVENT", Const, 0, ""},
+ {"SYS_WORKQ_KERNRETURN", Const, 0, ""},
+ {"SYS_WORKQ_OPEN", Const, 0, ""},
+ {"SYS_WRITE", Const, 0, ""},
+ {"SYS_WRITEV", Const, 0, ""},
+ {"SYS_WRITEV_NOCANCEL", Const, 0, ""},
+ {"SYS_WRITE_NOCANCEL", Const, 0, ""},
+ {"SYS_YIELD", Const, 0, ""},
+ {"SYS__LLSEEK", Const, 0, ""},
+ {"SYS__LWP_CONTINUE", Const, 1, ""},
+ {"SYS__LWP_CREATE", Const, 1, ""},
+ {"SYS__LWP_CTL", Const, 1, ""},
+ {"SYS__LWP_DETACH", Const, 1, ""},
+ {"SYS__LWP_EXIT", Const, 1, ""},
+ {"SYS__LWP_GETNAME", Const, 1, ""},
+ {"SYS__LWP_GETPRIVATE", Const, 1, ""},
+ {"SYS__LWP_KILL", Const, 1, ""},
+ {"SYS__LWP_PARK", Const, 1, ""},
+ {"SYS__LWP_SELF", Const, 1, ""},
+ {"SYS__LWP_SETNAME", Const, 1, ""},
+ {"SYS__LWP_SETPRIVATE", Const, 1, ""},
+ {"SYS__LWP_SUSPEND", Const, 1, ""},
+ {"SYS__LWP_UNPARK", Const, 1, ""},
+ {"SYS__LWP_UNPARK_ALL", Const, 1, ""},
+ {"SYS__LWP_WAIT", Const, 1, ""},
+ {"SYS__LWP_WAKEUP", Const, 1, ""},
+ {"SYS__NEWSELECT", Const, 0, ""},
+ {"SYS__PSET_BIND", Const, 1, ""},
+ {"SYS__SCHED_GETAFFINITY", Const, 1, ""},
+ {"SYS__SCHED_GETPARAM", Const, 1, ""},
+ {"SYS__SCHED_SETAFFINITY", Const, 1, ""},
+ {"SYS__SCHED_SETPARAM", Const, 1, ""},
+ {"SYS__SYSCTL", Const, 0, ""},
+ {"SYS__UMTX_LOCK", Const, 0, ""},
+ {"SYS__UMTX_OP", Const, 0, ""},
+ {"SYS__UMTX_UNLOCK", Const, 0, ""},
+ {"SYS___ACL_ACLCHECK_FD", Const, 0, ""},
+ {"SYS___ACL_ACLCHECK_FILE", Const, 0, ""},
+ {"SYS___ACL_ACLCHECK_LINK", Const, 0, ""},
+ {"SYS___ACL_DELETE_FD", Const, 0, ""},
+ {"SYS___ACL_DELETE_FILE", Const, 0, ""},
+ {"SYS___ACL_DELETE_LINK", Const, 0, ""},
+ {"SYS___ACL_GET_FD", Const, 0, ""},
+ {"SYS___ACL_GET_FILE", Const, 0, ""},
+ {"SYS___ACL_GET_LINK", Const, 0, ""},
+ {"SYS___ACL_SET_FD", Const, 0, ""},
+ {"SYS___ACL_SET_FILE", Const, 0, ""},
+ {"SYS___ACL_SET_LINK", Const, 0, ""},
+ {"SYS___CAP_RIGHTS_GET", Const, 14, ""},
+ {"SYS___CLONE", Const, 1, ""},
+ {"SYS___DISABLE_THREADSIGNAL", Const, 0, ""},
+ {"SYS___GETCWD", Const, 0, ""},
+ {"SYS___GETLOGIN", Const, 1, ""},
+ {"SYS___GET_TCB", Const, 1, ""},
+ {"SYS___MAC_EXECVE", Const, 0, ""},
+ {"SYS___MAC_GETFSSTAT", Const, 0, ""},
+ {"SYS___MAC_GET_FD", Const, 0, ""},
+ {"SYS___MAC_GET_FILE", Const, 0, ""},
+ {"SYS___MAC_GET_LCID", Const, 0, ""},
+ {"SYS___MAC_GET_LCTX", Const, 0, ""},
+ {"SYS___MAC_GET_LINK", Const, 0, ""},
+ {"SYS___MAC_GET_MOUNT", Const, 0, ""},
+ {"SYS___MAC_GET_PID", Const, 0, ""},
+ {"SYS___MAC_GET_PROC", Const, 0, ""},
+ {"SYS___MAC_MOUNT", Const, 0, ""},
+ {"SYS___MAC_SET_FD", Const, 0, ""},
+ {"SYS___MAC_SET_FILE", Const, 0, ""},
+ {"SYS___MAC_SET_LCTX", Const, 0, ""},
+ {"SYS___MAC_SET_LINK", Const, 0, ""},
+ {"SYS___MAC_SET_PROC", Const, 0, ""},
+ {"SYS___MAC_SYSCALL", Const, 0, ""},
+ {"SYS___OLD_SEMWAIT_SIGNAL", Const, 0, ""},
+ {"SYS___OLD_SEMWAIT_SIGNAL_NOCANCEL", Const, 0, ""},
+ {"SYS___POSIX_CHOWN", Const, 1, ""},
+ {"SYS___POSIX_FCHOWN", Const, 1, ""},
+ {"SYS___POSIX_LCHOWN", Const, 1, ""},
+ {"SYS___POSIX_RENAME", Const, 1, ""},
+ {"SYS___PTHREAD_CANCELED", Const, 0, ""},
+ {"SYS___PTHREAD_CHDIR", Const, 0, ""},
+ {"SYS___PTHREAD_FCHDIR", Const, 0, ""},
+ {"SYS___PTHREAD_KILL", Const, 0, ""},
+ {"SYS___PTHREAD_MARKCANCEL", Const, 0, ""},
+ {"SYS___PTHREAD_SIGMASK", Const, 0, ""},
+ {"SYS___QUOTACTL", Const, 1, ""},
+ {"SYS___SEMCTL", Const, 1, ""},
+ {"SYS___SEMWAIT_SIGNAL", Const, 0, ""},
+ {"SYS___SEMWAIT_SIGNAL_NOCANCEL", Const, 0, ""},
+ {"SYS___SETLOGIN", Const, 1, ""},
+ {"SYS___SETUGID", Const, 0, ""},
+ {"SYS___SET_TCB", Const, 1, ""},
+ {"SYS___SIGACTION_SIGTRAMP", Const, 1, ""},
+ {"SYS___SIGTIMEDWAIT", Const, 1, ""},
+ {"SYS___SIGWAIT", Const, 0, ""},
+ {"SYS___SIGWAIT_NOCANCEL", Const, 0, ""},
+ {"SYS___SYSCTL", Const, 0, ""},
+ {"SYS___TFORK", Const, 1, ""},
+ {"SYS___THREXIT", Const, 1, ""},
+ {"SYS___THRSIGDIVERT", Const, 1, ""},
+ {"SYS___THRSLEEP", Const, 1, ""},
+ {"SYS___THRWAKEUP", Const, 1, ""},
+ {"S_ARCH1", Const, 1, ""},
+ {"S_ARCH2", Const, 1, ""},
+ {"S_BLKSIZE", Const, 0, ""},
+ {"S_IEXEC", Const, 0, ""},
+ {"S_IFBLK", Const, 0, ""},
+ {"S_IFCHR", Const, 0, ""},
+ {"S_IFDIR", Const, 0, ""},
+ {"S_IFIFO", Const, 0, ""},
+ {"S_IFLNK", Const, 0, ""},
+ {"S_IFMT", Const, 0, ""},
+ {"S_IFREG", Const, 0, ""},
+ {"S_IFSOCK", Const, 0, ""},
+ {"S_IFWHT", Const, 0, ""},
+ {"S_IREAD", Const, 0, ""},
+ {"S_IRGRP", Const, 0, ""},
+ {"S_IROTH", Const, 0, ""},
+ {"S_IRUSR", Const, 0, ""},
+ {"S_IRWXG", Const, 0, ""},
+ {"S_IRWXO", Const, 0, ""},
+ {"S_IRWXU", Const, 0, ""},
+ {"S_ISGID", Const, 0, ""},
+ {"S_ISTXT", Const, 0, ""},
+ {"S_ISUID", Const, 0, ""},
+ {"S_ISVTX", Const, 0, ""},
+ {"S_IWGRP", Const, 0, ""},
+ {"S_IWOTH", Const, 0, ""},
+ {"S_IWRITE", Const, 0, ""},
+ {"S_IWUSR", Const, 0, ""},
+ {"S_IXGRP", Const, 0, ""},
+ {"S_IXOTH", Const, 0, ""},
+ {"S_IXUSR", Const, 0, ""},
+ {"S_LOGIN_SET", Const, 1, ""},
+ {"SecurityAttributes", Type, 0, ""},
+ {"SecurityAttributes.InheritHandle", Field, 0, ""},
+ {"SecurityAttributes.Length", Field, 0, ""},
+ {"SecurityAttributes.SecurityDescriptor", Field, 0, ""},
+ {"Seek", Func, 0, "func(fd int, offset int64, whence int) (off int64, err error)"},
+ {"Select", Func, 0, "func(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error)"},
+ {"Sendfile", Func, 0, "func(outfd int, infd int, offset *int64, count int) (written int, err error)"},
+ {"Sendmsg", Func, 0, "func(fd int, p []byte, oob []byte, to Sockaddr, flags int) (err error)"},
+ {"SendmsgN", Func, 3, "func(fd int, p []byte, oob []byte, to Sockaddr, flags int) (n int, err error)"},
+ {"Sendto", Func, 0, "func(fd int, p []byte, flags int, to Sockaddr) (err error)"},
+ {"Servent", Type, 0, ""},
+ {"Servent.Aliases", Field, 0, ""},
+ {"Servent.Name", Field, 0, ""},
+ {"Servent.Port", Field, 0, ""},
+ {"Servent.Proto", Field, 0, ""},
+ {"SetBpf", Func, 0, ""},
+ {"SetBpfBuflen", Func, 0, ""},
+ {"SetBpfDatalink", Func, 0, ""},
+ {"SetBpfHeadercmpl", Func, 0, ""},
+ {"SetBpfImmediate", Func, 0, ""},
+ {"SetBpfInterface", Func, 0, ""},
+ {"SetBpfPromisc", Func, 0, ""},
+ {"SetBpfTimeout", Func, 0, ""},
+ {"SetCurrentDirectory", Func, 0, ""},
+ {"SetEndOfFile", Func, 0, ""},
+ {"SetEnvironmentVariable", Func, 0, ""},
+ {"SetFileAttributes", Func, 0, ""},
+ {"SetFileCompletionNotificationModes", Func, 2, ""},
+ {"SetFilePointer", Func, 0, ""},
+ {"SetFileTime", Func, 0, ""},
+ {"SetHandleInformation", Func, 0, ""},
+ {"SetKevent", Func, 0, ""},
+ {"SetLsfPromisc", Func, 0, "func(name string, m bool) error"},
+ {"SetNonblock", Func, 0, "func(fd int, nonblocking bool) (err error)"},
+ {"Setdomainname", Func, 0, "func(p []byte) (err error)"},
+ {"Setegid", Func, 0, "func(egid int) (err error)"},
+ {"Setenv", Func, 0, "func(key string, value string) error"},
+ {"Seteuid", Func, 0, "func(euid int) (err error)"},
+ {"Setfsgid", Func, 0, "func(gid int) (err error)"},
+ {"Setfsuid", Func, 0, "func(uid int) (err error)"},
+ {"Setgid", Func, 0, "func(gid int) (err error)"},
+ {"Setgroups", Func, 0, "func(gids []int) (err error)"},
+ {"Sethostname", Func, 0, "func(p []byte) (err error)"},
+ {"Setlogin", Func, 0, ""},
+ {"Setpgid", Func, 0, "func(pid int, pgid int) (err error)"},
+ {"Setpriority", Func, 0, "func(which int, who int, prio int) (err error)"},
+ {"Setprivexec", Func, 0, ""},
+ {"Setregid", Func, 0, "func(rgid int, egid int) (err error)"},
+ {"Setresgid", Func, 0, "func(rgid int, egid int, sgid int) (err error)"},
+ {"Setresuid", Func, 0, "func(ruid int, euid int, suid int) (err error)"},
+ {"Setreuid", Func, 0, "func(ruid int, euid int) (err error)"},
+ {"Setrlimit", Func, 0, "func(resource int, rlim *Rlimit) error"},
+ {"Setsid", Func, 0, "func() (pid int, err error)"},
+ {"Setsockopt", Func, 0, ""},
+ {"SetsockoptByte", Func, 0, "func(fd int, level int, opt int, value byte) (err error)"},
+ {"SetsockoptICMPv6Filter", Func, 2, "func(fd int, level int, opt int, filter *ICMPv6Filter) error"},
+ {"SetsockoptIPMreq", Func, 0, "func(fd int, level int, opt int, mreq *IPMreq) (err error)"},
+ {"SetsockoptIPMreqn", Func, 0, "func(fd int, level int, opt int, mreq *IPMreqn) (err error)"},
+ {"SetsockoptIPv6Mreq", Func, 0, "func(fd int, level int, opt int, mreq *IPv6Mreq) (err error)"},
+ {"SetsockoptInet4Addr", Func, 0, "func(fd int, level int, opt int, value [4]byte) (err error)"},
+ {"SetsockoptInt", Func, 0, "func(fd int, level int, opt int, value int) (err error)"},
+ {"SetsockoptLinger", Func, 0, "func(fd int, level int, opt int, l *Linger) (err error)"},
+ {"SetsockoptString", Func, 0, "func(fd int, level int, opt int, s string) (err error)"},
+ {"SetsockoptTimeval", Func, 0, "func(fd int, level int, opt int, tv *Timeval) (err error)"},
+ {"Settimeofday", Func, 0, "func(tv *Timeval) (err error)"},
+ {"Setuid", Func, 0, "func(uid int) (err error)"},
+ {"Setxattr", Func, 1, "func(path string, attr string, data []byte, flags int) (err error)"},
+ {"Shutdown", Func, 0, "func(fd int, how int) (err error)"},
+ {"SidTypeAlias", Const, 0, ""},
+ {"SidTypeComputer", Const, 0, ""},
+ {"SidTypeDeletedAccount", Const, 0, ""},
+ {"SidTypeDomain", Const, 0, ""},
+ {"SidTypeGroup", Const, 0, ""},
+ {"SidTypeInvalid", Const, 0, ""},
+ {"SidTypeLabel", Const, 0, ""},
+ {"SidTypeUnknown", Const, 0, ""},
+ {"SidTypeUser", Const, 0, ""},
+ {"SidTypeWellKnownGroup", Const, 0, ""},
+ {"Signal", Type, 0, ""},
+ {"SizeofBpfHdr", Const, 0, ""},
+ {"SizeofBpfInsn", Const, 0, ""},
+ {"SizeofBpfProgram", Const, 0, ""},
+ {"SizeofBpfStat", Const, 0, ""},
+ {"SizeofBpfVersion", Const, 0, ""},
+ {"SizeofBpfZbuf", Const, 0, ""},
+ {"SizeofBpfZbufHeader", Const, 0, ""},
+ {"SizeofCmsghdr", Const, 0, ""},
+ {"SizeofICMPv6Filter", Const, 2, ""},
+ {"SizeofIPMreq", Const, 0, ""},
+ {"SizeofIPMreqn", Const, 0, ""},
+ {"SizeofIPv6MTUInfo", Const, 2, ""},
+ {"SizeofIPv6Mreq", Const, 0, ""},
+ {"SizeofIfAddrmsg", Const, 0, ""},
+ {"SizeofIfAnnounceMsghdr", Const, 1, ""},
+ {"SizeofIfData", Const, 0, ""},
+ {"SizeofIfInfomsg", Const, 0, ""},
+ {"SizeofIfMsghdr", Const, 0, ""},
+ {"SizeofIfaMsghdr", Const, 0, ""},
+ {"SizeofIfmaMsghdr", Const, 0, ""},
+ {"SizeofIfmaMsghdr2", Const, 0, ""},
+ {"SizeofInet4Pktinfo", Const, 0, ""},
+ {"SizeofInet6Pktinfo", Const, 0, ""},
+ {"SizeofInotifyEvent", Const, 0, ""},
+ {"SizeofLinger", Const, 0, ""},
+ {"SizeofMsghdr", Const, 0, ""},
+ {"SizeofNlAttr", Const, 0, ""},
+ {"SizeofNlMsgerr", Const, 0, ""},
+ {"SizeofNlMsghdr", Const, 0, ""},
+ {"SizeofRtAttr", Const, 0, ""},
+ {"SizeofRtGenmsg", Const, 0, ""},
+ {"SizeofRtMetrics", Const, 0, ""},
+ {"SizeofRtMsg", Const, 0, ""},
+ {"SizeofRtMsghdr", Const, 0, ""},
+ {"SizeofRtNexthop", Const, 0, ""},
+ {"SizeofSockFilter", Const, 0, ""},
+ {"SizeofSockFprog", Const, 0, ""},
+ {"SizeofSockaddrAny", Const, 0, ""},
+ {"SizeofSockaddrDatalink", Const, 0, ""},
+ {"SizeofSockaddrInet4", Const, 0, ""},
+ {"SizeofSockaddrInet6", Const, 0, ""},
+ {"SizeofSockaddrLinklayer", Const, 0, ""},
+ {"SizeofSockaddrNetlink", Const, 0, ""},
+ {"SizeofSockaddrUnix", Const, 0, ""},
+ {"SizeofTCPInfo", Const, 1, ""},
+ {"SizeofUcred", Const, 0, ""},
+ {"SlicePtrFromStrings", Func, 1, "func(ss []string) ([]*byte, error)"},
+ {"SockFilter", Type, 0, ""},
+ {"SockFilter.Code", Field, 0, ""},
+ {"SockFilter.Jf", Field, 0, ""},
+ {"SockFilter.Jt", Field, 0, ""},
+ {"SockFilter.K", Field, 0, ""},
+ {"SockFprog", Type, 0, ""},
+ {"SockFprog.Filter", Field, 0, ""},
+ {"SockFprog.Len", Field, 0, ""},
+ {"SockFprog.Pad_cgo_0", Field, 0, ""},
+ {"Sockaddr", Type, 0, ""},
+ {"SockaddrDatalink", Type, 0, ""},
+ {"SockaddrDatalink.Alen", Field, 0, ""},
+ {"SockaddrDatalink.Data", Field, 0, ""},
+ {"SockaddrDatalink.Family", Field, 0, ""},
+ {"SockaddrDatalink.Index", Field, 0, ""},
+ {"SockaddrDatalink.Len", Field, 0, ""},
+ {"SockaddrDatalink.Nlen", Field, 0, ""},
+ {"SockaddrDatalink.Slen", Field, 0, ""},
+ {"SockaddrDatalink.Type", Field, 0, ""},
+ {"SockaddrGen", Type, 0, ""},
+ {"SockaddrInet4", Type, 0, ""},
+ {"SockaddrInet4.Addr", Field, 0, ""},
+ {"SockaddrInet4.Port", Field, 0, ""},
+ {"SockaddrInet6", Type, 0, ""},
+ {"SockaddrInet6.Addr", Field, 0, ""},
+ {"SockaddrInet6.Port", Field, 0, ""},
+ {"SockaddrInet6.ZoneId", Field, 0, ""},
+ {"SockaddrLinklayer", Type, 0, ""},
+ {"SockaddrLinklayer.Addr", Field, 0, ""},
+ {"SockaddrLinklayer.Halen", Field, 0, ""},
+ {"SockaddrLinklayer.Hatype", Field, 0, ""},
+ {"SockaddrLinklayer.Ifindex", Field, 0, ""},
+ {"SockaddrLinklayer.Pkttype", Field, 0, ""},
+ {"SockaddrLinklayer.Protocol", Field, 0, ""},
+ {"SockaddrNetlink", Type, 0, ""},
+ {"SockaddrNetlink.Family", Field, 0, ""},
+ {"SockaddrNetlink.Groups", Field, 0, ""},
+ {"SockaddrNetlink.Pad", Field, 0, ""},
+ {"SockaddrNetlink.Pid", Field, 0, ""},
+ {"SockaddrUnix", Type, 0, ""},
+ {"SockaddrUnix.Name", Field, 0, ""},
+ {"Socket", Func, 0, "func(domain int, typ int, proto int) (fd int, err error)"},
+ {"SocketControlMessage", Type, 0, ""},
+ {"SocketControlMessage.Data", Field, 0, ""},
+ {"SocketControlMessage.Header", Field, 0, ""},
+ {"SocketDisableIPv6", Var, 0, ""},
+ {"Socketpair", Func, 0, "func(domain int, typ int, proto int) (fd [2]int, err error)"},
+ {"Splice", Func, 0, "func(rfd int, roff *int64, wfd int, woff *int64, len int, flags int) (n int64, err error)"},
+ {"StartProcess", Func, 0, "func(argv0 string, argv []string, attr *ProcAttr) (pid int, handle uintptr, err error)"},
+ {"StartupInfo", Type, 0, ""},
+ {"StartupInfo.Cb", Field, 0, ""},
+ {"StartupInfo.Desktop", Field, 0, ""},
+ {"StartupInfo.FillAttribute", Field, 0, ""},
+ {"StartupInfo.Flags", Field, 0, ""},
+ {"StartupInfo.ShowWindow", Field, 0, ""},
+ {"StartupInfo.StdErr", Field, 0, ""},
+ {"StartupInfo.StdInput", Field, 0, ""},
+ {"StartupInfo.StdOutput", Field, 0, ""},
+ {"StartupInfo.Title", Field, 0, ""},
+ {"StartupInfo.X", Field, 0, ""},
+ {"StartupInfo.XCountChars", Field, 0, ""},
+ {"StartupInfo.XSize", Field, 0, ""},
+ {"StartupInfo.Y", Field, 0, ""},
+ {"StartupInfo.YCountChars", Field, 0, ""},
+ {"StartupInfo.YSize", Field, 0, ""},
+ {"Stat", Func, 0, "func(path string, stat *Stat_t) (err error)"},
+ {"Stat_t", Type, 0, ""},
+ {"Stat_t.Atim", Field, 0, ""},
+ {"Stat_t.Atim_ext", Field, 12, ""},
+ {"Stat_t.Atimespec", Field, 0, ""},
+ {"Stat_t.Birthtimespec", Field, 0, ""},
+ {"Stat_t.Blksize", Field, 0, ""},
+ {"Stat_t.Blocks", Field, 0, ""},
+ {"Stat_t.Btim_ext", Field, 12, ""},
+ {"Stat_t.Ctim", Field, 0, ""},
+ {"Stat_t.Ctim_ext", Field, 12, ""},
+ {"Stat_t.Ctimespec", Field, 0, ""},
+ {"Stat_t.Dev", Field, 0, ""},
+ {"Stat_t.Flags", Field, 0, ""},
+ {"Stat_t.Gen", Field, 0, ""},
+ {"Stat_t.Gid", Field, 0, ""},
+ {"Stat_t.Ino", Field, 0, ""},
+ {"Stat_t.Lspare", Field, 0, ""},
+ {"Stat_t.Lspare0", Field, 2, ""},
+ {"Stat_t.Lspare1", Field, 2, ""},
+ {"Stat_t.Mode", Field, 0, ""},
+ {"Stat_t.Mtim", Field, 0, ""},
+ {"Stat_t.Mtim_ext", Field, 12, ""},
+ {"Stat_t.Mtimespec", Field, 0, ""},
+ {"Stat_t.Nlink", Field, 0, ""},
+ {"Stat_t.Pad_cgo_0", Field, 0, ""},
+ {"Stat_t.Pad_cgo_1", Field, 0, ""},
+ {"Stat_t.Pad_cgo_2", Field, 0, ""},
+ {"Stat_t.Padding0", Field, 12, ""},
+ {"Stat_t.Padding1", Field, 12, ""},
+ {"Stat_t.Qspare", Field, 0, ""},
+ {"Stat_t.Rdev", Field, 0, ""},
+ {"Stat_t.Size", Field, 0, ""},
+ {"Stat_t.Spare", Field, 2, ""},
+ {"Stat_t.Uid", Field, 0, ""},
+ {"Stat_t.X__pad0", Field, 0, ""},
+ {"Stat_t.X__pad1", Field, 0, ""},
+ {"Stat_t.X__pad2", Field, 0, ""},
+ {"Stat_t.X__st_birthtim", Field, 2, ""},
+ {"Stat_t.X__st_ino", Field, 0, ""},
+ {"Stat_t.X__unused", Field, 0, ""},
+ {"Statfs", Func, 0, "func(path string, buf *Statfs_t) (err error)"},
+ {"Statfs_t", Type, 0, ""},
+ {"Statfs_t.Asyncreads", Field, 0, ""},
+ {"Statfs_t.Asyncwrites", Field, 0, ""},
+ {"Statfs_t.Bavail", Field, 0, ""},
+ {"Statfs_t.Bfree", Field, 0, ""},
+ {"Statfs_t.Blocks", Field, 0, ""},
+ {"Statfs_t.Bsize", Field, 0, ""},
+ {"Statfs_t.Charspare", Field, 0, ""},
+ {"Statfs_t.F_asyncreads", Field, 2, ""},
+ {"Statfs_t.F_asyncwrites", Field, 2, ""},
+ {"Statfs_t.F_bavail", Field, 2, ""},
+ {"Statfs_t.F_bfree", Field, 2, ""},
+ {"Statfs_t.F_blocks", Field, 2, ""},
+ {"Statfs_t.F_bsize", Field, 2, ""},
+ {"Statfs_t.F_ctime", Field, 2, ""},
+ {"Statfs_t.F_favail", Field, 2, ""},
+ {"Statfs_t.F_ffree", Field, 2, ""},
+ {"Statfs_t.F_files", Field, 2, ""},
+ {"Statfs_t.F_flags", Field, 2, ""},
+ {"Statfs_t.F_fsid", Field, 2, ""},
+ {"Statfs_t.F_fstypename", Field, 2, ""},
+ {"Statfs_t.F_iosize", Field, 2, ""},
+ {"Statfs_t.F_mntfromname", Field, 2, ""},
+ {"Statfs_t.F_mntfromspec", Field, 3, ""},
+ {"Statfs_t.F_mntonname", Field, 2, ""},
+ {"Statfs_t.F_namemax", Field, 2, ""},
+ {"Statfs_t.F_owner", Field, 2, ""},
+ {"Statfs_t.F_spare", Field, 2, ""},
+ {"Statfs_t.F_syncreads", Field, 2, ""},
+ {"Statfs_t.F_syncwrites", Field, 2, ""},
+ {"Statfs_t.Ffree", Field, 0, ""},
+ {"Statfs_t.Files", Field, 0, ""},
+ {"Statfs_t.Flags", Field, 0, ""},
+ {"Statfs_t.Frsize", Field, 0, ""},
+ {"Statfs_t.Fsid", Field, 0, ""},
+ {"Statfs_t.Fssubtype", Field, 0, ""},
+ {"Statfs_t.Fstypename", Field, 0, ""},
+ {"Statfs_t.Iosize", Field, 0, ""},
+ {"Statfs_t.Mntfromname", Field, 0, ""},
+ {"Statfs_t.Mntonname", Field, 0, ""},
+ {"Statfs_t.Mount_info", Field, 2, ""},
+ {"Statfs_t.Namelen", Field, 0, ""},
+ {"Statfs_t.Namemax", Field, 0, ""},
+ {"Statfs_t.Owner", Field, 0, ""},
+ {"Statfs_t.Pad_cgo_0", Field, 0, ""},
+ {"Statfs_t.Pad_cgo_1", Field, 2, ""},
+ {"Statfs_t.Reserved", Field, 0, ""},
+ {"Statfs_t.Spare", Field, 0, ""},
+ {"Statfs_t.Syncreads", Field, 0, ""},
+ {"Statfs_t.Syncwrites", Field, 0, ""},
+ {"Statfs_t.Type", Field, 0, ""},
+ {"Statfs_t.Version", Field, 0, ""},
+ {"Stderr", Var, 0, ""},
+ {"Stdin", Var, 0, ""},
+ {"Stdout", Var, 0, ""},
+ {"StringBytePtr", Func, 0, "func(s string) *byte"},
+ {"StringByteSlice", Func, 0, "func(s string) []byte"},
+ {"StringSlicePtr", Func, 0, "func(ss []string) []*byte"},
+ {"StringToSid", Func, 0, ""},
+ {"StringToUTF16", Func, 0, ""},
+ {"StringToUTF16Ptr", Func, 0, ""},
+ {"Symlink", Func, 0, "func(oldpath string, newpath string) (err error)"},
+ {"Sync", Func, 0, "func()"},
+ {"SyncFileRange", Func, 0, "func(fd int, off int64, n int64, flags int) (err error)"},
+ {"SysProcAttr", Type, 0, ""},
+ {"SysProcAttr.AdditionalInheritedHandles", Field, 17, ""},
+ {"SysProcAttr.AmbientCaps", Field, 9, ""},
+ {"SysProcAttr.CgroupFD", Field, 20, ""},
+ {"SysProcAttr.Chroot", Field, 0, ""},
+ {"SysProcAttr.Cloneflags", Field, 2, ""},
+ {"SysProcAttr.CmdLine", Field, 0, ""},
+ {"SysProcAttr.CreationFlags", Field, 1, ""},
+ {"SysProcAttr.Credential", Field, 0, ""},
+ {"SysProcAttr.Ctty", Field, 1, ""},
+ {"SysProcAttr.Foreground", Field, 5, ""},
+ {"SysProcAttr.GidMappings", Field, 4, ""},
+ {"SysProcAttr.GidMappingsEnableSetgroups", Field, 5, ""},
+ {"SysProcAttr.HideWindow", Field, 0, ""},
+ {"SysProcAttr.Jail", Field, 21, ""},
+ {"SysProcAttr.NoInheritHandles", Field, 16, ""},
+ {"SysProcAttr.Noctty", Field, 0, ""},
+ {"SysProcAttr.ParentProcess", Field, 17, ""},
+ {"SysProcAttr.Pdeathsig", Field, 0, ""},
+ {"SysProcAttr.Pgid", Field, 5, ""},
+ {"SysProcAttr.PidFD", Field, 22, ""},
+ {"SysProcAttr.ProcessAttributes", Field, 13, ""},
+ {"SysProcAttr.Ptrace", Field, 0, ""},
+ {"SysProcAttr.Setctty", Field, 0, ""},
+ {"SysProcAttr.Setpgid", Field, 0, ""},
+ {"SysProcAttr.Setsid", Field, 0, ""},
+ {"SysProcAttr.ThreadAttributes", Field, 13, ""},
+ {"SysProcAttr.Token", Field, 10, ""},
+ {"SysProcAttr.UidMappings", Field, 4, ""},
+ {"SysProcAttr.Unshareflags", Field, 7, ""},
+ {"SysProcAttr.UseCgroupFD", Field, 20, ""},
+ {"SysProcIDMap", Type, 4, ""},
+ {"SysProcIDMap.ContainerID", Field, 4, ""},
+ {"SysProcIDMap.HostID", Field, 4, ""},
+ {"SysProcIDMap.Size", Field, 4, ""},
+ {"Syscall", Func, 0, "func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr) (r1 uintptr, r2 uintptr, err Errno)"},
+ {"Syscall12", Func, 0, ""},
+ {"Syscall15", Func, 0, ""},
+ {"Syscall18", Func, 12, ""},
+ {"Syscall6", Func, 0, "func(trap uintptr, a1 uintptr, a2 uintptr, a3 uintptr, a4 uintptr, a5 uintptr, a6 uintptr) (r1 uintptr, r2 uintptr, err Errno)"},
+ {"Syscall9", Func, 0, ""},
+ {"SyscallN", Func, 18, ""},
+ {"Sysctl", Func, 0, ""},
+ {"SysctlUint32", Func, 0, ""},
+ {"Sysctlnode", Type, 2, ""},
+ {"Sysctlnode.Flags", Field, 2, ""},
+ {"Sysctlnode.Name", Field, 2, ""},
+ {"Sysctlnode.Num", Field, 2, ""},
+ {"Sysctlnode.Un", Field, 2, ""},
+ {"Sysctlnode.Ver", Field, 2, ""},
+ {"Sysctlnode.X__rsvd", Field, 2, ""},
+ {"Sysctlnode.X_sysctl_desc", Field, 2, ""},
+ {"Sysctlnode.X_sysctl_func", Field, 2, ""},
+ {"Sysctlnode.X_sysctl_parent", Field, 2, ""},
+ {"Sysctlnode.X_sysctl_size", Field, 2, ""},
+ {"Sysinfo", Func, 0, "func(info *Sysinfo_t) (err error)"},
+ {"Sysinfo_t", Type, 0, ""},
+ {"Sysinfo_t.Bufferram", Field, 0, ""},
+ {"Sysinfo_t.Freehigh", Field, 0, ""},
+ {"Sysinfo_t.Freeram", Field, 0, ""},
+ {"Sysinfo_t.Freeswap", Field, 0, ""},
+ {"Sysinfo_t.Loads", Field, 0, ""},
+ {"Sysinfo_t.Pad", Field, 0, ""},
+ {"Sysinfo_t.Pad_cgo_0", Field, 0, ""},
+ {"Sysinfo_t.Pad_cgo_1", Field, 0, ""},
+ {"Sysinfo_t.Procs", Field, 0, ""},
+ {"Sysinfo_t.Sharedram", Field, 0, ""},
+ {"Sysinfo_t.Totalhigh", Field, 0, ""},
+ {"Sysinfo_t.Totalram", Field, 0, ""},
+ {"Sysinfo_t.Totalswap", Field, 0, ""},
+ {"Sysinfo_t.Unit", Field, 0, ""},
+ {"Sysinfo_t.Uptime", Field, 0, ""},
+ {"Sysinfo_t.X_f", Field, 0, ""},
+ {"Systemtime", Type, 0, ""},
+ {"Systemtime.Day", Field, 0, ""},
+ {"Systemtime.DayOfWeek", Field, 0, ""},
+ {"Systemtime.Hour", Field, 0, ""},
+ {"Systemtime.Milliseconds", Field, 0, ""},
+ {"Systemtime.Minute", Field, 0, ""},
+ {"Systemtime.Month", Field, 0, ""},
+ {"Systemtime.Second", Field, 0, ""},
+ {"Systemtime.Year", Field, 0, ""},
+ {"TCGETS", Const, 0, ""},
+ {"TCIFLUSH", Const, 1, ""},
+ {"TCIOFLUSH", Const, 1, ""},
+ {"TCOFLUSH", Const, 1, ""},
+ {"TCPInfo", Type, 1, ""},
+ {"TCPInfo.Advmss", Field, 1, ""},
+ {"TCPInfo.Ato", Field, 1, ""},
+ {"TCPInfo.Backoff", Field, 1, ""},
+ {"TCPInfo.Ca_state", Field, 1, ""},
+ {"TCPInfo.Fackets", Field, 1, ""},
+ {"TCPInfo.Last_ack_recv", Field, 1, ""},
+ {"TCPInfo.Last_ack_sent", Field, 1, ""},
+ {"TCPInfo.Last_data_recv", Field, 1, ""},
+ {"TCPInfo.Last_data_sent", Field, 1, ""},
+ {"TCPInfo.Lost", Field, 1, ""},
+ {"TCPInfo.Options", Field, 1, ""},
+ {"TCPInfo.Pad_cgo_0", Field, 1, ""},
+ {"TCPInfo.Pmtu", Field, 1, ""},
+ {"TCPInfo.Probes", Field, 1, ""},
+ {"TCPInfo.Rcv_mss", Field, 1, ""},
+ {"TCPInfo.Rcv_rtt", Field, 1, ""},
+ {"TCPInfo.Rcv_space", Field, 1, ""},
+ {"TCPInfo.Rcv_ssthresh", Field, 1, ""},
+ {"TCPInfo.Reordering", Field, 1, ""},
+ {"TCPInfo.Retrans", Field, 1, ""},
+ {"TCPInfo.Retransmits", Field, 1, ""},
+ {"TCPInfo.Rto", Field, 1, ""},
+ {"TCPInfo.Rtt", Field, 1, ""},
+ {"TCPInfo.Rttvar", Field, 1, ""},
+ {"TCPInfo.Sacked", Field, 1, ""},
+ {"TCPInfo.Snd_cwnd", Field, 1, ""},
+ {"TCPInfo.Snd_mss", Field, 1, ""},
+ {"TCPInfo.Snd_ssthresh", Field, 1, ""},
+ {"TCPInfo.State", Field, 1, ""},
+ {"TCPInfo.Total_retrans", Field, 1, ""},
+ {"TCPInfo.Unacked", Field, 1, ""},
+ {"TCPKeepalive", Type, 3, ""},
+ {"TCPKeepalive.Interval", Field, 3, ""},
+ {"TCPKeepalive.OnOff", Field, 3, ""},
+ {"TCPKeepalive.Time", Field, 3, ""},
+ {"TCP_CA_NAME_MAX", Const, 0, ""},
+ {"TCP_CONGCTL", Const, 1, ""},
+ {"TCP_CONGESTION", Const, 0, ""},
+ {"TCP_CONNECTIONTIMEOUT", Const, 0, ""},
+ {"TCP_CORK", Const, 0, ""},
+ {"TCP_DEFER_ACCEPT", Const, 0, ""},
+ {"TCP_ENABLE_ECN", Const, 16, ""},
+ {"TCP_INFO", Const, 0, ""},
+ {"TCP_KEEPALIVE", Const, 0, ""},
+ {"TCP_KEEPCNT", Const, 0, ""},
+ {"TCP_KEEPIDLE", Const, 0, ""},
+ {"TCP_KEEPINIT", Const, 1, ""},
+ {"TCP_KEEPINTVL", Const, 0, ""},
+ {"TCP_LINGER2", Const, 0, ""},
+ {"TCP_MAXBURST", Const, 0, ""},
+ {"TCP_MAXHLEN", Const, 0, ""},
+ {"TCP_MAXOLEN", Const, 0, ""},
+ {"TCP_MAXSEG", Const, 0, ""},
+ {"TCP_MAXWIN", Const, 0, ""},
+ {"TCP_MAX_SACK", Const, 0, ""},
+ {"TCP_MAX_WINSHIFT", Const, 0, ""},
+ {"TCP_MD5SIG", Const, 0, ""},
+ {"TCP_MD5SIG_MAXKEYLEN", Const, 0, ""},
+ {"TCP_MINMSS", Const, 0, ""},
+ {"TCP_MINMSSOVERLOAD", Const, 0, ""},
+ {"TCP_MSS", Const, 0, ""},
+ {"TCP_NODELAY", Const, 0, ""},
+ {"TCP_NOOPT", Const, 0, ""},
+ {"TCP_NOPUSH", Const, 0, ""},
+ {"TCP_NOTSENT_LOWAT", Const, 16, ""},
+ {"TCP_NSTATES", Const, 1, ""},
+ {"TCP_QUICKACK", Const, 0, ""},
+ {"TCP_RXT_CONNDROPTIME", Const, 0, ""},
+ {"TCP_RXT_FINDROP", Const, 0, ""},
+ {"TCP_SACK_ENABLE", Const, 1, ""},
+ {"TCP_SENDMOREACKS", Const, 16, ""},
+ {"TCP_SYNCNT", Const, 0, ""},
+ {"TCP_VENDOR", Const, 3, ""},
+ {"TCP_WINDOW_CLAMP", Const, 0, ""},
+ {"TCSAFLUSH", Const, 1, ""},
+ {"TCSETS", Const, 0, ""},
+ {"TF_DISCONNECT", Const, 0, ""},
+ {"TF_REUSE_SOCKET", Const, 0, ""},
+ {"TF_USE_DEFAULT_WORKER", Const, 0, ""},
+ {"TF_USE_KERNEL_APC", Const, 0, ""},
+ {"TF_USE_SYSTEM_THREAD", Const, 0, ""},
+ {"TF_WRITE_BEHIND", Const, 0, ""},
+ {"TH32CS_INHERIT", Const, 4, ""},
+ {"TH32CS_SNAPALL", Const, 4, ""},
+ {"TH32CS_SNAPHEAPLIST", Const, 4, ""},
+ {"TH32CS_SNAPMODULE", Const, 4, ""},
+ {"TH32CS_SNAPMODULE32", Const, 4, ""},
+ {"TH32CS_SNAPPROCESS", Const, 4, ""},
+ {"TH32CS_SNAPTHREAD", Const, 4, ""},
+ {"TIME_ZONE_ID_DAYLIGHT", Const, 0, ""},
+ {"TIME_ZONE_ID_STANDARD", Const, 0, ""},
+ {"TIME_ZONE_ID_UNKNOWN", Const, 0, ""},
+ {"TIOCCBRK", Const, 0, ""},
+ {"TIOCCDTR", Const, 0, ""},
+ {"TIOCCONS", Const, 0, ""},
+ {"TIOCDCDTIMESTAMP", Const, 0, ""},
+ {"TIOCDRAIN", Const, 0, ""},
+ {"TIOCDSIMICROCODE", Const, 0, ""},
+ {"TIOCEXCL", Const, 0, ""},
+ {"TIOCEXT", Const, 0, ""},
+ {"TIOCFLAG_CDTRCTS", Const, 1, ""},
+ {"TIOCFLAG_CLOCAL", Const, 1, ""},
+ {"TIOCFLAG_CRTSCTS", Const, 1, ""},
+ {"TIOCFLAG_MDMBUF", Const, 1, ""},
+ {"TIOCFLAG_PPS", Const, 1, ""},
+ {"TIOCFLAG_SOFTCAR", Const, 1, ""},
+ {"TIOCFLUSH", Const, 0, ""},
+ {"TIOCGDEV", Const, 0, ""},
+ {"TIOCGDRAINWAIT", Const, 0, ""},
+ {"TIOCGETA", Const, 0, ""},
+ {"TIOCGETD", Const, 0, ""},
+ {"TIOCGFLAGS", Const, 1, ""},
+ {"TIOCGICOUNT", Const, 0, ""},
+ {"TIOCGLCKTRMIOS", Const, 0, ""},
+ {"TIOCGLINED", Const, 1, ""},
+ {"TIOCGPGRP", Const, 0, ""},
+ {"TIOCGPTN", Const, 0, ""},
+ {"TIOCGQSIZE", Const, 1, ""},
+ {"TIOCGRANTPT", Const, 1, ""},
+ {"TIOCGRS485", Const, 0, ""},
+ {"TIOCGSERIAL", Const, 0, ""},
+ {"TIOCGSID", Const, 0, ""},
+ {"TIOCGSIZE", Const, 1, ""},
+ {"TIOCGSOFTCAR", Const, 0, ""},
+ {"TIOCGTSTAMP", Const, 1, ""},
+ {"TIOCGWINSZ", Const, 0, ""},
+ {"TIOCINQ", Const, 0, ""},
+ {"TIOCIXOFF", Const, 0, ""},
+ {"TIOCIXON", Const, 0, ""},
+ {"TIOCLINUX", Const, 0, ""},
+ {"TIOCMBIC", Const, 0, ""},
+ {"TIOCMBIS", Const, 0, ""},
+ {"TIOCMGDTRWAIT", Const, 0, ""},
+ {"TIOCMGET", Const, 0, ""},
+ {"TIOCMIWAIT", Const, 0, ""},
+ {"TIOCMODG", Const, 0, ""},
+ {"TIOCMODS", Const, 0, ""},
+ {"TIOCMSDTRWAIT", Const, 0, ""},
+ {"TIOCMSET", Const, 0, ""},
+ {"TIOCM_CAR", Const, 0, ""},
+ {"TIOCM_CD", Const, 0, ""},
+ {"TIOCM_CTS", Const, 0, ""},
+ {"TIOCM_DCD", Const, 0, ""},
+ {"TIOCM_DSR", Const, 0, ""},
+ {"TIOCM_DTR", Const, 0, ""},
+ {"TIOCM_LE", Const, 0, ""},
+ {"TIOCM_RI", Const, 0, ""},
+ {"TIOCM_RNG", Const, 0, ""},
+ {"TIOCM_RTS", Const, 0, ""},
+ {"TIOCM_SR", Const, 0, ""},
+ {"TIOCM_ST", Const, 0, ""},
+ {"TIOCNOTTY", Const, 0, ""},
+ {"TIOCNXCL", Const, 0, ""},
+ {"TIOCOUTQ", Const, 0, ""},
+ {"TIOCPKT", Const, 0, ""},
+ {"TIOCPKT_DATA", Const, 0, ""},
+ {"TIOCPKT_DOSTOP", Const, 0, ""},
+ {"TIOCPKT_FLUSHREAD", Const, 0, ""},
+ {"TIOCPKT_FLUSHWRITE", Const, 0, ""},
+ {"TIOCPKT_IOCTL", Const, 0, ""},
+ {"TIOCPKT_NOSTOP", Const, 0, ""},
+ {"TIOCPKT_START", Const, 0, ""},
+ {"TIOCPKT_STOP", Const, 0, ""},
+ {"TIOCPTMASTER", Const, 0, ""},
+ {"TIOCPTMGET", Const, 1, ""},
+ {"TIOCPTSNAME", Const, 1, ""},
+ {"TIOCPTYGNAME", Const, 0, ""},
+ {"TIOCPTYGRANT", Const, 0, ""},
+ {"TIOCPTYUNLK", Const, 0, ""},
+ {"TIOCRCVFRAME", Const, 1, ""},
+ {"TIOCREMOTE", Const, 0, ""},
+ {"TIOCSBRK", Const, 0, ""},
+ {"TIOCSCONS", Const, 0, ""},
+ {"TIOCSCTTY", Const, 0, ""},
+ {"TIOCSDRAINWAIT", Const, 0, ""},
+ {"TIOCSDTR", Const, 0, ""},
+ {"TIOCSERCONFIG", Const, 0, ""},
+ {"TIOCSERGETLSR", Const, 0, ""},
+ {"TIOCSERGETMULTI", Const, 0, ""},
+ {"TIOCSERGSTRUCT", Const, 0, ""},
+ {"TIOCSERGWILD", Const, 0, ""},
+ {"TIOCSERSETMULTI", Const, 0, ""},
+ {"TIOCSERSWILD", Const, 0, ""},
+ {"TIOCSER_TEMT", Const, 0, ""},
+ {"TIOCSETA", Const, 0, ""},
+ {"TIOCSETAF", Const, 0, ""},
+ {"TIOCSETAW", Const, 0, ""},
+ {"TIOCSETD", Const, 0, ""},
+ {"TIOCSFLAGS", Const, 1, ""},
+ {"TIOCSIG", Const, 0, ""},
+ {"TIOCSLCKTRMIOS", Const, 0, ""},
+ {"TIOCSLINED", Const, 1, ""},
+ {"TIOCSPGRP", Const, 0, ""},
+ {"TIOCSPTLCK", Const, 0, ""},
+ {"TIOCSQSIZE", Const, 1, ""},
+ {"TIOCSRS485", Const, 0, ""},
+ {"TIOCSSERIAL", Const, 0, ""},
+ {"TIOCSSIZE", Const, 1, ""},
+ {"TIOCSSOFTCAR", Const, 0, ""},
+ {"TIOCSTART", Const, 0, ""},
+ {"TIOCSTAT", Const, 0, ""},
+ {"TIOCSTI", Const, 0, ""},
+ {"TIOCSTOP", Const, 0, ""},
+ {"TIOCSTSTAMP", Const, 1, ""},
+ {"TIOCSWINSZ", Const, 0, ""},
+ {"TIOCTIMESTAMP", Const, 0, ""},
+ {"TIOCUCNTL", Const, 0, ""},
+ {"TIOCVHANGUP", Const, 0, ""},
+ {"TIOCXMTFRAME", Const, 1, ""},
+ {"TOKEN_ADJUST_DEFAULT", Const, 0, ""},
+ {"TOKEN_ADJUST_GROUPS", Const, 0, ""},
+ {"TOKEN_ADJUST_PRIVILEGES", Const, 0, ""},
+ {"TOKEN_ADJUST_SESSIONID", Const, 11, ""},
+ {"TOKEN_ALL_ACCESS", Const, 0, ""},
+ {"TOKEN_ASSIGN_PRIMARY", Const, 0, ""},
+ {"TOKEN_DUPLICATE", Const, 0, ""},
+ {"TOKEN_EXECUTE", Const, 0, ""},
+ {"TOKEN_IMPERSONATE", Const, 0, ""},
+ {"TOKEN_QUERY", Const, 0, ""},
+ {"TOKEN_QUERY_SOURCE", Const, 0, ""},
+ {"TOKEN_READ", Const, 0, ""},
+ {"TOKEN_WRITE", Const, 0, ""},
+ {"TOSTOP", Const, 0, ""},
+ {"TRUNCATE_EXISTING", Const, 0, ""},
+ {"TUNATTACHFILTER", Const, 0, ""},
+ {"TUNDETACHFILTER", Const, 0, ""},
+ {"TUNGETFEATURES", Const, 0, ""},
+ {"TUNGETIFF", Const, 0, ""},
+ {"TUNGETSNDBUF", Const, 0, ""},
+ {"TUNGETVNETHDRSZ", Const, 0, ""},
+ {"TUNSETDEBUG", Const, 0, ""},
+ {"TUNSETGROUP", Const, 0, ""},
+ {"TUNSETIFF", Const, 0, ""},
+ {"TUNSETLINK", Const, 0, ""},
+ {"TUNSETNOCSUM", Const, 0, ""},
+ {"TUNSETOFFLOAD", Const, 0, ""},
+ {"TUNSETOWNER", Const, 0, ""},
+ {"TUNSETPERSIST", Const, 0, ""},
+ {"TUNSETSNDBUF", Const, 0, ""},
+ {"TUNSETTXFILTER", Const, 0, ""},
+ {"TUNSETVNETHDRSZ", Const, 0, ""},
+ {"Tee", Func, 0, "func(rfd int, wfd int, len int, flags int) (n int64, err error)"},
+ {"TerminateProcess", Func, 0, ""},
+ {"Termios", Type, 0, ""},
+ {"Termios.Cc", Field, 0, ""},
+ {"Termios.Cflag", Field, 0, ""},
+ {"Termios.Iflag", Field, 0, ""},
+ {"Termios.Ispeed", Field, 0, ""},
+ {"Termios.Lflag", Field, 0, ""},
+ {"Termios.Line", Field, 0, ""},
+ {"Termios.Oflag", Field, 0, ""},
+ {"Termios.Ospeed", Field, 0, ""},
+ {"Termios.Pad_cgo_0", Field, 0, ""},
+ {"Tgkill", Func, 0, "func(tgid int, tid int, sig Signal) (err error)"},
+ {"Time", Func, 0, "func(t *Time_t) (tt Time_t, err error)"},
+ {"Time_t", Type, 0, ""},
+ {"Times", Func, 0, "func(tms *Tms) (ticks uintptr, err error)"},
+ {"Timespec", Type, 0, ""},
+ {"Timespec.Nsec", Field, 0, ""},
+ {"Timespec.Pad_cgo_0", Field, 2, ""},
+ {"Timespec.Sec", Field, 0, ""},
+ {"TimespecToNsec", Func, 0, "func(ts Timespec) int64"},
+ {"Timeval", Type, 0, ""},
+ {"Timeval.Pad_cgo_0", Field, 0, ""},
+ {"Timeval.Sec", Field, 0, ""},
+ {"Timeval.Usec", Field, 0, ""},
+ {"Timeval32", Type, 0, ""},
+ {"Timeval32.Sec", Field, 0, ""},
+ {"Timeval32.Usec", Field, 0, ""},
+ {"TimevalToNsec", Func, 0, "func(tv Timeval) int64"},
+ {"Timex", Type, 0, ""},
+ {"Timex.Calcnt", Field, 0, ""},
+ {"Timex.Constant", Field, 0, ""},
+ {"Timex.Errcnt", Field, 0, ""},
+ {"Timex.Esterror", Field, 0, ""},
+ {"Timex.Freq", Field, 0, ""},
+ {"Timex.Jitcnt", Field, 0, ""},
+ {"Timex.Jitter", Field, 0, ""},
+ {"Timex.Maxerror", Field, 0, ""},
+ {"Timex.Modes", Field, 0, ""},
+ {"Timex.Offset", Field, 0, ""},
+ {"Timex.Pad_cgo_0", Field, 0, ""},
+ {"Timex.Pad_cgo_1", Field, 0, ""},
+ {"Timex.Pad_cgo_2", Field, 0, ""},
+ {"Timex.Pad_cgo_3", Field, 0, ""},
+ {"Timex.Ppsfreq", Field, 0, ""},
+ {"Timex.Precision", Field, 0, ""},
+ {"Timex.Shift", Field, 0, ""},
+ {"Timex.Stabil", Field, 0, ""},
+ {"Timex.Status", Field, 0, ""},
+ {"Timex.Stbcnt", Field, 0, ""},
+ {"Timex.Tai", Field, 0, ""},
+ {"Timex.Tick", Field, 0, ""},
+ {"Timex.Time", Field, 0, ""},
+ {"Timex.Tolerance", Field, 0, ""},
+ {"Timezoneinformation", Type, 0, ""},
+ {"Timezoneinformation.Bias", Field, 0, ""},
+ {"Timezoneinformation.DaylightBias", Field, 0, ""},
+ {"Timezoneinformation.DaylightDate", Field, 0, ""},
+ {"Timezoneinformation.DaylightName", Field, 0, ""},
+ {"Timezoneinformation.StandardBias", Field, 0, ""},
+ {"Timezoneinformation.StandardDate", Field, 0, ""},
+ {"Timezoneinformation.StandardName", Field, 0, ""},
+ {"Tms", Type, 0, ""},
+ {"Tms.Cstime", Field, 0, ""},
+ {"Tms.Cutime", Field, 0, ""},
+ {"Tms.Stime", Field, 0, ""},
+ {"Tms.Utime", Field, 0, ""},
+ {"Token", Type, 0, ""},
+ {"TokenAccessInformation", Const, 0, ""},
+ {"TokenAuditPolicy", Const, 0, ""},
+ {"TokenDefaultDacl", Const, 0, ""},
+ {"TokenElevation", Const, 0, ""},
+ {"TokenElevationType", Const, 0, ""},
+ {"TokenGroups", Const, 0, ""},
+ {"TokenGroupsAndPrivileges", Const, 0, ""},
+ {"TokenHasRestrictions", Const, 0, ""},
+ {"TokenImpersonationLevel", Const, 0, ""},
+ {"TokenIntegrityLevel", Const, 0, ""},
+ {"TokenLinkedToken", Const, 0, ""},
+ {"TokenLogonSid", Const, 0, ""},
+ {"TokenMandatoryPolicy", Const, 0, ""},
+ {"TokenOrigin", Const, 0, ""},
+ {"TokenOwner", Const, 0, ""},
+ {"TokenPrimaryGroup", Const, 0, ""},
+ {"TokenPrivileges", Const, 0, ""},
+ {"TokenRestrictedSids", Const, 0, ""},
+ {"TokenSandBoxInert", Const, 0, ""},
+ {"TokenSessionId", Const, 0, ""},
+ {"TokenSessionReference", Const, 0, ""},
+ {"TokenSource", Const, 0, ""},
+ {"TokenStatistics", Const, 0, ""},
+ {"TokenType", Const, 0, ""},
+ {"TokenUIAccess", Const, 0, ""},
+ {"TokenUser", Const, 0, ""},
+ {"TokenVirtualizationAllowed", Const, 0, ""},
+ {"TokenVirtualizationEnabled", Const, 0, ""},
+ {"Tokenprimarygroup", Type, 0, ""},
+ {"Tokenprimarygroup.PrimaryGroup", Field, 0, ""},
+ {"Tokenuser", Type, 0, ""},
+ {"Tokenuser.User", Field, 0, ""},
+ {"TranslateAccountName", Func, 0, ""},
+ {"TranslateName", Func, 0, ""},
+ {"TransmitFile", Func, 0, ""},
+ {"TransmitFileBuffers", Type, 0, ""},
+ {"TransmitFileBuffers.Head", Field, 0, ""},
+ {"TransmitFileBuffers.HeadLength", Field, 0, ""},
+ {"TransmitFileBuffers.Tail", Field, 0, ""},
+ {"TransmitFileBuffers.TailLength", Field, 0, ""},
+ {"Truncate", Func, 0, "func(path string, length int64) (err error)"},
+ {"UNIX_PATH_MAX", Const, 12, ""},
+ {"USAGE_MATCH_TYPE_AND", Const, 0, ""},
+ {"USAGE_MATCH_TYPE_OR", Const, 0, ""},
+ {"UTF16FromString", Func, 1, ""},
+ {"UTF16PtrFromString", Func, 1, ""},
+ {"UTF16ToString", Func, 0, ""},
+ {"Ucred", Type, 0, ""},
+ {"Ucred.Gid", Field, 0, ""},
+ {"Ucred.Pid", Field, 0, ""},
+ {"Ucred.Uid", Field, 0, ""},
+ {"Umask", Func, 0, "func(mask int) (oldmask int)"},
+ {"Uname", Func, 0, "func(buf *Utsname) (err error)"},
+ {"Undelete", Func, 0, ""},
+ {"UnixCredentials", Func, 0, "func(ucred *Ucred) []byte"},
+ {"UnixRights", Func, 0, "func(fds ...int) []byte"},
+ {"Unlink", Func, 0, "func(path string) error"},
+ {"Unlinkat", Func, 0, "func(dirfd int, path string) error"},
+ {"UnmapViewOfFile", Func, 0, ""},
+ {"Unmount", Func, 0, "func(target string, flags int) (err error)"},
+ {"Unsetenv", Func, 4, "func(key string) error"},
+ {"Unshare", Func, 0, "func(flags int) (err error)"},
+ {"UserInfo10", Type, 0, ""},
+ {"UserInfo10.Comment", Field, 0, ""},
+ {"UserInfo10.FullName", Field, 0, ""},
+ {"UserInfo10.Name", Field, 0, ""},
+ {"UserInfo10.UsrComment", Field, 0, ""},
+ {"Ustat", Func, 0, "func(dev int, ubuf *Ustat_t) (err error)"},
+ {"Ustat_t", Type, 0, ""},
+ {"Ustat_t.Fname", Field, 0, ""},
+ {"Ustat_t.Fpack", Field, 0, ""},
+ {"Ustat_t.Pad_cgo_0", Field, 0, ""},
+ {"Ustat_t.Pad_cgo_1", Field, 0, ""},
+ {"Ustat_t.Tfree", Field, 0, ""},
+ {"Ustat_t.Tinode", Field, 0, ""},
+ {"Utimbuf", Type, 0, ""},
+ {"Utimbuf.Actime", Field, 0, ""},
+ {"Utimbuf.Modtime", Field, 0, ""},
+ {"Utime", Func, 0, "func(path string, buf *Utimbuf) (err error)"},
+ {"Utimes", Func, 0, "func(path string, tv []Timeval) (err error)"},
+ {"UtimesNano", Func, 1, "func(path string, ts []Timespec) (err error)"},
+ {"Utsname", Type, 0, ""},
+ {"Utsname.Domainname", Field, 0, ""},
+ {"Utsname.Machine", Field, 0, ""},
+ {"Utsname.Nodename", Field, 0, ""},
+ {"Utsname.Release", Field, 0, ""},
+ {"Utsname.Sysname", Field, 0, ""},
+ {"Utsname.Version", Field, 0, ""},
+ {"VDISCARD", Const, 0, ""},
+ {"VDSUSP", Const, 1, ""},
+ {"VEOF", Const, 0, ""},
+ {"VEOL", Const, 0, ""},
+ {"VEOL2", Const, 0, ""},
+ {"VERASE", Const, 0, ""},
+ {"VERASE2", Const, 1, ""},
+ {"VINTR", Const, 0, ""},
+ {"VKILL", Const, 0, ""},
+ {"VLNEXT", Const, 0, ""},
+ {"VMIN", Const, 0, ""},
+ {"VQUIT", Const, 0, ""},
+ {"VREPRINT", Const, 0, ""},
+ {"VSTART", Const, 0, ""},
+ {"VSTATUS", Const, 1, ""},
+ {"VSTOP", Const, 0, ""},
+ {"VSUSP", Const, 0, ""},
+ {"VSWTC", Const, 0, ""},
+ {"VT0", Const, 1, ""},
+ {"VT1", Const, 1, ""},
+ {"VTDLY", Const, 1, ""},
+ {"VTIME", Const, 0, ""},
+ {"VWERASE", Const, 0, ""},
+ {"VirtualLock", Func, 0, ""},
+ {"VirtualUnlock", Func, 0, ""},
+ {"WAIT_ABANDONED", Const, 0, ""},
+ {"WAIT_FAILED", Const, 0, ""},
+ {"WAIT_OBJECT_0", Const, 0, ""},
+ {"WAIT_TIMEOUT", Const, 0, ""},
+ {"WALL", Const, 0, ""},
+ {"WALLSIG", Const, 1, ""},
+ {"WALTSIG", Const, 1, ""},
+ {"WCLONE", Const, 0, ""},
+ {"WCONTINUED", Const, 0, ""},
+ {"WCOREFLAG", Const, 0, ""},
+ {"WEXITED", Const, 0, ""},
+ {"WLINUXCLONE", Const, 0, ""},
+ {"WNOHANG", Const, 0, ""},
+ {"WNOTHREAD", Const, 0, ""},
+ {"WNOWAIT", Const, 0, ""},
+ {"WNOZOMBIE", Const, 1, ""},
+ {"WOPTSCHECKED", Const, 1, ""},
+ {"WORDSIZE", Const, 0, ""},
+ {"WSABuf", Type, 0, ""},
+ {"WSABuf.Buf", Field, 0, ""},
+ {"WSABuf.Len", Field, 0, ""},
+ {"WSACleanup", Func, 0, ""},
+ {"WSADESCRIPTION_LEN", Const, 0, ""},
+ {"WSAData", Type, 0, ""},
+ {"WSAData.Description", Field, 0, ""},
+ {"WSAData.HighVersion", Field, 0, ""},
+ {"WSAData.MaxSockets", Field, 0, ""},
+ {"WSAData.MaxUdpDg", Field, 0, ""},
+ {"WSAData.SystemStatus", Field, 0, ""},
+ {"WSAData.VendorInfo", Field, 0, ""},
+ {"WSAData.Version", Field, 0, ""},
+ {"WSAEACCES", Const, 2, ""},
+ {"WSAECONNABORTED", Const, 9, ""},
+ {"WSAECONNRESET", Const, 3, ""},
+ {"WSAENOPROTOOPT", Const, 23, ""},
+ {"WSAEnumProtocols", Func, 2, ""},
+ {"WSAID_CONNECTEX", Var, 1, ""},
+ {"WSAIoctl", Func, 0, ""},
+ {"WSAPROTOCOL_LEN", Const, 2, ""},
+ {"WSAProtocolChain", Type, 2, ""},
+ {"WSAProtocolChain.ChainEntries", Field, 2, ""},
+ {"WSAProtocolChain.ChainLen", Field, 2, ""},
+ {"WSAProtocolInfo", Type, 2, ""},
+ {"WSAProtocolInfo.AddressFamily", Field, 2, ""},
+ {"WSAProtocolInfo.CatalogEntryId", Field, 2, ""},
+ {"WSAProtocolInfo.MaxSockAddr", Field, 2, ""},
+ {"WSAProtocolInfo.MessageSize", Field, 2, ""},
+ {"WSAProtocolInfo.MinSockAddr", Field, 2, ""},
+ {"WSAProtocolInfo.NetworkByteOrder", Field, 2, ""},
+ {"WSAProtocolInfo.Protocol", Field, 2, ""},
+ {"WSAProtocolInfo.ProtocolChain", Field, 2, ""},
+ {"WSAProtocolInfo.ProtocolMaxOffset", Field, 2, ""},
+ {"WSAProtocolInfo.ProtocolName", Field, 2, ""},
+ {"WSAProtocolInfo.ProviderFlags", Field, 2, ""},
+ {"WSAProtocolInfo.ProviderId", Field, 2, ""},
+ {"WSAProtocolInfo.ProviderReserved", Field, 2, ""},
+ {"WSAProtocolInfo.SecurityScheme", Field, 2, ""},
+ {"WSAProtocolInfo.ServiceFlags1", Field, 2, ""},
+ {"WSAProtocolInfo.ServiceFlags2", Field, 2, ""},
+ {"WSAProtocolInfo.ServiceFlags3", Field, 2, ""},
+ {"WSAProtocolInfo.ServiceFlags4", Field, 2, ""},
+ {"WSAProtocolInfo.SocketType", Field, 2, ""},
+ {"WSAProtocolInfo.Version", Field, 2, ""},
+ {"WSARecv", Func, 0, ""},
+ {"WSARecvFrom", Func, 0, ""},
+ {"WSASYS_STATUS_LEN", Const, 0, ""},
+ {"WSASend", Func, 0, ""},
+ {"WSASendTo", Func, 0, ""},
+ {"WSASendto", Func, 0, ""},
+ {"WSAStartup", Func, 0, ""},
+ {"WSTOPPED", Const, 0, ""},
+ {"WTRAPPED", Const, 1, ""},
+ {"WUNTRACED", Const, 0, ""},
+ {"Wait4", Func, 0, "func(pid int, wstatus *WaitStatus, options int, rusage *Rusage) (wpid int, err error)"},
+ {"WaitForSingleObject", Func, 0, ""},
+ {"WaitStatus", Type, 0, ""},
+ {"WaitStatus.ExitCode", Field, 0, ""},
+ {"Win32FileAttributeData", Type, 0, ""},
+ {"Win32FileAttributeData.CreationTime", Field, 0, ""},
+ {"Win32FileAttributeData.FileAttributes", Field, 0, ""},
+ {"Win32FileAttributeData.FileSizeHigh", Field, 0, ""},
+ {"Win32FileAttributeData.FileSizeLow", Field, 0, ""},
+ {"Win32FileAttributeData.LastAccessTime", Field, 0, ""},
+ {"Win32FileAttributeData.LastWriteTime", Field, 0, ""},
+ {"Win32finddata", Type, 0, ""},
+ {"Win32finddata.AlternateFileName", Field, 0, ""},
+ {"Win32finddata.CreationTime", Field, 0, ""},
+ {"Win32finddata.FileAttributes", Field, 0, ""},
+ {"Win32finddata.FileName", Field, 0, ""},
+ {"Win32finddata.FileSizeHigh", Field, 0, ""},
+ {"Win32finddata.FileSizeLow", Field, 0, ""},
+ {"Win32finddata.LastAccessTime", Field, 0, ""},
+ {"Win32finddata.LastWriteTime", Field, 0, ""},
+ {"Win32finddata.Reserved0", Field, 0, ""},
+ {"Win32finddata.Reserved1", Field, 0, ""},
+ {"Write", Func, 0, "func(fd int, p []byte) (n int, err error)"},
+ {"WriteConsole", Func, 1, ""},
+ {"WriteFile", Func, 0, ""},
+ {"X509_ASN_ENCODING", Const, 0, ""},
+ {"XCASE", Const, 0, ""},
+ {"XP1_CONNECTIONLESS", Const, 2, ""},
+ {"XP1_CONNECT_DATA", Const, 2, ""},
+ {"XP1_DISCONNECT_DATA", Const, 2, ""},
+ {"XP1_EXPEDITED_DATA", Const, 2, ""},
+ {"XP1_GRACEFUL_CLOSE", Const, 2, ""},
+ {"XP1_GUARANTEED_DELIVERY", Const, 2, ""},
+ {"XP1_GUARANTEED_ORDER", Const, 2, ""},
+ {"XP1_IFS_HANDLES", Const, 2, ""},
+ {"XP1_MESSAGE_ORIENTED", Const, 2, ""},
+ {"XP1_MULTIPOINT_CONTROL_PLANE", Const, 2, ""},
+ {"XP1_MULTIPOINT_DATA_PLANE", Const, 2, ""},
+ {"XP1_PARTIAL_MESSAGE", Const, 2, ""},
+ {"XP1_PSEUDO_STREAM", Const, 2, ""},
+ {"XP1_QOS_SUPPORTED", Const, 2, ""},
+ {"XP1_SAN_SUPPORT_SDP", Const, 2, ""},
+ {"XP1_SUPPORT_BROADCAST", Const, 2, ""},
+ {"XP1_SUPPORT_MULTIPOINT", Const, 2, ""},
+ {"XP1_UNI_RECV", Const, 2, ""},
+ {"XP1_UNI_SEND", Const, 2, ""},
+ },
+ "syscall/js": {
+ {"CopyBytesToGo", Func, 0, ""},
+ {"CopyBytesToJS", Func, 0, ""},
+ {"Error", Type, 0, ""},
+ {"Func", Type, 0, ""},
+ {"FuncOf", Func, 0, ""},
+ {"Global", Func, 0, ""},
+ {"Null", Func, 0, ""},
+ {"Type", Type, 0, ""},
+ {"TypeBoolean", Const, 0, ""},
+ {"TypeFunction", Const, 0, ""},
+ {"TypeNull", Const, 0, ""},
+ {"TypeNumber", Const, 0, ""},
+ {"TypeObject", Const, 0, ""},
+ {"TypeString", Const, 0, ""},
+ {"TypeSymbol", Const, 0, ""},
+ {"TypeUndefined", Const, 0, ""},
+ {"Undefined", Func, 0, ""},
+ {"Value", Type, 0, ""},
+ {"ValueError", Type, 0, ""},
+ {"ValueOf", Func, 0, ""},
+ },
+ "testing": {
+ {"(*B).Chdir", Method, 24, ""},
+ {"(*B).Cleanup", Method, 14, ""},
+ {"(*B).Context", Method, 24, ""},
+ {"(*B).Elapsed", Method, 20, ""},
+ {"(*B).Error", Method, 0, ""},
+ {"(*B).Errorf", Method, 0, ""},
+ {"(*B).Fail", Method, 0, ""},
+ {"(*B).FailNow", Method, 0, ""},
+ {"(*B).Failed", Method, 0, ""},
+ {"(*B).Fatal", Method, 0, ""},
+ {"(*B).Fatalf", Method, 0, ""},
+ {"(*B).Helper", Method, 9, ""},
+ {"(*B).Log", Method, 0, ""},
+ {"(*B).Logf", Method, 0, ""},
+ {"(*B).Loop", Method, 24, ""},
+ {"(*B).Name", Method, 8, ""},
+ {"(*B).ReportAllocs", Method, 1, ""},
+ {"(*B).ReportMetric", Method, 13, ""},
+ {"(*B).ResetTimer", Method, 0, ""},
+ {"(*B).Run", Method, 7, ""},
+ {"(*B).RunParallel", Method, 3, ""},
+ {"(*B).SetBytes", Method, 0, ""},
+ {"(*B).SetParallelism", Method, 3, ""},
+ {"(*B).Setenv", Method, 17, ""},
+ {"(*B).Skip", Method, 1, ""},
+ {"(*B).SkipNow", Method, 1, ""},
+ {"(*B).Skipf", Method, 1, ""},
+ {"(*B).Skipped", Method, 1, ""},
+ {"(*B).StartTimer", Method, 0, ""},
+ {"(*B).StopTimer", Method, 0, ""},
+ {"(*B).TempDir", Method, 15, ""},
+ {"(*F).Add", Method, 18, ""},
+ {"(*F).Chdir", Method, 24, ""},
+ {"(*F).Cleanup", Method, 18, ""},
+ {"(*F).Context", Method, 24, ""},
+ {"(*F).Error", Method, 18, ""},
+ {"(*F).Errorf", Method, 18, ""},
+ {"(*F).Fail", Method, 18, ""},
+ {"(*F).FailNow", Method, 18, ""},
+ {"(*F).Failed", Method, 18, ""},
+ {"(*F).Fatal", Method, 18, ""},
+ {"(*F).Fatalf", Method, 18, ""},
+ {"(*F).Fuzz", Method, 18, ""},
+ {"(*F).Helper", Method, 18, ""},
+ {"(*F).Log", Method, 18, ""},
+ {"(*F).Logf", Method, 18, ""},
+ {"(*F).Name", Method, 18, ""},
+ {"(*F).Setenv", Method, 18, ""},
+ {"(*F).Skip", Method, 18, ""},
+ {"(*F).SkipNow", Method, 18, ""},
+ {"(*F).Skipf", Method, 18, ""},
+ {"(*F).Skipped", Method, 18, ""},
+ {"(*F).TempDir", Method, 18, ""},
+ {"(*M).Run", Method, 4, ""},
+ {"(*PB).Next", Method, 3, ""},
+ {"(*T).Chdir", Method, 24, ""},
+ {"(*T).Cleanup", Method, 14, ""},
+ {"(*T).Context", Method, 24, ""},
+ {"(*T).Deadline", Method, 15, ""},
+ {"(*T).Error", Method, 0, ""},
+ {"(*T).Errorf", Method, 0, ""},
+ {"(*T).Fail", Method, 0, ""},
+ {"(*T).FailNow", Method, 0, ""},
+ {"(*T).Failed", Method, 0, ""},
+ {"(*T).Fatal", Method, 0, ""},
+ {"(*T).Fatalf", Method, 0, ""},
+ {"(*T).Helper", Method, 9, ""},
+ {"(*T).Log", Method, 0, ""},
+ {"(*T).Logf", Method, 0, ""},
+ {"(*T).Name", Method, 8, ""},
+ {"(*T).Parallel", Method, 0, ""},
+ {"(*T).Run", Method, 7, ""},
+ {"(*T).Setenv", Method, 17, ""},
+ {"(*T).Skip", Method, 1, ""},
+ {"(*T).SkipNow", Method, 1, ""},
+ {"(*T).Skipf", Method, 1, ""},
+ {"(*T).Skipped", Method, 1, ""},
+ {"(*T).TempDir", Method, 15, ""},
+ {"(BenchmarkResult).AllocedBytesPerOp", Method, 1, ""},
+ {"(BenchmarkResult).AllocsPerOp", Method, 1, ""},
+ {"(BenchmarkResult).MemString", Method, 1, ""},
+ {"(BenchmarkResult).NsPerOp", Method, 0, ""},
+ {"(BenchmarkResult).String", Method, 0, ""},
+ {"AllocsPerRun", Func, 1, "func(runs int, f func()) (avg float64)"},
+ {"B", Type, 0, ""},
+ {"B.N", Field, 0, ""},
+ {"Benchmark", Func, 0, "func(f func(b *B)) BenchmarkResult"},
+ {"BenchmarkResult", Type, 0, ""},
+ {"BenchmarkResult.Bytes", Field, 0, ""},
+ {"BenchmarkResult.Extra", Field, 13, ""},
+ {"BenchmarkResult.MemAllocs", Field, 1, ""},
+ {"BenchmarkResult.MemBytes", Field, 1, ""},
+ {"BenchmarkResult.N", Field, 0, ""},
+ {"BenchmarkResult.T", Field, 0, ""},
+ {"Cover", Type, 2, ""},
+ {"Cover.Blocks", Field, 2, ""},
+ {"Cover.Counters", Field, 2, ""},
+ {"Cover.CoveredPackages", Field, 2, ""},
+ {"Cover.Mode", Field, 2, ""},
+ {"CoverBlock", Type, 2, ""},
+ {"CoverBlock.Col0", Field, 2, ""},
+ {"CoverBlock.Col1", Field, 2, ""},
+ {"CoverBlock.Line0", Field, 2, ""},
+ {"CoverBlock.Line1", Field, 2, ""},
+ {"CoverBlock.Stmts", Field, 2, ""},
+ {"CoverMode", Func, 8, "func() string"},
+ {"Coverage", Func, 4, "func() float64"},
+ {"F", Type, 18, ""},
+ {"Init", Func, 13, "func()"},
+ {"InternalBenchmark", Type, 0, ""},
+ {"InternalBenchmark.F", Field, 0, ""},
+ {"InternalBenchmark.Name", Field, 0, ""},
+ {"InternalExample", Type, 0, ""},
+ {"InternalExample.F", Field, 0, ""},
+ {"InternalExample.Name", Field, 0, ""},
+ {"InternalExample.Output", Field, 0, ""},
+ {"InternalExample.Unordered", Field, 7, ""},
+ {"InternalFuzzTarget", Type, 18, ""},
+ {"InternalFuzzTarget.Fn", Field, 18, ""},
+ {"InternalFuzzTarget.Name", Field, 18, ""},
+ {"InternalTest", Type, 0, ""},
+ {"InternalTest.F", Field, 0, ""},
+ {"InternalTest.Name", Field, 0, ""},
+ {"M", Type, 4, ""},
+ {"Main", Func, 0, "func(matchString func(pat string, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)"},
+ {"MainStart", Func, 4, "func(deps testDeps, tests []InternalTest, benchmarks []InternalBenchmark, fuzzTargets []InternalFuzzTarget, examples []InternalExample) *M"},
+ {"PB", Type, 3, ""},
+ {"RegisterCover", Func, 2, "func(c Cover)"},
+ {"RunBenchmarks", Func, 0, "func(matchString func(pat string, str string) (bool, error), benchmarks []InternalBenchmark)"},
+ {"RunExamples", Func, 0, "func(matchString func(pat string, str string) (bool, error), examples []InternalExample) (ok bool)"},
+ {"RunTests", Func, 0, "func(matchString func(pat string, str string) (bool, error), tests []InternalTest) (ok bool)"},
+ {"Short", Func, 0, "func() bool"},
+ {"T", Type, 0, ""},
+ {"TB", Type, 2, ""},
+ {"Testing", Func, 21, "func() bool"},
+ {"Verbose", Func, 1, "func() bool"},
+ },
+ "testing/fstest": {
+ {"(MapFS).Glob", Method, 16, ""},
+ {"(MapFS).Lstat", Method, 25, ""},
+ {"(MapFS).Open", Method, 16, ""},
+ {"(MapFS).ReadDir", Method, 16, ""},
+ {"(MapFS).ReadFile", Method, 16, ""},
+ {"(MapFS).ReadLink", Method, 25, ""},
+ {"(MapFS).Stat", Method, 16, ""},
+ {"(MapFS).Sub", Method, 16, ""},
+ {"MapFS", Type, 16, ""},
+ {"MapFile", Type, 16, ""},
+ {"MapFile.Data", Field, 16, ""},
+ {"MapFile.ModTime", Field, 16, ""},
+ {"MapFile.Mode", Field, 16, ""},
+ {"MapFile.Sys", Field, 16, ""},
+ {"TestFS", Func, 16, "func(fsys fs.FS, expected ...string) error"},
+ },
+ "testing/iotest": {
+ {"DataErrReader", Func, 0, "func(r io.Reader) io.Reader"},
+ {"ErrReader", Func, 16, "func(err error) io.Reader"},
+ {"ErrTimeout", Var, 0, ""},
+ {"HalfReader", Func, 0, "func(r io.Reader) io.Reader"},
+ {"NewReadLogger", Func, 0, "func(prefix string, r io.Reader) io.Reader"},
+ {"NewWriteLogger", Func, 0, "func(prefix string, w io.Writer) io.Writer"},
+ {"OneByteReader", Func, 0, "func(r io.Reader) io.Reader"},
+ {"TestReader", Func, 16, "func(r io.Reader, content []byte) error"},
+ {"TimeoutReader", Func, 0, "func(r io.Reader) io.Reader"},
+ {"TruncateWriter", Func, 0, "func(w io.Writer, n int64) io.Writer"},
+ },
+ "testing/quick": {
+ {"(*CheckEqualError).Error", Method, 0, ""},
+ {"(*CheckError).Error", Method, 0, ""},
+ {"(SetupError).Error", Method, 0, ""},
+ {"Check", Func, 0, "func(f any, config *Config) error"},
+ {"CheckEqual", Func, 0, "func(f any, g any, config *Config) error"},
+ {"CheckEqualError", Type, 0, ""},
+ {"CheckEqualError.CheckError", Field, 0, ""},
+ {"CheckEqualError.Out1", Field, 0, ""},
+ {"CheckEqualError.Out2", Field, 0, ""},
+ {"CheckError", Type, 0, ""},
+ {"CheckError.Count", Field, 0, ""},
+ {"CheckError.In", Field, 0, ""},
+ {"Config", Type, 0, ""},
+ {"Config.MaxCount", Field, 0, ""},
+ {"Config.MaxCountScale", Field, 0, ""},
+ {"Config.Rand", Field, 0, ""},
+ {"Config.Values", Field, 0, ""},
+ {"Generator", Type, 0, ""},
+ {"SetupError", Type, 0, ""},
+ {"Value", Func, 0, "func(t reflect.Type, rand *rand.Rand) (value reflect.Value, ok bool)"},
+ },
+ "testing/slogtest": {
+ {"Run", Func, 22, "func(t *testing.T, newHandler func(*testing.T) slog.Handler, result func(*testing.T) map[string]any)"},
+ {"TestHandler", Func, 21, "func(h slog.Handler, results func() []map[string]any) error"},
+ },
+ "text/scanner": {
+ {"(*Position).IsValid", Method, 0, ""},
+ {"(*Scanner).Init", Method, 0, ""},
+ {"(*Scanner).IsValid", Method, 0, ""},
+ {"(*Scanner).Next", Method, 0, ""},
+ {"(*Scanner).Peek", Method, 0, ""},
+ {"(*Scanner).Pos", Method, 0, ""},
+ {"(*Scanner).Scan", Method, 0, ""},
+ {"(*Scanner).TokenText", Method, 0, ""},
+ {"(Position).String", Method, 0, ""},
+ {"(Scanner).String", Method, 0, ""},
+ {"Char", Const, 0, ""},
+ {"Comment", Const, 0, ""},
+ {"EOF", Const, 0, ""},
+ {"Float", Const, 0, ""},
+ {"GoTokens", Const, 0, ""},
+ {"GoWhitespace", Const, 0, ""},
+ {"Ident", Const, 0, ""},
+ {"Int", Const, 0, ""},
+ {"Position", Type, 0, ""},
+ {"Position.Column", Field, 0, ""},
+ {"Position.Filename", Field, 0, ""},
+ {"Position.Line", Field, 0, ""},
+ {"Position.Offset", Field, 0, ""},
+ {"RawString", Const, 0, ""},
+ {"ScanChars", Const, 0, ""},
+ {"ScanComments", Const, 0, ""},
+ {"ScanFloats", Const, 0, ""},
+ {"ScanIdents", Const, 0, ""},
+ {"ScanInts", Const, 0, ""},
+ {"ScanRawStrings", Const, 0, ""},
+ {"ScanStrings", Const, 0, ""},
+ {"Scanner", Type, 0, ""},
+ {"Scanner.Error", Field, 0, ""},
+ {"Scanner.ErrorCount", Field, 0, ""},
+ {"Scanner.IsIdentRune", Field, 4, ""},
+ {"Scanner.Mode", Field, 0, ""},
+ {"Scanner.Position", Field, 0, ""},
+ {"Scanner.Whitespace", Field, 0, ""},
+ {"SkipComments", Const, 0, ""},
+ {"String", Const, 0, ""},
+ {"TokenString", Func, 0, "func(tok rune) string"},
+ },
+ "text/tabwriter": {
+ {"(*Writer).Flush", Method, 0, ""},
+ {"(*Writer).Init", Method, 0, ""},
+ {"(*Writer).Write", Method, 0, ""},
+ {"AlignRight", Const, 0, ""},
+ {"Debug", Const, 0, ""},
+ {"DiscardEmptyColumns", Const, 0, ""},
+ {"Escape", Const, 0, ""},
+ {"FilterHTML", Const, 0, ""},
+ {"NewWriter", Func, 0, "func(output io.Writer, minwidth int, tabwidth int, padding int, padchar byte, flags uint) *Writer"},
+ {"StripEscape", Const, 0, ""},
+ {"TabIndent", Const, 0, ""},
+ {"Writer", Type, 0, ""},
+ },
+ "text/template": {
+ {"(*Template).AddParseTree", Method, 0, ""},
+ {"(*Template).Clone", Method, 0, ""},
+ {"(*Template).DefinedTemplates", Method, 5, ""},
+ {"(*Template).Delims", Method, 0, ""},
+ {"(*Template).Execute", Method, 0, ""},
+ {"(*Template).ExecuteTemplate", Method, 0, ""},
+ {"(*Template).Funcs", Method, 0, ""},
+ {"(*Template).Lookup", Method, 0, ""},
+ {"(*Template).Name", Method, 0, ""},
+ {"(*Template).New", Method, 0, ""},
+ {"(*Template).Option", Method, 5, ""},
+ {"(*Template).Parse", Method, 0, ""},
+ {"(*Template).ParseFS", Method, 16, ""},
+ {"(*Template).ParseFiles", Method, 0, ""},
+ {"(*Template).ParseGlob", Method, 0, ""},
+ {"(*Template).Templates", Method, 0, ""},
+ {"(ExecError).Error", Method, 6, ""},
+ {"(ExecError).Unwrap", Method, 13, ""},
+ {"(Template).Copy", Method, 2, ""},
+ {"(Template).ErrorContext", Method, 1, ""},
+ {"ExecError", Type, 6, ""},
+ {"ExecError.Err", Field, 6, ""},
+ {"ExecError.Name", Field, 6, ""},
+ {"FuncMap", Type, 0, ""},
+ {"HTMLEscape", Func, 0, "func(w io.Writer, b []byte)"},
+ {"HTMLEscapeString", Func, 0, "func(s string) string"},
+ {"HTMLEscaper", Func, 0, "func(args ...any) string"},
+ {"IsTrue", Func, 6, "func(val any) (truth bool, ok bool)"},
+ {"JSEscape", Func, 0, "func(w io.Writer, b []byte)"},
+ {"JSEscapeString", Func, 0, "func(s string) string"},
+ {"JSEscaper", Func, 0, "func(args ...any) string"},
+ {"Must", Func, 0, "func(t *Template, err error) *Template"},
+ {"New", Func, 0, "func(name string) *Template"},
+ {"ParseFS", Func, 16, "func(fsys fs.FS, patterns ...string) (*Template, error)"},
+ {"ParseFiles", Func, 0, "func(filenames ...string) (*Template, error)"},
+ {"ParseGlob", Func, 0, "func(pattern string) (*Template, error)"},
+ {"Template", Type, 0, ""},
+ {"Template.Tree", Field, 0, ""},
+ {"URLQueryEscaper", Func, 0, "func(args ...any) string"},
+ },
+ "text/template/parse": {
+ {"(*ActionNode).Copy", Method, 0, ""},
+ {"(*ActionNode).String", Method, 0, ""},
+ {"(*BoolNode).Copy", Method, 0, ""},
+ {"(*BoolNode).String", Method, 0, ""},
+ {"(*BranchNode).Copy", Method, 4, ""},
+ {"(*BranchNode).String", Method, 0, ""},
+ {"(*BreakNode).Copy", Method, 18, ""},
+ {"(*BreakNode).String", Method, 18, ""},
+ {"(*ChainNode).Add", Method, 1, ""},
+ {"(*ChainNode).Copy", Method, 1, ""},
+ {"(*ChainNode).String", Method, 1, ""},
+ {"(*CommandNode).Copy", Method, 0, ""},
+ {"(*CommandNode).String", Method, 0, ""},
+ {"(*CommentNode).Copy", Method, 16, ""},
+ {"(*CommentNode).String", Method, 16, ""},
+ {"(*ContinueNode).Copy", Method, 18, ""},
+ {"(*ContinueNode).String", Method, 18, ""},
+ {"(*DotNode).Copy", Method, 0, ""},
+ {"(*DotNode).String", Method, 0, ""},
+ {"(*DotNode).Type", Method, 0, ""},
+ {"(*FieldNode).Copy", Method, 0, ""},
+ {"(*FieldNode).String", Method, 0, ""},
+ {"(*IdentifierNode).Copy", Method, 0, ""},
+ {"(*IdentifierNode).SetPos", Method, 1, ""},
+ {"(*IdentifierNode).SetTree", Method, 4, ""},
+ {"(*IdentifierNode).String", Method, 0, ""},
+ {"(*IfNode).Copy", Method, 0, ""},
+ {"(*IfNode).String", Method, 0, ""},
+ {"(*ListNode).Copy", Method, 0, ""},
+ {"(*ListNode).CopyList", Method, 0, ""},
+ {"(*ListNode).String", Method, 0, ""},
+ {"(*NilNode).Copy", Method, 1, ""},
+ {"(*NilNode).String", Method, 1, ""},
+ {"(*NilNode).Type", Method, 1, ""},
+ {"(*NumberNode).Copy", Method, 0, ""},
+ {"(*NumberNode).String", Method, 0, ""},
+ {"(*PipeNode).Copy", Method, 0, ""},
+ {"(*PipeNode).CopyPipe", Method, 0, ""},
+ {"(*PipeNode).String", Method, 0, ""},
+ {"(*RangeNode).Copy", Method, 0, ""},
+ {"(*RangeNode).String", Method, 0, ""},
+ {"(*StringNode).Copy", Method, 0, ""},
+ {"(*StringNode).String", Method, 0, ""},
+ {"(*TemplateNode).Copy", Method, 0, ""},
+ {"(*TemplateNode).String", Method, 0, ""},
+ {"(*TextNode).Copy", Method, 0, ""},
+ {"(*TextNode).String", Method, 0, ""},
+ {"(*Tree).Copy", Method, 2, ""},
+ {"(*Tree).ErrorContext", Method, 1, ""},
+ {"(*Tree).Parse", Method, 0, ""},
+ {"(*VariableNode).Copy", Method, 0, ""},
+ {"(*VariableNode).String", Method, 0, ""},
+ {"(*WithNode).Copy", Method, 0, ""},
+ {"(*WithNode).String", Method, 0, ""},
+ {"(ActionNode).Position", Method, 1, ""},
+ {"(ActionNode).Type", Method, 0, ""},
+ {"(BoolNode).Position", Method, 1, ""},
+ {"(BoolNode).Type", Method, 0, ""},
+ {"(BranchNode).Position", Method, 1, ""},
+ {"(BranchNode).Type", Method, 0, ""},
+ {"(BreakNode).Position", Method, 18, ""},
+ {"(BreakNode).Type", Method, 18, ""},
+ {"(ChainNode).Position", Method, 1, ""},
+ {"(ChainNode).Type", Method, 1, ""},
+ {"(CommandNode).Position", Method, 1, ""},
+ {"(CommandNode).Type", Method, 0, ""},
+ {"(CommentNode).Position", Method, 16, ""},
+ {"(CommentNode).Type", Method, 16, ""},
+ {"(ContinueNode).Position", Method, 18, ""},
+ {"(ContinueNode).Type", Method, 18, ""},
+ {"(DotNode).Position", Method, 1, ""},
+ {"(FieldNode).Position", Method, 1, ""},
+ {"(FieldNode).Type", Method, 0, ""},
+ {"(IdentifierNode).Position", Method, 1, ""},
+ {"(IdentifierNode).Type", Method, 0, ""},
+ {"(IfNode).Position", Method, 1, ""},
+ {"(IfNode).Type", Method, 0, ""},
+ {"(ListNode).Position", Method, 1, ""},
+ {"(ListNode).Type", Method, 0, ""},
+ {"(NilNode).Position", Method, 1, ""},
+ {"(NodeType).Type", Method, 0, ""},
+ {"(NumberNode).Position", Method, 1, ""},
+ {"(NumberNode).Type", Method, 0, ""},
+ {"(PipeNode).Position", Method, 1, ""},
+ {"(PipeNode).Type", Method, 0, ""},
+ {"(Pos).Position", Method, 1, ""},
+ {"(RangeNode).Position", Method, 1, ""},
+ {"(RangeNode).Type", Method, 0, ""},
+ {"(StringNode).Position", Method, 1, ""},
+ {"(StringNode).Type", Method, 0, ""},
+ {"(TemplateNode).Position", Method, 1, ""},
+ {"(TemplateNode).Type", Method, 0, ""},
+ {"(TextNode).Position", Method, 1, ""},
+ {"(TextNode).Type", Method, 0, ""},
+ {"(VariableNode).Position", Method, 1, ""},
+ {"(VariableNode).Type", Method, 0, ""},
+ {"(WithNode).Position", Method, 1, ""},
+ {"(WithNode).Type", Method, 0, ""},
+ {"ActionNode", Type, 0, ""},
+ {"ActionNode.Line", Field, 0, ""},
+ {"ActionNode.NodeType", Field, 0, ""},
+ {"ActionNode.Pipe", Field, 0, ""},
+ {"ActionNode.Pos", Field, 1, ""},
+ {"BoolNode", Type, 0, ""},
+ {"BoolNode.NodeType", Field, 0, ""},
+ {"BoolNode.Pos", Field, 1, ""},
+ {"BoolNode.True", Field, 0, ""},
+ {"BranchNode", Type, 0, ""},
+ {"BranchNode.ElseList", Field, 0, ""},
+ {"BranchNode.Line", Field, 0, ""},
+ {"BranchNode.List", Field, 0, ""},
+ {"BranchNode.NodeType", Field, 0, ""},
+ {"BranchNode.Pipe", Field, 0, ""},
+ {"BranchNode.Pos", Field, 1, ""},
+ {"BreakNode", Type, 18, ""},
+ {"BreakNode.Line", Field, 18, ""},
+ {"BreakNode.NodeType", Field, 18, ""},
+ {"BreakNode.Pos", Field, 18, ""},
+ {"ChainNode", Type, 1, ""},
+ {"ChainNode.Field", Field, 1, ""},
+ {"ChainNode.Node", Field, 1, ""},
+ {"ChainNode.NodeType", Field, 1, ""},
+ {"ChainNode.Pos", Field, 1, ""},
+ {"CommandNode", Type, 0, ""},
+ {"CommandNode.Args", Field, 0, ""},
+ {"CommandNode.NodeType", Field, 0, ""},
+ {"CommandNode.Pos", Field, 1, ""},
+ {"CommentNode", Type, 16, ""},
+ {"CommentNode.NodeType", Field, 16, ""},
+ {"CommentNode.Pos", Field, 16, ""},
+ {"CommentNode.Text", Field, 16, ""},
+ {"ContinueNode", Type, 18, ""},
+ {"ContinueNode.Line", Field, 18, ""},
+ {"ContinueNode.NodeType", Field, 18, ""},
+ {"ContinueNode.Pos", Field, 18, ""},
+ {"DotNode", Type, 0, ""},
+ {"DotNode.NodeType", Field, 4, ""},
+ {"DotNode.Pos", Field, 1, ""},
+ {"FieldNode", Type, 0, ""},
+ {"FieldNode.Ident", Field, 0, ""},
+ {"FieldNode.NodeType", Field, 0, ""},
+ {"FieldNode.Pos", Field, 1, ""},
+ {"IdentifierNode", Type, 0, ""},
+ {"IdentifierNode.Ident", Field, 0, ""},
+ {"IdentifierNode.NodeType", Field, 0, ""},
+ {"IdentifierNode.Pos", Field, 1, ""},
+ {"IfNode", Type, 0, ""},
+ {"IfNode.BranchNode", Field, 0, ""},
+ {"IsEmptyTree", Func, 0, "func(n Node) bool"},
+ {"ListNode", Type, 0, ""},
+ {"ListNode.NodeType", Field, 0, ""},
+ {"ListNode.Nodes", Field, 0, ""},
+ {"ListNode.Pos", Field, 1, ""},
+ {"Mode", Type, 16, ""},
+ {"New", Func, 0, "func(name string, funcs ...map[string]any) *Tree"},
+ {"NewIdentifier", Func, 0, "func(ident string) *IdentifierNode"},
+ {"NilNode", Type, 1, ""},
+ {"NilNode.NodeType", Field, 4, ""},
+ {"NilNode.Pos", Field, 1, ""},
+ {"Node", Type, 0, ""},
+ {"NodeAction", Const, 0, ""},
+ {"NodeBool", Const, 0, ""},
+ {"NodeBreak", Const, 18, ""},
+ {"NodeChain", Const, 1, ""},
+ {"NodeCommand", Const, 0, ""},
+ {"NodeComment", Const, 16, ""},
+ {"NodeContinue", Const, 18, ""},
+ {"NodeDot", Const, 0, ""},
+ {"NodeField", Const, 0, ""},
+ {"NodeIdentifier", Const, 0, ""},
+ {"NodeIf", Const, 0, ""},
+ {"NodeList", Const, 0, ""},
+ {"NodeNil", Const, 1, ""},
+ {"NodeNumber", Const, 0, ""},
+ {"NodePipe", Const, 0, ""},
+ {"NodeRange", Const, 0, ""},
+ {"NodeString", Const, 0, ""},
+ {"NodeTemplate", Const, 0, ""},
+ {"NodeText", Const, 0, ""},
+ {"NodeType", Type, 0, ""},
+ {"NodeVariable", Const, 0, ""},
+ {"NodeWith", Const, 0, ""},
+ {"NumberNode", Type, 0, ""},
+ {"NumberNode.Complex128", Field, 0, ""},
+ {"NumberNode.Float64", Field, 0, ""},
+ {"NumberNode.Int64", Field, 0, ""},
+ {"NumberNode.IsComplex", Field, 0, ""},
+ {"NumberNode.IsFloat", Field, 0, ""},
+ {"NumberNode.IsInt", Field, 0, ""},
+ {"NumberNode.IsUint", Field, 0, ""},
+ {"NumberNode.NodeType", Field, 0, ""},
+ {"NumberNode.Pos", Field, 1, ""},
+ {"NumberNode.Text", Field, 0, ""},
+ {"NumberNode.Uint64", Field, 0, ""},
+ {"Parse", Func, 0, "func(name string, text string, leftDelim string, rightDelim string, funcs ...map[string]any) (map[string]*Tree, error)"},
+ {"ParseComments", Const, 16, ""},
+ {"PipeNode", Type, 0, ""},
+ {"PipeNode.Cmds", Field, 0, ""},
+ {"PipeNode.Decl", Field, 0, ""},
+ {"PipeNode.IsAssign", Field, 11, ""},
+ {"PipeNode.Line", Field, 0, ""},
+ {"PipeNode.NodeType", Field, 0, ""},
+ {"PipeNode.Pos", Field, 1, ""},
+ {"Pos", Type, 1, ""},
+ {"RangeNode", Type, 0, ""},
+ {"RangeNode.BranchNode", Field, 0, ""},
+ {"SkipFuncCheck", Const, 17, ""},
+ {"StringNode", Type, 0, ""},
+ {"StringNode.NodeType", Field, 0, ""},
+ {"StringNode.Pos", Field, 1, ""},
+ {"StringNode.Quoted", Field, 0, ""},
+ {"StringNode.Text", Field, 0, ""},
+ {"TemplateNode", Type, 0, ""},
+ {"TemplateNode.Line", Field, 0, ""},
+ {"TemplateNode.Name", Field, 0, ""},
+ {"TemplateNode.NodeType", Field, 0, ""},
+ {"TemplateNode.Pipe", Field, 0, ""},
+ {"TemplateNode.Pos", Field, 1, ""},
+ {"TextNode", Type, 0, ""},
+ {"TextNode.NodeType", Field, 0, ""},
+ {"TextNode.Pos", Field, 1, ""},
+ {"TextNode.Text", Field, 0, ""},
+ {"Tree", Type, 0, ""},
+ {"Tree.Mode", Field, 16, ""},
+ {"Tree.Name", Field, 0, ""},
+ {"Tree.ParseName", Field, 1, ""},
+ {"Tree.Root", Field, 0, ""},
+ {"VariableNode", Type, 0, ""},
+ {"VariableNode.Ident", Field, 0, ""},
+ {"VariableNode.NodeType", Field, 0, ""},
+ {"VariableNode.Pos", Field, 1, ""},
+ {"WithNode", Type, 0, ""},
+ {"WithNode.BranchNode", Field, 0, ""},
+ },
+ "time": {
+ {"(*Location).String", Method, 0, ""},
+ {"(*ParseError).Error", Method, 0, ""},
+ {"(*Ticker).Reset", Method, 15, ""},
+ {"(*Ticker).Stop", Method, 0, ""},
+ {"(*Time).GobDecode", Method, 0, ""},
+ {"(*Time).UnmarshalBinary", Method, 2, ""},
+ {"(*Time).UnmarshalJSON", Method, 0, ""},
+ {"(*Time).UnmarshalText", Method, 2, ""},
+ {"(*Timer).Reset", Method, 1, ""},
+ {"(*Timer).Stop", Method, 0, ""},
+ {"(Duration).Abs", Method, 19, ""},
+ {"(Duration).Hours", Method, 0, ""},
+ {"(Duration).Microseconds", Method, 13, ""},
+ {"(Duration).Milliseconds", Method, 13, ""},
+ {"(Duration).Minutes", Method, 0, ""},
+ {"(Duration).Nanoseconds", Method, 0, ""},
+ {"(Duration).Round", Method, 9, ""},
+ {"(Duration).Seconds", Method, 0, ""},
+ {"(Duration).String", Method, 0, ""},
+ {"(Duration).Truncate", Method, 9, ""},
+ {"(Month).String", Method, 0, ""},
+ {"(Time).Add", Method, 0, ""},
+ {"(Time).AddDate", Method, 0, ""},
+ {"(Time).After", Method, 0, ""},
+ {"(Time).AppendBinary", Method, 24, ""},
+ {"(Time).AppendFormat", Method, 5, ""},
+ {"(Time).AppendText", Method, 24, ""},
+ {"(Time).Before", Method, 0, ""},
+ {"(Time).Clock", Method, 0, ""},
+ {"(Time).Compare", Method, 20, ""},
+ {"(Time).Date", Method, 0, ""},
+ {"(Time).Day", Method, 0, ""},
+ {"(Time).Equal", Method, 0, ""},
+ {"(Time).Format", Method, 0, ""},
+ {"(Time).GoString", Method, 17, ""},
+ {"(Time).GobEncode", Method, 0, ""},
+ {"(Time).Hour", Method, 0, ""},
+ {"(Time).ISOWeek", Method, 0, ""},
+ {"(Time).In", Method, 0, ""},
+ {"(Time).IsDST", Method, 17, ""},
+ {"(Time).IsZero", Method, 0, ""},
+ {"(Time).Local", Method, 0, ""},
+ {"(Time).Location", Method, 0, ""},
+ {"(Time).MarshalBinary", Method, 2, ""},
+ {"(Time).MarshalJSON", Method, 0, ""},
+ {"(Time).MarshalText", Method, 2, ""},
+ {"(Time).Minute", Method, 0, ""},
+ {"(Time).Month", Method, 0, ""},
+ {"(Time).Nanosecond", Method, 0, ""},
+ {"(Time).Round", Method, 1, ""},
+ {"(Time).Second", Method, 0, ""},
+ {"(Time).String", Method, 0, ""},
+ {"(Time).Sub", Method, 0, ""},
+ {"(Time).Truncate", Method, 1, ""},
+ {"(Time).UTC", Method, 0, ""},
+ {"(Time).Unix", Method, 0, ""},
+ {"(Time).UnixMicro", Method, 17, ""},
+ {"(Time).UnixMilli", Method, 17, ""},
+ {"(Time).UnixNano", Method, 0, ""},
+ {"(Time).Weekday", Method, 0, ""},
+ {"(Time).Year", Method, 0, ""},
+ {"(Time).YearDay", Method, 1, ""},
+ {"(Time).Zone", Method, 0, ""},
+ {"(Time).ZoneBounds", Method, 19, ""},
+ {"(Weekday).String", Method, 0, ""},
+ {"ANSIC", Const, 0, ""},
+ {"After", Func, 0, "func(d Duration) <-chan Time"},
+ {"AfterFunc", Func, 0, "func(d Duration, f func()) *Timer"},
+ {"April", Const, 0, ""},
+ {"August", Const, 0, ""},
+ {"Date", Func, 0, "func(year int, month Month, day int, hour int, min int, sec int, nsec int, loc *Location) Time"},
+ {"DateOnly", Const, 20, ""},
+ {"DateTime", Const, 20, ""},
+ {"December", Const, 0, ""},
+ {"Duration", Type, 0, ""},
+ {"February", Const, 0, ""},
+ {"FixedZone", Func, 0, "func(name string, offset int) *Location"},
+ {"Friday", Const, 0, ""},
+ {"Hour", Const, 0, ""},
+ {"January", Const, 0, ""},
+ {"July", Const, 0, ""},
+ {"June", Const, 0, ""},
+ {"Kitchen", Const, 0, ""},
+ {"Layout", Const, 17, ""},
+ {"LoadLocation", Func, 0, "func(name string) (*Location, error)"},
+ {"LoadLocationFromTZData", Func, 10, "func(name string, data []byte) (*Location, error)"},
+ {"Local", Var, 0, ""},
+ {"Location", Type, 0, ""},
+ {"March", Const, 0, ""},
+ {"May", Const, 0, ""},
+ {"Microsecond", Const, 0, ""},
+ {"Millisecond", Const, 0, ""},
+ {"Minute", Const, 0, ""},
+ {"Monday", Const, 0, ""},
+ {"Month", Type, 0, ""},
+ {"Nanosecond", Const, 0, ""},
+ {"NewTicker", Func, 0, "func(d Duration) *Ticker"},
+ {"NewTimer", Func, 0, "func(d Duration) *Timer"},
+ {"November", Const, 0, ""},
+ {"Now", Func, 0, "func() Time"},
+ {"October", Const, 0, ""},
+ {"Parse", Func, 0, "func(layout string, value string) (Time, error)"},
+ {"ParseDuration", Func, 0, "func(s string) (Duration, error)"},
+ {"ParseError", Type, 0, ""},
+ {"ParseError.Layout", Field, 0, ""},
+ {"ParseError.LayoutElem", Field, 0, ""},
+ {"ParseError.Message", Field, 0, ""},
+ {"ParseError.Value", Field, 0, ""},
+ {"ParseError.ValueElem", Field, 0, ""},
+ {"ParseInLocation", Func, 1, "func(layout string, value string, loc *Location) (Time, error)"},
+ {"RFC1123", Const, 0, ""},
+ {"RFC1123Z", Const, 0, ""},
+ {"RFC3339", Const, 0, ""},
+ {"RFC3339Nano", Const, 0, ""},
+ {"RFC822", Const, 0, ""},
+ {"RFC822Z", Const, 0, ""},
+ {"RFC850", Const, 0, ""},
+ {"RubyDate", Const, 0, ""},
+ {"Saturday", Const, 0, ""},
+ {"Second", Const, 0, ""},
+ {"September", Const, 0, ""},
+ {"Since", Func, 0, "func(t Time) Duration"},
+ {"Sleep", Func, 0, "func(d Duration)"},
+ {"Stamp", Const, 0, ""},
+ {"StampMicro", Const, 0, ""},
+ {"StampMilli", Const, 0, ""},
+ {"StampNano", Const, 0, ""},
+ {"Sunday", Const, 0, ""},
+ {"Thursday", Const, 0, ""},
+ {"Tick", Func, 0, "func(d Duration) <-chan Time"},
+ {"Ticker", Type, 0, ""},
+ {"Ticker.C", Field, 0, ""},
+ {"Time", Type, 0, ""},
+ {"TimeOnly", Const, 20, ""},
+ {"Timer", Type, 0, ""},
+ {"Timer.C", Field, 0, ""},
+ {"Tuesday", Const, 0, ""},
+ {"UTC", Var, 0, ""},
+ {"Unix", Func, 0, "func(sec int64, nsec int64) Time"},
+ {"UnixDate", Const, 0, ""},
+ {"UnixMicro", Func, 17, "func(usec int64) Time"},
+ {"UnixMilli", Func, 17, "func(msec int64) Time"},
+ {"Until", Func, 8, "func(t Time) Duration"},
+ {"Wednesday", Const, 0, ""},
+ {"Weekday", Type, 0, ""},
+ },
+ "unicode": {
+ {"(SpecialCase).ToLower", Method, 0, ""},
+ {"(SpecialCase).ToTitle", Method, 0, ""},
+ {"(SpecialCase).ToUpper", Method, 0, ""},
+ {"ASCII_Hex_Digit", Var, 0, ""},
+ {"Adlam", Var, 7, ""},
+ {"Ahom", Var, 5, ""},
+ {"Anatolian_Hieroglyphs", Var, 5, ""},
+ {"Arabic", Var, 0, ""},
+ {"Armenian", Var, 0, ""},
+ {"Avestan", Var, 0, ""},
+ {"AzeriCase", Var, 0, ""},
+ {"Balinese", Var, 0, ""},
+ {"Bamum", Var, 0, ""},
+ {"Bassa_Vah", Var, 4, ""},
+ {"Batak", Var, 0, ""},
+ {"Bengali", Var, 0, ""},
+ {"Bhaiksuki", Var, 7, ""},
+ {"Bidi_Control", Var, 0, ""},
+ {"Bopomofo", Var, 0, ""},
+ {"Brahmi", Var, 0, ""},
+ {"Braille", Var, 0, ""},
+ {"Buginese", Var, 0, ""},
+ {"Buhid", Var, 0, ""},
+ {"C", Var, 0, ""},
+ {"Canadian_Aboriginal", Var, 0, ""},
+ {"Carian", Var, 0, ""},
+ {"CaseRange", Type, 0, ""},
+ {"CaseRange.Delta", Field, 0, ""},
+ {"CaseRange.Hi", Field, 0, ""},
+ {"CaseRange.Lo", Field, 0, ""},
+ {"CaseRanges", Var, 0, ""},
+ {"Categories", Var, 0, ""},
+ {"Caucasian_Albanian", Var, 4, ""},
+ {"Cc", Var, 0, ""},
+ {"Cf", Var, 0, ""},
+ {"Chakma", Var, 1, ""},
+ {"Cham", Var, 0, ""},
+ {"Cherokee", Var, 0, ""},
+ {"Chorasmian", Var, 16, ""},
+ {"Co", Var, 0, ""},
+ {"Common", Var, 0, ""},
+ {"Coptic", Var, 0, ""},
+ {"Cs", Var, 0, ""},
+ {"Cuneiform", Var, 0, ""},
+ {"Cypriot", Var, 0, ""},
+ {"Cypro_Minoan", Var, 21, ""},
+ {"Cyrillic", Var, 0, ""},
+ {"Dash", Var, 0, ""},
+ {"Deprecated", Var, 0, ""},
+ {"Deseret", Var, 0, ""},
+ {"Devanagari", Var, 0, ""},
+ {"Diacritic", Var, 0, ""},
+ {"Digit", Var, 0, ""},
+ {"Dives_Akuru", Var, 16, ""},
+ {"Dogra", Var, 13, ""},
+ {"Duployan", Var, 4, ""},
+ {"Egyptian_Hieroglyphs", Var, 0, ""},
+ {"Elbasan", Var, 4, ""},
+ {"Elymaic", Var, 14, ""},
+ {"Ethiopic", Var, 0, ""},
+ {"Extender", Var, 0, ""},
+ {"FoldCategory", Var, 0, ""},
+ {"FoldScript", Var, 0, ""},
+ {"Georgian", Var, 0, ""},
+ {"Glagolitic", Var, 0, ""},
+ {"Gothic", Var, 0, ""},
+ {"Grantha", Var, 4, ""},
+ {"GraphicRanges", Var, 0, ""},
+ {"Greek", Var, 0, ""},
+ {"Gujarati", Var, 0, ""},
+ {"Gunjala_Gondi", Var, 13, ""},
+ {"Gurmukhi", Var, 0, ""},
+ {"Han", Var, 0, ""},
+ {"Hangul", Var, 0, ""},
+ {"Hanifi_Rohingya", Var, 13, ""},
+ {"Hanunoo", Var, 0, ""},
+ {"Hatran", Var, 5, ""},
+ {"Hebrew", Var, 0, ""},
+ {"Hex_Digit", Var, 0, ""},
+ {"Hiragana", Var, 0, ""},
+ {"Hyphen", Var, 0, ""},
+ {"IDS_Binary_Operator", Var, 0, ""},
+ {"IDS_Trinary_Operator", Var, 0, ""},
+ {"Ideographic", Var, 0, ""},
+ {"Imperial_Aramaic", Var, 0, ""},
+ {"In", Func, 2, "func(r rune, ranges ...*RangeTable) bool"},
+ {"Inherited", Var, 0, ""},
+ {"Inscriptional_Pahlavi", Var, 0, ""},
+ {"Inscriptional_Parthian", Var, 0, ""},
+ {"Is", Func, 0, "func(rangeTab *RangeTable, r rune) bool"},
+ {"IsControl", Func, 0, "func(r rune) bool"},
+ {"IsDigit", Func, 0, "func(r rune) bool"},
+ {"IsGraphic", Func, 0, "func(r rune) bool"},
+ {"IsLetter", Func, 0, "func(r rune) bool"},
+ {"IsLower", Func, 0, "func(r rune) bool"},
+ {"IsMark", Func, 0, "func(r rune) bool"},
+ {"IsNumber", Func, 0, "func(r rune) bool"},
+ {"IsOneOf", Func, 0, "func(ranges []*RangeTable, r rune) bool"},
+ {"IsPrint", Func, 0, "func(r rune) bool"},
+ {"IsPunct", Func, 0, "func(r rune) bool"},
+ {"IsSpace", Func, 0, "func(r rune) bool"},
+ {"IsSymbol", Func, 0, "func(r rune) bool"},
+ {"IsTitle", Func, 0, "func(r rune) bool"},
+ {"IsUpper", Func, 0, "func(r rune) bool"},
+ {"Javanese", Var, 0, ""},
+ {"Join_Control", Var, 0, ""},
+ {"Kaithi", Var, 0, ""},
+ {"Kannada", Var, 0, ""},
+ {"Katakana", Var, 0, ""},
+ {"Kawi", Var, 21, ""},
+ {"Kayah_Li", Var, 0, ""},
+ {"Kharoshthi", Var, 0, ""},
+ {"Khitan_Small_Script", Var, 16, ""},
+ {"Khmer", Var, 0, ""},
+ {"Khojki", Var, 4, ""},
+ {"Khudawadi", Var, 4, ""},
+ {"L", Var, 0, ""},
+ {"Lao", Var, 0, ""},
+ {"Latin", Var, 0, ""},
+ {"Lepcha", Var, 0, ""},
+ {"Letter", Var, 0, ""},
+ {"Limbu", Var, 0, ""},
+ {"Linear_A", Var, 4, ""},
+ {"Linear_B", Var, 0, ""},
+ {"Lisu", Var, 0, ""},
+ {"Ll", Var, 0, ""},
+ {"Lm", Var, 0, ""},
+ {"Lo", Var, 0, ""},
+ {"Logical_Order_Exception", Var, 0, ""},
+ {"Lower", Var, 0, ""},
+ {"LowerCase", Const, 0, ""},
+ {"Lt", Var, 0, ""},
+ {"Lu", Var, 0, ""},
+ {"Lycian", Var, 0, ""},
+ {"Lydian", Var, 0, ""},
+ {"M", Var, 0, ""},
+ {"Mahajani", Var, 4, ""},
+ {"Makasar", Var, 13, ""},
+ {"Malayalam", Var, 0, ""},
+ {"Mandaic", Var, 0, ""},
+ {"Manichaean", Var, 4, ""},
+ {"Marchen", Var, 7, ""},
+ {"Mark", Var, 0, ""},
+ {"Masaram_Gondi", Var, 10, ""},
+ {"MaxASCII", Const, 0, ""},
+ {"MaxCase", Const, 0, ""},
+ {"MaxLatin1", Const, 0, ""},
+ {"MaxRune", Const, 0, ""},
+ {"Mc", Var, 0, ""},
+ {"Me", Var, 0, ""},
+ {"Medefaidrin", Var, 13, ""},
+ {"Meetei_Mayek", Var, 0, ""},
+ {"Mende_Kikakui", Var, 4, ""},
+ {"Meroitic_Cursive", Var, 1, ""},
+ {"Meroitic_Hieroglyphs", Var, 1, ""},
+ {"Miao", Var, 1, ""},
+ {"Mn", Var, 0, ""},
+ {"Modi", Var, 4, ""},
+ {"Mongolian", Var, 0, ""},
+ {"Mro", Var, 4, ""},
+ {"Multani", Var, 5, ""},
+ {"Myanmar", Var, 0, ""},
+ {"N", Var, 0, ""},
+ {"Nabataean", Var, 4, ""},
+ {"Nag_Mundari", Var, 21, ""},
+ {"Nandinagari", Var, 14, ""},
+ {"Nd", Var, 0, ""},
+ {"New_Tai_Lue", Var, 0, ""},
+ {"Newa", Var, 7, ""},
+ {"Nko", Var, 0, ""},
+ {"Nl", Var, 0, ""},
+ {"No", Var, 0, ""},
+ {"Noncharacter_Code_Point", Var, 0, ""},
+ {"Number", Var, 0, ""},
+ {"Nushu", Var, 10, ""},
+ {"Nyiakeng_Puachue_Hmong", Var, 14, ""},
+ {"Ogham", Var, 0, ""},
+ {"Ol_Chiki", Var, 0, ""},
+ {"Old_Hungarian", Var, 5, ""},
+ {"Old_Italic", Var, 0, ""},
+ {"Old_North_Arabian", Var, 4, ""},
+ {"Old_Permic", Var, 4, ""},
+ {"Old_Persian", Var, 0, ""},
+ {"Old_Sogdian", Var, 13, ""},
+ {"Old_South_Arabian", Var, 0, ""},
+ {"Old_Turkic", Var, 0, ""},
+ {"Old_Uyghur", Var, 21, ""},
+ {"Oriya", Var, 0, ""},
+ {"Osage", Var, 7, ""},
+ {"Osmanya", Var, 0, ""},
+ {"Other", Var, 0, ""},
+ {"Other_Alphabetic", Var, 0, ""},
+ {"Other_Default_Ignorable_Code_Point", Var, 0, ""},
+ {"Other_Grapheme_Extend", Var, 0, ""},
+ {"Other_ID_Continue", Var, 0, ""},
+ {"Other_ID_Start", Var, 0, ""},
+ {"Other_Lowercase", Var, 0, ""},
+ {"Other_Math", Var, 0, ""},
+ {"Other_Uppercase", Var, 0, ""},
+ {"P", Var, 0, ""},
+ {"Pahawh_Hmong", Var, 4, ""},
+ {"Palmyrene", Var, 4, ""},
+ {"Pattern_Syntax", Var, 0, ""},
+ {"Pattern_White_Space", Var, 0, ""},
+ {"Pau_Cin_Hau", Var, 4, ""},
+ {"Pc", Var, 0, ""},
+ {"Pd", Var, 0, ""},
+ {"Pe", Var, 0, ""},
+ {"Pf", Var, 0, ""},
+ {"Phags_Pa", Var, 0, ""},
+ {"Phoenician", Var, 0, ""},
+ {"Pi", Var, 0, ""},
+ {"Po", Var, 0, ""},
+ {"Prepended_Concatenation_Mark", Var, 7, ""},
+ {"PrintRanges", Var, 0, ""},
+ {"Properties", Var, 0, ""},
+ {"Ps", Var, 0, ""},
+ {"Psalter_Pahlavi", Var, 4, ""},
+ {"Punct", Var, 0, ""},
+ {"Quotation_Mark", Var, 0, ""},
+ {"Radical", Var, 0, ""},
+ {"Range16", Type, 0, ""},
+ {"Range16.Hi", Field, 0, ""},
+ {"Range16.Lo", Field, 0, ""},
+ {"Range16.Stride", Field, 0, ""},
+ {"Range32", Type, 0, ""},
+ {"Range32.Hi", Field, 0, ""},
+ {"Range32.Lo", Field, 0, ""},
+ {"Range32.Stride", Field, 0, ""},
+ {"RangeTable", Type, 0, ""},
+ {"RangeTable.LatinOffset", Field, 1, ""},
+ {"RangeTable.R16", Field, 0, ""},
+ {"RangeTable.R32", Field, 0, ""},
+ {"Regional_Indicator", Var, 10, ""},
+ {"Rejang", Var, 0, ""},
+ {"ReplacementChar", Const, 0, ""},
+ {"Runic", Var, 0, ""},
+ {"S", Var, 0, ""},
+ {"STerm", Var, 0, ""},
+ {"Samaritan", Var, 0, ""},
+ {"Saurashtra", Var, 0, ""},
+ {"Sc", Var, 0, ""},
+ {"Scripts", Var, 0, ""},
+ {"Sentence_Terminal", Var, 7, ""},
+ {"Sharada", Var, 1, ""},
+ {"Shavian", Var, 0, ""},
+ {"Siddham", Var, 4, ""},
+ {"SignWriting", Var, 5, ""},
+ {"SimpleFold", Func, 0, "func(r rune) rune"},
+ {"Sinhala", Var, 0, ""},
+ {"Sk", Var, 0, ""},
+ {"Sm", Var, 0, ""},
+ {"So", Var, 0, ""},
+ {"Soft_Dotted", Var, 0, ""},
+ {"Sogdian", Var, 13, ""},
+ {"Sora_Sompeng", Var, 1, ""},
+ {"Soyombo", Var, 10, ""},
+ {"Space", Var, 0, ""},
+ {"SpecialCase", Type, 0, ""},
+ {"Sundanese", Var, 0, ""},
+ {"Syloti_Nagri", Var, 0, ""},
+ {"Symbol", Var, 0, ""},
+ {"Syriac", Var, 0, ""},
+ {"Tagalog", Var, 0, ""},
+ {"Tagbanwa", Var, 0, ""},
+ {"Tai_Le", Var, 0, ""},
+ {"Tai_Tham", Var, 0, ""},
+ {"Tai_Viet", Var, 0, ""},
+ {"Takri", Var, 1, ""},
+ {"Tamil", Var, 0, ""},
+ {"Tangsa", Var, 21, ""},
+ {"Tangut", Var, 7, ""},
+ {"Telugu", Var, 0, ""},
+ {"Terminal_Punctuation", Var, 0, ""},
+ {"Thaana", Var, 0, ""},
+ {"Thai", Var, 0, ""},
+ {"Tibetan", Var, 0, ""},
+ {"Tifinagh", Var, 0, ""},
+ {"Tirhuta", Var, 4, ""},
+ {"Title", Var, 0, ""},
+ {"TitleCase", Const, 0, ""},
+ {"To", Func, 0, "func(_case int, r rune) rune"},
+ {"ToLower", Func, 0, "func(r rune) rune"},
+ {"ToTitle", Func, 0, "func(r rune) rune"},
+ {"ToUpper", Func, 0, "func(r rune) rune"},
+ {"Toto", Var, 21, ""},
+ {"TurkishCase", Var, 0, ""},
+ {"Ugaritic", Var, 0, ""},
+ {"Unified_Ideograph", Var, 0, ""},
+ {"Upper", Var, 0, ""},
+ {"UpperCase", Const, 0, ""},
+ {"UpperLower", Const, 0, ""},
+ {"Vai", Var, 0, ""},
+ {"Variation_Selector", Var, 0, ""},
+ {"Version", Const, 0, ""},
+ {"Vithkuqi", Var, 21, ""},
+ {"Wancho", Var, 14, ""},
+ {"Warang_Citi", Var, 4, ""},
+ {"White_Space", Var, 0, ""},
+ {"Yezidi", Var, 16, ""},
+ {"Yi", Var, 0, ""},
+ {"Z", Var, 0, ""},
+ {"Zanabazar_Square", Var, 10, ""},
+ {"Zl", Var, 0, ""},
+ {"Zp", Var, 0, ""},
+ {"Zs", Var, 0, ""},
+ },
+ "unicode/utf16": {
+ {"AppendRune", Func, 20, "func(a []uint16, r rune) []uint16"},
+ {"Decode", Func, 0, "func(s []uint16) []rune"},
+ {"DecodeRune", Func, 0, "func(r1 rune, r2 rune) rune"},
+ {"Encode", Func, 0, "func(s []rune) []uint16"},
+ {"EncodeRune", Func, 0, "func(r rune) (r1 rune, r2 rune)"},
+ {"IsSurrogate", Func, 0, "func(r rune) bool"},
+ {"RuneLen", Func, 23, "func(r rune) int"},
+ },
+ "unicode/utf8": {
+ {"AppendRune", Func, 18, "func(p []byte, r rune) []byte"},
+ {"DecodeLastRune", Func, 0, "func(p []byte) (r rune, size int)"},
+ {"DecodeLastRuneInString", Func, 0, "func(s string) (r rune, size int)"},
+ {"DecodeRune", Func, 0, "func(p []byte) (r rune, size int)"},
+ {"DecodeRuneInString", Func, 0, "func(s string) (r rune, size int)"},
+ {"EncodeRune", Func, 0, "func(p []byte, r rune) int"},
+ {"FullRune", Func, 0, "func(p []byte) bool"},
+ {"FullRuneInString", Func, 0, "func(s string) bool"},
+ {"MaxRune", Const, 0, ""},
+ {"RuneCount", Func, 0, "func(p []byte) int"},
+ {"RuneCountInString", Func, 0, "func(s string) (n int)"},
+ {"RuneError", Const, 0, ""},
+ {"RuneLen", Func, 0, "func(r rune) int"},
+ {"RuneSelf", Const, 0, ""},
+ {"RuneStart", Func, 0, "func(b byte) bool"},
+ {"UTFMax", Const, 0, ""},
+ {"Valid", Func, 0, "func(p []byte) bool"},
+ {"ValidRune", Func, 1, "func(r rune) bool"},
+ {"ValidString", Func, 0, "func(s string) bool"},
+ },
+ "unique": {
+ {"(Handle).Value", Method, 23, ""},
+ {"Handle", Type, 23, ""},
+ {"Make", Func, 23, "func[T comparable](value T) Handle[T]"},
+ },
+ "unsafe": {
+ {"Add", Func, 0, ""},
+ {"Alignof", Func, 0, ""},
+ {"Offsetof", Func, 0, ""},
+ {"Pointer", Type, 0, ""},
+ {"Sizeof", Func, 0, ""},
+ {"Slice", Func, 0, ""},
+ {"SliceData", Func, 0, ""},
+ {"String", Func, 0, ""},
+ {"StringData", Func, 0, ""},
+ },
+ "weak": {
+ {"(Pointer).Value", Method, 24, ""},
+ {"Make", Func, 24, "func[T any](ptr *T) Pointer[T]"},
+ {"Pointer", Type, 24, ""},
+ },
+}
diff --git a/vendor/golang.org/x/tools/internal/stdlib/stdlib.go b/vendor/golang.org/x/tools/internal/stdlib/stdlib.go
new file mode 100644
index 00000000..e223e0f3
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/stdlib/stdlib.go
@@ -0,0 +1,105 @@
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:generate go run generate.go
+
+// Package stdlib provides a table of all exported symbols in the
+// standard library, along with the version at which they first
+// appeared. It also provides the import graph of std packages.
+package stdlib
+
+import (
+ "fmt"
+ "strings"
+)
+
+type Symbol struct {
+ Name string
+ Kind Kind
+ Version Version // Go version that first included the symbol
+ // Signature provides the type of a function (defined only for Kind=Func).
+ // Imported types are denoted as pkg.T; pkg is not fully qualified.
+ // TODO(adonovan): use an unambiguous encoding that is parseable.
+ //
+ // Example2:
+ // func[M ~map[K]V, K comparable, V any](m M) M
+ // func(fi fs.FileInfo, link string) (*Header, error)
+ Signature string // if Kind == stdlib.Func
+}
+
+// A Kind indicates the kind of a symbol:
+// function, variable, constant, type, and so on.
+type Kind int8
+
+const (
+ Invalid Kind = iota // Example name:
+ Type // "Buffer"
+ Func // "Println"
+ Var // "EOF"
+ Const // "Pi"
+ Field // "Point.X"
+ Method // "(*Buffer).Grow"
+)
+
+func (kind Kind) String() string {
+ return [...]string{
+ Invalid: "invalid",
+ Type: "type",
+ Func: "func",
+ Var: "var",
+ Const: "const",
+ Field: "field",
+ Method: "method",
+ }[kind]
+}
+
+// A Version represents a version of Go of the form "go1.%d".
+type Version int8
+
+// String returns a version string of the form "go1.23", without allocating.
+func (v Version) String() string { return versions[v] }
+
+var versions [30]string // (increase constant as needed)
+
+func init() {
+ for i := range versions {
+ versions[i] = fmt.Sprintf("go1.%d", i)
+ }
+}
+
+// HasPackage reports whether the specified package path is part of
+// the standard library's public API.
+func HasPackage(path string) bool {
+ _, ok := PackageSymbols[path]
+ return ok
+}
+
+// SplitField splits the field symbol name into type and field
+// components. It must be called only on Field symbols.
+//
+// Example: "File.Package" -> ("File", "Package")
+func (sym *Symbol) SplitField() (typename, name string) {
+ if sym.Kind != Field {
+ panic("not a field")
+ }
+ typename, name, _ = strings.Cut(sym.Name, ".")
+ return
+}
+
+// SplitMethod splits the method symbol name into pointer, receiver,
+// and method components. It must be called only on Method symbols.
+//
+// Example: "(*Buffer).Grow" -> (true, "Buffer", "Grow")
+func (sym *Symbol) SplitMethod() (ptr bool, recv, name string) {
+ if sym.Kind != Method {
+ panic("not a method")
+ }
+ recv, name, _ = strings.Cut(sym.Name, ".")
+ recv = recv[len("(") : len(recv)-len(")")]
+ ptr = recv[0] == '*'
+ if ptr {
+ recv = recv[len("*"):]
+ }
+ return
+}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/common.go b/vendor/golang.org/x/tools/internal/typeparams/common.go
new file mode 100644
index 00000000..cdae2b8e
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typeparams/common.go
@@ -0,0 +1,68 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package typeparams contains common utilities for writing tools that
+// interact with generic Go code, as introduced with Go 1.18. It
+// supplements the standard library APIs. Notably, the StructuralTerms
+// API computes a minimal representation of the structural
+// restrictions on a type parameter.
+//
+// An external version of these APIs is available in the
+// golang.org/x/exp/typeparams module.
+package typeparams
+
+import (
+ "go/ast"
+ "go/token"
+ "go/types"
+)
+
+// UnpackIndexExpr extracts data from AST nodes that represent index
+// expressions.
+//
+// For an ast.IndexExpr, the resulting indices slice will contain exactly one
+// index expression. For an ast.IndexListExpr (go1.18+), it may have a variable
+// number of index expressions.
+//
+// For nodes that don't represent index expressions, the first return value of
+// UnpackIndexExpr will be nil.
+func UnpackIndexExpr(n ast.Node) (x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack token.Pos) {
+ switch e := n.(type) {
+ case *ast.IndexExpr:
+ return e.X, e.Lbrack, []ast.Expr{e.Index}, e.Rbrack
+ case *ast.IndexListExpr:
+ return e.X, e.Lbrack, e.Indices, e.Rbrack
+ }
+ return nil, token.NoPos, nil, token.NoPos
+}
+
+// PackIndexExpr returns an *ast.IndexExpr or *ast.IndexListExpr, depending on
+// the cardinality of indices. Calling PackIndexExpr with len(indices) == 0
+// will panic.
+func PackIndexExpr(x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack token.Pos) ast.Expr {
+ switch len(indices) {
+ case 0:
+ panic("empty indices")
+ case 1:
+ return &ast.IndexExpr{
+ X: x,
+ Lbrack: lbrack,
+ Index: indices[0],
+ Rbrack: rbrack,
+ }
+ default:
+ return &ast.IndexListExpr{
+ X: x,
+ Lbrack: lbrack,
+ Indices: indices,
+ Rbrack: rbrack,
+ }
+ }
+}
+
+// IsTypeParam reports whether t is a type parameter (or an alias of one).
+func IsTypeParam(t types.Type) bool {
+ _, ok := types.Unalias(t).(*types.TypeParam)
+ return ok
+}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/coretype.go b/vendor/golang.org/x/tools/internal/typeparams/coretype.go
new file mode 100644
index 00000000..27a2b179
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typeparams/coretype.go
@@ -0,0 +1,155 @@
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typeparams
+
+import (
+ "fmt"
+ "go/types"
+)
+
+// CoreType returns the core type of T or nil if T does not have a core type.
+//
+// See https://go.dev/ref/spec#Core_types for the definition of a core type.
+func CoreType(T types.Type) types.Type {
+ U := T.Underlying()
+ if _, ok := U.(*types.Interface); !ok {
+ return U // for non-interface types,
+ }
+
+ terms, err := NormalTerms(U)
+ if len(terms) == 0 || err != nil {
+ // len(terms) -> empty type set of interface.
+ // err != nil => U is invalid, exceeds complexity bounds, or has an empty type set.
+ return nil // no core type.
+ }
+
+ U = terms[0].Type().Underlying()
+ var identical int // i in [0,identical) => Identical(U, terms[i].Type().Underlying())
+ for identical = 1; identical < len(terms); identical++ {
+ if !types.Identical(U, terms[identical].Type().Underlying()) {
+ break
+ }
+ }
+
+ if identical == len(terms) {
+ // https://go.dev/ref/spec#Core_types
+ // "There is a single type U which is the underlying type of all types in the type set of T"
+ return U
+ }
+ ch, ok := U.(*types.Chan)
+ if !ok {
+ return nil // no core type as identical < len(terms) and U is not a channel.
+ }
+ // https://go.dev/ref/spec#Core_types
+ // "the type chan E if T contains only bidirectional channels, or the type chan<- E or
+ // <-chan E depending on the direction of the directional channels present."
+ for chans := identical; chans < len(terms); chans++ {
+ curr, ok := terms[chans].Type().Underlying().(*types.Chan)
+ if !ok {
+ return nil
+ }
+ if !types.Identical(ch.Elem(), curr.Elem()) {
+ return nil // channel elements are not identical.
+ }
+ if ch.Dir() == types.SendRecv {
+ // ch is bidirectional. We can safely always use curr's direction.
+ ch = curr
+ } else if curr.Dir() != types.SendRecv && ch.Dir() != curr.Dir() {
+ // ch and curr are not bidirectional and not the same direction.
+ return nil
+ }
+ }
+ return ch
+}
+
+// NormalTerms returns a slice of terms representing the normalized structural
+// type restrictions of a type, if any.
+//
+// For all types other than *types.TypeParam, *types.Interface, and
+// *types.Union, this is just a single term with Tilde() == false and
+// Type() == typ. For *types.TypeParam, *types.Interface, and *types.Union, see
+// below.
+//
+// Structural type restrictions of a type parameter are created via
+// non-interface types embedded in its constraint interface (directly, or via a
+// chain of interface embeddings). For example, in the declaration type
+// T[P interface{~int; m()}] int the structural restriction of the type
+// parameter P is ~int.
+//
+// With interface embedding and unions, the specification of structural type
+// restrictions may be arbitrarily complex. For example, consider the
+// following:
+//
+// type A interface{ ~string|~[]byte }
+//
+// type B interface{ int|string }
+//
+// type C interface { ~string|~int }
+//
+// type T[P interface{ A|B; C }] int
+//
+// In this example, the structural type restriction of P is ~string|int: A|B
+// expands to ~string|~[]byte|int|string, which reduces to ~string|~[]byte|int,
+// which when intersected with C (~string|~int) yields ~string|int.
+//
+// NormalTerms computes these expansions and reductions, producing a
+// "normalized" form of the embeddings. A structural restriction is normalized
+// if it is a single union containing no interface terms, and is minimal in the
+// sense that removing any term changes the set of types satisfying the
+// constraint. It is left as a proof for the reader that, modulo sorting, there
+// is exactly one such normalized form.
+//
+// Because the minimal representation always takes this form, NormalTerms
+// returns a slice of tilde terms corresponding to the terms of the union in
+// the normalized structural restriction. An error is returned if the type is
+// invalid, exceeds complexity bounds, or has an empty type set. In the latter
+// case, NormalTerms returns ErrEmptyTypeSet.
+//
+// NormalTerms makes no guarantees about the order of terms, except that it
+// is deterministic.
+func NormalTerms(T types.Type) ([]*types.Term, error) {
+ // typeSetOf(T) == typeSetOf(Unalias(T))
+ typ := types.Unalias(T)
+ if named, ok := typ.(*types.Named); ok {
+ typ = named.Underlying()
+ }
+ switch typ := typ.(type) {
+ case *types.TypeParam:
+ return StructuralTerms(typ)
+ case *types.Union:
+ return UnionTermSet(typ)
+ case *types.Interface:
+ return InterfaceTermSet(typ)
+ default:
+ return []*types.Term{types.NewTerm(false, T)}, nil
+ }
+}
+
+// Deref returns the type of the variable pointed to by t,
+// if t's core type is a pointer; otherwise it returns t.
+//
+// Do not assume that Deref(T)==T implies T is not a pointer:
+// consider "type T *T", for example.
+//
+// TODO(adonovan): ideally this would live in typesinternal, but that
+// creates an import cycle. Move there when we melt this package down.
+func Deref(t types.Type) types.Type {
+ if ptr, ok := CoreType(t).(*types.Pointer); ok {
+ return ptr.Elem()
+ }
+ return t
+}
+
+// MustDeref returns the type of the variable pointed to by t.
+// It panics if t's core type is not a pointer.
+//
+// TODO(adonovan): ideally this would live in typesinternal, but that
+// creates an import cycle. Move there when we melt this package down.
+func MustDeref(t types.Type) types.Type {
+ if ptr, ok := CoreType(t).(*types.Pointer); ok {
+ return ptr.Elem()
+ }
+ panic(fmt.Sprintf("%v is not a pointer", t))
+}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/free.go b/vendor/golang.org/x/tools/internal/typeparams/free.go
new file mode 100644
index 00000000..709d2fc1
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typeparams/free.go
@@ -0,0 +1,131 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typeparams
+
+import (
+ "go/types"
+
+ "golang.org/x/tools/internal/aliases"
+)
+
+// Free is a memoization of the set of free type parameters within a
+// type. It makes a sequence of calls to [Free.Has] for overlapping
+// types more efficient. The zero value is ready for use.
+//
+// NOTE: Adapted from go/types/infer.go. If it is later exported, factor.
+type Free struct {
+ seen map[types.Type]bool
+}
+
+// Has reports whether the specified type has a free type parameter.
+func (w *Free) Has(typ types.Type) (res bool) {
+ // detect cycles
+ if x, ok := w.seen[typ]; ok {
+ return x
+ }
+ if w.seen == nil {
+ w.seen = make(map[types.Type]bool)
+ }
+ w.seen[typ] = false
+ defer func() {
+ w.seen[typ] = res
+ }()
+
+ switch t := typ.(type) {
+ case nil, *types.Basic: // TODO(gri) should nil be handled here?
+ break
+
+ case *types.Alias:
+ if aliases.TypeParams(t).Len() > aliases.TypeArgs(t).Len() {
+ return true // This is an uninstantiated Alias.
+ }
+ // The expansion of an alias can have free type parameters,
+ // whether or not the alias itself has type parameters:
+ //
+ // func _[K comparable]() {
+ // type Set = map[K]bool // free(Set) = {K}
+ // type MapTo[V] = map[K]V // free(Map[foo]) = {V}
+ // }
+ //
+ // So, we must Unalias.
+ return w.Has(types.Unalias(t))
+
+ case *types.Array:
+ return w.Has(t.Elem())
+
+ case *types.Slice:
+ return w.Has(t.Elem())
+
+ case *types.Struct:
+ for i, n := 0, t.NumFields(); i < n; i++ {
+ if w.Has(t.Field(i).Type()) {
+ return true
+ }
+ }
+
+ case *types.Pointer:
+ return w.Has(t.Elem())
+
+ case *types.Tuple:
+ n := t.Len()
+ for i := range n {
+ if w.Has(t.At(i).Type()) {
+ return true
+ }
+ }
+
+ case *types.Signature:
+ // t.tparams may not be nil if we are looking at a signature
+ // of a generic function type (or an interface method) that is
+ // part of the type we're testing. We don't care about these type
+ // parameters.
+ // Similarly, the receiver of a method may declare (rather than
+ // use) type parameters, we don't care about those either.
+ // Thus, we only need to look at the input and result parameters.
+ return w.Has(t.Params()) || w.Has(t.Results())
+
+ case *types.Interface:
+ for i, n := 0, t.NumMethods(); i < n; i++ {
+ if w.Has(t.Method(i).Type()) {
+ return true
+ }
+ }
+ terms, err := InterfaceTermSet(t)
+ if err != nil {
+ return false // ill typed
+ }
+ for _, term := range terms {
+ if w.Has(term.Type()) {
+ return true
+ }
+ }
+
+ case *types.Map:
+ return w.Has(t.Key()) || w.Has(t.Elem())
+
+ case *types.Chan:
+ return w.Has(t.Elem())
+
+ case *types.Named:
+ args := t.TypeArgs()
+ if params := t.TypeParams(); params.Len() > args.Len() {
+ return true // this is an uninstantiated named type.
+ }
+ for i, n := 0, args.Len(); i < n; i++ {
+ if w.Has(args.At(i)) {
+ return true
+ }
+ }
+ return w.Has(t.Underlying()) // recurse for types local to parameterized functions
+
+ case *types.TypeParam:
+ return true
+
+ default:
+ panic(t) // unreachable
+ }
+
+ return false
+}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/normalize.go b/vendor/golang.org/x/tools/internal/typeparams/normalize.go
new file mode 100644
index 00000000..f49802b8
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typeparams/normalize.go
@@ -0,0 +1,218 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typeparams
+
+import (
+ "errors"
+ "fmt"
+ "go/types"
+ "os"
+ "strings"
+)
+
+//go:generate go run copytermlist.go
+
+const debug = false
+
+var ErrEmptyTypeSet = errors.New("empty type set")
+
+// StructuralTerms returns a slice of terms representing the normalized
+// structural type restrictions of a type parameter, if any.
+//
+// Structural type restrictions of a type parameter are created via
+// non-interface types embedded in its constraint interface (directly, or via a
+// chain of interface embeddings). For example, in the declaration
+//
+// type T[P interface{~int; m()}] int
+//
+// the structural restriction of the type parameter P is ~int.
+//
+// With interface embedding and unions, the specification of structural type
+// restrictions may be arbitrarily complex. For example, consider the
+// following:
+//
+// type A interface{ ~string|~[]byte }
+//
+// type B interface{ int|string }
+//
+// type C interface { ~string|~int }
+//
+// type T[P interface{ A|B; C }] int
+//
+// In this example, the structural type restriction of P is ~string|int: A|B
+// expands to ~string|~[]byte|int|string, which reduces to ~string|~[]byte|int,
+// which when intersected with C (~string|~int) yields ~string|int.
+//
+// StructuralTerms computes these expansions and reductions, producing a
+// "normalized" form of the embeddings. A structural restriction is normalized
+// if it is a single union containing no interface terms, and is minimal in the
+// sense that removing any term changes the set of types satisfying the
+// constraint. It is left as a proof for the reader that, modulo sorting, there
+// is exactly one such normalized form.
+//
+// Because the minimal representation always takes this form, StructuralTerms
+// returns a slice of tilde terms corresponding to the terms of the union in
+// the normalized structural restriction. An error is returned if the
+// constraint interface is invalid, exceeds complexity bounds, or has an empty
+// type set. In the latter case, StructuralTerms returns ErrEmptyTypeSet.
+//
+// StructuralTerms makes no guarantees about the order of terms, except that it
+// is deterministic.
+func StructuralTerms(tparam *types.TypeParam) ([]*types.Term, error) {
+ constraint := tparam.Constraint()
+ if constraint == nil {
+ return nil, fmt.Errorf("%s has nil constraint", tparam)
+ }
+ iface, _ := constraint.Underlying().(*types.Interface)
+ if iface == nil {
+ return nil, fmt.Errorf("constraint is %T, not *types.Interface", constraint.Underlying())
+ }
+ return InterfaceTermSet(iface)
+}
+
+// InterfaceTermSet computes the normalized terms for a constraint interface,
+// returning an error if the term set cannot be computed or is empty. In the
+// latter case, the error will be ErrEmptyTypeSet.
+//
+// See the documentation of StructuralTerms for more information on
+// normalization.
+func InterfaceTermSet(iface *types.Interface) ([]*types.Term, error) {
+ return computeTermSet(iface)
+}
+
+// UnionTermSet computes the normalized terms for a union, returning an error
+// if the term set cannot be computed or is empty. In the latter case, the
+// error will be ErrEmptyTypeSet.
+//
+// See the documentation of StructuralTerms for more information on
+// normalization.
+func UnionTermSet(union *types.Union) ([]*types.Term, error) {
+ return computeTermSet(union)
+}
+
+func computeTermSet(typ types.Type) ([]*types.Term, error) {
+ tset, err := computeTermSetInternal(typ, make(map[types.Type]*termSet), 0)
+ if err != nil {
+ return nil, err
+ }
+ if tset.terms.isEmpty() {
+ return nil, ErrEmptyTypeSet
+ }
+ if tset.terms.isAll() {
+ return nil, nil
+ }
+ var terms []*types.Term
+ for _, term := range tset.terms {
+ terms = append(terms, types.NewTerm(term.tilde, term.typ))
+ }
+ return terms, nil
+}
+
+// A termSet holds the normalized set of terms for a given type.
+//
+// The name termSet is intentionally distinct from 'type set': a type set is
+// all types that implement a type (and includes method restrictions), whereas
+// a term set just represents the structural restrictions on a type.
+type termSet struct {
+ complete bool
+ terms termlist
+}
+
+func indentf(depth int, format string, args ...any) {
+ fmt.Fprintf(os.Stderr, strings.Repeat(".", depth)+format+"\n", args...)
+}
+
+func computeTermSetInternal(t types.Type, seen map[types.Type]*termSet, depth int) (res *termSet, err error) {
+ if t == nil {
+ panic("nil type")
+ }
+
+ if debug {
+ indentf(depth, "%s", t.String())
+ defer func() {
+ if err != nil {
+ indentf(depth, "=> %s", err)
+ } else {
+ indentf(depth, "=> %s", res.terms.String())
+ }
+ }()
+ }
+
+ const maxTermCount = 100
+ if tset, ok := seen[t]; ok {
+ if !tset.complete {
+ return nil, fmt.Errorf("cycle detected in the declaration of %s", t)
+ }
+ return tset, nil
+ }
+
+ // Mark the current type as seen to avoid infinite recursion.
+ tset := new(termSet)
+ defer func() {
+ tset.complete = true
+ }()
+ seen[t] = tset
+
+ switch u := t.Underlying().(type) {
+ case *types.Interface:
+ // The term set of an interface is the intersection of the term sets of its
+ // embedded types.
+ tset.terms = allTermlist
+ for i := 0; i < u.NumEmbeddeds(); i++ {
+ embedded := u.EmbeddedType(i)
+ if _, ok := embedded.Underlying().(*types.TypeParam); ok {
+ return nil, fmt.Errorf("invalid embedded type %T", embedded)
+ }
+ tset2, err := computeTermSetInternal(embedded, seen, depth+1)
+ if err != nil {
+ return nil, err
+ }
+ tset.terms = tset.terms.intersect(tset2.terms)
+ }
+ case *types.Union:
+ // The term set of a union is the union of term sets of its terms.
+ tset.terms = nil
+ for i := 0; i < u.Len(); i++ {
+ t := u.Term(i)
+ var terms termlist
+ switch t.Type().Underlying().(type) {
+ case *types.Interface:
+ tset2, err := computeTermSetInternal(t.Type(), seen, depth+1)
+ if err != nil {
+ return nil, err
+ }
+ terms = tset2.terms
+ case *types.TypeParam, *types.Union:
+ // A stand-alone type parameter or union is not permitted as union
+ // term.
+ return nil, fmt.Errorf("invalid union term %T", t)
+ default:
+ if t.Type() == types.Typ[types.Invalid] {
+ continue
+ }
+ terms = termlist{{t.Tilde(), t.Type()}}
+ }
+ tset.terms = tset.terms.union(terms)
+ if len(tset.terms) > maxTermCount {
+ return nil, fmt.Errorf("exceeded max term count %d", maxTermCount)
+ }
+ }
+ case *types.TypeParam:
+ panic("unreachable")
+ default:
+ // For all other types, the term set is just a single non-tilde term
+ // holding the type itself.
+ if u != types.Typ[types.Invalid] {
+ tset.terms = termlist{{false, t}}
+ }
+ }
+ return tset, nil
+}
+
+// under is a facade for the go/types internal function of the same name. It is
+// used by typeterm.go.
+func under(t types.Type) types.Type {
+ return t.Underlying()
+}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/termlist.go b/vendor/golang.org/x/tools/internal/typeparams/termlist.go
new file mode 100644
index 00000000..9bc29143
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typeparams/termlist.go
@@ -0,0 +1,169 @@
+// Code generated by "go test -run=Generate -write=all"; DO NOT EDIT.
+// Source: ../../cmd/compile/internal/types2/termlist.go
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Code generated by copytermlist.go DO NOT EDIT.
+
+package typeparams
+
+import (
+ "go/types"
+ "strings"
+)
+
+// A termlist represents the type set represented by the union
+// t1 ∪ y2 ∪ ... tn of the type sets of the terms t1 to tn.
+// A termlist is in normal form if all terms are disjoint.
+// termlist operations don't require the operands to be in
+// normal form.
+type termlist []*term
+
+// allTermlist represents the set of all types.
+// It is in normal form.
+var allTermlist = termlist{new(term)}
+
+// termSep is the separator used between individual terms.
+const termSep = " | "
+
+// String prints the termlist exactly (without normalization).
+func (xl termlist) String() string {
+ if len(xl) == 0 {
+ return "∅"
+ }
+ var buf strings.Builder
+ for i, x := range xl {
+ if i > 0 {
+ buf.WriteString(termSep)
+ }
+ buf.WriteString(x.String())
+ }
+ return buf.String()
+}
+
+// isEmpty reports whether the termlist xl represents the empty set of types.
+func (xl termlist) isEmpty() bool {
+ // If there's a non-nil term, the entire list is not empty.
+ // If the termlist is in normal form, this requires at most
+ // one iteration.
+ for _, x := range xl {
+ if x != nil {
+ return false
+ }
+ }
+ return true
+}
+
+// isAll reports whether the termlist xl represents the set of all types.
+func (xl termlist) isAll() bool {
+ // If there's a 𝓤 term, the entire list is 𝓤.
+ // If the termlist is in normal form, this requires at most
+ // one iteration.
+ for _, x := range xl {
+ if x != nil && x.typ == nil {
+ return true
+ }
+ }
+ return false
+}
+
+// norm returns the normal form of xl.
+func (xl termlist) norm() termlist {
+ // Quadratic algorithm, but good enough for now.
+ // TODO(gri) fix asymptotic performance
+ used := make([]bool, len(xl))
+ var rl termlist
+ for i, xi := range xl {
+ if xi == nil || used[i] {
+ continue
+ }
+ for j := i + 1; j < len(xl); j++ {
+ xj := xl[j]
+ if xj == nil || used[j] {
+ continue
+ }
+ if u1, u2 := xi.union(xj); u2 == nil {
+ // If we encounter a 𝓤 term, the entire list is 𝓤.
+ // Exit early.
+ // (Note that this is not just an optimization;
+ // if we continue, we may end up with a 𝓤 term
+ // and other terms and the result would not be
+ // in normal form.)
+ if u1.typ == nil {
+ return allTermlist
+ }
+ xi = u1
+ used[j] = true // xj is now unioned into xi - ignore it in future iterations
+ }
+ }
+ rl = append(rl, xi)
+ }
+ return rl
+}
+
+// union returns the union xl ∪ yl.
+func (xl termlist) union(yl termlist) termlist {
+ return append(xl, yl...).norm()
+}
+
+// intersect returns the intersection xl ∩ yl.
+func (xl termlist) intersect(yl termlist) termlist {
+ if xl.isEmpty() || yl.isEmpty() {
+ return nil
+ }
+
+ // Quadratic algorithm, but good enough for now.
+ // TODO(gri) fix asymptotic performance
+ var rl termlist
+ for _, x := range xl {
+ for _, y := range yl {
+ if r := x.intersect(y); r != nil {
+ rl = append(rl, r)
+ }
+ }
+ }
+ return rl.norm()
+}
+
+// equal reports whether xl and yl represent the same type set.
+func (xl termlist) equal(yl termlist) bool {
+ // TODO(gri) this should be more efficient
+ return xl.subsetOf(yl) && yl.subsetOf(xl)
+}
+
+// includes reports whether t ∈ xl.
+func (xl termlist) includes(t types.Type) bool {
+ for _, x := range xl {
+ if x.includes(t) {
+ return true
+ }
+ }
+ return false
+}
+
+// supersetOf reports whether y ⊆ xl.
+func (xl termlist) supersetOf(y *term) bool {
+ for _, x := range xl {
+ if y.subsetOf(x) {
+ return true
+ }
+ }
+ return false
+}
+
+// subsetOf reports whether xl ⊆ yl.
+func (xl termlist) subsetOf(yl termlist) bool {
+ if yl.isEmpty() {
+ return xl.isEmpty()
+ }
+
+ // each term x of xl must be a subset of yl
+ for _, x := range xl {
+ if !yl.supersetOf(x) {
+ return false // x is not a subset yl
+ }
+ }
+ return true
+}
diff --git a/vendor/golang.org/x/tools/internal/typeparams/typeterm.go b/vendor/golang.org/x/tools/internal/typeparams/typeterm.go
new file mode 100644
index 00000000..fa758cdc
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typeparams/typeterm.go
@@ -0,0 +1,172 @@
+// Code generated by "go test -run=Generate -write=all"; DO NOT EDIT.
+// Source: ../../cmd/compile/internal/types2/typeterm.go
+
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Code generated by copytermlist.go DO NOT EDIT.
+
+package typeparams
+
+import "go/types"
+
+// A term describes elementary type sets:
+//
+// ∅: (*term)(nil) == ∅ // set of no types (empty set)
+// 𝓤: &term{} == 𝓤 // set of all types (𝓤niverse)
+// T: &term{false, T} == {T} // set of type T
+// ~t: &term{true, t} == {t' | under(t') == t} // set of types with underlying type t
+type term struct {
+ tilde bool // valid if typ != nil
+ typ types.Type
+}
+
+func (x *term) String() string {
+ switch {
+ case x == nil:
+ return "∅"
+ case x.typ == nil:
+ return "𝓤"
+ case x.tilde:
+ return "~" + x.typ.String()
+ default:
+ return x.typ.String()
+ }
+}
+
+// equal reports whether x and y represent the same type set.
+func (x *term) equal(y *term) bool {
+ // easy cases
+ switch {
+ case x == nil || y == nil:
+ return x == y
+ case x.typ == nil || y.typ == nil:
+ return x.typ == y.typ
+ }
+ // ∅ ⊂ x, y ⊂ 𝓤
+
+ return x.tilde == y.tilde && types.Identical(x.typ, y.typ)
+}
+
+// union returns the union x ∪ y: zero, one, or two non-nil terms.
+func (x *term) union(y *term) (_, _ *term) {
+ // easy cases
+ switch {
+ case x == nil && y == nil:
+ return nil, nil // ∅ ∪ ∅ == ∅
+ case x == nil:
+ return y, nil // ∅ ∪ y == y
+ case y == nil:
+ return x, nil // x ∪ ∅ == x
+ case x.typ == nil:
+ return x, nil // 𝓤 ∪ y == 𝓤
+ case y.typ == nil:
+ return y, nil // x ∪ 𝓤 == 𝓤
+ }
+ // ∅ ⊂ x, y ⊂ 𝓤
+
+ if x.disjoint(y) {
+ return x, y // x ∪ y == (x, y) if x ∩ y == ∅
+ }
+ // x.typ == y.typ
+
+ // ~t ∪ ~t == ~t
+ // ~t ∪ T == ~t
+ // T ∪ ~t == ~t
+ // T ∪ T == T
+ if x.tilde || !y.tilde {
+ return x, nil
+ }
+ return y, nil
+}
+
+// intersect returns the intersection x ∩ y.
+func (x *term) intersect(y *term) *term {
+ // easy cases
+ switch {
+ case x == nil || y == nil:
+ return nil // ∅ ∩ y == ∅ and ∩ ∅ == ∅
+ case x.typ == nil:
+ return y // 𝓤 ∩ y == y
+ case y.typ == nil:
+ return x // x ∩ 𝓤 == x
+ }
+ // ∅ ⊂ x, y ⊂ 𝓤
+
+ if x.disjoint(y) {
+ return nil // x ∩ y == ∅ if x ∩ y == ∅
+ }
+ // x.typ == y.typ
+
+ // ~t ∩ ~t == ~t
+ // ~t ∩ T == T
+ // T ∩ ~t == T
+ // T ∩ T == T
+ if !x.tilde || y.tilde {
+ return x
+ }
+ return y
+}
+
+// includes reports whether t ∈ x.
+func (x *term) includes(t types.Type) bool {
+ // easy cases
+ switch {
+ case x == nil:
+ return false // t ∈ ∅ == false
+ case x.typ == nil:
+ return true // t ∈ 𝓤 == true
+ }
+ // ∅ ⊂ x ⊂ 𝓤
+
+ u := t
+ if x.tilde {
+ u = under(u)
+ }
+ return types.Identical(x.typ, u)
+}
+
+// subsetOf reports whether x ⊆ y.
+func (x *term) subsetOf(y *term) bool {
+ // easy cases
+ switch {
+ case x == nil:
+ return true // ∅ ⊆ y == true
+ case y == nil:
+ return false // x ⊆ ∅ == false since x != ∅
+ case y.typ == nil:
+ return true // x ⊆ 𝓤 == true
+ case x.typ == nil:
+ return false // 𝓤 ⊆ y == false since y != 𝓤
+ }
+ // ∅ ⊂ x, y ⊂ 𝓤
+
+ if x.disjoint(y) {
+ return false // x ⊆ y == false if x ∩ y == ∅
+ }
+ // x.typ == y.typ
+
+ // ~t ⊆ ~t == true
+ // ~t ⊆ T == false
+ // T ⊆ ~t == true
+ // T ⊆ T == true
+ return !x.tilde || y.tilde
+}
+
+// disjoint reports whether x ∩ y == ∅.
+// x.typ and y.typ must not be nil.
+func (x *term) disjoint(y *term) bool {
+ if debug && (x.typ == nil || y.typ == nil) {
+ panic("invalid argument(s)")
+ }
+ ux := x.typ
+ if y.tilde {
+ ux = under(ux)
+ }
+ uy := y.typ
+ if x.tilde {
+ uy = under(uy)
+ }
+ return !types.Identical(ux, uy)
+}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/classify_call.go b/vendor/golang.org/x/tools/internal/typesinternal/classify_call.go
new file mode 100644
index 00000000..3db2a135
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/classify_call.go
@@ -0,0 +1,137 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typesinternal
+
+import (
+ "fmt"
+ "go/ast"
+ "go/types"
+ _ "unsafe"
+)
+
+// CallKind describes the function position of an [*ast.CallExpr].
+type CallKind int
+
+const (
+ CallStatic CallKind = iota // static call to known function
+ CallInterface // dynamic call through an interface method
+ CallDynamic // dynamic call of a func value
+ CallBuiltin // call to a builtin function
+ CallConversion // a conversion (not a call)
+)
+
+var callKindNames = []string{
+ "CallStatic",
+ "CallInterface",
+ "CallDynamic",
+ "CallBuiltin",
+ "CallConversion",
+}
+
+func (k CallKind) String() string {
+ if i := int(k); i >= 0 && i < len(callKindNames) {
+ return callKindNames[i]
+ }
+ return fmt.Sprintf("typeutil.CallKind(%d)", k)
+}
+
+// ClassifyCall classifies the function position of a call expression ([*ast.CallExpr]).
+// It distinguishes among true function calls, calls to builtins, and type conversions,
+// and further classifies function calls as static calls (where the function is known),
+// dynamic interface calls, and other dynamic calls.
+//
+// For the declarations:
+//
+// func f() {}
+// func g[T any]() {}
+// var v func()
+// var s []func()
+// type I interface { M() }
+// var i I
+//
+// ClassifyCall returns the following:
+//
+// f() CallStatic
+// g[int]() CallStatic
+// i.M() CallInterface
+// min(1, 2) CallBuiltin
+// v() CallDynamic
+// s[0]() CallDynamic
+// int(x) CallConversion
+// []byte("") CallConversion
+func ClassifyCall(info *types.Info, call *ast.CallExpr) CallKind {
+ if info.Types == nil {
+ panic("ClassifyCall: info.Types is nil")
+ }
+ tv := info.Types[call.Fun]
+ if tv.IsType() {
+ return CallConversion
+ }
+ if tv.IsBuiltin() {
+ return CallBuiltin
+ }
+ obj := info.Uses[UsedIdent(info, call.Fun)]
+ // Classify the call by the type of the object, if any.
+ switch obj := obj.(type) {
+ case *types.Func:
+ if interfaceMethod(obj) {
+ return CallInterface
+ }
+ return CallStatic
+ default:
+ return CallDynamic
+ }
+}
+
+// UsedIdent returns the identifier such that info.Uses[UsedIdent(info, e)]
+// is the [types.Object] used by e, if any.
+//
+// If e is one of various forms of reference:
+//
+// f, c, v, T lexical reference
+// pkg.X qualified identifier
+// f[T] or pkg.F[K,V] instantiations of the above kinds
+// expr.f field or method value selector
+// T.f method expression selector
+//
+// UsedIdent returns the identifier whose is associated value in [types.Info.Uses]
+// is the object to which it refers.
+//
+// For the declarations:
+//
+// func F[T any] {...}
+// type I interface { M() }
+// var (
+// x int
+// s struct { f int }
+// a []int
+// i I
+// )
+//
+// UsedIdent returns the following:
+//
+// Expr UsedIdent
+// x x
+// s.f f
+// F[int] F
+// i.M M
+// I.M M
+// min min
+// int int
+// 1 nil
+// a[0] nil
+// []byte nil
+//
+// Note: if e is an instantiated function or method, UsedIdent returns
+// the corresponding generic function or method on the generic type.
+func UsedIdent(info *types.Info, e ast.Expr) *ast.Ident {
+ return usedIdent(info, e)
+}
+
+//go:linkname usedIdent golang.org/x/tools/go/types/typeutil.usedIdent
+func usedIdent(info *types.Info, e ast.Expr) *ast.Ident
+
+//go:linkname interfaceMethod golang.org/x/tools/go/types/typeutil.interfaceMethod
+func interfaceMethod(f *types.Func) bool
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/element.go b/vendor/golang.org/x/tools/internal/typesinternal/element.go
new file mode 100644
index 00000000..4957f021
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/element.go
@@ -0,0 +1,133 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typesinternal
+
+import (
+ "fmt"
+ "go/types"
+
+ "golang.org/x/tools/go/types/typeutil"
+)
+
+// ForEachElement calls f for type T and each type reachable from its
+// type through reflection. It does this by recursively stripping off
+// type constructors; in addition, for each named type N, the type *N
+// is added to the result as it may have additional methods.
+//
+// The caller must provide an initially empty set used to de-duplicate
+// identical types, potentially across multiple calls to ForEachElement.
+// (Its final value holds all the elements seen, matching the arguments
+// passed to f.)
+//
+// TODO(adonovan): share/harmonize with go/callgraph/rta.
+func ForEachElement(rtypes *typeutil.Map, msets *typeutil.MethodSetCache, T types.Type, f func(types.Type)) {
+ var visit func(T types.Type, skip bool)
+ visit = func(T types.Type, skip bool) {
+ if !skip {
+ if seen, _ := rtypes.Set(T, true).(bool); seen {
+ return // de-dup
+ }
+
+ f(T) // notify caller of new element type
+ }
+
+ // Recursion over signatures of each method.
+ tmset := msets.MethodSet(T)
+ for i := 0; i < tmset.Len(); i++ {
+ sig := tmset.At(i).Type().(*types.Signature)
+ // It is tempting to call visit(sig, false)
+ // but, as noted in golang.org/cl/65450043,
+ // the Signature.Recv field is ignored by
+ // types.Identical and typeutil.Map, which
+ // is confusing at best.
+ //
+ // More importantly, the true signature rtype
+ // reachable from a method using reflection
+ // has no receiver but an extra ordinary parameter.
+ // For the Read method of io.Reader we want:
+ // func(Reader, []byte) (int, error)
+ // but here sig is:
+ // func([]byte) (int, error)
+ // with .Recv = Reader (though it is hard to
+ // notice because it doesn't affect Signature.String
+ // or types.Identical).
+ //
+ // TODO(adonovan): construct and visit the correct
+ // non-method signature with an extra parameter
+ // (though since unnamed func types have no methods
+ // there is essentially no actual demand for this).
+ //
+ // TODO(adonovan): document whether or not it is
+ // safe to skip non-exported methods (as RTA does).
+ visit(sig.Params(), true) // skip the Tuple
+ visit(sig.Results(), true) // skip the Tuple
+ }
+
+ switch T := T.(type) {
+ case *types.Alias:
+ visit(types.Unalias(T), skip) // emulates the pre-Alias behavior
+
+ case *types.Basic:
+ // nop
+
+ case *types.Interface:
+ // nop---handled by recursion over method set.
+
+ case *types.Pointer:
+ visit(T.Elem(), false)
+
+ case *types.Slice:
+ visit(T.Elem(), false)
+
+ case *types.Chan:
+ visit(T.Elem(), false)
+
+ case *types.Map:
+ visit(T.Key(), false)
+ visit(T.Elem(), false)
+
+ case *types.Signature:
+ if T.Recv() != nil {
+ panic(fmt.Sprintf("Signature %s has Recv %s", T, T.Recv()))
+ }
+ visit(T.Params(), true) // skip the Tuple
+ visit(T.Results(), true) // skip the Tuple
+
+ case *types.Named:
+ // A pointer-to-named type can be derived from a named
+ // type via reflection. It may have methods too.
+ visit(types.NewPointer(T), false)
+
+ // Consider 'type T struct{S}' where S has methods.
+ // Reflection provides no way to get from T to struct{S},
+ // only to S, so the method set of struct{S} is unwanted,
+ // so set 'skip' flag during recursion.
+ visit(T.Underlying(), true) // skip the unnamed type
+
+ case *types.Array:
+ visit(T.Elem(), false)
+
+ case *types.Struct:
+ for i, n := 0, T.NumFields(); i < n; i++ {
+ // TODO(adonovan): document whether or not
+ // it is safe to skip non-exported fields.
+ visit(T.Field(i).Type(), false)
+ }
+
+ case *types.Tuple:
+ for i, n := 0, T.Len(); i < n; i++ {
+ visit(T.At(i).Type(), false)
+ }
+
+ case *types.TypeParam, *types.Union:
+ // forEachReachable must not be called on parameterized types.
+ panic(T)
+
+ default:
+ panic(T)
+ }
+ }
+ visit(T, false)
+}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go b/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go
new file mode 100644
index 00000000..235a6def
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/errorcode.go
@@ -0,0 +1,1560 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typesinternal
+
+//go:generate stringer -type=ErrorCode
+
+type ErrorCode int
+
+// This file defines the error codes that can be produced during type-checking.
+// Collectively, these codes provide an identifier that may be used to
+// implement special handling for certain types of errors.
+//
+// Error codes should be fine-grained enough that the exact nature of the error
+// can be easily determined, but coarse enough that they are not an
+// implementation detail of the type checking algorithm. As a rule-of-thumb,
+// errors should be considered equivalent if there is a theoretical refactoring
+// of the type checker in which they are emitted in exactly one place. For
+// example, the type checker emits different error messages for "too many
+// arguments" and "too few arguments", but one can imagine an alternative type
+// checker where this check instead just emits a single "wrong number of
+// arguments", so these errors should have the same code.
+//
+// Error code names should be as brief as possible while retaining accuracy and
+// distinctiveness. In most cases names should start with an adjective
+// describing the nature of the error (e.g. "invalid", "unused", "misplaced"),
+// and end with a noun identifying the relevant language object. For example,
+// "DuplicateDecl" or "InvalidSliceExpr". For brevity, naming follows the
+// convention that "bad" implies a problem with syntax, and "invalid" implies a
+// problem with types.
+
+const (
+ // InvalidSyntaxTree occurs if an invalid syntax tree is provided
+ // to the type checker. It should never happen.
+ InvalidSyntaxTree ErrorCode = -1
+)
+
+const (
+ _ ErrorCode = iota
+
+ // Test is reserved for errors that only apply while in self-test mode.
+ Test
+
+ /* package names */
+
+ // BlankPkgName occurs when a package name is the blank identifier "_".
+ //
+ // Per the spec:
+ // "The PackageName must not be the blank identifier."
+ BlankPkgName
+
+ // MismatchedPkgName occurs when a file's package name doesn't match the
+ // package name already established by other files.
+ MismatchedPkgName
+
+ // InvalidPkgUse occurs when a package identifier is used outside of a
+ // selector expression.
+ //
+ // Example:
+ // import "fmt"
+ //
+ // var _ = fmt
+ InvalidPkgUse
+
+ /* imports */
+
+ // BadImportPath occurs when an import path is not valid.
+ BadImportPath
+
+ // BrokenImport occurs when importing a package fails.
+ //
+ // Example:
+ // import "amissingpackage"
+ BrokenImport
+
+ // ImportCRenamed occurs when the special import "C" is renamed. "C" is a
+ // pseudo-package, and must not be renamed.
+ //
+ // Example:
+ // import _ "C"
+ ImportCRenamed
+
+ // UnusedImport occurs when an import is unused.
+ //
+ // Example:
+ // import "fmt"
+ //
+ // func main() {}
+ UnusedImport
+
+ /* initialization */
+
+ // InvalidInitCycle occurs when an invalid cycle is detected within the
+ // initialization graph.
+ //
+ // Example:
+ // var x int = f()
+ //
+ // func f() int { return x }
+ InvalidInitCycle
+
+ /* decls */
+
+ // DuplicateDecl occurs when an identifier is declared multiple times.
+ //
+ // Example:
+ // var x = 1
+ // var x = 2
+ DuplicateDecl
+
+ // InvalidDeclCycle occurs when a declaration cycle is not valid.
+ //
+ // Example:
+ // import "unsafe"
+ //
+ // type T struct {
+ // a [n]int
+ // }
+ //
+ // var n = unsafe.Sizeof(T{})
+ InvalidDeclCycle
+
+ // InvalidTypeCycle occurs when a cycle in type definitions results in a
+ // type that is not well-defined.
+ //
+ // Example:
+ // import "unsafe"
+ //
+ // type T [unsafe.Sizeof(T{})]int
+ InvalidTypeCycle
+
+ /* decls > const */
+
+ // InvalidConstInit occurs when a const declaration has a non-constant
+ // initializer.
+ //
+ // Example:
+ // var x int
+ // const _ = x
+ InvalidConstInit
+
+ // InvalidConstVal occurs when a const value cannot be converted to its
+ // target type.
+ //
+ // TODO(findleyr): this error code and example are not very clear. Consider
+ // removing it.
+ //
+ // Example:
+ // const _ = 1 << "hello"
+ InvalidConstVal
+
+ // InvalidConstType occurs when the underlying type in a const declaration
+ // is not a valid constant type.
+ //
+ // Example:
+ // const c *int = 4
+ InvalidConstType
+
+ /* decls > var (+ other variable assignment codes) */
+
+ // UntypedNilUse occurs when the predeclared (untyped) value nil is used to
+ // initialize a variable declared without an explicit type.
+ //
+ // Example:
+ // var x = nil
+ UntypedNilUse
+
+ // WrongAssignCount occurs when the number of values on the right-hand side
+ // of an assignment or initialization expression does not match the number
+ // of variables on the left-hand side.
+ //
+ // Example:
+ // var x = 1, 2
+ WrongAssignCount
+
+ // UnassignableOperand occurs when the left-hand side of an assignment is
+ // not assignable.
+ //
+ // Example:
+ // func f() {
+ // const c = 1
+ // c = 2
+ // }
+ UnassignableOperand
+
+ // NoNewVar occurs when a short variable declaration (':=') does not declare
+ // new variables.
+ //
+ // Example:
+ // func f() {
+ // x := 1
+ // x := 2
+ // }
+ NoNewVar
+
+ // MultiValAssignOp occurs when an assignment operation (+=, *=, etc) does
+ // not have single-valued left-hand or right-hand side.
+ //
+ // Per the spec:
+ // "In assignment operations, both the left- and right-hand expression lists
+ // must contain exactly one single-valued expression"
+ //
+ // Example:
+ // func f() int {
+ // x, y := 1, 2
+ // x, y += 1
+ // return x + y
+ // }
+ MultiValAssignOp
+
+ // InvalidIfaceAssign occurs when a value of type T is used as an
+ // interface, but T does not implement a method of the expected interface.
+ //
+ // Example:
+ // type I interface {
+ // f()
+ // }
+ //
+ // type T int
+ //
+ // var x I = T(1)
+ InvalidIfaceAssign
+
+ // InvalidChanAssign occurs when a chan assignment is invalid.
+ //
+ // Per the spec, a value x is assignable to a channel type T if:
+ // "x is a bidirectional channel value, T is a channel type, x's type V and
+ // T have identical element types, and at least one of V or T is not a
+ // defined type."
+ //
+ // Example:
+ // type T1 chan int
+ // type T2 chan int
+ //
+ // var x T1
+ // // Invalid assignment because both types are named
+ // var _ T2 = x
+ InvalidChanAssign
+
+ // IncompatibleAssign occurs when the type of the right-hand side expression
+ // in an assignment cannot be assigned to the type of the variable being
+ // assigned.
+ //
+ // Example:
+ // var x []int
+ // var _ int = x
+ IncompatibleAssign
+
+ // UnaddressableFieldAssign occurs when trying to assign to a struct field
+ // in a map value.
+ //
+ // Example:
+ // func f() {
+ // m := make(map[string]struct{i int})
+ // m["foo"].i = 42
+ // }
+ UnaddressableFieldAssign
+
+ /* decls > type (+ other type expression codes) */
+
+ // NotAType occurs when the identifier used as the underlying type in a type
+ // declaration or the right-hand side of a type alias does not denote a type.
+ //
+ // Example:
+ // var S = 2
+ //
+ // type T S
+ NotAType
+
+ // InvalidArrayLen occurs when an array length is not a constant value.
+ //
+ // Example:
+ // var n = 3
+ // var _ = [n]int{}
+ InvalidArrayLen
+
+ // BlankIfaceMethod occurs when a method name is '_'.
+ //
+ // Per the spec:
+ // "The name of each explicitly specified method must be unique and not
+ // blank."
+ //
+ // Example:
+ // type T interface {
+ // _(int)
+ // }
+ BlankIfaceMethod
+
+ // IncomparableMapKey occurs when a map key type does not support the == and
+ // != operators.
+ //
+ // Per the spec:
+ // "The comparison operators == and != must be fully defined for operands of
+ // the key type; thus the key type must not be a function, map, or slice."
+ //
+ // Example:
+ // var x map[T]int
+ //
+ // type T []int
+ IncomparableMapKey
+
+ // InvalidIfaceEmbed occurs when a non-interface type is embedded in an
+ // interface.
+ //
+ // Example:
+ // type T struct {}
+ //
+ // func (T) m()
+ //
+ // type I interface {
+ // T
+ // }
+ InvalidIfaceEmbed
+
+ // InvalidPtrEmbed occurs when an embedded field is of the pointer form *T,
+ // and T itself is itself a pointer, an unsafe.Pointer, or an interface.
+ //
+ // Per the spec:
+ // "An embedded field must be specified as a type name T or as a pointer to
+ // a non-interface type name *T, and T itself may not be a pointer type."
+ //
+ // Example:
+ // type T *int
+ //
+ // type S struct {
+ // *T
+ // }
+ InvalidPtrEmbed
+
+ /* decls > func and method */
+
+ // BadRecv occurs when a method declaration does not have exactly one
+ // receiver parameter.
+ //
+ // Example:
+ // func () _() {}
+ BadRecv
+
+ // InvalidRecv occurs when a receiver type expression is not of the form T
+ // or *T, or T is a pointer type.
+ //
+ // Example:
+ // type T struct {}
+ //
+ // func (**T) m() {}
+ InvalidRecv
+
+ // DuplicateFieldAndMethod occurs when an identifier appears as both a field
+ // and method name.
+ //
+ // Example:
+ // type T struct {
+ // m int
+ // }
+ //
+ // func (T) m() {}
+ DuplicateFieldAndMethod
+
+ // DuplicateMethod occurs when two methods on the same receiver type have
+ // the same name.
+ //
+ // Example:
+ // type T struct {}
+ // func (T) m() {}
+ // func (T) m(i int) int { return i }
+ DuplicateMethod
+
+ /* decls > special */
+
+ // InvalidBlank occurs when a blank identifier is used as a value or type.
+ //
+ // Per the spec:
+ // "The blank identifier may appear as an operand only on the left-hand side
+ // of an assignment."
+ //
+ // Example:
+ // var x = _
+ InvalidBlank
+
+ // InvalidIota occurs when the predeclared identifier iota is used outside
+ // of a constant declaration.
+ //
+ // Example:
+ // var x = iota
+ InvalidIota
+
+ // MissingInitBody occurs when an init function is missing its body.
+ //
+ // Example:
+ // func init()
+ MissingInitBody
+
+ // InvalidInitSig occurs when an init function declares parameters or
+ // results.
+ //
+ // Example:
+ // func init() int { return 1 }
+ InvalidInitSig
+
+ // InvalidInitDecl occurs when init is declared as anything other than a
+ // function.
+ //
+ // Example:
+ // var init = 1
+ InvalidInitDecl
+
+ // InvalidMainDecl occurs when main is declared as anything other than a
+ // function, in a main package.
+ InvalidMainDecl
+
+ /* exprs */
+
+ // TooManyValues occurs when a function returns too many values for the
+ // expression context in which it is used.
+ //
+ // Example:
+ // func ReturnTwo() (int, int) {
+ // return 1, 2
+ // }
+ //
+ // var x = ReturnTwo()
+ TooManyValues
+
+ // NotAnExpr occurs when a type expression is used where a value expression
+ // is expected.
+ //
+ // Example:
+ // type T struct {}
+ //
+ // func f() {
+ // T
+ // }
+ NotAnExpr
+
+ /* exprs > const */
+
+ // TruncatedFloat occurs when a float constant is truncated to an integer
+ // value.
+ //
+ // Example:
+ // var _ int = 98.6
+ TruncatedFloat
+
+ // NumericOverflow occurs when a numeric constant overflows its target type.
+ //
+ // Example:
+ // var x int8 = 1000
+ NumericOverflow
+
+ /* exprs > operation */
+
+ // UndefinedOp occurs when an operator is not defined for the type(s) used
+ // in an operation.
+ //
+ // Example:
+ // var c = "a" - "b"
+ UndefinedOp
+
+ // MismatchedTypes occurs when operand types are incompatible in a binary
+ // operation.
+ //
+ // Example:
+ // var a = "hello"
+ // var b = 1
+ // var c = a - b
+ MismatchedTypes
+
+ // DivByZero occurs when a division operation is provable at compile
+ // time to be a division by zero.
+ //
+ // Example:
+ // const divisor = 0
+ // var x int = 1/divisor
+ DivByZero
+
+ // NonNumericIncDec occurs when an increment or decrement operator is
+ // applied to a non-numeric value.
+ //
+ // Example:
+ // func f() {
+ // var c = "c"
+ // c++
+ // }
+ NonNumericIncDec
+
+ /* exprs > ptr */
+
+ // UnaddressableOperand occurs when the & operator is applied to an
+ // unaddressable expression.
+ //
+ // Example:
+ // var x = &1
+ UnaddressableOperand
+
+ // InvalidIndirection occurs when a non-pointer value is indirected via the
+ // '*' operator.
+ //
+ // Example:
+ // var x int
+ // var y = *x
+ InvalidIndirection
+
+ /* exprs > [] */
+
+ // NonIndexableOperand occurs when an index operation is applied to a value
+ // that cannot be indexed.
+ //
+ // Example:
+ // var x = 1
+ // var y = x[1]
+ NonIndexableOperand
+
+ // InvalidIndex occurs when an index argument is not of integer type,
+ // negative, or out-of-bounds.
+ //
+ // Example:
+ // var s = [...]int{1,2,3}
+ // var x = s[5]
+ //
+ // Example:
+ // var s = []int{1,2,3}
+ // var _ = s[-1]
+ //
+ // Example:
+ // var s = []int{1,2,3}
+ // var i string
+ // var _ = s[i]
+ InvalidIndex
+
+ // SwappedSliceIndices occurs when constant indices in a slice expression
+ // are decreasing in value.
+ //
+ // Example:
+ // var _ = []int{1,2,3}[2:1]
+ SwappedSliceIndices
+
+ /* operators > slice */
+
+ // NonSliceableOperand occurs when a slice operation is applied to a value
+ // whose type is not sliceable, or is unaddressable.
+ //
+ // Example:
+ // var x = [...]int{1, 2, 3}[:1]
+ //
+ // Example:
+ // var x = 1
+ // var y = 1[:1]
+ NonSliceableOperand
+
+ // InvalidSliceExpr occurs when a three-index slice expression (a[x:y:z]) is
+ // applied to a string.
+ //
+ // Example:
+ // var s = "hello"
+ // var x = s[1:2:3]
+ InvalidSliceExpr
+
+ /* exprs > shift */
+
+ // InvalidShiftCount occurs when the right-hand side of a shift operation is
+ // either non-integer, negative, or too large.
+ //
+ // Example:
+ // var (
+ // x string
+ // y int = 1 << x
+ // )
+ InvalidShiftCount
+
+ // InvalidShiftOperand occurs when the shifted operand is not an integer.
+ //
+ // Example:
+ // var s = "hello"
+ // var x = s << 2
+ InvalidShiftOperand
+
+ /* exprs > chan */
+
+ // InvalidReceive occurs when there is a channel receive from a value that
+ // is either not a channel, or is a send-only channel.
+ //
+ // Example:
+ // func f() {
+ // var x = 1
+ // <-x
+ // }
+ InvalidReceive
+
+ // InvalidSend occurs when there is a channel send to a value that is not a
+ // channel, or is a receive-only channel.
+ //
+ // Example:
+ // func f() {
+ // var x = 1
+ // x <- "hello!"
+ // }
+ InvalidSend
+
+ /* exprs > literal */
+
+ // DuplicateLitKey occurs when an index is duplicated in a slice, array, or
+ // map literal.
+ //
+ // Example:
+ // var _ = []int{0:1, 0:2}
+ //
+ // Example:
+ // var _ = map[string]int{"a": 1, "a": 2}
+ DuplicateLitKey
+
+ // MissingLitKey occurs when a map literal is missing a key expression.
+ //
+ // Example:
+ // var _ = map[string]int{1}
+ MissingLitKey
+
+ // InvalidLitIndex occurs when the key in a key-value element of a slice or
+ // array literal is not an integer constant.
+ //
+ // Example:
+ // var i = 0
+ // var x = []string{i: "world"}
+ InvalidLitIndex
+
+ // OversizeArrayLit occurs when an array literal exceeds its length.
+ //
+ // Example:
+ // var _ = [2]int{1,2,3}
+ OversizeArrayLit
+
+ // MixedStructLit occurs when a struct literal contains a mix of positional
+ // and named elements.
+ //
+ // Example:
+ // var _ = struct{i, j int}{i: 1, 2}
+ MixedStructLit
+
+ // InvalidStructLit occurs when a positional struct literal has an incorrect
+ // number of values.
+ //
+ // Example:
+ // var _ = struct{i, j int}{1,2,3}
+ InvalidStructLit
+
+ // MissingLitField occurs when a struct literal refers to a field that does
+ // not exist on the struct type.
+ //
+ // Example:
+ // var _ = struct{i int}{j: 2}
+ MissingLitField
+
+ // DuplicateLitField occurs when a struct literal contains duplicated
+ // fields.
+ //
+ // Example:
+ // var _ = struct{i int}{i: 1, i: 2}
+ DuplicateLitField
+
+ // UnexportedLitField occurs when a positional struct literal implicitly
+ // assigns an unexported field of an imported type.
+ UnexportedLitField
+
+ // InvalidLitField occurs when a field name is not a valid identifier.
+ //
+ // Example:
+ // var _ = struct{i int}{1: 1}
+ InvalidLitField
+
+ // UntypedLit occurs when a composite literal omits a required type
+ // identifier.
+ //
+ // Example:
+ // type outer struct{
+ // inner struct { i int }
+ // }
+ //
+ // var _ = outer{inner: {1}}
+ UntypedLit
+
+ // InvalidLit occurs when a composite literal expression does not match its
+ // type.
+ //
+ // Example:
+ // type P *struct{
+ // x int
+ // }
+ // var _ = P {}
+ InvalidLit
+
+ /* exprs > selector */
+
+ // AmbiguousSelector occurs when a selector is ambiguous.
+ //
+ // Example:
+ // type E1 struct { i int }
+ // type E2 struct { i int }
+ // type T struct { E1; E2 }
+ //
+ // var x T
+ // var _ = x.i
+ AmbiguousSelector
+
+ // UndeclaredImportedName occurs when a package-qualified identifier is
+ // undeclared by the imported package.
+ //
+ // Example:
+ // import "go/types"
+ //
+ // var _ = types.NotAnActualIdentifier
+ UndeclaredImportedName
+
+ // UnexportedName occurs when a selector refers to an unexported identifier
+ // of an imported package.
+ //
+ // Example:
+ // import "reflect"
+ //
+ // type _ reflect.flag
+ UnexportedName
+
+ // UndeclaredName occurs when an identifier is not declared in the current
+ // scope.
+ //
+ // Example:
+ // var x T
+ UndeclaredName
+
+ // MissingFieldOrMethod occurs when a selector references a field or method
+ // that does not exist.
+ //
+ // Example:
+ // type T struct {}
+ //
+ // var x = T{}.f
+ MissingFieldOrMethod
+
+ /* exprs > ... */
+
+ // BadDotDotDotSyntax occurs when a "..." occurs in a context where it is
+ // not valid.
+ //
+ // Example:
+ // var _ = map[int][...]int{0: {}}
+ BadDotDotDotSyntax
+
+ // NonVariadicDotDotDot occurs when a "..." is used on the final argument to
+ // a non-variadic function.
+ //
+ // Example:
+ // func printArgs(s []string) {
+ // for _, a := range s {
+ // println(a)
+ // }
+ // }
+ //
+ // func f() {
+ // s := []string{"a", "b", "c"}
+ // printArgs(s...)
+ // }
+ NonVariadicDotDotDot
+
+ // MisplacedDotDotDot occurs when a "..." is used somewhere other than the
+ // final argument to a function call.
+ //
+ // Example:
+ // func printArgs(args ...int) {
+ // for _, a := range args {
+ // println(a)
+ // }
+ // }
+ //
+ // func f() {
+ // a := []int{1,2,3}
+ // printArgs(0, a...)
+ // }
+ MisplacedDotDotDot
+
+ // InvalidDotDotDotOperand occurs when a "..." operator is applied to a
+ // single-valued operand.
+ //
+ // Example:
+ // func printArgs(args ...int) {
+ // for _, a := range args {
+ // println(a)
+ // }
+ // }
+ //
+ // func f() {
+ // a := 1
+ // printArgs(a...)
+ // }
+ //
+ // Example:
+ // func args() (int, int) {
+ // return 1, 2
+ // }
+ //
+ // func printArgs(args ...int) {
+ // for _, a := range args {
+ // println(a)
+ // }
+ // }
+ //
+ // func g() {
+ // printArgs(args()...)
+ // }
+ InvalidDotDotDotOperand
+
+ // InvalidDotDotDot occurs when a "..." is used in a non-variadic built-in
+ // function.
+ //
+ // Example:
+ // var s = []int{1, 2, 3}
+ // var l = len(s...)
+ InvalidDotDotDot
+
+ /* exprs > built-in */
+
+ // UncalledBuiltin occurs when a built-in function is used as a
+ // function-valued expression, instead of being called.
+ //
+ // Per the spec:
+ // "The built-in functions do not have standard Go types, so they can only
+ // appear in call expressions; they cannot be used as function values."
+ //
+ // Example:
+ // var _ = copy
+ UncalledBuiltin
+
+ // InvalidAppend occurs when append is called with a first argument that is
+ // not a slice.
+ //
+ // Example:
+ // var _ = append(1, 2)
+ InvalidAppend
+
+ // InvalidCap occurs when an argument to the cap built-in function is not of
+ // supported type.
+ //
+ // See https://golang.org/ref/spec#Length_and_capacity for information on
+ // which underlying types are supported as arguments to cap and len.
+ //
+ // Example:
+ // var s = 2
+ // var x = cap(s)
+ InvalidCap
+
+ // InvalidClose occurs when close(...) is called with an argument that is
+ // not of channel type, or that is a receive-only channel.
+ //
+ // Example:
+ // func f() {
+ // var x int
+ // close(x)
+ // }
+ InvalidClose
+
+ // InvalidCopy occurs when the arguments are not of slice type or do not
+ // have compatible type.
+ //
+ // See https://golang.org/ref/spec#Appending_and_copying_slices for more
+ // information on the type requirements for the copy built-in.
+ //
+ // Example:
+ // func f() {
+ // var x []int
+ // y := []int64{1,2,3}
+ // copy(x, y)
+ // }
+ InvalidCopy
+
+ // InvalidComplex occurs when the complex built-in function is called with
+ // arguments with incompatible types.
+ //
+ // Example:
+ // var _ = complex(float32(1), float64(2))
+ InvalidComplex
+
+ // InvalidDelete occurs when the delete built-in function is called with a
+ // first argument that is not a map.
+ //
+ // Example:
+ // func f() {
+ // m := "hello"
+ // delete(m, "e")
+ // }
+ InvalidDelete
+
+ // InvalidImag occurs when the imag built-in function is called with an
+ // argument that does not have complex type.
+ //
+ // Example:
+ // var _ = imag(int(1))
+ InvalidImag
+
+ // InvalidLen occurs when an argument to the len built-in function is not of
+ // supported type.
+ //
+ // See https://golang.org/ref/spec#Length_and_capacity for information on
+ // which underlying types are supported as arguments to cap and len.
+ //
+ // Example:
+ // var s = 2
+ // var x = len(s)
+ InvalidLen
+
+ // SwappedMakeArgs occurs when make is called with three arguments, and its
+ // length argument is larger than its capacity argument.
+ //
+ // Example:
+ // var x = make([]int, 3, 2)
+ SwappedMakeArgs
+
+ // InvalidMake occurs when make is called with an unsupported type argument.
+ //
+ // See https://golang.org/ref/spec#Making_slices_maps_and_channels for
+ // information on the types that may be created using make.
+ //
+ // Example:
+ // var x = make(int)
+ InvalidMake
+
+ // InvalidReal occurs when the real built-in function is called with an
+ // argument that does not have complex type.
+ //
+ // Example:
+ // var _ = real(int(1))
+ InvalidReal
+
+ /* exprs > assertion */
+
+ // InvalidAssert occurs when a type assertion is applied to a
+ // value that is not of interface type.
+ //
+ // Example:
+ // var x = 1
+ // var _ = x.(float64)
+ InvalidAssert
+
+ // ImpossibleAssert occurs for a type assertion x.(T) when the value x of
+ // interface cannot have dynamic type T, due to a missing or mismatching
+ // method on T.
+ //
+ // Example:
+ // type T int
+ //
+ // func (t *T) m() int { return int(*t) }
+ //
+ // type I interface { m() int }
+ //
+ // var x I
+ // var _ = x.(T)
+ ImpossibleAssert
+
+ /* exprs > conversion */
+
+ // InvalidConversion occurs when the argument type cannot be converted to the
+ // target.
+ //
+ // See https://golang.org/ref/spec#Conversions for the rules of
+ // convertibility.
+ //
+ // Example:
+ // var x float64
+ // var _ = string(x)
+ InvalidConversion
+
+ // InvalidUntypedConversion occurs when there is no valid implicit
+ // conversion from an untyped value satisfying the type constraints of the
+ // context in which it is used.
+ //
+ // Example:
+ // var _ = 1 + ""
+ InvalidUntypedConversion
+
+ /* offsetof */
+
+ // BadOffsetofSyntax occurs when unsafe.Offsetof is called with an argument
+ // that is not a selector expression.
+ //
+ // Example:
+ // import "unsafe"
+ //
+ // var x int
+ // var _ = unsafe.Offsetof(x)
+ BadOffsetofSyntax
+
+ // InvalidOffsetof occurs when unsafe.Offsetof is called with a method
+ // selector, rather than a field selector, or when the field is embedded via
+ // a pointer.
+ //
+ // Per the spec:
+ //
+ // "If f is an embedded field, it must be reachable without pointer
+ // indirections through fields of the struct. "
+ //
+ // Example:
+ // import "unsafe"
+ //
+ // type T struct { f int }
+ // type S struct { *T }
+ // var s S
+ // var _ = unsafe.Offsetof(s.f)
+ //
+ // Example:
+ // import "unsafe"
+ //
+ // type S struct{}
+ //
+ // func (S) m() {}
+ //
+ // var s S
+ // var _ = unsafe.Offsetof(s.m)
+ InvalidOffsetof
+
+ /* control flow > scope */
+
+ // UnusedExpr occurs when a side-effect free expression is used as a
+ // statement. Such a statement has no effect.
+ //
+ // Example:
+ // func f(i int) {
+ // i*i
+ // }
+ UnusedExpr
+
+ // UnusedVar occurs when a variable is declared but unused.
+ //
+ // Example:
+ // func f() {
+ // x := 1
+ // }
+ UnusedVar
+
+ // MissingReturn occurs when a function with results is missing a return
+ // statement.
+ //
+ // Example:
+ // func f() int {}
+ MissingReturn
+
+ // WrongResultCount occurs when a return statement returns an incorrect
+ // number of values.
+ //
+ // Example:
+ // func ReturnOne() int {
+ // return 1, 2
+ // }
+ WrongResultCount
+
+ // OutOfScopeResult occurs when the name of a value implicitly returned by
+ // an empty return statement is shadowed in a nested scope.
+ //
+ // Example:
+ // func factor(n int) (i int) {
+ // for i := 2; i < n; i++ {
+ // if n%i == 0 {
+ // return
+ // }
+ // }
+ // return 0
+ // }
+ OutOfScopeResult
+
+ /* control flow > if */
+
+ // InvalidCond occurs when an if condition is not a boolean expression.
+ //
+ // Example:
+ // func checkReturn(i int) {
+ // if i {
+ // panic("non-zero return")
+ // }
+ // }
+ InvalidCond
+
+ /* control flow > for */
+
+ // InvalidPostDecl occurs when there is a declaration in a for-loop post
+ // statement.
+ //
+ // Example:
+ // func f() {
+ // for i := 0; i < 10; j := 0 {}
+ // }
+ InvalidPostDecl
+
+ // InvalidChanRange occurs when a send-only channel used in a range
+ // expression.
+ //
+ // Example:
+ // func sum(c chan<- int) {
+ // s := 0
+ // for i := range c {
+ // s += i
+ // }
+ // }
+ InvalidChanRange
+
+ // InvalidIterVar occurs when two iteration variables are used while ranging
+ // over a channel.
+ //
+ // Example:
+ // func f(c chan int) {
+ // for k, v := range c {
+ // println(k, v)
+ // }
+ // }
+ InvalidIterVar
+
+ // InvalidRangeExpr occurs when the type of a range expression is not array,
+ // slice, string, map, or channel.
+ //
+ // Example:
+ // func f(i int) {
+ // for j := range i {
+ // println(j)
+ // }
+ // }
+ InvalidRangeExpr
+
+ /* control flow > switch */
+
+ // MisplacedBreak occurs when a break statement is not within a for, switch,
+ // or select statement of the innermost function definition.
+ //
+ // Example:
+ // func f() {
+ // break
+ // }
+ MisplacedBreak
+
+ // MisplacedContinue occurs when a continue statement is not within a for
+ // loop of the innermost function definition.
+ //
+ // Example:
+ // func sumeven(n int) int {
+ // proceed := func() {
+ // continue
+ // }
+ // sum := 0
+ // for i := 1; i <= n; i++ {
+ // if i % 2 != 0 {
+ // proceed()
+ // }
+ // sum += i
+ // }
+ // return sum
+ // }
+ MisplacedContinue
+
+ // MisplacedFallthrough occurs when a fallthrough statement is not within an
+ // expression switch.
+ //
+ // Example:
+ // func typename(i interface{}) string {
+ // switch i.(type) {
+ // case int64:
+ // fallthrough
+ // case int:
+ // return "int"
+ // }
+ // return "unsupported"
+ // }
+ MisplacedFallthrough
+
+ // DuplicateCase occurs when a type or expression switch has duplicate
+ // cases.
+ //
+ // Example:
+ // func printInt(i int) {
+ // switch i {
+ // case 1:
+ // println("one")
+ // case 1:
+ // println("One")
+ // }
+ // }
+ DuplicateCase
+
+ // DuplicateDefault occurs when a type or expression switch has multiple
+ // default clauses.
+ //
+ // Example:
+ // func printInt(i int) {
+ // switch i {
+ // case 1:
+ // println("one")
+ // default:
+ // println("One")
+ // default:
+ // println("1")
+ // }
+ // }
+ DuplicateDefault
+
+ // BadTypeKeyword occurs when a .(type) expression is used anywhere other
+ // than a type switch.
+ //
+ // Example:
+ // type I interface {
+ // m()
+ // }
+ // var t I
+ // var _ = t.(type)
+ BadTypeKeyword
+
+ // InvalidTypeSwitch occurs when .(type) is used on an expression that is
+ // not of interface type.
+ //
+ // Example:
+ // func f(i int) {
+ // switch x := i.(type) {}
+ // }
+ InvalidTypeSwitch
+
+ // InvalidExprSwitch occurs when a switch expression is not comparable.
+ //
+ // Example:
+ // func _() {
+ // var a struct{ _ func() }
+ // switch a /* ERROR cannot switch on a */ {
+ // }
+ // }
+ InvalidExprSwitch
+
+ /* control flow > select */
+
+ // InvalidSelectCase occurs when a select case is not a channel send or
+ // receive.
+ //
+ // Example:
+ // func checkChan(c <-chan int) bool {
+ // select {
+ // case c:
+ // return true
+ // default:
+ // return false
+ // }
+ // }
+ InvalidSelectCase
+
+ /* control flow > labels and jumps */
+
+ // UndeclaredLabel occurs when an undeclared label is jumped to.
+ //
+ // Example:
+ // func f() {
+ // goto L
+ // }
+ UndeclaredLabel
+
+ // DuplicateLabel occurs when a label is declared more than once.
+ //
+ // Example:
+ // func f() int {
+ // L:
+ // L:
+ // return 1
+ // }
+ DuplicateLabel
+
+ // MisplacedLabel occurs when a break or continue label is not on a for,
+ // switch, or select statement.
+ //
+ // Example:
+ // func f() {
+ // L:
+ // a := []int{1,2,3}
+ // for _, e := range a {
+ // if e > 10 {
+ // break L
+ // }
+ // println(a)
+ // }
+ // }
+ MisplacedLabel
+
+ // UnusedLabel occurs when a label is declared but not used.
+ //
+ // Example:
+ // func f() {
+ // L:
+ // }
+ UnusedLabel
+
+ // JumpOverDecl occurs when a label jumps over a variable declaration.
+ //
+ // Example:
+ // func f() int {
+ // goto L
+ // x := 2
+ // L:
+ // x++
+ // return x
+ // }
+ JumpOverDecl
+
+ // JumpIntoBlock occurs when a forward jump goes to a label inside a nested
+ // block.
+ //
+ // Example:
+ // func f(x int) {
+ // goto L
+ // if x > 0 {
+ // L:
+ // print("inside block")
+ // }
+ // }
+ JumpIntoBlock
+
+ /* control flow > calls */
+
+ // InvalidMethodExpr occurs when a pointer method is called but the argument
+ // is not addressable.
+ //
+ // Example:
+ // type T struct {}
+ //
+ // func (*T) m() int { return 1 }
+ //
+ // var _ = T.m(T{})
+ InvalidMethodExpr
+
+ // WrongArgCount occurs when too few or too many arguments are passed by a
+ // function call.
+ //
+ // Example:
+ // func f(i int) {}
+ // var x = f()
+ WrongArgCount
+
+ // InvalidCall occurs when an expression is called that is not of function
+ // type.
+ //
+ // Example:
+ // var x = "x"
+ // var y = x()
+ InvalidCall
+
+ /* control flow > suspended */
+
+ // UnusedResults occurs when a restricted expression-only built-in function
+ // is suspended via go or defer. Such a suspension discards the results of
+ // these side-effect free built-in functions, and therefore is ineffectual.
+ //
+ // Example:
+ // func f(a []int) int {
+ // defer len(a)
+ // return i
+ // }
+ UnusedResults
+
+ // InvalidDefer occurs when a deferred expression is not a function call,
+ // for example if the expression is a type conversion.
+ //
+ // Example:
+ // func f(i int) int {
+ // defer int32(i)
+ // return i
+ // }
+ InvalidDefer
+
+ // InvalidGo occurs when a go expression is not a function call, for example
+ // if the expression is a type conversion.
+ //
+ // Example:
+ // func f(i int) int {
+ // go int32(i)
+ // return i
+ // }
+ InvalidGo
+
+ // All codes below were added in Go 1.17.
+
+ /* decl */
+
+ // BadDecl occurs when a declaration has invalid syntax.
+ BadDecl
+
+ // RepeatedDecl occurs when an identifier occurs more than once on the left
+ // hand side of a short variable declaration.
+ //
+ // Example:
+ // func _() {
+ // x, y, y := 1, 2, 3
+ // }
+ RepeatedDecl
+
+ /* unsafe */
+
+ // InvalidUnsafeAdd occurs when unsafe.Add is called with a
+ // length argument that is not of integer type.
+ //
+ // Example:
+ // import "unsafe"
+ //
+ // var p unsafe.Pointer
+ // var _ = unsafe.Add(p, float64(1))
+ InvalidUnsafeAdd
+
+ // InvalidUnsafeSlice occurs when unsafe.Slice is called with a
+ // pointer argument that is not of pointer type or a length argument
+ // that is not of integer type, negative, or out of bounds.
+ //
+ // Example:
+ // import "unsafe"
+ //
+ // var x int
+ // var _ = unsafe.Slice(x, 1)
+ //
+ // Example:
+ // import "unsafe"
+ //
+ // var x int
+ // var _ = unsafe.Slice(&x, float64(1))
+ //
+ // Example:
+ // import "unsafe"
+ //
+ // var x int
+ // var _ = unsafe.Slice(&x, -1)
+ //
+ // Example:
+ // import "unsafe"
+ //
+ // var x int
+ // var _ = unsafe.Slice(&x, uint64(1) << 63)
+ InvalidUnsafeSlice
+
+ // All codes below were added in Go 1.18.
+
+ /* features */
+
+ // UnsupportedFeature occurs when a language feature is used that is not
+ // supported at this Go version.
+ UnsupportedFeature
+
+ /* type params */
+
+ // NotAGenericType occurs when a non-generic type is used where a generic
+ // type is expected: in type or function instantiation.
+ //
+ // Example:
+ // type T int
+ //
+ // var _ T[int]
+ NotAGenericType
+
+ // WrongTypeArgCount occurs when a type or function is instantiated with an
+ // incorrect number of type arguments, including when a generic type or
+ // function is used without instantiation.
+ //
+ // Errors involving failed type inference are assigned other error codes.
+ //
+ // Example:
+ // type T[p any] int
+ //
+ // var _ T[int, string]
+ //
+ // Example:
+ // func f[T any]() {}
+ //
+ // var x = f
+ WrongTypeArgCount
+
+ // CannotInferTypeArgs occurs when type or function type argument inference
+ // fails to infer all type arguments.
+ //
+ // Example:
+ // func f[T any]() {}
+ //
+ // func _() {
+ // f()
+ // }
+ //
+ // Example:
+ // type N[P, Q any] struct{}
+ //
+ // var _ N[int]
+ CannotInferTypeArgs
+
+ // InvalidTypeArg occurs when a type argument does not satisfy its
+ // corresponding type parameter constraints.
+ //
+ // Example:
+ // type T[P ~int] struct{}
+ //
+ // var _ T[string]
+ InvalidTypeArg // arguments? InferenceFailed
+
+ // InvalidInstanceCycle occurs when an invalid cycle is detected
+ // within the instantiation graph.
+ //
+ // Example:
+ // func f[T any]() { f[*T]() }
+ InvalidInstanceCycle
+
+ // InvalidUnion occurs when an embedded union or approximation element is
+ // not valid.
+ //
+ // Example:
+ // type _ interface {
+ // ~int | interface{ m() }
+ // }
+ InvalidUnion
+
+ // MisplacedConstraintIface occurs when a constraint-type interface is used
+ // outside of constraint position.
+ //
+ // Example:
+ // type I interface { ~int }
+ //
+ // var _ I
+ MisplacedConstraintIface
+
+ // InvalidMethodTypeParams occurs when methods have type parameters.
+ //
+ // It cannot be encountered with an AST parsed using go/parser.
+ InvalidMethodTypeParams
+
+ // MisplacedTypeParam occurs when a type parameter is used in a place where
+ // it is not permitted.
+ //
+ // Example:
+ // type T[P any] P
+ //
+ // Example:
+ // type T[P any] struct{ *P }
+ MisplacedTypeParam
+
+ // InvalidUnsafeSliceData occurs when unsafe.SliceData is called with
+ // an argument that is not of slice type. It also occurs if it is used
+ // in a package compiled for a language version before go1.20.
+ //
+ // Example:
+ // import "unsafe"
+ //
+ // var x int
+ // var _ = unsafe.SliceData(x)
+ InvalidUnsafeSliceData
+
+ // InvalidUnsafeString occurs when unsafe.String is called with
+ // a length argument that is not of integer type, negative, or
+ // out of bounds. It also occurs if it is used in a package
+ // compiled for a language version before go1.20.
+ //
+ // Example:
+ // import "unsafe"
+ //
+ // var b [10]byte
+ // var _ = unsafe.String(&b[0], -1)
+ InvalidUnsafeString
+
+ // InvalidUnsafeStringData occurs if it is used in a package
+ // compiled for a language version before go1.20.
+ _ // not used anymore
+
+)
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/errorcode_string.go b/vendor/golang.org/x/tools/internal/typesinternal/errorcode_string.go
new file mode 100644
index 00000000..15ecf7c5
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/errorcode_string.go
@@ -0,0 +1,179 @@
+// Code generated by "stringer -type=ErrorCode"; DO NOT EDIT.
+
+package typesinternal
+
+import "strconv"
+
+func _() {
+ // An "invalid array index" compiler error signifies that the constant values have changed.
+ // Re-run the stringer command to generate them again.
+ var x [1]struct{}
+ _ = x[InvalidSyntaxTree - -1]
+ _ = x[Test-1]
+ _ = x[BlankPkgName-2]
+ _ = x[MismatchedPkgName-3]
+ _ = x[InvalidPkgUse-4]
+ _ = x[BadImportPath-5]
+ _ = x[BrokenImport-6]
+ _ = x[ImportCRenamed-7]
+ _ = x[UnusedImport-8]
+ _ = x[InvalidInitCycle-9]
+ _ = x[DuplicateDecl-10]
+ _ = x[InvalidDeclCycle-11]
+ _ = x[InvalidTypeCycle-12]
+ _ = x[InvalidConstInit-13]
+ _ = x[InvalidConstVal-14]
+ _ = x[InvalidConstType-15]
+ _ = x[UntypedNilUse-16]
+ _ = x[WrongAssignCount-17]
+ _ = x[UnassignableOperand-18]
+ _ = x[NoNewVar-19]
+ _ = x[MultiValAssignOp-20]
+ _ = x[InvalidIfaceAssign-21]
+ _ = x[InvalidChanAssign-22]
+ _ = x[IncompatibleAssign-23]
+ _ = x[UnaddressableFieldAssign-24]
+ _ = x[NotAType-25]
+ _ = x[InvalidArrayLen-26]
+ _ = x[BlankIfaceMethod-27]
+ _ = x[IncomparableMapKey-28]
+ _ = x[InvalidIfaceEmbed-29]
+ _ = x[InvalidPtrEmbed-30]
+ _ = x[BadRecv-31]
+ _ = x[InvalidRecv-32]
+ _ = x[DuplicateFieldAndMethod-33]
+ _ = x[DuplicateMethod-34]
+ _ = x[InvalidBlank-35]
+ _ = x[InvalidIota-36]
+ _ = x[MissingInitBody-37]
+ _ = x[InvalidInitSig-38]
+ _ = x[InvalidInitDecl-39]
+ _ = x[InvalidMainDecl-40]
+ _ = x[TooManyValues-41]
+ _ = x[NotAnExpr-42]
+ _ = x[TruncatedFloat-43]
+ _ = x[NumericOverflow-44]
+ _ = x[UndefinedOp-45]
+ _ = x[MismatchedTypes-46]
+ _ = x[DivByZero-47]
+ _ = x[NonNumericIncDec-48]
+ _ = x[UnaddressableOperand-49]
+ _ = x[InvalidIndirection-50]
+ _ = x[NonIndexableOperand-51]
+ _ = x[InvalidIndex-52]
+ _ = x[SwappedSliceIndices-53]
+ _ = x[NonSliceableOperand-54]
+ _ = x[InvalidSliceExpr-55]
+ _ = x[InvalidShiftCount-56]
+ _ = x[InvalidShiftOperand-57]
+ _ = x[InvalidReceive-58]
+ _ = x[InvalidSend-59]
+ _ = x[DuplicateLitKey-60]
+ _ = x[MissingLitKey-61]
+ _ = x[InvalidLitIndex-62]
+ _ = x[OversizeArrayLit-63]
+ _ = x[MixedStructLit-64]
+ _ = x[InvalidStructLit-65]
+ _ = x[MissingLitField-66]
+ _ = x[DuplicateLitField-67]
+ _ = x[UnexportedLitField-68]
+ _ = x[InvalidLitField-69]
+ _ = x[UntypedLit-70]
+ _ = x[InvalidLit-71]
+ _ = x[AmbiguousSelector-72]
+ _ = x[UndeclaredImportedName-73]
+ _ = x[UnexportedName-74]
+ _ = x[UndeclaredName-75]
+ _ = x[MissingFieldOrMethod-76]
+ _ = x[BadDotDotDotSyntax-77]
+ _ = x[NonVariadicDotDotDot-78]
+ _ = x[MisplacedDotDotDot-79]
+ _ = x[InvalidDotDotDotOperand-80]
+ _ = x[InvalidDotDotDot-81]
+ _ = x[UncalledBuiltin-82]
+ _ = x[InvalidAppend-83]
+ _ = x[InvalidCap-84]
+ _ = x[InvalidClose-85]
+ _ = x[InvalidCopy-86]
+ _ = x[InvalidComplex-87]
+ _ = x[InvalidDelete-88]
+ _ = x[InvalidImag-89]
+ _ = x[InvalidLen-90]
+ _ = x[SwappedMakeArgs-91]
+ _ = x[InvalidMake-92]
+ _ = x[InvalidReal-93]
+ _ = x[InvalidAssert-94]
+ _ = x[ImpossibleAssert-95]
+ _ = x[InvalidConversion-96]
+ _ = x[InvalidUntypedConversion-97]
+ _ = x[BadOffsetofSyntax-98]
+ _ = x[InvalidOffsetof-99]
+ _ = x[UnusedExpr-100]
+ _ = x[UnusedVar-101]
+ _ = x[MissingReturn-102]
+ _ = x[WrongResultCount-103]
+ _ = x[OutOfScopeResult-104]
+ _ = x[InvalidCond-105]
+ _ = x[InvalidPostDecl-106]
+ _ = x[InvalidChanRange-107]
+ _ = x[InvalidIterVar-108]
+ _ = x[InvalidRangeExpr-109]
+ _ = x[MisplacedBreak-110]
+ _ = x[MisplacedContinue-111]
+ _ = x[MisplacedFallthrough-112]
+ _ = x[DuplicateCase-113]
+ _ = x[DuplicateDefault-114]
+ _ = x[BadTypeKeyword-115]
+ _ = x[InvalidTypeSwitch-116]
+ _ = x[InvalidExprSwitch-117]
+ _ = x[InvalidSelectCase-118]
+ _ = x[UndeclaredLabel-119]
+ _ = x[DuplicateLabel-120]
+ _ = x[MisplacedLabel-121]
+ _ = x[UnusedLabel-122]
+ _ = x[JumpOverDecl-123]
+ _ = x[JumpIntoBlock-124]
+ _ = x[InvalidMethodExpr-125]
+ _ = x[WrongArgCount-126]
+ _ = x[InvalidCall-127]
+ _ = x[UnusedResults-128]
+ _ = x[InvalidDefer-129]
+ _ = x[InvalidGo-130]
+ _ = x[BadDecl-131]
+ _ = x[RepeatedDecl-132]
+ _ = x[InvalidUnsafeAdd-133]
+ _ = x[InvalidUnsafeSlice-134]
+ _ = x[UnsupportedFeature-135]
+ _ = x[NotAGenericType-136]
+ _ = x[WrongTypeArgCount-137]
+ _ = x[CannotInferTypeArgs-138]
+ _ = x[InvalidTypeArg-139]
+ _ = x[InvalidInstanceCycle-140]
+ _ = x[InvalidUnion-141]
+ _ = x[MisplacedConstraintIface-142]
+ _ = x[InvalidMethodTypeParams-143]
+ _ = x[MisplacedTypeParam-144]
+ _ = x[InvalidUnsafeSliceData-145]
+ _ = x[InvalidUnsafeString-146]
+}
+
+const (
+ _ErrorCode_name_0 = "InvalidSyntaxTree"
+ _ErrorCode_name_1 = "TestBlankPkgNameMismatchedPkgNameInvalidPkgUseBadImportPathBrokenImportImportCRenamedUnusedImportInvalidInitCycleDuplicateDeclInvalidDeclCycleInvalidTypeCycleInvalidConstInitInvalidConstValInvalidConstTypeUntypedNilUseWrongAssignCountUnassignableOperandNoNewVarMultiValAssignOpInvalidIfaceAssignInvalidChanAssignIncompatibleAssignUnaddressableFieldAssignNotATypeInvalidArrayLenBlankIfaceMethodIncomparableMapKeyInvalidIfaceEmbedInvalidPtrEmbedBadRecvInvalidRecvDuplicateFieldAndMethodDuplicateMethodInvalidBlankInvalidIotaMissingInitBodyInvalidInitSigInvalidInitDeclInvalidMainDeclTooManyValuesNotAnExprTruncatedFloatNumericOverflowUndefinedOpMismatchedTypesDivByZeroNonNumericIncDecUnaddressableOperandInvalidIndirectionNonIndexableOperandInvalidIndexSwappedSliceIndicesNonSliceableOperandInvalidSliceExprInvalidShiftCountInvalidShiftOperandInvalidReceiveInvalidSendDuplicateLitKeyMissingLitKeyInvalidLitIndexOversizeArrayLitMixedStructLitInvalidStructLitMissingLitFieldDuplicateLitFieldUnexportedLitFieldInvalidLitFieldUntypedLitInvalidLitAmbiguousSelectorUndeclaredImportedNameUnexportedNameUndeclaredNameMissingFieldOrMethodBadDotDotDotSyntaxNonVariadicDotDotDotMisplacedDotDotDotInvalidDotDotDotOperandInvalidDotDotDotUncalledBuiltinInvalidAppendInvalidCapInvalidCloseInvalidCopyInvalidComplexInvalidDeleteInvalidImagInvalidLenSwappedMakeArgsInvalidMakeInvalidRealInvalidAssertImpossibleAssertInvalidConversionInvalidUntypedConversionBadOffsetofSyntaxInvalidOffsetofUnusedExprUnusedVarMissingReturnWrongResultCountOutOfScopeResultInvalidCondInvalidPostDeclInvalidChanRangeInvalidIterVarInvalidRangeExprMisplacedBreakMisplacedContinueMisplacedFallthroughDuplicateCaseDuplicateDefaultBadTypeKeywordInvalidTypeSwitchInvalidExprSwitchInvalidSelectCaseUndeclaredLabelDuplicateLabelMisplacedLabelUnusedLabelJumpOverDeclJumpIntoBlockInvalidMethodExprWrongArgCountInvalidCallUnusedResultsInvalidDeferInvalidGoBadDeclRepeatedDeclInvalidUnsafeAddInvalidUnsafeSliceUnsupportedFeatureNotAGenericTypeWrongTypeArgCountCannotInferTypeArgsInvalidTypeArgInvalidInstanceCycleInvalidUnionMisplacedConstraintIfaceInvalidMethodTypeParamsMisplacedTypeParamInvalidUnsafeSliceDataInvalidUnsafeString"
+)
+
+var (
+ _ErrorCode_index_1 = [...]uint16{0, 4, 16, 33, 46, 59, 71, 85, 97, 113, 126, 142, 158, 174, 189, 205, 218, 234, 253, 261, 277, 295, 312, 330, 354, 362, 377, 393, 411, 428, 443, 450, 461, 484, 499, 511, 522, 537, 551, 566, 581, 594, 603, 617, 632, 643, 658, 667, 683, 703, 721, 740, 752, 771, 790, 806, 823, 842, 856, 867, 882, 895, 910, 926, 940, 956, 971, 988, 1006, 1021, 1031, 1041, 1058, 1080, 1094, 1108, 1128, 1146, 1166, 1184, 1207, 1223, 1238, 1251, 1261, 1273, 1284, 1298, 1311, 1322, 1332, 1347, 1358, 1369, 1382, 1398, 1415, 1439, 1456, 1471, 1481, 1490, 1503, 1519, 1535, 1546, 1561, 1577, 1591, 1607, 1621, 1638, 1658, 1671, 1687, 1701, 1718, 1735, 1752, 1767, 1781, 1795, 1806, 1818, 1831, 1848, 1861, 1872, 1885, 1897, 1906, 1913, 1925, 1941, 1959, 1977, 1992, 2009, 2028, 2042, 2062, 2074, 2098, 2121, 2139, 2161, 2180}
+)
+
+func (i ErrorCode) String() string {
+ switch {
+ case i == -1:
+ return _ErrorCode_name_0
+ case 1 <= i && i <= 146:
+ i -= 1
+ return _ErrorCode_name_1[_ErrorCode_index_1[i]:_ErrorCode_index_1[i+1]]
+ default:
+ return "ErrorCode(" + strconv.FormatInt(int64(i), 10) + ")"
+ }
+}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/qualifier.go b/vendor/golang.org/x/tools/internal/typesinternal/qualifier.go
new file mode 100644
index 00000000..b64f714e
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/qualifier.go
@@ -0,0 +1,46 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typesinternal
+
+import (
+ "go/ast"
+ "go/types"
+ "strconv"
+)
+
+// FileQualifier returns a [types.Qualifier] function that qualifies
+// imported symbols appropriately based on the import environment of a given
+// file.
+// If the same package is imported multiple times, the last appearance is
+// recorded.
+func FileQualifier(f *ast.File, pkg *types.Package) types.Qualifier {
+ // Construct mapping of import paths to their defined names.
+ // It is only necessary to look at renaming imports.
+ imports := make(map[string]string)
+ for _, imp := range f.Imports {
+ if imp.Name != nil && imp.Name.Name != "_" {
+ path, _ := strconv.Unquote(imp.Path.Value)
+ imports[path] = imp.Name.Name
+ }
+ }
+
+ // Define qualifier to replace full package paths with names of the imports.
+ return func(p *types.Package) string {
+ if p == nil || p == pkg {
+ return ""
+ }
+
+ if name, ok := imports[p.Path()]; ok {
+ if name == "." {
+ return ""
+ } else {
+ return name
+ }
+ }
+
+ // If there is no local renaming, fall back to the package name.
+ return p.Name()
+ }
+}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/recv.go b/vendor/golang.org/x/tools/internal/typesinternal/recv.go
new file mode 100644
index 00000000..8352ea76
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/recv.go
@@ -0,0 +1,44 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typesinternal
+
+import (
+ "go/types"
+)
+
+// ReceiverNamed returns the named type (if any) associated with the
+// type of recv, which may be of the form N or *N, or aliases thereof.
+// It also reports whether a Pointer was present.
+//
+// The named result may be nil if recv is from a method on an
+// anonymous interface or struct types or in ill-typed code.
+func ReceiverNamed(recv *types.Var) (isPtr bool, named *types.Named) {
+ t := recv.Type()
+ if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
+ isPtr = true
+ t = ptr.Elem()
+ }
+ named, _ = types.Unalias(t).(*types.Named)
+ return
+}
+
+// Unpointer returns T given *T or an alias thereof.
+// For all other types it is the identity function.
+// It does not look at underlying types.
+// The result may be an alias.
+//
+// Use this function to strip off the optional pointer on a receiver
+// in a field or method selection, without losing the named type
+// (which is needed to compute the method set).
+//
+// See also [typeparams.MustDeref], which removes one level of
+// indirection from the type, regardless of named types (analogous to
+// a LOAD instruction).
+func Unpointer(t types.Type) types.Type {
+ if ptr, ok := types.Unalias(t).(*types.Pointer); ok {
+ return ptr.Elem()
+ }
+ return t
+}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/toonew.go b/vendor/golang.org/x/tools/internal/typesinternal/toonew.go
new file mode 100644
index 00000000..cc86487e
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/toonew.go
@@ -0,0 +1,89 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typesinternal
+
+import (
+ "go/types"
+
+ "golang.org/x/tools/internal/stdlib"
+ "golang.org/x/tools/internal/versions"
+)
+
+// TooNewStdSymbols computes the set of package-level symbols
+// exported by pkg that are not available at the specified version.
+// The result maps each symbol to its minimum version.
+//
+// The pkg is allowed to contain type errors.
+func TooNewStdSymbols(pkg *types.Package, version string) map[types.Object]string {
+ disallowed := make(map[types.Object]string)
+
+ // Pass 1: package-level symbols.
+ symbols := stdlib.PackageSymbols[pkg.Path()]
+ for _, sym := range symbols {
+ symver := sym.Version.String()
+ if versions.Before(version, symver) {
+ switch sym.Kind {
+ case stdlib.Func, stdlib.Var, stdlib.Const, stdlib.Type:
+ disallowed[pkg.Scope().Lookup(sym.Name)] = symver
+ }
+ }
+ }
+
+ // Pass 2: fields and methods.
+ //
+ // We allow fields and methods if their associated type is
+ // disallowed, as otherwise we would report false positives
+ // for compatibility shims. Consider:
+ //
+ // //go:build go1.22
+ // type T struct { F std.Real } // correct new API
+ //
+ // //go:build !go1.22
+ // type T struct { F fake } // shim
+ // type fake struct { ... }
+ // func (fake) M () {}
+ //
+ // These alternative declarations of T use either the std.Real
+ // type, introduced in go1.22, or a fake type, for the field
+ // F. (The fakery could be arbitrarily deep, involving more
+ // nested fields and methods than are shown here.) Clients
+ // that use the compatibility shim T will compile with any
+ // version of go, whether older or newer than go1.22, but only
+ // the newer version will use the std.Real implementation.
+ //
+ // Now consider a reference to method M in new(T).F.M() in a
+ // module that requires a minimum of go1.21. The analysis may
+ // occur using a version of Go higher than 1.21, selecting the
+ // first version of T, so the method M is Real.M. This would
+ // spuriously cause the analyzer to report a reference to a
+ // too-new symbol even though this expression compiles just
+ // fine (with the fake implementation) using go1.21.
+ for _, sym := range symbols {
+ symVersion := sym.Version.String()
+ if !versions.Before(version, symVersion) {
+ continue // allowed
+ }
+
+ var obj types.Object
+ switch sym.Kind {
+ case stdlib.Field:
+ typename, name := sym.SplitField()
+ if t := pkg.Scope().Lookup(typename); t != nil && disallowed[t] == "" {
+ obj, _, _ = types.LookupFieldOrMethod(t.Type(), false, pkg, name)
+ }
+
+ case stdlib.Method:
+ ptr, recvname, name := sym.SplitMethod()
+ if t := pkg.Scope().Lookup(recvname); t != nil && disallowed[t] == "" {
+ obj, _, _ = types.LookupFieldOrMethod(t.Type(), ptr, pkg, name)
+ }
+ }
+ if obj != nil {
+ disallowed[obj] = symVersion
+ }
+ }
+
+ return disallowed
+}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/types.go b/vendor/golang.org/x/tools/internal/typesinternal/types.go
new file mode 100644
index 00000000..a5cd7e8d
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/types.go
@@ -0,0 +1,155 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package typesinternal provides access to internal go/types APIs that are not
+// yet exported.
+package typesinternal
+
+import (
+ "go/ast"
+ "go/token"
+ "go/types"
+ "reflect"
+ "unsafe"
+
+ "golang.org/x/tools/internal/aliases"
+)
+
+func SetUsesCgo(conf *types.Config) bool {
+ v := reflect.ValueOf(conf).Elem()
+
+ f := v.FieldByName("go115UsesCgo")
+ if !f.IsValid() {
+ f = v.FieldByName("UsesCgo")
+ if !f.IsValid() {
+ return false
+ }
+ }
+
+ addr := unsafe.Pointer(f.UnsafeAddr())
+ *(*bool)(addr) = true
+
+ return true
+}
+
+// ErrorCodeStartEnd extracts additional information from types.Error values
+// generated by Go version 1.16 and later: the error code, start position, and
+// end position. If all positions are valid, start <= err.Pos <= end.
+//
+// If the data could not be read, the final result parameter will be false.
+//
+// TODO(adonovan): eliminate start/end when proposal #71803 is accepted.
+func ErrorCodeStartEnd(err types.Error) (code ErrorCode, start, end token.Pos, ok bool) {
+ var data [3]int
+ // By coincidence all of these fields are ints, which simplifies things.
+ v := reflect.ValueOf(err)
+ for i, name := range []string{"go116code", "go116start", "go116end"} {
+ f := v.FieldByName(name)
+ if !f.IsValid() {
+ return 0, 0, 0, false
+ }
+ data[i] = int(f.Int())
+ }
+ return ErrorCode(data[0]), token.Pos(data[1]), token.Pos(data[2]), true
+}
+
+// NameRelativeTo returns a types.Qualifier that qualifies members of
+// all packages other than pkg, using only the package name.
+// (By contrast, [types.RelativeTo] uses the complete package path,
+// which is often excessive.)
+//
+// If pkg is nil, it is equivalent to [*types.Package.Name].
+func NameRelativeTo(pkg *types.Package) types.Qualifier {
+ return func(other *types.Package) string {
+ if pkg != nil && pkg == other {
+ return "" // same package; unqualified
+ }
+ return other.Name()
+ }
+}
+
+// TypeNameFor returns the type name symbol for the specified type, if
+// it is a [*types.Alias], [*types.Named], [*types.TypeParam], or a
+// [*types.Basic] representing a type.
+//
+// For all other types, and for Basic types representing a builtin,
+// constant, or nil, it returns nil. Be careful not to convert the
+// resulting nil pointer to a [types.Object]!
+//
+// If t is the type of a constant, it may be an "untyped" type, which
+// has no TypeName. To access the name of such types (e.g. "untyped
+// int"), use [types.Basic.Name].
+func TypeNameFor(t types.Type) *types.TypeName {
+ switch t := t.(type) {
+ case *types.Alias:
+ return t.Obj()
+ case *types.Named:
+ return t.Obj()
+ case *types.TypeParam:
+ return t.Obj()
+ case *types.Basic:
+ // See issues #71886 and #66890 for some history.
+ if tname, ok := types.Universe.Lookup(t.Name()).(*types.TypeName); ok {
+ return tname
+ }
+ }
+ return nil
+}
+
+// A NamedOrAlias is a [types.Type] that is named (as
+// defined by the spec) and capable of bearing type parameters: it
+// abstracts aliases ([types.Alias]) and defined types
+// ([types.Named]).
+//
+// Every type declared by an explicit "type" declaration is a
+// NamedOrAlias. (Built-in type symbols may additionally
+// have type [types.Basic], which is not a NamedOrAlias,
+// though the spec regards them as "named"; see [TypeNameFor].)
+//
+// NamedOrAlias cannot expose the Origin method, because
+// [types.Alias.Origin] and [types.Named.Origin] have different
+// (covariant) result types; use [Origin] instead.
+type NamedOrAlias interface {
+ types.Type
+ Obj() *types.TypeName
+ TypeArgs() *types.TypeList
+ TypeParams() *types.TypeParamList
+ SetTypeParams(tparams []*types.TypeParam)
+}
+
+var (
+ _ NamedOrAlias = (*types.Alias)(nil)
+ _ NamedOrAlias = (*types.Named)(nil)
+)
+
+// Origin returns the generic type of the Named or Alias type t if it
+// is instantiated, otherwise it returns t.
+func Origin(t NamedOrAlias) NamedOrAlias {
+ switch t := t.(type) {
+ case *types.Alias:
+ return aliases.Origin(t)
+ case *types.Named:
+ return t.Origin()
+ }
+ return t
+}
+
+// IsPackageLevel reports whether obj is a package-level symbol.
+func IsPackageLevel(obj types.Object) bool {
+ return obj.Pkg() != nil && obj.Parent() == obj.Pkg().Scope()
+}
+
+// NewTypesInfo returns a *types.Info with all maps populated.
+func NewTypesInfo() *types.Info {
+ return &types.Info{
+ Types: map[ast.Expr]types.TypeAndValue{},
+ Instances: map[*ast.Ident]types.Instance{},
+ Defs: map[*ast.Ident]types.Object{},
+ Uses: map[*ast.Ident]types.Object{},
+ Implicits: map[ast.Node]types.Object{},
+ Selections: map[*ast.SelectorExpr]*types.Selection{},
+ Scopes: map[ast.Node]*types.Scope{},
+ FileVersions: map[*ast.File]string{},
+ }
+}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/varkind.go b/vendor/golang.org/x/tools/internal/typesinternal/varkind.go
new file mode 100644
index 00000000..e5da0495
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/varkind.go
@@ -0,0 +1,40 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typesinternal
+
+// TODO(adonovan): when CL 645115 lands, define the go1.25 version of
+// this API that actually does something.
+
+import "go/types"
+
+type VarKind uint8
+
+const (
+ _ VarKind = iota // (not meaningful)
+ PackageVar // a package-level variable
+ LocalVar // a local variable
+ RecvVar // a method receiver variable
+ ParamVar // a function parameter variable
+ ResultVar // a function result variable
+ FieldVar // a struct field
+)
+
+func (kind VarKind) String() string {
+ return [...]string{
+ 0: "VarKind(0)",
+ PackageVar: "PackageVar",
+ LocalVar: "LocalVar",
+ RecvVar: "RecvVar",
+ ParamVar: "ParamVar",
+ ResultVar: "ResultVar",
+ FieldVar: "FieldVar",
+ }[kind]
+}
+
+// GetVarKind returns an invalid VarKind.
+func GetVarKind(v *types.Var) VarKind { return 0 }
+
+// SetVarKind has no effect.
+func SetVarKind(v *types.Var, kind VarKind) {}
diff --git a/vendor/golang.org/x/tools/internal/typesinternal/zerovalue.go b/vendor/golang.org/x/tools/internal/typesinternal/zerovalue.go
new file mode 100644
index 00000000..d272949c
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/typesinternal/zerovalue.go
@@ -0,0 +1,392 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package typesinternal
+
+import (
+ "fmt"
+ "go/ast"
+ "go/token"
+ "go/types"
+ "strings"
+)
+
+// ZeroString returns the string representation of the zero value for any type t.
+// The boolean result indicates whether the type is or contains an invalid type
+// or a non-basic (constraint) interface type.
+//
+// Even for invalid input types, ZeroString may return a partially correct
+// string representation. The caller should use the returned isValid boolean
+// to determine the validity of the expression.
+//
+// When assigning to a wider type (such as 'any'), it's the caller's
+// responsibility to handle any necessary type conversions.
+//
+// This string can be used on the right-hand side of an assignment where the
+// left-hand side has that explicit type.
+// References to named types are qualified by an appropriate (optional)
+// qualifier function.
+// Exception: This does not apply to tuples. Their string representation is
+// informational only and cannot be used in an assignment.
+//
+// See [ZeroExpr] for a variant that returns an [ast.Expr].
+func ZeroString(t types.Type, qual types.Qualifier) (_ string, isValid bool) {
+ switch t := t.(type) {
+ case *types.Basic:
+ switch {
+ case t.Info()&types.IsBoolean != 0:
+ return "false", true
+ case t.Info()&types.IsNumeric != 0:
+ return "0", true
+ case t.Info()&types.IsString != 0:
+ return `""`, true
+ case t.Kind() == types.UnsafePointer:
+ fallthrough
+ case t.Kind() == types.UntypedNil:
+ return "nil", true
+ case t.Kind() == types.Invalid:
+ return "invalid", false
+ default:
+ panic(fmt.Sprintf("ZeroString for unexpected type %v", t))
+ }
+
+ case *types.Pointer, *types.Slice, *types.Chan, *types.Map, *types.Signature:
+ return "nil", true
+
+ case *types.Interface:
+ if !t.IsMethodSet() {
+ return "invalid", false
+ }
+ return "nil", true
+
+ case *types.Named:
+ switch under := t.Underlying().(type) {
+ case *types.Struct, *types.Array:
+ return types.TypeString(t, qual) + "{}", true
+ default:
+ return ZeroString(under, qual)
+ }
+
+ case *types.Alias:
+ switch t.Underlying().(type) {
+ case *types.Struct, *types.Array:
+ return types.TypeString(t, qual) + "{}", true
+ default:
+ // A type parameter can have alias but alias type's underlying type
+ // can never be a type parameter.
+ // Use types.Unalias to preserve the info of type parameter instead
+ // of call Underlying() going right through and get the underlying
+ // type of the type parameter which is always an interface.
+ return ZeroString(types.Unalias(t), qual)
+ }
+
+ case *types.Array, *types.Struct:
+ return types.TypeString(t, qual) + "{}", true
+
+ case *types.TypeParam:
+ // Assumes func new is not shadowed.
+ return "*new(" + types.TypeString(t, qual) + ")", true
+
+ case *types.Tuple:
+ // Tuples are not normal values.
+ // We are currently format as "(t[0], ..., t[n])". Could be something else.
+ isValid := true
+ components := make([]string, t.Len())
+ for i := 0; i < t.Len(); i++ {
+ comp, ok := ZeroString(t.At(i).Type(), qual)
+
+ components[i] = comp
+ isValid = isValid && ok
+ }
+ return "(" + strings.Join(components, ", ") + ")", isValid
+
+ case *types.Union:
+ // Variables of these types cannot be created, so it makes
+ // no sense to ask for their zero value.
+ panic(fmt.Sprintf("invalid type for a variable: %v", t))
+
+ default:
+ panic(t) // unreachable.
+ }
+}
+
+// ZeroExpr returns the ast.Expr representation of the zero value for any type t.
+// The boolean result indicates whether the type is or contains an invalid type
+// or a non-basic (constraint) interface type.
+//
+// Even for invalid input types, ZeroExpr may return a partially correct ast.Expr
+// representation. The caller should use the returned isValid boolean to determine
+// the validity of the expression.
+//
+// This function is designed for types suitable for variables and should not be
+// used with Tuple or Union types.References to named types are qualified by an
+// appropriate (optional) qualifier function.
+//
+// See [ZeroString] for a variant that returns a string.
+func ZeroExpr(t types.Type, qual types.Qualifier) (_ ast.Expr, isValid bool) {
+ switch t := t.(type) {
+ case *types.Basic:
+ switch {
+ case t.Info()&types.IsBoolean != 0:
+ return &ast.Ident{Name: "false"}, true
+ case t.Info()&types.IsNumeric != 0:
+ return &ast.BasicLit{Kind: token.INT, Value: "0"}, true
+ case t.Info()&types.IsString != 0:
+ return &ast.BasicLit{Kind: token.STRING, Value: `""`}, true
+ case t.Kind() == types.UnsafePointer:
+ fallthrough
+ case t.Kind() == types.UntypedNil:
+ return ast.NewIdent("nil"), true
+ case t.Kind() == types.Invalid:
+ return &ast.BasicLit{Kind: token.STRING, Value: `"invalid"`}, false
+ default:
+ panic(fmt.Sprintf("ZeroExpr for unexpected type %v", t))
+ }
+
+ case *types.Pointer, *types.Slice, *types.Chan, *types.Map, *types.Signature:
+ return ast.NewIdent("nil"), true
+
+ case *types.Interface:
+ if !t.IsMethodSet() {
+ return &ast.BasicLit{Kind: token.STRING, Value: `"invalid"`}, false
+ }
+ return ast.NewIdent("nil"), true
+
+ case *types.Named:
+ switch under := t.Underlying().(type) {
+ case *types.Struct, *types.Array:
+ return &ast.CompositeLit{
+ Type: TypeExpr(t, qual),
+ }, true
+ default:
+ return ZeroExpr(under, qual)
+ }
+
+ case *types.Alias:
+ switch t.Underlying().(type) {
+ case *types.Struct, *types.Array:
+ return &ast.CompositeLit{
+ Type: TypeExpr(t, qual),
+ }, true
+ default:
+ return ZeroExpr(types.Unalias(t), qual)
+ }
+
+ case *types.Array, *types.Struct:
+ return &ast.CompositeLit{
+ Type: TypeExpr(t, qual),
+ }, true
+
+ case *types.TypeParam:
+ return &ast.StarExpr{ // *new(T)
+ X: &ast.CallExpr{
+ // Assumes func new is not shadowed.
+ Fun: ast.NewIdent("new"),
+ Args: []ast.Expr{
+ ast.NewIdent(t.Obj().Name()),
+ },
+ },
+ }, true
+
+ case *types.Tuple:
+ // Unlike ZeroString, there is no ast.Expr can express tuple by
+ // "(t[0], ..., t[n])".
+ panic(fmt.Sprintf("invalid type for a variable: %v", t))
+
+ case *types.Union:
+ // Variables of these types cannot be created, so it makes
+ // no sense to ask for their zero value.
+ panic(fmt.Sprintf("invalid type for a variable: %v", t))
+
+ default:
+ panic(t) // unreachable.
+ }
+}
+
+// IsZeroExpr uses simple syntactic heuristics to report whether expr
+// is a obvious zero value, such as 0, "", nil, or false.
+// It cannot do better without type information.
+func IsZeroExpr(expr ast.Expr) bool {
+ switch e := expr.(type) {
+ case *ast.BasicLit:
+ return e.Value == "0" || e.Value == `""`
+ case *ast.Ident:
+ return e.Name == "nil" || e.Name == "false"
+ default:
+ return false
+ }
+}
+
+// TypeExpr returns syntax for the specified type. References to named types
+// are qualified by an appropriate (optional) qualifier function.
+// It may panic for types such as Tuple or Union.
+func TypeExpr(t types.Type, qual types.Qualifier) ast.Expr {
+ switch t := t.(type) {
+ case *types.Basic:
+ switch t.Kind() {
+ case types.UnsafePointer:
+ return &ast.SelectorExpr{X: ast.NewIdent(qual(types.NewPackage("unsafe", "unsafe"))), Sel: ast.NewIdent("Pointer")}
+ default:
+ return ast.NewIdent(t.Name())
+ }
+
+ case *types.Pointer:
+ return &ast.UnaryExpr{
+ Op: token.MUL,
+ X: TypeExpr(t.Elem(), qual),
+ }
+
+ case *types.Array:
+ return &ast.ArrayType{
+ Len: &ast.BasicLit{
+ Kind: token.INT,
+ Value: fmt.Sprintf("%d", t.Len()),
+ },
+ Elt: TypeExpr(t.Elem(), qual),
+ }
+
+ case *types.Slice:
+ return &ast.ArrayType{
+ Elt: TypeExpr(t.Elem(), qual),
+ }
+
+ case *types.Map:
+ return &ast.MapType{
+ Key: TypeExpr(t.Key(), qual),
+ Value: TypeExpr(t.Elem(), qual),
+ }
+
+ case *types.Chan:
+ dir := ast.ChanDir(t.Dir())
+ if t.Dir() == types.SendRecv {
+ dir = ast.SEND | ast.RECV
+ }
+ return &ast.ChanType{
+ Dir: dir,
+ Value: TypeExpr(t.Elem(), qual),
+ }
+
+ case *types.Signature:
+ var params []*ast.Field
+ for i := 0; i < t.Params().Len(); i++ {
+ params = append(params, &ast.Field{
+ Type: TypeExpr(t.Params().At(i).Type(), qual),
+ Names: []*ast.Ident{
+ {
+ Name: t.Params().At(i).Name(),
+ },
+ },
+ })
+ }
+ if t.Variadic() {
+ last := params[len(params)-1]
+ last.Type = &ast.Ellipsis{Elt: last.Type.(*ast.ArrayType).Elt}
+ }
+ var returns []*ast.Field
+ for i := 0; i < t.Results().Len(); i++ {
+ returns = append(returns, &ast.Field{
+ Type: TypeExpr(t.Results().At(i).Type(), qual),
+ })
+ }
+ return &ast.FuncType{
+ Params: &ast.FieldList{
+ List: params,
+ },
+ Results: &ast.FieldList{
+ List: returns,
+ },
+ }
+
+ case *types.TypeParam:
+ pkgName := qual(t.Obj().Pkg())
+ if pkgName == "" || t.Obj().Pkg() == nil {
+ return ast.NewIdent(t.Obj().Name())
+ }
+ return &ast.SelectorExpr{
+ X: ast.NewIdent(pkgName),
+ Sel: ast.NewIdent(t.Obj().Name()),
+ }
+
+ // types.TypeParam also implements interface NamedOrAlias. To differentiate,
+ // case TypeParam need to be present before case NamedOrAlias.
+ // TODO(hxjiang): remove this comment once TypeArgs() is added to interface
+ // NamedOrAlias.
+ case NamedOrAlias:
+ var expr ast.Expr = ast.NewIdent(t.Obj().Name())
+ if pkgName := qual(t.Obj().Pkg()); pkgName != "." && pkgName != "" {
+ expr = &ast.SelectorExpr{
+ X: ast.NewIdent(pkgName),
+ Sel: expr.(*ast.Ident),
+ }
+ }
+
+ // TODO(hxjiang): call t.TypeArgs after adding method TypeArgs() to
+ // typesinternal.NamedOrAlias.
+ if hasTypeArgs, ok := t.(interface{ TypeArgs() *types.TypeList }); ok {
+ if typeArgs := hasTypeArgs.TypeArgs(); typeArgs != nil && typeArgs.Len() > 0 {
+ var indices []ast.Expr
+ for i := range typeArgs.Len() {
+ indices = append(indices, TypeExpr(typeArgs.At(i), qual))
+ }
+ expr = &ast.IndexListExpr{
+ X: expr,
+ Indices: indices,
+ }
+ }
+ }
+
+ return expr
+
+ case *types.Struct:
+ return ast.NewIdent(t.String())
+
+ case *types.Interface:
+ return ast.NewIdent(t.String())
+
+ case *types.Union:
+ if t.Len() == 0 {
+ panic("Union type should have at least one term")
+ }
+ // Same as go/ast, the return expression will put last term in the
+ // Y field at topmost level of BinaryExpr.
+ // For union of type "float32 | float64 | int64", the structure looks
+ // similar to:
+ // {
+ // X: {
+ // X: float32,
+ // Op: |
+ // Y: float64,
+ // }
+ // Op: |,
+ // Y: int64,
+ // }
+ var union ast.Expr
+ for i := range t.Len() {
+ term := t.Term(i)
+ termExpr := TypeExpr(term.Type(), qual)
+ if term.Tilde() {
+ termExpr = &ast.UnaryExpr{
+ Op: token.TILDE,
+ X: termExpr,
+ }
+ }
+ if i == 0 {
+ union = termExpr
+ } else {
+ union = &ast.BinaryExpr{
+ X: union,
+ Op: token.OR,
+ Y: termExpr,
+ }
+ }
+ }
+ return union
+
+ case *types.Tuple:
+ panic("invalid input type types.Tuple")
+
+ default:
+ panic("unreachable")
+ }
+}
diff --git a/vendor/golang.org/x/tools/internal/versions/features.go b/vendor/golang.org/x/tools/internal/versions/features.go
new file mode 100644
index 00000000..b53f1786
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/versions/features.go
@@ -0,0 +1,43 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package versions
+
+// This file contains predicates for working with file versions to
+// decide when a tool should consider a language feature enabled.
+
+// GoVersions that features in x/tools can be gated to.
+const (
+ Go1_18 = "go1.18"
+ Go1_19 = "go1.19"
+ Go1_20 = "go1.20"
+ Go1_21 = "go1.21"
+ Go1_22 = "go1.22"
+)
+
+// Future is an invalid unknown Go version sometime in the future.
+// Do not use directly with Compare.
+const Future = ""
+
+// AtLeast reports whether the file version v comes after a Go release.
+//
+// Use this predicate to enable a behavior once a certain Go release
+// has happened (and stays enabled in the future).
+func AtLeast(v, release string) bool {
+ if v == Future {
+ return true // an unknown future version is always after y.
+ }
+ return Compare(Lang(v), Lang(release)) >= 0
+}
+
+// Before reports whether the file version v is strictly before a Go release.
+//
+// Use this predicate to disable a behavior once a certain Go release
+// has happened (and stays enabled in the future).
+func Before(v, release string) bool {
+ if v == Future {
+ return false // an unknown future version happens after y.
+ }
+ return Compare(Lang(v), Lang(release)) < 0
+}
diff --git a/vendor/golang.org/x/tools/internal/versions/gover.go b/vendor/golang.org/x/tools/internal/versions/gover.go
new file mode 100644
index 00000000..bbabcd22
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/versions/gover.go
@@ -0,0 +1,172 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This is a fork of internal/gover for use by x/tools until
+// go1.21 and earlier are no longer supported by x/tools.
+
+package versions
+
+import "strings"
+
+// A gover is a parsed Go gover: major[.Minor[.Patch]][kind[pre]]
+// The numbers are the original decimal strings to avoid integer overflows
+// and since there is very little actual math. (Probably overflow doesn't matter in practice,
+// but at the time this code was written, there was an existing test that used
+// go1.99999999999, which does not fit in an int on 32-bit platforms.
+// The "big decimal" representation avoids the problem entirely.)
+type gover struct {
+ major string // decimal
+ minor string // decimal or ""
+ patch string // decimal or ""
+ kind string // "", "alpha", "beta", "rc"
+ pre string // decimal or ""
+}
+
+// compare returns -1, 0, or +1 depending on whether
+// x < y, x == y, or x > y, interpreted as toolchain versions.
+// The versions x and y must not begin with a "go" prefix: just "1.21" not "go1.21".
+// Malformed versions compare less than well-formed versions and equal to each other.
+// The language version "1.21" compares less than the release candidate and eventual releases "1.21rc1" and "1.21.0".
+func compare(x, y string) int {
+ vx := parse(x)
+ vy := parse(y)
+
+ if c := cmpInt(vx.major, vy.major); c != 0 {
+ return c
+ }
+ if c := cmpInt(vx.minor, vy.minor); c != 0 {
+ return c
+ }
+ if c := cmpInt(vx.patch, vy.patch); c != 0 {
+ return c
+ }
+ if c := strings.Compare(vx.kind, vy.kind); c != 0 { // "" < alpha < beta < rc
+ return c
+ }
+ if c := cmpInt(vx.pre, vy.pre); c != 0 {
+ return c
+ }
+ return 0
+}
+
+// lang returns the Go language version. For example, lang("1.2.3") == "1.2".
+func lang(x string) string {
+ v := parse(x)
+ if v.minor == "" || v.major == "1" && v.minor == "0" {
+ return v.major
+ }
+ return v.major + "." + v.minor
+}
+
+// isValid reports whether the version x is valid.
+func isValid(x string) bool {
+ return parse(x) != gover{}
+}
+
+// parse parses the Go version string x into a version.
+// It returns the zero version if x is malformed.
+func parse(x string) gover {
+ var v gover
+
+ // Parse major version.
+ var ok bool
+ v.major, x, ok = cutInt(x)
+ if !ok {
+ return gover{}
+ }
+ if x == "" {
+ // Interpret "1" as "1.0.0".
+ v.minor = "0"
+ v.patch = "0"
+ return v
+ }
+
+ // Parse . before minor version.
+ if x[0] != '.' {
+ return gover{}
+ }
+
+ // Parse minor version.
+ v.minor, x, ok = cutInt(x[1:])
+ if !ok {
+ return gover{}
+ }
+ if x == "" {
+ // Patch missing is same as "0" for older versions.
+ // Starting in Go 1.21, patch missing is different from explicit .0.
+ if cmpInt(v.minor, "21") < 0 {
+ v.patch = "0"
+ }
+ return v
+ }
+
+ // Parse patch if present.
+ if x[0] == '.' {
+ v.patch, x, ok = cutInt(x[1:])
+ if !ok || x != "" {
+ // Note that we are disallowing prereleases (alpha, beta, rc) for patch releases here (x != "").
+ // Allowing them would be a bit confusing because we already have:
+ // 1.21 < 1.21rc1
+ // But a prerelease of a patch would have the opposite effect:
+ // 1.21.3rc1 < 1.21.3
+ // We've never needed them before, so let's not start now.
+ return gover{}
+ }
+ return v
+ }
+
+ // Parse prerelease.
+ i := 0
+ for i < len(x) && (x[i] < '0' || '9' < x[i]) {
+ if x[i] < 'a' || 'z' < x[i] {
+ return gover{}
+ }
+ i++
+ }
+ if i == 0 {
+ return gover{}
+ }
+ v.kind, x = x[:i], x[i:]
+ if x == "" {
+ return v
+ }
+ v.pre, x, ok = cutInt(x)
+ if !ok || x != "" {
+ return gover{}
+ }
+
+ return v
+}
+
+// cutInt scans the leading decimal number at the start of x to an integer
+// and returns that value and the rest of the string.
+func cutInt(x string) (n, rest string, ok bool) {
+ i := 0
+ for i < len(x) && '0' <= x[i] && x[i] <= '9' {
+ i++
+ }
+ if i == 0 || x[0] == '0' && i != 1 { // no digits or unnecessary leading zero
+ return "", "", false
+ }
+ return x[:i], x[i:], true
+}
+
+// cmpInt returns cmp.Compare(x, y) interpreting x and y as decimal numbers.
+// (Copied from golang.org/x/mod/semver's compareInt.)
+func cmpInt(x, y string) int {
+ if x == y {
+ return 0
+ }
+ if len(x) < len(y) {
+ return -1
+ }
+ if len(x) > len(y) {
+ return +1
+ }
+ if x < y {
+ return -1
+ } else {
+ return +1
+ }
+}
diff --git a/vendor/golang.org/x/tools/internal/versions/types.go b/vendor/golang.org/x/tools/internal/versions/types.go
new file mode 100644
index 00000000..0fc10ce4
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/versions/types.go
@@ -0,0 +1,33 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package versions
+
+import (
+ "go/ast"
+ "go/types"
+)
+
+// FileVersion returns a file's Go version.
+// The reported version is an unknown Future version if a
+// version cannot be determined.
+func FileVersion(info *types.Info, file *ast.File) string {
+ // In tools built with Go >= 1.22, the Go version of a file
+ // follow a cascades of sources:
+ // 1) types.Info.FileVersion, which follows the cascade:
+ // 1.a) file version (ast.File.GoVersion),
+ // 1.b) the package version (types.Config.GoVersion), or
+ // 2) is some unknown Future version.
+ //
+ // File versions require a valid package version to be provided to types
+ // in Config.GoVersion. Config.GoVersion is either from the package's module
+ // or the toolchain (go run). This value should be provided by go/packages
+ // or unitchecker.Config.GoVersion.
+ if v := info.FileVersions[file]; IsValid(v) {
+ return v
+ }
+ // Note: we could instead return runtime.Version() [if valid].
+ // This would act as a max version on what a tool can support.
+ return Future
+}
diff --git a/vendor/golang.org/x/tools/internal/versions/versions.go b/vendor/golang.org/x/tools/internal/versions/versions.go
new file mode 100644
index 00000000..8d1f7453
--- /dev/null
+++ b/vendor/golang.org/x/tools/internal/versions/versions.go
@@ -0,0 +1,57 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package versions
+
+import (
+ "strings"
+)
+
+// Note: If we use build tags to use go/versions when go >=1.22,
+// we run into go.dev/issue/53737. Under some operations users would see an
+// import of "go/versions" even if they would not compile the file.
+// For example, during `go get -u ./...` (go.dev/issue/64490) we do not try to include
+// For this reason, this library just a clone of go/versions for the moment.
+
+// Lang returns the Go language version for version x.
+// If x is not a valid version, Lang returns the empty string.
+// For example:
+//
+// Lang("go1.21rc2") = "go1.21"
+// Lang("go1.21.2") = "go1.21"
+// Lang("go1.21") = "go1.21"
+// Lang("go1") = "go1"
+// Lang("bad") = ""
+// Lang("1.21") = ""
+func Lang(x string) string {
+ v := lang(stripGo(x))
+ if v == "" {
+ return ""
+ }
+ return x[:2+len(v)] // "go"+v without allocation
+}
+
+// Compare returns -1, 0, or +1 depending on whether
+// x < y, x == y, or x > y, interpreted as Go versions.
+// The versions x and y must begin with a "go" prefix: "go1.21" not "1.21".
+// Invalid versions, including the empty string, compare less than
+// valid versions and equal to each other.
+// The language version "go1.21" compares less than the
+// release candidate and eventual releases "go1.21rc1" and "go1.21.0".
+// Custom toolchain suffixes are ignored during comparison:
+// "go1.21.0" and "go1.21.0-bigcorp" are equal.
+func Compare(x, y string) int { return compare(stripGo(x), stripGo(y)) }
+
+// IsValid reports whether the version x is valid.
+func IsValid(x string) bool { return isValid(stripGo(x)) }
+
+// stripGo converts from a "go1.21" version to a "1.21" version.
+// If v does not start with "go", stripGo returns the empty string (a known invalid version).
+func stripGo(v string) string {
+ v, _, _ = strings.Cut(v, "-") // strip -bigcorp suffix.
+ if len(v) < 2 || v[:2] != "go" {
+ return ""
+ }
+ return v[2:]
+}
diff --git a/vendor/google.golang.org/protobuf/encoding/protowire/wire.go b/vendor/google.golang.org/protobuf/encoding/protowire/wire.go
index e942bc98..743bfb81 100644
--- a/vendor/google.golang.org/protobuf/encoding/protowire/wire.go
+++ b/vendor/google.golang.org/protobuf/encoding/protowire/wire.go
@@ -371,7 +371,31 @@ func ConsumeVarint(b []byte) (v uint64, n int) {
func SizeVarint(v uint64) int {
// This computes 1 + (bits.Len64(v)-1)/7.
// 9/64 is a good enough approximation of 1/7
- return int(9*uint32(bits.Len64(v))+64) / 64
+ //
+ // The Go compiler can translate the bits.LeadingZeros64 call into the LZCNT
+ // instruction, which is very fast on CPUs from the last few years. The
+ // specific way of expressing the calculation matches C++ Protobuf, see
+ // https://godbolt.org/z/4P3h53oM4 for the C++ code and how gcc/clang
+ // optimize that function for GOAMD64=v1 and GOAMD64=v3 (-march=haswell).
+
+ // By OR'ing v with 1, we guarantee that v is never 0, without changing the
+ // result of SizeVarint. LZCNT is not defined for 0, meaning the compiler
+ // needs to add extra instructions to handle that case.
+ //
+ // The Go compiler currently (go1.24.4) does not make use of this knowledge.
+ // This opportunity (removing the XOR instruction, which handles the 0 case)
+ // results in a small (1%) performance win across CPU architectures.
+ //
+ // Independently of avoiding the 0 case, we need the v |= 1 line because
+ // it allows the Go compiler to eliminate an extra XCHGL barrier.
+ v |= 1
+
+ // It would be clearer to write log2value := 63 - uint32(...), but
+ // writing uint32(...) ^ 63 is much more efficient (-14% ARM, -20% Intel).
+ // Proof of identity for our value range [0..63]:
+ // https://go.dev/play/p/Pdn9hEWYakX
+ log2value := uint32(bits.LeadingZeros64(v)) ^ 63
+ return int((log2value*9 + (64 + 9)) / 64)
}
// AppendFixed32 appends v to b as a little-endian uint32.
diff --git a/vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb b/vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb
index 323829da..04696351 100644
Binary files a/vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb and b/vendor/google.golang.org/protobuf/internal/editiondefaults/editions_defaults.binpb differ
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/editions.go b/vendor/google.golang.org/protobuf/internal/filedesc/editions.go
index b08b7183..a0aad277 100644
--- a/vendor/google.golang.org/protobuf/internal/filedesc/editions.go
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/editions.go
@@ -72,6 +72,9 @@ func unmarshalFeatureSet(b []byte, parent EditionFeatures) EditionFeatures {
case genid.FeatureSet_EnforceNamingStyle_field_number:
// EnforceNamingStyle is enforced in protoc, languages other than C++
// are not supposed to do anything with this feature.
+ case genid.FeatureSet_DefaultSymbolVisibility_field_number:
+ // DefaultSymbolVisibility is enforced in protoc, runtimes should not
+ // inspect this value.
default:
panic(fmt.Sprintf("unkown field number %d while unmarshalling FeatureSet", num))
}
diff --git a/vendor/google.golang.org/protobuf/internal/filedesc/presence.go b/vendor/google.golang.org/protobuf/internal/filedesc/presence.go
new file mode 100644
index 00000000..a12ec979
--- /dev/null
+++ b/vendor/google.golang.org/protobuf/internal/filedesc/presence.go
@@ -0,0 +1,33 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package filedesc
+
+import "google.golang.org/protobuf/reflect/protoreflect"
+
+// UsePresenceForField reports whether the presence bitmap should be used for
+// the specified field.
+func UsePresenceForField(fd protoreflect.FieldDescriptor) (usePresence, canBeLazy bool) {
+ switch {
+ case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
+ // Oneof fields never use the presence bitmap.
+ //
+ // Synthetic oneofs are an exception: Those are used to implement proto3
+ // optional fields and hence should follow non-oneof field semantics.
+ return false, false
+
+ case fd.IsMap():
+ // Map-typed fields never use the presence bitmap.
+ return false, false
+
+ case fd.Kind() == protoreflect.MessageKind || fd.Kind() == protoreflect.GroupKind:
+ // Lazy fields always use the presence bitmap (only messages can be lazy).
+ isLazy := fd.(interface{ IsLazy() bool }).IsLazy()
+ return isLazy, isLazy
+
+ default:
+ // If the field has presence, use the presence bitmap.
+ return fd.HasPresence(), false
+ }
+}
diff --git a/vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go b/vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go
index 39524782..950a6a32 100644
--- a/vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go
+++ b/vendor/google.golang.org/protobuf/internal/genid/descriptor_gen.go
@@ -34,6 +34,19 @@ const (
Edition_EDITION_MAX_enum_value = 2147483647
)
+// Full and short names for google.protobuf.SymbolVisibility.
+const (
+ SymbolVisibility_enum_fullname = "google.protobuf.SymbolVisibility"
+ SymbolVisibility_enum_name = "SymbolVisibility"
+)
+
+// Enum values for google.protobuf.SymbolVisibility.
+const (
+ SymbolVisibility_VISIBILITY_UNSET_enum_value = 0
+ SymbolVisibility_VISIBILITY_LOCAL_enum_value = 1
+ SymbolVisibility_VISIBILITY_EXPORT_enum_value = 2
+)
+
// Names for google.protobuf.FileDescriptorSet.
const (
FileDescriptorSet_message_name protoreflect.Name = "FileDescriptorSet"
@@ -65,6 +78,7 @@ const (
FileDescriptorProto_Dependency_field_name protoreflect.Name = "dependency"
FileDescriptorProto_PublicDependency_field_name protoreflect.Name = "public_dependency"
FileDescriptorProto_WeakDependency_field_name protoreflect.Name = "weak_dependency"
+ FileDescriptorProto_OptionDependency_field_name protoreflect.Name = "option_dependency"
FileDescriptorProto_MessageType_field_name protoreflect.Name = "message_type"
FileDescriptorProto_EnumType_field_name protoreflect.Name = "enum_type"
FileDescriptorProto_Service_field_name protoreflect.Name = "service"
@@ -79,6 +93,7 @@ const (
FileDescriptorProto_Dependency_field_fullname protoreflect.FullName = "google.protobuf.FileDescriptorProto.dependency"
FileDescriptorProto_PublicDependency_field_fullname protoreflect.FullName = "google.protobuf.FileDescriptorProto.public_dependency"
FileDescriptorProto_WeakDependency_field_fullname protoreflect.FullName = "google.protobuf.FileDescriptorProto.weak_dependency"
+ FileDescriptorProto_OptionDependency_field_fullname protoreflect.FullName = "google.protobuf.FileDescriptorProto.option_dependency"
FileDescriptorProto_MessageType_field_fullname protoreflect.FullName = "google.protobuf.FileDescriptorProto.message_type"
FileDescriptorProto_EnumType_field_fullname protoreflect.FullName = "google.protobuf.FileDescriptorProto.enum_type"
FileDescriptorProto_Service_field_fullname protoreflect.FullName = "google.protobuf.FileDescriptorProto.service"
@@ -96,6 +111,7 @@ const (
FileDescriptorProto_Dependency_field_number protoreflect.FieldNumber = 3
FileDescriptorProto_PublicDependency_field_number protoreflect.FieldNumber = 10
FileDescriptorProto_WeakDependency_field_number protoreflect.FieldNumber = 11
+ FileDescriptorProto_OptionDependency_field_number protoreflect.FieldNumber = 15
FileDescriptorProto_MessageType_field_number protoreflect.FieldNumber = 4
FileDescriptorProto_EnumType_field_number protoreflect.FieldNumber = 5
FileDescriptorProto_Service_field_number protoreflect.FieldNumber = 6
@@ -124,6 +140,7 @@ const (
DescriptorProto_Options_field_name protoreflect.Name = "options"
DescriptorProto_ReservedRange_field_name protoreflect.Name = "reserved_range"
DescriptorProto_ReservedName_field_name protoreflect.Name = "reserved_name"
+ DescriptorProto_Visibility_field_name protoreflect.Name = "visibility"
DescriptorProto_Name_field_fullname protoreflect.FullName = "google.protobuf.DescriptorProto.name"
DescriptorProto_Field_field_fullname protoreflect.FullName = "google.protobuf.DescriptorProto.field"
@@ -135,6 +152,7 @@ const (
DescriptorProto_Options_field_fullname protoreflect.FullName = "google.protobuf.DescriptorProto.options"
DescriptorProto_ReservedRange_field_fullname protoreflect.FullName = "google.protobuf.DescriptorProto.reserved_range"
DescriptorProto_ReservedName_field_fullname protoreflect.FullName = "google.protobuf.DescriptorProto.reserved_name"
+ DescriptorProto_Visibility_field_fullname protoreflect.FullName = "google.protobuf.DescriptorProto.visibility"
)
// Field numbers for google.protobuf.DescriptorProto.
@@ -149,6 +167,7 @@ const (
DescriptorProto_Options_field_number protoreflect.FieldNumber = 7
DescriptorProto_ReservedRange_field_number protoreflect.FieldNumber = 9
DescriptorProto_ReservedName_field_number protoreflect.FieldNumber = 10
+ DescriptorProto_Visibility_field_number protoreflect.FieldNumber = 11
)
// Names for google.protobuf.DescriptorProto.ExtensionRange.
@@ -388,12 +407,14 @@ const (
EnumDescriptorProto_Options_field_name protoreflect.Name = "options"
EnumDescriptorProto_ReservedRange_field_name protoreflect.Name = "reserved_range"
EnumDescriptorProto_ReservedName_field_name protoreflect.Name = "reserved_name"
+ EnumDescriptorProto_Visibility_field_name protoreflect.Name = "visibility"
EnumDescriptorProto_Name_field_fullname protoreflect.FullName = "google.protobuf.EnumDescriptorProto.name"
EnumDescriptorProto_Value_field_fullname protoreflect.FullName = "google.protobuf.EnumDescriptorProto.value"
EnumDescriptorProto_Options_field_fullname protoreflect.FullName = "google.protobuf.EnumDescriptorProto.options"
EnumDescriptorProto_ReservedRange_field_fullname protoreflect.FullName = "google.protobuf.EnumDescriptorProto.reserved_range"
EnumDescriptorProto_ReservedName_field_fullname protoreflect.FullName = "google.protobuf.EnumDescriptorProto.reserved_name"
+ EnumDescriptorProto_Visibility_field_fullname protoreflect.FullName = "google.protobuf.EnumDescriptorProto.visibility"
)
// Field numbers for google.protobuf.EnumDescriptorProto.
@@ -403,6 +424,7 @@ const (
EnumDescriptorProto_Options_field_number protoreflect.FieldNumber = 3
EnumDescriptorProto_ReservedRange_field_number protoreflect.FieldNumber = 4
EnumDescriptorProto_ReservedName_field_number protoreflect.FieldNumber = 5
+ EnumDescriptorProto_Visibility_field_number protoreflect.FieldNumber = 6
)
// Names for google.protobuf.EnumDescriptorProto.EnumReservedRange.
@@ -1008,32 +1030,35 @@ const (
// Field names for google.protobuf.FeatureSet.
const (
- FeatureSet_FieldPresence_field_name protoreflect.Name = "field_presence"
- FeatureSet_EnumType_field_name protoreflect.Name = "enum_type"
- FeatureSet_RepeatedFieldEncoding_field_name protoreflect.Name = "repeated_field_encoding"
- FeatureSet_Utf8Validation_field_name protoreflect.Name = "utf8_validation"
- FeatureSet_MessageEncoding_field_name protoreflect.Name = "message_encoding"
- FeatureSet_JsonFormat_field_name protoreflect.Name = "json_format"
- FeatureSet_EnforceNamingStyle_field_name protoreflect.Name = "enforce_naming_style"
-
- FeatureSet_FieldPresence_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.field_presence"
- FeatureSet_EnumType_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.enum_type"
- FeatureSet_RepeatedFieldEncoding_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.repeated_field_encoding"
- FeatureSet_Utf8Validation_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.utf8_validation"
- FeatureSet_MessageEncoding_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.message_encoding"
- FeatureSet_JsonFormat_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.json_format"
- FeatureSet_EnforceNamingStyle_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.enforce_naming_style"
+ FeatureSet_FieldPresence_field_name protoreflect.Name = "field_presence"
+ FeatureSet_EnumType_field_name protoreflect.Name = "enum_type"
+ FeatureSet_RepeatedFieldEncoding_field_name protoreflect.Name = "repeated_field_encoding"
+ FeatureSet_Utf8Validation_field_name protoreflect.Name = "utf8_validation"
+ FeatureSet_MessageEncoding_field_name protoreflect.Name = "message_encoding"
+ FeatureSet_JsonFormat_field_name protoreflect.Name = "json_format"
+ FeatureSet_EnforceNamingStyle_field_name protoreflect.Name = "enforce_naming_style"
+ FeatureSet_DefaultSymbolVisibility_field_name protoreflect.Name = "default_symbol_visibility"
+
+ FeatureSet_FieldPresence_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.field_presence"
+ FeatureSet_EnumType_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.enum_type"
+ FeatureSet_RepeatedFieldEncoding_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.repeated_field_encoding"
+ FeatureSet_Utf8Validation_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.utf8_validation"
+ FeatureSet_MessageEncoding_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.message_encoding"
+ FeatureSet_JsonFormat_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.json_format"
+ FeatureSet_EnforceNamingStyle_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.enforce_naming_style"
+ FeatureSet_DefaultSymbolVisibility_field_fullname protoreflect.FullName = "google.protobuf.FeatureSet.default_symbol_visibility"
)
// Field numbers for google.protobuf.FeatureSet.
const (
- FeatureSet_FieldPresence_field_number protoreflect.FieldNumber = 1
- FeatureSet_EnumType_field_number protoreflect.FieldNumber = 2
- FeatureSet_RepeatedFieldEncoding_field_number protoreflect.FieldNumber = 3
- FeatureSet_Utf8Validation_field_number protoreflect.FieldNumber = 4
- FeatureSet_MessageEncoding_field_number protoreflect.FieldNumber = 5
- FeatureSet_JsonFormat_field_number protoreflect.FieldNumber = 6
- FeatureSet_EnforceNamingStyle_field_number protoreflect.FieldNumber = 7
+ FeatureSet_FieldPresence_field_number protoreflect.FieldNumber = 1
+ FeatureSet_EnumType_field_number protoreflect.FieldNumber = 2
+ FeatureSet_RepeatedFieldEncoding_field_number protoreflect.FieldNumber = 3
+ FeatureSet_Utf8Validation_field_number protoreflect.FieldNumber = 4
+ FeatureSet_MessageEncoding_field_number protoreflect.FieldNumber = 5
+ FeatureSet_JsonFormat_field_number protoreflect.FieldNumber = 6
+ FeatureSet_EnforceNamingStyle_field_number protoreflect.FieldNumber = 7
+ FeatureSet_DefaultSymbolVisibility_field_number protoreflect.FieldNumber = 8
)
// Full and short names for google.protobuf.FeatureSet.FieldPresence.
@@ -1128,6 +1153,27 @@ const (
FeatureSet_STYLE_LEGACY_enum_value = 2
)
+// Names for google.protobuf.FeatureSet.VisibilityFeature.
+const (
+ FeatureSet_VisibilityFeature_message_name protoreflect.Name = "VisibilityFeature"
+ FeatureSet_VisibilityFeature_message_fullname protoreflect.FullName = "google.protobuf.FeatureSet.VisibilityFeature"
+)
+
+// Full and short names for google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility.
+const (
+ FeatureSet_VisibilityFeature_DefaultSymbolVisibility_enum_fullname = "google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility"
+ FeatureSet_VisibilityFeature_DefaultSymbolVisibility_enum_name = "DefaultSymbolVisibility"
+)
+
+// Enum values for google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility.
+const (
+ FeatureSet_VisibilityFeature_DEFAULT_SYMBOL_VISIBILITY_UNKNOWN_enum_value = 0
+ FeatureSet_VisibilityFeature_EXPORT_ALL_enum_value = 1
+ FeatureSet_VisibilityFeature_EXPORT_TOP_LEVEL_enum_value = 2
+ FeatureSet_VisibilityFeature_LOCAL_ALL_enum_value = 3
+ FeatureSet_VisibilityFeature_STRICT_enum_value = 4
+)
+
// Names for google.protobuf.FeatureSetDefaults.
const (
FeatureSetDefaults_message_name protoreflect.Name = "FeatureSetDefaults"
diff --git a/vendor/google.golang.org/protobuf/internal/impl/codec_message_opaque.go b/vendor/google.golang.org/protobuf/internal/impl/codec_message_opaque.go
index 41c1f74e..bdad12a9 100644
--- a/vendor/google.golang.org/protobuf/internal/impl/codec_message_opaque.go
+++ b/vendor/google.golang.org/protobuf/internal/impl/codec_message_opaque.go
@@ -11,6 +11,7 @@ import (
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/encoding/messageset"
+ "google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/order"
"google.golang.org/protobuf/reflect/protoreflect"
piface "google.golang.org/protobuf/runtime/protoiface"
@@ -80,7 +81,7 @@ func (mi *MessageInfo) makeOpaqueCoderMethods(t reflect.Type, si opaqueStructInf
// permit us to skip over definitely-unset fields at marshal time.
var hasPresence bool
- hasPresence, cf.isLazy = usePresenceForField(si, fd)
+ hasPresence, cf.isLazy = filedesc.UsePresenceForField(fd)
if hasPresence {
cf.presenceIndex, mi.presenceSize = presenceIndex(mi.Desc, fd)
diff --git a/vendor/google.golang.org/protobuf/internal/impl/message_opaque.go b/vendor/google.golang.org/protobuf/internal/impl/message_opaque.go
index dd55e8e0..5a439daa 100644
--- a/vendor/google.golang.org/protobuf/internal/impl/message_opaque.go
+++ b/vendor/google.golang.org/protobuf/internal/impl/message_opaque.go
@@ -11,6 +11,7 @@ import (
"strings"
"sync/atomic"
+ "google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/reflect/protoreflect"
)
@@ -53,7 +54,7 @@ func opaqueInitHook(mi *MessageInfo) bool {
fd := fds.Get(i)
fs := si.fieldsByNumber[fd.Number()]
var fi fieldInfo
- usePresence, _ := usePresenceForField(si, fd)
+ usePresence, _ := filedesc.UsePresenceForField(fd)
switch {
case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
@@ -343,17 +344,15 @@ func (mi *MessageInfo) fieldInfoForMessageListOpaqueNoPresence(si opaqueStructIn
if p.IsNil() {
return false
}
- sp := p.Apply(fieldOffset).AtomicGetPointer()
- if sp.IsNil() {
+ rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+ if rv.IsNil() {
return false
}
- rv := sp.AsValueOf(fs.Type.Elem())
return rv.Elem().Len() > 0
},
clear: func(p pointer) {
- sp := p.Apply(fieldOffset).AtomicGetPointer()
- if !sp.IsNil() {
- rv := sp.AsValueOf(fs.Type.Elem())
+ rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+ if !rv.IsNil() {
rv.Elem().Set(reflect.Zero(rv.Type().Elem()))
}
},
@@ -361,11 +360,10 @@ func (mi *MessageInfo) fieldInfoForMessageListOpaqueNoPresence(si opaqueStructIn
if p.IsNil() {
return conv.Zero()
}
- sp := p.Apply(fieldOffset).AtomicGetPointer()
- if sp.IsNil() {
+ rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()
+ if rv.IsNil() {
return conv.Zero()
}
- rv := sp.AsValueOf(fs.Type.Elem())
if rv.Elem().Len() == 0 {
return conv.Zero()
}
@@ -598,30 +596,3 @@ func (mi *MessageInfo) clearPresent(p pointer, index uint32) {
func (mi *MessageInfo) present(p pointer, index uint32) bool {
return p.Apply(mi.presenceOffset).PresenceInfo().Present(index)
}
-
-// usePresenceForField implements the somewhat intricate logic of when
-// the presence bitmap is used for a field. The main logic is that a
-// field that is optional or that can be lazy will use the presence
-// bit, but for proto2, also maps have a presence bit. It also records
-// if the field can ever be lazy, which is true if we have a
-// lazyOffset and the field is a message or a slice of messages. A
-// field that is lazy will always need a presence bit. Oneofs are not
-// lazy and do not use presence, unless they are a synthetic oneof,
-// which is a proto3 optional field. For proto3 optionals, we use the
-// presence and they can also be lazy when applicable (a message).
-func usePresenceForField(si opaqueStructInfo, fd protoreflect.FieldDescriptor) (usePresence, canBeLazy bool) {
- hasLazyField := fd.(interface{ IsLazy() bool }).IsLazy()
-
- // Non-oneof scalar fields with explicit field presence use the presence array.
- usesPresenceArray := fd.HasPresence() && fd.Message() == nil && (fd.ContainingOneof() == nil || fd.ContainingOneof().IsSynthetic())
- switch {
- case fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic():
- return false, false
- case fd.IsMap():
- return false, false
- case fd.Kind() == protoreflect.MessageKind || fd.Kind() == protoreflect.GroupKind:
- return hasLazyField, hasLazyField
- default:
- return usesPresenceArray || (hasLazyField && fd.HasPresence()), false
- }
-}
diff --git a/vendor/google.golang.org/protobuf/internal/impl/presence.go b/vendor/google.golang.org/protobuf/internal/impl/presence.go
index 914cb1de..443afe81 100644
--- a/vendor/google.golang.org/protobuf/internal/impl/presence.go
+++ b/vendor/google.golang.org/protobuf/internal/impl/presence.go
@@ -32,9 +32,6 @@ func (p presence) toElem(num uint32) (ret *uint32) {
// Present checks for the presence of a specific field number in a presence set.
func (p presence) Present(num uint32) bool {
- if p.P == nil {
- return false
- }
return Export{}.Present(p.toElem(num), num)
}
diff --git a/vendor/google.golang.org/protobuf/internal/version/version.go b/vendor/google.golang.org/protobuf/internal/version/version.go
index aac1cb18..a53364c5 100644
--- a/vendor/google.golang.org/protobuf/internal/version/version.go
+++ b/vendor/google.golang.org/protobuf/internal/version/version.go
@@ -52,7 +52,7 @@ import (
const (
Major = 1
Minor = 36
- Patch = 6
+ Patch = 7
PreRelease = ""
)
diff --git a/vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go b/vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go
index a4a0a297..730331e6 100644
--- a/vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go
+++ b/vendor/google.golang.org/protobuf/reflect/protoreflect/source_gen.go
@@ -21,6 +21,8 @@ func (p *SourcePath) appendFileDescriptorProto(b []byte) []byte {
b = p.appendRepeatedField(b, "public_dependency", nil)
case 11:
b = p.appendRepeatedField(b, "weak_dependency", nil)
+ case 15:
+ b = p.appendRepeatedField(b, "option_dependency", nil)
case 4:
b = p.appendRepeatedField(b, "message_type", (*SourcePath).appendDescriptorProto)
case 5:
@@ -66,6 +68,8 @@ func (p *SourcePath) appendDescriptorProto(b []byte) []byte {
b = p.appendRepeatedField(b, "reserved_range", (*SourcePath).appendDescriptorProto_ReservedRange)
case 10:
b = p.appendRepeatedField(b, "reserved_name", nil)
+ case 11:
+ b = p.appendSingularField(b, "visibility", nil)
}
return b
}
@@ -85,6 +89,8 @@ func (p *SourcePath) appendEnumDescriptorProto(b []byte) []byte {
b = p.appendRepeatedField(b, "reserved_range", (*SourcePath).appendEnumDescriptorProto_EnumReservedRange)
case 5:
b = p.appendRepeatedField(b, "reserved_name", nil)
+ case 6:
+ b = p.appendSingularField(b, "visibility", nil)
}
return b
}
@@ -400,6 +406,8 @@ func (p *SourcePath) appendFeatureSet(b []byte) []byte {
b = p.appendSingularField(b, "json_format", nil)
case 7:
b = p.appendSingularField(b, "enforce_naming_style", nil)
+ case 8:
+ b = p.appendSingularField(b, "default_symbol_visibility", nil)
}
return b
}
diff --git a/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go b/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
index 7fe280f1..6843b0be 100644
--- a/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
+++ b/vendor/google.golang.org/protobuf/types/descriptorpb/descriptor.pb.go
@@ -151,6 +151,70 @@ func (Edition) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{0}
}
+// Describes the 'visibility' of a symbol with respect to the proto import
+// system. Symbols can only be imported when the visibility rules do not prevent
+// it (ex: local symbols cannot be imported). Visibility modifiers can only set
+// on `message` and `enum` as they are the only types available to be referenced
+// from other files.
+type SymbolVisibility int32
+
+const (
+ SymbolVisibility_VISIBILITY_UNSET SymbolVisibility = 0
+ SymbolVisibility_VISIBILITY_LOCAL SymbolVisibility = 1
+ SymbolVisibility_VISIBILITY_EXPORT SymbolVisibility = 2
+)
+
+// Enum value maps for SymbolVisibility.
+var (
+ SymbolVisibility_name = map[int32]string{
+ 0: "VISIBILITY_UNSET",
+ 1: "VISIBILITY_LOCAL",
+ 2: "VISIBILITY_EXPORT",
+ }
+ SymbolVisibility_value = map[string]int32{
+ "VISIBILITY_UNSET": 0,
+ "VISIBILITY_LOCAL": 1,
+ "VISIBILITY_EXPORT": 2,
+ }
+)
+
+func (x SymbolVisibility) Enum() *SymbolVisibility {
+ p := new(SymbolVisibility)
+ *p = x
+ return p
+}
+
+func (x SymbolVisibility) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (SymbolVisibility) Descriptor() protoreflect.EnumDescriptor {
+ return file_google_protobuf_descriptor_proto_enumTypes[1].Descriptor()
+}
+
+func (SymbolVisibility) Type() protoreflect.EnumType {
+ return &file_google_protobuf_descriptor_proto_enumTypes[1]
+}
+
+func (x SymbolVisibility) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *SymbolVisibility) UnmarshalJSON(b []byte) error {
+ num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+ if err != nil {
+ return err
+ }
+ *x = SymbolVisibility(num)
+ return nil
+}
+
+// Deprecated: Use SymbolVisibility.Descriptor instead.
+func (SymbolVisibility) EnumDescriptor() ([]byte, []int) {
+ return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{1}
+}
+
// The verification state of the extension range.
type ExtensionRangeOptions_VerificationState int32
@@ -183,11 +247,11 @@ func (x ExtensionRangeOptions_VerificationState) String() string {
}
func (ExtensionRangeOptions_VerificationState) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[1].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[2].Descriptor()
}
func (ExtensionRangeOptions_VerificationState) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[1]
+ return &file_google_protobuf_descriptor_proto_enumTypes[2]
}
func (x ExtensionRangeOptions_VerificationState) Number() protoreflect.EnumNumber {
@@ -299,11 +363,11 @@ func (x FieldDescriptorProto_Type) String() string {
}
func (FieldDescriptorProto_Type) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[2].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[3].Descriptor()
}
func (FieldDescriptorProto_Type) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[2]
+ return &file_google_protobuf_descriptor_proto_enumTypes[3]
}
func (x FieldDescriptorProto_Type) Number() protoreflect.EnumNumber {
@@ -362,11 +426,11 @@ func (x FieldDescriptorProto_Label) String() string {
}
func (FieldDescriptorProto_Label) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[3].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[4].Descriptor()
}
func (FieldDescriptorProto_Label) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[3]
+ return &file_google_protobuf_descriptor_proto_enumTypes[4]
}
func (x FieldDescriptorProto_Label) Number() protoreflect.EnumNumber {
@@ -423,11 +487,11 @@ func (x FileOptions_OptimizeMode) String() string {
}
func (FileOptions_OptimizeMode) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[4].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[5].Descriptor()
}
func (FileOptions_OptimizeMode) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[4]
+ return &file_google_protobuf_descriptor_proto_enumTypes[5]
}
func (x FileOptions_OptimizeMode) Number() protoreflect.EnumNumber {
@@ -489,11 +553,11 @@ func (x FieldOptions_CType) String() string {
}
func (FieldOptions_CType) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[5].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[6].Descriptor()
}
func (FieldOptions_CType) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[5]
+ return &file_google_protobuf_descriptor_proto_enumTypes[6]
}
func (x FieldOptions_CType) Number() protoreflect.EnumNumber {
@@ -551,11 +615,11 @@ func (x FieldOptions_JSType) String() string {
}
func (FieldOptions_JSType) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[6].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[7].Descriptor()
}
func (FieldOptions_JSType) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[6]
+ return &file_google_protobuf_descriptor_proto_enumTypes[7]
}
func (x FieldOptions_JSType) Number() protoreflect.EnumNumber {
@@ -611,11 +675,11 @@ func (x FieldOptions_OptionRetention) String() string {
}
func (FieldOptions_OptionRetention) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[7].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[8].Descriptor()
}
func (FieldOptions_OptionRetention) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[7]
+ return &file_google_protobuf_descriptor_proto_enumTypes[8]
}
func (x FieldOptions_OptionRetention) Number() protoreflect.EnumNumber {
@@ -694,11 +758,11 @@ func (x FieldOptions_OptionTargetType) String() string {
}
func (FieldOptions_OptionTargetType) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[8].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[9].Descriptor()
}
func (FieldOptions_OptionTargetType) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[8]
+ return &file_google_protobuf_descriptor_proto_enumTypes[9]
}
func (x FieldOptions_OptionTargetType) Number() protoreflect.EnumNumber {
@@ -756,11 +820,11 @@ func (x MethodOptions_IdempotencyLevel) String() string {
}
func (MethodOptions_IdempotencyLevel) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[9].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[10].Descriptor()
}
func (MethodOptions_IdempotencyLevel) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[9]
+ return &file_google_protobuf_descriptor_proto_enumTypes[10]
}
func (x MethodOptions_IdempotencyLevel) Number() protoreflect.EnumNumber {
@@ -818,11 +882,11 @@ func (x FeatureSet_FieldPresence) String() string {
}
func (FeatureSet_FieldPresence) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[10].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[11].Descriptor()
}
func (FeatureSet_FieldPresence) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[10]
+ return &file_google_protobuf_descriptor_proto_enumTypes[11]
}
func (x FeatureSet_FieldPresence) Number() protoreflect.EnumNumber {
@@ -877,11 +941,11 @@ func (x FeatureSet_EnumType) String() string {
}
func (FeatureSet_EnumType) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[11].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[12].Descriptor()
}
func (FeatureSet_EnumType) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[11]
+ return &file_google_protobuf_descriptor_proto_enumTypes[12]
}
func (x FeatureSet_EnumType) Number() protoreflect.EnumNumber {
@@ -936,11 +1000,11 @@ func (x FeatureSet_RepeatedFieldEncoding) String() string {
}
func (FeatureSet_RepeatedFieldEncoding) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[12].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[13].Descriptor()
}
func (FeatureSet_RepeatedFieldEncoding) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[12]
+ return &file_google_protobuf_descriptor_proto_enumTypes[13]
}
func (x FeatureSet_RepeatedFieldEncoding) Number() protoreflect.EnumNumber {
@@ -995,11 +1059,11 @@ func (x FeatureSet_Utf8Validation) String() string {
}
func (FeatureSet_Utf8Validation) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[13].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[14].Descriptor()
}
func (FeatureSet_Utf8Validation) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[13]
+ return &file_google_protobuf_descriptor_proto_enumTypes[14]
}
func (x FeatureSet_Utf8Validation) Number() protoreflect.EnumNumber {
@@ -1054,11 +1118,11 @@ func (x FeatureSet_MessageEncoding) String() string {
}
func (FeatureSet_MessageEncoding) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[14].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[15].Descriptor()
}
func (FeatureSet_MessageEncoding) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[14]
+ return &file_google_protobuf_descriptor_proto_enumTypes[15]
}
func (x FeatureSet_MessageEncoding) Number() protoreflect.EnumNumber {
@@ -1113,11 +1177,11 @@ func (x FeatureSet_JsonFormat) String() string {
}
func (FeatureSet_JsonFormat) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[15].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[16].Descriptor()
}
func (FeatureSet_JsonFormat) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[15]
+ return &file_google_protobuf_descriptor_proto_enumTypes[16]
}
func (x FeatureSet_JsonFormat) Number() protoreflect.EnumNumber {
@@ -1172,11 +1236,11 @@ func (x FeatureSet_EnforceNamingStyle) String() string {
}
func (FeatureSet_EnforceNamingStyle) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[16].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[17].Descriptor()
}
func (FeatureSet_EnforceNamingStyle) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[16]
+ return &file_google_protobuf_descriptor_proto_enumTypes[17]
}
func (x FeatureSet_EnforceNamingStyle) Number() protoreflect.EnumNumber {
@@ -1198,6 +1262,77 @@ func (FeatureSet_EnforceNamingStyle) EnumDescriptor() ([]byte, []int) {
return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 6}
}
+type FeatureSet_VisibilityFeature_DefaultSymbolVisibility int32
+
+const (
+ FeatureSet_VisibilityFeature_DEFAULT_SYMBOL_VISIBILITY_UNKNOWN FeatureSet_VisibilityFeature_DefaultSymbolVisibility = 0
+ // Default pre-EDITION_2024, all UNSET visibility are export.
+ FeatureSet_VisibilityFeature_EXPORT_ALL FeatureSet_VisibilityFeature_DefaultSymbolVisibility = 1
+ // All top-level symbols default to export, nested default to local.
+ FeatureSet_VisibilityFeature_EXPORT_TOP_LEVEL FeatureSet_VisibilityFeature_DefaultSymbolVisibility = 2
+ // All symbols default to local.
+ FeatureSet_VisibilityFeature_LOCAL_ALL FeatureSet_VisibilityFeature_DefaultSymbolVisibility = 3
+ // All symbols local by default. Nested types cannot be exported.
+ // With special case caveat for message { enum {} reserved 1 to max; }
+ // This is the recommended setting for new protos.
+ FeatureSet_VisibilityFeature_STRICT FeatureSet_VisibilityFeature_DefaultSymbolVisibility = 4
+)
+
+// Enum value maps for FeatureSet_VisibilityFeature_DefaultSymbolVisibility.
+var (
+ FeatureSet_VisibilityFeature_DefaultSymbolVisibility_name = map[int32]string{
+ 0: "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN",
+ 1: "EXPORT_ALL",
+ 2: "EXPORT_TOP_LEVEL",
+ 3: "LOCAL_ALL",
+ 4: "STRICT",
+ }
+ FeatureSet_VisibilityFeature_DefaultSymbolVisibility_value = map[string]int32{
+ "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN": 0,
+ "EXPORT_ALL": 1,
+ "EXPORT_TOP_LEVEL": 2,
+ "LOCAL_ALL": 3,
+ "STRICT": 4,
+ }
+)
+
+func (x FeatureSet_VisibilityFeature_DefaultSymbolVisibility) Enum() *FeatureSet_VisibilityFeature_DefaultSymbolVisibility {
+ p := new(FeatureSet_VisibilityFeature_DefaultSymbolVisibility)
+ *p = x
+ return p
+}
+
+func (x FeatureSet_VisibilityFeature_DefaultSymbolVisibility) String() string {
+ return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
+}
+
+func (FeatureSet_VisibilityFeature_DefaultSymbolVisibility) Descriptor() protoreflect.EnumDescriptor {
+ return file_google_protobuf_descriptor_proto_enumTypes[18].Descriptor()
+}
+
+func (FeatureSet_VisibilityFeature_DefaultSymbolVisibility) Type() protoreflect.EnumType {
+ return &file_google_protobuf_descriptor_proto_enumTypes[18]
+}
+
+func (x FeatureSet_VisibilityFeature_DefaultSymbolVisibility) Number() protoreflect.EnumNumber {
+ return protoreflect.EnumNumber(x)
+}
+
+// Deprecated: Do not use.
+func (x *FeatureSet_VisibilityFeature_DefaultSymbolVisibility) UnmarshalJSON(b []byte) error {
+ num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
+ if err != nil {
+ return err
+ }
+ *x = FeatureSet_VisibilityFeature_DefaultSymbolVisibility(num)
+ return nil
+}
+
+// Deprecated: Use FeatureSet_VisibilityFeature_DefaultSymbolVisibility.Descriptor instead.
+func (FeatureSet_VisibilityFeature_DefaultSymbolVisibility) EnumDescriptor() ([]byte, []int) {
+ return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 0, 0}
+}
+
// Represents the identified object's effect on the element in the original
// .proto file.
type GeneratedCodeInfo_Annotation_Semantic int32
@@ -1236,11 +1371,11 @@ func (x GeneratedCodeInfo_Annotation_Semantic) String() string {
}
func (GeneratedCodeInfo_Annotation_Semantic) Descriptor() protoreflect.EnumDescriptor {
- return file_google_protobuf_descriptor_proto_enumTypes[17].Descriptor()
+ return file_google_protobuf_descriptor_proto_enumTypes[19].Descriptor()
}
func (GeneratedCodeInfo_Annotation_Semantic) Type() protoreflect.EnumType {
- return &file_google_protobuf_descriptor_proto_enumTypes[17]
+ return &file_google_protobuf_descriptor_proto_enumTypes[19]
}
func (x GeneratedCodeInfo_Annotation_Semantic) Number() protoreflect.EnumNumber {
@@ -1321,6 +1456,9 @@ type FileDescriptorProto struct {
// Indexes of the weak imported files in the dependency list.
// For Google-internal migration only. Do not use.
WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"`
+ // Names of files imported by this file purely for the purpose of providing
+ // option extensions. These are excluded from the dependency list above.
+ OptionDependency []string `protobuf:"bytes,15,rep,name=option_dependency,json=optionDependency" json:"option_dependency,omitempty"`
// All top-level definitions in this file.
MessageType []*DescriptorProto `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"`
EnumType []*EnumDescriptorProto `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
@@ -1414,6 +1552,13 @@ func (x *FileDescriptorProto) GetWeakDependency() []int32 {
return nil
}
+func (x *FileDescriptorProto) GetOptionDependency() []string {
+ if x != nil {
+ return x.OptionDependency
+ }
+ return nil
+}
+
func (x *FileDescriptorProto) GetMessageType() []*DescriptorProto {
if x != nil {
return x.MessageType
@@ -1484,7 +1629,9 @@ type DescriptorProto struct {
ReservedRange []*DescriptorProto_ReservedRange `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
// Reserved field names, which may not be used by fields in the same message.
// A given name may only be reserved once.
- ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
+ ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
+ // Support for `export` and `local` keywords on enums.
+ Visibility *SymbolVisibility `protobuf:"varint,11,opt,name=visibility,enum=google.protobuf.SymbolVisibility" json:"visibility,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -1589,6 +1736,13 @@ func (x *DescriptorProto) GetReservedName() []string {
return nil
}
+func (x *DescriptorProto) GetVisibility() SymbolVisibility {
+ if x != nil && x.Visibility != nil {
+ return *x.Visibility
+ }
+ return SymbolVisibility_VISIBILITY_UNSET
+}
+
type ExtensionRangeOptions struct {
state protoimpl.MessageState `protogen:"open.v1"`
// The parser stores options it doesn't recognize here. See above.
@@ -1901,7 +2055,9 @@ type EnumDescriptorProto struct {
ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
// Reserved enum value names, which may not be reused. A given name may only
// be reserved once.
- ReservedName []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
+ ReservedName []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
+ // Support for `export` and `local` keywords on enums.
+ Visibility *SymbolVisibility `protobuf:"varint,6,opt,name=visibility,enum=google.protobuf.SymbolVisibility" json:"visibility,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -1971,6 +2127,13 @@ func (x *EnumDescriptorProto) GetReservedName() []string {
return nil
}
+func (x *EnumDescriptorProto) GetVisibility() SymbolVisibility {
+ if x != nil && x.Visibility != nil {
+ return *x.Visibility
+ }
+ return SymbolVisibility_VISIBILITY_UNSET
+}
+
// Describes a value within an enum.
type EnumValueDescriptorProto struct {
state protoimpl.MessageState `protogen:"open.v1"`
@@ -3392,17 +3555,18 @@ func (x *UninterpretedOption) GetAggregateValue() string {
// be designed and implemented to handle this, hopefully before we ever hit a
// conflict here.
type FeatureSet struct {
- state protoimpl.MessageState `protogen:"open.v1"`
- FieldPresence *FeatureSet_FieldPresence `protobuf:"varint,1,opt,name=field_presence,json=fieldPresence,enum=google.protobuf.FeatureSet_FieldPresence" json:"field_presence,omitempty"`
- EnumType *FeatureSet_EnumType `protobuf:"varint,2,opt,name=enum_type,json=enumType,enum=google.protobuf.FeatureSet_EnumType" json:"enum_type,omitempty"`
- RepeatedFieldEncoding *FeatureSet_RepeatedFieldEncoding `protobuf:"varint,3,opt,name=repeated_field_encoding,json=repeatedFieldEncoding,enum=google.protobuf.FeatureSet_RepeatedFieldEncoding" json:"repeated_field_encoding,omitempty"`
- Utf8Validation *FeatureSet_Utf8Validation `protobuf:"varint,4,opt,name=utf8_validation,json=utf8Validation,enum=google.protobuf.FeatureSet_Utf8Validation" json:"utf8_validation,omitempty"`
- MessageEncoding *FeatureSet_MessageEncoding `protobuf:"varint,5,opt,name=message_encoding,json=messageEncoding,enum=google.protobuf.FeatureSet_MessageEncoding" json:"message_encoding,omitempty"`
- JsonFormat *FeatureSet_JsonFormat `protobuf:"varint,6,opt,name=json_format,json=jsonFormat,enum=google.protobuf.FeatureSet_JsonFormat" json:"json_format,omitempty"`
- EnforceNamingStyle *FeatureSet_EnforceNamingStyle `protobuf:"varint,7,opt,name=enforce_naming_style,json=enforceNamingStyle,enum=google.protobuf.FeatureSet_EnforceNamingStyle" json:"enforce_naming_style,omitempty"`
- extensionFields protoimpl.ExtensionFields
- unknownFields protoimpl.UnknownFields
- sizeCache protoimpl.SizeCache
+ state protoimpl.MessageState `protogen:"open.v1"`
+ FieldPresence *FeatureSet_FieldPresence `protobuf:"varint,1,opt,name=field_presence,json=fieldPresence,enum=google.protobuf.FeatureSet_FieldPresence" json:"field_presence,omitempty"`
+ EnumType *FeatureSet_EnumType `protobuf:"varint,2,opt,name=enum_type,json=enumType,enum=google.protobuf.FeatureSet_EnumType" json:"enum_type,omitempty"`
+ RepeatedFieldEncoding *FeatureSet_RepeatedFieldEncoding `protobuf:"varint,3,opt,name=repeated_field_encoding,json=repeatedFieldEncoding,enum=google.protobuf.FeatureSet_RepeatedFieldEncoding" json:"repeated_field_encoding,omitempty"`
+ Utf8Validation *FeatureSet_Utf8Validation `protobuf:"varint,4,opt,name=utf8_validation,json=utf8Validation,enum=google.protobuf.FeatureSet_Utf8Validation" json:"utf8_validation,omitempty"`
+ MessageEncoding *FeatureSet_MessageEncoding `protobuf:"varint,5,opt,name=message_encoding,json=messageEncoding,enum=google.protobuf.FeatureSet_MessageEncoding" json:"message_encoding,omitempty"`
+ JsonFormat *FeatureSet_JsonFormat `protobuf:"varint,6,opt,name=json_format,json=jsonFormat,enum=google.protobuf.FeatureSet_JsonFormat" json:"json_format,omitempty"`
+ EnforceNamingStyle *FeatureSet_EnforceNamingStyle `protobuf:"varint,7,opt,name=enforce_naming_style,json=enforceNamingStyle,enum=google.protobuf.FeatureSet_EnforceNamingStyle" json:"enforce_naming_style,omitempty"`
+ DefaultSymbolVisibility *FeatureSet_VisibilityFeature_DefaultSymbolVisibility `protobuf:"varint,8,opt,name=default_symbol_visibility,json=defaultSymbolVisibility,enum=google.protobuf.FeatureSet_VisibilityFeature_DefaultSymbolVisibility" json:"default_symbol_visibility,omitempty"`
+ extensionFields protoimpl.ExtensionFields
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
}
func (x *FeatureSet) Reset() {
@@ -3484,6 +3648,13 @@ func (x *FeatureSet) GetEnforceNamingStyle() FeatureSet_EnforceNamingStyle {
return FeatureSet_ENFORCE_NAMING_STYLE_UNKNOWN
}
+func (x *FeatureSet) GetDefaultSymbolVisibility() FeatureSet_VisibilityFeature_DefaultSymbolVisibility {
+ if x != nil && x.DefaultSymbolVisibility != nil {
+ return *x.DefaultSymbolVisibility
+ }
+ return FeatureSet_VisibilityFeature_DEFAULT_SYMBOL_VISIBILITY_UNKNOWN
+}
+
// A compiled specification for the defaults of a set of features. These
// messages are generated from FeatureSet extensions and can be used to seed
// feature resolution. The resolution with this object becomes a simple search
@@ -4144,6 +4315,42 @@ func (x *UninterpretedOption_NamePart) GetIsExtension() bool {
return false
}
+type FeatureSet_VisibilityFeature struct {
+ state protoimpl.MessageState `protogen:"open.v1"`
+ unknownFields protoimpl.UnknownFields
+ sizeCache protoimpl.SizeCache
+}
+
+func (x *FeatureSet_VisibilityFeature) Reset() {
+ *x = FeatureSet_VisibilityFeature{}
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[30]
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ ms.StoreMessageInfo(mi)
+}
+
+func (x *FeatureSet_VisibilityFeature) String() string {
+ return protoimpl.X.MessageStringOf(x)
+}
+
+func (*FeatureSet_VisibilityFeature) ProtoMessage() {}
+
+func (x *FeatureSet_VisibilityFeature) ProtoReflect() protoreflect.Message {
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[30]
+ if x != nil {
+ ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+ if ms.LoadMessageInfo() == nil {
+ ms.StoreMessageInfo(mi)
+ }
+ return ms
+ }
+ return mi.MessageOf(x)
+}
+
+// Deprecated: Use FeatureSet_VisibilityFeature.ProtoReflect.Descriptor instead.
+func (*FeatureSet_VisibilityFeature) Descriptor() ([]byte, []int) {
+ return file_google_protobuf_descriptor_proto_rawDescGZIP(), []int{19, 0}
+}
+
// A map from every known edition with a unique set of defaults to its
// defaults. Not all editions may be contained here. For a given edition,
// the defaults at the closest matching edition ordered at or before it should
@@ -4161,7 +4368,7 @@ type FeatureSetDefaults_FeatureSetEditionDefault struct {
func (x *FeatureSetDefaults_FeatureSetEditionDefault) Reset() {
*x = FeatureSetDefaults_FeatureSetEditionDefault{}
- mi := &file_google_protobuf_descriptor_proto_msgTypes[30]
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[31]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -4173,7 +4380,7 @@ func (x *FeatureSetDefaults_FeatureSetEditionDefault) String() string {
func (*FeatureSetDefaults_FeatureSetEditionDefault) ProtoMessage() {}
func (x *FeatureSetDefaults_FeatureSetEditionDefault) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[30]
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[31]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -4309,7 +4516,7 @@ type SourceCodeInfo_Location struct {
func (x *SourceCodeInfo_Location) Reset() {
*x = SourceCodeInfo_Location{}
- mi := &file_google_protobuf_descriptor_proto_msgTypes[31]
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[32]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -4321,7 +4528,7 @@ func (x *SourceCodeInfo_Location) String() string {
func (*SourceCodeInfo_Location) ProtoMessage() {}
func (x *SourceCodeInfo_Location) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[31]
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[32]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -4393,7 +4600,7 @@ type GeneratedCodeInfo_Annotation struct {
func (x *GeneratedCodeInfo_Annotation) Reset() {
*x = GeneratedCodeInfo_Annotation{}
- mi := &file_google_protobuf_descriptor_proto_msgTypes[32]
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[33]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
@@ -4405,7 +4612,7 @@ func (x *GeneratedCodeInfo_Annotation) String() string {
func (*GeneratedCodeInfo_Annotation) ProtoMessage() {}
func (x *GeneratedCodeInfo_Annotation) ProtoReflect() protoreflect.Message {
- mi := &file_google_protobuf_descriptor_proto_msgTypes[32]
+ mi := &file_google_protobuf_descriptor_proto_msgTypes[33]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
@@ -4462,7 +4669,7 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\n" +
" google/protobuf/descriptor.proto\x12\x0fgoogle.protobuf\"[\n" +
"\x11FileDescriptorSet\x128\n" +
- "\x04file\x18\x01 \x03(\v2$.google.protobuf.FileDescriptorProtoR\x04file*\f\b\x80\xec\xca\xff\x01\x10\x81\xec\xca\xff\x01\"\x98\x05\n" +
+ "\x04file\x18\x01 \x03(\v2$.google.protobuf.FileDescriptorProtoR\x04file*\f\b\x80\xec\xca\xff\x01\x10\x81\xec\xca\xff\x01\"\xc5\x05\n" +
"\x13FileDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n" +
"\apackage\x18\x02 \x01(\tR\apackage\x12\x1e\n" +
@@ -4471,7 +4678,8 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"dependency\x12+\n" +
"\x11public_dependency\x18\n" +
" \x03(\x05R\x10publicDependency\x12'\n" +
- "\x0fweak_dependency\x18\v \x03(\x05R\x0eweakDependency\x12C\n" +
+ "\x0fweak_dependency\x18\v \x03(\x05R\x0eweakDependency\x12+\n" +
+ "\x11option_dependency\x18\x0f \x03(\tR\x10optionDependency\x12C\n" +
"\fmessage_type\x18\x04 \x03(\v2 .google.protobuf.DescriptorProtoR\vmessageType\x12A\n" +
"\tenum_type\x18\x05 \x03(\v2$.google.protobuf.EnumDescriptorProtoR\benumType\x12A\n" +
"\aservice\x18\x06 \x03(\v2'.google.protobuf.ServiceDescriptorProtoR\aservice\x12C\n" +
@@ -4479,7 +4687,7 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\aoptions\x18\b \x01(\v2\x1c.google.protobuf.FileOptionsR\aoptions\x12I\n" +
"\x10source_code_info\x18\t \x01(\v2\x1f.google.protobuf.SourceCodeInfoR\x0esourceCodeInfo\x12\x16\n" +
"\x06syntax\x18\f \x01(\tR\x06syntax\x122\n" +
- "\aedition\x18\x0e \x01(\x0e2\x18.google.protobuf.EditionR\aedition\"\xb9\x06\n" +
+ "\aedition\x18\x0e \x01(\x0e2\x18.google.protobuf.EditionR\aedition\"\xfc\x06\n" +
"\x0fDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12;\n" +
"\x05field\x18\x02 \x03(\v2%.google.protobuf.FieldDescriptorProtoR\x05field\x12C\n" +
@@ -4493,7 +4701,10 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\aoptions\x18\a \x01(\v2\x1f.google.protobuf.MessageOptionsR\aoptions\x12U\n" +
"\x0ereserved_range\x18\t \x03(\v2..google.protobuf.DescriptorProto.ReservedRangeR\rreservedRange\x12#\n" +
"\rreserved_name\x18\n" +
- " \x03(\tR\freservedName\x1az\n" +
+ " \x03(\tR\freservedName\x12A\n" +
+ "\n" +
+ "visibility\x18\v \x01(\x0e2!.google.protobuf.SymbolVisibilityR\n" +
+ "visibility\x1az\n" +
"\x0eExtensionRange\x12\x14\n" +
"\x05start\x18\x01 \x01(\x05R\x05start\x12\x10\n" +
"\x03end\x18\x02 \x01(\x05R\x03end\x12@\n" +
@@ -4562,13 +4773,16 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\x0eLABEL_REQUIRED\x10\x02\"c\n" +
"\x14OneofDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x127\n" +
- "\aoptions\x18\x02 \x01(\v2\x1d.google.protobuf.OneofOptionsR\aoptions\"\xe3\x02\n" +
+ "\aoptions\x18\x02 \x01(\v2\x1d.google.protobuf.OneofOptionsR\aoptions\"\xa6\x03\n" +
"\x13EnumDescriptorProto\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12?\n" +
"\x05value\x18\x02 \x03(\v2).google.protobuf.EnumValueDescriptorProtoR\x05value\x126\n" +
"\aoptions\x18\x03 \x01(\v2\x1c.google.protobuf.EnumOptionsR\aoptions\x12]\n" +
"\x0ereserved_range\x18\x04 \x03(\v26.google.protobuf.EnumDescriptorProto.EnumReservedRangeR\rreservedRange\x12#\n" +
- "\rreserved_name\x18\x05 \x03(\tR\freservedName\x1a;\n" +
+ "\rreserved_name\x18\x05 \x03(\tR\freservedName\x12A\n" +
+ "\n" +
+ "visibility\x18\x06 \x01(\x0e2!.google.protobuf.SymbolVisibilityR\n" +
+ "visibility\x1a;\n" +
"\x11EnumReservedRange\x12\x14\n" +
"\x05start\x18\x01 \x01(\x05R\x05start\x12\x10\n" +
"\x03end\x18\x02 \x01(\x05R\x03end\"\x83\x01\n" +
@@ -4728,7 +4942,7 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\x0faggregate_value\x18\b \x01(\tR\x0eaggregateValue\x1aJ\n" +
"\bNamePart\x12\x1b\n" +
"\tname_part\x18\x01 \x02(\tR\bnamePart\x12!\n" +
- "\fis_extension\x18\x02 \x02(\bR\visExtension\"\xae\f\n" +
+ "\fis_extension\x18\x02 \x02(\bR\visExtension\"\x8e\x0f\n" +
"\n" +
"FeatureSet\x12\x91\x01\n" +
"\x0efield_presence\x18\x01 \x01(\x0e2).google.protobuf.FeatureSet.FieldPresenceB?\x88\x01\x01\x98\x01\x04\x98\x01\x01\xa2\x01\r\x12\bEXPLICIT\x18\x84\a\xa2\x01\r\x12\bIMPLICIT\x18\xe7\a\xa2\x01\r\x12\bEXPLICIT\x18\xe8\a\xb2\x01\x03\b\xe8\aR\rfieldPresence\x12l\n" +
@@ -4739,7 +4953,18 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\vjson_format\x18\x06 \x01(\x0e2&.google.protobuf.FeatureSet.JsonFormatB9\x88\x01\x01\x98\x01\x03\x98\x01\x06\x98\x01\x01\xa2\x01\x17\x12\x12LEGACY_BEST_EFFORT\x18\x84\a\xa2\x01\n" +
"\x12\x05ALLOW\x18\xe7\a\xb2\x01\x03\b\xe8\aR\n" +
"jsonFormat\x12\xab\x01\n" +
- "\x14enforce_naming_style\x18\a \x01(\x0e2..google.protobuf.FeatureSet.EnforceNamingStyleBI\x88\x01\x02\x98\x01\x01\x98\x01\x02\x98\x01\x03\x98\x01\x04\x98\x01\x05\x98\x01\x06\x98\x01\a\x98\x01\b\x98\x01\t\xa2\x01\x11\x12\fSTYLE_LEGACY\x18\x84\a\xa2\x01\x0e\x12\tSTYLE2024\x18\xe9\a\xb2\x01\x03\b\xe9\aR\x12enforceNamingStyle\"\\\n" +
+ "\x14enforce_naming_style\x18\a \x01(\x0e2..google.protobuf.FeatureSet.EnforceNamingStyleBI\x88\x01\x02\x98\x01\x01\x98\x01\x02\x98\x01\x03\x98\x01\x04\x98\x01\x05\x98\x01\x06\x98\x01\a\x98\x01\b\x98\x01\t\xa2\x01\x11\x12\fSTYLE_LEGACY\x18\x84\a\xa2\x01\x0e\x12\tSTYLE2024\x18\xe9\a\xb2\x01\x03\b\xe9\aR\x12enforceNamingStyle\x12\xb9\x01\n" +
+ "\x19default_symbol_visibility\x18\b \x01(\x0e2E.google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibilityB6\x88\x01\x02\x98\x01\x01\xa2\x01\x0f\x12\n" +
+ "EXPORT_ALL\x18\x84\a\xa2\x01\x15\x12\x10EXPORT_TOP_LEVEL\x18\xe9\a\xb2\x01\x03\b\xe9\aR\x17defaultSymbolVisibility\x1a\xa1\x01\n" +
+ "\x11VisibilityFeature\"\x81\x01\n" +
+ "\x17DefaultSymbolVisibility\x12%\n" +
+ "!DEFAULT_SYMBOL_VISIBILITY_UNKNOWN\x10\x00\x12\x0e\n" +
+ "\n" +
+ "EXPORT_ALL\x10\x01\x12\x14\n" +
+ "\x10EXPORT_TOP_LEVEL\x10\x02\x12\r\n" +
+ "\tLOCAL_ALL\x10\x03\x12\n" +
+ "\n" +
+ "\x06STRICT\x10\x04J\b\b\x01\x10\x80\x80\x80\x80\x02\"\\\n" +
"\rFieldPresence\x12\x1a\n" +
"\x16FIELD_PRESENCE_UNKNOWN\x10\x00\x12\f\n" +
"\bEXPLICIT\x10\x01\x12\f\n" +
@@ -4817,7 +5042,11 @@ const file_google_protobuf_descriptor_proto_rawDesc = "" +
"\x17EDITION_99997_TEST_ONLY\x10\x9d\x8d\x06\x12\x1d\n" +
"\x17EDITION_99998_TEST_ONLY\x10\x9e\x8d\x06\x12\x1d\n" +
"\x17EDITION_99999_TEST_ONLY\x10\x9f\x8d\x06\x12\x13\n" +
- "\vEDITION_MAX\x10\xff\xff\xff\xff\aB~\n" +
+ "\vEDITION_MAX\x10\xff\xff\xff\xff\a*U\n" +
+ "\x10SymbolVisibility\x12\x14\n" +
+ "\x10VISIBILITY_UNSET\x10\x00\x12\x14\n" +
+ "\x10VISIBILITY_LOCAL\x10\x01\x12\x15\n" +
+ "\x11VISIBILITY_EXPORT\x10\x02B~\n" +
"\x13com.google.protobufB\x10DescriptorProtosH\x01Z-google.golang.org/protobuf/types/descriptorpb\xf8\x01\x01\xa2\x02\x03GPB\xaa\x02\x1aGoogle.Protobuf.Reflection"
var (
@@ -4832,145 +5061,151 @@ func file_google_protobuf_descriptor_proto_rawDescGZIP() []byte {
return file_google_protobuf_descriptor_proto_rawDescData
}
-var file_google_protobuf_descriptor_proto_enumTypes = make([]protoimpl.EnumInfo, 18)
-var file_google_protobuf_descriptor_proto_msgTypes = make([]protoimpl.MessageInfo, 33)
+var file_google_protobuf_descriptor_proto_enumTypes = make([]protoimpl.EnumInfo, 20)
+var file_google_protobuf_descriptor_proto_msgTypes = make([]protoimpl.MessageInfo, 34)
var file_google_protobuf_descriptor_proto_goTypes = []any{
- (Edition)(0), // 0: google.protobuf.Edition
- (ExtensionRangeOptions_VerificationState)(0), // 1: google.protobuf.ExtensionRangeOptions.VerificationState
- (FieldDescriptorProto_Type)(0), // 2: google.protobuf.FieldDescriptorProto.Type
- (FieldDescriptorProto_Label)(0), // 3: google.protobuf.FieldDescriptorProto.Label
- (FileOptions_OptimizeMode)(0), // 4: google.protobuf.FileOptions.OptimizeMode
- (FieldOptions_CType)(0), // 5: google.protobuf.FieldOptions.CType
- (FieldOptions_JSType)(0), // 6: google.protobuf.FieldOptions.JSType
- (FieldOptions_OptionRetention)(0), // 7: google.protobuf.FieldOptions.OptionRetention
- (FieldOptions_OptionTargetType)(0), // 8: google.protobuf.FieldOptions.OptionTargetType
- (MethodOptions_IdempotencyLevel)(0), // 9: google.protobuf.MethodOptions.IdempotencyLevel
- (FeatureSet_FieldPresence)(0), // 10: google.protobuf.FeatureSet.FieldPresence
- (FeatureSet_EnumType)(0), // 11: google.protobuf.FeatureSet.EnumType
- (FeatureSet_RepeatedFieldEncoding)(0), // 12: google.protobuf.FeatureSet.RepeatedFieldEncoding
- (FeatureSet_Utf8Validation)(0), // 13: google.protobuf.FeatureSet.Utf8Validation
- (FeatureSet_MessageEncoding)(0), // 14: google.protobuf.FeatureSet.MessageEncoding
- (FeatureSet_JsonFormat)(0), // 15: google.protobuf.FeatureSet.JsonFormat
- (FeatureSet_EnforceNamingStyle)(0), // 16: google.protobuf.FeatureSet.EnforceNamingStyle
- (GeneratedCodeInfo_Annotation_Semantic)(0), // 17: google.protobuf.GeneratedCodeInfo.Annotation.Semantic
- (*FileDescriptorSet)(nil), // 18: google.protobuf.FileDescriptorSet
- (*FileDescriptorProto)(nil), // 19: google.protobuf.FileDescriptorProto
- (*DescriptorProto)(nil), // 20: google.protobuf.DescriptorProto
- (*ExtensionRangeOptions)(nil), // 21: google.protobuf.ExtensionRangeOptions
- (*FieldDescriptorProto)(nil), // 22: google.protobuf.FieldDescriptorProto
- (*OneofDescriptorProto)(nil), // 23: google.protobuf.OneofDescriptorProto
- (*EnumDescriptorProto)(nil), // 24: google.protobuf.EnumDescriptorProto
- (*EnumValueDescriptorProto)(nil), // 25: google.protobuf.EnumValueDescriptorProto
- (*ServiceDescriptorProto)(nil), // 26: google.protobuf.ServiceDescriptorProto
- (*MethodDescriptorProto)(nil), // 27: google.protobuf.MethodDescriptorProto
- (*FileOptions)(nil), // 28: google.protobuf.FileOptions
- (*MessageOptions)(nil), // 29: google.protobuf.MessageOptions
- (*FieldOptions)(nil), // 30: google.protobuf.FieldOptions
- (*OneofOptions)(nil), // 31: google.protobuf.OneofOptions
- (*EnumOptions)(nil), // 32: google.protobuf.EnumOptions
- (*EnumValueOptions)(nil), // 33: google.protobuf.EnumValueOptions
- (*ServiceOptions)(nil), // 34: google.protobuf.ServiceOptions
- (*MethodOptions)(nil), // 35: google.protobuf.MethodOptions
- (*UninterpretedOption)(nil), // 36: google.protobuf.UninterpretedOption
- (*FeatureSet)(nil), // 37: google.protobuf.FeatureSet
- (*FeatureSetDefaults)(nil), // 38: google.protobuf.FeatureSetDefaults
- (*SourceCodeInfo)(nil), // 39: google.protobuf.SourceCodeInfo
- (*GeneratedCodeInfo)(nil), // 40: google.protobuf.GeneratedCodeInfo
- (*DescriptorProto_ExtensionRange)(nil), // 41: google.protobuf.DescriptorProto.ExtensionRange
- (*DescriptorProto_ReservedRange)(nil), // 42: google.protobuf.DescriptorProto.ReservedRange
- (*ExtensionRangeOptions_Declaration)(nil), // 43: google.protobuf.ExtensionRangeOptions.Declaration
- (*EnumDescriptorProto_EnumReservedRange)(nil), // 44: google.protobuf.EnumDescriptorProto.EnumReservedRange
- (*FieldOptions_EditionDefault)(nil), // 45: google.protobuf.FieldOptions.EditionDefault
- (*FieldOptions_FeatureSupport)(nil), // 46: google.protobuf.FieldOptions.FeatureSupport
- (*UninterpretedOption_NamePart)(nil), // 47: google.protobuf.UninterpretedOption.NamePart
- (*FeatureSetDefaults_FeatureSetEditionDefault)(nil), // 48: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault
- (*SourceCodeInfo_Location)(nil), // 49: google.protobuf.SourceCodeInfo.Location
- (*GeneratedCodeInfo_Annotation)(nil), // 50: google.protobuf.GeneratedCodeInfo.Annotation
+ (Edition)(0), // 0: google.protobuf.Edition
+ (SymbolVisibility)(0), // 1: google.protobuf.SymbolVisibility
+ (ExtensionRangeOptions_VerificationState)(0), // 2: google.protobuf.ExtensionRangeOptions.VerificationState
+ (FieldDescriptorProto_Type)(0), // 3: google.protobuf.FieldDescriptorProto.Type
+ (FieldDescriptorProto_Label)(0), // 4: google.protobuf.FieldDescriptorProto.Label
+ (FileOptions_OptimizeMode)(0), // 5: google.protobuf.FileOptions.OptimizeMode
+ (FieldOptions_CType)(0), // 6: google.protobuf.FieldOptions.CType
+ (FieldOptions_JSType)(0), // 7: google.protobuf.FieldOptions.JSType
+ (FieldOptions_OptionRetention)(0), // 8: google.protobuf.FieldOptions.OptionRetention
+ (FieldOptions_OptionTargetType)(0), // 9: google.protobuf.FieldOptions.OptionTargetType
+ (MethodOptions_IdempotencyLevel)(0), // 10: google.protobuf.MethodOptions.IdempotencyLevel
+ (FeatureSet_FieldPresence)(0), // 11: google.protobuf.FeatureSet.FieldPresence
+ (FeatureSet_EnumType)(0), // 12: google.protobuf.FeatureSet.EnumType
+ (FeatureSet_RepeatedFieldEncoding)(0), // 13: google.protobuf.FeatureSet.RepeatedFieldEncoding
+ (FeatureSet_Utf8Validation)(0), // 14: google.protobuf.FeatureSet.Utf8Validation
+ (FeatureSet_MessageEncoding)(0), // 15: google.protobuf.FeatureSet.MessageEncoding
+ (FeatureSet_JsonFormat)(0), // 16: google.protobuf.FeatureSet.JsonFormat
+ (FeatureSet_EnforceNamingStyle)(0), // 17: google.protobuf.FeatureSet.EnforceNamingStyle
+ (FeatureSet_VisibilityFeature_DefaultSymbolVisibility)(0), // 18: google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility
+ (GeneratedCodeInfo_Annotation_Semantic)(0), // 19: google.protobuf.GeneratedCodeInfo.Annotation.Semantic
+ (*FileDescriptorSet)(nil), // 20: google.protobuf.FileDescriptorSet
+ (*FileDescriptorProto)(nil), // 21: google.protobuf.FileDescriptorProto
+ (*DescriptorProto)(nil), // 22: google.protobuf.DescriptorProto
+ (*ExtensionRangeOptions)(nil), // 23: google.protobuf.ExtensionRangeOptions
+ (*FieldDescriptorProto)(nil), // 24: google.protobuf.FieldDescriptorProto
+ (*OneofDescriptorProto)(nil), // 25: google.protobuf.OneofDescriptorProto
+ (*EnumDescriptorProto)(nil), // 26: google.protobuf.EnumDescriptorProto
+ (*EnumValueDescriptorProto)(nil), // 27: google.protobuf.EnumValueDescriptorProto
+ (*ServiceDescriptorProto)(nil), // 28: google.protobuf.ServiceDescriptorProto
+ (*MethodDescriptorProto)(nil), // 29: google.protobuf.MethodDescriptorProto
+ (*FileOptions)(nil), // 30: google.protobuf.FileOptions
+ (*MessageOptions)(nil), // 31: google.protobuf.MessageOptions
+ (*FieldOptions)(nil), // 32: google.protobuf.FieldOptions
+ (*OneofOptions)(nil), // 33: google.protobuf.OneofOptions
+ (*EnumOptions)(nil), // 34: google.protobuf.EnumOptions
+ (*EnumValueOptions)(nil), // 35: google.protobuf.EnumValueOptions
+ (*ServiceOptions)(nil), // 36: google.protobuf.ServiceOptions
+ (*MethodOptions)(nil), // 37: google.protobuf.MethodOptions
+ (*UninterpretedOption)(nil), // 38: google.protobuf.UninterpretedOption
+ (*FeatureSet)(nil), // 39: google.protobuf.FeatureSet
+ (*FeatureSetDefaults)(nil), // 40: google.protobuf.FeatureSetDefaults
+ (*SourceCodeInfo)(nil), // 41: google.protobuf.SourceCodeInfo
+ (*GeneratedCodeInfo)(nil), // 42: google.protobuf.GeneratedCodeInfo
+ (*DescriptorProto_ExtensionRange)(nil), // 43: google.protobuf.DescriptorProto.ExtensionRange
+ (*DescriptorProto_ReservedRange)(nil), // 44: google.protobuf.DescriptorProto.ReservedRange
+ (*ExtensionRangeOptions_Declaration)(nil), // 45: google.protobuf.ExtensionRangeOptions.Declaration
+ (*EnumDescriptorProto_EnumReservedRange)(nil), // 46: google.protobuf.EnumDescriptorProto.EnumReservedRange
+ (*FieldOptions_EditionDefault)(nil), // 47: google.protobuf.FieldOptions.EditionDefault
+ (*FieldOptions_FeatureSupport)(nil), // 48: google.protobuf.FieldOptions.FeatureSupport
+ (*UninterpretedOption_NamePart)(nil), // 49: google.protobuf.UninterpretedOption.NamePart
+ (*FeatureSet_VisibilityFeature)(nil), // 50: google.protobuf.FeatureSet.VisibilityFeature
+ (*FeatureSetDefaults_FeatureSetEditionDefault)(nil), // 51: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault
+ (*SourceCodeInfo_Location)(nil), // 52: google.protobuf.SourceCodeInfo.Location
+ (*GeneratedCodeInfo_Annotation)(nil), // 53: google.protobuf.GeneratedCodeInfo.Annotation
}
var file_google_protobuf_descriptor_proto_depIdxs = []int32{
- 19, // 0: google.protobuf.FileDescriptorSet.file:type_name -> google.protobuf.FileDescriptorProto
- 20, // 1: google.protobuf.FileDescriptorProto.message_type:type_name -> google.protobuf.DescriptorProto
- 24, // 2: google.protobuf.FileDescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto
- 26, // 3: google.protobuf.FileDescriptorProto.service:type_name -> google.protobuf.ServiceDescriptorProto
- 22, // 4: google.protobuf.FileDescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto
- 28, // 5: google.protobuf.FileDescriptorProto.options:type_name -> google.protobuf.FileOptions
- 39, // 6: google.protobuf.FileDescriptorProto.source_code_info:type_name -> google.protobuf.SourceCodeInfo
+ 21, // 0: google.protobuf.FileDescriptorSet.file:type_name -> google.protobuf.FileDescriptorProto
+ 22, // 1: google.protobuf.FileDescriptorProto.message_type:type_name -> google.protobuf.DescriptorProto
+ 26, // 2: google.protobuf.FileDescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto
+ 28, // 3: google.protobuf.FileDescriptorProto.service:type_name -> google.protobuf.ServiceDescriptorProto
+ 24, // 4: google.protobuf.FileDescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto
+ 30, // 5: google.protobuf.FileDescriptorProto.options:type_name -> google.protobuf.FileOptions
+ 41, // 6: google.protobuf.FileDescriptorProto.source_code_info:type_name -> google.protobuf.SourceCodeInfo
0, // 7: google.protobuf.FileDescriptorProto.edition:type_name -> google.protobuf.Edition
- 22, // 8: google.protobuf.DescriptorProto.field:type_name -> google.protobuf.FieldDescriptorProto
- 22, // 9: google.protobuf.DescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto
- 20, // 10: google.protobuf.DescriptorProto.nested_type:type_name -> google.protobuf.DescriptorProto
- 24, // 11: google.protobuf.DescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto
- 41, // 12: google.protobuf.DescriptorProto.extension_range:type_name -> google.protobuf.DescriptorProto.ExtensionRange
- 23, // 13: google.protobuf.DescriptorProto.oneof_decl:type_name -> google.protobuf.OneofDescriptorProto
- 29, // 14: google.protobuf.DescriptorProto.options:type_name -> google.protobuf.MessageOptions
- 42, // 15: google.protobuf.DescriptorProto.reserved_range:type_name -> google.protobuf.DescriptorProto.ReservedRange
- 36, // 16: google.protobuf.ExtensionRangeOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 43, // 17: google.protobuf.ExtensionRangeOptions.declaration:type_name -> google.protobuf.ExtensionRangeOptions.Declaration
- 37, // 18: google.protobuf.ExtensionRangeOptions.features:type_name -> google.protobuf.FeatureSet
- 1, // 19: google.protobuf.ExtensionRangeOptions.verification:type_name -> google.protobuf.ExtensionRangeOptions.VerificationState
- 3, // 20: google.protobuf.FieldDescriptorProto.label:type_name -> google.protobuf.FieldDescriptorProto.Label
- 2, // 21: google.protobuf.FieldDescriptorProto.type:type_name -> google.protobuf.FieldDescriptorProto.Type
- 30, // 22: google.protobuf.FieldDescriptorProto.options:type_name -> google.protobuf.FieldOptions
- 31, // 23: google.protobuf.OneofDescriptorProto.options:type_name -> google.protobuf.OneofOptions
- 25, // 24: google.protobuf.EnumDescriptorProto.value:type_name -> google.protobuf.EnumValueDescriptorProto
- 32, // 25: google.protobuf.EnumDescriptorProto.options:type_name -> google.protobuf.EnumOptions
- 44, // 26: google.protobuf.EnumDescriptorProto.reserved_range:type_name -> google.protobuf.EnumDescriptorProto.EnumReservedRange
- 33, // 27: google.protobuf.EnumValueDescriptorProto.options:type_name -> google.protobuf.EnumValueOptions
- 27, // 28: google.protobuf.ServiceDescriptorProto.method:type_name -> google.protobuf.MethodDescriptorProto
- 34, // 29: google.protobuf.ServiceDescriptorProto.options:type_name -> google.protobuf.ServiceOptions
- 35, // 30: google.protobuf.MethodDescriptorProto.options:type_name -> google.protobuf.MethodOptions
- 4, // 31: google.protobuf.FileOptions.optimize_for:type_name -> google.protobuf.FileOptions.OptimizeMode
- 37, // 32: google.protobuf.FileOptions.features:type_name -> google.protobuf.FeatureSet
- 36, // 33: google.protobuf.FileOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 37, // 34: google.protobuf.MessageOptions.features:type_name -> google.protobuf.FeatureSet
- 36, // 35: google.protobuf.MessageOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 5, // 36: google.protobuf.FieldOptions.ctype:type_name -> google.protobuf.FieldOptions.CType
- 6, // 37: google.protobuf.FieldOptions.jstype:type_name -> google.protobuf.FieldOptions.JSType
- 7, // 38: google.protobuf.FieldOptions.retention:type_name -> google.protobuf.FieldOptions.OptionRetention
- 8, // 39: google.protobuf.FieldOptions.targets:type_name -> google.protobuf.FieldOptions.OptionTargetType
- 45, // 40: google.protobuf.FieldOptions.edition_defaults:type_name -> google.protobuf.FieldOptions.EditionDefault
- 37, // 41: google.protobuf.FieldOptions.features:type_name -> google.protobuf.FeatureSet
- 46, // 42: google.protobuf.FieldOptions.feature_support:type_name -> google.protobuf.FieldOptions.FeatureSupport
- 36, // 43: google.protobuf.FieldOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 37, // 44: google.protobuf.OneofOptions.features:type_name -> google.protobuf.FeatureSet
- 36, // 45: google.protobuf.OneofOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 37, // 46: google.protobuf.EnumOptions.features:type_name -> google.protobuf.FeatureSet
- 36, // 47: google.protobuf.EnumOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 37, // 48: google.protobuf.EnumValueOptions.features:type_name -> google.protobuf.FeatureSet
- 46, // 49: google.protobuf.EnumValueOptions.feature_support:type_name -> google.protobuf.FieldOptions.FeatureSupport
- 36, // 50: google.protobuf.EnumValueOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 37, // 51: google.protobuf.ServiceOptions.features:type_name -> google.protobuf.FeatureSet
- 36, // 52: google.protobuf.ServiceOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 9, // 53: google.protobuf.MethodOptions.idempotency_level:type_name -> google.protobuf.MethodOptions.IdempotencyLevel
- 37, // 54: google.protobuf.MethodOptions.features:type_name -> google.protobuf.FeatureSet
- 36, // 55: google.protobuf.MethodOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
- 47, // 56: google.protobuf.UninterpretedOption.name:type_name -> google.protobuf.UninterpretedOption.NamePart
- 10, // 57: google.protobuf.FeatureSet.field_presence:type_name -> google.protobuf.FeatureSet.FieldPresence
- 11, // 58: google.protobuf.FeatureSet.enum_type:type_name -> google.protobuf.FeatureSet.EnumType
- 12, // 59: google.protobuf.FeatureSet.repeated_field_encoding:type_name -> google.protobuf.FeatureSet.RepeatedFieldEncoding
- 13, // 60: google.protobuf.FeatureSet.utf8_validation:type_name -> google.protobuf.FeatureSet.Utf8Validation
- 14, // 61: google.protobuf.FeatureSet.message_encoding:type_name -> google.protobuf.FeatureSet.MessageEncoding
- 15, // 62: google.protobuf.FeatureSet.json_format:type_name -> google.protobuf.FeatureSet.JsonFormat
- 16, // 63: google.protobuf.FeatureSet.enforce_naming_style:type_name -> google.protobuf.FeatureSet.EnforceNamingStyle
- 48, // 64: google.protobuf.FeatureSetDefaults.defaults:type_name -> google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault
- 0, // 65: google.protobuf.FeatureSetDefaults.minimum_edition:type_name -> google.protobuf.Edition
- 0, // 66: google.protobuf.FeatureSetDefaults.maximum_edition:type_name -> google.protobuf.Edition
- 49, // 67: google.protobuf.SourceCodeInfo.location:type_name -> google.protobuf.SourceCodeInfo.Location
- 50, // 68: google.protobuf.GeneratedCodeInfo.annotation:type_name -> google.protobuf.GeneratedCodeInfo.Annotation
- 21, // 69: google.protobuf.DescriptorProto.ExtensionRange.options:type_name -> google.protobuf.ExtensionRangeOptions
- 0, // 70: google.protobuf.FieldOptions.EditionDefault.edition:type_name -> google.protobuf.Edition
- 0, // 71: google.protobuf.FieldOptions.FeatureSupport.edition_introduced:type_name -> google.protobuf.Edition
- 0, // 72: google.protobuf.FieldOptions.FeatureSupport.edition_deprecated:type_name -> google.protobuf.Edition
- 0, // 73: google.protobuf.FieldOptions.FeatureSupport.edition_removed:type_name -> google.protobuf.Edition
- 0, // 74: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition:type_name -> google.protobuf.Edition
- 37, // 75: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.overridable_features:type_name -> google.protobuf.FeatureSet
- 37, // 76: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.fixed_features:type_name -> google.protobuf.FeatureSet
- 17, // 77: google.protobuf.GeneratedCodeInfo.Annotation.semantic:type_name -> google.protobuf.GeneratedCodeInfo.Annotation.Semantic
- 78, // [78:78] is the sub-list for method output_type
- 78, // [78:78] is the sub-list for method input_type
- 78, // [78:78] is the sub-list for extension type_name
- 78, // [78:78] is the sub-list for extension extendee
- 0, // [0:78] is the sub-list for field type_name
+ 24, // 8: google.protobuf.DescriptorProto.field:type_name -> google.protobuf.FieldDescriptorProto
+ 24, // 9: google.protobuf.DescriptorProto.extension:type_name -> google.protobuf.FieldDescriptorProto
+ 22, // 10: google.protobuf.DescriptorProto.nested_type:type_name -> google.protobuf.DescriptorProto
+ 26, // 11: google.protobuf.DescriptorProto.enum_type:type_name -> google.protobuf.EnumDescriptorProto
+ 43, // 12: google.protobuf.DescriptorProto.extension_range:type_name -> google.protobuf.DescriptorProto.ExtensionRange
+ 25, // 13: google.protobuf.DescriptorProto.oneof_decl:type_name -> google.protobuf.OneofDescriptorProto
+ 31, // 14: google.protobuf.DescriptorProto.options:type_name -> google.protobuf.MessageOptions
+ 44, // 15: google.protobuf.DescriptorProto.reserved_range:type_name -> google.protobuf.DescriptorProto.ReservedRange
+ 1, // 16: google.protobuf.DescriptorProto.visibility:type_name -> google.protobuf.SymbolVisibility
+ 38, // 17: google.protobuf.ExtensionRangeOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+ 45, // 18: google.protobuf.ExtensionRangeOptions.declaration:type_name -> google.protobuf.ExtensionRangeOptions.Declaration
+ 39, // 19: google.protobuf.ExtensionRangeOptions.features:type_name -> google.protobuf.FeatureSet
+ 2, // 20: google.protobuf.ExtensionRangeOptions.verification:type_name -> google.protobuf.ExtensionRangeOptions.VerificationState
+ 4, // 21: google.protobuf.FieldDescriptorProto.label:type_name -> google.protobuf.FieldDescriptorProto.Label
+ 3, // 22: google.protobuf.FieldDescriptorProto.type:type_name -> google.protobuf.FieldDescriptorProto.Type
+ 32, // 23: google.protobuf.FieldDescriptorProto.options:type_name -> google.protobuf.FieldOptions
+ 33, // 24: google.protobuf.OneofDescriptorProto.options:type_name -> google.protobuf.OneofOptions
+ 27, // 25: google.protobuf.EnumDescriptorProto.value:type_name -> google.protobuf.EnumValueDescriptorProto
+ 34, // 26: google.protobuf.EnumDescriptorProto.options:type_name -> google.protobuf.EnumOptions
+ 46, // 27: google.protobuf.EnumDescriptorProto.reserved_range:type_name -> google.protobuf.EnumDescriptorProto.EnumReservedRange
+ 1, // 28: google.protobuf.EnumDescriptorProto.visibility:type_name -> google.protobuf.SymbolVisibility
+ 35, // 29: google.protobuf.EnumValueDescriptorProto.options:type_name -> google.protobuf.EnumValueOptions
+ 29, // 30: google.protobuf.ServiceDescriptorProto.method:type_name -> google.protobuf.MethodDescriptorProto
+ 36, // 31: google.protobuf.ServiceDescriptorProto.options:type_name -> google.protobuf.ServiceOptions
+ 37, // 32: google.protobuf.MethodDescriptorProto.options:type_name -> google.protobuf.MethodOptions
+ 5, // 33: google.protobuf.FileOptions.optimize_for:type_name -> google.protobuf.FileOptions.OptimizeMode
+ 39, // 34: google.protobuf.FileOptions.features:type_name -> google.protobuf.FeatureSet
+ 38, // 35: google.protobuf.FileOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+ 39, // 36: google.protobuf.MessageOptions.features:type_name -> google.protobuf.FeatureSet
+ 38, // 37: google.protobuf.MessageOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+ 6, // 38: google.protobuf.FieldOptions.ctype:type_name -> google.protobuf.FieldOptions.CType
+ 7, // 39: google.protobuf.FieldOptions.jstype:type_name -> google.protobuf.FieldOptions.JSType
+ 8, // 40: google.protobuf.FieldOptions.retention:type_name -> google.protobuf.FieldOptions.OptionRetention
+ 9, // 41: google.protobuf.FieldOptions.targets:type_name -> google.protobuf.FieldOptions.OptionTargetType
+ 47, // 42: google.protobuf.FieldOptions.edition_defaults:type_name -> google.protobuf.FieldOptions.EditionDefault
+ 39, // 43: google.protobuf.FieldOptions.features:type_name -> google.protobuf.FeatureSet
+ 48, // 44: google.protobuf.FieldOptions.feature_support:type_name -> google.protobuf.FieldOptions.FeatureSupport
+ 38, // 45: google.protobuf.FieldOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+ 39, // 46: google.protobuf.OneofOptions.features:type_name -> google.protobuf.FeatureSet
+ 38, // 47: google.protobuf.OneofOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+ 39, // 48: google.protobuf.EnumOptions.features:type_name -> google.protobuf.FeatureSet
+ 38, // 49: google.protobuf.EnumOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+ 39, // 50: google.protobuf.EnumValueOptions.features:type_name -> google.protobuf.FeatureSet
+ 48, // 51: google.protobuf.EnumValueOptions.feature_support:type_name -> google.protobuf.FieldOptions.FeatureSupport
+ 38, // 52: google.protobuf.EnumValueOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+ 39, // 53: google.protobuf.ServiceOptions.features:type_name -> google.protobuf.FeatureSet
+ 38, // 54: google.protobuf.ServiceOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+ 10, // 55: google.protobuf.MethodOptions.idempotency_level:type_name -> google.protobuf.MethodOptions.IdempotencyLevel
+ 39, // 56: google.protobuf.MethodOptions.features:type_name -> google.protobuf.FeatureSet
+ 38, // 57: google.protobuf.MethodOptions.uninterpreted_option:type_name -> google.protobuf.UninterpretedOption
+ 49, // 58: google.protobuf.UninterpretedOption.name:type_name -> google.protobuf.UninterpretedOption.NamePart
+ 11, // 59: google.protobuf.FeatureSet.field_presence:type_name -> google.protobuf.FeatureSet.FieldPresence
+ 12, // 60: google.protobuf.FeatureSet.enum_type:type_name -> google.protobuf.FeatureSet.EnumType
+ 13, // 61: google.protobuf.FeatureSet.repeated_field_encoding:type_name -> google.protobuf.FeatureSet.RepeatedFieldEncoding
+ 14, // 62: google.protobuf.FeatureSet.utf8_validation:type_name -> google.protobuf.FeatureSet.Utf8Validation
+ 15, // 63: google.protobuf.FeatureSet.message_encoding:type_name -> google.protobuf.FeatureSet.MessageEncoding
+ 16, // 64: google.protobuf.FeatureSet.json_format:type_name -> google.protobuf.FeatureSet.JsonFormat
+ 17, // 65: google.protobuf.FeatureSet.enforce_naming_style:type_name -> google.protobuf.FeatureSet.EnforceNamingStyle
+ 18, // 66: google.protobuf.FeatureSet.default_symbol_visibility:type_name -> google.protobuf.FeatureSet.VisibilityFeature.DefaultSymbolVisibility
+ 51, // 67: google.protobuf.FeatureSetDefaults.defaults:type_name -> google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault
+ 0, // 68: google.protobuf.FeatureSetDefaults.minimum_edition:type_name -> google.protobuf.Edition
+ 0, // 69: google.protobuf.FeatureSetDefaults.maximum_edition:type_name -> google.protobuf.Edition
+ 52, // 70: google.protobuf.SourceCodeInfo.location:type_name -> google.protobuf.SourceCodeInfo.Location
+ 53, // 71: google.protobuf.GeneratedCodeInfo.annotation:type_name -> google.protobuf.GeneratedCodeInfo.Annotation
+ 23, // 72: google.protobuf.DescriptorProto.ExtensionRange.options:type_name -> google.protobuf.ExtensionRangeOptions
+ 0, // 73: google.protobuf.FieldOptions.EditionDefault.edition:type_name -> google.protobuf.Edition
+ 0, // 74: google.protobuf.FieldOptions.FeatureSupport.edition_introduced:type_name -> google.protobuf.Edition
+ 0, // 75: google.protobuf.FieldOptions.FeatureSupport.edition_deprecated:type_name -> google.protobuf.Edition
+ 0, // 76: google.protobuf.FieldOptions.FeatureSupport.edition_removed:type_name -> google.protobuf.Edition
+ 0, // 77: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.edition:type_name -> google.protobuf.Edition
+ 39, // 78: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.overridable_features:type_name -> google.protobuf.FeatureSet
+ 39, // 79: google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault.fixed_features:type_name -> google.protobuf.FeatureSet
+ 19, // 80: google.protobuf.GeneratedCodeInfo.Annotation.semantic:type_name -> google.protobuf.GeneratedCodeInfo.Annotation.Semantic
+ 81, // [81:81] is the sub-list for method output_type
+ 81, // [81:81] is the sub-list for method input_type
+ 81, // [81:81] is the sub-list for extension type_name
+ 81, // [81:81] is the sub-list for extension extendee
+ 0, // [0:81] is the sub-list for field type_name
}
func init() { file_google_protobuf_descriptor_proto_init() }
@@ -4983,8 +5218,8 @@ func file_google_protobuf_descriptor_proto_init() {
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_google_protobuf_descriptor_proto_rawDesc), len(file_google_protobuf_descriptor_proto_rawDesc)),
- NumEnums: 18,
- NumMessages: 33,
+ NumEnums: 20,
+ NumMessages: 34,
NumExtensions: 0,
NumServices: 0,
},
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 91c065b7..56771ce7 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -1,6 +1,9 @@
# github.com/IBM/csi-volume-group-operator v0.9.2
## explicit; go 1.23.1
github.com/IBM/csi-volume-group-operator/api/v1
+# github.com/Masterminds/semver/v3 v3.4.0
+## explicit; go 1.21
+github.com/Masterminds/semver/v3
# github.com/beorn7/perks v1.0.1
## explicit; go 1.11
github.com/beorn7/perks/quantile
@@ -113,7 +116,7 @@ github.com/modern-go/reflect2
# github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822
## explicit
github.com/munnerz/goautoneg
-# github.com/onsi/ginkgo/v2 v2.23.4
+# github.com/onsi/ginkgo/v2 v2.26.0
## explicit; go 1.23.0
github.com/onsi/ginkgo/v2
github.com/onsi/ginkgo/v2/config
@@ -132,10 +135,11 @@ github.com/onsi/ginkgo/v2/internal
github.com/onsi/ginkgo/v2/internal/global
github.com/onsi/ginkgo/v2/internal/interrupt_handler
github.com/onsi/ginkgo/v2/internal/parallel_support
+github.com/onsi/ginkgo/v2/internal/reporters
github.com/onsi/ginkgo/v2/internal/testingtproxy
github.com/onsi/ginkgo/v2/reporters
github.com/onsi/ginkgo/v2/types
-# github.com/onsi/gomega v1.38.0
+# github.com/onsi/gomega v1.38.2
## explicit; go 1.23.0
github.com/onsi/gomega
github.com/onsi/gomega/format
@@ -237,7 +241,13 @@ go.uber.org/zap/internal/exit
go.uber.org/zap/internal/pool
go.uber.org/zap/internal/stacktrace
go.uber.org/zap/zapcore
-# golang.org/x/net v0.41.0
+# go.yaml.in/yaml/v3 v3.0.4
+## explicit; go 1.16
+go.yaml.in/yaml/v3
+# golang.org/x/mod v0.27.0
+## explicit; go 1.23.0
+golang.org/x/mod/semver
+# golang.org/x/net v0.43.0
## explicit; go 1.23.0
golang.org/x/net/html
golang.org/x/net/html/atom
@@ -253,18 +263,18 @@ golang.org/x/net/trace
## explicit; go 1.23.0
golang.org/x/oauth2
golang.org/x/oauth2/internal
-# golang.org/x/sync v0.15.0
+# golang.org/x/sync v0.16.0
## explicit; go 1.23.0
golang.org/x/sync/errgroup
-# golang.org/x/sys v0.33.0
+# golang.org/x/sys v0.35.0
## explicit; go 1.23.0
golang.org/x/sys/plan9
golang.org/x/sys/unix
golang.org/x/sys/windows
-# golang.org/x/term v0.32.0
+# golang.org/x/term v0.34.0
## explicit; go 1.23.0
golang.org/x/term
-# golang.org/x/text v0.26.0
+# golang.org/x/text v0.28.0
## explicit; go 1.23.0
golang.org/x/text/encoding
golang.org/x/text/encoding/charmap
@@ -289,11 +299,28 @@ golang.org/x/text/unicode/norm
# golang.org/x/time v0.9.0
## explicit; go 1.18
golang.org/x/time/rate
-# golang.org/x/tools v0.33.0
+# golang.org/x/tools v0.36.0
## explicit; go 1.23.0
golang.org/x/tools/cover
+golang.org/x/tools/go/ast/edge
golang.org/x/tools/go/ast/inspector
-golang.org/x/tools/internal/astutil/edge
+golang.org/x/tools/go/gcexportdata
+golang.org/x/tools/go/packages
+golang.org/x/tools/go/types/objectpath
+golang.org/x/tools/go/types/typeutil
+golang.org/x/tools/internal/aliases
+golang.org/x/tools/internal/event
+golang.org/x/tools/internal/event/core
+golang.org/x/tools/internal/event/keys
+golang.org/x/tools/internal/event/label
+golang.org/x/tools/internal/gcimporter
+golang.org/x/tools/internal/gocommand
+golang.org/x/tools/internal/packagesinternal
+golang.org/x/tools/internal/pkgbits
+golang.org/x/tools/internal/stdlib
+golang.org/x/tools/internal/typeparams
+golang.org/x/tools/internal/typesinternal
+golang.org/x/tools/internal/versions
# gomodules.xyz/jsonpatch/v2 v2.4.0
## explicit; go 1.20
gomodules.xyz/jsonpatch/v2
@@ -362,7 +389,7 @@ google.golang.org/grpc/serviceconfig
google.golang.org/grpc/stats
google.golang.org/grpc/status
google.golang.org/grpc/tap
-# google.golang.org/protobuf v1.36.6
+# google.golang.org/protobuf v1.36.7
## explicit; go 1.22
google.golang.org/protobuf/encoding/protodelim
google.golang.org/protobuf/encoding/protojson