mleku/moxa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Drop go1.11

Browse Source
This commit is contained in:
Ludovic Fernandez
2019-10-01 14:40:05 +02:00
committed by Traefiker Bot
parent 4bf4aeecbb
commit 1cf327bd7d
182 changed files with 6 additions and 80572 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.golangci.toml
View File

@@ -41,10 +41,6 @@
max-same-issues = 0
exclude = []
[[issues.exclude-rules]]
path = "cmd/goexports/goexports.go"
text = "SA1019: importer.For is deprecated: use ForCompiler, which populates a FileSet with the positions of objects created by the importer."
[[issues.exclude-rules]]
path = "interp/.+_test\\.go"
linters = ["goconst"]

3
cmd/goexports/goexports.go
View File

@@ -26,6 +26,7 @@ import (
"go/constant"
"go/format"
"go/importer"
"go/token"
"go/types"
"io/ioutil"
"log"
@@ -114,7 +115,7 @@ type Wrap struct {
}
func genContent(dest, pkgName, license string) ([]byte, error) {
p, err := importer.For("source", nil).Import(pkgName)
p, err := importer.ForCompiler(token.NewFileSet(), "source", nil).Import(pkgName)
if err != nil {
return nil, err
}

2
go.mod
View File

@@ -1,3 +1,3 @@
module github.com/containous/yaegi
go 1.11
go 1.12

47
stdlib/go1_11_archive_tar.go
View File

@@ -1,47 +0,0 @@
// Code generated by 'goexports archive/tar'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"archive/tar"
"reflect"
)
func init() {
Symbols["archive/tar"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrFieldTooLong": reflect.ValueOf(&tar.ErrFieldTooLong).Elem(),
"ErrHeader": reflect.ValueOf(&tar.ErrHeader).Elem(),
"ErrWriteAfterClose": reflect.ValueOf(&tar.ErrWriteAfterClose).Elem(),
"ErrWriteTooLong": reflect.ValueOf(&tar.ErrWriteTooLong).Elem(),
"FileInfoHeader": reflect.ValueOf(tar.FileInfoHeader),
"FormatGNU": reflect.ValueOf(tar.FormatGNU),
"FormatPAX": reflect.ValueOf(tar.FormatPAX),
"FormatUSTAR": reflect.ValueOf(tar.FormatUSTAR),
"FormatUnknown": reflect.ValueOf(tar.FormatUnknown),
"NewReader": reflect.ValueOf(tar.NewReader),
"NewWriter": reflect.ValueOf(tar.NewWriter),
"TypeBlock": reflect.ValueOf(tar.TypeBlock),
"TypeChar": reflect.ValueOf(tar.TypeChar),
"TypeCont": reflect.ValueOf(tar.TypeCont),
"TypeDir": reflect.ValueOf(tar.TypeDir),
"TypeFifo": reflect.ValueOf(tar.TypeFifo),
"TypeGNULongLink": reflect.ValueOf(tar.TypeGNULongLink),
"TypeGNULongName": reflect.ValueOf(tar.TypeGNULongName),
"TypeGNUSparse": reflect.ValueOf(tar.TypeGNUSparse),
"TypeLink": reflect.ValueOf(tar.TypeLink),
"TypeReg": reflect.ValueOf(tar.TypeReg),
"TypeRegA": reflect.ValueOf(tar.TypeRegA),
"TypeSymlink": reflect.ValueOf(tar.TypeSymlink),
"TypeXGlobalHeader": reflect.ValueOf(tar.TypeXGlobalHeader),
"TypeXHeader": reflect.ValueOf(tar.TypeXHeader),
// type definitions
"Format": reflect.ValueOf((*tar.Format)(nil)),
"Header": reflect.ValueOf((*tar.Header)(nil)),
"Reader": reflect.ValueOf((*tar.Reader)(nil)),
"Writer": reflect.ValueOf((*tar.Writer)(nil)),
}
}

36
stdlib/go1_11_archive_zip.go
View File

@@ -1,36 +0,0 @@
// Code generated by 'goexports archive/zip'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"archive/zip"
"reflect"
)
func init() {
Symbols["archive/zip"] = map[string]reflect.Value{
// function, constant and variable definitions
"Deflate": reflect.ValueOf(zip.Deflate),
"ErrAlgorithm": reflect.ValueOf(&zip.ErrAlgorithm).Elem(),
"ErrChecksum": reflect.ValueOf(&zip.ErrChecksum).Elem(),
"ErrFormat": reflect.ValueOf(&zip.ErrFormat).Elem(),
"FileInfoHeader": reflect.ValueOf(zip.FileInfoHeader),
"NewReader": reflect.ValueOf(zip.NewReader),
"NewWriter": reflect.ValueOf(zip.NewWriter),
"OpenReader": reflect.ValueOf(zip.OpenReader),
"RegisterCompressor": reflect.ValueOf(zip.RegisterCompressor),
"RegisterDecompressor": reflect.ValueOf(zip.RegisterDecompressor),
"Store": reflect.ValueOf(zip.Store),
// type definitions
"Compressor": reflect.ValueOf((*zip.Compressor)(nil)),
"Decompressor": reflect.ValueOf((*zip.Decompressor)(nil)),
"File": reflect.ValueOf((*zip.File)(nil)),
"FileHeader": reflect.ValueOf((*zip.FileHeader)(nil)),
"ReadCloser": reflect.ValueOf((*zip.ReadCloser)(nil)),
"Reader": reflect.ValueOf((*zip.Reader)(nil)),
"Writer": reflect.ValueOf((*zip.Writer)(nil)),
}
}

42
stdlib/go1_11_bufio.go
View File

@@ -1,42 +0,0 @@
// Code generated by 'goexports bufio'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"bufio"
"reflect"
)
func init() {
Symbols["bufio"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrAdvanceTooFar": reflect.ValueOf(&bufio.ErrAdvanceTooFar).Elem(),
"ErrBufferFull": reflect.ValueOf(&bufio.ErrBufferFull).Elem(),
"ErrFinalToken": reflect.ValueOf(&bufio.ErrFinalToken).Elem(),
"ErrInvalidUnreadByte": reflect.ValueOf(&bufio.ErrInvalidUnreadByte).Elem(),
"ErrInvalidUnreadRune": reflect.ValueOf(&bufio.ErrInvalidUnreadRune).Elem(),
"ErrNegativeAdvance": reflect.ValueOf(&bufio.ErrNegativeAdvance).Elem(),
"ErrNegativeCount": reflect.ValueOf(&bufio.ErrNegativeCount).Elem(),
"ErrTooLong": reflect.ValueOf(&bufio.ErrTooLong).Elem(),
"MaxScanTokenSize": reflect.ValueOf(bufio.MaxScanTokenSize),
"NewReadWriter": reflect.ValueOf(bufio.NewReadWriter),
"NewReader": reflect.ValueOf(bufio.NewReader),
"NewReaderSize": reflect.ValueOf(bufio.NewReaderSize),
"NewScanner": reflect.ValueOf(bufio.NewScanner),
"NewWriter": reflect.ValueOf(bufio.NewWriter),
"NewWriterSize": reflect.ValueOf(bufio.NewWriterSize),
"ScanBytes": reflect.ValueOf(bufio.ScanBytes),
"ScanLines": reflect.ValueOf(bufio.ScanLines),
"ScanRunes": reflect.ValueOf(bufio.ScanRunes),
"ScanWords": reflect.ValueOf(bufio.ScanWords),
// type definitions
"ReadWriter": reflect.ValueOf((*bufio.ReadWriter)(nil)),
"Reader": reflect.ValueOf((*bufio.Reader)(nil)),
"Scanner": reflect.ValueOf((*bufio.Scanner)(nil)),
"SplitFunc": reflect.ValueOf((*bufio.SplitFunc)(nil)),
"Writer": reflect.ValueOf((*bufio.Writer)(nil)),
}
}

70
stdlib/go1_11_bytes.go
View File

@@ -1,70 +0,0 @@
// Code generated by 'goexports bytes'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"bytes"
"reflect"
)
func init() {
Symbols["bytes"] = map[string]reflect.Value{
// function, constant and variable definitions
"Compare": reflect.ValueOf(bytes.Compare),
"Contains": reflect.ValueOf(bytes.Contains),
"ContainsAny": reflect.ValueOf(bytes.ContainsAny),
"ContainsRune": reflect.ValueOf(bytes.ContainsRune),
"Count": reflect.ValueOf(bytes.Count),
"Equal": reflect.ValueOf(bytes.Equal),
"EqualFold": reflect.ValueOf(bytes.EqualFold),
"ErrTooLarge": reflect.ValueOf(&bytes.ErrTooLarge).Elem(),
"Fields": reflect.ValueOf(bytes.Fields),
"FieldsFunc": reflect.ValueOf(bytes.FieldsFunc),
"HasPrefix": reflect.ValueOf(bytes.HasPrefix),
"HasSuffix": reflect.ValueOf(bytes.HasSuffix),
"Index": reflect.ValueOf(bytes.Index),
"IndexAny": reflect.ValueOf(bytes.IndexAny),
"IndexByte": reflect.ValueOf(bytes.IndexByte),
"IndexFunc": reflect.ValueOf(bytes.IndexFunc),
"IndexRune": reflect.ValueOf(bytes.IndexRune),
"Join": reflect.ValueOf(bytes.Join),
"LastIndex": reflect.ValueOf(bytes.LastIndex),
"LastIndexAny": reflect.ValueOf(bytes.LastIndexAny),
"LastIndexByte": reflect.ValueOf(bytes.LastIndexByte),
"LastIndexFunc": reflect.ValueOf(bytes.LastIndexFunc),
"Map": reflect.ValueOf(bytes.Map),
"MinRead": reflect.ValueOf(bytes.MinRead),
"NewBuffer": reflect.ValueOf(bytes.NewBuffer),
"NewBufferString": reflect.ValueOf(bytes.NewBufferString),
"NewReader": reflect.ValueOf(bytes.NewReader),
"Repeat": reflect.ValueOf(bytes.Repeat),
"Replace": reflect.ValueOf(bytes.Replace),
"Runes": reflect.ValueOf(bytes.Runes),
"Split": reflect.ValueOf(bytes.Split),
"SplitAfter": reflect.ValueOf(bytes.SplitAfter),
"SplitAfterN": reflect.ValueOf(bytes.SplitAfterN),
"SplitN": reflect.ValueOf(bytes.SplitN),
"Title": reflect.ValueOf(bytes.Title),
"ToLower": reflect.ValueOf(bytes.ToLower),
"ToLowerSpecial": reflect.ValueOf(bytes.ToLowerSpecial),
"ToTitle": reflect.ValueOf(bytes.ToTitle),
"ToTitleSpecial": reflect.ValueOf(bytes.ToTitleSpecial),
"ToUpper": reflect.ValueOf(bytes.ToUpper),
"ToUpperSpecial": reflect.ValueOf(bytes.ToUpperSpecial),
"Trim": reflect.ValueOf(bytes.Trim),
"TrimFunc": reflect.ValueOf(bytes.TrimFunc),
"TrimLeft": reflect.ValueOf(bytes.TrimLeft),
"TrimLeftFunc": reflect.ValueOf(bytes.TrimLeftFunc),
"TrimPrefix": reflect.ValueOf(bytes.TrimPrefix),
"TrimRight": reflect.ValueOf(bytes.TrimRight),
"TrimRightFunc": reflect.ValueOf(bytes.TrimRightFunc),
"TrimSpace": reflect.ValueOf(bytes.TrimSpace),
"TrimSuffix": reflect.ValueOf(bytes.TrimSuffix),
// type definitions
"Buffer": reflect.ValueOf((*bytes.Buffer)(nil)),
"Reader": reflect.ValueOf((*bytes.Reader)(nil)),
}
}

20
stdlib/go1_11_compress_bzip2.go
View File

@@ -1,20 +0,0 @@
// Code generated by 'goexports compress/bzip2'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"compress/bzip2"
"reflect"
)
func init() {
Symbols["compress/bzip2"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewReader": reflect.ValueOf(bzip2.NewReader),
// type definitions
"StructuralError": reflect.ValueOf((*bzip2.StructuralError)(nil)),
}
}

55
stdlib/go1_11_compress_flate.go
View File

@@ -1,55 +0,0 @@
// Code generated by 'goexports compress/flate'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"compress/flate"
"io"
"reflect"
)
func init() {
Symbols["compress/flate"] = map[string]reflect.Value{
// function, constant and variable definitions
"BestCompression": reflect.ValueOf(flate.BestCompression),
"BestSpeed": reflect.ValueOf(flate.BestSpeed),
"DefaultCompression": reflect.ValueOf(flate.DefaultCompression),
"HuffmanOnly": reflect.ValueOf(flate.HuffmanOnly),
"NewReader": reflect.ValueOf(flate.NewReader),
"NewReaderDict": reflect.ValueOf(flate.NewReaderDict),
"NewWriter": reflect.ValueOf(flate.NewWriter),
"NewWriterDict": reflect.ValueOf(flate.NewWriterDict),
"NoCompression": reflect.ValueOf(flate.NoCompression),
// type definitions
"CorruptInputError": reflect.ValueOf((*flate.CorruptInputError)(nil)),
"InternalError": reflect.ValueOf((*flate.InternalError)(nil)),
"ReadError": reflect.ValueOf((*flate.ReadError)(nil)),
"Reader": reflect.ValueOf((*flate.Reader)(nil)),
"Resetter": reflect.ValueOf((*flate.Resetter)(nil)),
"WriteError": reflect.ValueOf((*flate.WriteError)(nil)),
"Writer": reflect.ValueOf((*flate.Writer)(nil)),
// interface wrapper definitions
"_Reader": reflect.ValueOf((*_compress_flate_Reader)(nil)),
"_Resetter": reflect.ValueOf((*_compress_flate_Resetter)(nil)),
}
}
// _compress_flate_Reader is an interface wrapper for Reader type
type _compress_flate_Reader struct {
WRead func(p []byte) (n int, err error)
WReadByte func() (byte, error)
}
func (W _compress_flate_Reader) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _compress_flate_Reader) ReadByte() (byte, error) { return W.WReadByte() }
// _compress_flate_Resetter is an interface wrapper for Resetter type
type _compress_flate_Resetter struct {
WReset func(r io.Reader, dict []byte) error
}
func (W _compress_flate_Resetter) Reset(r io.Reader, dict []byte) error { return W.WReset(r, dict) }

31
stdlib/go1_11_compress_gzip.go
View File

@@ -1,31 +0,0 @@
// Code generated by 'goexports compress/gzip'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"compress/gzip"
"reflect"
)
func init() {
Symbols["compress/gzip"] = map[string]reflect.Value{
// function, constant and variable definitions
"BestCompression": reflect.ValueOf(gzip.BestCompression),
"BestSpeed": reflect.ValueOf(gzip.BestSpeed),
"DefaultCompression": reflect.ValueOf(gzip.DefaultCompression),
"ErrChecksum": reflect.ValueOf(&gzip.ErrChecksum).Elem(),
"ErrHeader": reflect.ValueOf(&gzip.ErrHeader).Elem(),
"HuffmanOnly": reflect.ValueOf(gzip.HuffmanOnly),
"NewReader": reflect.ValueOf(gzip.NewReader),
"NewWriter": reflect.ValueOf(gzip.NewWriter),
"NewWriterLevel": reflect.ValueOf(gzip.NewWriterLevel),
"NoCompression": reflect.ValueOf(gzip.NoCompression),
// type definitions
"Header": reflect.ValueOf((*gzip.Header)(nil)),
"Reader": reflect.ValueOf((*gzip.Reader)(nil)),
"Writer": reflect.ValueOf((*gzip.Writer)(nil)),
}
}

23
stdlib/go1_11_compress_lzw.go
View File

@@ -1,23 +0,0 @@
// Code generated by 'goexports compress/lzw'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"compress/lzw"
"reflect"
)
func init() {
Symbols["compress/lzw"] = map[string]reflect.Value{
// function, constant and variable definitions
"LSB": reflect.ValueOf(lzw.LSB),
"MSB": reflect.ValueOf(lzw.MSB),
"NewReader": reflect.ValueOf(lzw.NewReader),
"NewWriter": reflect.ValueOf(lzw.NewWriter),
// type definitions
"Order": reflect.ValueOf((*lzw.Order)(nil)),
}
}

44
stdlib/go1_11_compress_zlib.go
View File

@@ -1,44 +0,0 @@
// Code generated by 'goexports compress/zlib'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"compress/zlib"
"io"
"reflect"
)
func init() {
Symbols["compress/zlib"] = map[string]reflect.Value{
// function, constant and variable definitions
"BestCompression": reflect.ValueOf(zlib.BestCompression),
"BestSpeed": reflect.ValueOf(zlib.BestSpeed),
"DefaultCompression": reflect.ValueOf(zlib.DefaultCompression),
"ErrChecksum": reflect.ValueOf(&zlib.ErrChecksum).Elem(),
"ErrDictionary": reflect.ValueOf(&zlib.ErrDictionary).Elem(),
"ErrHeader": reflect.ValueOf(&zlib.ErrHeader).Elem(),
"HuffmanOnly": reflect.ValueOf(zlib.HuffmanOnly),
"NewReader": reflect.ValueOf(zlib.NewReader),
"NewReaderDict": reflect.ValueOf(zlib.NewReaderDict),
"NewWriter": reflect.ValueOf(zlib.NewWriter),
"NewWriterLevel": reflect.ValueOf(zlib.NewWriterLevel),
"NewWriterLevelDict": reflect.ValueOf(zlib.NewWriterLevelDict),
"NoCompression": reflect.ValueOf(zlib.NoCompression),
// type definitions
"Resetter": reflect.ValueOf((*zlib.Resetter)(nil)),
"Writer": reflect.ValueOf((*zlib.Writer)(nil)),
// interface wrapper definitions
"_Resetter": reflect.ValueOf((*_compress_zlib_Resetter)(nil)),
}
}
// _compress_zlib_Resetter is an interface wrapper for Resetter type
type _compress_zlib_Resetter struct {
WReset func(r io.Reader, dict []byte) error
}
func (W _compress_zlib_Resetter) Reset(r io.Reader, dict []byte) error { return W.WReset(r, dict) }

42
stdlib/go1_11_container_heap.go
View File

@@ -1,42 +0,0 @@
// Code generated by 'goexports container/heap'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"container/heap"
"reflect"
)
func init() {
Symbols["container/heap"] = map[string]reflect.Value{
// function, constant and variable definitions
"Fix": reflect.ValueOf(heap.Fix),
"Init": reflect.ValueOf(heap.Init),
"Pop": reflect.ValueOf(heap.Pop),
"Push": reflect.ValueOf(heap.Push),
"Remove": reflect.ValueOf(heap.Remove),
// type definitions
"Interface": reflect.ValueOf((*heap.Interface)(nil)),
// interface wrapper definitions
"_Interface": reflect.ValueOf((*_container_heap_Interface)(nil)),
}
}
// _container_heap_Interface is an interface wrapper for Interface type
type _container_heap_Interface struct {
WLen func() int
WLess func(i int, j int) bool
WPop func() interface{}
WPush func(x interface{})
WSwap func(i int, j int)
}
func (W _container_heap_Interface) Len() int { return W.WLen() }
func (W _container_heap_Interface) Less(i int, j int) bool { return W.WLess(i, j) }
func (W _container_heap_Interface) Pop() interface{} { return W.WPop() }
func (W _container_heap_Interface) Push(x interface{}) { W.WPush(x) }
func (W _container_heap_Interface) Swap(i int, j int) { W.WSwap(i, j) }

21
stdlib/go1_11_container_list.go
View File

@@ -1,21 +0,0 @@
// Code generated by 'goexports container/list'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"container/list"
"reflect"
)
func init() {
Symbols["container/list"] = map[string]reflect.Value{
// function, constant and variable definitions
"New": reflect.ValueOf(list.New),
// type definitions
"Element": reflect.ValueOf((*list.Element)(nil)),
"List": reflect.ValueOf((*list.List)(nil)),
}
}

20
stdlib/go1_11_container_ring.go
View File

@@ -1,20 +0,0 @@
// Code generated by 'goexports container/ring'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"container/ring"
"reflect"
)
func init() {
Symbols["container/ring"] = map[string]reflect.Value{
// function, constant and variable definitions
"New": reflect.ValueOf(ring.New),
// type definitions
"Ring": reflect.ValueOf((*ring.Ring)(nil)),
}
}

45
stdlib/go1_11_context.go
View File

@@ -1,45 +0,0 @@
// Code generated by 'goexports context'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"context"
"reflect"
"time"
)
func init() {
Symbols["context"] = map[string]reflect.Value{
// function, constant and variable definitions
"Background": reflect.ValueOf(context.Background),
"Canceled": reflect.ValueOf(&context.Canceled).Elem(),
"DeadlineExceeded": reflect.ValueOf(&context.DeadlineExceeded).Elem(),
"TODO": reflect.ValueOf(context.TODO),
"WithCancel": reflect.ValueOf(context.WithCancel),
"WithDeadline": reflect.ValueOf(context.WithDeadline),
"WithTimeout": reflect.ValueOf(context.WithTimeout),
"WithValue": reflect.ValueOf(context.WithValue),
// type definitions
"CancelFunc": reflect.ValueOf((*context.CancelFunc)(nil)),
"Context": reflect.ValueOf((*context.Context)(nil)),
// interface wrapper definitions
"_Context": reflect.ValueOf((*_context_Context)(nil)),
}
}
// _context_Context is an interface wrapper for Context type
type _context_Context struct {
WDeadline func() (deadline time.Time, ok bool)
WDone func() <-chan struct{}
WErr func() error
WValue func(key interface{}) interface{}
}
func (W _context_Context) Deadline() (deadline time.Time, ok bool) { return W.WDeadline() }
func (W _context_Context) Done() <-chan struct{} { return W.WDone() }
func (W _context_Context) Err() error { return W.WErr() }
func (W _context_Context) Value(key interface{}) interface{} { return W.WValue(key) }

95
stdlib/go1_11_crypto.go
View File

@@ -1,95 +0,0 @@
// Code generated by 'goexports crypto'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto"
"io"
"reflect"
)
func init() {
Symbols["crypto"] = map[string]reflect.Value{
// function, constant and variable definitions
"BLAKE2b_256": reflect.ValueOf(crypto.BLAKE2b_256),
"BLAKE2b_384": reflect.ValueOf(crypto.BLAKE2b_384),
"BLAKE2b_512": reflect.ValueOf(crypto.BLAKE2b_512),
"BLAKE2s_256": reflect.ValueOf(crypto.BLAKE2s_256),
"MD4": reflect.ValueOf(crypto.MD4),
"MD5": reflect.ValueOf(crypto.MD5),
"MD5SHA1": reflect.ValueOf(crypto.MD5SHA1),
"RIPEMD160": reflect.ValueOf(crypto.RIPEMD160),
"RegisterHash": reflect.ValueOf(crypto.RegisterHash),
"SHA1": reflect.ValueOf(crypto.SHA1),
"SHA224": reflect.ValueOf(crypto.SHA224),
"SHA256": reflect.ValueOf(crypto.SHA256),
"SHA384": reflect.ValueOf(crypto.SHA384),
"SHA3_224": reflect.ValueOf(crypto.SHA3_224),
"SHA3_256": reflect.ValueOf(crypto.SHA3_256),
"SHA3_384": reflect.ValueOf(crypto.SHA3_384),
"SHA3_512": reflect.ValueOf(crypto.SHA3_512),
"SHA512": reflect.ValueOf(crypto.SHA512),
"SHA512_224": reflect.ValueOf(crypto.SHA512_224),
"SHA512_256": reflect.ValueOf(crypto.SHA512_256),
// type definitions
"Decrypter": reflect.ValueOf((*crypto.Decrypter)(nil)),
"DecrypterOpts": reflect.ValueOf((*crypto.DecrypterOpts)(nil)),
"Hash": reflect.ValueOf((*crypto.Hash)(nil)),
"PrivateKey": reflect.ValueOf((*crypto.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*crypto.PublicKey)(nil)),
"Signer": reflect.ValueOf((*crypto.Signer)(nil)),
"SignerOpts": reflect.ValueOf((*crypto.SignerOpts)(nil)),
// interface wrapper definitions
"_Decrypter": reflect.ValueOf((*_crypto_Decrypter)(nil)),
"_DecrypterOpts": reflect.ValueOf((*_crypto_DecrypterOpts)(nil)),
"_PrivateKey": reflect.ValueOf((*_crypto_PrivateKey)(nil)),
"_PublicKey": reflect.ValueOf((*_crypto_PublicKey)(nil)),
"_Signer": reflect.ValueOf((*_crypto_Signer)(nil)),
"_SignerOpts": reflect.ValueOf((*_crypto_SignerOpts)(nil)),
}
}
// _crypto_Decrypter is an interface wrapper for Decrypter type
type _crypto_Decrypter struct {
WDecrypt func(rand io.Reader, msg []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error)
WPublic func() crypto.PublicKey
}
func (W _crypto_Decrypter) Decrypt(rand io.Reader, msg []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error) {
return W.WDecrypt(rand, msg, opts)
}
func (W _crypto_Decrypter) Public() crypto.PublicKey { return W.WPublic() }
// _crypto_DecrypterOpts is an interface wrapper for DecrypterOpts type
type _crypto_DecrypterOpts struct {
}
// _crypto_PrivateKey is an interface wrapper for PrivateKey type
type _crypto_PrivateKey struct {
}
// _crypto_PublicKey is an interface wrapper for PublicKey type
type _crypto_PublicKey struct {
}
// _crypto_Signer is an interface wrapper for Signer type
type _crypto_Signer struct {
WPublic func() crypto.PublicKey
WSign func(rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error)
}
func (W _crypto_Signer) Public() crypto.PublicKey { return W.WPublic() }
func (W _crypto_Signer) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error) {
return W.WSign(rand, digest, opts)
}
// _crypto_SignerOpts is an interface wrapper for SignerOpts type
type _crypto_SignerOpts struct {
WHashFunc func() crypto.Hash
}
func (W _crypto_SignerOpts) HashFunc() crypto.Hash { return W.WHashFunc() }

21
stdlib/go1_11_crypto_aes.go
View File

@@ -1,21 +0,0 @@
// Code generated by 'goexports crypto/aes'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/aes"
"reflect"
)
func init() {
Symbols["crypto/aes"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(aes.BlockSize),
"NewCipher": reflect.ValueOf(aes.NewCipher),
// type definitions
"KeySizeError": reflect.ValueOf((*aes.KeySizeError)(nil)),
}
}

83
stdlib/go1_11_crypto_cipher.go
View File

@@ -1,83 +0,0 @@
// Code generated by 'goexports crypto/cipher'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/cipher"
"reflect"
)
func init() {
Symbols["crypto/cipher"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewCBCDecrypter": reflect.ValueOf(cipher.NewCBCDecrypter),
"NewCBCEncrypter": reflect.ValueOf(cipher.NewCBCEncrypter),
"NewCFBDecrypter": reflect.ValueOf(cipher.NewCFBDecrypter),
"NewCFBEncrypter": reflect.ValueOf(cipher.NewCFBEncrypter),
"NewCTR": reflect.ValueOf(cipher.NewCTR),
"NewGCM": reflect.ValueOf(cipher.NewGCM),
"NewGCMWithNonceSize": reflect.ValueOf(cipher.NewGCMWithNonceSize),
"NewGCMWithTagSize": reflect.ValueOf(cipher.NewGCMWithTagSize),
"NewOFB": reflect.ValueOf(cipher.NewOFB),
// type definitions
"AEAD": reflect.ValueOf((*cipher.AEAD)(nil)),
"Block": reflect.ValueOf((*cipher.Block)(nil)),
"BlockMode": reflect.ValueOf((*cipher.BlockMode)(nil)),
"Stream": reflect.ValueOf((*cipher.Stream)(nil)),
"StreamReader": reflect.ValueOf((*cipher.StreamReader)(nil)),
"StreamWriter": reflect.ValueOf((*cipher.StreamWriter)(nil)),
// interface wrapper definitions
"_AEAD": reflect.ValueOf((*_crypto_cipher_AEAD)(nil)),
"_Block": reflect.ValueOf((*_crypto_cipher_Block)(nil)),
"_BlockMode": reflect.ValueOf((*_crypto_cipher_BlockMode)(nil)),
"_Stream": reflect.ValueOf((*_crypto_cipher_Stream)(nil)),
}
}
// _crypto_cipher_AEAD is an interface wrapper for AEAD type
type _crypto_cipher_AEAD struct {
WNonceSize func() int
WOpen func(dst []byte, nonce []byte, ciphertext []byte, additionalData []byte) ([]byte, error)
WOverhead func() int
WSeal func(dst []byte, nonce []byte, plaintext []byte, additionalData []byte) []byte
}
func (W _crypto_cipher_AEAD) NonceSize() int { return W.WNonceSize() }
func (W _crypto_cipher_AEAD) Open(dst []byte, nonce []byte, ciphertext []byte, additionalData []byte) ([]byte, error) {
return W.WOpen(dst, nonce, ciphertext, additionalData)
}
func (W _crypto_cipher_AEAD) Overhead() int { return W.WOverhead() }
func (W _crypto_cipher_AEAD) Seal(dst []byte, nonce []byte, plaintext []byte, additionalData []byte) []byte {
return W.WSeal(dst, nonce, plaintext, additionalData)
}
// _crypto_cipher_Block is an interface wrapper for Block type
type _crypto_cipher_Block struct {
WBlockSize func() int
WDecrypt func(dst []byte, src []byte)
WEncrypt func(dst []byte, src []byte)
}
func (W _crypto_cipher_Block) BlockSize() int { return W.WBlockSize() }
func (W _crypto_cipher_Block) Decrypt(dst []byte, src []byte) { W.WDecrypt(dst, src) }
func (W _crypto_cipher_Block) Encrypt(dst []byte, src []byte) { W.WEncrypt(dst, src) }
// _crypto_cipher_BlockMode is an interface wrapper for BlockMode type
type _crypto_cipher_BlockMode struct {
WBlockSize func() int
WCryptBlocks func(dst []byte, src []byte)
}
func (W _crypto_cipher_BlockMode) BlockSize() int { return W.WBlockSize() }
func (W _crypto_cipher_BlockMode) CryptBlocks(dst []byte, src []byte) { W.WCryptBlocks(dst, src) }
// _crypto_cipher_Stream is an interface wrapper for Stream type
type _crypto_cipher_Stream struct {
WXORKeyStream func(dst []byte, src []byte)
}
func (W _crypto_cipher_Stream) XORKeyStream(dst []byte, src []byte) { W.WXORKeyStream(dst, src) }

22
stdlib/go1_11_crypto_des.go
View File

@@ -1,22 +0,0 @@
// Code generated by 'goexports crypto/des'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/des"
"reflect"
)
func init() {
Symbols["crypto/des"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(des.BlockSize),
"NewCipher": reflect.ValueOf(des.NewCipher),
"NewTripleDESCipher": reflect.ValueOf(des.NewTripleDESCipher),
// type definitions
"KeySizeError": reflect.ValueOf((*des.KeySizeError)(nil)),
}
}

31
stdlib/go1_11_crypto_dsa.go
View File

@@ -1,31 +0,0 @@
// Code generated by 'goexports crypto/dsa'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/dsa"
"reflect"
)
func init() {
Symbols["crypto/dsa"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrInvalidPublicKey": reflect.ValueOf(&dsa.ErrInvalidPublicKey).Elem(),
"GenerateKey": reflect.ValueOf(dsa.GenerateKey),
"GenerateParameters": reflect.ValueOf(dsa.GenerateParameters),
"L1024N160": reflect.ValueOf(dsa.L1024N160),
"L2048N224": reflect.ValueOf(dsa.L2048N224),
"L2048N256": reflect.ValueOf(dsa.L2048N256),
"L3072N256": reflect.ValueOf(dsa.L3072N256),
"Sign": reflect.ValueOf(dsa.Sign),
"Verify": reflect.ValueOf(dsa.Verify),
// type definitions
"ParameterSizes": reflect.ValueOf((*dsa.ParameterSizes)(nil)),
"Parameters": reflect.ValueOf((*dsa.Parameters)(nil)),
"PrivateKey": reflect.ValueOf((*dsa.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*dsa.PublicKey)(nil)),
}
}

23
stdlib/go1_11_crypto_ecdsa.go
View File

@@ -1,23 +0,0 @@
// Code generated by 'goexports crypto/ecdsa'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/ecdsa"
"reflect"
)
func init() {
Symbols["crypto/ecdsa"] = map[string]reflect.Value{
// function, constant and variable definitions
"GenerateKey": reflect.ValueOf(ecdsa.GenerateKey),
"Sign": reflect.ValueOf(ecdsa.Sign),
"Verify": reflect.ValueOf(ecdsa.Verify),
// type definitions
"PrivateKey": reflect.ValueOf((*ecdsa.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*ecdsa.PublicKey)(nil)),
}
}

56
stdlib/go1_11_crypto_elliptic.go
View File

@@ -1,56 +0,0 @@
// Code generated by 'goexports crypto/elliptic'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/elliptic"
"math/big"
"reflect"
)
func init() {
Symbols["crypto/elliptic"] = map[string]reflect.Value{
// function, constant and variable definitions
"GenerateKey": reflect.ValueOf(elliptic.GenerateKey),
"Marshal": reflect.ValueOf(elliptic.Marshal),
"P224": reflect.ValueOf(elliptic.P224),
"P256": reflect.ValueOf(elliptic.P256),
"P384": reflect.ValueOf(elliptic.P384),
"P521": reflect.ValueOf(elliptic.P521),
"Unmarshal": reflect.ValueOf(elliptic.Unmarshal),
// type definitions
"Curve": reflect.ValueOf((*elliptic.Curve)(nil)),
"CurveParams": reflect.ValueOf((*elliptic.CurveParams)(nil)),
// interface wrapper definitions
"_Curve": reflect.ValueOf((*_crypto_elliptic_Curve)(nil)),
}
}
// _crypto_elliptic_Curve is an interface wrapper for Curve type
type _crypto_elliptic_Curve struct {
WAdd func(x1 *big.Int, y1 *big.Int, x2 *big.Int, y2 *big.Int) (x *big.Int, y *big.Int)
WDouble func(x1 *big.Int, y1 *big.Int) (x *big.Int, y *big.Int)
WIsOnCurve func(x *big.Int, y *big.Int) bool
WParams func() *elliptic.CurveParams
WScalarBaseMult func(k []byte) (x *big.Int, y *big.Int)
WScalarMult func(x1 *big.Int, y1 *big.Int, k []byte) (x *big.Int, y *big.Int)
}
func (W _crypto_elliptic_Curve) Add(x1 *big.Int, y1 *big.Int, x2 *big.Int, y2 *big.Int) (x *big.Int, y *big.Int) {
return W.WAdd(x1, y1, x2, y2)
}
func (W _crypto_elliptic_Curve) Double(x1 *big.Int, y1 *big.Int) (x *big.Int, y *big.Int) {
return W.WDouble(x1, y1)
}
func (W _crypto_elliptic_Curve) IsOnCurve(x *big.Int, y *big.Int) bool { return W.WIsOnCurve(x, y) }
func (W _crypto_elliptic_Curve) Params() *elliptic.CurveParams { return W.WParams() }
func (W _crypto_elliptic_Curve) ScalarBaseMult(k []byte) (x *big.Int, y *big.Int) {
return W.WScalarBaseMult(k)
}
func (W _crypto_elliptic_Curve) ScalarMult(x1 *big.Int, y1 *big.Int, k []byte) (x *big.Int, y *big.Int) {
return W.WScalarMult(x1, y1, k)
}

18
stdlib/go1_11_crypto_hmac.go
View File

@@ -1,18 +0,0 @@
// Code generated by 'goexports crypto/hmac'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/hmac"
"reflect"
)
func init() {
Symbols["crypto/hmac"] = map[string]reflect.Value{
// function, constant and variable definitions
"Equal": reflect.ValueOf(hmac.Equal),
"New": reflect.ValueOf(hmac.New),
}
}

20
stdlib/go1_11_crypto_md5.go
View File

@@ -1,20 +0,0 @@
// Code generated by 'goexports crypto/md5'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/md5"
"reflect"
)
func init() {
Symbols["crypto/md5"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(md5.BlockSize),
"New": reflect.ValueOf(md5.New),
"Size": reflect.ValueOf(md5.Size),
"Sum": reflect.ValueOf(md5.Sum),
}
}

20
stdlib/go1_11_crypto_rand.go
View File

@@ -1,20 +0,0 @@
// Code generated by 'goexports crypto/rand'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/rand"
"reflect"
)
func init() {
Symbols["crypto/rand"] = map[string]reflect.Value{
// function, constant and variable definitions
"Int": reflect.ValueOf(rand.Int),
"Prime": reflect.ValueOf(rand.Prime),
"Read": reflect.ValueOf(rand.Read),
"Reader": reflect.ValueOf(&rand.Reader).Elem(),
}
}

21
stdlib/go1_11_crypto_rc4.go
View File

@@ -1,21 +0,0 @@
// Code generated by 'goexports crypto/rc4'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/rc4"
"reflect"
)
func init() {
Symbols["crypto/rc4"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewCipher": reflect.ValueOf(rc4.NewCipher),
// type definitions
"Cipher": reflect.ValueOf((*rc4.Cipher)(nil)),
"KeySizeError": reflect.ValueOf((*rc4.KeySizeError)(nil)),
}
}

41
stdlib/go1_11_crypto_rsa.go
View File

@@ -1,41 +0,0 @@
// Code generated by 'goexports crypto/rsa'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/rsa"
"reflect"
)
func init() {
Symbols["crypto/rsa"] = map[string]reflect.Value{
// function, constant and variable definitions
"DecryptOAEP": reflect.ValueOf(rsa.DecryptOAEP),
"DecryptPKCS1v15": reflect.ValueOf(rsa.DecryptPKCS1v15),
"DecryptPKCS1v15SessionKey": reflect.ValueOf(rsa.DecryptPKCS1v15SessionKey),
"EncryptOAEP": reflect.ValueOf(rsa.EncryptOAEP),
"EncryptPKCS1v15": reflect.ValueOf(rsa.EncryptPKCS1v15),
"ErrDecryption": reflect.ValueOf(&rsa.ErrDecryption).Elem(),
"ErrMessageTooLong": reflect.ValueOf(&rsa.ErrMessageTooLong).Elem(),
"ErrVerification": reflect.ValueOf(&rsa.ErrVerification).Elem(),
"GenerateKey": reflect.ValueOf(rsa.GenerateKey),
"GenerateMultiPrimeKey": reflect.ValueOf(rsa.GenerateMultiPrimeKey),
"PSSSaltLengthAuto": reflect.ValueOf(rsa.PSSSaltLengthAuto),
"PSSSaltLengthEqualsHash": reflect.ValueOf(rsa.PSSSaltLengthEqualsHash),
"SignPKCS1v15": reflect.ValueOf(rsa.SignPKCS1v15),
"SignPSS": reflect.ValueOf(rsa.SignPSS),
"VerifyPKCS1v15": reflect.ValueOf(rsa.VerifyPKCS1v15),
"VerifyPSS": reflect.ValueOf(rsa.VerifyPSS),
// type definitions
"CRTValue": reflect.ValueOf((*rsa.CRTValue)(nil)),
"OAEPOptions": reflect.ValueOf((*rsa.OAEPOptions)(nil)),
"PKCS1v15DecryptOptions": reflect.ValueOf((*rsa.PKCS1v15DecryptOptions)(nil)),
"PSSOptions": reflect.ValueOf((*rsa.PSSOptions)(nil)),
"PrecomputedValues": reflect.ValueOf((*rsa.PrecomputedValues)(nil)),
"PrivateKey": reflect.ValueOf((*rsa.PrivateKey)(nil)),
"PublicKey": reflect.ValueOf((*rsa.PublicKey)(nil)),
}
}

20
stdlib/go1_11_crypto_sha1.go
View File

@@ -1,20 +0,0 @@
// Code generated by 'goexports crypto/sha1'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/sha1"
"reflect"
)
func init() {
Symbols["crypto/sha1"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(sha1.BlockSize),
"New": reflect.ValueOf(sha1.New),
"Size": reflect.ValueOf(sha1.Size),
"Sum": reflect.ValueOf(sha1.Sum),
}
}

23
stdlib/go1_11_crypto_sha256.go
View File

@@ -1,23 +0,0 @@
// Code generated by 'goexports crypto/sha256'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/sha256"
"reflect"
)
func init() {
Symbols["crypto/sha256"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(sha256.BlockSize),
"New": reflect.ValueOf(sha256.New),
"New224": reflect.ValueOf(sha256.New224),
"Size": reflect.ValueOf(sha256.Size),
"Size224": reflect.ValueOf(sha256.Size224),
"Sum224": reflect.ValueOf(sha256.Sum224),
"Sum256": reflect.ValueOf(sha256.Sum256),
}
}

29
stdlib/go1_11_crypto_sha512.go
View File

@@ -1,29 +0,0 @@
// Code generated by 'goexports crypto/sha512'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/sha512"
"reflect"
)
func init() {
Symbols["crypto/sha512"] = map[string]reflect.Value{
// function, constant and variable definitions
"BlockSize": reflect.ValueOf(sha512.BlockSize),
"New": reflect.ValueOf(sha512.New),
"New384": reflect.ValueOf(sha512.New384),
"New512_224": reflect.ValueOf(sha512.New512_224),
"New512_256": reflect.ValueOf(sha512.New512_256),
"Size": reflect.ValueOf(sha512.Size),
"Size224": reflect.ValueOf(sha512.Size224),
"Size256": reflect.ValueOf(sha512.Size256),
"Size384": reflect.ValueOf(sha512.Size384),
"Sum384": reflect.ValueOf(sha512.Sum384),
"Sum512": reflect.ValueOf(sha512.Sum512),
"Sum512_224": reflect.ValueOf(sha512.Sum512_224),
"Sum512_256": reflect.ValueOf(sha512.Sum512_256),
}
}

22
stdlib/go1_11_crypto_subtle.go
View File

@@ -1,22 +0,0 @@
// Code generated by 'goexports crypto/subtle'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/subtle"
"reflect"
)
func init() {
Symbols["crypto/subtle"] = map[string]reflect.Value{
// function, constant and variable definitions
"ConstantTimeByteEq": reflect.ValueOf(subtle.ConstantTimeByteEq),
"ConstantTimeCompare": reflect.ValueOf(subtle.ConstantTimeCompare),
"ConstantTimeCopy": reflect.ValueOf(subtle.ConstantTimeCopy),
"ConstantTimeEq": reflect.ValueOf(subtle.ConstantTimeEq),
"ConstantTimeLessOrEq": reflect.ValueOf(subtle.ConstantTimeLessOrEq),
"ConstantTimeSelect": reflect.ValueOf(subtle.ConstantTimeSelect),
}
}

106
stdlib/go1_11_crypto_tls.go
View File

@@ -1,106 +0,0 @@
// Code generated by 'goexports crypto/tls'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/tls"
"reflect"
)
func init() {
Symbols["crypto/tls"] = map[string]reflect.Value{
// function, constant and variable definitions
"Client": reflect.ValueOf(tls.Client),
"CurveP256": reflect.ValueOf(tls.CurveP256),
"CurveP384": reflect.ValueOf(tls.CurveP384),
"CurveP521": reflect.ValueOf(tls.CurveP521),
"Dial": reflect.ValueOf(tls.Dial),
"DialWithDialer": reflect.ValueOf(tls.DialWithDialer),
"ECDSAWithP256AndSHA256": reflect.ValueOf(tls.ECDSAWithP256AndSHA256),
"ECDSAWithP384AndSHA384": reflect.ValueOf(tls.ECDSAWithP384AndSHA384),
"ECDSAWithP521AndSHA512": reflect.ValueOf(tls.ECDSAWithP521AndSHA512),
"ECDSAWithSHA1": reflect.ValueOf(tls.ECDSAWithSHA1),
"Listen": reflect.ValueOf(tls.Listen),
"LoadX509KeyPair": reflect.ValueOf(tls.LoadX509KeyPair),
"NewLRUClientSessionCache": reflect.ValueOf(tls.NewLRUClientSessionCache),
"NewListener": reflect.ValueOf(tls.NewListener),
"NoClientCert": reflect.ValueOf(tls.NoClientCert),
"PKCS1WithSHA1": reflect.ValueOf(tls.PKCS1WithSHA1),
"PKCS1WithSHA256": reflect.ValueOf(tls.PKCS1WithSHA256),
"PKCS1WithSHA384": reflect.ValueOf(tls.PKCS1WithSHA384),
"PKCS1WithSHA512": reflect.ValueOf(tls.PKCS1WithSHA512),
"PSSWithSHA256": reflect.ValueOf(tls.PSSWithSHA256),
"PSSWithSHA384": reflect.ValueOf(tls.PSSWithSHA384),
"PSSWithSHA512": reflect.ValueOf(tls.PSSWithSHA512),
"RenegotiateFreelyAsClient": reflect.ValueOf(tls.RenegotiateFreelyAsClient),
"RenegotiateNever": reflect.ValueOf(tls.RenegotiateNever),
"RenegotiateOnceAsClient": reflect.ValueOf(tls.RenegotiateOnceAsClient),
"RequestClientCert": reflect.ValueOf(tls.RequestClientCert),
"RequireAndVerifyClientCert": reflect.ValueOf(tls.RequireAndVerifyClientCert),
"RequireAnyClientCert": reflect.ValueOf(tls.RequireAnyClientCert),
"Server": reflect.ValueOf(tls.Server),
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA),
"TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256),
"TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256),
"TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA),
"TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384),
"TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305),
"TLS_ECDHE_ECDSA_WITH_RC4_128_SHA": reflect.ValueOf(tls.TLS_ECDHE_ECDSA_WITH_RC4_128_SHA),
"TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA),
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA),
"TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256),
"TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256),
"TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA),
"TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384),
"TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305),
"TLS_ECDHE_RSA_WITH_RC4_128_SHA": reflect.ValueOf(tls.TLS_ECDHE_RSA_WITH_RC4_128_SHA),
"TLS_FALLBACK_SCSV": reflect.ValueOf(tls.TLS_FALLBACK_SCSV),
"TLS_RSA_WITH_3DES_EDE_CBC_SHA": reflect.ValueOf(tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA),
"TLS_RSA_WITH_AES_128_CBC_SHA": reflect.ValueOf(tls.TLS_RSA_WITH_AES_128_CBC_SHA),
"TLS_RSA_WITH_AES_128_CBC_SHA256": reflect.ValueOf(tls.TLS_RSA_WITH_AES_128_CBC_SHA256),
"TLS_RSA_WITH_AES_128_GCM_SHA256": reflect.ValueOf(tls.TLS_RSA_WITH_AES_128_GCM_SHA256),
"TLS_RSA_WITH_AES_256_CBC_SHA": reflect.ValueOf(tls.TLS_RSA_WITH_AES_256_CBC_SHA),
"TLS_RSA_WITH_AES_256_GCM_SHA384": reflect.ValueOf(tls.TLS_RSA_WITH_AES_256_GCM_SHA384),
"TLS_RSA_WITH_RC4_128_SHA": reflect.ValueOf(tls.TLS_RSA_WITH_RC4_128_SHA),
"VerifyClientCertIfGiven": reflect.ValueOf(tls.VerifyClientCertIfGiven),
"VersionSSL30": reflect.ValueOf(tls.VersionSSL30),
"VersionTLS10": reflect.ValueOf(tls.VersionTLS10),
"VersionTLS11": reflect.ValueOf(tls.VersionTLS11),
"VersionTLS12": reflect.ValueOf(tls.VersionTLS12),
"X25519": reflect.ValueOf(tls.X25519),
"X509KeyPair": reflect.ValueOf(tls.X509KeyPair),
// type definitions
"Certificate": reflect.ValueOf((*tls.Certificate)(nil)),
"CertificateRequestInfo": reflect.ValueOf((*tls.CertificateRequestInfo)(nil)),
"ClientAuthType": reflect.ValueOf((*tls.ClientAuthType)(nil)),
"ClientHelloInfo": reflect.ValueOf((*tls.ClientHelloInfo)(nil)),
"ClientSessionCache": reflect.ValueOf((*tls.ClientSessionCache)(nil)),
"ClientSessionState": reflect.ValueOf((*tls.ClientSessionState)(nil)),
"Config": reflect.ValueOf((*tls.Config)(nil)),
"Conn": reflect.ValueOf((*tls.Conn)(nil)),
"ConnectionState": reflect.ValueOf((*tls.ConnectionState)(nil)),
"CurveID": reflect.ValueOf((*tls.CurveID)(nil)),
"RecordHeaderError": reflect.ValueOf((*tls.RecordHeaderError)(nil)),
"RenegotiationSupport": reflect.ValueOf((*tls.RenegotiationSupport)(nil)),
"SignatureScheme": reflect.ValueOf((*tls.SignatureScheme)(nil)),
// interface wrapper definitions
"_ClientSessionCache": reflect.ValueOf((*_crypto_tls_ClientSessionCache)(nil)),
}
}
// _crypto_tls_ClientSessionCache is an interface wrapper for ClientSessionCache type
type _crypto_tls_ClientSessionCache struct {
WGet func(sessionKey string) (session *tls.ClientSessionState, ok bool)
WPut func(sessionKey string, cs *tls.ClientSessionState)
}
func (W _crypto_tls_ClientSessionCache) Get(sessionKey string) (session *tls.ClientSessionState, ok bool) {
return W.WGet(sessionKey)
}
func (W _crypto_tls_ClientSessionCache) Put(sessionKey string, cs *tls.ClientSessionState) {
W.WPut(sessionKey, cs)
}

117
stdlib/go1_11_crypto_x509.go
View File

@@ -1,117 +0,0 @@
// Code generated by 'goexports crypto/x509'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/x509"
"reflect"
)
func init() {
Symbols["crypto/x509"] = map[string]reflect.Value{
// function, constant and variable definitions
"CANotAuthorizedForExtKeyUsage": reflect.ValueOf(x509.CANotAuthorizedForExtKeyUsage),
"CANotAuthorizedForThisName": reflect.ValueOf(x509.CANotAuthorizedForThisName),
"CreateCertificate": reflect.ValueOf(x509.CreateCertificate),
"CreateCertificateRequest": reflect.ValueOf(x509.CreateCertificateRequest),
"DSA": reflect.ValueOf(x509.DSA),
"DSAWithSHA1": reflect.ValueOf(x509.DSAWithSHA1),
"DSAWithSHA256": reflect.ValueOf(x509.DSAWithSHA256),
"DecryptPEMBlock": reflect.ValueOf(x509.DecryptPEMBlock),
"ECDSA": reflect.ValueOf(x509.ECDSA),
"ECDSAWithSHA1": reflect.ValueOf(x509.ECDSAWithSHA1),
"ECDSAWithSHA256": reflect.ValueOf(x509.ECDSAWithSHA256),
"ECDSAWithSHA384": reflect.ValueOf(x509.ECDSAWithSHA384),
"ECDSAWithSHA512": reflect.ValueOf(x509.ECDSAWithSHA512),
"EncryptPEMBlock": reflect.ValueOf(x509.EncryptPEMBlock),
"ErrUnsupportedAlgorithm": reflect.ValueOf(&x509.ErrUnsupportedAlgorithm).Elem(),
"Expired": reflect.ValueOf(x509.Expired),
"ExtKeyUsageAny": reflect.ValueOf(x509.ExtKeyUsageAny),
"ExtKeyUsageClientAuth": reflect.ValueOf(x509.ExtKeyUsageClientAuth),
"ExtKeyUsageCodeSigning": reflect.ValueOf(x509.ExtKeyUsageCodeSigning),
"ExtKeyUsageEmailProtection": reflect.ValueOf(x509.ExtKeyUsageEmailProtection),
"ExtKeyUsageIPSECEndSystem": reflect.ValueOf(x509.ExtKeyUsageIPSECEndSystem),
"ExtKeyUsageIPSECTunnel": reflect.ValueOf(x509.ExtKeyUsageIPSECTunnel),
"ExtKeyUsageIPSECUser": reflect.ValueOf(x509.ExtKeyUsageIPSECUser),
"ExtKeyUsageMicrosoftCommercialCodeSigning": reflect.ValueOf(x509.ExtKeyUsageMicrosoftCommercialCodeSigning),
"ExtKeyUsageMicrosoftKernelCodeSigning": reflect.ValueOf(x509.ExtKeyUsageMicrosoftKernelCodeSigning),
"ExtKeyUsageMicrosoftServerGatedCrypto": reflect.ValueOf(x509.ExtKeyUsageMicrosoftServerGatedCrypto),
"ExtKeyUsageNetscapeServerGatedCrypto": reflect.ValueOf(x509.ExtKeyUsageNetscapeServerGatedCrypto),
"ExtKeyUsageOCSPSigning": reflect.ValueOf(x509.ExtKeyUsageOCSPSigning),
"ExtKeyUsageServerAuth": reflect.ValueOf(x509.ExtKeyUsageServerAuth),
"ExtKeyUsageTimeStamping": reflect.ValueOf(x509.ExtKeyUsageTimeStamping),
"IncompatibleUsage": reflect.ValueOf(x509.IncompatibleUsage),
"IncorrectPasswordError": reflect.ValueOf(&x509.IncorrectPasswordError).Elem(),
"IsEncryptedPEMBlock": reflect.ValueOf(x509.IsEncryptedPEMBlock),
"KeyUsageCRLSign": reflect.ValueOf(x509.KeyUsageCRLSign),
"KeyUsageCertSign": reflect.ValueOf(x509.KeyUsageCertSign),
"KeyUsageContentCommitment": reflect.ValueOf(x509.KeyUsageContentCommitment),
"KeyUsageDataEncipherment": reflect.ValueOf(x509.KeyUsageDataEncipherment),
"KeyUsageDecipherOnly": reflect.ValueOf(x509.KeyUsageDecipherOnly),
"KeyUsageDigitalSignature": reflect.ValueOf(x509.KeyUsageDigitalSignature),
"KeyUsageEncipherOnly": reflect.ValueOf(x509.KeyUsageEncipherOnly),
"KeyUsageKeyAgreement": reflect.ValueOf(x509.KeyUsageKeyAgreement),
"KeyUsageKeyEncipherment": reflect.ValueOf(x509.KeyUsageKeyEncipherment),
"MD2WithRSA": reflect.ValueOf(x509.MD2WithRSA),
"MD5WithRSA": reflect.ValueOf(x509.MD5WithRSA),
"MarshalECPrivateKey": reflect.ValueOf(x509.MarshalECPrivateKey),
"MarshalPKCS1PrivateKey": reflect.ValueOf(x509.MarshalPKCS1PrivateKey),
"MarshalPKCS1PublicKey": reflect.ValueOf(x509.MarshalPKCS1PublicKey),
"MarshalPKCS8PrivateKey": reflect.ValueOf(x509.MarshalPKCS8PrivateKey),
"MarshalPKIXPublicKey": reflect.ValueOf(x509.MarshalPKIXPublicKey),
"NameConstraintsWithoutSANs": reflect.ValueOf(x509.NameConstraintsWithoutSANs),
"NameMismatch": reflect.ValueOf(x509.NameMismatch),
"NewCertPool": reflect.ValueOf(x509.NewCertPool),
"NotAuthorizedToSign": reflect.ValueOf(x509.NotAuthorizedToSign),
"PEMCipher3DES": reflect.ValueOf(x509.PEMCipher3DES),
"PEMCipherAES128": reflect.ValueOf(x509.PEMCipherAES128),
"PEMCipherAES192": reflect.ValueOf(x509.PEMCipherAES192),
"PEMCipherAES256": reflect.ValueOf(x509.PEMCipherAES256),
"PEMCipherDES": reflect.ValueOf(x509.PEMCipherDES),
"ParseCRL": reflect.ValueOf(x509.ParseCRL),
"ParseCertificate": reflect.ValueOf(x509.ParseCertificate),
"ParseCertificateRequest": reflect.ValueOf(x509.ParseCertificateRequest),
"ParseCertificates": reflect.ValueOf(x509.ParseCertificates),
"ParseDERCRL": reflect.ValueOf(x509.ParseDERCRL),
"ParseECPrivateKey": reflect.ValueOf(x509.ParseECPrivateKey),
"ParsePKCS1PrivateKey": reflect.ValueOf(x509.ParsePKCS1PrivateKey),
"ParsePKCS1PublicKey": reflect.ValueOf(x509.ParsePKCS1PublicKey),
"ParsePKCS8PrivateKey": reflect.ValueOf(x509.ParsePKCS8PrivateKey),
"ParsePKIXPublicKey": reflect.ValueOf(x509.ParsePKIXPublicKey),
"RSA": reflect.ValueOf(x509.RSA),
"SHA1WithRSA": reflect.ValueOf(x509.SHA1WithRSA),
"SHA256WithRSA": reflect.ValueOf(x509.SHA256WithRSA),
"SHA256WithRSAPSS": reflect.ValueOf(x509.SHA256WithRSAPSS),
"SHA384WithRSA": reflect.ValueOf(x509.SHA384WithRSA),
"SHA384WithRSAPSS": reflect.ValueOf(x509.SHA384WithRSAPSS),
"SHA512WithRSA": reflect.ValueOf(x509.SHA512WithRSA),
"SHA512WithRSAPSS": reflect.ValueOf(x509.SHA512WithRSAPSS),
"SystemCertPool": reflect.ValueOf(x509.SystemCertPool),
"TooManyConstraints": reflect.ValueOf(x509.TooManyConstraints),
"TooManyIntermediates": reflect.ValueOf(x509.TooManyIntermediates),
"UnconstrainedName": reflect.ValueOf(x509.UnconstrainedName),
"UnknownPublicKeyAlgorithm": reflect.ValueOf(x509.UnknownPublicKeyAlgorithm),
"UnknownSignatureAlgorithm": reflect.ValueOf(x509.UnknownSignatureAlgorithm),
// type definitions
"CertPool": reflect.ValueOf((*x509.CertPool)(nil)),
"Certificate": reflect.ValueOf((*x509.Certificate)(nil)),
"CertificateInvalidError": reflect.ValueOf((*x509.CertificateInvalidError)(nil)),
"CertificateRequest": reflect.ValueOf((*x509.CertificateRequest)(nil)),
"ConstraintViolationError": reflect.ValueOf((*x509.ConstraintViolationError)(nil)),
"ExtKeyUsage": reflect.ValueOf((*x509.ExtKeyUsage)(nil)),
"HostnameError": reflect.ValueOf((*x509.HostnameError)(nil)),
"InsecureAlgorithmError": reflect.ValueOf((*x509.InsecureAlgorithmError)(nil)),
"InvalidReason": reflect.ValueOf((*x509.InvalidReason)(nil)),
"KeyUsage": reflect.ValueOf((*x509.KeyUsage)(nil)),
"PEMCipher": reflect.ValueOf((*x509.PEMCipher)(nil)),
"PublicKeyAlgorithm": reflect.ValueOf((*x509.PublicKeyAlgorithm)(nil)),
"SignatureAlgorithm": reflect.ValueOf((*x509.SignatureAlgorithm)(nil)),
"SystemRootsError": reflect.ValueOf((*x509.SystemRootsError)(nil)),
"UnhandledCriticalExtension": reflect.ValueOf((*x509.UnhandledCriticalExtension)(nil)),
"UnknownAuthorityError": reflect.ValueOf((*x509.UnknownAuthorityError)(nil)),
"VerifyOptions": reflect.ValueOf((*x509.VerifyOptions)(nil)),
}
}

26
stdlib/go1_11_crypto_x509_pkix.go
View File

@@ -1,26 +0,0 @@
// Code generated by 'goexports crypto/x509/pkix'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"crypto/x509/pkix"
"reflect"
)
func init() {
Symbols["crypto/x509/pkix"] = map[string]reflect.Value{
// type definitions
"AlgorithmIdentifier": reflect.ValueOf((*pkix.AlgorithmIdentifier)(nil)),
"AttributeTypeAndValue": reflect.ValueOf((*pkix.AttributeTypeAndValue)(nil)),
"AttributeTypeAndValueSET": reflect.ValueOf((*pkix.AttributeTypeAndValueSET)(nil)),
"CertificateList": reflect.ValueOf((*pkix.CertificateList)(nil)),
"Extension": reflect.ValueOf((*pkix.Extension)(nil)),
"Name": reflect.ValueOf((*pkix.Name)(nil)),
"RDNSequence": reflect.ValueOf((*pkix.RDNSequence)(nil)),
"RelativeDistinguishedNameSET": reflect.ValueOf((*pkix.RelativeDistinguishedNameSET)(nil)),
"RevokedCertificate": reflect.ValueOf((*pkix.RevokedCertificate)(nil)),
"TBSCertificateList": reflect.ValueOf((*pkix.TBSCertificateList)(nil)),
}
}

73
stdlib/go1_11_database_sql.go
View File

@@ -1,73 +0,0 @@
// Code generated by 'goexports database/sql'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"database/sql"
"reflect"
)
func init() {
Symbols["database/sql"] = map[string]reflect.Value{
// function, constant and variable definitions
"Drivers": reflect.ValueOf(sql.Drivers),
"ErrConnDone": reflect.ValueOf(&sql.ErrConnDone).Elem(),
"ErrNoRows": reflect.ValueOf(&sql.ErrNoRows).Elem(),
"ErrTxDone": reflect.ValueOf(&sql.ErrTxDone).Elem(),
"LevelDefault": reflect.ValueOf(sql.LevelDefault),
"LevelLinearizable": reflect.ValueOf(sql.LevelLinearizable),
"LevelReadCommitted": reflect.ValueOf(sql.LevelReadCommitted),
"LevelReadUncommitted": reflect.ValueOf(sql.LevelReadUncommitted),
"LevelRepeatableRead": reflect.ValueOf(sql.LevelRepeatableRead),
"LevelSerializable": reflect.ValueOf(sql.LevelSerializable),
"LevelSnapshot": reflect.ValueOf(sql.LevelSnapshot),
"LevelWriteCommitted": reflect.ValueOf(sql.LevelWriteCommitted),
"Named": reflect.ValueOf(sql.Named),
"Open": reflect.ValueOf(sql.Open),
"OpenDB": reflect.ValueOf(sql.OpenDB),
"Register": reflect.ValueOf(sql.Register),
// type definitions
"ColumnType": reflect.ValueOf((*sql.ColumnType)(nil)),
"Conn": reflect.ValueOf((*sql.Conn)(nil)),
"DB": reflect.ValueOf((*sql.DB)(nil)),
"DBStats": reflect.ValueOf((*sql.DBStats)(nil)),
"IsolationLevel": reflect.ValueOf((*sql.IsolationLevel)(nil)),
"NamedArg": reflect.ValueOf((*sql.NamedArg)(nil)),
"NullBool": reflect.ValueOf((*sql.NullBool)(nil)),
"NullFloat64": reflect.ValueOf((*sql.NullFloat64)(nil)),
"NullInt64": reflect.ValueOf((*sql.NullInt64)(nil)),
"NullString": reflect.ValueOf((*sql.NullString)(nil)),
"Out": reflect.ValueOf((*sql.Out)(nil)),
"RawBytes": reflect.ValueOf((*sql.RawBytes)(nil)),
"Result": reflect.ValueOf((*sql.Result)(nil)),
"Row": reflect.ValueOf((*sql.Row)(nil)),
"Rows": reflect.ValueOf((*sql.Rows)(nil)),
"Scanner": reflect.ValueOf((*sql.Scanner)(nil)),
"Stmt": reflect.ValueOf((*sql.Stmt)(nil)),
"Tx": reflect.ValueOf((*sql.Tx)(nil)),
"TxOptions": reflect.ValueOf((*sql.TxOptions)(nil)),
// interface wrapper definitions
"_Result": reflect.ValueOf((*_database_sql_Result)(nil)),
"_Scanner": reflect.ValueOf((*_database_sql_Scanner)(nil)),
}
}
// _database_sql_Result is an interface wrapper for Result type
type _database_sql_Result struct {
WLastInsertId func() (int64, error)
WRowsAffected func() (int64, error)
}
func (W _database_sql_Result) LastInsertId() (int64, error) { return W.WLastInsertId() }
func (W _database_sql_Result) RowsAffected() (int64, error) { return W.WRowsAffected() }
// _database_sql_Scanner is an interface wrapper for Scanner type
type _database_sql_Scanner struct {
WScan func(src interface{}) error
}
func (W _database_sql_Scanner) Scan(src interface{}) error { return W.WScan(src) }

411
stdlib/go1_11_database_sql_driver.go
View File

@@ -1,411 +0,0 @@
// Code generated by 'goexports database/sql/driver'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"context"
"database/sql/driver"
"reflect"
)
func init() {
Symbols["database/sql/driver"] = map[string]reflect.Value{
// function, constant and variable definitions
"Bool": reflect.ValueOf(&driver.Bool).Elem(),
"DefaultParameterConverter": reflect.ValueOf(&driver.DefaultParameterConverter).Elem(),
"ErrBadConn": reflect.ValueOf(&driver.ErrBadConn).Elem(),
"ErrRemoveArgument": reflect.ValueOf(&driver.ErrRemoveArgument).Elem(),
"ErrSkip": reflect.ValueOf(&driver.ErrSkip).Elem(),
"Int32": reflect.ValueOf(&driver.Int32).Elem(),
"IsScanValue": reflect.ValueOf(driver.IsScanValue),
"IsValue": reflect.ValueOf(driver.IsValue),
"ResultNoRows": reflect.ValueOf(&driver.ResultNoRows).Elem(),
"String": reflect.ValueOf(&driver.String).Elem(),
// type definitions
"ColumnConverter": reflect.ValueOf((*driver.ColumnConverter)(nil)),
"Conn": reflect.ValueOf((*driver.Conn)(nil)),
"ConnBeginTx": reflect.ValueOf((*driver.ConnBeginTx)(nil)),
"ConnPrepareContext": reflect.ValueOf((*driver.ConnPrepareContext)(nil)),
"Connector": reflect.ValueOf((*driver.Connector)(nil)),
"Driver": reflect.ValueOf((*driver.Driver)(nil)),
"DriverContext": reflect.ValueOf((*driver.DriverContext)(nil)),
"Execer": reflect.ValueOf((*driver.Execer)(nil)),
"ExecerContext": reflect.ValueOf((*driver.ExecerContext)(nil)),
"IsolationLevel": reflect.ValueOf((*driver.IsolationLevel)(nil)),
"NamedValue": reflect.ValueOf((*driver.NamedValue)(nil)),
"NamedValueChecker": reflect.ValueOf((*driver.NamedValueChecker)(nil)),
"NotNull": reflect.ValueOf((*driver.NotNull)(nil)),
"Null": reflect.ValueOf((*driver.Null)(nil)),
"Pinger": reflect.ValueOf((*driver.Pinger)(nil)),
"Queryer": reflect.ValueOf((*driver.Queryer)(nil)),
"QueryerContext": reflect.ValueOf((*driver.QueryerContext)(nil)),
"Result": reflect.ValueOf((*driver.Result)(nil)),
"Rows": reflect.ValueOf((*driver.Rows)(nil)),
"RowsAffected": reflect.ValueOf((*driver.RowsAffected)(nil)),
"RowsColumnTypeDatabaseTypeName": reflect.ValueOf((*driver.RowsColumnTypeDatabaseTypeName)(nil)),
"RowsColumnTypeLength": reflect.ValueOf((*driver.RowsColumnTypeLength)(nil)),
"RowsColumnTypeNullable": reflect.ValueOf((*driver.RowsColumnTypeNullable)(nil)),
"RowsColumnTypePrecisionScale": reflect.ValueOf((*driver.RowsColumnTypePrecisionScale)(nil)),
"RowsColumnTypeScanType": reflect.ValueOf((*driver.RowsColumnTypeScanType)(nil)),
"RowsNextResultSet": reflect.ValueOf((*driver.RowsNextResultSet)(nil)),
"SessionResetter": reflect.ValueOf((*driver.SessionResetter)(nil)),
"Stmt": reflect.ValueOf((*driver.Stmt)(nil)),
"StmtExecContext": reflect.ValueOf((*driver.StmtExecContext)(nil)),
"StmtQueryContext": reflect.ValueOf((*driver.StmtQueryContext)(nil)),
"Tx": reflect.ValueOf((*driver.Tx)(nil)),
"TxOptions": reflect.ValueOf((*driver.TxOptions)(nil)),
"Value": reflect.ValueOf((*driver.Value)(nil)),
"ValueConverter": reflect.ValueOf((*driver.ValueConverter)(nil)),
"Valuer": reflect.ValueOf((*driver.Valuer)(nil)),
// interface wrapper definitions
"_ColumnConverter": reflect.ValueOf((*_database_sql_driver_ColumnConverter)(nil)),
"_Conn": reflect.ValueOf((*_database_sql_driver_Conn)(nil)),
"_ConnBeginTx": reflect.ValueOf((*_database_sql_driver_ConnBeginTx)(nil)),
"_ConnPrepareContext": reflect.ValueOf((*_database_sql_driver_ConnPrepareContext)(nil)),
"_Connector": reflect.ValueOf((*_database_sql_driver_Connector)(nil)),
"_Driver": reflect.ValueOf((*_database_sql_driver_Driver)(nil)),
"_DriverContext": reflect.ValueOf((*_database_sql_driver_DriverContext)(nil)),
"_Execer": reflect.ValueOf((*_database_sql_driver_Execer)(nil)),
"_ExecerContext": reflect.ValueOf((*_database_sql_driver_ExecerContext)(nil)),
"_NamedValueChecker": reflect.ValueOf((*_database_sql_driver_NamedValueChecker)(nil)),
"_Pinger": reflect.ValueOf((*_database_sql_driver_Pinger)(nil)),
"_Queryer": reflect.ValueOf((*_database_sql_driver_Queryer)(nil)),
"_QueryerContext": reflect.ValueOf((*_database_sql_driver_QueryerContext)(nil)),
"_Result": reflect.ValueOf((*_database_sql_driver_Result)(nil)),
"_Rows": reflect.ValueOf((*_database_sql_driver_Rows)(nil)),
"_RowsColumnTypeDatabaseTypeName": reflect.ValueOf((*_database_sql_driver_RowsColumnTypeDatabaseTypeName)(nil)),
"_RowsColumnTypeLength": reflect.ValueOf((*_database_sql_driver_RowsColumnTypeLength)(nil)),
"_RowsColumnTypeNullable": reflect.ValueOf((*_database_sql_driver_RowsColumnTypeNullable)(nil)),
"_RowsColumnTypePrecisionScale": reflect.ValueOf((*_database_sql_driver_RowsColumnTypePrecisionScale)(nil)),
"_RowsColumnTypeScanType": reflect.ValueOf((*_database_sql_driver_RowsColumnTypeScanType)(nil)),
"_RowsNextResultSet": reflect.ValueOf((*_database_sql_driver_RowsNextResultSet)(nil)),
"_SessionResetter": reflect.ValueOf((*_database_sql_driver_SessionResetter)(nil)),
"_Stmt": reflect.ValueOf((*_database_sql_driver_Stmt)(nil)),
"_StmtExecContext": reflect.ValueOf((*_database_sql_driver_StmtExecContext)(nil)),
"_StmtQueryContext": reflect.ValueOf((*_database_sql_driver_StmtQueryContext)(nil)),
"_Tx": reflect.ValueOf((*_database_sql_driver_Tx)(nil)),
"_Value": reflect.ValueOf((*_database_sql_driver_Value)(nil)),
"_ValueConverter": reflect.ValueOf((*_database_sql_driver_ValueConverter)(nil)),
"_Valuer": reflect.ValueOf((*_database_sql_driver_Valuer)(nil)),
}
}
// _database_sql_driver_ColumnConverter is an interface wrapper for ColumnConverter type
type _database_sql_driver_ColumnConverter struct {
WColumnConverter func(idx int) driver.ValueConverter
}
func (W _database_sql_driver_ColumnConverter) ColumnConverter(idx int) driver.ValueConverter {
return W.WColumnConverter(idx)
}
// _database_sql_driver_Conn is an interface wrapper for Conn type
type _database_sql_driver_Conn struct {
WBegin func() (driver.Tx, error)
WClose func() error
WPrepare func(query string) (driver.Stmt, error)
}
func (W _database_sql_driver_Conn) Begin() (driver.Tx, error) { return W.WBegin() }
func (W _database_sql_driver_Conn) Close() error { return W.WClose() }
func (W _database_sql_driver_Conn) Prepare(query string) (driver.Stmt, error) {
return W.WPrepare(query)
}
// _database_sql_driver_ConnBeginTx is an interface wrapper for ConnBeginTx type
type _database_sql_driver_ConnBeginTx struct {
WBeginTx func(ctx context.Context, opts driver.TxOptions) (driver.Tx, error)
}
func (W _database_sql_driver_ConnBeginTx) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) {
return W.WBeginTx(ctx, opts)
}
// _database_sql_driver_ConnPrepareContext is an interface wrapper for ConnPrepareContext type
type _database_sql_driver_ConnPrepareContext struct {
WPrepareContext func(ctx context.Context, query string) (driver.Stmt, error)
}
func (W _database_sql_driver_ConnPrepareContext) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) {
return W.WPrepareContext(ctx, query)
}
// _database_sql_driver_Connector is an interface wrapper for Connector type
type _database_sql_driver_Connector struct {
WConnect func(a0 context.Context) (driver.Conn, error)
WDriver func() driver.Driver
}
func (W _database_sql_driver_Connector) Connect(a0 context.Context) (driver.Conn, error) {
return W.WConnect(a0)
}
func (W _database_sql_driver_Connector) Driver() driver.Driver { return W.WDriver() }
// _database_sql_driver_Driver is an interface wrapper for Driver type
type _database_sql_driver_Driver struct {
WOpen func(name string) (driver.Conn, error)
}
func (W _database_sql_driver_Driver) Open(name string) (driver.Conn, error) { return W.WOpen(name) }
// _database_sql_driver_DriverContext is an interface wrapper for DriverContext type
type _database_sql_driver_DriverContext struct {
WOpenConnector func(name string) (driver.Connector, error)
}
func (W _database_sql_driver_DriverContext) OpenConnector(name string) (driver.Connector, error) {
return W.WOpenConnector(name)
}
// _database_sql_driver_Execer is an interface wrapper for Execer type
type _database_sql_driver_Execer struct {
WExec func(query string, args []driver.Value) (driver.Result, error)
}
func (W _database_sql_driver_Execer) Exec(query string, args []driver.Value) (driver.Result, error) {
return W.WExec(query, args)
}
// _database_sql_driver_ExecerContext is an interface wrapper for ExecerContext type
type _database_sql_driver_ExecerContext struct {
WExecContext func(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error)
}
func (W _database_sql_driver_ExecerContext) ExecContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error) {
return W.WExecContext(ctx, query, args)
}
// _database_sql_driver_NamedValueChecker is an interface wrapper for NamedValueChecker type
type _database_sql_driver_NamedValueChecker struct {
WCheckNamedValue func(a0 *driver.NamedValue) error
}
func (W _database_sql_driver_NamedValueChecker) CheckNamedValue(a0 *driver.NamedValue) error {
return W.WCheckNamedValue(a0)
}
// _database_sql_driver_Pinger is an interface wrapper for Pinger type
type _database_sql_driver_Pinger struct {
WPing func(ctx context.Context) error
}
func (W _database_sql_driver_Pinger) Ping(ctx context.Context) error { return W.WPing(ctx) }
// _database_sql_driver_Queryer is an interface wrapper for Queryer type
type _database_sql_driver_Queryer struct {
WQuery func(query string, args []driver.Value) (driver.Rows, error)
}
func (W _database_sql_driver_Queryer) Query(query string, args []driver.Value) (driver.Rows, error) {
return W.WQuery(query, args)
}
// _database_sql_driver_QueryerContext is an interface wrapper for QueryerContext type
type _database_sql_driver_QueryerContext struct {
WQueryContext func(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error)
}
func (W _database_sql_driver_QueryerContext) QueryContext(ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error) {
return W.WQueryContext(ctx, query, args)
}
// _database_sql_driver_Result is an interface wrapper for Result type
type _database_sql_driver_Result struct {
WLastInsertId func() (int64, error)
WRowsAffected func() (int64, error)
}
func (W _database_sql_driver_Result) LastInsertId() (int64, error) { return W.WLastInsertId() }
func (W _database_sql_driver_Result) RowsAffected() (int64, error) { return W.WRowsAffected() }
// _database_sql_driver_Rows is an interface wrapper for Rows type
type _database_sql_driver_Rows struct {
WClose func() error
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_Rows) Close() error { return W.WClose() }
func (W _database_sql_driver_Rows) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_Rows) Next(dest []driver.Value) error { return W.WNext(dest) }
// _database_sql_driver_RowsColumnTypeDatabaseTypeName is an interface wrapper for RowsColumnTypeDatabaseTypeName type
type _database_sql_driver_RowsColumnTypeDatabaseTypeName struct {
WClose func() error
WColumnTypeDatabaseTypeName func(index int) string
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypeDatabaseTypeName) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypeDatabaseTypeName) ColumnTypeDatabaseTypeName(index int) string {
return W.WColumnTypeDatabaseTypeName(index)
}
func (W _database_sql_driver_RowsColumnTypeDatabaseTypeName) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypeDatabaseTypeName) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsColumnTypeLength is an interface wrapper for RowsColumnTypeLength type
type _database_sql_driver_RowsColumnTypeLength struct {
WClose func() error
WColumnTypeLength func(index int) (length int64, ok bool)
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypeLength) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypeLength) ColumnTypeLength(index int) (length int64, ok bool) {
return W.WColumnTypeLength(index)
}
func (W _database_sql_driver_RowsColumnTypeLength) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypeLength) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsColumnTypeNullable is an interface wrapper for RowsColumnTypeNullable type
type _database_sql_driver_RowsColumnTypeNullable struct {
WClose func() error
WColumnTypeNullable func(index int) (nullable bool, ok bool)
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypeNullable) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypeNullable) ColumnTypeNullable(index int) (nullable bool, ok bool) {
return W.WColumnTypeNullable(index)
}
func (W _database_sql_driver_RowsColumnTypeNullable) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypeNullable) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsColumnTypePrecisionScale is an interface wrapper for RowsColumnTypePrecisionScale type
type _database_sql_driver_RowsColumnTypePrecisionScale struct {
WClose func() error
WColumnTypePrecisionScale func(index int) (precision int64, scale int64, ok bool)
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypePrecisionScale) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypePrecisionScale) ColumnTypePrecisionScale(index int) (precision int64, scale int64, ok bool) {
return W.WColumnTypePrecisionScale(index)
}
func (W _database_sql_driver_RowsColumnTypePrecisionScale) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypePrecisionScale) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsColumnTypeScanType is an interface wrapper for RowsColumnTypeScanType type
type _database_sql_driver_RowsColumnTypeScanType struct {
WClose func() error
WColumnTypeScanType func(index int) reflect.Type
WColumns func() []string
WNext func(dest []driver.Value) error
}
func (W _database_sql_driver_RowsColumnTypeScanType) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsColumnTypeScanType) ColumnTypeScanType(index int) reflect.Type {
return W.WColumnTypeScanType(index)
}
func (W _database_sql_driver_RowsColumnTypeScanType) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsColumnTypeScanType) Next(dest []driver.Value) error {
return W.WNext(dest)
}
// _database_sql_driver_RowsNextResultSet is an interface wrapper for RowsNextResultSet type
type _database_sql_driver_RowsNextResultSet struct {
WClose func() error
WColumns func() []string
WHasNextResultSet func() bool
WNext func(dest []driver.Value) error
WNextResultSet func() error
}
func (W _database_sql_driver_RowsNextResultSet) Close() error { return W.WClose() }
func (W _database_sql_driver_RowsNextResultSet) Columns() []string { return W.WColumns() }
func (W _database_sql_driver_RowsNextResultSet) HasNextResultSet() bool {
return W.WHasNextResultSet()
}
func (W _database_sql_driver_RowsNextResultSet) Next(dest []driver.Value) error {
return W.WNext(dest)
}
func (W _database_sql_driver_RowsNextResultSet) NextResultSet() error { return W.WNextResultSet() }
// _database_sql_driver_SessionResetter is an interface wrapper for SessionResetter type
type _database_sql_driver_SessionResetter struct {
WResetSession func(ctx context.Context) error
}
func (W _database_sql_driver_SessionResetter) ResetSession(ctx context.Context) error {
return W.WResetSession(ctx)
}
// _database_sql_driver_Stmt is an interface wrapper for Stmt type
type _database_sql_driver_Stmt struct {
WClose func() error
WExec func(args []driver.Value) (driver.Result, error)
WNumInput func() int
WQuery func(args []driver.Value) (driver.Rows, error)
}
func (W _database_sql_driver_Stmt) Close() error { return W.WClose() }
func (W _database_sql_driver_Stmt) Exec(args []driver.Value) (driver.Result, error) {
return W.WExec(args)
}
func (W _database_sql_driver_Stmt) NumInput() int { return W.WNumInput() }
func (W _database_sql_driver_Stmt) Query(args []driver.Value) (driver.Rows, error) {
return W.WQuery(args)
}
// _database_sql_driver_StmtExecContext is an interface wrapper for StmtExecContext type
type _database_sql_driver_StmtExecContext struct {
WExecContext func(ctx context.Context, args []driver.NamedValue) (driver.Result, error)
}
func (W _database_sql_driver_StmtExecContext) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) {
return W.WExecContext(ctx, args)
}
// _database_sql_driver_StmtQueryContext is an interface wrapper for StmtQueryContext type
type _database_sql_driver_StmtQueryContext struct {
WQueryContext func(ctx context.Context, args []driver.NamedValue) (driver.Rows, error)
}
func (W _database_sql_driver_StmtQueryContext) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) {
return W.WQueryContext(ctx, args)
}
// _database_sql_driver_Tx is an interface wrapper for Tx type
type _database_sql_driver_Tx struct {
WCommit func() error
WRollback func() error
}
func (W _database_sql_driver_Tx) Commit() error { return W.WCommit() }
func (W _database_sql_driver_Tx) Rollback() error { return W.WRollback() }
// _database_sql_driver_Value is an interface wrapper for Value type
type _database_sql_driver_Value struct {
}
// _database_sql_driver_ValueConverter is an interface wrapper for ValueConverter type
type _database_sql_driver_ValueConverter struct {
WConvertValue func(v interface{}) (driver.Value, error)
}
func (W _database_sql_driver_ValueConverter) ConvertValue(v interface{}) (driver.Value, error) {
return W.WConvertValue(v)
}
// _database_sql_driver_Valuer is an interface wrapper for Valuer type
type _database_sql_driver_Valuer struct {
WValue func() (driver.Value, error)
}
func (W _database_sql_driver_Valuer) Value() (driver.Value, error) { return W.WValue() }

218
stdlib/go1_11_debug_dwarf.go
View File

@@ -1,218 +0,0 @@
// Code generated by 'goexports debug/dwarf'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"debug/dwarf"
"reflect"
)
func init() {
Symbols["debug/dwarf"] = map[string]reflect.Value{
// function, constant and variable definitions
"AttrAbstractOrigin": reflect.ValueOf(dwarf.AttrAbstractOrigin),
"AttrAccessibility": reflect.ValueOf(dwarf.AttrAccessibility),
"AttrAddrClass": reflect.ValueOf(dwarf.AttrAddrClass),
"AttrAllocated": reflect.ValueOf(dwarf.AttrAllocated),
"AttrArtificial": reflect.ValueOf(dwarf.AttrArtificial),
"AttrAssociated": reflect.ValueOf(dwarf.AttrAssociated),
"AttrBaseTypes": reflect.ValueOf(dwarf.AttrBaseTypes),
"AttrBitOffset": reflect.ValueOf(dwarf.AttrBitOffset),
"AttrBitSize": reflect.ValueOf(dwarf.AttrBitSize),
"AttrByteSize": reflect.ValueOf(dwarf.AttrByteSize),
"AttrCallColumn": reflect.ValueOf(dwarf.AttrCallColumn),
"AttrCallFile": reflect.ValueOf(dwarf.AttrCallFile),
"AttrCallLine": reflect.ValueOf(dwarf.AttrCallLine),
"AttrCalling": reflect.ValueOf(dwarf.AttrCalling),
"AttrCommonRef": reflect.ValueOf(dwarf.AttrCommonRef),
"AttrCompDir": reflect.ValueOf(dwarf.AttrCompDir),
"AttrConstValue": reflect.ValueOf(dwarf.AttrConstValue),
"AttrContainingType": reflect.ValueOf(dwarf.AttrContainingType),
"AttrCount": reflect.ValueOf(dwarf.AttrCount),
"AttrDataLocation": reflect.ValueOf(dwarf.AttrDataLocation),
"AttrDataMemberLoc": reflect.ValueOf(dwarf.AttrDataMemberLoc),
"AttrDeclColumn": reflect.ValueOf(dwarf.AttrDeclColumn),
"AttrDeclFile": reflect.ValueOf(dwarf.AttrDeclFile),
"AttrDeclLine": reflect.ValueOf(dwarf.AttrDeclLine),
"AttrDeclaration": reflect.ValueOf(dwarf.AttrDeclaration),
"AttrDefaultValue": reflect.ValueOf(dwarf.AttrDefaultValue),
"AttrDescription": reflect.ValueOf(dwarf.AttrDescription),
"AttrDiscr": reflect.ValueOf(dwarf.AttrDiscr),
"AttrDiscrList": reflect.ValueOf(dwarf.AttrDiscrList),
"AttrDiscrValue": reflect.ValueOf(dwarf.AttrDiscrValue),
"AttrEncoding": reflect.ValueOf(dwarf.AttrEncoding),
"AttrEntrypc": reflect.ValueOf(dwarf.AttrEntrypc),
"AttrExtension": reflect.ValueOf(dwarf.AttrExtension),
"AttrExternal": reflect.ValueOf(dwarf.AttrExternal),
"AttrFrameBase": reflect.ValueOf(dwarf.AttrFrameBase),
"AttrFriend": reflect.ValueOf(dwarf.AttrFriend),
"AttrHighpc": reflect.ValueOf(dwarf.AttrHighpc),
"AttrIdentifierCase": reflect.ValueOf(dwarf.AttrIdentifierCase),
"AttrImport": reflect.ValueOf(dwarf.AttrImport),
"AttrInline": reflect.ValueOf(dwarf.AttrInline),
"AttrIsOptional": reflect.ValueOf(dwarf.AttrIsOptional),
"AttrLanguage": reflect.ValueOf(dwarf.AttrLanguage),
"AttrLocation": reflect.ValueOf(dwarf.AttrLocation),
"AttrLowerBound": reflect.ValueOf(dwarf.AttrLowerBound),
"AttrLowpc": reflect.ValueOf(dwarf.AttrLowpc),
"AttrMacroInfo": reflect.ValueOf(dwarf.AttrMacroInfo),
"AttrName": reflect.ValueOf(dwarf.AttrName),
"AttrNamelistItem": reflect.ValueOf(dwarf.AttrNamelistItem),
"AttrOrdering": reflect.ValueOf(dwarf.AttrOrdering),
"AttrPriority": reflect.ValueOf(dwarf.AttrPriority),
"AttrProducer": reflect.ValueOf(dwarf.AttrProducer),
"AttrPrototyped": reflect.ValueOf(dwarf.AttrPrototyped),
"AttrRanges": reflect.ValueOf(dwarf.AttrRanges),
"AttrReturnAddr": reflect.ValueOf(dwarf.AttrReturnAddr),
"AttrSegment": reflect.ValueOf(dwarf.AttrSegment),
"AttrSibling": reflect.ValueOf(dwarf.AttrSibling),
"AttrSpecification": reflect.ValueOf(dwarf.AttrSpecification),
"AttrStartScope": reflect.ValueOf(dwarf.AttrStartScope),
"AttrStaticLink": reflect.ValueOf(dwarf.AttrStaticLink),
"AttrStmtList": reflect.ValueOf(dwarf.AttrStmtList),
"AttrStride": reflect.ValueOf(dwarf.AttrStride),
"AttrStrideSize": reflect.ValueOf(dwarf.AttrStrideSize),
"AttrStringLength": reflect.ValueOf(dwarf.AttrStringLength),
"AttrTrampoline": reflect.ValueOf(dwarf.AttrTrampoline),
"AttrType": reflect.ValueOf(dwarf.AttrType),
"AttrUpperBound": reflect.ValueOf(dwarf.AttrUpperBound),
"AttrUseLocation": reflect.ValueOf(dwarf.AttrUseLocation),
"AttrUseUTF8": reflect.ValueOf(dwarf.AttrUseUTF8),
"AttrVarParam": reflect.ValueOf(dwarf.AttrVarParam),
"AttrVirtuality": reflect.ValueOf(dwarf.AttrVirtuality),
"AttrVisibility": reflect.ValueOf(dwarf.AttrVisibility),
"AttrVtableElemLoc": reflect.ValueOf(dwarf.AttrVtableElemLoc),
"ClassAddress": reflect.ValueOf(dwarf.ClassAddress),
"ClassBlock": reflect.ValueOf(dwarf.ClassBlock),
"ClassConstant": reflect.ValueOf(dwarf.ClassConstant),
"ClassExprLoc": reflect.ValueOf(dwarf.ClassExprLoc),
"ClassFlag": reflect.ValueOf(dwarf.ClassFlag),
"ClassLinePtr": reflect.ValueOf(dwarf.ClassLinePtr),
"ClassLocListPtr": reflect.ValueOf(dwarf.ClassLocListPtr),
"ClassMacPtr": reflect.ValueOf(dwarf.ClassMacPtr),
"ClassRangeListPtr": reflect.ValueOf(dwarf.ClassRangeListPtr),
"ClassReference": reflect.ValueOf(dwarf.ClassReference),
"ClassReferenceAlt": reflect.ValueOf(dwarf.ClassReferenceAlt),
"ClassReferenceSig": reflect.ValueOf(dwarf.ClassReferenceSig),
"ClassString": reflect.ValueOf(dwarf.ClassString),
"ClassStringAlt": reflect.ValueOf(dwarf.ClassStringAlt),
"ClassUnknown": reflect.ValueOf(dwarf.ClassUnknown),
"ErrUnknownPC": reflect.ValueOf(&dwarf.ErrUnknownPC).Elem(),
"New": reflect.ValueOf(dwarf.New),
"TagAccessDeclaration": reflect.ValueOf(dwarf.TagAccessDeclaration),
"TagArrayType": reflect.ValueOf(dwarf.TagArrayType),
"TagBaseType": reflect.ValueOf(dwarf.TagBaseType),
"TagCatchDwarfBlock": reflect.ValueOf(dwarf.TagCatchDwarfBlock),
"TagClassType": reflect.ValueOf(dwarf.TagClassType),
"TagCommonDwarfBlock": reflect.ValueOf(dwarf.TagCommonDwarfBlock),
"TagCommonInclusion": reflect.ValueOf(dwarf.TagCommonInclusion),
"TagCompileUnit": reflect.ValueOf(dwarf.TagCompileUnit),
"TagCondition": reflect.ValueOf(dwarf.TagCondition),
"TagConstType": reflect.ValueOf(dwarf.TagConstType),
"TagConstant": reflect.ValueOf(dwarf.TagConstant),
"TagDwarfProcedure": reflect.ValueOf(dwarf.TagDwarfProcedure),
"TagEntryPoint": reflect.ValueOf(dwarf.TagEntryPoint),
"TagEnumerationType": reflect.ValueOf(dwarf.TagEnumerationType),
"TagEnumerator": reflect.ValueOf(dwarf.TagEnumerator),
"TagFileType": reflect.ValueOf(dwarf.TagFileType),
"TagFormalParameter": reflect.ValueOf(dwarf.TagFormalParameter),
"TagFriend": reflect.ValueOf(dwarf.TagFriend),
"TagImportedDeclaration": reflect.ValueOf(dwarf.TagImportedDeclaration),
"TagImportedModule": reflect.ValueOf(dwarf.TagImportedModule),
"TagImportedUnit": reflect.ValueOf(dwarf.TagImportedUnit),
"TagInheritance": reflect.ValueOf(dwarf.TagInheritance),
"TagInlinedSubroutine": reflect.ValueOf(dwarf.TagInlinedSubroutine),
"TagInterfaceType": reflect.ValueOf(dwarf.TagInterfaceType),
"TagLabel": reflect.ValueOf(dwarf.TagLabel),
"TagLexDwarfBlock": reflect.ValueOf(dwarf.TagLexDwarfBlock),
"TagMember": reflect.ValueOf(dwarf.TagMember),
"TagModule": reflect.ValueOf(dwarf.TagModule),
"TagMutableType": reflect.ValueOf(dwarf.TagMutableType),
"TagNamelist": reflect.ValueOf(dwarf.TagNamelist),
"TagNamelistItem": reflect.ValueOf(dwarf.TagNamelistItem),
"TagNamespace": reflect.ValueOf(dwarf.TagNamespace),
"TagPackedType": reflect.ValueOf(dwarf.TagPackedType),
"TagPartialUnit": reflect.ValueOf(dwarf.TagPartialUnit),
"TagPointerType": reflect.ValueOf(dwarf.TagPointerType),
"TagPtrToMemberType": reflect.ValueOf(dwarf.TagPtrToMemberType),
"TagReferenceType": reflect.ValueOf(dwarf.TagReferenceType),
"TagRestrictType": reflect.ValueOf(dwarf.TagRestrictType),
"TagRvalueReferenceType": reflect.ValueOf(dwarf.TagRvalueReferenceType),
"TagSetType": reflect.ValueOf(dwarf.TagSetType),
"TagSharedType": reflect.ValueOf(dwarf.TagSharedType),
"TagStringType": reflect.ValueOf(dwarf.TagStringType),
"TagStructType": reflect.ValueOf(dwarf.TagStructType),
"TagSubprogram": reflect.ValueOf(dwarf.TagSubprogram),
"TagSubrangeType": reflect.ValueOf(dwarf.TagSubrangeType),
"TagSubroutineType": reflect.ValueOf(dwarf.TagSubroutineType),
"TagTemplateAlias": reflect.ValueOf(dwarf.TagTemplateAlias),
"TagTemplateTypeParameter": reflect.ValueOf(dwarf.TagTemplateTypeParameter),
"TagTemplateValueParameter": reflect.ValueOf(dwarf.TagTemplateValueParameter),
"TagThrownType": reflect.ValueOf(dwarf.TagThrownType),
"TagTryDwarfBlock": reflect.ValueOf(dwarf.TagTryDwarfBlock),
"TagTypeUnit": reflect.ValueOf(dwarf.TagTypeUnit),
"TagTypedef": reflect.ValueOf(dwarf.TagTypedef),
"TagUnionType": reflect.ValueOf(dwarf.TagUnionType),
"TagUnspecifiedParameters": reflect.ValueOf(dwarf.TagUnspecifiedParameters),
"TagUnspecifiedType": reflect.ValueOf(dwarf.TagUnspecifiedType),
"TagVariable": reflect.ValueOf(dwarf.TagVariable),
"TagVariant": reflect.ValueOf(dwarf.TagVariant),
"TagVariantPart": reflect.ValueOf(dwarf.TagVariantPart),
"TagVolatileType": reflect.ValueOf(dwarf.TagVolatileType),
"TagWithStmt": reflect.ValueOf(dwarf.TagWithStmt),
// type definitions
"AddrType": reflect.ValueOf((*dwarf.AddrType)(nil)),
"ArrayType": reflect.ValueOf((*dwarf.ArrayType)(nil)),
"Attr": reflect.ValueOf((*dwarf.Attr)(nil)),
"BasicType": reflect.ValueOf((*dwarf.BasicType)(nil)),
"BoolType": reflect.ValueOf((*dwarf.BoolType)(nil)),
"CharType": reflect.ValueOf((*dwarf.CharType)(nil)),
"Class": reflect.ValueOf((*dwarf.Class)(nil)),
"CommonType": reflect.ValueOf((*dwarf.CommonType)(nil)),
"ComplexType": reflect.ValueOf((*dwarf.ComplexType)(nil)),
"Data": reflect.ValueOf((*dwarf.Data)(nil)),
"DecodeError": reflect.ValueOf((*dwarf.DecodeError)(nil)),
"DotDotDotType": reflect.ValueOf((*dwarf.DotDotDotType)(nil)),
"Entry": reflect.ValueOf((*dwarf.Entry)(nil)),
"EnumType": reflect.ValueOf((*dwarf.EnumType)(nil)),
"EnumValue": reflect.ValueOf((*dwarf.EnumValue)(nil)),
"Field": reflect.ValueOf((*dwarf.Field)(nil)),
"FloatType": reflect.ValueOf((*dwarf.FloatType)(nil)),
"FuncType": reflect.ValueOf((*dwarf.FuncType)(nil)),
"IntType": reflect.ValueOf((*dwarf.IntType)(nil)),
"LineEntry": reflect.ValueOf((*dwarf.LineEntry)(nil)),
"LineFile": reflect.ValueOf((*dwarf.LineFile)(nil)),
"LineReader": reflect.ValueOf((*dwarf.LineReader)(nil)),
"LineReaderPos": reflect.ValueOf((*dwarf.LineReaderPos)(nil)),
"Offset": reflect.ValueOf((*dwarf.Offset)(nil)),
"PtrType": reflect.ValueOf((*dwarf.PtrType)(nil)),
"QualType": reflect.ValueOf((*dwarf.QualType)(nil)),
"Reader": reflect.ValueOf((*dwarf.Reader)(nil)),
"StructField": reflect.ValueOf((*dwarf.StructField)(nil)),
"StructType": reflect.ValueOf((*dwarf.StructType)(nil)),
"Tag": reflect.ValueOf((*dwarf.Tag)(nil)),
"Type": reflect.ValueOf((*dwarf.Type)(nil)),
"TypedefType": reflect.ValueOf((*dwarf.TypedefType)(nil)),
"UcharType": reflect.ValueOf((*dwarf.UcharType)(nil)),
"UintType": reflect.ValueOf((*dwarf.UintType)(nil)),
"UnspecifiedType": reflect.ValueOf((*dwarf.UnspecifiedType)(nil)),
"VoidType": reflect.ValueOf((*dwarf.VoidType)(nil)),
// interface wrapper definitions
"_Type": reflect.ValueOf((*_debug_dwarf_Type)(nil)),
}
}
// _debug_dwarf_Type is an interface wrapper for Type type
type _debug_dwarf_Type struct {
WCommon func() *dwarf.CommonType
WSize func() int64
WString func() string
}
func (W _debug_dwarf_Type) Common() *dwarf.CommonType { return W.WCommon() }
func (W _debug_dwarf_Type) Size() int64 { return W.WSize() }
func (W _debug_dwarf_Type) String() string { return W.WString() }

1251
stdlib/go1_11_debug_elf.go
View File

File diff suppressed because it is too large Load Diff

28
stdlib/go1_11_debug_gosym.go
View File

@@ -1,28 +0,0 @@
// Code generated by 'goexports debug/gosym'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"debug/gosym"
"reflect"
)
func init() {
Symbols["debug/gosym"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewLineTable": reflect.ValueOf(gosym.NewLineTable),
"NewTable": reflect.ValueOf(gosym.NewTable),
// type definitions
"DecodingError": reflect.ValueOf((*gosym.DecodingError)(nil)),
"Func": reflect.ValueOf((*gosym.Func)(nil)),
"LineTable": reflect.ValueOf((*gosym.LineTable)(nil)),
"Obj": reflect.ValueOf((*gosym.Obj)(nil)),
"Sym": reflect.ValueOf((*gosym.Sym)(nil)),
"Table": reflect.ValueOf((*gosym.Table)(nil)),
"UnknownFileError": reflect.ValueOf((*gosym.UnknownFileError)(nil)),
"UnknownLineError": reflect.ValueOf((*gosym.UnknownLineError)(nil)),
}
}

156
stdlib/go1_11_debug_macho.go
View File

@@ -1,156 +0,0 @@
// Code generated by 'goexports debug/macho'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"debug/macho"
"reflect"
)
func init() {
Symbols["debug/macho"] = map[string]reflect.Value{
// function, constant and variable definitions
"ARM64_RELOC_ADDEND": reflect.ValueOf(macho.ARM64_RELOC_ADDEND),
"ARM64_RELOC_BRANCH26": reflect.ValueOf(macho.ARM64_RELOC_BRANCH26),
"ARM64_RELOC_GOT_LOAD_PAGE21": reflect.ValueOf(macho.ARM64_RELOC_GOT_LOAD_PAGE21),
"ARM64_RELOC_GOT_LOAD_PAGEOFF12": reflect.ValueOf(macho.ARM64_RELOC_GOT_LOAD_PAGEOFF12),
"ARM64_RELOC_PAGE21": reflect.ValueOf(macho.ARM64_RELOC_PAGE21),
"ARM64_RELOC_PAGEOFF12": reflect.ValueOf(macho.ARM64_RELOC_PAGEOFF12),
"ARM64_RELOC_POINTER_TO_GOT": reflect.ValueOf(macho.ARM64_RELOC_POINTER_TO_GOT),
"ARM64_RELOC_SUBTRACTOR": reflect.ValueOf(macho.ARM64_RELOC_SUBTRACTOR),
"ARM64_RELOC_TLVP_LOAD_PAGE21": reflect.ValueOf(macho.ARM64_RELOC_TLVP_LOAD_PAGE21),
"ARM64_RELOC_TLVP_LOAD_PAGEOFF12": reflect.ValueOf(macho.ARM64_RELOC_TLVP_LOAD_PAGEOFF12),
"ARM64_RELOC_UNSIGNED": reflect.ValueOf(macho.ARM64_RELOC_UNSIGNED),
"ARM_RELOC_BR24": reflect.ValueOf(macho.ARM_RELOC_BR24),
"ARM_RELOC_HALF": reflect.ValueOf(macho.ARM_RELOC_HALF),
"ARM_RELOC_HALF_SECTDIFF": reflect.ValueOf(macho.ARM_RELOC_HALF_SECTDIFF),
"ARM_RELOC_LOCAL_SECTDIFF": reflect.ValueOf(macho.ARM_RELOC_LOCAL_SECTDIFF),
"ARM_RELOC_PAIR": reflect.ValueOf(macho.ARM_RELOC_PAIR),
"ARM_RELOC_PB_LA_PTR": reflect.ValueOf(macho.ARM_RELOC_PB_LA_PTR),
"ARM_RELOC_SECTDIFF": reflect.ValueOf(macho.ARM_RELOC_SECTDIFF),
"ARM_RELOC_VANILLA": reflect.ValueOf(macho.ARM_RELOC_VANILLA),
"ARM_THUMB_32BIT_BRANCH": reflect.ValueOf(macho.ARM_THUMB_32BIT_BRANCH),
"ARM_THUMB_RELOC_BR22": reflect.ValueOf(macho.ARM_THUMB_RELOC_BR22),
"Cpu386": reflect.ValueOf(macho.Cpu386),
"CpuAmd64": reflect.ValueOf(macho.CpuAmd64),
"CpuArm": reflect.ValueOf(macho.CpuArm),
"CpuArm64": reflect.ValueOf(macho.CpuArm64),
"CpuPpc": reflect.ValueOf(macho.CpuPpc),
"CpuPpc64": reflect.ValueOf(macho.CpuPpc64),
"ErrNotFat": reflect.ValueOf(&macho.ErrNotFat).Elem(),
"FlagAllModsBound": reflect.ValueOf(macho.FlagAllModsBound),
"FlagAllowStackExecution": reflect.ValueOf(macho.FlagAllowStackExecution),
"FlagAppExtensionSafe": reflect.ValueOf(macho.FlagAppExtensionSafe),
"FlagBindAtLoad": reflect.ValueOf(macho.FlagBindAtLoad),
"FlagBindsToWeak": reflect.ValueOf(macho.FlagBindsToWeak),
"FlagCanonical": reflect.ValueOf(macho.FlagCanonical),
"FlagDeadStrippableDylib": reflect.ValueOf(macho.FlagDeadStrippableDylib),
"FlagDyldLink": reflect.ValueOf(macho.FlagDyldLink),
"FlagForceFlat": reflect.ValueOf(macho.FlagForceFlat),
"FlagHasTLVDescriptors": reflect.ValueOf(macho.FlagHasTLVDescriptors),
"FlagIncrLink": reflect.ValueOf(macho.FlagIncrLink),
"FlagLazyInit": reflect.ValueOf(macho.FlagLazyInit),
"FlagNoFixPrebinding": reflect.ValueOf(macho.FlagNoFixPrebinding),
"FlagNoHeapExecution": reflect.ValueOf(macho.FlagNoHeapExecution),
"FlagNoMultiDefs": reflect.ValueOf(macho.FlagNoMultiDefs),
"FlagNoReexportedDylibs": reflect.ValueOf(macho.FlagNoReexportedDylibs),
"FlagNoUndefs": reflect.ValueOf(macho.FlagNoUndefs),
"FlagPIE": reflect.ValueOf(macho.FlagPIE),
"FlagPrebindable": reflect.ValueOf(macho.FlagPrebindable),
"FlagPrebound": reflect.ValueOf(macho.FlagPrebound),
"FlagRootSafe": reflect.ValueOf(macho.FlagRootSafe),
"FlagSetuidSafe": reflect.ValueOf(macho.FlagSetuidSafe),
"FlagSplitSegs": reflect.ValueOf(macho.FlagSplitSegs),
"FlagSubsectionsViaSymbols": reflect.ValueOf(macho.FlagSubsectionsViaSymbols),
"FlagTwoLevel": reflect.ValueOf(macho.FlagTwoLevel),
"FlagWeakDefines": reflect.ValueOf(macho.FlagWeakDefines),
"GENERIC_RELOC_LOCAL_SECTDIFF": reflect.ValueOf(macho.GENERIC_RELOC_LOCAL_SECTDIFF),
"GENERIC_RELOC_PAIR": reflect.ValueOf(macho.GENERIC_RELOC_PAIR),
"GENERIC_RELOC_PB_LA_PTR": reflect.ValueOf(macho.GENERIC_RELOC_PB_LA_PTR),
"GENERIC_RELOC_SECTDIFF": reflect.ValueOf(macho.GENERIC_RELOC_SECTDIFF),
"GENERIC_RELOC_TLV": reflect.ValueOf(macho.GENERIC_RELOC_TLV),
"GENERIC_RELOC_VANILLA": reflect.ValueOf(macho.GENERIC_RELOC_VANILLA),
"LoadCmdDylib": reflect.ValueOf(macho.LoadCmdDylib),
"LoadCmdDylinker": reflect.ValueOf(macho.LoadCmdDylinker),
"LoadCmdDysymtab": reflect.ValueOf(macho.LoadCmdDysymtab),
"LoadCmdRpath": reflect.ValueOf(macho.LoadCmdRpath),
"LoadCmdSegment": reflect.ValueOf(macho.LoadCmdSegment),
"LoadCmdSegment64": reflect.ValueOf(macho.LoadCmdSegment64),
"LoadCmdSymtab": reflect.ValueOf(macho.LoadCmdSymtab),
"LoadCmdThread": reflect.ValueOf(macho.LoadCmdThread),
"LoadCmdUnixThread": reflect.ValueOf(macho.LoadCmdUnixThread),
"Magic32": reflect.ValueOf(macho.Magic32),
"Magic64": reflect.ValueOf(macho.Magic64),
"MagicFat": reflect.ValueOf(macho.MagicFat),
"NewFatFile": reflect.ValueOf(macho.NewFatFile),
"NewFile": reflect.ValueOf(macho.NewFile),
"Open": reflect.ValueOf(macho.Open),
"OpenFat": reflect.ValueOf(macho.OpenFat),
"TypeBundle": reflect.ValueOf(macho.TypeBundle),
"TypeDylib": reflect.ValueOf(macho.TypeDylib),
"TypeExec": reflect.ValueOf(macho.TypeExec),
"TypeObj": reflect.ValueOf(macho.TypeObj),
"X86_64_RELOC_BRANCH": reflect.ValueOf(macho.X86_64_RELOC_BRANCH),
"X86_64_RELOC_GOT": reflect.ValueOf(macho.X86_64_RELOC_GOT),
"X86_64_RELOC_GOT_LOAD": reflect.ValueOf(macho.X86_64_RELOC_GOT_LOAD),
"X86_64_RELOC_SIGNED": reflect.ValueOf(macho.X86_64_RELOC_SIGNED),
"X86_64_RELOC_SIGNED_1": reflect.ValueOf(macho.X86_64_RELOC_SIGNED_1),
"X86_64_RELOC_SIGNED_2": reflect.ValueOf(macho.X86_64_RELOC_SIGNED_2),
"X86_64_RELOC_SIGNED_4": reflect.ValueOf(macho.X86_64_RELOC_SIGNED_4),
"X86_64_RELOC_SUBTRACTOR": reflect.ValueOf(macho.X86_64_RELOC_SUBTRACTOR),
"X86_64_RELOC_TLV": reflect.ValueOf(macho.X86_64_RELOC_TLV),
"X86_64_RELOC_UNSIGNED": reflect.ValueOf(macho.X86_64_RELOC_UNSIGNED),
// type definitions
"Cpu": reflect.ValueOf((*macho.Cpu)(nil)),
"Dylib": reflect.ValueOf((*macho.Dylib)(nil)),
"DylibCmd": reflect.ValueOf((*macho.DylibCmd)(nil)),
"Dysymtab": reflect.ValueOf((*macho.Dysymtab)(nil)),
"DysymtabCmd": reflect.ValueOf((*macho.DysymtabCmd)(nil)),
"FatArch": reflect.ValueOf((*macho.FatArch)(nil)),
"FatArchHeader": reflect.ValueOf((*macho.FatArchHeader)(nil)),
"FatFile": reflect.ValueOf((*macho.FatFile)(nil)),
"File": reflect.ValueOf((*macho.File)(nil)),
"FileHeader": reflect.ValueOf((*macho.FileHeader)(nil)),
"FormatError": reflect.ValueOf((*macho.FormatError)(nil)),
"Load": reflect.ValueOf((*macho.Load)(nil)),
"LoadBytes": reflect.ValueOf((*macho.LoadBytes)(nil)),
"LoadCmd": reflect.ValueOf((*macho.LoadCmd)(nil)),
"Nlist32": reflect.ValueOf((*macho.Nlist32)(nil)),
"Nlist64": reflect.ValueOf((*macho.Nlist64)(nil)),
"Regs386": reflect.ValueOf((*macho.Regs386)(nil)),
"RegsAMD64": reflect.ValueOf((*macho.RegsAMD64)(nil)),
"Reloc": reflect.ValueOf((*macho.Reloc)(nil)),
"RelocTypeARM": reflect.ValueOf((*macho.RelocTypeARM)(nil)),
"RelocTypeARM64": reflect.ValueOf((*macho.RelocTypeARM64)(nil)),
"RelocTypeGeneric": reflect.ValueOf((*macho.RelocTypeGeneric)(nil)),
"RelocTypeX86_64": reflect.ValueOf((*macho.RelocTypeX86_64)(nil)),
"Rpath": reflect.ValueOf((*macho.Rpath)(nil)),
"RpathCmd": reflect.ValueOf((*macho.RpathCmd)(nil)),
"Section": reflect.ValueOf((*macho.Section)(nil)),
"Section32": reflect.ValueOf((*macho.Section32)(nil)),
"Section64": reflect.ValueOf((*macho.Section64)(nil)),
"SectionHeader": reflect.ValueOf((*macho.SectionHeader)(nil)),
"Segment": reflect.ValueOf((*macho.Segment)(nil)),
"Segment32": reflect.ValueOf((*macho.Segment32)(nil)),
"Segment64": reflect.ValueOf((*macho.Segment64)(nil)),
"SegmentHeader": reflect.ValueOf((*macho.SegmentHeader)(nil)),
"Symbol": reflect.ValueOf((*macho.Symbol)(nil)),
"Symtab": reflect.ValueOf((*macho.Symtab)(nil)),
"SymtabCmd": reflect.ValueOf((*macho.SymtabCmd)(nil)),
"Thread": reflect.ValueOf((*macho.Thread)(nil)),
"Type": reflect.ValueOf((*macho.Type)(nil)),
// interface wrapper definitions
"_Load": reflect.ValueOf((*_debug_macho_Load)(nil)),
}
}
// _debug_macho_Load is an interface wrapper for Load type
type _debug_macho_Load struct {
WRaw func() []byte
}
func (W _debug_macho_Load) Raw() []byte { return W.WRaw() }

71
stdlib/go1_11_debug_pe.go
View File

@@ -1,71 +0,0 @@
// Code generated by 'goexports debug/pe'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"debug/pe"
"reflect"
)
func init() {
Symbols["debug/pe"] = map[string]reflect.Value{
// function, constant and variable definitions
"COFFSymbolSize": reflect.ValueOf(pe.COFFSymbolSize),
"IMAGE_DIRECTORY_ENTRY_ARCHITECTURE": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_ARCHITECTURE),
"IMAGE_DIRECTORY_ENTRY_BASERELOC": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_BASERELOC),
"IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT),
"IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR),
"IMAGE_DIRECTORY_ENTRY_DEBUG": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_DEBUG),
"IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT),
"IMAGE_DIRECTORY_ENTRY_EXCEPTION": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_EXCEPTION),
"IMAGE_DIRECTORY_ENTRY_EXPORT": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_EXPORT),
"IMAGE_DIRECTORY_ENTRY_GLOBALPTR": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_GLOBALPTR),
"IMAGE_DIRECTORY_ENTRY_IAT": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_IAT),
"IMAGE_DIRECTORY_ENTRY_IMPORT": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_IMPORT),
"IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG),
"IMAGE_DIRECTORY_ENTRY_RESOURCE": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_RESOURCE),
"IMAGE_DIRECTORY_ENTRY_SECURITY": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_SECURITY),
"IMAGE_DIRECTORY_ENTRY_TLS": reflect.ValueOf(pe.IMAGE_DIRECTORY_ENTRY_TLS),
"IMAGE_FILE_MACHINE_AM33": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_AM33),
"IMAGE_FILE_MACHINE_AMD64": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_AMD64),
"IMAGE_FILE_MACHINE_ARM": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_ARM),
"IMAGE_FILE_MACHINE_ARM64": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_ARM64),
"IMAGE_FILE_MACHINE_EBC": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_EBC),
"IMAGE_FILE_MACHINE_I386": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_I386),
"IMAGE_FILE_MACHINE_IA64": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_IA64),
"IMAGE_FILE_MACHINE_M32R": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_M32R),
"IMAGE_FILE_MACHINE_MIPS16": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_MIPS16),
"IMAGE_FILE_MACHINE_MIPSFPU": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_MIPSFPU),
"IMAGE_FILE_MACHINE_MIPSFPU16": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_MIPSFPU16),
"IMAGE_FILE_MACHINE_POWERPC": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_POWERPC),
"IMAGE_FILE_MACHINE_POWERPCFP": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_POWERPCFP),
"IMAGE_FILE_MACHINE_R4000": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_R4000),
"IMAGE_FILE_MACHINE_SH3": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_SH3),
"IMAGE_FILE_MACHINE_SH3DSP": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_SH3DSP),
"IMAGE_FILE_MACHINE_SH4": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_SH4),
"IMAGE_FILE_MACHINE_SH5": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_SH5),
"IMAGE_FILE_MACHINE_THUMB": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_THUMB),
"IMAGE_FILE_MACHINE_UNKNOWN": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_UNKNOWN),
"IMAGE_FILE_MACHINE_WCEMIPSV2": reflect.ValueOf(pe.IMAGE_FILE_MACHINE_WCEMIPSV2),
"NewFile": reflect.ValueOf(pe.NewFile),
"Open": reflect.ValueOf(pe.Open),
// type definitions
"COFFSymbol": reflect.ValueOf((*pe.COFFSymbol)(nil)),
"DataDirectory": reflect.ValueOf((*pe.DataDirectory)(nil)),
"File": reflect.ValueOf((*pe.File)(nil)),
"FileHeader": reflect.ValueOf((*pe.FileHeader)(nil)),
"FormatError": reflect.ValueOf((*pe.FormatError)(nil)),
"ImportDirectory": reflect.ValueOf((*pe.ImportDirectory)(nil)),
"OptionalHeader32": reflect.ValueOf((*pe.OptionalHeader32)(nil)),
"OptionalHeader64": reflect.ValueOf((*pe.OptionalHeader64)(nil)),
"Reloc": reflect.ValueOf((*pe.Reloc)(nil)),
"Section": reflect.ValueOf((*pe.Section)(nil)),
"SectionHeader": reflect.ValueOf((*pe.SectionHeader)(nil)),
"SectionHeader32": reflect.ValueOf((*pe.SectionHeader32)(nil)),
"StringTable": reflect.ValueOf((*pe.StringTable)(nil)),
"Symbol": reflect.ValueOf((*pe.Symbol)(nil)),
}
}

29
stdlib/go1_11_debug_plan9obj.go
View File

@@ -1,29 +0,0 @@
// Code generated by 'goexports debug/plan9obj'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"debug/plan9obj"
"reflect"
)
func init() {
Symbols["debug/plan9obj"] = map[string]reflect.Value{
// function, constant and variable definitions
"Magic386": reflect.ValueOf(plan9obj.Magic386),
"Magic64": reflect.ValueOf(plan9obj.Magic64),
"MagicAMD64": reflect.ValueOf(plan9obj.MagicAMD64),
"MagicARM": reflect.ValueOf(plan9obj.MagicARM),
"NewFile": reflect.ValueOf(plan9obj.NewFile),
"Open": reflect.ValueOf(plan9obj.Open),
// type definitions
"File": reflect.ValueOf((*plan9obj.File)(nil)),
"FileHeader": reflect.ValueOf((*plan9obj.FileHeader)(nil)),
"Section": reflect.ValueOf((*plan9obj.Section)(nil)),
"SectionHeader": reflect.ValueOf((*plan9obj.SectionHeader)(nil)),
"Sym": reflect.ValueOf((*plan9obj.Sym)(nil)),
}
}

56
stdlib/go1_11_encoding.go
View File

@@ -1,56 +0,0 @@
// Code generated by 'goexports encoding'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"encoding"
"reflect"
)
func init() {
Symbols["encoding"] = map[string]reflect.Value{
// type definitions
"BinaryMarshaler": reflect.ValueOf((*encoding.BinaryMarshaler)(nil)),
"BinaryUnmarshaler": reflect.ValueOf((*encoding.BinaryUnmarshaler)(nil)),
"TextMarshaler": reflect.ValueOf((*encoding.TextMarshaler)(nil)),
"TextUnmarshaler": reflect.ValueOf((*encoding.TextUnmarshaler)(nil)),
// interface wrapper definitions
"_BinaryMarshaler": reflect.ValueOf((*_encoding_BinaryMarshaler)(nil)),
"_BinaryUnmarshaler": reflect.ValueOf((*_encoding_BinaryUnmarshaler)(nil)),
"_TextMarshaler": reflect.ValueOf((*_encoding_TextMarshaler)(nil)),
"_TextUnmarshaler": reflect.ValueOf((*_encoding_TextUnmarshaler)(nil)),
}
}
// _encoding_BinaryMarshaler is an interface wrapper for BinaryMarshaler type
type _encoding_BinaryMarshaler struct {
WMarshalBinary func() (data []byte, err error)
}
func (W _encoding_BinaryMarshaler) MarshalBinary() (data []byte, err error) { return W.WMarshalBinary() }
// _encoding_BinaryUnmarshaler is an interface wrapper for BinaryUnmarshaler type
type _encoding_BinaryUnmarshaler struct {
WUnmarshalBinary func(data []byte) error
}
func (W _encoding_BinaryUnmarshaler) UnmarshalBinary(data []byte) error {
return W.WUnmarshalBinary(data)
}
// _encoding_TextMarshaler is an interface wrapper for TextMarshaler type
type _encoding_TextMarshaler struct {
WMarshalText func() (text []byte, err error)
}
func (W _encoding_TextMarshaler) MarshalText() (text []byte, err error) { return W.WMarshalText() }
// _encoding_TextUnmarshaler is an interface wrapper for TextUnmarshaler type
type _encoding_TextUnmarshaler struct {
WUnmarshalText func(text []byte) error
}
func (W _encoding_TextUnmarshaler) UnmarshalText(text []byte) error { return W.WUnmarshalText(text) }

24
stdlib/go1_11_encoding_ascii85.go
View File

@@ -1,24 +0,0 @@
// Code generated by 'goexports encoding/ascii85'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"encoding/ascii85"
"reflect"
)
func init() {
Symbols["encoding/ascii85"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(ascii85.Decode),
"Encode": reflect.ValueOf(ascii85.Encode),
"MaxEncodedLen": reflect.ValueOf(ascii85.MaxEncodedLen),
"NewDecoder": reflect.ValueOf(ascii85.NewDecoder),
"NewEncoder": reflect.ValueOf(ascii85.NewEncoder),
// type definitions
"CorruptInputError": reflect.ValueOf((*ascii85.CorruptInputError)(nil)),
}
}

53
stdlib/go1_11_encoding_asn1.go
View File

@@ -1,53 +0,0 @@
// Code generated by 'goexports encoding/asn1'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"encoding/asn1"
"reflect"
)
func init() {
Symbols["encoding/asn1"] = map[string]reflect.Value{
// function, constant and variable definitions
"ClassApplication": reflect.ValueOf(asn1.ClassApplication),
"ClassContextSpecific": reflect.ValueOf(asn1.ClassContextSpecific),
"ClassPrivate": reflect.ValueOf(asn1.ClassPrivate),
"ClassUniversal": reflect.ValueOf(asn1.ClassUniversal),
"Marshal": reflect.ValueOf(asn1.Marshal),
"MarshalWithParams": reflect.ValueOf(asn1.MarshalWithParams),
"NullBytes": reflect.ValueOf(&asn1.NullBytes).Elem(),
"NullRawValue": reflect.ValueOf(&asn1.NullRawValue).Elem(),
"TagBitString": reflect.ValueOf(asn1.TagBitString),
"TagBoolean": reflect.ValueOf(asn1.TagBoolean),
"TagEnum": reflect.ValueOf(asn1.TagEnum),
"TagGeneralString": reflect.ValueOf(asn1.TagGeneralString),
"TagGeneralizedTime": reflect.ValueOf(asn1.TagGeneralizedTime),
"TagIA5String": reflect.ValueOf(asn1.TagIA5String),
"TagInteger": reflect.ValueOf(asn1.TagInteger),
"TagNull": reflect.ValueOf(asn1.TagNull),
"TagNumericString": reflect.ValueOf(asn1.TagNumericString),
"TagOID": reflect.ValueOf(asn1.TagOID),
"TagOctetString": reflect.ValueOf(asn1.TagOctetString),
"TagPrintableString": reflect.ValueOf(asn1.TagPrintableString),
"TagSequence": reflect.ValueOf(asn1.TagSequence),
"TagSet": reflect.ValueOf(asn1.TagSet),
"TagT61String": reflect.ValueOf(asn1.TagT61String),
"TagUTCTime": reflect.ValueOf(asn1.TagUTCTime),
"TagUTF8String": reflect.ValueOf(asn1.TagUTF8String),
"Unmarshal": reflect.ValueOf(asn1.Unmarshal),
"UnmarshalWithParams": reflect.ValueOf(asn1.UnmarshalWithParams),
// type definitions
"BitString": reflect.ValueOf((*asn1.BitString)(nil)),
"Enumerated": reflect.ValueOf((*asn1.Enumerated)(nil)),
"Flag": reflect.ValueOf((*asn1.Flag)(nil)),
"ObjectIdentifier": reflect.ValueOf((*asn1.ObjectIdentifier)(nil)),
"RawContent": reflect.ValueOf((*asn1.RawContent)(nil)),
"RawValue": reflect.ValueOf((*asn1.RawValue)(nil)),
"StructuralError": reflect.ValueOf((*asn1.StructuralError)(nil)),
"SyntaxError": reflect.ValueOf((*asn1.SyntaxError)(nil)),
}
}

27
stdlib/go1_11_encoding_base32.go
View File

@@ -1,27 +0,0 @@
// Code generated by 'goexports encoding/base32'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"encoding/base32"
"reflect"
)
func init() {
Symbols["encoding/base32"] = map[string]reflect.Value{
// function, constant and variable definitions
"HexEncoding": reflect.ValueOf(&base32.HexEncoding).Elem(),
"NewDecoder": reflect.ValueOf(base32.NewDecoder),
"NewEncoder": reflect.ValueOf(base32.NewEncoder),
"NewEncoding": reflect.ValueOf(base32.NewEncoding),
"NoPadding": reflect.ValueOf(base32.NoPadding),
"StdEncoding": reflect.ValueOf(&base32.StdEncoding).Elem(),
"StdPadding": reflect.ValueOf(base32.StdPadding),
// type definitions
"CorruptInputError": reflect.ValueOf((*base32.CorruptInputError)(nil)),
"Encoding": reflect.ValueOf((*base32.Encoding)(nil)),
}
}

29
stdlib/go1_11_encoding_base64.go
View File

@@ -1,29 +0,0 @@
// Code generated by 'goexports encoding/base64'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"encoding/base64"
"reflect"
)
func init() {
Symbols["encoding/base64"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewDecoder": reflect.ValueOf(base64.NewDecoder),
"NewEncoder": reflect.ValueOf(base64.NewEncoder),
"NewEncoding": reflect.ValueOf(base64.NewEncoding),
"NoPadding": reflect.ValueOf(base64.NoPadding),
"RawStdEncoding": reflect.ValueOf(&base64.RawStdEncoding).Elem(),
"RawURLEncoding": reflect.ValueOf(&base64.RawURLEncoding).Elem(),
"StdEncoding": reflect.ValueOf(&base64.StdEncoding).Elem(),
"StdPadding": reflect.ValueOf(base64.StdPadding),
"URLEncoding": reflect.ValueOf(&base64.URLEncoding).Elem(),
// type definitions
"CorruptInputError": reflect.ValueOf((*base64.CorruptInputError)(nil)),
"Encoding": reflect.ValueOf((*base64.Encoding)(nil)),
}
}

55
stdlib/go1_11_encoding_binary.go
View File

@@ -1,55 +0,0 @@
// Code generated by 'goexports encoding/binary'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"encoding/binary"
"reflect"
)
func init() {
Symbols["encoding/binary"] = map[string]reflect.Value{
// function, constant and variable definitions
"BigEndian": reflect.ValueOf(&binary.BigEndian).Elem(),
"LittleEndian": reflect.ValueOf(&binary.LittleEndian).Elem(),
"MaxVarintLen16": reflect.ValueOf(binary.MaxVarintLen16),
"MaxVarintLen32": reflect.ValueOf(binary.MaxVarintLen32),
"MaxVarintLen64": reflect.ValueOf(binary.MaxVarintLen64),
"PutUvarint": reflect.ValueOf(binary.PutUvarint),
"PutVarint": reflect.ValueOf(binary.PutVarint),
"Read": reflect.ValueOf(binary.Read),
"ReadUvarint": reflect.ValueOf(binary.ReadUvarint),
"ReadVarint": reflect.ValueOf(binary.ReadVarint),
"Size": reflect.ValueOf(binary.Size),
"Uvarint": reflect.ValueOf(binary.Uvarint),
"Varint": reflect.ValueOf(binary.Varint),
"Write": reflect.ValueOf(binary.Write),
// type definitions
"ByteOrder": reflect.ValueOf((*binary.ByteOrder)(nil)),
// interface wrapper definitions
"_ByteOrder": reflect.ValueOf((*_encoding_binary_ByteOrder)(nil)),
}
}
// _encoding_binary_ByteOrder is an interface wrapper for ByteOrder type
type _encoding_binary_ByteOrder struct {
WPutUint16 func(a0 []byte, a1 uint16)
WPutUint32 func(a0 []byte, a1 uint32)
WPutUint64 func(a0 []byte, a1 uint64)
WString func() string
WUint16 func(a0 []byte) uint16
WUint32 func(a0 []byte) uint32
WUint64 func(a0 []byte) uint64
}
func (W _encoding_binary_ByteOrder) PutUint16(a0 []byte, a1 uint16) { W.WPutUint16(a0, a1) }
func (W _encoding_binary_ByteOrder) PutUint32(a0 []byte, a1 uint32) { W.WPutUint32(a0, a1) }
func (W _encoding_binary_ByteOrder) PutUint64(a0 []byte, a1 uint64) { W.WPutUint64(a0, a1) }
func (W _encoding_binary_ByteOrder) String() string { return W.WString() }
func (W _encoding_binary_ByteOrder) Uint16(a0 []byte) uint16 { return W.WUint16(a0) }
func (W _encoding_binary_ByteOrder) Uint32(a0 []byte) uint32 { return W.WUint32(a0) }
func (W _encoding_binary_ByteOrder) Uint64(a0 []byte) uint64 { return W.WUint64(a0) }

27
stdlib/go1_11_encoding_csv.go
View File

@@ -1,27 +0,0 @@
// Code generated by 'goexports encoding/csv'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"encoding/csv"
"reflect"
)
func init() {
Symbols["encoding/csv"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrBareQuote": reflect.ValueOf(&csv.ErrBareQuote).Elem(),
"ErrFieldCount": reflect.ValueOf(&csv.ErrFieldCount).Elem(),
"ErrQuote": reflect.ValueOf(&csv.ErrQuote).Elem(),
"ErrTrailingComma": reflect.ValueOf(&csv.ErrTrailingComma).Elem(),
"NewReader": reflect.ValueOf(csv.NewReader),
"NewWriter": reflect.ValueOf(csv.NewWriter),
// type definitions
"ParseError": reflect.ValueOf((*csv.ParseError)(nil)),
"Reader": reflect.ValueOf((*csv.Reader)(nil)),
"Writer": reflect.ValueOf((*csv.Writer)(nil)),
}
}

45
stdlib/go1_11_encoding_gob.go
View File

@@ -1,45 +0,0 @@
// Code generated by 'goexports encoding/gob'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"encoding/gob"
"reflect"
)
func init() {
Symbols["encoding/gob"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewDecoder": reflect.ValueOf(gob.NewDecoder),
"NewEncoder": reflect.ValueOf(gob.NewEncoder),
"Register": reflect.ValueOf(gob.Register),
"RegisterName": reflect.ValueOf(gob.RegisterName),
// type definitions
"CommonType": reflect.ValueOf((*gob.CommonType)(nil)),
"Decoder": reflect.ValueOf((*gob.Decoder)(nil)),
"Encoder": reflect.ValueOf((*gob.Encoder)(nil)),
"GobDecoder": reflect.ValueOf((*gob.GobDecoder)(nil)),
"GobEncoder": reflect.ValueOf((*gob.GobEncoder)(nil)),
// interface wrapper definitions
"_GobDecoder": reflect.ValueOf((*_encoding_gob_GobDecoder)(nil)),
"_GobEncoder": reflect.ValueOf((*_encoding_gob_GobEncoder)(nil)),
}
}
// _encoding_gob_GobDecoder is an interface wrapper for GobDecoder type
type _encoding_gob_GobDecoder struct {
WGobDecode func(a0 []byte) error
}
func (W _encoding_gob_GobDecoder) GobDecode(a0 []byte) error { return W.WGobDecode(a0) }
// _encoding_gob_GobEncoder is an interface wrapper for GobEncoder type
type _encoding_gob_GobEncoder struct {
WGobEncode func() ([]byte, error)
}
func (W _encoding_gob_GobEncoder) GobEncode() ([]byte, error) { return W.WGobEncode() }

30
stdlib/go1_11_encoding_hex.go
View File

@@ -1,30 +0,0 @@
// Code generated by 'goexports encoding/hex'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"encoding/hex"
"reflect"
)
func init() {
Symbols["encoding/hex"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(hex.Decode),
"DecodeString": reflect.ValueOf(hex.DecodeString),
"DecodedLen": reflect.ValueOf(hex.DecodedLen),
"Dump": reflect.ValueOf(hex.Dump),
"Dumper": reflect.ValueOf(hex.Dumper),
"Encode": reflect.ValueOf(hex.Encode),
"EncodeToString": reflect.ValueOf(hex.EncodeToString),
"EncodedLen": reflect.ValueOf(hex.EncodedLen),
"ErrLength": reflect.ValueOf(&hex.ErrLength).Elem(),
"NewDecoder": reflect.ValueOf(hex.NewDecoder),
"NewEncoder": reflect.ValueOf(hex.NewEncoder),
// type definitions
"InvalidByteError": reflect.ValueOf((*hex.InvalidByteError)(nil)),
}
}

66
stdlib/go1_11_encoding_json.go
View File

@@ -1,66 +0,0 @@
// Code generated by 'goexports encoding/json'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"encoding/json"
"reflect"
)
func init() {
Symbols["encoding/json"] = map[string]reflect.Value{
// function, constant and variable definitions
"Compact": reflect.ValueOf(json.Compact),
"HTMLEscape": reflect.ValueOf(json.HTMLEscape),
"Indent": reflect.ValueOf(json.Indent),
"Marshal": reflect.ValueOf(json.Marshal),
"MarshalIndent": reflect.ValueOf(json.MarshalIndent),
"NewDecoder": reflect.ValueOf(json.NewDecoder),
"NewEncoder": reflect.ValueOf(json.NewEncoder),
"Unmarshal": reflect.ValueOf(json.Unmarshal),
"Valid": reflect.ValueOf(json.Valid),
// type definitions
"Decoder": reflect.ValueOf((*json.Decoder)(nil)),
"Delim": reflect.ValueOf((*json.Delim)(nil)),
"Encoder": reflect.ValueOf((*json.Encoder)(nil)),
"InvalidUTF8Error": reflect.ValueOf((*json.InvalidUTF8Error)(nil)),
"InvalidUnmarshalError": reflect.ValueOf((*json.InvalidUnmarshalError)(nil)),
"Marshaler": reflect.ValueOf((*json.Marshaler)(nil)),
"MarshalerError": reflect.ValueOf((*json.MarshalerError)(nil)),
"Number": reflect.ValueOf((*json.Number)(nil)),
"RawMessage": reflect.ValueOf((*json.RawMessage)(nil)),
"SyntaxError": reflect.ValueOf((*json.SyntaxError)(nil)),
"Token": reflect.ValueOf((*json.Token)(nil)),
"UnmarshalFieldError": reflect.ValueOf((*json.UnmarshalFieldError)(nil)),
"UnmarshalTypeError": reflect.ValueOf((*json.UnmarshalTypeError)(nil)),
"Unmarshaler": reflect.ValueOf((*json.Unmarshaler)(nil)),
"UnsupportedTypeError": reflect.ValueOf((*json.UnsupportedTypeError)(nil)),
"UnsupportedValueError": reflect.ValueOf((*json.UnsupportedValueError)(nil)),
// interface wrapper definitions
"_Marshaler": reflect.ValueOf((*_encoding_json_Marshaler)(nil)),
"_Token": reflect.ValueOf((*_encoding_json_Token)(nil)),
"_Unmarshaler": reflect.ValueOf((*_encoding_json_Unmarshaler)(nil)),
}
}
// _encoding_json_Marshaler is an interface wrapper for Marshaler type
type _encoding_json_Marshaler struct {
WMarshalJSON func() ([]byte, error)
}
func (W _encoding_json_Marshaler) MarshalJSON() ([]byte, error) { return W.WMarshalJSON() }
// _encoding_json_Token is an interface wrapper for Token type
type _encoding_json_Token struct {
}
// _encoding_json_Unmarshaler is an interface wrapper for Unmarshaler type
type _encoding_json_Unmarshaler struct {
WUnmarshalJSON func(a0 []byte) error
}
func (W _encoding_json_Unmarshaler) UnmarshalJSON(a0 []byte) error { return W.WUnmarshalJSON(a0) }

22
stdlib/go1_11_encoding_pem.go
View File

@@ -1,22 +0,0 @@
// Code generated by 'goexports encoding/pem'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"encoding/pem"
"reflect"
)
func init() {
Symbols["encoding/pem"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(pem.Decode),
"Encode": reflect.ValueOf(pem.Encode),
"EncodeToMemory": reflect.ValueOf(pem.EncodeToMemory),
// type definitions
"Block": reflect.ValueOf((*pem.Block)(nil)),
}
}

105
stdlib/go1_11_encoding_xml.go
View File

@@ -1,105 +0,0 @@
// Code generated by 'goexports encoding/xml'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"encoding/xml"
"reflect"
)
func init() {
Symbols["encoding/xml"] = map[string]reflect.Value{
// function, constant and variable definitions
"CopyToken": reflect.ValueOf(xml.CopyToken),
"Escape": reflect.ValueOf(xml.Escape),
"EscapeText": reflect.ValueOf(xml.EscapeText),
"HTMLAutoClose": reflect.ValueOf(&xml.HTMLAutoClose).Elem(),
"HTMLEntity": reflect.ValueOf(&xml.HTMLEntity).Elem(),
"Header": reflect.ValueOf(xml.Header),
"Marshal": reflect.ValueOf(xml.Marshal),
"MarshalIndent": reflect.ValueOf(xml.MarshalIndent),
"NewDecoder": reflect.ValueOf(xml.NewDecoder),
"NewEncoder": reflect.ValueOf(xml.NewEncoder),
"NewTokenDecoder": reflect.ValueOf(xml.NewTokenDecoder),
"Unmarshal": reflect.ValueOf(xml.Unmarshal),
// type definitions
"Attr": reflect.ValueOf((*xml.Attr)(nil)),
"CharData": reflect.ValueOf((*xml.CharData)(nil)),
"Comment": reflect.ValueOf((*xml.Comment)(nil)),
"Decoder": reflect.ValueOf((*xml.Decoder)(nil)),
"Directive": reflect.ValueOf((*xml.Directive)(nil)),
"Encoder": reflect.ValueOf((*xml.Encoder)(nil)),
"EndElement": reflect.ValueOf((*xml.EndElement)(nil)),
"Marshaler": reflect.ValueOf((*xml.Marshaler)(nil)),
"MarshalerAttr": reflect.ValueOf((*xml.MarshalerAttr)(nil)),
"Name": reflect.ValueOf((*xml.Name)(nil)),
"ProcInst": reflect.ValueOf((*xml.ProcInst)(nil)),
"StartElement": reflect.ValueOf((*xml.StartElement)(nil)),
"SyntaxError": reflect.ValueOf((*xml.SyntaxError)(nil)),
"TagPathError": reflect.ValueOf((*xml.TagPathError)(nil)),
"Token": reflect.ValueOf((*xml.Token)(nil)),
"TokenReader": reflect.ValueOf((*xml.TokenReader)(nil)),
"UnmarshalError": reflect.ValueOf((*xml.UnmarshalError)(nil)),
"Unmarshaler": reflect.ValueOf((*xml.Unmarshaler)(nil)),
"UnmarshalerAttr": reflect.ValueOf((*xml.UnmarshalerAttr)(nil)),
"UnsupportedTypeError": reflect.ValueOf((*xml.UnsupportedTypeError)(nil)),
// interface wrapper definitions
"_Marshaler": reflect.ValueOf((*_encoding_xml_Marshaler)(nil)),
"_MarshalerAttr": reflect.ValueOf((*_encoding_xml_MarshalerAttr)(nil)),
"_Token": reflect.ValueOf((*_encoding_xml_Token)(nil)),
"_TokenReader": reflect.ValueOf((*_encoding_xml_TokenReader)(nil)),
"_Unmarshaler": reflect.ValueOf((*_encoding_xml_Unmarshaler)(nil)),
"_UnmarshalerAttr": reflect.ValueOf((*_encoding_xml_UnmarshalerAttr)(nil)),
}
}
// _encoding_xml_Marshaler is an interface wrapper for Marshaler type
type _encoding_xml_Marshaler struct {
WMarshalXML func(e *xml.Encoder, start xml.StartElement) error
}
func (W _encoding_xml_Marshaler) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
return W.WMarshalXML(e, start)
}
// _encoding_xml_MarshalerAttr is an interface wrapper for MarshalerAttr type
type _encoding_xml_MarshalerAttr struct {
WMarshalXMLAttr func(name xml.Name) (xml.Attr, error)
}
func (W _encoding_xml_MarshalerAttr) MarshalXMLAttr(name xml.Name) (xml.Attr, error) {
return W.WMarshalXMLAttr(name)
}
// _encoding_xml_Token is an interface wrapper for Token type
type _encoding_xml_Token struct {
}
// _encoding_xml_TokenReader is an interface wrapper for TokenReader type
type _encoding_xml_TokenReader struct {
WToken func() (xml.Token, error)
}
func (W _encoding_xml_TokenReader) Token() (xml.Token, error) { return W.WToken() }
// _encoding_xml_Unmarshaler is an interface wrapper for Unmarshaler type
type _encoding_xml_Unmarshaler struct {
WUnmarshalXML func(d *xml.Decoder, start xml.StartElement) error
}
func (W _encoding_xml_Unmarshaler) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
return W.WUnmarshalXML(d, start)
}
// _encoding_xml_UnmarshalerAttr is an interface wrapper for UnmarshalerAttr type
type _encoding_xml_UnmarshalerAttr struct {
WUnmarshalXMLAttr func(attr xml.Attr) error
}
func (W _encoding_xml_UnmarshalerAttr) UnmarshalXMLAttr(attr xml.Attr) error {
return W.WUnmarshalXMLAttr(attr)
}

17
stdlib/go1_11_errors.go
View File

@@ -1,17 +0,0 @@
// Code generated by 'goexports errors'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"errors"
"reflect"
)
func init() {
Symbols["errors"] = map[string]reflect.Value{
// function, constant and variable definitions
"New": reflect.ValueOf(errors.New),
}
}

43
stdlib/go1_11_expvar.go
View File

@@ -1,43 +0,0 @@
// Code generated by 'goexports expvar'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"expvar"
"reflect"
)
func init() {
Symbols["expvar"] = map[string]reflect.Value{
// function, constant and variable definitions
"Do": reflect.ValueOf(expvar.Do),
"Get": reflect.ValueOf(expvar.Get),
"Handler": reflect.ValueOf(expvar.Handler),
"NewFloat": reflect.ValueOf(expvar.NewFloat),
"NewInt": reflect.ValueOf(expvar.NewInt),
"NewMap": reflect.ValueOf(expvar.NewMap),
"NewString": reflect.ValueOf(expvar.NewString),
"Publish": reflect.ValueOf(expvar.Publish),
// type definitions
"Float": reflect.ValueOf((*expvar.Float)(nil)),
"Func": reflect.ValueOf((*expvar.Func)(nil)),
"Int": reflect.ValueOf((*expvar.Int)(nil)),
"KeyValue": reflect.ValueOf((*expvar.KeyValue)(nil)),
"Map": reflect.ValueOf((*expvar.Map)(nil)),
"String": reflect.ValueOf((*expvar.String)(nil)),
"Var": reflect.ValueOf((*expvar.Var)(nil)),
// interface wrapper definitions
"_Var": reflect.ValueOf((*_expvar_Var)(nil)),
}
}
// _expvar_Var is an interface wrapper for Var type
type _expvar_Var struct {
WString func() string
}
func (W _expvar_Var) String() string { return W.WString() }

83
stdlib/go1_11_flag.go
View File

@@ -1,83 +0,0 @@
// Code generated by 'goexports flag'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"flag"
"reflect"
)
func init() {
Symbols["flag"] = map[string]reflect.Value{
// function, constant and variable definitions
"Arg": reflect.ValueOf(flag.Arg),
"Args": reflect.ValueOf(flag.Args),
"Bool": reflect.ValueOf(flag.Bool),
"BoolVar": reflect.ValueOf(flag.BoolVar),
"CommandLine": reflect.ValueOf(&flag.CommandLine).Elem(),
"ContinueOnError": reflect.ValueOf(flag.ContinueOnError),
"Duration": reflect.ValueOf(flag.Duration),
"DurationVar": reflect.ValueOf(flag.DurationVar),
"ErrHelp": reflect.ValueOf(&flag.ErrHelp).Elem(),
"ExitOnError": reflect.ValueOf(flag.ExitOnError),
"Float64": reflect.ValueOf(flag.Float64),
"Float64Var": reflect.ValueOf(flag.Float64Var),
"Int": reflect.ValueOf(flag.Int),
"Int64": reflect.ValueOf(flag.Int64),
"Int64Var": reflect.ValueOf(flag.Int64Var),
"IntVar": reflect.ValueOf(flag.IntVar),
"Lookup": reflect.ValueOf(flag.Lookup),
"NArg": reflect.ValueOf(flag.NArg),
"NFlag": reflect.ValueOf(flag.NFlag),
"NewFlagSet": reflect.ValueOf(flag.NewFlagSet),
"PanicOnError": reflect.ValueOf(flag.PanicOnError),
"Parse": reflect.ValueOf(flag.Parse),
"Parsed": reflect.ValueOf(flag.Parsed),
"PrintDefaults": reflect.ValueOf(flag.PrintDefaults),
"Set": reflect.ValueOf(flag.Set),
"String": reflect.ValueOf(flag.String),
"StringVar": reflect.ValueOf(flag.StringVar),
"Uint": reflect.ValueOf(flag.Uint),
"Uint64": reflect.ValueOf(flag.Uint64),
"Uint64Var": reflect.ValueOf(flag.Uint64Var),
"UintVar": reflect.ValueOf(flag.UintVar),
"UnquoteUsage": reflect.ValueOf(flag.UnquoteUsage),
"Usage": reflect.ValueOf(&flag.Usage).Elem(),
"Var": reflect.ValueOf(flag.Var),
"Visit": reflect.ValueOf(flag.Visit),
"VisitAll": reflect.ValueOf(flag.VisitAll),
// type definitions
"ErrorHandling": reflect.ValueOf((*flag.ErrorHandling)(nil)),
"Flag": reflect.ValueOf((*flag.Flag)(nil)),
"FlagSet": reflect.ValueOf((*flag.FlagSet)(nil)),
"Getter": reflect.ValueOf((*flag.Getter)(nil)),
"Value": reflect.ValueOf((*flag.Value)(nil)),
// interface wrapper definitions
"_Getter": reflect.ValueOf((*_flag_Getter)(nil)),
"_Value": reflect.ValueOf((*_flag_Value)(nil)),
}
}
// _flag_Getter is an interface wrapper for Getter type
type _flag_Getter struct {
WGet func() interface{}
WSet func(a0 string) error
WString func() string
}
func (W _flag_Getter) Get() interface{} { return W.WGet() }
func (W _flag_Getter) Set(a0 string) error { return W.WSet(a0) }
func (W _flag_Getter) String() string { return W.WString() }
// _flag_Value is an interface wrapper for Value type
type _flag_Value struct {
WSet func(a0 string) error
WString func() string
}
func (W _flag_Value) Set(a0 string) error { return W.WSet(a0) }
func (W _flag_Value) String() string { return W.WString() }

111
stdlib/go1_11_fmt.go
View File

@@ -1,111 +0,0 @@
// Code generated by 'goexports fmt'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"fmt"
"reflect"
)
func init() {
Symbols["fmt"] = map[string]reflect.Value{
// function, constant and variable definitions
"Errorf": reflect.ValueOf(fmt.Errorf),
"Fprint": reflect.ValueOf(fmt.Fprint),
"Fprintf": reflect.ValueOf(fmt.Fprintf),
"Fprintln": reflect.ValueOf(fmt.Fprintln),
"Fscan": reflect.ValueOf(fmt.Fscan),
"Fscanf": reflect.ValueOf(fmt.Fscanf),
"Fscanln": reflect.ValueOf(fmt.Fscanln),
"Print": reflect.ValueOf(fmt.Print),
"Printf": reflect.ValueOf(fmt.Printf),
"Println": reflect.ValueOf(fmt.Println),
"Scan": reflect.ValueOf(fmt.Scan),
"Scanf": reflect.ValueOf(fmt.Scanf),
"Scanln": reflect.ValueOf(fmt.Scanln),
"Sprint": reflect.ValueOf(fmt.Sprint),
"Sprintf": reflect.ValueOf(fmt.Sprintf),
"Sprintln": reflect.ValueOf(fmt.Sprintln),
"Sscan": reflect.ValueOf(fmt.Sscan),
"Sscanf": reflect.ValueOf(fmt.Sscanf),
"Sscanln": reflect.ValueOf(fmt.Sscanln),
// type definitions
"Formatter": reflect.ValueOf((*fmt.Formatter)(nil)),
"GoStringer": reflect.ValueOf((*fmt.GoStringer)(nil)),
"ScanState": reflect.ValueOf((*fmt.ScanState)(nil)),
"Scanner": reflect.ValueOf((*fmt.Scanner)(nil)),
"State": reflect.ValueOf((*fmt.State)(nil)),
"Stringer": reflect.ValueOf((*fmt.Stringer)(nil)),
// interface wrapper definitions
"_Formatter": reflect.ValueOf((*_fmt_Formatter)(nil)),
"_GoStringer": reflect.ValueOf((*_fmt_GoStringer)(nil)),
"_ScanState": reflect.ValueOf((*_fmt_ScanState)(nil)),
"_Scanner": reflect.ValueOf((*_fmt_Scanner)(nil)),
"_State": reflect.ValueOf((*_fmt_State)(nil)),
"_Stringer": reflect.ValueOf((*_fmt_Stringer)(nil)),
}
}
// _fmt_Formatter is an interface wrapper for Formatter type
type _fmt_Formatter struct {
WFormat func(f fmt.State, c rune)
}
func (W _fmt_Formatter) Format(f fmt.State, c rune) { W.WFormat(f, c) }
// _fmt_GoStringer is an interface wrapper for GoStringer type
type _fmt_GoStringer struct {
WGoString func() string
}
func (W _fmt_GoStringer) GoString() string { return W.WGoString() }
// _fmt_ScanState is an interface wrapper for ScanState type
type _fmt_ScanState struct {
WRead func(buf []byte) (n int, err error)
WReadRune func() (r rune, size int, err error)
WSkipSpace func()
WToken func(skipSpace bool, f func(rune) bool) (token []byte, err error)
WUnreadRune func() error
WWidth func() (wid int, ok bool)
}
func (W _fmt_ScanState) Read(buf []byte) (n int, err error) { return W.WRead(buf) }
func (W _fmt_ScanState) ReadRune() (r rune, size int, err error) { return W.WReadRune() }
func (W _fmt_ScanState) SkipSpace() { W.WSkipSpace() }
func (W _fmt_ScanState) Token(skipSpace bool, f func(rune) bool) (token []byte, err error) {
return W.WToken(skipSpace, f)
}
func (W _fmt_ScanState) UnreadRune() error { return W.WUnreadRune() }
func (W _fmt_ScanState) Width() (wid int, ok bool) { return W.WWidth() }
// _fmt_Scanner is an interface wrapper for Scanner type
type _fmt_Scanner struct {
WScan func(state fmt.ScanState, verb rune) error
}
func (W _fmt_Scanner) Scan(state fmt.ScanState, verb rune) error { return W.WScan(state, verb) }
// _fmt_State is an interface wrapper for State type
type _fmt_State struct {
WFlag func(c int) bool
WPrecision func() (prec int, ok bool)
WWidth func() (wid int, ok bool)
WWrite func(b []byte) (n int, err error)
}
func (W _fmt_State) Flag(c int) bool { return W.WFlag(c) }
func (W _fmt_State) Precision() (prec int, ok bool) { return W.WPrecision() }
func (W _fmt_State) Width() (wid int, ok bool) { return W.WWidth() }
func (W _fmt_State) Write(b []byte) (n int, err error) { return W.WWrite(b) }
// _fmt_Stringer is an interface wrapper for Stringer type
type _fmt_Stringer struct {
WString func() string
}
func (W _fmt_Stringer) String() string { return W.WString() }

179
stdlib/go1_11_go_ast.go
View File

@@ -1,179 +0,0 @@
// Code generated by 'goexports go/ast'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"go/ast"
"go/token"
"reflect"
)
func init() {
Symbols["go/ast"] = map[string]reflect.Value{
// function, constant and variable definitions
"Bad": reflect.ValueOf(ast.Bad),
"Con": reflect.ValueOf(ast.Con),
"FileExports": reflect.ValueOf(ast.FileExports),
"FilterDecl": reflect.ValueOf(ast.FilterDecl),
"FilterFile": reflect.ValueOf(ast.FilterFile),
"FilterFuncDuplicates": reflect.ValueOf(ast.FilterFuncDuplicates),
"FilterImportDuplicates": reflect.ValueOf(ast.FilterImportDuplicates),
"FilterPackage": reflect.ValueOf(ast.FilterPackage),
"FilterUnassociatedComments": reflect.ValueOf(ast.FilterUnassociatedComments),
"Fprint": reflect.ValueOf(ast.Fprint),
"Fun": reflect.ValueOf(ast.Fun),
"Inspect": reflect.ValueOf(ast.Inspect),
"IsExported": reflect.ValueOf(ast.IsExported),
"Lbl": reflect.ValueOf(ast.Lbl),
"MergePackageFiles": reflect.ValueOf(ast.MergePackageFiles),
"NewCommentMap": reflect.ValueOf(ast.NewCommentMap),
"NewIdent": reflect.ValueOf(ast.NewIdent),
"NewObj": reflect.ValueOf(ast.NewObj),
"NewPackage": reflect.ValueOf(ast.NewPackage),
"NewScope": reflect.ValueOf(ast.NewScope),
"NotNilFilter": reflect.ValueOf(ast.NotNilFilter),
"PackageExports": reflect.ValueOf(ast.PackageExports),
"Pkg": reflect.ValueOf(ast.Pkg),
"Print": reflect.ValueOf(ast.Print),
"RECV": reflect.ValueOf(ast.RECV),
"SEND": reflect.ValueOf(ast.SEND),
"SortImports": reflect.ValueOf(ast.SortImports),
"Typ": reflect.ValueOf(ast.Typ),
"Var": reflect.ValueOf(ast.Var),
"Walk": reflect.ValueOf(ast.Walk),
// type definitions
"ArrayType": reflect.ValueOf((*ast.ArrayType)(nil)),
"AssignStmt": reflect.ValueOf((*ast.AssignStmt)(nil)),
"BadDecl": reflect.ValueOf((*ast.BadDecl)(nil)),
"BadExpr": reflect.ValueOf((*ast.BadExpr)(nil)),
"BadStmt": reflect.ValueOf((*ast.BadStmt)(nil)),
"BasicLit": reflect.ValueOf((*ast.BasicLit)(nil)),
"BinaryExpr": reflect.ValueOf((*ast.BinaryExpr)(nil)),
"BlockStmt": reflect.ValueOf((*ast.BlockStmt)(nil)),
"BranchStmt": reflect.ValueOf((*ast.BranchStmt)(nil)),
"CallExpr": reflect.ValueOf((*ast.CallExpr)(nil)),
"CaseClause": reflect.ValueOf((*ast.CaseClause)(nil)),
"ChanDir": reflect.ValueOf((*ast.ChanDir)(nil)),
"ChanType": reflect.ValueOf((*ast.ChanType)(nil)),
"CommClause": reflect.ValueOf((*ast.CommClause)(nil)),
"Comment": reflect.ValueOf((*ast.Comment)(nil)),
"CommentGroup": reflect.ValueOf((*ast.CommentGroup)(nil)),
"CommentMap": reflect.ValueOf((*ast.CommentMap)(nil)),
"CompositeLit": reflect.ValueOf((*ast.CompositeLit)(nil)),
"Decl": reflect.ValueOf((*ast.Decl)(nil)),
"DeclStmt": reflect.ValueOf((*ast.DeclStmt)(nil)),
"DeferStmt": reflect.ValueOf((*ast.DeferStmt)(nil)),
"Ellipsis": reflect.ValueOf((*ast.Ellipsis)(nil)),
"EmptyStmt": reflect.ValueOf((*ast.EmptyStmt)(nil)),
"Expr": reflect.ValueOf((*ast.Expr)(nil)),
"ExprStmt": reflect.ValueOf((*ast.ExprStmt)(nil)),
"Field": reflect.ValueOf((*ast.Field)(nil)),
"FieldFilter": reflect.ValueOf((*ast.FieldFilter)(nil)),
"FieldList": reflect.ValueOf((*ast.FieldList)(nil)),
"File": reflect.ValueOf((*ast.File)(nil)),
"Filter": reflect.ValueOf((*ast.Filter)(nil)),
"ForStmt": reflect.ValueOf((*ast.ForStmt)(nil)),
"FuncDecl": reflect.ValueOf((*ast.FuncDecl)(nil)),
"FuncLit": reflect.ValueOf((*ast.FuncLit)(nil)),
"FuncType": reflect.ValueOf((*ast.FuncType)(nil)),
"GenDecl": reflect.ValueOf((*ast.GenDecl)(nil)),
"GoStmt": reflect.ValueOf((*ast.GoStmt)(nil)),
"Ident": reflect.ValueOf((*ast.Ident)(nil)),
"IfStmt": reflect.ValueOf((*ast.IfStmt)(nil)),
"ImportSpec": reflect.ValueOf((*ast.ImportSpec)(nil)),
"Importer": reflect.ValueOf((*ast.Importer)(nil)),
"IncDecStmt": reflect.ValueOf((*ast.IncDecStmt)(nil)),
"IndexExpr": reflect.ValueOf((*ast.IndexExpr)(nil)),
"InterfaceType": reflect.ValueOf((*ast.InterfaceType)(nil)),
"KeyValueExpr": reflect.ValueOf((*ast.KeyValueExpr)(nil)),
"LabeledStmt": reflect.ValueOf((*ast.LabeledStmt)(nil)),
"MapType": reflect.ValueOf((*ast.MapType)(nil)),
"MergeMode": reflect.ValueOf((*ast.MergeMode)(nil)),
"Node": reflect.ValueOf((*ast.Node)(nil)),
"ObjKind": reflect.ValueOf((*ast.ObjKind)(nil)),
"Object": reflect.ValueOf((*ast.Object)(nil)),
"Package": reflect.ValueOf((*ast.Package)(nil)),
"ParenExpr": reflect.ValueOf((*ast.ParenExpr)(nil)),
"RangeStmt": reflect.ValueOf((*ast.RangeStmt)(nil)),
"ReturnStmt": reflect.ValueOf((*ast.ReturnStmt)(nil)),
"Scope": reflect.ValueOf((*ast.Scope)(nil)),
"SelectStmt": reflect.ValueOf((*ast.SelectStmt)(nil)),
"SelectorExpr": reflect.ValueOf((*ast.SelectorExpr)(nil)),
"SendStmt": reflect.ValueOf((*ast.SendStmt)(nil)),
"SliceExpr": reflect.ValueOf((*ast.SliceExpr)(nil)),
"Spec": reflect.ValueOf((*ast.Spec)(nil)),
"StarExpr": reflect.ValueOf((*ast.StarExpr)(nil)),
"Stmt": reflect.ValueOf((*ast.Stmt)(nil)),
"StructType": reflect.ValueOf((*ast.StructType)(nil)),
"SwitchStmt": reflect.ValueOf((*ast.SwitchStmt)(nil)),
"TypeAssertExpr": reflect.ValueOf((*ast.TypeAssertExpr)(nil)),
"TypeSpec": reflect.ValueOf((*ast.TypeSpec)(nil)),
"TypeSwitchStmt": reflect.ValueOf((*ast.TypeSwitchStmt)(nil)),
"UnaryExpr": reflect.ValueOf((*ast.UnaryExpr)(nil)),
"ValueSpec": reflect.ValueOf((*ast.ValueSpec)(nil)),
"Visitor": reflect.ValueOf((*ast.Visitor)(nil)),
// interface wrapper definitions
"_Decl": reflect.ValueOf((*_go_ast_Decl)(nil)),
"_Expr": reflect.ValueOf((*_go_ast_Expr)(nil)),
"_Node": reflect.ValueOf((*_go_ast_Node)(nil)),
"_Spec": reflect.ValueOf((*_go_ast_Spec)(nil)),
"_Stmt": reflect.ValueOf((*_go_ast_Stmt)(nil)),
"_Visitor": reflect.ValueOf((*_go_ast_Visitor)(nil)),
}
}
// _go_ast_Decl is an interface wrapper for Decl type
type _go_ast_Decl struct {
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Decl) End() token.Pos { return W.WEnd() }
func (W _go_ast_Decl) Pos() token.Pos { return W.WPos() }
// _go_ast_Expr is an interface wrapper for Expr type
type _go_ast_Expr struct {
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Expr) End() token.Pos { return W.WEnd() }
func (W _go_ast_Expr) Pos() token.Pos { return W.WPos() }
// _go_ast_Node is an interface wrapper for Node type
type _go_ast_Node struct {
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Node) End() token.Pos { return W.WEnd() }
func (W _go_ast_Node) Pos() token.Pos { return W.WPos() }
// _go_ast_Spec is an interface wrapper for Spec type
type _go_ast_Spec struct {
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Spec) End() token.Pos { return W.WEnd() }
func (W _go_ast_Spec) Pos() token.Pos { return W.WPos() }
// _go_ast_Stmt is an interface wrapper for Stmt type
type _go_ast_Stmt struct {
WEnd func() token.Pos
WPos func() token.Pos
}
func (W _go_ast_Stmt) End() token.Pos { return W.WEnd() }
func (W _go_ast_Stmt) Pos() token.Pos { return W.WPos() }
// _go_ast_Visitor is an interface wrapper for Visitor type
type _go_ast_Visitor struct {
WVisit func(node ast.Node) (w ast.Visitor)
}
func (W _go_ast_Visitor) Visit(node ast.Node) (w ast.Visitor) { return W.WVisit(node) }

33
stdlib/go1_11_go_build.go
View File

@@ -1,33 +0,0 @@
// Code generated by 'goexports go/build'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"go/build"
"reflect"
)
func init() {
Symbols["go/build"] = map[string]reflect.Value{
// function, constant and variable definitions
"AllowBinary": reflect.ValueOf(build.AllowBinary),
"ArchChar": reflect.ValueOf(build.ArchChar),
"Default": reflect.ValueOf(&build.Default).Elem(),
"FindOnly": reflect.ValueOf(build.FindOnly),
"IgnoreVendor": reflect.ValueOf(build.IgnoreVendor),
"Import": reflect.ValueOf(build.Import),
"ImportComment": reflect.ValueOf(build.ImportComment),
"ImportDir": reflect.ValueOf(build.ImportDir),
"IsLocalImport": reflect.ValueOf(build.IsLocalImport),
"ToolDir": reflect.ValueOf(&build.ToolDir).Elem(),
// type definitions
"Context": reflect.ValueOf((*build.Context)(nil)),
"ImportMode": reflect.ValueOf((*build.ImportMode)(nil)),
"MultiplePackageError": reflect.ValueOf((*build.MultiplePackageError)(nil)),
"NoGoError": reflect.ValueOf((*build.NoGoError)(nil)),
"Package": reflect.ValueOf((*build.Package)(nil)),
}
}

69
stdlib/go1_11_go_constant.go
View File

@@ -1,69 +0,0 @@
// Code generated by 'goexports go/constant'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"go/constant"
"reflect"
)
func init() {
Symbols["go/constant"] = map[string]reflect.Value{
// function, constant and variable definitions
"BinaryOp": reflect.ValueOf(constant.BinaryOp),
"BitLen": reflect.ValueOf(constant.BitLen),
"Bool": reflect.ValueOf(constant.Bool),
"BoolVal": reflect.ValueOf(constant.BoolVal),
"Bytes": reflect.ValueOf(constant.Bytes),
"Compare": reflect.ValueOf(constant.Compare),
"Complex": reflect.ValueOf(constant.Complex),
"Denom": reflect.ValueOf(constant.Denom),
"Float": reflect.ValueOf(constant.Float),
"Float32Val": reflect.ValueOf(constant.Float32Val),
"Float64Val": reflect.ValueOf(constant.Float64Val),
"Imag": reflect.ValueOf(constant.Imag),
"Int": reflect.ValueOf(constant.Int),
"Int64Val": reflect.ValueOf(constant.Int64Val),
"MakeBool": reflect.ValueOf(constant.MakeBool),
"MakeFloat64": reflect.ValueOf(constant.MakeFloat64),
"MakeFromBytes": reflect.ValueOf(constant.MakeFromBytes),
"MakeFromLiteral": reflect.ValueOf(constant.MakeFromLiteral),
"MakeImag": reflect.ValueOf(constant.MakeImag),
"MakeInt64": reflect.ValueOf(constant.MakeInt64),
"MakeString": reflect.ValueOf(constant.MakeString),
"MakeUint64": reflect.ValueOf(constant.MakeUint64),
"MakeUnknown": reflect.ValueOf(constant.MakeUnknown),
"Num": reflect.ValueOf(constant.Num),
"Real": reflect.ValueOf(constant.Real),
"Shift": reflect.ValueOf(constant.Shift),
"Sign": reflect.ValueOf(constant.Sign),
"String": reflect.ValueOf(constant.String),
"StringVal": reflect.ValueOf(constant.StringVal),
"ToComplex": reflect.ValueOf(constant.ToComplex),
"ToFloat": reflect.ValueOf(constant.ToFloat),
"ToInt": reflect.ValueOf(constant.ToInt),
"Uint64Val": reflect.ValueOf(constant.Uint64Val),
"UnaryOp": reflect.ValueOf(constant.UnaryOp),
"Unknown": reflect.ValueOf(constant.Unknown),
// type definitions
"Kind": reflect.ValueOf((*constant.Kind)(nil)),
"Value": reflect.ValueOf((*constant.Value)(nil)),
// interface wrapper definitions
"_Value": reflect.ValueOf((*_go_constant_Value)(nil)),
}
}
// _go_constant_Value is an interface wrapper for Value type
type _go_constant_Value struct {
WExactString func() string
WKind func() constant.Kind
WString func() string
}
func (W _go_constant_Value) ExactString() string { return W.WExactString() }
func (W _go_constant_Value) Kind() constant.Kind { return W.WKind() }
func (W _go_constant_Value) String() string { return W.WString() }

35
stdlib/go1_11_go_doc.go
View File

@@ -1,35 +0,0 @@
// Code generated by 'goexports go/doc'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"go/doc"
"reflect"
)
func init() {
Symbols["go/doc"] = map[string]reflect.Value{
// function, constant and variable definitions
"AllDecls": reflect.ValueOf(doc.AllDecls),
"AllMethods": reflect.ValueOf(doc.AllMethods),
"Examples": reflect.ValueOf(doc.Examples),
"IllegalPrefixes": reflect.ValueOf(&doc.IllegalPrefixes).Elem(),
"IsPredeclared": reflect.ValueOf(doc.IsPredeclared),
"New": reflect.ValueOf(doc.New),
"Synopsis": reflect.ValueOf(doc.Synopsis),
"ToHTML": reflect.ValueOf(doc.ToHTML),
"ToText": reflect.ValueOf(doc.ToText),
// type definitions
"Example": reflect.ValueOf((*doc.Example)(nil)),
"Filter": reflect.ValueOf((*doc.Filter)(nil)),
"Func": reflect.ValueOf((*doc.Func)(nil)),
"Mode": reflect.ValueOf((*doc.Mode)(nil)),
"Note": reflect.ValueOf((*doc.Note)(nil)),
"Package": reflect.ValueOf((*doc.Package)(nil)),
"Type": reflect.ValueOf((*doc.Type)(nil)),
"Value": reflect.ValueOf((*doc.Value)(nil)),
}
}

18
stdlib/go1_11_go_format.go
View File

@@ -1,18 +0,0 @@
// Code generated by 'goexports go/format'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"go/format"
"reflect"
)
func init() {
Symbols["go/format"] = map[string]reflect.Value{
// function, constant and variable definitions
"Node": reflect.ValueOf(format.Node),
"Source": reflect.ValueOf(format.Source),
}
}

21
stdlib/go1_11_go_importer.go
View File

@@ -1,21 +0,0 @@
// Code generated by 'goexports go/importer'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"go/importer"
"reflect"
)
func init() {
Symbols["go/importer"] = map[string]reflect.Value{
// function, constant and variable definitions
"Default": reflect.ValueOf(importer.Default),
"For": reflect.ValueOf(importer.For),
// type definitions
"Lookup": reflect.ValueOf((*importer.Lookup)(nil)),
}
}

30
stdlib/go1_11_go_parser.go
View File

@@ -1,30 +0,0 @@
// Code generated by 'goexports go/parser'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"go/parser"
"reflect"
)
func init() {
Symbols["go/parser"] = map[string]reflect.Value{
// function, constant and variable definitions
"AllErrors": reflect.ValueOf(parser.AllErrors),
"DeclarationErrors": reflect.ValueOf(parser.DeclarationErrors),
"ImportsOnly": reflect.ValueOf(parser.ImportsOnly),
"PackageClauseOnly": reflect.ValueOf(parser.PackageClauseOnly),
"ParseComments": reflect.ValueOf(parser.ParseComments),
"ParseDir": reflect.ValueOf(parser.ParseDir),
"ParseExpr": reflect.ValueOf(parser.ParseExpr),
"ParseExprFrom": reflect.ValueOf(parser.ParseExprFrom),
"ParseFile": reflect.ValueOf(parser.ParseFile),
"SpuriousErrors": reflect.ValueOf(parser.SpuriousErrors),
"Trace": reflect.ValueOf(parser.Trace),
// type definitions
"Mode": reflect.ValueOf((*parser.Mode)(nil)),
}
}

26
stdlib/go1_11_go_printer.go
View File

@@ -1,26 +0,0 @@
// Code generated by 'goexports go/printer'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"go/printer"
"reflect"
)
func init() {
Symbols["go/printer"] = map[string]reflect.Value{
// function, constant and variable definitions
"Fprint": reflect.ValueOf(printer.Fprint),
"RawFormat": reflect.ValueOf(printer.RawFormat),
"SourcePos": reflect.ValueOf(printer.SourcePos),
"TabIndent": reflect.ValueOf(printer.TabIndent),
"UseSpaces": reflect.ValueOf(printer.UseSpaces),
// type definitions
"CommentedNode": reflect.ValueOf((*printer.CommentedNode)(nil)),
"Config": reflect.ValueOf((*printer.Config)(nil)),
"Mode": reflect.ValueOf((*printer.Mode)(nil)),
}
}

25
stdlib/go1_11_go_scanner.go
View File

@@ -1,25 +0,0 @@
// Code generated by 'goexports go/scanner'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"go/scanner"
"reflect"
)
func init() {
Symbols["go/scanner"] = map[string]reflect.Value{
// function, constant and variable definitions
"PrintError": reflect.ValueOf(scanner.PrintError),
"ScanComments": reflect.ValueOf(scanner.ScanComments),
// type definitions
"Error": reflect.ValueOf((*scanner.Error)(nil)),
"ErrorHandler": reflect.ValueOf((*scanner.ErrorHandler)(nil)),
"ErrorList": reflect.ValueOf((*scanner.ErrorList)(nil)),
"Mode": reflect.ValueOf((*scanner.Mode)(nil)),
"Scanner": reflect.ValueOf((*scanner.Scanner)(nil)),
}
}

110
stdlib/go1_11_go_token.go
View File

@@ -1,110 +0,0 @@
// Code generated by 'goexports go/token'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"go/token"
"reflect"
)
func init() {
Symbols["go/token"] = map[string]reflect.Value{
// function, constant and variable definitions
"ADD": reflect.ValueOf(token.ADD),
"ADD_ASSIGN": reflect.ValueOf(token.ADD_ASSIGN),
"AND": reflect.ValueOf(token.AND),
"AND_ASSIGN": reflect.ValueOf(token.AND_ASSIGN),
"AND_NOT": reflect.ValueOf(token.AND_NOT),
"AND_NOT_ASSIGN": reflect.ValueOf(token.AND_NOT_ASSIGN),
"ARROW": reflect.ValueOf(token.ARROW),
"ASSIGN": reflect.ValueOf(token.ASSIGN),
"BREAK": reflect.ValueOf(token.BREAK),
"CASE": reflect.ValueOf(token.CASE),
"CHAN": reflect.ValueOf(token.CHAN),
"CHAR": reflect.ValueOf(token.CHAR),
"COLON": reflect.ValueOf(token.COLON),
"COMMA": reflect.ValueOf(token.COMMA),
"COMMENT": reflect.ValueOf(token.COMMENT),
"CONST": reflect.ValueOf(token.CONST),
"CONTINUE": reflect.ValueOf(token.CONTINUE),
"DEC": reflect.ValueOf(token.DEC),
"DEFAULT": reflect.ValueOf(token.DEFAULT),
"DEFER": reflect.ValueOf(token.DEFER),
"DEFINE": reflect.ValueOf(token.DEFINE),
"ELLIPSIS": reflect.ValueOf(token.ELLIPSIS),
"ELSE": reflect.ValueOf(token.ELSE),
"EOF": reflect.ValueOf(token.EOF),
"EQL": reflect.ValueOf(token.EQL),
"FALLTHROUGH": reflect.ValueOf(token.FALLTHROUGH),
"FLOAT": reflect.ValueOf(token.FLOAT),
"FOR": reflect.ValueOf(token.FOR),
"FUNC": reflect.ValueOf(token.FUNC),
"GEQ": reflect.ValueOf(token.GEQ),
"GO": reflect.ValueOf(token.GO),
"GOTO": reflect.ValueOf(token.GOTO),
"GTR": reflect.ValueOf(token.GTR),
"HighestPrec": reflect.ValueOf(token.HighestPrec),
"IDENT": reflect.ValueOf(token.IDENT),
"IF": reflect.ValueOf(token.IF),
"ILLEGAL": reflect.ValueOf(token.ILLEGAL),
"IMAG": reflect.ValueOf(token.IMAG),
"IMPORT": reflect.ValueOf(token.IMPORT),
"INC": reflect.ValueOf(token.INC),
"INT": reflect.ValueOf(token.INT),
"INTERFACE": reflect.ValueOf(token.INTERFACE),
"LAND": reflect.ValueOf(token.LAND),
"LBRACE": reflect.ValueOf(token.LBRACE),
"LBRACK": reflect.ValueOf(token.LBRACK),
"LEQ": reflect.ValueOf(token.LEQ),
"LOR": reflect.ValueOf(token.LOR),
"LPAREN": reflect.ValueOf(token.LPAREN),
"LSS": reflect.ValueOf(token.LSS),
"Lookup": reflect.ValueOf(token.Lookup),
"LowestPrec": reflect.ValueOf(token.LowestPrec),
"MAP": reflect.ValueOf(token.MAP),
"MUL": reflect.ValueOf(token.MUL),
"MUL_ASSIGN": reflect.ValueOf(token.MUL_ASSIGN),
"NEQ": reflect.ValueOf(token.NEQ),
"NOT": reflect.ValueOf(token.NOT),
"NewFileSet": reflect.ValueOf(token.NewFileSet),
"NoPos": reflect.ValueOf(token.NoPos),
"OR": reflect.ValueOf(token.OR),
"OR_ASSIGN": reflect.ValueOf(token.OR_ASSIGN),
"PACKAGE": reflect.ValueOf(token.PACKAGE),
"PERIOD": reflect.ValueOf(token.PERIOD),
"QUO": reflect.ValueOf(token.QUO),
"QUO_ASSIGN": reflect.ValueOf(token.QUO_ASSIGN),
"RANGE": reflect.ValueOf(token.RANGE),
"RBRACE": reflect.ValueOf(token.RBRACE),
"RBRACK": reflect.ValueOf(token.RBRACK),
"REM": reflect.ValueOf(token.REM),
"REM_ASSIGN": reflect.ValueOf(token.REM_ASSIGN),
"RETURN": reflect.ValueOf(token.RETURN),
"RPAREN": reflect.ValueOf(token.RPAREN),
"SELECT": reflect.ValueOf(token.SELECT),
"SEMICOLON": reflect.ValueOf(token.SEMICOLON),
"SHL": reflect.ValueOf(token.SHL),
"SHL_ASSIGN": reflect.ValueOf(token.SHL_ASSIGN),
"SHR": reflect.ValueOf(token.SHR),
"SHR_ASSIGN": reflect.ValueOf(token.SHR_ASSIGN),
"STRING": reflect.ValueOf(token.STRING),
"STRUCT": reflect.ValueOf(token.STRUCT),
"SUB": reflect.ValueOf(token.SUB),
"SUB_ASSIGN": reflect.ValueOf(token.SUB_ASSIGN),
"SWITCH": reflect.ValueOf(token.SWITCH),
"TYPE": reflect.ValueOf(token.TYPE),
"UnaryPrec": reflect.ValueOf(token.UnaryPrec),
"VAR": reflect.ValueOf(token.VAR),
"XOR": reflect.ValueOf(token.XOR),
"XOR_ASSIGN": reflect.ValueOf(token.XOR_ASSIGN),
// type definitions
"File": reflect.ValueOf((*token.File)(nil)),
"FileSet": reflect.ValueOf((*token.FileSet)(nil)),
"Pos": reflect.ValueOf((*token.Pos)(nil)),
"Position": reflect.ValueOf((*token.Position)(nil)),
"Token": reflect.ValueOf((*token.Token)(nil)),
}
}

219
stdlib/go1_11_go_types.go
View File

@@ -1,219 +0,0 @@
// Code generated by 'goexports go/types'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"go/token"
"go/types"
"reflect"
)
func init() {
Symbols["go/types"] = map[string]reflect.Value{
// function, constant and variable definitions
"AssertableTo": reflect.ValueOf(types.AssertableTo),
"AssignableTo": reflect.ValueOf(types.AssignableTo),
"Bool": reflect.ValueOf(types.Bool),
"Byte": reflect.ValueOf(types.Byte),
"Comparable": reflect.ValueOf(types.Comparable),
"Complex128": reflect.ValueOf(types.Complex128),
"Complex64": reflect.ValueOf(types.Complex64),
"ConvertibleTo": reflect.ValueOf(types.ConvertibleTo),
"DefPredeclaredTestFuncs": reflect.ValueOf(types.DefPredeclaredTestFuncs),
"Default": reflect.ValueOf(types.Default),
"Eval": reflect.ValueOf(types.Eval),
"ExprString": reflect.ValueOf(types.ExprString),
"FieldVal": reflect.ValueOf(types.FieldVal),
"Float32": reflect.ValueOf(types.Float32),
"Float64": reflect.ValueOf(types.Float64),
"Id": reflect.ValueOf(types.Id),
"Identical": reflect.ValueOf(types.Identical),
"IdenticalIgnoreTags": reflect.ValueOf(types.IdenticalIgnoreTags),
"Implements": reflect.ValueOf(types.Implements),
"Int": reflect.ValueOf(types.Int),
"Int16": reflect.ValueOf(types.Int16),
"Int32": reflect.ValueOf(types.Int32),
"Int64": reflect.ValueOf(types.Int64),
"Int8": reflect.ValueOf(types.Int8),
"Invalid": reflect.ValueOf(types.Invalid),
"IsBoolean": reflect.ValueOf(types.IsBoolean),
"IsComplex": reflect.ValueOf(types.IsComplex),
"IsConstType": reflect.ValueOf(types.IsConstType),
"IsFloat": reflect.ValueOf(types.IsFloat),
"IsInteger": reflect.ValueOf(types.IsInteger),
"IsInterface": reflect.ValueOf(types.IsInterface),
"IsNumeric": reflect.ValueOf(types.IsNumeric),
"IsOrdered": reflect.ValueOf(types.IsOrdered),
"IsString": reflect.ValueOf(types.IsString),
"IsUnsigned": reflect.ValueOf(types.IsUnsigned),
"IsUntyped": reflect.ValueOf(types.IsUntyped),
"LookupFieldOrMethod": reflect.ValueOf(types.LookupFieldOrMethod),
"MethodExpr": reflect.ValueOf(types.MethodExpr),
"MethodVal": reflect.ValueOf(types.MethodVal),
"MissingMethod": reflect.ValueOf(types.MissingMethod),
"NewArray": reflect.ValueOf(types.NewArray),
"NewChan": reflect.ValueOf(types.NewChan),
"NewChecker": reflect.ValueOf(types.NewChecker),
"NewConst": reflect.ValueOf(types.NewConst),
"NewField": reflect.ValueOf(types.NewField),
"NewFunc": reflect.ValueOf(types.NewFunc),
"NewInterface": reflect.ValueOf(types.NewInterface),
"NewInterfaceType": reflect.ValueOf(types.NewInterfaceType),
"NewLabel": reflect.ValueOf(types.NewLabel),
"NewMap": reflect.ValueOf(types.NewMap),
"NewMethodSet": reflect.ValueOf(types.NewMethodSet),
"NewNamed": reflect.ValueOf(types.NewNamed),
"NewPackage": reflect.ValueOf(types.NewPackage),
"NewParam": reflect.ValueOf(types.NewParam),
"NewPkgName": reflect.ValueOf(types.NewPkgName),
"NewPointer": reflect.ValueOf(types.NewPointer),
"NewScope": reflect.ValueOf(types.NewScope),
"NewSignature": reflect.ValueOf(types.NewSignature),
"NewSlice": reflect.ValueOf(types.NewSlice),
"NewStruct": reflect.ValueOf(types.NewStruct),
"NewTuple": reflect.ValueOf(types.NewTuple),
"NewTypeName": reflect.ValueOf(types.NewTypeName),
"NewVar": reflect.ValueOf(types.NewVar),
"ObjectString": reflect.ValueOf(types.ObjectString),
"RecvOnly": reflect.ValueOf(types.RecvOnly),
"RelativeTo": reflect.ValueOf(types.RelativeTo),
"Rune": reflect.ValueOf(types.Rune),
"SelectionString": reflect.ValueOf(types.SelectionString),
"SendOnly": reflect.ValueOf(types.SendOnly),
"SendRecv": reflect.ValueOf(types.SendRecv),
"SizesFor": reflect.ValueOf(types.SizesFor),
"String": reflect.ValueOf(types.String),
"Typ": reflect.ValueOf(&types.Typ).Elem(),
"TypeString": reflect.ValueOf(types.TypeString),
"Uint": reflect.ValueOf(types.Uint),
"Uint16": reflect.ValueOf(types.Uint16),
"Uint32": reflect.ValueOf(types.Uint32),
"Uint64": reflect.ValueOf(types.Uint64),
"Uint8": reflect.ValueOf(types.Uint8),
"Uintptr": reflect.ValueOf(types.Uintptr),
"Universe": reflect.ValueOf(&types.Universe).Elem(),
"Unsafe": reflect.ValueOf(&types.Unsafe).Elem(),
"UnsafePointer": reflect.ValueOf(types.UnsafePointer),
"UntypedBool": reflect.ValueOf(types.UntypedBool),
"UntypedComplex": reflect.ValueOf(types.UntypedComplex),
"UntypedFloat": reflect.ValueOf(types.UntypedFloat),
"UntypedInt": reflect.ValueOf(types.UntypedInt),
"UntypedNil": reflect.ValueOf(types.UntypedNil),
"UntypedRune": reflect.ValueOf(types.UntypedRune),
"UntypedString": reflect.ValueOf(types.UntypedString),
"WriteExpr": reflect.ValueOf(types.WriteExpr),
"WriteSignature": reflect.ValueOf(types.WriteSignature),
"WriteType": reflect.ValueOf(types.WriteType),
// type definitions
"Array": reflect.ValueOf((*types.Array)(nil)),
"Basic": reflect.ValueOf((*types.Basic)(nil)),
"BasicInfo": reflect.ValueOf((*types.BasicInfo)(nil)),
"BasicKind": reflect.ValueOf((*types.BasicKind)(nil)),
"Builtin": reflect.ValueOf((*types.Builtin)(nil)),
"Chan": reflect.ValueOf((*types.Chan)(nil)),
"ChanDir": reflect.ValueOf((*types.ChanDir)(nil)),
"Checker": reflect.ValueOf((*types.Checker)(nil)),
"Config": reflect.ValueOf((*types.Config)(nil)),
"Const": reflect.ValueOf((*types.Const)(nil)),
"Error": reflect.ValueOf((*types.Error)(nil)),
"Func": reflect.ValueOf((*types.Func)(nil)),
"ImportMode": reflect.ValueOf((*types.ImportMode)(nil)),
"Importer": reflect.ValueOf((*types.Importer)(nil)),
"ImporterFrom": reflect.ValueOf((*types.ImporterFrom)(nil)),
"Info": reflect.ValueOf((*types.Info)(nil)),
"Initializer": reflect.ValueOf((*types.Initializer)(nil)),
"Interface": reflect.ValueOf((*types.Interface)(nil)),
"Label": reflect.ValueOf((*types.Label)(nil)),
"Map": reflect.ValueOf((*types.Map)(nil)),
"MethodSet": reflect.ValueOf((*types.MethodSet)(nil)),
"Named": reflect.ValueOf((*types.Named)(nil)),
"Nil": reflect.ValueOf((*types.Nil)(nil)),
"Object": reflect.ValueOf((*types.Object)(nil)),
"Package": reflect.ValueOf((*types.Package)(nil)),
"PkgName": reflect.ValueOf((*types.PkgName)(nil)),
"Pointer": reflect.ValueOf((*types.Pointer)(nil)),
"Qualifier": reflect.ValueOf((*types.Qualifier)(nil)),
"Scope": reflect.ValueOf((*types.Scope)(nil)),
"Selection": reflect.ValueOf((*types.Selection)(nil)),
"SelectionKind": reflect.ValueOf((*types.SelectionKind)(nil)),
"Signature": reflect.ValueOf((*types.Signature)(nil)),
"Sizes": reflect.ValueOf((*types.Sizes)(nil)),
"Slice": reflect.ValueOf((*types.Slice)(nil)),
"StdSizes": reflect.ValueOf((*types.StdSizes)(nil)),
"Struct": reflect.ValueOf((*types.Struct)(nil)),
"Tuple": reflect.ValueOf((*types.Tuple)(nil)),
"Type": reflect.ValueOf((*types.Type)(nil)),
"TypeAndValue": reflect.ValueOf((*types.TypeAndValue)(nil)),
"TypeName": reflect.ValueOf((*types.TypeName)(nil)),
"Var": reflect.ValueOf((*types.Var)(nil)),
// interface wrapper definitions
"_Importer": reflect.ValueOf((*_go_types_Importer)(nil)),
"_ImporterFrom": reflect.ValueOf((*_go_types_ImporterFrom)(nil)),
"_Object": reflect.ValueOf((*_go_types_Object)(nil)),
"_Sizes": reflect.ValueOf((*_go_types_Sizes)(nil)),
"_Type": reflect.ValueOf((*_go_types_Type)(nil)),
}
}
// _go_types_Importer is an interface wrapper for Importer type
type _go_types_Importer struct {
WImport func(path string) (*types.Package, error)
}
func (W _go_types_Importer) Import(path string) (*types.Package, error) { return W.WImport(path) }
// _go_types_ImporterFrom is an interface wrapper for ImporterFrom type
type _go_types_ImporterFrom struct {
WImport func(path string) (*types.Package, error)
WImportFrom func(path string, dir string, mode types.ImportMode) (*types.Package, error)
}
func (W _go_types_ImporterFrom) Import(path string) (*types.Package, error) { return W.WImport(path) }
func (W _go_types_ImporterFrom) ImportFrom(path string, dir string, mode types.ImportMode) (*types.Package, error) {
return W.WImportFrom(path, dir, mode)
}
// _go_types_Object is an interface wrapper for Object type
type _go_types_Object struct {
WExported func() bool
WId func() string
WName func() string
WParent func() *types.Scope
WPkg func() *types.Package
WPos func() token.Pos
WString func() string
WType func() types.Type
}
func (W _go_types_Object) Exported() bool { return W.WExported() }
func (W _go_types_Object) Id() string { return W.WId() }
func (W _go_types_Object) Name() string { return W.WName() }
func (W _go_types_Object) Parent() *types.Scope { return W.WParent() }
func (W _go_types_Object) Pkg() *types.Package { return W.WPkg() }
func (W _go_types_Object) Pos() token.Pos { return W.WPos() }
func (W _go_types_Object) String() string { return W.WString() }
func (W _go_types_Object) Type() types.Type { return W.WType() }
// _go_types_Sizes is an interface wrapper for Sizes type
type _go_types_Sizes struct {
WAlignof func(T types.Type) int64
WOffsetsof func(fields []*types.Var) []int64
WSizeof func(T types.Type) int64
}
func (W _go_types_Sizes) Alignof(T types.Type) int64 { return W.WAlignof(T) }
func (W _go_types_Sizes) Offsetsof(fields []*types.Var) []int64 { return W.WOffsetsof(fields) }
func (W _go_types_Sizes) Sizeof(T types.Type) int64 { return W.WSizeof(T) }
// _go_types_Type is an interface wrapper for Type type
type _go_types_Type struct {
WString func() string
WUnderlying func() types.Type
}
func (W _go_types_Type) String() string { return W.WString() }
func (W _go_types_Type) Underlying() types.Type { return W.WUnderlying() }

73
stdlib/go1_11_hash.go
View File

@@ -1,73 +0,0 @@
// Code generated by 'goexports hash'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"hash"
"reflect"
)
func init() {
Symbols["hash"] = map[string]reflect.Value{
// type definitions
"Hash": reflect.ValueOf((*hash.Hash)(nil)),
"Hash32": reflect.ValueOf((*hash.Hash32)(nil)),
"Hash64": reflect.ValueOf((*hash.Hash64)(nil)),
// interface wrapper definitions
"_Hash": reflect.ValueOf((*_hash_Hash)(nil)),
"_Hash32": reflect.ValueOf((*_hash_Hash32)(nil)),
"_Hash64": reflect.ValueOf((*_hash_Hash64)(nil)),
}
}
// _hash_Hash is an interface wrapper for Hash type
type _hash_Hash struct {
WBlockSize func() int
WReset func()
WSize func() int
WSum func(b []byte) []byte
WWrite func(p []byte) (n int, err error)
}
func (W _hash_Hash) BlockSize() int { return W.WBlockSize() }
func (W _hash_Hash) Reset() { W.WReset() }
func (W _hash_Hash) Size() int { return W.WSize() }
func (W _hash_Hash) Sum(b []byte) []byte { return W.WSum(b) }
func (W _hash_Hash) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _hash_Hash32 is an interface wrapper for Hash32 type
type _hash_Hash32 struct {
WBlockSize func() int
WReset func()
WSize func() int
WSum func(b []byte) []byte
WSum32 func() uint32
WWrite func(p []byte) (n int, err error)
}
func (W _hash_Hash32) BlockSize() int { return W.WBlockSize() }
func (W _hash_Hash32) Reset() { W.WReset() }
func (W _hash_Hash32) Size() int { return W.WSize() }
func (W _hash_Hash32) Sum(b []byte) []byte { return W.WSum(b) }
func (W _hash_Hash32) Sum32() uint32 { return W.WSum32() }
func (W _hash_Hash32) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _hash_Hash64 is an interface wrapper for Hash64 type
type _hash_Hash64 struct {
WBlockSize func() int
WReset func()
WSize func() int
WSum func(b []byte) []byte
WSum64 func() uint64
WWrite func(p []byte) (n int, err error)
}
func (W _hash_Hash64) BlockSize() int { return W.WBlockSize() }
func (W _hash_Hash64) Reset() { W.WReset() }
func (W _hash_Hash64) Size() int { return W.WSize() }
func (W _hash_Hash64) Sum(b []byte) []byte { return W.WSum(b) }
func (W _hash_Hash64) Sum64() uint64 { return W.WSum64() }
func (W _hash_Hash64) Write(p []byte) (n int, err error) { return W.WWrite(p) }

19
stdlib/go1_11_hash_adler32.go
View File

@@ -1,19 +0,0 @@
// Code generated by 'goexports hash/adler32'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"hash/adler32"
"reflect"
)
func init() {
Symbols["hash/adler32"] = map[string]reflect.Value{
// function, constant and variable definitions
"Checksum": reflect.ValueOf(adler32.Checksum),
"New": reflect.ValueOf(adler32.New),
"Size": reflect.ValueOf(adler32.Size),
}
}

30
stdlib/go1_11_hash_crc32.go
View File

@@ -1,30 +0,0 @@
// Code generated by 'goexports hash/crc32'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"hash/crc32"
"reflect"
)
func init() {
Symbols["hash/crc32"] = map[string]reflect.Value{
// function, constant and variable definitions
"Castagnoli": reflect.ValueOf(uint32(crc32.Castagnoli)),
"Checksum": reflect.ValueOf(crc32.Checksum),
"ChecksumIEEE": reflect.ValueOf(crc32.ChecksumIEEE),
"IEEE": reflect.ValueOf(uint32(crc32.IEEE)),
"IEEETable": reflect.ValueOf(&crc32.IEEETable).Elem(),
"Koopman": reflect.ValueOf(uint32(crc32.Koopman)),
"MakeTable": reflect.ValueOf(crc32.MakeTable),
"New": reflect.ValueOf(crc32.New),
"NewIEEE": reflect.ValueOf(crc32.NewIEEE),
"Size": reflect.ValueOf(crc32.Size),
"Update": reflect.ValueOf(crc32.Update),
// type definitions
"Table": reflect.ValueOf((*crc32.Table)(nil)),
}
}

26
stdlib/go1_11_hash_crc64.go
View File

@@ -1,26 +0,0 @@
// Code generated by 'goexports hash/crc64'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"hash/crc64"
"reflect"
)
func init() {
Symbols["hash/crc64"] = map[string]reflect.Value{
// function, constant and variable definitions
"Checksum": reflect.ValueOf(crc64.Checksum),
"ECMA": reflect.ValueOf(uint64(crc64.ECMA)),
"ISO": reflect.ValueOf(uint64(crc64.ISO)),
"MakeTable": reflect.ValueOf(crc64.MakeTable),
"New": reflect.ValueOf(crc64.New),
"Size": reflect.ValueOf(crc64.Size),
"Update": reflect.ValueOf(crc64.Update),
// type definitions
"Table": reflect.ValueOf((*crc64.Table)(nil)),
}
}

22
stdlib/go1_11_hash_fnv.go
View File

@@ -1,22 +0,0 @@
// Code generated by 'goexports hash/fnv'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"hash/fnv"
"reflect"
)
func init() {
Symbols["hash/fnv"] = map[string]reflect.Value{
// function, constant and variable definitions
"New128": reflect.ValueOf(fnv.New128),
"New128a": reflect.ValueOf(fnv.New128a),
"New32": reflect.ValueOf(fnv.New32),
"New32a": reflect.ValueOf(fnv.New32a),
"New64": reflect.ValueOf(fnv.New64),
"New64a": reflect.ValueOf(fnv.New64a),
}
}

18
stdlib/go1_11_html.go
View File

@@ -1,18 +0,0 @@
// Code generated by 'goexports html'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"html"
"reflect"
)
func init() {
Symbols["html"] = map[string]reflect.Value{
// function, constant and variable definitions
"EscapeString": reflect.ValueOf(html.EscapeString),
"UnescapeString": reflect.ValueOf(html.UnescapeString),
}
}

53
stdlib/go1_11_html_template.go
View File

@@ -1,53 +0,0 @@
// Code generated by 'goexports html/template'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"html/template"
"reflect"
)
func init() {
Symbols["html/template"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrAmbigContext": reflect.ValueOf(template.ErrAmbigContext),
"ErrBadHTML": reflect.ValueOf(template.ErrBadHTML),
"ErrBranchEnd": reflect.ValueOf(template.ErrBranchEnd),
"ErrEndContext": reflect.ValueOf(template.ErrEndContext),
"ErrNoSuchTemplate": reflect.ValueOf(template.ErrNoSuchTemplate),
"ErrOutputContext": reflect.ValueOf(template.ErrOutputContext),
"ErrPartialCharset": reflect.ValueOf(template.ErrPartialCharset),
"ErrPartialEscape": reflect.ValueOf(template.ErrPartialEscape),
"ErrPredefinedEscaper": reflect.ValueOf(template.ErrPredefinedEscaper),
"ErrRangeLoopReentry": reflect.ValueOf(template.ErrRangeLoopReentry),
"ErrSlashAmbig": reflect.ValueOf(template.ErrSlashAmbig),
"HTMLEscape": reflect.ValueOf(template.HTMLEscape),
"HTMLEscapeString": reflect.ValueOf(template.HTMLEscapeString),
"HTMLEscaper": reflect.ValueOf(template.HTMLEscaper),
"IsTrue": reflect.ValueOf(template.IsTrue),
"JSEscape": reflect.ValueOf(template.JSEscape),
"JSEscapeString": reflect.ValueOf(template.JSEscapeString),
"JSEscaper": reflect.ValueOf(template.JSEscaper),
"Must": reflect.ValueOf(template.Must),
"New": reflect.ValueOf(template.New),
"OK": reflect.ValueOf(template.OK),
"ParseFiles": reflect.ValueOf(template.ParseFiles),
"ParseGlob": reflect.ValueOf(template.ParseGlob),
"URLQueryEscaper": reflect.ValueOf(template.URLQueryEscaper),
// type definitions
"CSS": reflect.ValueOf((*template.CSS)(nil)),
"Error": reflect.ValueOf((*template.Error)(nil)),
"ErrorCode": reflect.ValueOf((*template.ErrorCode)(nil)),
"FuncMap": reflect.ValueOf((*template.FuncMap)(nil)),
"HTML": reflect.ValueOf((*template.HTML)(nil)),
"HTMLAttr": reflect.ValueOf((*template.HTMLAttr)(nil)),
"JS": reflect.ValueOf((*template.JS)(nil)),
"JSStr": reflect.ValueOf((*template.JSStr)(nil)),
"Srcset": reflect.ValueOf((*template.Srcset)(nil)),
"Template": reflect.ValueOf((*template.Template)(nil)),
"URL": reflect.ValueOf((*template.URL)(nil)),
}
}

97
stdlib/go1_11_image.go
View File

@@ -1,97 +0,0 @@
// Code generated by 'goexports image'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"image"
"image/color"
"reflect"
)
func init() {
Symbols["image"] = map[string]reflect.Value{
// function, constant and variable definitions
"Black": reflect.ValueOf(&image.Black).Elem(),
"Decode": reflect.ValueOf(image.Decode),
"DecodeConfig": reflect.ValueOf(image.DecodeConfig),
"ErrFormat": reflect.ValueOf(&image.ErrFormat).Elem(),
"NewAlpha": reflect.ValueOf(image.NewAlpha),
"NewAlpha16": reflect.ValueOf(image.NewAlpha16),
"NewCMYK": reflect.ValueOf(image.NewCMYK),
"NewGray": reflect.ValueOf(image.NewGray),
"NewGray16": reflect.ValueOf(image.NewGray16),
"NewNRGBA": reflect.ValueOf(image.NewNRGBA),
"NewNRGBA64": reflect.ValueOf(image.NewNRGBA64),
"NewNYCbCrA": reflect.ValueOf(image.NewNYCbCrA),
"NewPaletted": reflect.ValueOf(image.NewPaletted),
"NewRGBA": reflect.ValueOf(image.NewRGBA),
"NewRGBA64": reflect.ValueOf(image.NewRGBA64),
"NewUniform": reflect.ValueOf(image.NewUniform),
"NewYCbCr": reflect.ValueOf(image.NewYCbCr),
"Opaque": reflect.ValueOf(&image.Opaque).Elem(),
"Pt": reflect.ValueOf(image.Pt),
"Rect": reflect.ValueOf(image.Rect),
"RegisterFormat": reflect.ValueOf(image.RegisterFormat),
"Transparent": reflect.ValueOf(&image.Transparent).Elem(),
"White": reflect.ValueOf(&image.White).Elem(),
"YCbCrSubsampleRatio410": reflect.ValueOf(image.YCbCrSubsampleRatio410),
"YCbCrSubsampleRatio411": reflect.ValueOf(image.YCbCrSubsampleRatio411),
"YCbCrSubsampleRatio420": reflect.ValueOf(image.YCbCrSubsampleRatio420),
"YCbCrSubsampleRatio422": reflect.ValueOf(image.YCbCrSubsampleRatio422),
"YCbCrSubsampleRatio440": reflect.ValueOf(image.YCbCrSubsampleRatio440),
"YCbCrSubsampleRatio444": reflect.ValueOf(image.YCbCrSubsampleRatio444),
"ZP": reflect.ValueOf(&image.ZP).Elem(),
"ZR": reflect.ValueOf(&image.ZR).Elem(),
// type definitions
"Alpha": reflect.ValueOf((*image.Alpha)(nil)),
"Alpha16": reflect.ValueOf((*image.Alpha16)(nil)),
"CMYK": reflect.ValueOf((*image.CMYK)(nil)),
"Config": reflect.ValueOf((*image.Config)(nil)),
"Gray": reflect.ValueOf((*image.Gray)(nil)),
"Gray16": reflect.ValueOf((*image.Gray16)(nil)),
"Image": reflect.ValueOf((*image.Image)(nil)),
"NRGBA": reflect.ValueOf((*image.NRGBA)(nil)),
"NRGBA64": reflect.ValueOf((*image.NRGBA64)(nil)),
"NYCbCrA": reflect.ValueOf((*image.NYCbCrA)(nil)),
"Paletted": reflect.ValueOf((*image.Paletted)(nil)),
"PalettedImage": reflect.ValueOf((*image.PalettedImage)(nil)),
"Point": reflect.ValueOf((*image.Point)(nil)),
"RGBA": reflect.ValueOf((*image.RGBA)(nil)),
"RGBA64": reflect.ValueOf((*image.RGBA64)(nil)),
"Rectangle": reflect.ValueOf((*image.Rectangle)(nil)),
"Uniform": reflect.ValueOf((*image.Uniform)(nil)),
"YCbCr": reflect.ValueOf((*image.YCbCr)(nil)),
"YCbCrSubsampleRatio": reflect.ValueOf((*image.YCbCrSubsampleRatio)(nil)),
// interface wrapper definitions
"_Image": reflect.ValueOf((*_image_Image)(nil)),
"_PalettedImage": reflect.ValueOf((*_image_PalettedImage)(nil)),
}
}
// _image_Image is an interface wrapper for Image type
type _image_Image struct {
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorModel func() color.Model
}
func (W _image_Image) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_Image) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_Image) ColorModel() color.Model { return W.WColorModel() }
// _image_PalettedImage is an interface wrapper for PalettedImage type
type _image_PalettedImage struct {
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorIndexAt func(x int, y int) uint8
WColorModel func() color.Model
}
func (W _image_PalettedImage) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_PalettedImage) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_PalettedImage) ColorIndexAt(x int, y int) uint8 { return W.WColorIndexAt(x, y) }
func (W _image_PalettedImage) ColorModel() color.Model { return W.WColorModel() }

70
stdlib/go1_11_image_color.go
View File

@@ -1,70 +0,0 @@
// Code generated by 'goexports image/color'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"image/color"
"reflect"
)
func init() {
Symbols["image/color"] = map[string]reflect.Value{
// function, constant and variable definitions
"Alpha16Model": reflect.ValueOf(&color.Alpha16Model).Elem(),
"AlphaModel": reflect.ValueOf(&color.AlphaModel).Elem(),
"Black": reflect.ValueOf(&color.Black).Elem(),
"CMYKModel": reflect.ValueOf(&color.CMYKModel).Elem(),
"CMYKToRGB": reflect.ValueOf(color.CMYKToRGB),
"Gray16Model": reflect.ValueOf(&color.Gray16Model).Elem(),
"GrayModel": reflect.ValueOf(&color.GrayModel).Elem(),
"ModelFunc": reflect.ValueOf(color.ModelFunc),
"NRGBA64Model": reflect.ValueOf(&color.NRGBA64Model).Elem(),
"NRGBAModel": reflect.ValueOf(&color.NRGBAModel).Elem(),
"NYCbCrAModel": reflect.ValueOf(&color.NYCbCrAModel).Elem(),
"Opaque": reflect.ValueOf(&color.Opaque).Elem(),
"RGBA64Model": reflect.ValueOf(&color.RGBA64Model).Elem(),
"RGBAModel": reflect.ValueOf(&color.RGBAModel).Elem(),
"RGBToCMYK": reflect.ValueOf(color.RGBToCMYK),
"RGBToYCbCr": reflect.ValueOf(color.RGBToYCbCr),
"Transparent": reflect.ValueOf(&color.Transparent).Elem(),
"White": reflect.ValueOf(&color.White).Elem(),
"YCbCrModel": reflect.ValueOf(&color.YCbCrModel).Elem(),
"YCbCrToRGB": reflect.ValueOf(color.YCbCrToRGB),
// type definitions
"Alpha": reflect.ValueOf((*color.Alpha)(nil)),
"Alpha16": reflect.ValueOf((*color.Alpha16)(nil)),
"CMYK": reflect.ValueOf((*color.CMYK)(nil)),
"Color": reflect.ValueOf((*color.Color)(nil)),
"Gray": reflect.ValueOf((*color.Gray)(nil)),
"Gray16": reflect.ValueOf((*color.Gray16)(nil)),
"Model": reflect.ValueOf((*color.Model)(nil)),
"NRGBA": reflect.ValueOf((*color.NRGBA)(nil)),
"NRGBA64": reflect.ValueOf((*color.NRGBA64)(nil)),
"NYCbCrA": reflect.ValueOf((*color.NYCbCrA)(nil)),
"Palette": reflect.ValueOf((*color.Palette)(nil)),
"RGBA": reflect.ValueOf((*color.RGBA)(nil)),
"RGBA64": reflect.ValueOf((*color.RGBA64)(nil)),
"YCbCr": reflect.ValueOf((*color.YCbCr)(nil)),
// interface wrapper definitions
"_Color": reflect.ValueOf((*_image_color_Color)(nil)),
"_Model": reflect.ValueOf((*_image_color_Model)(nil)),
}
}
// _image_color_Color is an interface wrapper for Color type
type _image_color_Color struct {
WRGBA func() (r uint32, g uint32, b uint32, a uint32)
}
func (W _image_color_Color) RGBA() (r uint32, g uint32, b uint32, a uint32) { return W.WRGBA() }
// _image_color_Model is an interface wrapper for Model type
type _image_color_Model struct {
WConvert func(c color.Color) color.Color
}
func (W _image_color_Model) Convert(c color.Color) color.Color { return W.WConvert(c) }

18
stdlib/go1_11_image_color_palette.go
View File

@@ -1,18 +0,0 @@
// Code generated by 'goexports image/color/palette'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"image/color/palette"
"reflect"
)
func init() {
Symbols["image/color/palette"] = map[string]reflect.Value{
// function, constant and variable definitions
"Plan9": reflect.ValueOf(&palette.Plan9).Elem(),
"WebSafe": reflect.ValueOf(&palette.WebSafe).Elem(),
}
}

65
stdlib/go1_11_image_draw.go
View File

@@ -1,65 +0,0 @@
// Code generated by 'goexports image/draw'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"image"
"image/color"
"image/draw"
"reflect"
)
func init() {
Symbols["image/draw"] = map[string]reflect.Value{
// function, constant and variable definitions
"Draw": reflect.ValueOf(draw.Draw),
"DrawMask": reflect.ValueOf(draw.DrawMask),
"FloydSteinberg": reflect.ValueOf(&draw.FloydSteinberg).Elem(),
"Over": reflect.ValueOf(draw.Over),
"Src": reflect.ValueOf(draw.Src),
// type definitions
"Drawer": reflect.ValueOf((*draw.Drawer)(nil)),
"Image": reflect.ValueOf((*draw.Image)(nil)),
"Op": reflect.ValueOf((*draw.Op)(nil)),
"Quantizer": reflect.ValueOf((*draw.Quantizer)(nil)),
// interface wrapper definitions
"_Drawer": reflect.ValueOf((*_image_draw_Drawer)(nil)),
"_Image": reflect.ValueOf((*_image_draw_Image)(nil)),
"_Quantizer": reflect.ValueOf((*_image_draw_Quantizer)(nil)),
}
}
// _image_draw_Drawer is an interface wrapper for Drawer type
type _image_draw_Drawer struct {
WDraw func(dst draw.Image, r image.Rectangle, src image.Image, sp image.Point)
}
func (W _image_draw_Drawer) Draw(dst draw.Image, r image.Rectangle, src image.Image, sp image.Point) {
W.WDraw(dst, r, src, sp)
}
// _image_draw_Image is an interface wrapper for Image type
type _image_draw_Image struct {
WAt func(x int, y int) color.Color
WBounds func() image.Rectangle
WColorModel func() color.Model
WSet func(x int, y int, c color.Color)
}
func (W _image_draw_Image) At(x int, y int) color.Color { return W.WAt(x, y) }
func (W _image_draw_Image) Bounds() image.Rectangle { return W.WBounds() }
func (W _image_draw_Image) ColorModel() color.Model { return W.WColorModel() }
func (W _image_draw_Image) Set(x int, y int, c color.Color) { W.WSet(x, y, c) }
// _image_draw_Quantizer is an interface wrapper for Quantizer type
type _image_draw_Quantizer struct {
WQuantize func(p color.Palette, m image.Image) color.Palette
}
func (W _image_draw_Quantizer) Quantize(p color.Palette, m image.Image) color.Palette {
return W.WQuantize(p, m)
}

28
stdlib/go1_11_image_gif.go
View File

@@ -1,28 +0,0 @@
// Code generated by 'goexports image/gif'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"image/gif"
"reflect"
)
func init() {
Symbols["image/gif"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(gif.Decode),
"DecodeAll": reflect.ValueOf(gif.DecodeAll),
"DecodeConfig": reflect.ValueOf(gif.DecodeConfig),
"DisposalBackground": reflect.ValueOf(gif.DisposalBackground),
"DisposalNone": reflect.ValueOf(gif.DisposalNone),
"DisposalPrevious": reflect.ValueOf(gif.DisposalPrevious),
"Encode": reflect.ValueOf(gif.Encode),
"EncodeAll": reflect.ValueOf(gif.EncodeAll),
// type definitions
"GIF": reflect.ValueOf((*gif.GIF)(nil)),
"Options": reflect.ValueOf((*gif.Options)(nil)),
}
}

38
stdlib/go1_11_image_jpeg.go
View File

@@ -1,38 +0,0 @@
// Code generated by 'goexports image/jpeg'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"image/jpeg"
"reflect"
)
func init() {
Symbols["image/jpeg"] = map[string]reflect.Value{
// function, constant and variable definitions
"Decode": reflect.ValueOf(jpeg.Decode),
"DecodeConfig": reflect.ValueOf(jpeg.DecodeConfig),
"DefaultQuality": reflect.ValueOf(jpeg.DefaultQuality),
"Encode": reflect.ValueOf(jpeg.Encode),
// type definitions
"FormatError": reflect.ValueOf((*jpeg.FormatError)(nil)),
"Options": reflect.ValueOf((*jpeg.Options)(nil)),
"Reader": reflect.ValueOf((*jpeg.Reader)(nil)),
"UnsupportedError": reflect.ValueOf((*jpeg.UnsupportedError)(nil)),
// interface wrapper definitions
"_Reader": reflect.ValueOf((*_image_jpeg_Reader)(nil)),
}
}
// _image_jpeg_Reader is an interface wrapper for Reader type
type _image_jpeg_Reader struct {
WRead func(p []byte) (n int, err error)
WReadByte func() (byte, error)
}
func (W _image_jpeg_Reader) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _image_jpeg_Reader) ReadByte() (byte, error) { return W.WReadByte() }

43
stdlib/go1_11_image_png.go
View File

@@ -1,43 +0,0 @@
// Code generated by 'goexports image/png'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"image/png"
"reflect"
)
func init() {
Symbols["image/png"] = map[string]reflect.Value{
// function, constant and variable definitions
"BestCompression": reflect.ValueOf(png.BestCompression),
"BestSpeed": reflect.ValueOf(png.BestSpeed),
"Decode": reflect.ValueOf(png.Decode),
"DecodeConfig": reflect.ValueOf(png.DecodeConfig),
"DefaultCompression": reflect.ValueOf(png.DefaultCompression),
"Encode": reflect.ValueOf(png.Encode),
"NoCompression": reflect.ValueOf(png.NoCompression),
// type definitions
"CompressionLevel": reflect.ValueOf((*png.CompressionLevel)(nil)),
"Encoder": reflect.ValueOf((*png.Encoder)(nil)),
"EncoderBuffer": reflect.ValueOf((*png.EncoderBuffer)(nil)),
"EncoderBufferPool": reflect.ValueOf((*png.EncoderBufferPool)(nil)),
"FormatError": reflect.ValueOf((*png.FormatError)(nil)),
"UnsupportedError": reflect.ValueOf((*png.UnsupportedError)(nil)),
// interface wrapper definitions
"_EncoderBufferPool": reflect.ValueOf((*_image_png_EncoderBufferPool)(nil)),
}
}
// _image_png_EncoderBufferPool is an interface wrapper for EncoderBufferPool type
type _image_png_EncoderBufferPool struct {
WGet func() *png.EncoderBuffer
WPut func(a0 *png.EncoderBuffer)
}
func (W _image_png_EncoderBufferPool) Get() *png.EncoderBuffer { return W.WGet() }
func (W _image_png_EncoderBufferPool) Put(a0 *png.EncoderBuffer) { W.WPut(a0) }

20
stdlib/go1_11_index_suffixarray.go
View File

@@ -1,20 +0,0 @@
// Code generated by 'goexports index/suffixarray'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"index/suffixarray"
"reflect"
)
func init() {
Symbols["index/suffixarray"] = map[string]reflect.Value{
// function, constant and variable definitions
"New": reflect.ValueOf(suffixarray.New),
// type definitions
"Index": reflect.ValueOf((*suffixarray.Index)(nil)),
}
}

253
stdlib/go1_11_io.go
View File

@@ -1,253 +0,0 @@
// Code generated by 'goexports io'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"io"
"reflect"
)
func init() {
Symbols["io"] = map[string]reflect.Value{
// function, constant and variable definitions
"Copy": reflect.ValueOf(io.Copy),
"CopyBuffer": reflect.ValueOf(io.CopyBuffer),
"CopyN": reflect.ValueOf(io.CopyN),
"EOF": reflect.ValueOf(&io.EOF).Elem(),
"ErrClosedPipe": reflect.ValueOf(&io.ErrClosedPipe).Elem(),
"ErrNoProgress": reflect.ValueOf(&io.ErrNoProgress).Elem(),
"ErrShortBuffer": reflect.ValueOf(&io.ErrShortBuffer).Elem(),
"ErrShortWrite": reflect.ValueOf(&io.ErrShortWrite).Elem(),
"ErrUnexpectedEOF": reflect.ValueOf(&io.ErrUnexpectedEOF).Elem(),
"LimitReader": reflect.ValueOf(io.LimitReader),
"MultiReader": reflect.ValueOf(io.MultiReader),
"MultiWriter": reflect.ValueOf(io.MultiWriter),
"NewSectionReader": reflect.ValueOf(io.NewSectionReader),
"Pipe": reflect.ValueOf(io.Pipe),
"ReadAtLeast": reflect.ValueOf(io.ReadAtLeast),
"ReadFull": reflect.ValueOf(io.ReadFull),
"SeekCurrent": reflect.ValueOf(io.SeekCurrent),
"SeekEnd": reflect.ValueOf(io.SeekEnd),
"SeekStart": reflect.ValueOf(io.SeekStart),
"TeeReader": reflect.ValueOf(io.TeeReader),
"WriteString": reflect.ValueOf(io.WriteString),
// type definitions
"ByteReader": reflect.ValueOf((*io.ByteReader)(nil)),
"ByteScanner": reflect.ValueOf((*io.ByteScanner)(nil)),
"ByteWriter": reflect.ValueOf((*io.ByteWriter)(nil)),
"Closer": reflect.ValueOf((*io.Closer)(nil)),
"LimitedReader": reflect.ValueOf((*io.LimitedReader)(nil)),
"PipeReader": reflect.ValueOf((*io.PipeReader)(nil)),
"PipeWriter": reflect.ValueOf((*io.PipeWriter)(nil)),
"ReadCloser": reflect.ValueOf((*io.ReadCloser)(nil)),
"ReadSeeker": reflect.ValueOf((*io.ReadSeeker)(nil)),
"ReadWriteCloser": reflect.ValueOf((*io.ReadWriteCloser)(nil)),
"ReadWriteSeeker": reflect.ValueOf((*io.ReadWriteSeeker)(nil)),
"ReadWriter": reflect.ValueOf((*io.ReadWriter)(nil)),
"Reader": reflect.ValueOf((*io.Reader)(nil)),
"ReaderAt": reflect.ValueOf((*io.ReaderAt)(nil)),
"ReaderFrom": reflect.ValueOf((*io.ReaderFrom)(nil)),
"RuneReader": reflect.ValueOf((*io.RuneReader)(nil)),
"RuneScanner": reflect.ValueOf((*io.RuneScanner)(nil)),
"SectionReader": reflect.ValueOf((*io.SectionReader)(nil)),
"Seeker": reflect.ValueOf((*io.Seeker)(nil)),
"WriteCloser": reflect.ValueOf((*io.WriteCloser)(nil)),
"WriteSeeker": reflect.ValueOf((*io.WriteSeeker)(nil)),
"Writer": reflect.ValueOf((*io.Writer)(nil)),
"WriterAt": reflect.ValueOf((*io.WriterAt)(nil)),
"WriterTo": reflect.ValueOf((*io.WriterTo)(nil)),
// interface wrapper definitions
"_ByteReader": reflect.ValueOf((*_io_ByteReader)(nil)),
"_ByteScanner": reflect.ValueOf((*_io_ByteScanner)(nil)),
"_ByteWriter": reflect.ValueOf((*_io_ByteWriter)(nil)),
"_Closer": reflect.ValueOf((*_io_Closer)(nil)),
"_ReadCloser": reflect.ValueOf((*_io_ReadCloser)(nil)),
"_ReadSeeker": reflect.ValueOf((*_io_ReadSeeker)(nil)),
"_ReadWriteCloser": reflect.ValueOf((*_io_ReadWriteCloser)(nil)),
"_ReadWriteSeeker": reflect.ValueOf((*_io_ReadWriteSeeker)(nil)),
"_ReadWriter": reflect.ValueOf((*_io_ReadWriter)(nil)),
"_Reader": reflect.ValueOf((*_io_Reader)(nil)),
"_ReaderAt": reflect.ValueOf((*_io_ReaderAt)(nil)),
"_ReaderFrom": reflect.ValueOf((*_io_ReaderFrom)(nil)),
"_RuneReader": reflect.ValueOf((*_io_RuneReader)(nil)),
"_RuneScanner": reflect.ValueOf((*_io_RuneScanner)(nil)),
"_Seeker": reflect.ValueOf((*_io_Seeker)(nil)),
"_WriteCloser": reflect.ValueOf((*_io_WriteCloser)(nil)),
"_WriteSeeker": reflect.ValueOf((*_io_WriteSeeker)(nil)),
"_Writer": reflect.ValueOf((*_io_Writer)(nil)),
"_WriterAt": reflect.ValueOf((*_io_WriterAt)(nil)),
"_WriterTo": reflect.ValueOf((*_io_WriterTo)(nil)),
}
}
// _io_ByteReader is an interface wrapper for ByteReader type
type _io_ByteReader struct {
WReadByte func() (byte, error)
}
func (W _io_ByteReader) ReadByte() (byte, error) { return W.WReadByte() }
// _io_ByteScanner is an interface wrapper for ByteScanner type
type _io_ByteScanner struct {
WReadByte func() (byte, error)
WUnreadByte func() error
}
func (W _io_ByteScanner) ReadByte() (byte, error) { return W.WReadByte() }
func (W _io_ByteScanner) UnreadByte() error { return W.WUnreadByte() }
// _io_ByteWriter is an interface wrapper for ByteWriter type
type _io_ByteWriter struct {
WWriteByte func(c byte) error
}
func (W _io_ByteWriter) WriteByte(c byte) error { return W.WWriteByte(c) }
// _io_Closer is an interface wrapper for Closer type
type _io_Closer struct {
WClose func() error
}
func (W _io_Closer) Close() error { return W.WClose() }
// _io_ReadCloser is an interface wrapper for ReadCloser type
type _io_ReadCloser struct {
WClose func() error
WRead func(p []byte) (n int, err error)
}
func (W _io_ReadCloser) Close() error { return W.WClose() }
func (W _io_ReadCloser) Read(p []byte) (n int, err error) { return W.WRead(p) }
// _io_ReadSeeker is an interface wrapper for ReadSeeker type
type _io_ReadSeeker struct {
WRead func(p []byte) (n int, err error)
WSeek func(offset int64, whence int) (int64, error)
}
func (W _io_ReadSeeker) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadSeeker) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}
// _io_ReadWriteCloser is an interface wrapper for ReadWriteCloser type
type _io_ReadWriteCloser struct {
WClose func() error
WRead func(p []byte) (n int, err error)
WWrite func(p []byte) (n int, err error)
}
func (W _io_ReadWriteCloser) Close() error { return W.WClose() }
func (W _io_ReadWriteCloser) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadWriteCloser) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_ReadWriteSeeker is an interface wrapper for ReadWriteSeeker type
type _io_ReadWriteSeeker struct {
WRead func(p []byte) (n int, err error)
WSeek func(offset int64, whence int) (int64, error)
WWrite func(p []byte) (n int, err error)
}
func (W _io_ReadWriteSeeker) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadWriteSeeker) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}
func (W _io_ReadWriteSeeker) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_ReadWriter is an interface wrapper for ReadWriter type
type _io_ReadWriter struct {
WRead func(p []byte) (n int, err error)
WWrite func(p []byte) (n int, err error)
}
func (W _io_ReadWriter) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _io_ReadWriter) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_Reader is an interface wrapper for Reader type
type _io_Reader struct {
WRead func(p []byte) (n int, err error)
}
func (W _io_Reader) Read(p []byte) (n int, err error) { return W.WRead(p) }
// _io_ReaderAt is an interface wrapper for ReaderAt type
type _io_ReaderAt struct {
WReadAt func(p []byte, off int64) (n int, err error)
}
func (W _io_ReaderAt) ReadAt(p []byte, off int64) (n int, err error) { return W.WReadAt(p, off) }
// _io_ReaderFrom is an interface wrapper for ReaderFrom type
type _io_ReaderFrom struct {
WReadFrom func(r io.Reader) (n int64, err error)
}
func (W _io_ReaderFrom) ReadFrom(r io.Reader) (n int64, err error) { return W.WReadFrom(r) }
// _io_RuneReader is an interface wrapper for RuneReader type
type _io_RuneReader struct {
WReadRune func() (r rune, size int, err error)
}
func (W _io_RuneReader) ReadRune() (r rune, size int, err error) { return W.WReadRune() }
// _io_RuneScanner is an interface wrapper for RuneScanner type
type _io_RuneScanner struct {
WReadRune func() (r rune, size int, err error)
WUnreadRune func() error
}
func (W _io_RuneScanner) ReadRune() (r rune, size int, err error) { return W.WReadRune() }
func (W _io_RuneScanner) UnreadRune() error { return W.WUnreadRune() }
// _io_Seeker is an interface wrapper for Seeker type
type _io_Seeker struct {
WSeek func(offset int64, whence int) (int64, error)
}
func (W _io_Seeker) Seek(offset int64, whence int) (int64, error) { return W.WSeek(offset, whence) }
// _io_WriteCloser is an interface wrapper for WriteCloser type
type _io_WriteCloser struct {
WClose func() error
WWrite func(p []byte) (n int, err error)
}
func (W _io_WriteCloser) Close() error { return W.WClose() }
func (W _io_WriteCloser) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_WriteSeeker is an interface wrapper for WriteSeeker type
type _io_WriteSeeker struct {
WSeek func(offset int64, whence int) (int64, error)
WWrite func(p []byte) (n int, err error)
}
func (W _io_WriteSeeker) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}
func (W _io_WriteSeeker) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_Writer is an interface wrapper for Writer type
type _io_Writer struct {
WWrite func(p []byte) (n int, err error)
}
func (W _io_Writer) Write(p []byte) (n int, err error) { return W.WWrite(p) }
// _io_WriterAt is an interface wrapper for WriterAt type
type _io_WriterAt struct {
WWriteAt func(p []byte, off int64) (n int, err error)
}
func (W _io_WriterAt) WriteAt(p []byte, off int64) (n int, err error) { return W.WWriteAt(p, off) }
// _io_WriterTo is an interface wrapper for WriterTo type
type _io_WriterTo struct {
WWriteTo func(w io.Writer) (n int64, err error)
}
func (W _io_WriterTo) WriteTo(w io.Writer) (n int64, err error) { return W.WWriteTo(w) }

24
stdlib/go1_11_io_ioutil.go
View File

@@ -1,24 +0,0 @@
// Code generated by 'goexports io/ioutil'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"io/ioutil"
"reflect"
)
func init() {
Symbols["io/ioutil"] = map[string]reflect.Value{
// function, constant and variable definitions
"Discard": reflect.ValueOf(&ioutil.Discard).Elem(),
"NopCloser": reflect.ValueOf(ioutil.NopCloser),
"ReadAll": reflect.ValueOf(ioutil.ReadAll),
"ReadDir": reflect.ValueOf(ioutil.ReadDir),
"ReadFile": reflect.ValueOf(ioutil.ReadFile),
"TempDir": reflect.ValueOf(ioutil.TempDir),
"TempFile": reflect.ValueOf(ioutil.TempFile),
"WriteFile": reflect.ValueOf(ioutil.WriteFile),
}
}

42
stdlib/go1_11_log.go
View File

@@ -1,42 +0,0 @@
// Code generated by 'goexports log'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"log"
"reflect"
)
func init() {
Symbols["log"] = map[string]reflect.Value{
// function, constant and variable definitions
"Fatal": reflect.ValueOf(log.Fatal),
"Fatalf": reflect.ValueOf(log.Fatalf),
"Fatalln": reflect.ValueOf(log.Fatalln),
"Flags": reflect.ValueOf(log.Flags),
"LUTC": reflect.ValueOf(log.LUTC),
"Ldate": reflect.ValueOf(log.Ldate),
"Llongfile": reflect.ValueOf(log.Llongfile),
"Lmicroseconds": reflect.ValueOf(log.Lmicroseconds),
"Lshortfile": reflect.ValueOf(log.Lshortfile),
"LstdFlags": reflect.ValueOf(log.LstdFlags),
"Ltime": reflect.ValueOf(log.Ltime),
"New": reflect.ValueOf(log.New),
"Output": reflect.ValueOf(log.Output),
"Panic": reflect.ValueOf(log.Panic),
"Panicf": reflect.ValueOf(log.Panicf),
"Panicln": reflect.ValueOf(log.Panicln),
"Prefix": reflect.ValueOf(log.Prefix),
"Print": reflect.ValueOf(log.Print),
"Printf": reflect.ValueOf(log.Printf),
"Println": reflect.ValueOf(log.Println),
"SetFlags": reflect.ValueOf(log.SetFlags),
"SetOutput": reflect.ValueOf(log.SetOutput),
"SetPrefix": reflect.ValueOf(log.SetPrefix),
// type definitions
"Logger": reflect.ValueOf((*log.Logger)(nil)),
}
}

51
stdlib/go1_11_log_syslog.go
View File

@@ -1,51 +0,0 @@
// Code generated by 'goexports log/syslog'. DO NOT EDIT.
// +build go1.11,!go1.12,!windows,!nacl,!plan9
package stdlib
import (
"log/syslog"
"reflect"
)
func init() {
Symbols["log/syslog"] = map[string]reflect.Value{
// function, constant and variable definitions
"Dial": reflect.ValueOf(syslog.Dial),
"LOG_ALERT": reflect.ValueOf(syslog.LOG_ALERT),
"LOG_AUTH": reflect.ValueOf(syslog.LOG_AUTH),
"LOG_AUTHPRIV": reflect.ValueOf(syslog.LOG_AUTHPRIV),
"LOG_CRIT": reflect.ValueOf(syslog.LOG_CRIT),
"LOG_CRON": reflect.ValueOf(syslog.LOG_CRON),
"LOG_DAEMON": reflect.ValueOf(syslog.LOG_DAEMON),
"LOG_DEBUG": reflect.ValueOf(syslog.LOG_DEBUG),
"LOG_EMERG": reflect.ValueOf(syslog.LOG_EMERG),
"LOG_ERR": reflect.ValueOf(syslog.LOG_ERR),
"LOG_FTP": reflect.ValueOf(syslog.LOG_FTP),
"LOG_INFO": reflect.ValueOf(syslog.LOG_INFO),
"LOG_KERN": reflect.ValueOf(syslog.LOG_KERN),
"LOG_LOCAL0": reflect.ValueOf(syslog.LOG_LOCAL0),
"LOG_LOCAL1": reflect.ValueOf(syslog.LOG_LOCAL1),
"LOG_LOCAL2": reflect.ValueOf(syslog.LOG_LOCAL2),
"LOG_LOCAL3": reflect.ValueOf(syslog.LOG_LOCAL3),
"LOG_LOCAL4": reflect.ValueOf(syslog.LOG_LOCAL4),
"LOG_LOCAL5": reflect.ValueOf(syslog.LOG_LOCAL5),
"LOG_LOCAL6": reflect.ValueOf(syslog.LOG_LOCAL6),
"LOG_LOCAL7": reflect.ValueOf(syslog.LOG_LOCAL7),
"LOG_LPR": reflect.ValueOf(syslog.LOG_LPR),
"LOG_MAIL": reflect.ValueOf(syslog.LOG_MAIL),
"LOG_NEWS": reflect.ValueOf(syslog.LOG_NEWS),
"LOG_NOTICE": reflect.ValueOf(syslog.LOG_NOTICE),
"LOG_SYSLOG": reflect.ValueOf(syslog.LOG_SYSLOG),
"LOG_USER": reflect.ValueOf(syslog.LOG_USER),
"LOG_UUCP": reflect.ValueOf(syslog.LOG_UUCP),
"LOG_WARNING": reflect.ValueOf(syslog.LOG_WARNING),
"New": reflect.ValueOf(syslog.New),
"NewLogger": reflect.ValueOf(syslog.NewLogger),
// type definitions
"Priority": reflect.ValueOf((*syslog.Priority)(nil)),
"Writer": reflect.ValueOf((*syslog.Writer)(nil)),
}
}

109
stdlib/go1_11_math.go
View File

@@ -1,109 +0,0 @@
// Code generated by 'goexports math'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"math"
"reflect"
)
func init() {
Symbols["math"] = map[string]reflect.Value{
// function, constant and variable definitions
"Abs": reflect.ValueOf(math.Abs),
"Acos": reflect.ValueOf(math.Acos),
"Acosh": reflect.ValueOf(math.Acosh),
"Asin": reflect.ValueOf(math.Asin),
"Asinh": reflect.ValueOf(math.Asinh),
"Atan": reflect.ValueOf(math.Atan),
"Atan2": reflect.ValueOf(math.Atan2),
"Atanh": reflect.ValueOf(math.Atanh),
"Cbrt": reflect.ValueOf(math.Cbrt),
"Ceil": reflect.ValueOf(math.Ceil),
"Copysign": reflect.ValueOf(math.Copysign),
"Cos": reflect.ValueOf(math.Cos),
"Cosh": reflect.ValueOf(math.Cosh),
"Dim": reflect.ValueOf(math.Dim),
"E": reflect.ValueOf(math.E),
"Erf": reflect.ValueOf(math.Erf),
"Erfc": reflect.ValueOf(math.Erfc),
"Erfcinv": reflect.ValueOf(math.Erfcinv),
"Erfinv": reflect.ValueOf(math.Erfinv),
"Exp": reflect.ValueOf(math.Exp),
"Exp2": reflect.ValueOf(math.Exp2),
"Expm1": reflect.ValueOf(math.Expm1),
"Float32bits": reflect.ValueOf(math.Float32bits),
"Float32frombits": reflect.ValueOf(math.Float32frombits),
"Float64bits": reflect.ValueOf(math.Float64bits),
"Float64frombits": reflect.ValueOf(math.Float64frombits),
"Floor": reflect.ValueOf(math.Floor),
"Frexp": reflect.ValueOf(math.Frexp),
"Gamma": reflect.ValueOf(math.Gamma),
"Hypot": reflect.ValueOf(math.Hypot),
"Ilogb": reflect.ValueOf(math.Ilogb),
"Inf": reflect.ValueOf(math.Inf),
"IsInf": reflect.ValueOf(math.IsInf),
"IsNaN": reflect.ValueOf(math.IsNaN),
"J0": reflect.ValueOf(math.J0),
"J1": reflect.ValueOf(math.J1),
"Jn": reflect.ValueOf(math.Jn),
"Ldexp": reflect.ValueOf(math.Ldexp),
"Lgamma": reflect.ValueOf(math.Lgamma),
"Ln10": reflect.ValueOf(math.Ln10),
"Ln2": reflect.ValueOf(math.Ln2),
"Log": reflect.ValueOf(math.Log),
"Log10": reflect.ValueOf(math.Log10),
"Log10E": reflect.ValueOf(math.Log10E),
"Log1p": reflect.ValueOf(math.Log1p),
"Log2": reflect.ValueOf(math.Log2),
"Log2E": reflect.ValueOf(math.Log2E),
"Logb": reflect.ValueOf(math.Logb),
"Max": reflect.ValueOf(math.Max),
"MaxFloat32": reflect.ValueOf(math.MaxFloat32),
"MaxFloat64": reflect.ValueOf(math.MaxFloat64),
"MaxInt16": reflect.ValueOf(math.MaxInt16),
"MaxInt32": reflect.ValueOf(math.MaxInt32),
"MaxInt64": reflect.ValueOf(int64(math.MaxInt64)),
"MaxInt8": reflect.ValueOf(math.MaxInt8),
"MaxUint16": reflect.ValueOf(math.MaxUint16),
"MaxUint32": reflect.ValueOf(uint32(math.MaxUint32)),
"MaxUint64": reflect.ValueOf(uint64(math.MaxUint64)),
"MaxUint8": reflect.ValueOf(math.MaxUint8),
"Min": reflect.ValueOf(math.Min),
"MinInt16": reflect.ValueOf(math.MinInt16),
"MinInt32": reflect.ValueOf(math.MinInt32),
"MinInt64": reflect.ValueOf(int64(math.MinInt64)),
"MinInt8": reflect.ValueOf(math.MinInt8),
"Mod": reflect.ValueOf(math.Mod),
"Modf": reflect.ValueOf(math.Modf),
"NaN": reflect.ValueOf(math.NaN),
"Nextafter": reflect.ValueOf(math.Nextafter),
"Nextafter32": reflect.ValueOf(math.Nextafter32),
"Phi": reflect.ValueOf(math.Phi),
"Pi": reflect.ValueOf(math.Pi),
"Pow": reflect.ValueOf(math.Pow),
"Pow10": reflect.ValueOf(math.Pow10),
"Remainder": reflect.ValueOf(math.Remainder),
"Round": reflect.ValueOf(math.Round),
"RoundToEven": reflect.ValueOf(math.RoundToEven),
"Signbit": reflect.ValueOf(math.Signbit),
"Sin": reflect.ValueOf(math.Sin),
"Sincos": reflect.ValueOf(math.Sincos),
"Sinh": reflect.ValueOf(math.Sinh),
"SmallestNonzeroFloat32": reflect.ValueOf(math.SmallestNonzeroFloat32),
"SmallestNonzeroFloat64": reflect.ValueOf(math.SmallestNonzeroFloat64),
"Sqrt": reflect.ValueOf(math.Sqrt),
"Sqrt2": reflect.ValueOf(math.Sqrt2),
"SqrtE": reflect.ValueOf(math.SqrtE),
"SqrtPhi": reflect.ValueOf(math.SqrtPhi),
"SqrtPi": reflect.ValueOf(math.SqrtPi),
"Tan": reflect.ValueOf(math.Tan),
"Tanh": reflect.ValueOf(math.Tanh),
"Trunc": reflect.ValueOf(math.Trunc),
"Y0": reflect.ValueOf(math.Y0),
"Y1": reflect.ValueOf(math.Y1),
"Yn": reflect.ValueOf(math.Yn),
}
}

43
stdlib/go1_11_math_big.go
View File

@@ -1,43 +0,0 @@
// Code generated by 'goexports math/big'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"math/big"
"reflect"
)
func init() {
Symbols["math/big"] = map[string]reflect.Value{
// function, constant and variable definitions
"Above": reflect.ValueOf(big.Above),
"AwayFromZero": reflect.ValueOf(big.AwayFromZero),
"Below": reflect.ValueOf(big.Below),
"Exact": reflect.ValueOf(big.Exact),
"Jacobi": reflect.ValueOf(big.Jacobi),
"MaxBase": reflect.ValueOf(big.MaxBase),
"MaxExp": reflect.ValueOf(big.MaxExp),
"MaxPrec": reflect.ValueOf(uint32(big.MaxPrec)),
"MinExp": reflect.ValueOf(big.MinExp),
"NewFloat": reflect.ValueOf(big.NewFloat),
"NewInt": reflect.ValueOf(big.NewInt),
"NewRat": reflect.ValueOf(big.NewRat),
"ParseFloat": reflect.ValueOf(big.ParseFloat),
"ToNearestAway": reflect.ValueOf(big.ToNearestAway),
"ToNearestEven": reflect.ValueOf(big.ToNearestEven),
"ToNegativeInf": reflect.ValueOf(big.ToNegativeInf),
"ToPositiveInf": reflect.ValueOf(big.ToPositiveInf),
"ToZero": reflect.ValueOf(big.ToZero),
// type definitions
"Accuracy": reflect.ValueOf((*big.Accuracy)(nil)),
"ErrNaN": reflect.ValueOf((*big.ErrNaN)(nil)),
"Float": reflect.ValueOf((*big.Float)(nil)),
"Int": reflect.ValueOf((*big.Int)(nil)),
"Rat": reflect.ValueOf((*big.Rat)(nil)),
"RoundingMode": reflect.ValueOf((*big.RoundingMode)(nil)),
"Word": reflect.ValueOf((*big.Word)(nil)),
}
}

51
stdlib/go1_11_math_bits.go
View File

@@ -1,51 +0,0 @@
// Code generated by 'goexports math/bits'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"math/bits"
"reflect"
)
func init() {
Symbols["math/bits"] = map[string]reflect.Value{
// function, constant and variable definitions
"LeadingZeros": reflect.ValueOf(bits.LeadingZeros),
"LeadingZeros16": reflect.ValueOf(bits.LeadingZeros16),
"LeadingZeros32": reflect.ValueOf(bits.LeadingZeros32),
"LeadingZeros64": reflect.ValueOf(bits.LeadingZeros64),
"LeadingZeros8": reflect.ValueOf(bits.LeadingZeros8),
"Len": reflect.ValueOf(bits.Len),
"Len16": reflect.ValueOf(bits.Len16),
"Len32": reflect.ValueOf(bits.Len32),
"Len64": reflect.ValueOf(bits.Len64),
"Len8": reflect.ValueOf(bits.Len8),
"OnesCount": reflect.ValueOf(bits.OnesCount),
"OnesCount16": reflect.ValueOf(bits.OnesCount16),
"OnesCount32": reflect.ValueOf(bits.OnesCount32),
"OnesCount64": reflect.ValueOf(bits.OnesCount64),
"OnesCount8": reflect.ValueOf(bits.OnesCount8),
"Reverse": reflect.ValueOf(bits.Reverse),
"Reverse16": reflect.ValueOf(bits.Reverse16),
"Reverse32": reflect.ValueOf(bits.Reverse32),
"Reverse64": reflect.ValueOf(bits.Reverse64),
"Reverse8": reflect.ValueOf(bits.Reverse8),
"ReverseBytes": reflect.ValueOf(bits.ReverseBytes),
"ReverseBytes16": reflect.ValueOf(bits.ReverseBytes16),
"ReverseBytes32": reflect.ValueOf(bits.ReverseBytes32),
"ReverseBytes64": reflect.ValueOf(bits.ReverseBytes64),
"RotateLeft": reflect.ValueOf(bits.RotateLeft),
"RotateLeft16": reflect.ValueOf(bits.RotateLeft16),
"RotateLeft32": reflect.ValueOf(bits.RotateLeft32),
"RotateLeft64": reflect.ValueOf(bits.RotateLeft64),
"RotateLeft8": reflect.ValueOf(bits.RotateLeft8),
"TrailingZeros": reflect.ValueOf(bits.TrailingZeros),
"TrailingZeros16": reflect.ValueOf(bits.TrailingZeros16),
"TrailingZeros32": reflect.ValueOf(bits.TrailingZeros32),
"TrailingZeros64": reflect.ValueOf(bits.TrailingZeros64),
"TrailingZeros8": reflect.ValueOf(bits.TrailingZeros8),
"UintSize": reflect.ValueOf(bits.UintSize),
}
}

43
stdlib/go1_11_math_cmplx.go
View File

@@ -1,43 +0,0 @@
// Code generated by 'goexports math/cmplx'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"math/cmplx"
"reflect"
)
func init() {
Symbols["math/cmplx"] = map[string]reflect.Value{
// function, constant and variable definitions
"Abs": reflect.ValueOf(cmplx.Abs),
"Acos": reflect.ValueOf(cmplx.Acos),
"Acosh": reflect.ValueOf(cmplx.Acosh),
"Asin": reflect.ValueOf(cmplx.Asin),
"Asinh": reflect.ValueOf(cmplx.Asinh),
"Atan": reflect.ValueOf(cmplx.Atan),
"Atanh": reflect.ValueOf(cmplx.Atanh),
"Conj": reflect.ValueOf(cmplx.Conj),
"Cos": reflect.ValueOf(cmplx.Cos),
"Cosh": reflect.ValueOf(cmplx.Cosh),
"Cot": reflect.ValueOf(cmplx.Cot),
"Exp": reflect.ValueOf(cmplx.Exp),
"Inf": reflect.ValueOf(cmplx.Inf),
"IsInf": reflect.ValueOf(cmplx.IsInf),
"IsNaN": reflect.ValueOf(cmplx.IsNaN),
"Log": reflect.ValueOf(cmplx.Log),
"Log10": reflect.ValueOf(cmplx.Log10),
"NaN": reflect.ValueOf(cmplx.NaN),
"Phase": reflect.ValueOf(cmplx.Phase),
"Polar": reflect.ValueOf(cmplx.Polar),
"Pow": reflect.ValueOf(cmplx.Pow),
"Rect": reflect.ValueOf(cmplx.Rect),
"Sin": reflect.ValueOf(cmplx.Sin),
"Sinh": reflect.ValueOf(cmplx.Sinh),
"Sqrt": reflect.ValueOf(cmplx.Sqrt),
"Tan": reflect.ValueOf(cmplx.Tan),
"Tanh": reflect.ValueOf(cmplx.Tanh),
}
}

65
stdlib/go1_11_math_rand.go
View File

@@ -1,65 +0,0 @@
// Code generated by 'goexports math/rand'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"math/rand"
"reflect"
)
func init() {
Symbols["math/rand"] = map[string]reflect.Value{
// function, constant and variable definitions
"ExpFloat64": reflect.ValueOf(rand.ExpFloat64),
"Float32": reflect.ValueOf(rand.Float32),
"Float64": reflect.ValueOf(rand.Float64),
"Int": reflect.ValueOf(rand.Int),
"Int31": reflect.ValueOf(rand.Int31),
"Int31n": reflect.ValueOf(rand.Int31n),
"Int63": reflect.ValueOf(rand.Int63),
"Int63n": reflect.ValueOf(rand.Int63n),
"Intn": reflect.ValueOf(rand.Intn),
"New": reflect.ValueOf(rand.New),
"NewSource": reflect.ValueOf(rand.NewSource),
"NewZipf": reflect.ValueOf(rand.NewZipf),
"NormFloat64": reflect.ValueOf(rand.NormFloat64),
"Perm": reflect.ValueOf(rand.Perm),
"Read": reflect.ValueOf(rand.Read),
"Seed": reflect.ValueOf(rand.Seed),
"Shuffle": reflect.ValueOf(rand.Shuffle),
"Uint32": reflect.ValueOf(rand.Uint32),
"Uint64": reflect.ValueOf(rand.Uint64),
// type definitions
"Rand": reflect.ValueOf((*rand.Rand)(nil)),
"Source": reflect.ValueOf((*rand.Source)(nil)),
"Source64": reflect.ValueOf((*rand.Source64)(nil)),
"Zipf": reflect.ValueOf((*rand.Zipf)(nil)),
// interface wrapper definitions
"_Source": reflect.ValueOf((*_math_rand_Source)(nil)),
"_Source64": reflect.ValueOf((*_math_rand_Source64)(nil)),
}
}
// _math_rand_Source is an interface wrapper for Source type
type _math_rand_Source struct {
WInt63 func() int64
WSeed func(seed int64)
}
func (W _math_rand_Source) Int63() int64 { return W.WInt63() }
func (W _math_rand_Source) Seed(seed int64) { W.WSeed(seed) }
// _math_rand_Source64 is an interface wrapper for Source64 type
type _math_rand_Source64 struct {
WInt63 func() int64
WSeed func(seed int64)
WUint64 func() uint64
}
func (W _math_rand_Source64) Int63() int64 { return W.WInt63() }
func (W _math_rand_Source64) Seed(seed int64) { W.WSeed(seed) }
func (W _math_rand_Source64) Uint64() uint64 { return W.WUint64() }

28
stdlib/go1_11_mime.go
View File

@@ -1,28 +0,0 @@
// Code generated by 'goexports mime'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"mime"
"reflect"
)
func init() {
Symbols["mime"] = map[string]reflect.Value{
// function, constant and variable definitions
"AddExtensionType": reflect.ValueOf(mime.AddExtensionType),
"BEncoding": reflect.ValueOf(mime.BEncoding),
"ErrInvalidMediaParameter": reflect.ValueOf(&mime.ErrInvalidMediaParameter).Elem(),
"ExtensionsByType": reflect.ValueOf(mime.ExtensionsByType),
"FormatMediaType": reflect.ValueOf(mime.FormatMediaType),
"ParseMediaType": reflect.ValueOf(mime.ParseMediaType),
"QEncoding": reflect.ValueOf(mime.QEncoding),
"TypeByExtension": reflect.ValueOf(mime.TypeByExtension),
// type definitions
"WordDecoder": reflect.ValueOf((*mime.WordDecoder)(nil)),
"WordEncoder": reflect.ValueOf((*mime.WordEncoder)(nil)),
}
}

45
stdlib/go1_11_mime_multipart.go
View File

@@ -1,45 +0,0 @@
// Code generated by 'goexports mime/multipart'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"mime/multipart"
"reflect"
)
func init() {
Symbols["mime/multipart"] = map[string]reflect.Value{
// function, constant and variable definitions
"ErrMessageTooLarge": reflect.ValueOf(&multipart.ErrMessageTooLarge).Elem(),
"NewReader": reflect.ValueOf(multipart.NewReader),
"NewWriter": reflect.ValueOf(multipart.NewWriter),
// type definitions
"File": reflect.ValueOf((*multipart.File)(nil)),
"FileHeader": reflect.ValueOf((*multipart.FileHeader)(nil)),
"Form": reflect.ValueOf((*multipart.Form)(nil)),
"Part": reflect.ValueOf((*multipart.Part)(nil)),
"Reader": reflect.ValueOf((*multipart.Reader)(nil)),
"Writer": reflect.ValueOf((*multipart.Writer)(nil)),
// interface wrapper definitions
"_File": reflect.ValueOf((*_mime_multipart_File)(nil)),
}
}
// _mime_multipart_File is an interface wrapper for File type
type _mime_multipart_File struct {
WClose func() error
WRead func(p []byte) (n int, err error)
WReadAt func(p []byte, off int64) (n int, err error)
WSeek func(offset int64, whence int) (int64, error)
}
func (W _mime_multipart_File) Close() error { return W.WClose() }
func (W _mime_multipart_File) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _mime_multipart_File) ReadAt(p []byte, off int64) (n int, err error) { return W.WReadAt(p, off) }
func (W _mime_multipart_File) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}

22
stdlib/go1_11_mime_quotedprintable.go
View File

@@ -1,22 +0,0 @@
// Code generated by 'goexports mime/quotedprintable'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"mime/quotedprintable"
"reflect"
)
func init() {
Symbols["mime/quotedprintable"] = map[string]reflect.Value{
// function, constant and variable definitions
"NewReader": reflect.ValueOf(quotedprintable.NewReader),
"NewWriter": reflect.ValueOf(quotedprintable.NewWriter),
// type definitions
"Reader": reflect.ValueOf((*quotedprintable.Reader)(nil)),
"Writer": reflect.ValueOf((*quotedprintable.Writer)(nil)),
}
}

196
stdlib/go1_11_net.go
View File

@@ -1,196 +0,0 @@
// Code generated by 'goexports net'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"net"
"reflect"
"time"
)
func init() {
Symbols["net"] = map[string]reflect.Value{
// function, constant and variable definitions
"CIDRMask": reflect.ValueOf(net.CIDRMask),
"DefaultResolver": reflect.ValueOf(&net.DefaultResolver).Elem(),
"Dial": reflect.ValueOf(net.Dial),
"DialIP": reflect.ValueOf(net.DialIP),
"DialTCP": reflect.ValueOf(net.DialTCP),
"DialTimeout": reflect.ValueOf(net.DialTimeout),
"DialUDP": reflect.ValueOf(net.DialUDP),
"DialUnix": reflect.ValueOf(net.DialUnix),
"ErrWriteToConnected": reflect.ValueOf(&net.ErrWriteToConnected).Elem(),
"FileConn": reflect.ValueOf(net.FileConn),
"FileListener": reflect.ValueOf(net.FileListener),
"FilePacketConn": reflect.ValueOf(net.FilePacketConn),
"FlagBroadcast": reflect.ValueOf(net.FlagBroadcast),
"FlagLoopback": reflect.ValueOf(net.FlagLoopback),
"FlagMulticast": reflect.ValueOf(net.FlagMulticast),
"FlagPointToPoint": reflect.ValueOf(net.FlagPointToPoint),
"FlagUp": reflect.ValueOf(net.FlagUp),
"IPv4": reflect.ValueOf(net.IPv4),
"IPv4Mask": reflect.ValueOf(net.IPv4Mask),
"IPv4allrouter": reflect.ValueOf(&net.IPv4allrouter).Elem(),
"IPv4allsys": reflect.ValueOf(&net.IPv4allsys).Elem(),
"IPv4bcast": reflect.ValueOf(&net.IPv4bcast).Elem(),
"IPv4len": reflect.ValueOf(net.IPv4len),
"IPv4zero": reflect.ValueOf(&net.IPv4zero).Elem(),
"IPv6interfacelocalallnodes": reflect.ValueOf(&net.IPv6interfacelocalallnodes).Elem(),
"IPv6len": reflect.ValueOf(net.IPv6len),
"IPv6linklocalallnodes": reflect.ValueOf(&net.IPv6linklocalallnodes).Elem(),
"IPv6linklocalallrouters": reflect.ValueOf(&net.IPv6linklocalallrouters).Elem(),
"IPv6loopback": reflect.ValueOf(&net.IPv6loopback).Elem(),
"IPv6unspecified": reflect.ValueOf(&net.IPv6unspecified).Elem(),
"IPv6zero": reflect.ValueOf(&net.IPv6zero).Elem(),
"InterfaceAddrs": reflect.ValueOf(net.InterfaceAddrs),
"InterfaceByIndex": reflect.ValueOf(net.InterfaceByIndex),
"InterfaceByName": reflect.ValueOf(net.InterfaceByName),
"Interfaces": reflect.ValueOf(net.Interfaces),
"JoinHostPort": reflect.ValueOf(net.JoinHostPort),
"Listen": reflect.ValueOf(net.Listen),
"ListenIP": reflect.ValueOf(net.ListenIP),
"ListenMulticastUDP": reflect.ValueOf(net.ListenMulticastUDP),
"ListenPacket": reflect.ValueOf(net.ListenPacket),
"ListenTCP": reflect.ValueOf(net.ListenTCP),
"ListenUDP": reflect.ValueOf(net.ListenUDP),
"ListenUnix": reflect.ValueOf(net.ListenUnix),
"ListenUnixgram": reflect.ValueOf(net.ListenUnixgram),
"LookupAddr": reflect.ValueOf(net.LookupAddr),
"LookupCNAME": reflect.ValueOf(net.LookupCNAME),
"LookupHost": reflect.ValueOf(net.LookupHost),
"LookupIP": reflect.ValueOf(net.LookupIP),
"LookupMX": reflect.ValueOf(net.LookupMX),
"LookupNS": reflect.ValueOf(net.LookupNS),
"LookupPort": reflect.ValueOf(net.LookupPort),
"LookupSRV": reflect.ValueOf(net.LookupSRV),
"LookupTXT": reflect.ValueOf(net.LookupTXT),
"ParseCIDR": reflect.ValueOf(net.ParseCIDR),
"ParseIP": reflect.ValueOf(net.ParseIP),
"ParseMAC": reflect.ValueOf(net.ParseMAC),
"Pipe": reflect.ValueOf(net.Pipe),
"ResolveIPAddr": reflect.ValueOf(net.ResolveIPAddr),
"ResolveTCPAddr": reflect.ValueOf(net.ResolveTCPAddr),
"ResolveUDPAddr": reflect.ValueOf(net.ResolveUDPAddr),
"ResolveUnixAddr": reflect.ValueOf(net.ResolveUnixAddr),
"SplitHostPort": reflect.ValueOf(net.SplitHostPort),
// type definitions
"Addr": reflect.ValueOf((*net.Addr)(nil)),
"AddrError": reflect.ValueOf((*net.AddrError)(nil)),
"Buffers": reflect.ValueOf((*net.Buffers)(nil)),
"Conn": reflect.ValueOf((*net.Conn)(nil)),
"DNSConfigError": reflect.ValueOf((*net.DNSConfigError)(nil)),
"DNSError": reflect.ValueOf((*net.DNSError)(nil)),
"Dialer": reflect.ValueOf((*net.Dialer)(nil)),
"Error": reflect.ValueOf((*net.Error)(nil)),
"Flags": reflect.ValueOf((*net.Flags)(nil)),
"HardwareAddr": reflect.ValueOf((*net.HardwareAddr)(nil)),
"IP": reflect.ValueOf((*net.IP)(nil)),
"IPAddr": reflect.ValueOf((*net.IPAddr)(nil)),
"IPConn": reflect.ValueOf((*net.IPConn)(nil)),
"IPMask": reflect.ValueOf((*net.IPMask)(nil)),
"IPNet": reflect.ValueOf((*net.IPNet)(nil)),
"Interface": reflect.ValueOf((*net.Interface)(nil)),
"InvalidAddrError": reflect.ValueOf((*net.InvalidAddrError)(nil)),
"ListenConfig": reflect.ValueOf((*net.ListenConfig)(nil)),
"Listener": reflect.ValueOf((*net.Listener)(nil)),
"MX": reflect.ValueOf((*net.MX)(nil)),
"NS": reflect.ValueOf((*net.NS)(nil)),
"OpError": reflect.ValueOf((*net.OpError)(nil)),
"PacketConn": reflect.ValueOf((*net.PacketConn)(nil)),
"ParseError": reflect.ValueOf((*net.ParseError)(nil)),
"Resolver": reflect.ValueOf((*net.Resolver)(nil)),
"SRV": reflect.ValueOf((*net.SRV)(nil)),
"TCPAddr": reflect.ValueOf((*net.TCPAddr)(nil)),
"TCPConn": reflect.ValueOf((*net.TCPConn)(nil)),
"TCPListener": reflect.ValueOf((*net.TCPListener)(nil)),
"UDPAddr": reflect.ValueOf((*net.UDPAddr)(nil)),
"UDPConn": reflect.ValueOf((*net.UDPConn)(nil)),
"UnixAddr": reflect.ValueOf((*net.UnixAddr)(nil)),
"UnixConn": reflect.ValueOf((*net.UnixConn)(nil)),
"UnixListener": reflect.ValueOf((*net.UnixListener)(nil)),
"UnknownNetworkError": reflect.ValueOf((*net.UnknownNetworkError)(nil)),
// interface wrapper definitions
"_Addr": reflect.ValueOf((*_net_Addr)(nil)),
"_Conn": reflect.ValueOf((*_net_Conn)(nil)),
"_Error": reflect.ValueOf((*_net_Error)(nil)),
"_Listener": reflect.ValueOf((*_net_Listener)(nil)),
"_PacketConn": reflect.ValueOf((*_net_PacketConn)(nil)),
}
}
// _net_Addr is an interface wrapper for Addr type
type _net_Addr struct {
WNetwork func() string
WString func() string
}
func (W _net_Addr) Network() string { return W.WNetwork() }
func (W _net_Addr) String() string { return W.WString() }
// _net_Conn is an interface wrapper for Conn type
type _net_Conn struct {
WClose func() error
WLocalAddr func() net.Addr
WRead func(b []byte) (n int, err error)
WRemoteAddr func() net.Addr
WSetDeadline func(t time.Time) error
WSetReadDeadline func(t time.Time) error
WSetWriteDeadline func(t time.Time) error
WWrite func(b []byte) (n int, err error)
}
func (W _net_Conn) Close() error { return W.WClose() }
func (W _net_Conn) LocalAddr() net.Addr { return W.WLocalAddr() }
func (W _net_Conn) Read(b []byte) (n int, err error) { return W.WRead(b) }
func (W _net_Conn) RemoteAddr() net.Addr { return W.WRemoteAddr() }
func (W _net_Conn) SetDeadline(t time.Time) error { return W.WSetDeadline(t) }
func (W _net_Conn) SetReadDeadline(t time.Time) error { return W.WSetReadDeadline(t) }
func (W _net_Conn) SetWriteDeadline(t time.Time) error { return W.WSetWriteDeadline(t) }
func (W _net_Conn) Write(b []byte) (n int, err error) { return W.WWrite(b) }
// _net_Error is an interface wrapper for Error type
type _net_Error struct {
WError func() string
WTemporary func() bool
WTimeout func() bool
}
func (W _net_Error) Error() string { return W.WError() }
func (W _net_Error) Temporary() bool { return W.WTemporary() }
func (W _net_Error) Timeout() bool { return W.WTimeout() }
// _net_Listener is an interface wrapper for Listener type
type _net_Listener struct {
WAccept func() (net.Conn, error)
WAddr func() net.Addr
WClose func() error
}
func (W _net_Listener) Accept() (net.Conn, error) { return W.WAccept() }
func (W _net_Listener) Addr() net.Addr { return W.WAddr() }
func (W _net_Listener) Close() error { return W.WClose() }
// _net_PacketConn is an interface wrapper for PacketConn type
type _net_PacketConn struct {
WClose func() error
WLocalAddr func() net.Addr
WReadFrom func(p []byte) (n int, addr net.Addr, err error)
WSetDeadline func(t time.Time) error
WSetReadDeadline func(t time.Time) error
WSetWriteDeadline func(t time.Time) error
WWriteTo func(p []byte, addr net.Addr) (n int, err error)
}
func (W _net_PacketConn) Close() error { return W.WClose() }
func (W _net_PacketConn) LocalAddr() net.Addr { return W.WLocalAddr() }
func (W _net_PacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) { return W.WReadFrom(p) }
func (W _net_PacketConn) SetDeadline(t time.Time) error { return W.WSetDeadline(t) }
func (W _net_PacketConn) SetReadDeadline(t time.Time) error { return W.WSetReadDeadline(t) }
func (W _net_PacketConn) SetWriteDeadline(t time.Time) error { return W.WSetWriteDeadline(t) }
func (W _net_PacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) {
return W.WWriteTo(p, addr)
}

290
stdlib/go1_11_net_http.go
View File

@@ -1,290 +0,0 @@
// Code generated by 'goexports net/http'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"bufio"
"net"
"net/http"
"net/url"
"os"
"reflect"
)
func init() {
Symbols["net/http"] = map[string]reflect.Value{
// function, constant and variable definitions
"CanonicalHeaderKey": reflect.ValueOf(http.CanonicalHeaderKey),
"DefaultClient": reflect.ValueOf(&http.DefaultClient).Elem(),
"DefaultMaxHeaderBytes": reflect.ValueOf(http.DefaultMaxHeaderBytes),
"DefaultMaxIdleConnsPerHost": reflect.ValueOf(http.DefaultMaxIdleConnsPerHost),
"DefaultServeMux": reflect.ValueOf(&http.DefaultServeMux).Elem(),
"DefaultTransport": reflect.ValueOf(&http.DefaultTransport).Elem(),
"DetectContentType": reflect.ValueOf(http.DetectContentType),
"ErrAbortHandler": reflect.ValueOf(&http.ErrAbortHandler).Elem(),
"ErrBodyNotAllowed": reflect.ValueOf(&http.ErrBodyNotAllowed).Elem(),
"ErrBodyReadAfterClose": reflect.ValueOf(&http.ErrBodyReadAfterClose).Elem(),
"ErrContentLength": reflect.ValueOf(&http.ErrContentLength).Elem(),
"ErrHandlerTimeout": reflect.ValueOf(&http.ErrHandlerTimeout).Elem(),
"ErrHeaderTooLong": reflect.ValueOf(&http.ErrHeaderTooLong).Elem(),
"ErrHijacked": reflect.ValueOf(&http.ErrHijacked).Elem(),
"ErrLineTooLong": reflect.ValueOf(&http.ErrLineTooLong).Elem(),
"ErrMissingBoundary": reflect.ValueOf(&http.ErrMissingBoundary).Elem(),
"ErrMissingContentLength": reflect.ValueOf(&http.ErrMissingContentLength).Elem(),
"ErrMissingFile": reflect.ValueOf(&http.ErrMissingFile).Elem(),
"ErrNoCookie": reflect.ValueOf(&http.ErrNoCookie).Elem(),
"ErrNoLocation": reflect.ValueOf(&http.ErrNoLocation).Elem(),
"ErrNotMultipart": reflect.ValueOf(&http.ErrNotMultipart).Elem(),
"ErrNotSupported": reflect.ValueOf(&http.ErrNotSupported).Elem(),
"ErrServerClosed": reflect.ValueOf(&http.ErrServerClosed).Elem(),
"ErrShortBody": reflect.ValueOf(&http.ErrShortBody).Elem(),
"ErrSkipAltProtocol": reflect.ValueOf(&http.ErrSkipAltProtocol).Elem(),
"ErrUnexpectedTrailer": reflect.ValueOf(&http.ErrUnexpectedTrailer).Elem(),
"ErrUseLastResponse": reflect.ValueOf(&http.ErrUseLastResponse).Elem(),
"ErrWriteAfterFlush": reflect.ValueOf(&http.ErrWriteAfterFlush).Elem(),
"Error": reflect.ValueOf(http.Error),
"FileServer": reflect.ValueOf(http.FileServer),
"Get": reflect.ValueOf(http.Get),
"Handle": reflect.ValueOf(http.Handle),
"HandleFunc": reflect.ValueOf(http.HandleFunc),
"Head": reflect.ValueOf(http.Head),
"ListenAndServe": reflect.ValueOf(http.ListenAndServe),
"ListenAndServeTLS": reflect.ValueOf(http.ListenAndServeTLS),
"LocalAddrContextKey": reflect.ValueOf(&http.LocalAddrContextKey).Elem(),
"MaxBytesReader": reflect.ValueOf(http.MaxBytesReader),
"MethodConnect": reflect.ValueOf(http.MethodConnect),
"MethodDelete": reflect.ValueOf(http.MethodDelete),
"MethodGet": reflect.ValueOf(http.MethodGet),
"MethodHead": reflect.ValueOf(http.MethodHead),
"MethodOptions": reflect.ValueOf(http.MethodOptions),
"MethodPatch": reflect.ValueOf(http.MethodPatch),
"MethodPost": reflect.ValueOf(http.MethodPost),
"MethodPut": reflect.ValueOf(http.MethodPut),
"MethodTrace": reflect.ValueOf(http.MethodTrace),
"NewFileTransport": reflect.ValueOf(http.NewFileTransport),
"NewRequest": reflect.ValueOf(http.NewRequest),
"NewServeMux": reflect.ValueOf(http.NewServeMux),
"NoBody": reflect.ValueOf(&http.NoBody).Elem(),
"NotFound": reflect.ValueOf(http.NotFound),
"NotFoundHandler": reflect.ValueOf(http.NotFoundHandler),
"ParseHTTPVersion": reflect.ValueOf(http.ParseHTTPVersion),
"ParseTime": reflect.ValueOf(http.ParseTime),
"Post": reflect.ValueOf(http.Post),
"PostForm": reflect.ValueOf(http.PostForm),
"ProxyFromEnvironment": reflect.ValueOf(http.ProxyFromEnvironment),
"ProxyURL": reflect.ValueOf(http.ProxyURL),
"ReadRequest": reflect.ValueOf(http.ReadRequest),
"ReadResponse": reflect.ValueOf(http.ReadResponse),
"Redirect": reflect.ValueOf(http.Redirect),
"RedirectHandler": reflect.ValueOf(http.RedirectHandler),
"SameSiteDefaultMode": reflect.ValueOf(http.SameSiteDefaultMode),
"SameSiteLaxMode": reflect.ValueOf(http.SameSiteLaxMode),
"SameSiteStrictMode": reflect.ValueOf(http.SameSiteStrictMode),
"Serve": reflect.ValueOf(http.Serve),
"ServeContent": reflect.ValueOf(http.ServeContent),
"ServeFile": reflect.ValueOf(http.ServeFile),
"ServeTLS": reflect.ValueOf(http.ServeTLS),
"ServerContextKey": reflect.ValueOf(&http.ServerContextKey).Elem(),
"SetCookie": reflect.ValueOf(http.SetCookie),
"StateActive": reflect.ValueOf(http.StateActive),
"StateClosed": reflect.ValueOf(http.StateClosed),
"StateHijacked": reflect.ValueOf(http.StateHijacked),
"StateIdle": reflect.ValueOf(http.StateIdle),
"StateNew": reflect.ValueOf(http.StateNew),
"StatusAccepted": reflect.ValueOf(http.StatusAccepted),
"StatusAlreadyReported": reflect.ValueOf(http.StatusAlreadyReported),
"StatusBadGateway": reflect.ValueOf(http.StatusBadGateway),
"StatusBadRequest": reflect.ValueOf(http.StatusBadRequest),
"StatusConflict": reflect.ValueOf(http.StatusConflict),
"StatusContinue": reflect.ValueOf(http.StatusContinue),
"StatusCreated": reflect.ValueOf(http.StatusCreated),
"StatusExpectationFailed": reflect.ValueOf(http.StatusExpectationFailed),
"StatusFailedDependency": reflect.ValueOf(http.StatusFailedDependency),
"StatusForbidden": reflect.ValueOf(http.StatusForbidden),
"StatusFound": reflect.ValueOf(http.StatusFound),
"StatusGatewayTimeout": reflect.ValueOf(http.StatusGatewayTimeout),
"StatusGone": reflect.ValueOf(http.StatusGone),
"StatusHTTPVersionNotSupported": reflect.ValueOf(http.StatusHTTPVersionNotSupported),
"StatusIMUsed": reflect.ValueOf(http.StatusIMUsed),
"StatusInsufficientStorage": reflect.ValueOf(http.StatusInsufficientStorage),
"StatusInternalServerError": reflect.ValueOf(http.StatusInternalServerError),
"StatusLengthRequired": reflect.ValueOf(http.StatusLengthRequired),
"StatusLocked": reflect.ValueOf(http.StatusLocked),
"StatusLoopDetected": reflect.ValueOf(http.StatusLoopDetected),
"StatusMethodNotAllowed": reflect.ValueOf(http.StatusMethodNotAllowed),
"StatusMisdirectedRequest": reflect.ValueOf(http.StatusMisdirectedRequest),
"StatusMovedPermanently": reflect.ValueOf(http.StatusMovedPermanently),
"StatusMultiStatus": reflect.ValueOf(http.StatusMultiStatus),
"StatusMultipleChoices": reflect.ValueOf(http.StatusMultipleChoices),
"StatusNetworkAuthenticationRequired": reflect.ValueOf(http.StatusNetworkAuthenticationRequired),
"StatusNoContent": reflect.ValueOf(http.StatusNoContent),
"StatusNonAuthoritativeInfo": reflect.ValueOf(http.StatusNonAuthoritativeInfo),
"StatusNotAcceptable": reflect.ValueOf(http.StatusNotAcceptable),
"StatusNotExtended": reflect.ValueOf(http.StatusNotExtended),
"StatusNotFound": reflect.ValueOf(http.StatusNotFound),
"StatusNotImplemented": reflect.ValueOf(http.StatusNotImplemented),
"StatusNotModified": reflect.ValueOf(http.StatusNotModified),
"StatusOK": reflect.ValueOf(http.StatusOK),
"StatusPartialContent": reflect.ValueOf(http.StatusPartialContent),
"StatusPaymentRequired": reflect.ValueOf(http.StatusPaymentRequired),
"StatusPermanentRedirect": reflect.ValueOf(http.StatusPermanentRedirect),
"StatusPreconditionFailed": reflect.ValueOf(http.StatusPreconditionFailed),
"StatusPreconditionRequired": reflect.ValueOf(http.StatusPreconditionRequired),
"StatusProcessing": reflect.ValueOf(http.StatusProcessing),
"StatusProxyAuthRequired": reflect.ValueOf(http.StatusProxyAuthRequired),
"StatusRequestEntityTooLarge": reflect.ValueOf(http.StatusRequestEntityTooLarge),
"StatusRequestHeaderFieldsTooLarge": reflect.ValueOf(http.StatusRequestHeaderFieldsTooLarge),
"StatusRequestTimeout": reflect.ValueOf(http.StatusRequestTimeout),
"StatusRequestURITooLong": reflect.ValueOf(http.StatusRequestURITooLong),
"StatusRequestedRangeNotSatisfiable": reflect.ValueOf(http.StatusRequestedRangeNotSatisfiable),
"StatusResetContent": reflect.ValueOf(http.StatusResetContent),
"StatusSeeOther": reflect.ValueOf(http.StatusSeeOther),
"StatusServiceUnavailable": reflect.ValueOf(http.StatusServiceUnavailable),
"StatusSwitchingProtocols": reflect.ValueOf(http.StatusSwitchingProtocols),
"StatusTeapot": reflect.ValueOf(http.StatusTeapot),
"StatusTemporaryRedirect": reflect.ValueOf(http.StatusTemporaryRedirect),
"StatusText": reflect.ValueOf(http.StatusText),
"StatusTooManyRequests": reflect.ValueOf(http.StatusTooManyRequests),
"StatusUnauthorized": reflect.ValueOf(http.StatusUnauthorized),
"StatusUnavailableForLegalReasons": reflect.ValueOf(http.StatusUnavailableForLegalReasons),
"StatusUnprocessableEntity": reflect.ValueOf(http.StatusUnprocessableEntity),
"StatusUnsupportedMediaType": reflect.ValueOf(http.StatusUnsupportedMediaType),
"StatusUpgradeRequired": reflect.ValueOf(http.StatusUpgradeRequired),
"StatusUseProxy": reflect.ValueOf(http.StatusUseProxy),
"StatusVariantAlsoNegotiates": reflect.ValueOf(http.StatusVariantAlsoNegotiates),
"StripPrefix": reflect.ValueOf(http.StripPrefix),
"TimeFormat": reflect.ValueOf(http.TimeFormat),
"TimeoutHandler": reflect.ValueOf(http.TimeoutHandler),
"TrailerPrefix": reflect.ValueOf(http.TrailerPrefix),
// type definitions
"Client": reflect.ValueOf((*http.Client)(nil)),
"CloseNotifier": reflect.ValueOf((*http.CloseNotifier)(nil)),
"ConnState": reflect.ValueOf((*http.ConnState)(nil)),
"Cookie": reflect.ValueOf((*http.Cookie)(nil)),
"CookieJar": reflect.ValueOf((*http.CookieJar)(nil)),
"Dir": reflect.ValueOf((*http.Dir)(nil)),
"File": reflect.ValueOf((*http.File)(nil)),
"FileSystem": reflect.ValueOf((*http.FileSystem)(nil)),
"Flusher": reflect.ValueOf((*http.Flusher)(nil)),
"Handler": reflect.ValueOf((*http.Handler)(nil)),
"HandlerFunc": reflect.ValueOf((*http.HandlerFunc)(nil)),
"Header": reflect.ValueOf((*http.Header)(nil)),
"Hijacker": reflect.ValueOf((*http.Hijacker)(nil)),
"ProtocolError": reflect.ValueOf((*http.ProtocolError)(nil)),
"PushOptions": reflect.ValueOf((*http.PushOptions)(nil)),
"Pusher": reflect.ValueOf((*http.Pusher)(nil)),
"Request": reflect.ValueOf((*http.Request)(nil)),
"Response": reflect.ValueOf((*http.Response)(nil)),
"ResponseWriter": reflect.ValueOf((*http.ResponseWriter)(nil)),
"RoundTripper": reflect.ValueOf((*http.RoundTripper)(nil)),
"SameSite": reflect.ValueOf((*http.SameSite)(nil)),
"ServeMux": reflect.ValueOf((*http.ServeMux)(nil)),
"Server": reflect.ValueOf((*http.Server)(nil)),
"Transport": reflect.ValueOf((*http.Transport)(nil)),
// interface wrapper definitions
"_CloseNotifier": reflect.ValueOf((*_net_http_CloseNotifier)(nil)),
"_CookieJar": reflect.ValueOf((*_net_http_CookieJar)(nil)),
"_File": reflect.ValueOf((*_net_http_File)(nil)),
"_FileSystem": reflect.ValueOf((*_net_http_FileSystem)(nil)),
"_Flusher": reflect.ValueOf((*_net_http_Flusher)(nil)),
"_Handler": reflect.ValueOf((*_net_http_Handler)(nil)),
"_Hijacker": reflect.ValueOf((*_net_http_Hijacker)(nil)),
"_Pusher": reflect.ValueOf((*_net_http_Pusher)(nil)),
"_ResponseWriter": reflect.ValueOf((*_net_http_ResponseWriter)(nil)),
"_RoundTripper": reflect.ValueOf((*_net_http_RoundTripper)(nil)),
}
}
// _net_http_CloseNotifier is an interface wrapper for CloseNotifier type
type _net_http_CloseNotifier struct {
WCloseNotify func() <-chan bool
}
func (W _net_http_CloseNotifier) CloseNotify() <-chan bool { return W.WCloseNotify() }
// _net_http_CookieJar is an interface wrapper for CookieJar type
type _net_http_CookieJar struct {
WCookies func(u *url.URL) []*http.Cookie
WSetCookies func(u *url.URL, cookies []*http.Cookie)
}
func (W _net_http_CookieJar) Cookies(u *url.URL) []*http.Cookie { return W.WCookies(u) }
func (W _net_http_CookieJar) SetCookies(u *url.URL, cookies []*http.Cookie) { W.WSetCookies(u, cookies) }
// _net_http_File is an interface wrapper for File type
type _net_http_File struct {
WClose func() error
WRead func(p []byte) (n int, err error)
WReaddir func(count int) ([]os.FileInfo, error)
WSeek func(offset int64, whence int) (int64, error)
WStat func() (os.FileInfo, error)
}
func (W _net_http_File) Close() error { return W.WClose() }
func (W _net_http_File) Read(p []byte) (n int, err error) { return W.WRead(p) }
func (W _net_http_File) Readdir(count int) ([]os.FileInfo, error) { return W.WReaddir(count) }
func (W _net_http_File) Seek(offset int64, whence int) (int64, error) {
return W.WSeek(offset, whence)
}
func (W _net_http_File) Stat() (os.FileInfo, error) { return W.WStat() }
// _net_http_FileSystem is an interface wrapper for FileSystem type
type _net_http_FileSystem struct {
WOpen func(name string) (http.File, error)
}
func (W _net_http_FileSystem) Open(name string) (http.File, error) { return W.WOpen(name) }
// _net_http_Flusher is an interface wrapper for Flusher type
type _net_http_Flusher struct {
WFlush func()
}
func (W _net_http_Flusher) Flush() { W.WFlush() }
// _net_http_Handler is an interface wrapper for Handler type
type _net_http_Handler struct {
WServeHTTP func(a0 http.ResponseWriter, a1 *http.Request)
}
func (W _net_http_Handler) ServeHTTP(a0 http.ResponseWriter, a1 *http.Request) { W.WServeHTTP(a0, a1) }
// _net_http_Hijacker is an interface wrapper for Hijacker type
type _net_http_Hijacker struct {
WHijack func() (net.Conn, *bufio.ReadWriter, error)
}
func (W _net_http_Hijacker) Hijack() (net.Conn, *bufio.ReadWriter, error) { return W.WHijack() }
// _net_http_Pusher is an interface wrapper for Pusher type
type _net_http_Pusher struct {
WPush func(target string, opts *http.PushOptions) error
}
func (W _net_http_Pusher) Push(target string, opts *http.PushOptions) error {
return W.WPush(target, opts)
}
// _net_http_ResponseWriter is an interface wrapper for ResponseWriter type
type _net_http_ResponseWriter struct {
WHeader func() http.Header
WWrite func(a0 []byte) (int, error)
WWriteHeader func(statusCode int)
}
func (W _net_http_ResponseWriter) Header() http.Header { return W.WHeader() }
func (W _net_http_ResponseWriter) Write(a0 []byte) (int, error) { return W.WWrite(a0) }
func (W _net_http_ResponseWriter) WriteHeader(statusCode int) { W.WWriteHeader(statusCode) }
// _net_http_RoundTripper is an interface wrapper for RoundTripper type
type _net_http_RoundTripper struct {
WRoundTrip func(a0 *http.Request) (*http.Response, error)
}
func (W _net_http_RoundTripper) RoundTrip(a0 *http.Request) (*http.Response, error) {
return W.WRoundTrip(a0)
}

22
stdlib/go1_11_net_http_cgi.go
View File

@@ -1,22 +0,0 @@
// Code generated by 'goexports net/http/cgi'. DO NOT EDIT.
// +build go1.11,!go1.12
package stdlib
import (
"net/http/cgi"
"reflect"
)
func init() {
Symbols["net/http/cgi"] = map[string]reflect.Value{
// function, constant and variable definitions
"Request": reflect.ValueOf(cgi.Request),
"RequestFromMap": reflect.ValueOf(cgi.RequestFromMap),
"Serve": reflect.ValueOf(cgi.Serve),
// type definitions
"Handler": reflect.ValueOf((*cgi.Handler)(nil)),
}
}

Some files were not shown because too many files have changed in this diff Show More