forked from mirror/go-ethereum
Compare commits
11 Commits
release/1.
...
master
| Author | SHA1 | Date |
|---|---|---|
ucwong
|
687e4dc855 | 3 years ago |
Martin Holst Swende
|
0cb4d65f8d | 3 years ago |
Sina Mahmoodi
|
862f8e98bc | 3 years ago |
Felix Lange
|
d6f49bf764 | 3 years ago |
|
Felix Lange
|
06aaeed1a6 | 3 years ago |
|
Felix Lange
|
9b93564e21 | 3 years ago |
|
Martin Holst Swende
|
4335bbbf0a | 3 years ago |
Péter Szilágyi
|
fc8ad1b70d | 3 years ago |
rjl493456442
|
4d086430bd | 3 years ago |
|
Martin Holst Swende
|
2056e596f2 | 3 years ago |
|
Gary Rong
|
55430b6ea2 | 3 years ago |
@ -0,0 +1,27 @@ |
|||||||
|
// Code generated by rlpgen. DO NOT EDIT.
|
||||||
|
|
||||||
|
//go:build !norlpgen
|
||||||
|
// +build !norlpgen
|
||||||
|
|
||||||
|
package types |
||||||
|
|
||||||
|
import "github.com/ethereum/go-ethereum/rlp" |
||||||
|
import "io" |
||||||
|
|
||||||
|
func (obj *StateAccount) EncodeRLP(_w io.Writer) error { |
||||||
|
w := rlp.NewEncoderBuffer(_w) |
||||||
|
_tmp0 := w.List() |
||||||
|
w.WriteUint64(obj.Nonce) |
||||||
|
if obj.Balance == nil { |
||||||
|
w.Write(rlp.EmptyString) |
||||||
|
} else { |
||||||
|
if obj.Balance.Sign() == -1 { |
||||||
|
return rlp.ErrNegativeBigInt |
||||||
|
} |
||||||
|
w.WriteBigInt(obj.Balance) |
||||||
|
} |
||||||
|
w.WriteBytes(obj.Root[:]) |
||||||
|
w.WriteBytes(obj.CodeHash) |
||||||
|
w.ListEnd(_tmp0) |
||||||
|
return w.Flush() |
||||||
|
} |
||||||
@ -0,0 +1,56 @@ |
|||||||
|
// Code generated by rlpgen. DO NOT EDIT.
|
||||||
|
|
||||||
|
//go:build !norlpgen
|
||||||
|
// +build !norlpgen
|
||||||
|
|
||||||
|
package types |
||||||
|
|
||||||
|
import "github.com/ethereum/go-ethereum/rlp" |
||||||
|
import "io" |
||||||
|
|
||||||
|
func (obj *Header) EncodeRLP(_w io.Writer) error { |
||||||
|
w := rlp.NewEncoderBuffer(_w) |
||||||
|
_tmp0 := w.List() |
||||||
|
w.WriteBytes(obj.ParentHash[:]) |
||||||
|
w.WriteBytes(obj.UncleHash[:]) |
||||||
|
w.WriteBytes(obj.Coinbase[:]) |
||||||
|
w.WriteBytes(obj.Root[:]) |
||||||
|
w.WriteBytes(obj.TxHash[:]) |
||||||
|
w.WriteBytes(obj.ReceiptHash[:]) |
||||||
|
w.WriteBytes(obj.Bloom[:]) |
||||||
|
if obj.Difficulty == nil { |
||||||
|
w.Write(rlp.EmptyString) |
||||||
|
} else { |
||||||
|
if obj.Difficulty.Sign() == -1 { |
||||||
|
return rlp.ErrNegativeBigInt |
||||||
|
} |
||||||
|
w.WriteBigInt(obj.Difficulty) |
||||||
|
} |
||||||
|
if obj.Number == nil { |
||||||
|
w.Write(rlp.EmptyString) |
||||||
|
} else { |
||||||
|
if obj.Number.Sign() == -1 { |
||||||
|
return rlp.ErrNegativeBigInt |
||||||
|
} |
||||||
|
w.WriteBigInt(obj.Number) |
||||||
|
} |
||||||
|
w.WriteUint64(obj.GasLimit) |
||||||
|
w.WriteUint64(obj.GasUsed) |
||||||
|
w.WriteUint64(obj.Time) |
||||||
|
w.WriteBytes(obj.Extra) |
||||||
|
w.WriteBytes(obj.MixDigest[:]) |
||||||
|
w.WriteBytes(obj.Nonce[:]) |
||||||
|
_tmp1 := obj.BaseFee != nil |
||||||
|
if _tmp1 { |
||||||
|
if obj.BaseFee == nil { |
||||||
|
w.Write(rlp.EmptyString) |
||||||
|
} else { |
||||||
|
if obj.BaseFee.Sign() == -1 { |
||||||
|
return rlp.ErrNegativeBigInt |
||||||
|
} |
||||||
|
w.WriteBigInt(obj.BaseFee) |
||||||
|
} |
||||||
|
} |
||||||
|
w.ListEnd(_tmp0) |
||||||
|
return w.Flush() |
||||||
|
} |
||||||
@ -0,0 +1,23 @@ |
|||||||
|
// Code generated by rlpgen. DO NOT EDIT.
|
||||||
|
|
||||||
|
//go:build !norlpgen
|
||||||
|
// +build !norlpgen
|
||||||
|
|
||||||
|
package types |
||||||
|
|
||||||
|
import "github.com/ethereum/go-ethereum/rlp" |
||||||
|
import "io" |
||||||
|
|
||||||
|
func (obj *rlpLog) EncodeRLP(_w io.Writer) error { |
||||||
|
w := rlp.NewEncoderBuffer(_w) |
||||||
|
_tmp0 := w.List() |
||||||
|
w.WriteBytes(obj.Address[:]) |
||||||
|
_tmp1 := w.List() |
||||||
|
for _, _tmp2 := range obj.Topics { |
||||||
|
w.WriteBytes(_tmp2[:]) |
||||||
|
} |
||||||
|
w.ListEnd(_tmp1) |
||||||
|
w.WriteBytes(obj.Data) |
||||||
|
w.ListEnd(_tmp0) |
||||||
|
return w.Flush() |
||||||
|
} |
||||||
@ -0,0 +1,361 @@ |
|||||||
|
package rlp |
||||||
|
|
||||||
|
import ( |
||||||
|
"io" |
||||||
|
"math/big" |
||||||
|
"reflect" |
||||||
|
"sync" |
||||||
|
) |
||||||
|
|
||||||
|
type encBuffer struct { |
||||||
|
str []byte // string data, contains everything except list headers
|
||||||
|
lheads []listhead // all list headers
|
||||||
|
lhsize int // sum of sizes of all encoded list headers
|
||||||
|
sizebuf [9]byte // auxiliary buffer for uint encoding
|
||||||
|
} |
||||||
|
|
||||||
|
// The global encBuffer pool.
|
||||||
|
var encBufferPool = sync.Pool{ |
||||||
|
New: func() interface{} { return new(encBuffer) }, |
||||||
|
} |
||||||
|
|
||||||
|
func getEncBuffer() *encBuffer { |
||||||
|
buf := encBufferPool.Get().(*encBuffer) |
||||||
|
buf.reset() |
||||||
|
return buf |
||||||
|
} |
||||||
|
|
||||||
|
func (buf *encBuffer) reset() { |
||||||
|
buf.lhsize = 0 |
||||||
|
buf.str = buf.str[:0] |
||||||
|
buf.lheads = buf.lheads[:0] |
||||||
|
} |
||||||
|
|
||||||
|
// size returns the length of the encoded data.
|
||||||
|
func (buf *encBuffer) size() int { |
||||||
|
return len(buf.str) + buf.lhsize |
||||||
|
} |
||||||
|
|
||||||
|
// toBytes creates the encoder output.
|
||||||
|
func (w *encBuffer) toBytes() []byte { |
||||||
|
out := make([]byte, w.size()) |
||||||
|
strpos := 0 |
||||||
|
pos := 0 |
||||||
|
for _, head := range w.lheads { |
||||||
|
// write string data before header
|
||||||
|
n := copy(out[pos:], w.str[strpos:head.offset]) |
||||||
|
pos += n |
||||||
|
strpos += n |
||||||
|
// write the header
|
||||||
|
enc := head.encode(out[pos:]) |
||||||
|
pos += len(enc) |
||||||
|
} |
||||||
|
// copy string data after the last list header
|
||||||
|
copy(out[pos:], w.str[strpos:]) |
||||||
|
return out |
||||||
|
} |
||||||
|
|
||||||
|
// toWriter writes the encoder output to w.
|
||||||
|
func (buf *encBuffer) toWriter(w io.Writer) (err error) { |
||||||
|
strpos := 0 |
||||||
|
for _, head := range buf.lheads { |
||||||
|
// write string data before header
|
||||||
|
if head.offset-strpos > 0 { |
||||||
|
n, err := w.Write(buf.str[strpos:head.offset]) |
||||||
|
strpos += n |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
// write the header
|
||||||
|
enc := head.encode(buf.sizebuf[:]) |
||||||
|
if _, err = w.Write(enc); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
if strpos < len(buf.str) { |
||||||
|
// write string data after the last list header
|
||||||
|
_, err = w.Write(buf.str[strpos:]) |
||||||
|
} |
||||||
|
return err |
||||||
|
} |
||||||
|
|
||||||
|
// Write implements io.Writer and appends b directly to the output.
|
||||||
|
func (buf *encBuffer) Write(b []byte) (int, error) { |
||||||
|
buf.str = append(buf.str, b...) |
||||||
|
return len(b), nil |
||||||
|
} |
||||||
|
|
||||||
|
// writeBool writes b as the integer 0 (false) or 1 (true).
|
||||||
|
func (buf *encBuffer) writeBool(b bool) { |
||||||
|
if b { |
||||||
|
buf.str = append(buf.str, 0x01) |
||||||
|
} else { |
||||||
|
buf.str = append(buf.str, 0x80) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (buf *encBuffer) writeUint64(i uint64) { |
||||||
|
if i == 0 { |
||||||
|
buf.str = append(buf.str, 0x80) |
||||||
|
} else if i < 128 { |
||||||
|
// fits single byte
|
||||||
|
buf.str = append(buf.str, byte(i)) |
||||||
|
} else { |
||||||
|
s := putint(buf.sizebuf[1:], i) |
||||||
|
buf.sizebuf[0] = 0x80 + byte(s) |
||||||
|
buf.str = append(buf.str, buf.sizebuf[:s+1]...) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (buf *encBuffer) writeBytes(b []byte) { |
||||||
|
if len(b) == 1 && b[0] <= 0x7F { |
||||||
|
// fits single byte, no string header
|
||||||
|
buf.str = append(buf.str, b[0]) |
||||||
|
} else { |
||||||
|
buf.encodeStringHeader(len(b)) |
||||||
|
buf.str = append(buf.str, b...) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (buf *encBuffer) writeString(s string) { |
||||||
|
buf.writeBytes([]byte(s)) |
||||||
|
} |
||||||
|
|
||||||
|
// wordBytes is the number of bytes in a big.Word
|
||||||
|
const wordBytes = (32 << (uint64(^big.Word(0)) >> 63)) / 8 |
||||||
|
|
||||||
|
// writeBigInt writes i as an integer.
|
||||||
|
func (w *encBuffer) writeBigInt(i *big.Int) { |
||||||
|
bitlen := i.BitLen() |
||||||
|
if bitlen <= 64 { |
||||||
|
w.writeUint64(i.Uint64()) |
||||||
|
return |
||||||
|
} |
||||||
|
// Integer is larger than 64 bits, encode from i.Bits().
|
||||||
|
// The minimal byte length is bitlen rounded up to the next
|
||||||
|
// multiple of 8, divided by 8.
|
||||||
|
length := ((bitlen + 7) & -8) >> 3 |
||||||
|
w.encodeStringHeader(length) |
||||||
|
w.str = append(w.str, make([]byte, length)...) |
||||||
|
index := length |
||||||
|
buf := w.str[len(w.str)-length:] |
||||||
|
for _, d := range i.Bits() { |
||||||
|
for j := 0; j < wordBytes && index > 0; j++ { |
||||||
|
index-- |
||||||
|
buf[index] = byte(d) |
||||||
|
d >>= 8 |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// list adds a new list header to the header stack. It returns the index of the header.
|
||||||
|
// Call listEnd with this index after encoding the content of the list.
|
||||||
|
func (buf *encBuffer) list() int { |
||||||
|
buf.lheads = append(buf.lheads, listhead{offset: len(buf.str), size: buf.lhsize}) |
||||||
|
return len(buf.lheads) - 1 |
||||||
|
} |
||||||
|
|
||||||
|
func (buf *encBuffer) listEnd(index int) { |
||||||
|
lh := &buf.lheads[index] |
||||||
|
lh.size = buf.size() - lh.offset - lh.size |
||||||
|
if lh.size < 56 { |
||||||
|
buf.lhsize++ // length encoded into kind tag
|
||||||
|
} else { |
||||||
|
buf.lhsize += 1 + intsize(uint64(lh.size)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (buf *encBuffer) encode(val interface{}) error { |
||||||
|
rval := reflect.ValueOf(val) |
||||||
|
writer, err := cachedWriter(rval.Type()) |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
return writer(rval, buf) |
||||||
|
} |
||||||
|
|
||||||
|
func (buf *encBuffer) encodeStringHeader(size int) { |
||||||
|
if size < 56 { |
||||||
|
buf.str = append(buf.str, 0x80+byte(size)) |
||||||
|
} else { |
||||||
|
sizesize := putint(buf.sizebuf[1:], uint64(size)) |
||||||
|
buf.sizebuf[0] = 0xB7 + byte(sizesize) |
||||||
|
buf.str = append(buf.str, buf.sizebuf[:sizesize+1]...) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// encReader is the io.Reader returned by EncodeToReader.
|
||||||
|
// It releases its encbuf at EOF.
|
||||||
|
type encReader struct { |
||||||
|
buf *encBuffer // the buffer we're reading from. this is nil when we're at EOF.
|
||||||
|
lhpos int // index of list header that we're reading
|
||||||
|
strpos int // current position in string buffer
|
||||||
|
piece []byte // next piece to be read
|
||||||
|
} |
||||||
|
|
||||||
|
func (r *encReader) Read(b []byte) (n int, err error) { |
||||||
|
for { |
||||||
|
if r.piece = r.next(); r.piece == nil { |
||||||
|
// Put the encode buffer back into the pool at EOF when it
|
||||||
|
// is first encountered. Subsequent calls still return EOF
|
||||||
|
// as the error but the buffer is no longer valid.
|
||||||
|
if r.buf != nil { |
||||||
|
encBufferPool.Put(r.buf) |
||||||
|
r.buf = nil |
||||||
|
} |
||||||
|
return n, io.EOF |
||||||
|
} |
||||||
|
nn := copy(b[n:], r.piece) |
||||||
|
n += nn |
||||||
|
if nn < len(r.piece) { |
||||||
|
// piece didn't fit, see you next time.
|
||||||
|
r.piece = r.piece[nn:] |
||||||
|
return n, nil |
||||||
|
} |
||||||
|
r.piece = nil |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// next returns the next piece of data to be read.
|
||||||
|
// it returns nil at EOF.
|
||||||
|
func (r *encReader) next() []byte { |
||||||
|
switch { |
||||||
|
case r.buf == nil: |
||||||
|
return nil |
||||||
|
|
||||||
|
case r.piece != nil: |
||||||
|
// There is still data available for reading.
|
||||||
|
return r.piece |
||||||
|
|
||||||
|
case r.lhpos < len(r.buf.lheads): |
||||||
|
// We're before the last list header.
|
||||||
|
head := r.buf.lheads[r.lhpos] |
||||||
|
sizebefore := head.offset - r.strpos |
||||||
|
if sizebefore > 0 { |
||||||
|
// String data before header.
|
||||||
|
p := r.buf.str[r.strpos:head.offset] |
||||||
|
r.strpos += sizebefore |
||||||
|
return p |
||||||
|
} |
||||||
|
r.lhpos++ |
||||||
|
return head.encode(r.buf.sizebuf[:]) |
||||||
|
|
||||||
|
case r.strpos < len(r.buf.str): |
||||||
|
// String data at the end, after all list headers.
|
||||||
|
p := r.buf.str[r.strpos:] |
||||||
|
r.strpos = len(r.buf.str) |
||||||
|
return p |
||||||
|
|
||||||
|
default: |
||||||
|
return nil |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// EncoderBuffer is a buffer for incremental encoding.
|
||||||
|
//
|
||||||
|
// The zero value is NOT ready for use. To get a usable buffer,
|
||||||
|
// create it using NewEncoderBuffer or call Reset.
|
||||||
|
type EncoderBuffer struct { |
||||||
|
buf *encBuffer |
||||||
|
dst io.Writer |
||||||
|
|
||||||
|
ownBuffer bool |
||||||
|
} |
||||||
|
|
||||||
|
// NewEncoderBuffer creates an encoder buffer.
|
||||||
|
func NewEncoderBuffer(dst io.Writer) EncoderBuffer { |
||||||
|
var w EncoderBuffer |
||||||
|
w.Reset(dst) |
||||||
|
return w |
||||||
|
} |
||||||
|
|
||||||
|
// Reset truncates the buffer and sets the output destination.
|
||||||
|
func (w *EncoderBuffer) Reset(dst io.Writer) { |
||||||
|
if w.buf != nil && !w.ownBuffer { |
||||||
|
panic("can't Reset derived EncoderBuffer") |
||||||
|
} |
||||||
|
|
||||||
|
// If the destination writer has an *encBuffer, use it.
|
||||||
|
// Note that w.ownBuffer is left false here.
|
||||||
|
if dst != nil { |
||||||
|
if outer, ok := dst.(*encBuffer); ok { |
||||||
|
*w = EncoderBuffer{outer, nil, false} |
||||||
|
return |
||||||
|
} |
||||||
|
if outer, ok := dst.(EncoderBuffer); ok { |
||||||
|
*w = EncoderBuffer{outer.buf, nil, false} |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Get a fresh buffer.
|
||||||
|
if w.buf == nil { |
||||||
|
w.buf = encBufferPool.Get().(*encBuffer) |
||||||
|
w.ownBuffer = true |
||||||
|
} |
||||||
|
w.buf.reset() |
||||||
|
w.dst = dst |
||||||
|
} |
||||||
|
|
||||||
|
// Flush writes encoded RLP data to the output writer. This can only be called once.
|
||||||
|
// If you want to re-use the buffer after Flush, you must call Reset.
|
||||||
|
func (w *EncoderBuffer) Flush() error { |
||||||
|
var err error |
||||||
|
if w.dst != nil { |
||||||
|
err = w.buf.toWriter(w.dst) |
||||||
|
} |
||||||
|
// Release the internal buffer.
|
||||||
|
if w.ownBuffer { |
||||||
|
encBufferPool.Put(w.buf) |
||||||
|
} |
||||||
|
*w = EncoderBuffer{} |
||||||
|
return err |
||||||
|
} |
||||||
|
|
||||||
|
// ToBytes returns the encoded bytes.
|
||||||
|
func (w *EncoderBuffer) ToBytes() []byte { |
||||||
|
return w.buf.toBytes() |
||||||
|
} |
||||||
|
|
||||||
|
// Write appends b directly to the encoder output.
|
||||||
|
func (w EncoderBuffer) Write(b []byte) (int, error) { |
||||||
|
return w.buf.Write(b) |
||||||
|
} |
||||||
|
|
||||||
|
// WriteBool writes b as the integer 0 (false) or 1 (true).
|
||||||
|
func (w EncoderBuffer) WriteBool(b bool) { |
||||||
|
w.buf.writeBool(b) |
||||||
|
} |
||||||
|
|
||||||
|
// WriteUint64 encodes an unsigned integer.
|
||||||
|
func (w EncoderBuffer) WriteUint64(i uint64) { |
||||||
|
w.buf.writeUint64(i) |
||||||
|
} |
||||||
|
|
||||||
|
// WriteBigInt encodes a big.Int as an RLP string.
|
||||||
|
// Note: Unlike with Encode, the sign of i is ignored.
|
||||||
|
func (w EncoderBuffer) WriteBigInt(i *big.Int) { |
||||||
|
w.buf.writeBigInt(i) |
||||||
|
} |
||||||
|
|
||||||
|
// WriteBytes encodes b as an RLP string.
|
||||||
|
func (w EncoderBuffer) WriteBytes(b []byte) { |
||||||
|
w.buf.writeBytes(b) |
||||||
|
} |
||||||
|
|
||||||
|
// WriteBytes encodes s as an RLP string.
|
||||||
|
func (w EncoderBuffer) WriteString(s string) { |
||||||
|
w.buf.writeString(s) |
||||||
|
} |
||||||
|
|
||||||
|
// List starts a list. It returns an internal index. Call EndList with
|
||||||
|
// this index after encoding the content to finish the list.
|
||||||
|
func (w EncoderBuffer) List() int { |
||||||
|
return w.buf.list() |
||||||
|
} |
||||||
|
|
||||||
|
// ListEnd finishes the given list.
|
||||||
|
func (w EncoderBuffer) ListEnd(index int) { |
||||||
|
w.buf.listEnd(index) |
||||||
|
} |
||||||
@ -0,0 +1,45 @@ |
|||||||
|
// Copyright 2022 The go-ethereum Authors
|
||||||
|
// This file is part of the go-ethereum library.
|
||||||
|
//
|
||||||
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||||
|
// it under the terms of the GNU Lesser General Public License as published by
|
||||||
|
// the Free Software Foundation, either version 3 of the License, or
|
||||||
|
// (at your option) any later version.
|
||||||
|
//
|
||||||
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||||
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
// GNU Lesser General Public License for more details.
|
||||||
|
//
|
||||||
|
// You should have received a copy of the GNU Lesser General Public License
|
||||||
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
|
package rlp_test |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"fmt" |
||||||
|
|
||||||
|
"github.com/ethereum/go-ethereum/rlp" |
||||||
|
) |
||||||
|
|
||||||
|
func ExampleEncoderBuffer() { |
||||||
|
var w bytes.Buffer |
||||||
|
|
||||||
|
// Encode [4, [5, 6]] to w.
|
||||||
|
buf := rlp.NewEncoderBuffer(&w) |
||||||
|
l1 := buf.List() |
||||||
|
buf.WriteUint64(4) |
||||||
|
l2 := buf.List() |
||||||
|
buf.WriteUint64(5) |
||||||
|
buf.WriteUint64(6) |
||||||
|
buf.ListEnd(l2) |
||||||
|
buf.ListEnd(l1) |
||||||
|
|
||||||
|
if err := buf.Flush(); err != nil { |
||||||
|
panic(err) |
||||||
|
} |
||||||
|
fmt.Printf("%X\n", w.Bytes()) |
||||||
|
// Output:
|
||||||
|
// C404C20506
|
||||||
|
} |
||||||
@ -0,0 +1,213 @@ |
|||||||
|
// Copyright 2021 The go-ethereum Authors
|
||||||
|
// This file is part of the go-ethereum library.
|
||||||
|
//
|
||||||
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||||
|
// it under the terms of the GNU Lesser General Public License as published by
|
||||||
|
// the Free Software Foundation, either version 3 of the License, or
|
||||||
|
// (at your option) any later version.
|
||||||
|
//
|
||||||
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||||
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
// GNU Lesser General Public License for more details.
|
||||||
|
//
|
||||||
|
// You should have received a copy of the GNU Lesser General Public License
|
||||||
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
|
// Package rlpstruct implements struct processing for RLP encoding/decoding.
|
||||||
|
//
|
||||||
|
// In particular, this package handles all rules around field filtering,
|
||||||
|
// struct tags and nil value determination.
|
||||||
|
package rlpstruct |
||||||
|
|
||||||
|
import ( |
||||||
|
"fmt" |
||||||
|
"reflect" |
||||||
|
"strings" |
||||||
|
) |
||||||
|
|
||||||
|
// Field represents a struct field.
|
||||||
|
type Field struct { |
||||||
|
Name string |
||||||
|
Index int |
||||||
|
Exported bool |
||||||
|
Type Type |
||||||
|
Tag string |
||||||
|
} |
||||||
|
|
||||||
|
// Type represents the attributes of a Go type.
|
||||||
|
type Type struct { |
||||||
|
Name string |
||||||
|
Kind reflect.Kind |
||||||
|
IsEncoder bool // whether type implements rlp.Encoder
|
||||||
|
IsDecoder bool // whether type implements rlp.Decoder
|
||||||
|
Elem *Type // non-nil for Kind values of Ptr, Slice, Array
|
||||||
|
} |
||||||
|
|
||||||
|
// defaultNilValue determines whether a nil pointer to t encodes/decodes
|
||||||
|
// as an empty string or empty list.
|
||||||
|
func (t Type) DefaultNilValue() NilKind { |
||||||
|
k := t.Kind |
||||||
|
if isUint(k) || k == reflect.String || k == reflect.Bool || isByteArray(t) { |
||||||
|
return NilKindString |
||||||
|
} |
||||||
|
return NilKindList |
||||||
|
} |
||||||
|
|
||||||
|
// NilKind is the RLP value encoded in place of nil pointers.
|
||||||
|
type NilKind uint8 |
||||||
|
|
||||||
|
const ( |
||||||
|
NilKindString NilKind = 0x80 |
||||||
|
NilKindList NilKind = 0xC0 |
||||||
|
) |
||||||
|
|
||||||
|
// Tags represents struct tags.
|
||||||
|
type Tags struct { |
||||||
|
// rlp:"nil" controls whether empty input results in a nil pointer.
|
||||||
|
// nilKind is the kind of empty value allowed for the field.
|
||||||
|
NilKind NilKind |
||||||
|
NilOK bool |
||||||
|
|
||||||
|
// rlp:"optional" allows for a field to be missing in the input list.
|
||||||
|
// If this is set, all subsequent fields must also be optional.
|
||||||
|
Optional bool |
||||||
|
|
||||||
|
// rlp:"tail" controls whether this field swallows additional list elements. It can
|
||||||
|
// only be set for the last field, which must be of slice type.
|
||||||
|
Tail bool |
||||||
|
|
||||||
|
// rlp:"-" ignores fields.
|
||||||
|
Ignored bool |
||||||
|
} |
||||||
|
|
||||||
|
// TagError is raised for invalid struct tags.
|
||||||
|
type TagError struct { |
||||||
|
StructType string |
||||||
|
|
||||||
|
// These are set by this package.
|
||||||
|
Field string |
||||||
|
Tag string |
||||||
|
Err string |
||||||
|
} |
||||||
|
|
||||||
|
func (e TagError) Error() string { |
||||||
|
field := "field " + e.Field |
||||||
|
if e.StructType != "" { |
||||||
|
field = e.StructType + "." + e.Field |
||||||
|
} |
||||||
|
return fmt.Sprintf("rlp: invalid struct tag %q for %s (%s)", e.Tag, field, e.Err) |
||||||
|
} |
||||||
|
|
||||||
|
// ProcessFields filters the given struct fields, returning only fields
|
||||||
|
// that should be considered for encoding/decoding.
|
||||||
|
func ProcessFields(allFields []Field) ([]Field, []Tags, error) { |
||||||
|
lastPublic := lastPublicField(allFields) |
||||||
|
|
||||||
|
// Gather all exported fields and their tags.
|
||||||
|
var fields []Field |
||||||
|
var tags []Tags |
||||||
|
for _, field := range allFields { |
||||||
|
if !field.Exported { |
||||||
|
continue |
||||||
|
} |
||||||
|
ts, err := parseTag(field, lastPublic) |
||||||
|
if err != nil { |
||||||
|
return nil, nil, err |
||||||
|
} |
||||||
|
if ts.Ignored { |
||||||
|
continue |
||||||
|
} |
||||||
|
fields = append(fields, field) |
||||||
|
tags = append(tags, ts) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify optional field consistency. If any optional field exists,
|
||||||
|
// all fields after it must also be optional. Note: optional + tail
|
||||||
|
// is supported.
|
||||||
|
var anyOptional bool |
||||||
|
var firstOptionalName string |
||||||
|
for i, ts := range tags { |
||||||
|
name := fields[i].Name |
||||||
|
if ts.Optional || ts.Tail { |
||||||
|
if !anyOptional { |
||||||
|
firstOptionalName = name |
||||||
|
} |
||||||
|
anyOptional = true |
||||||
|
} else { |
||||||
|
if anyOptional { |
||||||
|
msg := fmt.Sprintf("must be optional because preceding field %q is optional", firstOptionalName) |
||||||
|
return nil, nil, TagError{Field: name, Err: msg} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
return fields, tags, nil |
||||||
|
} |
||||||
|
|
||||||
|
func parseTag(field Field, lastPublic int) (Tags, error) { |
||||||
|
name := field.Name |
||||||
|
tag := reflect.StructTag(field.Tag) |
||||||
|
var ts Tags |
||||||
|
for _, t := range strings.Split(tag.Get("rlp"), ",") { |
||||||
|
switch t = strings.TrimSpace(t); t { |
||||||
|
case "": |
||||||
|
// empty tag is allowed for some reason
|
||||||
|
case "-": |
||||||
|
ts.Ignored = true |
||||||
|
case "nil", "nilString", "nilList": |
||||||
|
ts.NilOK = true |
||||||
|
if field.Type.Kind != reflect.Ptr { |
||||||
|
return ts, TagError{Field: name, Tag: t, Err: "field is not a pointer"} |
||||||
|
} |
||||||
|
switch t { |
||||||
|
case "nil": |
||||||
|
ts.NilKind = field.Type.Elem.DefaultNilValue() |
||||||
|
case "nilString": |
||||||
|
ts.NilKind = NilKindString |
||||||
|
case "nilList": |
||||||
|
ts.NilKind = NilKindList |
||||||
|
} |
||||||
|
case "optional": |
||||||
|
ts.Optional = true |
||||||
|
if ts.Tail { |
||||||
|
return ts, TagError{Field: name, Tag: t, Err: `also has "tail" tag`} |
||||||
|
} |
||||||
|
case "tail": |
||||||
|
ts.Tail = true |
||||||
|
if field.Index != lastPublic { |
||||||
|
return ts, TagError{Field: name, Tag: t, Err: "must be on last field"} |
||||||
|
} |
||||||
|
if ts.Optional { |
||||||
|
return ts, TagError{Field: name, Tag: t, Err: `also has "optional" tag`} |
||||||
|
} |
||||||
|
if field.Type.Kind != reflect.Slice { |
||||||
|
return ts, TagError{Field: name, Tag: t, Err: "field type is not slice"} |
||||||
|
} |
||||||
|
default: |
||||||
|
return ts, TagError{Field: name, Tag: t, Err: "unknown tag"} |
||||||
|
} |
||||||
|
} |
||||||
|
return ts, nil |
||||||
|
} |
||||||
|
|
||||||
|
func lastPublicField(fields []Field) int { |
||||||
|
last := 0 |
||||||
|
for _, f := range fields { |
||||||
|
if f.Exported { |
||||||
|
last = f.Index |
||||||
|
} |
||||||
|
} |
||||||
|
return last |
||||||
|
} |
||||||
|
|
||||||
|
func isUint(k reflect.Kind) bool { |
||||||
|
return k >= reflect.Uint && k <= reflect.Uintptr |
||||||
|
} |
||||||
|
|
||||||
|
func isByte(typ Type) bool { |
||||||
|
return typ.Kind == reflect.Uint8 && !typ.IsEncoder |
||||||
|
} |
||||||
|
|
||||||
|
func isByteArray(typ Type) bool { |
||||||
|
return (typ.Kind == reflect.Slice || typ.Kind == reflect.Array) && isByte(*typ.Elem) |
||||||
|
} |
||||||
@ -0,0 +1,735 @@ |
|||||||
|
package main |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"fmt" |
||||||
|
"go/format" |
||||||
|
"go/types" |
||||||
|
"sort" |
||||||
|
|
||||||
|
"github.com/ethereum/go-ethereum/rlp/internal/rlpstruct" |
||||||
|
) |
||||||
|
|
||||||
|
// buildContext keeps the data needed for make*Op.
|
||||||
|
type buildContext struct { |
||||||
|
topType *types.Named // the type we're creating methods for
|
||||||
|
|
||||||
|
encoderIface *types.Interface |
||||||
|
decoderIface *types.Interface |
||||||
|
rawValueType *types.Named |
||||||
|
|
||||||
|
typeToStructCache map[types.Type]*rlpstruct.Type |
||||||
|
} |
||||||
|
|
||||||
|
func newBuildContext(packageRLP *types.Package) *buildContext { |
||||||
|
enc := packageRLP.Scope().Lookup("Encoder").Type().Underlying() |
||||||
|
dec := packageRLP.Scope().Lookup("Decoder").Type().Underlying() |
||||||
|
rawv := packageRLP.Scope().Lookup("RawValue").Type() |
||||||
|
return &buildContext{ |
||||||
|
typeToStructCache: make(map[types.Type]*rlpstruct.Type), |
||||||
|
encoderIface: enc.(*types.Interface), |
||||||
|
decoderIface: dec.(*types.Interface), |
||||||
|
rawValueType: rawv.(*types.Named), |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (bctx *buildContext) isEncoder(typ types.Type) bool { |
||||||
|
return types.Implements(typ, bctx.encoderIface) |
||||||
|
} |
||||||
|
|
||||||
|
func (bctx *buildContext) isDecoder(typ types.Type) bool { |
||||||
|
return types.Implements(typ, bctx.decoderIface) |
||||||
|
} |
||||||
|
|
||||||
|
// typeToStructType converts typ to rlpstruct.Type.
|
||||||
|
func (bctx *buildContext) typeToStructType(typ types.Type) *rlpstruct.Type { |
||||||
|
if prev := bctx.typeToStructCache[typ]; prev != nil { |
||||||
|
return prev // short-circuit for recursive types.
|
||||||
|
} |
||||||
|
|
||||||
|
// Resolve named types to their underlying type, but keep the name.
|
||||||
|
name := types.TypeString(typ, nil) |
||||||
|
for { |
||||||
|
utype := typ.Underlying() |
||||||
|
if utype == typ { |
||||||
|
break |
||||||
|
} |
||||||
|
typ = utype |
||||||
|
} |
||||||
|
|
||||||
|
// Create the type and store it in cache.
|
||||||
|
t := &rlpstruct.Type{ |
||||||
|
Name: name, |
||||||
|
Kind: typeReflectKind(typ), |
||||||
|
IsEncoder: bctx.isEncoder(typ), |
||||||
|
IsDecoder: bctx.isDecoder(typ), |
||||||
|
} |
||||||
|
bctx.typeToStructCache[typ] = t |
||||||
|
|
||||||
|
// Assign element type.
|
||||||
|
switch typ.(type) { |
||||||
|
case *types.Array, *types.Slice, *types.Pointer: |
||||||
|
etype := typ.(interface{ Elem() types.Type }).Elem() |
||||||
|
t.Elem = bctx.typeToStructType(etype) |
||||||
|
} |
||||||
|
return t |
||||||
|
} |
||||||
|
|
||||||
|
// genContext is passed to the gen* methods of op when generating
|
||||||
|
// the output code. It tracks packages to be imported by the output
|
||||||
|
// file and assigns unique names of temporary variables.
|
||||||
|
type genContext struct { |
||||||
|
inPackage *types.Package |
||||||
|
imports map[string]struct{} |
||||||
|
tempCounter int |
||||||
|
} |
||||||
|
|
||||||
|
func newGenContext(inPackage *types.Package) *genContext { |
||||||
|
return &genContext{ |
||||||
|
inPackage: inPackage, |
||||||
|
imports: make(map[string]struct{}), |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (ctx *genContext) temp() string { |
||||||
|
v := fmt.Sprintf("_tmp%d", ctx.tempCounter) |
||||||
|
ctx.tempCounter++ |
||||||
|
return v |
||||||
|
} |
||||||
|
|
||||||
|
func (ctx *genContext) resetTemp() { |
||||||
|
ctx.tempCounter = 0 |
||||||
|
} |
||||||
|
|
||||||
|
func (ctx *genContext) addImport(path string) { |
||||||
|
if path == ctx.inPackage.Path() { |
||||||
|
return // avoid importing the package that we're generating in.
|
||||||
|
} |
||||||
|
// TODO: renaming?
|
||||||
|
ctx.imports[path] = struct{}{} |
||||||
|
} |
||||||
|
|
||||||
|
// importsList returns all packages that need to be imported.
|
||||||
|
func (ctx *genContext) importsList() []string { |
||||||
|
imp := make([]string, 0, len(ctx.imports)) |
||||||
|
for k := range ctx.imports { |
||||||
|
imp = append(imp, k) |
||||||
|
} |
||||||
|
sort.Strings(imp) |
||||||
|
return imp |
||||||
|
} |
||||||
|
|
||||||
|
// qualify is the types.Qualifier used for printing types.
|
||||||
|
func (ctx *genContext) qualify(pkg *types.Package) string { |
||||||
|
if pkg.Path() == ctx.inPackage.Path() { |
||||||
|
return "" |
||||||
|
} |
||||||
|
ctx.addImport(pkg.Path()) |
||||||
|
// TODO: renaming?
|
||||||
|
return pkg.Name() |
||||||
|
} |
||||||
|
|
||||||
|
type op interface { |
||||||
|
// genWrite creates the encoder. The generated code should write v,
|
||||||
|
// which is any Go expression, to the rlp.EncoderBuffer 'w'.
|
||||||
|
genWrite(ctx *genContext, v string) string |
||||||
|
|
||||||
|
// genDecode creates the decoder. The generated code should read
|
||||||
|
// a value from the rlp.Stream 'dec' and store it to dst.
|
||||||
|
genDecode(ctx *genContext) (string, string) |
||||||
|
} |
||||||
|
|
||||||
|
// basicOp handles basic types bool, uint*, string.
|
||||||
|
type basicOp struct { |
||||||
|
typ types.Type |
||||||
|
writeMethod string // calle write the value
|
||||||
|
writeArgType types.Type // parameter type of writeMethod
|
||||||
|
decMethod string |
||||||
|
decResultType types.Type // return type of decMethod
|
||||||
|
decUseBitSize bool // if true, result bit size is appended to decMethod
|
||||||
|
} |
||||||
|
|
||||||
|
func (*buildContext) makeBasicOp(typ *types.Basic) (op, error) { |
||||||
|
op := basicOp{typ: typ} |
||||||
|
kind := typ.Kind() |
||||||
|
switch { |
||||||
|
case kind == types.Bool: |
||||||
|
op.writeMethod = "WriteBool" |
||||||
|
op.writeArgType = types.Typ[types.Bool] |
||||||
|
op.decMethod = "Bool" |
||||||
|
op.decResultType = types.Typ[types.Bool] |
||||||
|
case kind >= types.Uint8 && kind <= types.Uint64: |
||||||
|
op.writeMethod = "WriteUint64" |
||||||
|
op.writeArgType = types.Typ[types.Uint64] |
||||||
|
op.decMethod = "Uint" |
||||||
|
op.decResultType = typ |
||||||
|
op.decUseBitSize = true |
||||||
|
case kind == types.String: |
||||||
|
op.writeMethod = "WriteString" |
||||||
|
op.writeArgType = types.Typ[types.String] |
||||||
|
op.decMethod = "String" |
||||||
|
op.decResultType = types.Typ[types.String] |
||||||
|
default: |
||||||
|
return nil, fmt.Errorf("unhandled basic type: %v", typ) |
||||||
|
} |
||||||
|
return op, nil |
||||||
|
} |
||||||
|
|
||||||
|
func (*buildContext) makeByteSliceOp(typ *types.Slice) op { |
||||||
|
if !isByte(typ.Elem()) { |
||||||
|
panic("non-byte slice type in makeByteSliceOp") |
||||||
|
} |
||||||
|
bslice := types.NewSlice(types.Typ[types.Uint8]) |
||||||
|
return basicOp{ |
||||||
|
typ: typ, |
||||||
|
writeMethod: "WriteBytes", |
||||||
|
writeArgType: bslice, |
||||||
|
decMethod: "Bytes", |
||||||
|
decResultType: bslice, |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (bctx *buildContext) makeRawValueOp() op { |
||||||
|
bslice := types.NewSlice(types.Typ[types.Uint8]) |
||||||
|
return basicOp{ |
||||||
|
typ: bctx.rawValueType, |
||||||
|
writeMethod: "Write", |
||||||
|
writeArgType: bslice, |
||||||
|
decMethod: "Raw", |
||||||
|
decResultType: bslice, |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (op basicOp) writeNeedsConversion() bool { |
||||||
|
return !types.AssignableTo(op.typ, op.writeArgType) |
||||||
|
} |
||||||
|
|
||||||
|
func (op basicOp) decodeNeedsConversion() bool { |
||||||
|
return !types.AssignableTo(op.decResultType, op.typ) |
||||||
|
} |
||||||
|
|
||||||
|
func (op basicOp) genWrite(ctx *genContext, v string) string { |
||||||
|
if op.writeNeedsConversion() { |
||||||
|
v = fmt.Sprintf("%s(%s)", op.writeArgType, v) |
||||||
|
} |
||||||
|
return fmt.Sprintf("w.%s(%s)\n", op.writeMethod, v) |
||||||
|
} |
||||||
|
|
||||||
|
func (op basicOp) genDecode(ctx *genContext) (string, string) { |
||||||
|
var ( |
||||||
|
resultV = ctx.temp() |
||||||
|
result = resultV |
||||||
|
method = op.decMethod |
||||||
|
) |
||||||
|
if op.decUseBitSize { |
||||||
|
// Note: For now, this only works for platform-independent integer
|
||||||
|
// sizes. makeBasicOp forbids the platform-dependent types.
|
||||||
|
var sizes types.StdSizes |
||||||
|
method = fmt.Sprintf("%s%d", op.decMethod, sizes.Sizeof(op.typ)*8) |
||||||
|
} |
||||||
|
|
||||||
|
// Call the decoder method.
|
||||||
|
var b bytes.Buffer |
||||||
|
fmt.Fprintf(&b, "%s, err := dec.%s()\n", resultV, method) |
||||||
|
fmt.Fprintf(&b, "if err != nil { return err }\n") |
||||||
|
if op.decodeNeedsConversion() { |
||||||
|
conv := ctx.temp() |
||||||
|
fmt.Fprintf(&b, "%s := %s(%s)\n", conv, types.TypeString(op.typ, ctx.qualify), resultV) |
||||||
|
result = conv |
||||||
|
} |
||||||
|
return result, b.String() |
||||||
|
} |
||||||
|
|
||||||
|
// byteArrayOp handles [...]byte.
|
||||||
|
type byteArrayOp struct { |
||||||
|
typ types.Type |
||||||
|
name types.Type // name != typ for named byte array types (e.g. common.Address)
|
||||||
|
} |
||||||
|
|
||||||
|
func (bctx *buildContext) makeByteArrayOp(name *types.Named, typ *types.Array) byteArrayOp { |
||||||
|
nt := types.Type(name) |
||||||
|
if name == nil { |
||||||
|
nt = typ |
||||||
|
} |
||||||
|
return byteArrayOp{typ, nt} |
||||||
|
} |
||||||
|
|
||||||
|
func (op byteArrayOp) genWrite(ctx *genContext, v string) string { |
||||||
|
return fmt.Sprintf("w.WriteBytes(%s[:])\n", v) |
||||||
|
} |
||||||
|
|
||||||
|
func (op byteArrayOp) genDecode(ctx *genContext) (string, string) { |
||||||
|
var resultV = ctx.temp() |
||||||
|
|
||||||
|
var b bytes.Buffer |
||||||
|
fmt.Fprintf(&b, "var %s %s\n", resultV, types.TypeString(op.name, ctx.qualify)) |
||||||
|
fmt.Fprintf(&b, "if err := dec.ReadBytes(%s[:]); err != nil { return err }\n", resultV) |
||||||
|
return resultV, b.String() |
||||||
|
} |
||||||
|
|
||||||
|
// bigIntNoPtrOp handles non-pointer big.Int.
|
||||||
|
// This exists because big.Int has it's own decoder operation on rlp.Stream,
|
||||||
|
// but the decode method returns *big.Int, so it needs to be dereferenced.
|
||||||
|
type bigIntOp struct { |
||||||
|
pointer bool |
||||||
|
} |
||||||
|
|
||||||
|
func (op bigIntOp) genWrite(ctx *genContext, v string) string { |
||||||
|
var b bytes.Buffer |
||||||
|
|
||||||
|
fmt.Fprintf(&b, "if %s.Sign() == -1 {\n", v) |
||||||
|
fmt.Fprintf(&b, " return rlp.ErrNegativeBigInt\n") |
||||||
|
fmt.Fprintf(&b, "}\n") |
||||||
|
dst := v |
||||||
|
if !op.pointer { |
||||||
|
dst = "&" + v |
||||||
|
} |
||||||
|
fmt.Fprintf(&b, "w.WriteBigInt(%s)\n", dst) |
||||||
|
|
||||||
|
// Wrap with nil check.
|
||||||
|
if op.pointer { |
||||||
|
code := b.String() |
||||||
|
b.Reset() |
||||||
|
fmt.Fprintf(&b, "if %s == nil {\n", v) |
||||||
|
fmt.Fprintf(&b, " w.Write(rlp.EmptyString)") |
||||||
|
fmt.Fprintf(&b, "} else {\n") |
||||||
|
fmt.Fprint(&b, code) |
||||||
|
fmt.Fprintf(&b, "}\n") |
||||||
|
} |
||||||
|
|
||||||
|
return b.String() |
||||||
|
} |
||||||
|
|
||||||
|
func (op bigIntOp) genDecode(ctx *genContext) (string, string) { |
||||||
|
var resultV = ctx.temp() |
||||||
|
|
||||||
|
var b bytes.Buffer |
||||||
|
fmt.Fprintf(&b, "%s, err := dec.BigInt()\n", resultV) |
||||||
|
fmt.Fprintf(&b, "if err != nil { return err }\n") |
||||||
|
|
||||||
|
result := resultV |
||||||
|
if !op.pointer { |
||||||
|
result = "(*" + resultV + ")" |
||||||
|
} |
||||||
|
return result, b.String() |
||||||
|
} |
||||||
|
|
||||||
|
// encoderDecoderOp handles rlp.Encoder and rlp.Decoder.
|
||||||
|
// In order to be used with this, the type must implement both interfaces.
|
||||||
|
// This restriction may be lifted in the future by creating separate ops for
|
||||||
|
// encoding and decoding.
|
||||||
|
type encoderDecoderOp struct { |
||||||
|
typ types.Type |
||||||
|
} |
||||||
|
|
||||||
|
func (op encoderDecoderOp) genWrite(ctx *genContext, v string) string { |
||||||
|
return fmt.Sprintf("if err := %s.EncodeRLP(w); err != nil { return err }\n", v) |
||||||
|
} |
||||||
|
|
||||||
|
func (op encoderDecoderOp) genDecode(ctx *genContext) (string, string) { |
||||||
|
// DecodeRLP must have pointer receiver, and this is verified in makeOp.
|
||||||
|
etyp := op.typ.(*types.Pointer).Elem() |
||||||
|
var resultV = ctx.temp() |
||||||
|
|
||||||
|
var b bytes.Buffer |
||||||
|
fmt.Fprintf(&b, "%s := new(%s)\n", resultV, types.TypeString(etyp, ctx.qualify)) |
||||||
|
fmt.Fprintf(&b, "if err := %s.DecodeRLP(dec); err != nil { return err }\n", resultV) |
||||||
|
return resultV, b.String() |
||||||
|
} |
||||||
|
|
||||||
|
// ptrOp handles pointer types.
|
||||||
|
type ptrOp struct { |
||||||
|
elemTyp types.Type |
||||||
|
elem op |
||||||
|
nilOK bool |
||||||
|
nilValue rlpstruct.NilKind |
||||||
|
} |
||||||
|
|
||||||
|
func (bctx *buildContext) makePtrOp(elemTyp types.Type, tags rlpstruct.Tags) (op, error) { |
||||||
|
elemOp, err := bctx.makeOp(nil, elemTyp, rlpstruct.Tags{}) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
op := ptrOp{elemTyp: elemTyp, elem: elemOp} |
||||||
|
|
||||||
|
// Determine nil value.
|
||||||
|
if tags.NilOK { |
||||||
|
op.nilOK = true |
||||||
|
op.nilValue = tags.NilKind |
||||||
|
} else { |
||||||
|
styp := bctx.typeToStructType(elemTyp) |
||||||
|
op.nilValue = styp.DefaultNilValue() |
||||||
|
} |
||||||
|
return op, nil |
||||||
|
} |
||||||
|
|
||||||
|
func (op ptrOp) genWrite(ctx *genContext, v string) string { |
||||||
|
// Note: in writer functions, accesses to v are read-only, i.e. v is any Go
|
||||||
|
// expression. To make all accesses work through the pointer, we substitute
|
||||||
|
// v with (*v). This is required for most accesses including `v`, `call(v)`,
|
||||||
|
// and `v[index]` on slices.
|
||||||
|
//
|
||||||
|
// For `v.field` and `v[:]` on arrays, the dereference operation is not required.
|
||||||
|
var vv string |
||||||
|
_, isStruct := op.elem.(structOp) |
||||||
|
_, isByteArray := op.elem.(byteArrayOp) |
||||||
|
if isStruct || isByteArray { |
||||||
|
vv = v |
||||||
|
} else { |
||||||
|
vv = fmt.Sprintf("(*%s)", v) |
||||||
|
} |
||||||
|
|
||||||
|
var b bytes.Buffer |
||||||
|
fmt.Fprintf(&b, "if %s == nil {\n", v) |
||||||
|
fmt.Fprintf(&b, " w.Write([]byte{0x%X})\n", op.nilValue) |
||||||
|
fmt.Fprintf(&b, "} else {\n") |
||||||
|
fmt.Fprintf(&b, " %s", op.elem.genWrite(ctx, vv)) |
||||||
|
fmt.Fprintf(&b, "}\n") |
||||||
|
return b.String() |
||||||
|
} |
||||||
|
|
||||||
|
func (op ptrOp) genDecode(ctx *genContext) (string, string) { |
||||||
|
result, code := op.elem.genDecode(ctx) |
||||||
|
if !op.nilOK { |
||||||
|
// If nil pointers are not allowed, we can just decode the element.
|
||||||
|
return "&" + result, code |
||||||
|
} |
||||||
|
|
||||||
|
// nil is allowed, so check the kind and size first.
|
||||||
|
// If size is zero and kind matches the nilKind of the type,
|
||||||
|
// the value decodes as a nil pointer.
|
||||||
|
var ( |
||||||
|
resultV = ctx.temp() |
||||||
|
kindV = ctx.temp() |
||||||
|
sizeV = ctx.temp() |
||||||
|
wantKind string |
||||||
|
) |
||||||
|
if op.nilValue == rlpstruct.NilKindList { |
||||||
|
wantKind = "rlp.List" |
||||||
|
} else { |
||||||
|
wantKind = "rlp.String" |
||||||
|
} |
||||||
|
var b bytes.Buffer |
||||||
|
fmt.Fprintf(&b, "var %s %s\n", resultV, types.TypeString(types.NewPointer(op.elemTyp), ctx.qualify)) |
||||||
|
fmt.Fprintf(&b, "if %s, %s, err := dec.Kind(); err != nil {\n", kindV, sizeV) |
||||||
|
fmt.Fprintf(&b, " return err\n") |
||||||
|
fmt.Fprintf(&b, "} else if %s != 0 || %s != %s {\n", sizeV, kindV, wantKind) |
||||||
|
fmt.Fprint(&b, code) |
||||||
|
fmt.Fprintf(&b, " %s = &%s\n", resultV, result) |
||||||
|
fmt.Fprintf(&b, "}\n") |
||||||
|
return resultV, b.String() |
||||||
|
} |
||||||
|
|
||||||
|
// structOp handles struct types.
|
||||||
|
type structOp struct { |
||||||
|
named *types.Named |
||||||
|
typ *types.Struct |
||||||
|
fields []*structField |
||||||
|
optionalFields []*structField |
||||||
|
} |
||||||
|
|
||||||
|
type structField struct { |
||||||
|
name string |
||||||
|
typ types.Type |
||||||
|
elem op |
||||||
|
} |
||||||
|
|
||||||
|
func (bctx *buildContext) makeStructOp(named *types.Named, typ *types.Struct) (op, error) { |
||||||
|
// Convert fields to []rlpstruct.Field.
|
||||||
|
var allStructFields []rlpstruct.Field |
||||||
|
for i := 0; i < typ.NumFields(); i++ { |
||||||
|
f := typ.Field(i) |
||||||
|
allStructFields = append(allStructFields, rlpstruct.Field{ |
||||||
|
Name: f.Name(), |
||||||
|
Exported: f.Exported(), |
||||||
|
Index: i, |
||||||
|
Tag: typ.Tag(i), |
||||||
|
Type: *bctx.typeToStructType(f.Type()), |
||||||
|
}) |
||||||
|
} |
||||||
|
|
||||||
|
// Filter/validate fields.
|
||||||
|
fields, tags, err := rlpstruct.ProcessFields(allStructFields) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
// Create field ops.
|
||||||
|
var op = structOp{named: named, typ: typ} |
||||||
|
for i, field := range fields { |
||||||
|
// Advanced struct tags are not supported yet.
|
||||||
|
tag := tags[i] |
||||||
|
if err := checkUnsupportedTags(field.Name, tag); err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
typ := typ.Field(field.Index).Type() |
||||||
|
elem, err := bctx.makeOp(nil, typ, tags[i]) |
||||||
|
if err != nil { |
||||||
|
return nil, fmt.Errorf("field %s: %v", field.Name, err) |
||||||
|
} |
||||||
|
f := &structField{name: field.Name, typ: typ, elem: elem} |
||||||
|
if tag.Optional { |
||||||
|
op.optionalFields = append(op.optionalFields, f) |
||||||
|
} else { |
||||||
|
op.fields = append(op.fields, f) |
||||||
|
} |
||||||
|
} |
||||||
|
return op, nil |
||||||
|
} |
||||||
|
|
||||||
|
func checkUnsupportedTags(field string, tag rlpstruct.Tags) error { |
||||||
|
if tag.Tail { |
||||||
|
return fmt.Errorf(`field %s has unsupported struct tag "tail"`, field) |
||||||
|
} |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
func (op structOp) genWrite(ctx *genContext, v string) string { |
||||||
|
var b bytes.Buffer |
||||||
|
var listMarker = ctx.temp() |
||||||
|
fmt.Fprintf(&b, "%s := w.List()\n", listMarker) |
||||||
|
for _, field := range op.fields { |
||||||
|
selector := v + "." + field.name |
||||||
|
fmt.Fprint(&b, field.elem.genWrite(ctx, selector)) |
||||||
|
} |
||||||
|
op.writeOptionalFields(&b, ctx, v) |
||||||
|
fmt.Fprintf(&b, "w.ListEnd(%s)\n", listMarker) |
||||||
|
return b.String() |
||||||
|
} |
||||||
|
|
||||||
|
func (op structOp) writeOptionalFields(b *bytes.Buffer, ctx *genContext, v string) { |
||||||
|
if len(op.optionalFields) == 0 { |
||||||
|
return |
||||||
|
} |
||||||
|
// First check zero-ness of all optional fields.
|
||||||
|
var zeroV = make([]string, len(op.optionalFields)) |
||||||
|
for i, field := range op.optionalFields { |
||||||
|
selector := v + "." + field.name |
||||||
|
zeroV[i] = ctx.temp() |
||||||
|
fmt.Fprintf(b, "%s := %s\n", zeroV[i], nonZeroCheck(selector, field.typ, ctx.qualify)) |
||||||
|
} |
||||||
|
// Now write the fields.
|
||||||
|
for i, field := range op.optionalFields { |
||||||
|
selector := v + "." + field.name |
||||||
|
cond := "" |
||||||
|
for j := i; j < len(op.optionalFields); j++ { |
||||||
|
if j > i { |
||||||
|
cond += " || " |
||||||
|
} |
||||||
|
cond += zeroV[j] |
||||||
|
} |
||||||
|
fmt.Fprintf(b, "if %s {\n", cond) |
||||||
|
fmt.Fprint(b, field.elem.genWrite(ctx, selector)) |
||||||
|
fmt.Fprintf(b, "}\n") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (op structOp) genDecode(ctx *genContext) (string, string) { |
||||||
|
// Get the string representation of the type.
|
||||||
|
// Here, named types are handled separately because the output
|
||||||
|
// would contain a copy of the struct definition otherwise.
|
||||||
|
var typeName string |
||||||
|
if op.named != nil { |
||||||
|
typeName = types.TypeString(op.named, ctx.qualify) |
||||||
|
} else { |
||||||
|
typeName = types.TypeString(op.typ, ctx.qualify) |
||||||
|
} |
||||||
|
|
||||||
|
// Create struct object.
|
||||||
|
var resultV = ctx.temp() |
||||||
|
var b bytes.Buffer |
||||||
|
fmt.Fprintf(&b, "var %s %s\n", resultV, typeName) |
||||||
|
|
||||||
|
// Decode fields.
|
||||||
|
fmt.Fprintf(&b, "{\n") |
||||||
|
fmt.Fprintf(&b, "if _, err := dec.List(); err != nil { return err }\n") |
||||||
|
for _, field := range op.fields { |
||||||
|
result, code := field.elem.genDecode(ctx) |
||||||
|
fmt.Fprintf(&b, "// %s:\n", field.name) |
||||||
|
fmt.Fprint(&b, code) |
||||||
|
fmt.Fprintf(&b, "%s.%s = %s\n", resultV, field.name, result) |
||||||
|
} |
||||||
|
op.decodeOptionalFields(&b, ctx, resultV) |
||||||
|
fmt.Fprintf(&b, "if err := dec.ListEnd(); err != nil { return err }\n") |
||||||
|
fmt.Fprintf(&b, "}\n") |
||||||
|
return resultV, b.String() |
||||||
|
} |
||||||
|
|
||||||
|
func (op structOp) decodeOptionalFields(b *bytes.Buffer, ctx *genContext, resultV string) { |
||||||
|
var suffix bytes.Buffer |
||||||
|
for _, field := range op.optionalFields { |
||||||
|
result, code := field.elem.genDecode(ctx) |
||||||
|
fmt.Fprintf(b, "// %s:\n", field.name) |
||||||
|
fmt.Fprintf(b, "if dec.MoreDataInList() {\n") |
||||||
|
fmt.Fprint(b, code) |
||||||
|
fmt.Fprintf(b, "%s.%s = %s\n", resultV, field.name, result) |
||||||
|
fmt.Fprintf(&suffix, "}\n") |
||||||
|
} |
||||||
|
suffix.WriteTo(b) |
||||||
|
} |
||||||
|
|
||||||
|
// sliceOp handles slice types.
|
||||||
|
type sliceOp struct { |
||||||
|
typ *types.Slice |
||||||
|
elemOp op |
||||||
|
} |
||||||
|
|
||||||
|
func (bctx *buildContext) makeSliceOp(typ *types.Slice) (op, error) { |
||||||
|
elemOp, err := bctx.makeOp(nil, typ.Elem(), rlpstruct.Tags{}) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
return sliceOp{typ: typ, elemOp: elemOp}, nil |
||||||
|
} |
||||||
|
|
||||||
|
func (op sliceOp) genWrite(ctx *genContext, v string) string { |
||||||
|
var ( |
||||||
|
listMarker = ctx.temp() // holds return value of w.List()
|
||||||
|
iterElemV = ctx.temp() // iteration variable
|
||||||
|
elemCode = op.elemOp.genWrite(ctx, iterElemV) |
||||||
|
) |
||||||
|
|
||||||
|
var b bytes.Buffer |
||||||
|
fmt.Fprintf(&b, "%s := w.List()\n", listMarker) |
||||||
|
fmt.Fprintf(&b, "for _, %s := range %s {\n", iterElemV, v) |
||||||
|
fmt.Fprint(&b, elemCode) |
||||||
|
fmt.Fprintf(&b, "}\n") |
||||||
|
fmt.Fprintf(&b, "w.ListEnd(%s)\n", listMarker) |
||||||
|
return b.String() |
||||||
|
} |
||||||
|
|
||||||
|
func (op sliceOp) genDecode(ctx *genContext) (string, string) { |
||||||
|
var sliceV = ctx.temp() // holds the output slice
|
||||||
|
elemResult, elemCode := op.elemOp.genDecode(ctx) |
||||||
|
|
||||||
|
var b bytes.Buffer |
||||||
|
fmt.Fprintf(&b, "var %s %s\n", sliceV, types.TypeString(op.typ, ctx.qualify)) |
||||||
|
fmt.Fprintf(&b, "if _, err := dec.List(); err != nil { return err }\n") |
||||||
|
fmt.Fprintf(&b, "for dec.MoreDataInList() {\n") |
||||||
|
fmt.Fprintf(&b, " %s", elemCode) |
||||||
|
fmt.Fprintf(&b, " %s = append(%s, %s)\n", sliceV, sliceV, elemResult) |
||||||
|
fmt.Fprintf(&b, "}\n") |
||||||
|
fmt.Fprintf(&b, "if err := dec.ListEnd(); err != nil { return err }\n") |
||||||
|
return sliceV, b.String() |
||||||
|
} |
||||||
|
|
||||||
|
func (bctx *buildContext) makeOp(name *types.Named, typ types.Type, tags rlpstruct.Tags) (op, error) { |
||||||
|
switch typ := typ.(type) { |
||||||
|
case *types.Named: |
||||||
|
if isBigInt(typ) { |
||||||
|
return bigIntOp{}, nil |
||||||
|
} |
||||||
|
if typ == bctx.rawValueType { |
||||||
|
return bctx.makeRawValueOp(), nil |
||||||
|
} |
||||||
|
if bctx.isDecoder(typ) { |
||||||
|
return nil, fmt.Errorf("type %v implements rlp.Decoder with non-pointer receiver", typ) |
||||||
|
} |
||||||
|
// TODO: same check for encoder?
|
||||||
|
return bctx.makeOp(typ, typ.Underlying(), tags) |
||||||
|
case *types.Pointer: |
||||||
|
if isBigInt(typ.Elem()) { |
||||||
|
return bigIntOp{pointer: true}, nil |
||||||
|
} |
||||||
|
// Encoder/Decoder interfaces.
|
||||||
|
if bctx.isEncoder(typ) { |
||||||
|
if bctx.isDecoder(typ) { |
||||||
|
return encoderDecoderOp{typ}, nil |
||||||
|
} |
||||||
|
return nil, fmt.Errorf("type %v implements rlp.Encoder but not rlp.Decoder", typ) |
||||||
|
} |
||||||
|
if bctx.isDecoder(typ) { |
||||||
|
return nil, fmt.Errorf("type %v implements rlp.Decoder but not rlp.Encoder", typ) |
||||||
|
} |
||||||
|
// Default pointer handling.
|
||||||
|
return bctx.makePtrOp(typ.Elem(), tags) |
||||||
|
case *types.Basic: |
||||||
|
return bctx.makeBasicOp(typ) |
||||||
|
case *types.Struct: |
||||||
|
return bctx.makeStructOp(name, typ) |
||||||
|
case *types.Slice: |
||||||
|
etyp := typ.Elem() |
||||||
|
if isByte(etyp) && !bctx.isEncoder(etyp) { |
||||||
|
return bctx.makeByteSliceOp(typ), nil |
||||||
|
} |
||||||
|
return bctx.makeSliceOp(typ) |
||||||
|
case *types.Array: |
||||||
|
etyp := typ.Elem() |
||||||
|
if isByte(etyp) && !bctx.isEncoder(etyp) { |
||||||
|
return bctx.makeByteArrayOp(name, typ), nil |
||||||
|
} |
||||||
|
return nil, fmt.Errorf("unhandled array type: %v", typ) |
||||||
|
default: |
||||||
|
return nil, fmt.Errorf("unhandled type: %v", typ) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// generateDecoder generates the DecodeRLP method on 'typ'.
|
||||||
|
func generateDecoder(ctx *genContext, typ string, op op) []byte { |
||||||
|
ctx.resetTemp() |
||||||
|
ctx.addImport(pathOfPackageRLP) |
||||||
|
|
||||||
|
result, code := op.genDecode(ctx) |
||||||
|
var b bytes.Buffer |
||||||
|
fmt.Fprintf(&b, "func (obj *%s) DecodeRLP(dec *rlp.Stream) error {\n", typ) |
||||||
|
fmt.Fprint(&b, code) |
||||||
|
fmt.Fprintf(&b, " *obj = %s\n", result) |
||||||
|
fmt.Fprintf(&b, " return nil\n") |
||||||
|
fmt.Fprintf(&b, "}\n") |
||||||
|
return b.Bytes() |
||||||
|
} |
||||||
|
|
||||||
|
// generateEncoder generates the EncodeRLP method on 'typ'.
|
||||||
|
func generateEncoder(ctx *genContext, typ string, op op) []byte { |
||||||
|
ctx.resetTemp() |
||||||
|
ctx.addImport("io") |
||||||
|
ctx.addImport(pathOfPackageRLP) |
||||||
|
|
||||||
|
var b bytes.Buffer |
||||||
|
fmt.Fprintf(&b, "func (obj *%s) EncodeRLP(_w io.Writer) error {\n", typ) |
||||||
|
fmt.Fprintf(&b, " w := rlp.NewEncoderBuffer(_w)\n") |
||||||
|
fmt.Fprint(&b, op.genWrite(ctx, "obj")) |
||||||
|
fmt.Fprintf(&b, " return w.Flush()\n") |
||||||
|
fmt.Fprintf(&b, "}\n") |
||||||
|
return b.Bytes() |
||||||
|
} |
||||||
|
|
||||||
|
func (bctx *buildContext) generate(typ *types.Named, encoder, decoder bool) ([]byte, error) { |
||||||
|
bctx.topType = typ |
||||||
|
|
||||||
|
pkg := typ.Obj().Pkg() |
||||||
|
op, err := bctx.makeOp(nil, typ, rlpstruct.Tags{}) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
var ( |
||||||
|
ctx = newGenContext(pkg) |
||||||
|
encSource []byte |
||||||
|
decSource []byte |
||||||
|
) |
||||||
|
if encoder { |
||||||
|
encSource = generateEncoder(ctx, typ.Obj().Name(), op) |
||||||
|
} |
||||||
|
if decoder { |
||||||
|
decSource = generateDecoder(ctx, typ.Obj().Name(), op) |
||||||
|
} |
||||||
|
|
||||||
|
var b bytes.Buffer |
||||||
|
fmt.Fprintf(&b, "package %s\n\n", pkg.Name()) |
||||||
|
for _, imp := range ctx.importsList() { |
||||||
|
fmt.Fprintf(&b, "import %q\n", imp) |
||||||
|
} |
||||||
|
if encoder { |
||||||
|
fmt.Fprintln(&b) |
||||||
|
b.Write(encSource) |
||||||
|
} |
||||||
|
if decoder { |
||||||
|
fmt.Fprintln(&b) |
||||||
|
b.Write(decSource) |
||||||
|
} |
||||||
|
|
||||||
|
source := b.Bytes() |
||||||
|
// fmt.Println(string(source))
|
||||||
|
return format.Source(source) |
||||||
|
} |
||||||
@ -0,0 +1,92 @@ |
|||||||
|
package main |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"fmt" |
||||||
|
"go/ast" |
||||||
|
"go/importer" |
||||||
|
"go/parser" |
||||||
|
"go/token" |
||||||
|
"go/types" |
||||||
|
"io/ioutil" |
||||||
|
"os" |
||||||
|
"path/filepath" |
||||||
|
"testing" |
||||||
|
) |
||||||
|
|
||||||
|
// Package RLP is loaded only once and reused for all tests.
|
||||||
|
var ( |
||||||
|
testFset = token.NewFileSet() |
||||||
|
testImporter = importer.ForCompiler(testFset, "source", nil).(types.ImporterFrom) |
||||||
|
testPackageRLP *types.Package |
||||||
|
) |
||||||
|
|
||||||
|
func init() { |
||||||
|
cwd, err := os.Getwd() |
||||||
|
if err != nil { |
||||||
|
panic(err) |
||||||
|
} |
||||||
|
testPackageRLP, err = testImporter.ImportFrom(pathOfPackageRLP, cwd, 0) |
||||||
|
if err != nil { |
||||||
|
panic(fmt.Errorf("can't load package RLP: %v", err)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
var tests = []string{"uints", "nil", "rawvalue", "optional", "bigint"} |
||||||
|
|
||||||
|
func TestOutput(t *testing.T) { |
||||||
|
for _, test := range tests { |
||||||
|
test := test |
||||||
|
t.Run(test, func(t *testing.T) { |
||||||
|
inputFile := filepath.Join("testdata", test+".in.txt") |
||||||
|
outputFile := filepath.Join("testdata", test+".out.txt") |
||||||
|
bctx, typ, err := loadTestSource(inputFile, "Test") |
||||||
|
if err != nil { |
||||||
|
t.Fatal("error loading test source:", err) |
||||||
|
} |
||||||
|
output, err := bctx.generate(typ, true, true) |
||||||
|
if err != nil { |
||||||
|
t.Fatal("error in generate:", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Set this environment variable to regenerate the test outputs.
|
||||||
|
if os.Getenv("WRITE_TEST_FILES") != "" { |
||||||
|
ioutil.WriteFile(outputFile, output, 0644) |
||||||
|
} |
||||||
|
|
||||||
|
// Check if output matches.
|
||||||
|
wantOutput, err := ioutil.ReadFile(outputFile) |
||||||
|
if err != nil { |
||||||
|
t.Fatal("error loading expected test output:", err) |
||||||
|
} |
||||||
|
if !bytes.Equal(output, wantOutput) { |
||||||
|
t.Fatal("output mismatch:\n", string(output)) |
||||||
|
} |
||||||
|
}) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func loadTestSource(file string, typeName string) (*buildContext, *types.Named, error) { |
||||||
|
// Load the test input.
|
||||||
|
content, err := ioutil.ReadFile(file) |
||||||
|
if err != nil { |
||||||
|
return nil, nil, err |
||||||
|
} |
||||||
|
f, err := parser.ParseFile(testFset, file, content, 0) |
||||||
|
if err != nil { |
||||||
|
return nil, nil, err |
||||||
|
} |
||||||
|
conf := types.Config{Importer: testImporter} |
||||||
|
pkg, err := conf.Check("test", testFset, []*ast.File{f}, nil) |
||||||
|
if err != nil { |
||||||
|
return nil, nil, err |
||||||
|
} |
||||||
|
|
||||||
|
// Find the test struct.
|
||||||
|
bctx := newBuildContext(testPackageRLP) |
||||||
|
typ, err := lookupStructType(pkg.Scope(), typeName) |
||||||
|
if err != nil { |
||||||
|
return nil, nil, fmt.Errorf("can't find type %s: %v", typeName, err) |
||||||
|
} |
||||||
|
return bctx, typ, nil |
||||||
|
} |
||||||
@ -0,0 +1,148 @@ |
|||||||
|
// Copyright 2021 The go-ethereum Authors
|
||||||
|
// This file is part of the go-ethereum library.
|
||||||
|
//
|
||||||
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||||
|
// it under the terms of the GNU Lesser General Public License as published by
|
||||||
|
// the Free Software Foundation, either version 3 of the License, or
|
||||||
|
// (at your option) any later version.
|
||||||
|
//
|
||||||
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||||
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
// GNU Lesser General Public License for more details.
|
||||||
|
//
|
||||||
|
// You should have received a copy of the GNU Lesser General Public License
|
||||||
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||||
|
|
||||||
|
package main |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"errors" |
||||||
|
"flag" |
||||||
|
"fmt" |
||||||
|
"go/types" |
||||||
|
"io/ioutil" |
||||||
|
"os" |
||||||
|
|
||||||
|
"golang.org/x/tools/go/packages" |
||||||
|
) |
||||||
|
|
||||||
|
const pathOfPackageRLP = "github.com/ethereum/go-ethereum/rlp" |
||||||
|
|
||||||
|
func main() { |
||||||
|
var ( |
||||||
|
pkgdir = flag.String("dir", ".", "input package") |
||||||
|
output = flag.String("out", "-", "output file (default is stdout)") |
||||||
|
genEncoder = flag.Bool("encoder", true, "generate EncodeRLP?") |
||||||
|
genDecoder = flag.Bool("decoder", false, "generate DecodeRLP?") |
||||||
|
typename = flag.String("type", "", "type to generate methods for") |
||||||
|
) |
||||||
|
flag.Parse() |
||||||
|
|
||||||
|
cfg := Config{ |
||||||
|
Dir: *pkgdir, |
||||||
|
Type: *typename, |
||||||
|
GenerateEncoder: *genEncoder, |
||||||
|
GenerateDecoder: *genDecoder, |
||||||
|
} |
||||||
|
code, err := cfg.process() |
||||||
|
if err != nil { |
||||||
|
fatal(err) |
||||||
|
} |
||||||
|
if *output == "-" { |
||||||
|
os.Stdout.Write(code) |
||||||
|
} else if err := ioutil.WriteFile(*output, code, 0644); err != nil { |
||||||
|
fatal(err) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func fatal(args ...interface{}) { |
||||||
|
fmt.Fprintln(os.Stderr, args...) |
||||||
|
os.Exit(1) |
||||||
|
} |
||||||
|
|
||||||
|
type Config struct { |
||||||
|
Dir string // input package directory
|
||||||
|
Type string |
||||||
|
|
||||||
|
GenerateEncoder bool |
||||||
|
GenerateDecoder bool |
||||||
|
} |
||||||
|
|
||||||
|
// process generates the Go code.
|
||||||
|
func (cfg *Config) process() (code []byte, err error) { |
||||||
|
// Load packages.
|
||||||
|
pcfg := &packages.Config{ |
||||||
|
Mode: packages.NeedName | packages.NeedTypes | packages.NeedImports | packages.NeedDeps, |
||||||
|
Dir: cfg.Dir, |
||||||
|
BuildFlags: []string{"-tags", "norlpgen"}, |
||||||
|
} |
||||||
|
ps, err := packages.Load(pcfg, pathOfPackageRLP, ".") |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
if len(ps) == 0 { |
||||||
|
return nil, fmt.Errorf("no Go package found in %s", cfg.Dir) |
||||||
|
} |
||||||
|
packages.PrintErrors(ps) |
||||||
|
|
||||||
|
// Find the packages that were loaded.
|
||||||
|
var ( |
||||||
|
pkg *types.Package |
||||||
|
packageRLP *types.Package |
||||||
|
) |
||||||
|
for _, p := range ps { |
||||||
|
if len(p.Errors) > 0 { |
||||||
|
return nil, fmt.Errorf("package %s has errors", p.PkgPath) |
||||||
|
} |
||||||
|
if p.PkgPath == pathOfPackageRLP { |
||||||
|
packageRLP = p.Types |
||||||
|
} else { |
||||||
|
pkg = p.Types |
||||||
|
} |
||||||
|
} |
||||||
|
bctx := newBuildContext(packageRLP) |
||||||
|
|
||||||
|
// Find the type and generate.
|
||||||
|
typ, err := lookupStructType(pkg.Scope(), cfg.Type) |
||||||
|
if err != nil { |
||||||
|
return nil, fmt.Errorf("can't find %s in %s: %v", typ, pkg, err) |
||||||
|
} |
||||||
|
code, err = bctx.generate(typ, cfg.GenerateEncoder, cfg.GenerateDecoder) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
|
||||||
|
// Add build comments.
|
||||||
|
// This is done here to avoid processing these lines with gofmt.
|
||||||
|
var header bytes.Buffer |
||||||
|
fmt.Fprint(&header, "// Code generated by rlpgen. DO NOT EDIT.\n\n") |
||||||
|
fmt.Fprint(&header, "//go:build !norlpgen\n") |
||||||
|
fmt.Fprint(&header, "// +build !norlpgen\n\n") |
||||||
|
return append(header.Bytes(), code...), nil |
||||||
|
} |
||||||
|
|
||||||
|
func lookupStructType(scope *types.Scope, name string) (*types.Named, error) { |
||||||
|
typ, err := lookupType(scope, name) |
||||||
|
if err != nil { |
||||||
|
return nil, err |
||||||
|
} |
||||||
|
_, ok := typ.Underlying().(*types.Struct) |
||||||
|
if !ok { |
||||||
|
return nil, errors.New("not a struct type") |
||||||
|
} |
||||||
|
return typ, nil |
||||||
|
} |
||||||
|
|
||||||
|
func lookupType(scope *types.Scope, name string) (*types.Named, error) { |
||||||
|
obj := scope.Lookup(name) |
||||||
|
if obj == nil { |
||||||
|
return nil, errors.New("no such identifier") |
||||||
|
} |
||||||
|
typ, ok := obj.(*types.TypeName) |
||||||
|
if !ok { |
||||||
|
return nil, errors.New("not a type") |
||||||
|
} |
||||||
|
return typ.Type().(*types.Named), nil |
||||||
|
} |
||||||
@ -0,0 +1,10 @@ |
|||||||
|
// -*- mode: go -*- |
||||||
|
|
||||||
|
package test |
||||||
|
|
||||||
|
import "math/big" |
||||||
|
|
||||||
|
type Test struct { |
||||||
|
Int *big.Int |
||||||
|
IntNoPtr big.Int |
||||||
|
} |
||||||
@ -0,0 +1,49 @@ |
|||||||
|
package test |
||||||
|
|
||||||
|
import "github.com/ethereum/go-ethereum/rlp" |
||||||
|
import "io" |
||||||
|
|
||||||
|
func (obj *Test) EncodeRLP(_w io.Writer) error { |
||||||
|
w := rlp.NewEncoderBuffer(_w) |
||||||
|
_tmp0 := w.List() |
||||||
|
if obj.Int == nil { |
||||||
|
w.Write(rlp.EmptyString) |
||||||
|
} else { |
||||||
|
if obj.Int.Sign() == -1 { |
||||||
|
return rlp.ErrNegativeBigInt |
||||||
|
} |
||||||
|
w.WriteBigInt(obj.Int) |
||||||
|
} |
||||||
|
if obj.IntNoPtr.Sign() == -1 { |
||||||
|
return rlp.ErrNegativeBigInt |
||||||
|
} |
||||||
|
w.WriteBigInt(&obj.IntNoPtr) |
||||||
|
w.ListEnd(_tmp0) |
||||||
|
return w.Flush() |
||||||
|
} |
||||||
|
|
||||||
|
func (obj *Test) DecodeRLP(dec *rlp.Stream) error { |
||||||
|
var _tmp0 Test |
||||||
|
{ |
||||||
|
if _, err := dec.List(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
// Int: |
||||||
|
_tmp1, err := dec.BigInt() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.Int = _tmp1 |
||||||
|
// IntNoPtr: |
||||||
|
_tmp2, err := dec.BigInt() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.IntNoPtr = (*_tmp2) |
||||||
|
if err := dec.ListEnd(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
*obj = _tmp0 |
||||||
|
return nil |
||||||
|
} |
||||||
@ -0,0 +1,30 @@ |
|||||||
|
// -*- mode: go -*- |
||||||
|
|
||||||
|
package test |
||||||
|
|
||||||
|
type Aux struct{ |
||||||
|
A uint32 |
||||||
|
} |
||||||
|
|
||||||
|
type Test struct{ |
||||||
|
Uint8 *byte `rlp:"nil"` |
||||||
|
Uint8List *byte `rlp:"nilList"` |
||||||
|
|
||||||
|
Uint32 *uint32 `rlp:"nil"` |
||||||
|
Uint32List *uint32 `rlp:"nilList"` |
||||||
|
|
||||||
|
Uint64 *uint64 `rlp:"nil"` |
||||||
|
Uint64List *uint64 `rlp:"nilList"` |
||||||
|
|
||||||
|
String *string `rlp:"nil"` |
||||||
|
StringList *string `rlp:"nilList"` |
||||||
|
|
||||||
|
ByteArray *[3]byte `rlp:"nil"` |
||||||
|
ByteArrayList *[3]byte `rlp:"nilList"` |
||||||
|
|
||||||
|
ByteSlice *[]byte `rlp:"nil"` |
||||||
|
ByteSliceList *[]byte `rlp:"nilList"` |
||||||
|
|
||||||
|
Struct *Aux `rlp:"nil"` |
||||||
|
StructString *Aux `rlp:"nilString"` |
||||||
|
} |
||||||
@ -0,0 +1,289 @@ |
|||||||
|
package test |
||||||
|
|
||||||
|
import "github.com/ethereum/go-ethereum/rlp" |
||||||
|
import "io" |
||||||
|
|
||||||
|
func (obj *Test) EncodeRLP(_w io.Writer) error { |
||||||
|
w := rlp.NewEncoderBuffer(_w) |
||||||
|
_tmp0 := w.List() |
||||||
|
if obj.Uint8 == nil { |
||||||
|
w.Write([]byte{0x80}) |
||||||
|
} else { |
||||||
|
w.WriteUint64(uint64((*obj.Uint8))) |
||||||
|
} |
||||||
|
if obj.Uint8List == nil { |
||||||
|
w.Write([]byte{0xC0}) |
||||||
|
} else { |
||||||
|
w.WriteUint64(uint64((*obj.Uint8List))) |
||||||
|
} |
||||||
|
if obj.Uint32 == nil { |
||||||
|
w.Write([]byte{0x80}) |
||||||
|
} else { |
||||||
|
w.WriteUint64(uint64((*obj.Uint32))) |
||||||
|
} |
||||||
|
if obj.Uint32List == nil { |
||||||
|
w.Write([]byte{0xC0}) |
||||||
|
} else { |
||||||
|
w.WriteUint64(uint64((*obj.Uint32List))) |
||||||
|
} |
||||||
|
if obj.Uint64 == nil { |
||||||
|
w.Write([]byte{0x80}) |
||||||
|
} else { |
||||||
|
w.WriteUint64((*obj.Uint64)) |
||||||
|
} |
||||||
|
if obj.Uint64List == nil { |
||||||
|
w.Write([]byte{0xC0}) |
||||||
|
} else { |
||||||
|
w.WriteUint64((*obj.Uint64List)) |
||||||
|
} |
||||||
|
if obj.String == nil { |
||||||
|
w.Write([]byte{0x80}) |
||||||
|
} else { |
||||||
|
w.WriteString((*obj.String)) |
||||||
|
} |
||||||
|
if obj.StringList == nil { |
||||||
|
w.Write([]byte{0xC0}) |
||||||
|
} else { |
||||||
|
w.WriteString((*obj.StringList)) |
||||||
|
} |
||||||
|
if obj.ByteArray == nil { |
||||||
|
w.Write([]byte{0x80}) |
||||||
|
} else { |
||||||
|
w.WriteBytes(obj.ByteArray[:]) |
||||||
|
} |
||||||
|
if obj.ByteArrayList == nil { |
||||||
|
w.Write([]byte{0xC0}) |
||||||
|
} else { |
||||||
|
w.WriteBytes(obj.ByteArrayList[:]) |
||||||
|
} |
||||||
|
if obj.ByteSlice == nil { |
||||||
|
w.Write([]byte{0x80}) |
||||||
|
} else { |
||||||
|
w.WriteBytes((*obj.ByteSlice)) |
||||||
|
} |
||||||
|
if obj.ByteSliceList == nil { |
||||||
|
w.Write([]byte{0xC0}) |
||||||
|
} else { |
||||||
|
w.WriteBytes((*obj.ByteSliceList)) |
||||||
|
} |
||||||
|
if obj.Struct == nil { |
||||||
|
w.Write([]byte{0xC0}) |
||||||
|
} else { |
||||||
|
_tmp1 := w.List() |
||||||
|
w.WriteUint64(uint64(obj.Struct.A)) |
||||||
|
w.ListEnd(_tmp1) |
||||||
|
} |
||||||
|
if obj.StructString == nil { |
||||||
|
w.Write([]byte{0x80}) |
||||||
|
} else { |
||||||
|
_tmp2 := w.List() |
||||||
|
w.WriteUint64(uint64(obj.StructString.A)) |
||||||
|
w.ListEnd(_tmp2) |
||||||
|
} |
||||||
|
w.ListEnd(_tmp0) |
||||||
|
return w.Flush() |
||||||
|
} |
||||||
|
|
||||||
|
func (obj *Test) DecodeRLP(dec *rlp.Stream) error { |
||||||
|
var _tmp0 Test |
||||||
|
{ |
||||||
|
if _, err := dec.List(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
// Uint8: |
||||||
|
var _tmp2 *byte |
||||||
|
if _tmp3, _tmp4, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp4 != 0 || _tmp3 != rlp.String { |
||||||
|
_tmp1, err := dec.Uint8() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp2 = &_tmp1 |
||||||
|
} |
||||||
|
_tmp0.Uint8 = _tmp2 |
||||||
|
// Uint8List: |
||||||
|
var _tmp6 *byte |
||||||
|
if _tmp7, _tmp8, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp8 != 0 || _tmp7 != rlp.List { |
||||||
|
_tmp5, err := dec.Uint8() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp6 = &_tmp5 |
||||||
|
} |
||||||
|
_tmp0.Uint8List = _tmp6 |
||||||
|
// Uint32: |
||||||
|
var _tmp10 *uint32 |
||||||
|
if _tmp11, _tmp12, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp12 != 0 || _tmp11 != rlp.String { |
||||||
|
_tmp9, err := dec.Uint32() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp10 = &_tmp9 |
||||||
|
} |
||||||
|
_tmp0.Uint32 = _tmp10 |
||||||
|
// Uint32List: |
||||||
|
var _tmp14 *uint32 |
||||||
|
if _tmp15, _tmp16, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp16 != 0 || _tmp15 != rlp.List { |
||||||
|
_tmp13, err := dec.Uint32() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp14 = &_tmp13 |
||||||
|
} |
||||||
|
_tmp0.Uint32List = _tmp14 |
||||||
|
// Uint64: |
||||||
|
var _tmp18 *uint64 |
||||||
|
if _tmp19, _tmp20, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp20 != 0 || _tmp19 != rlp.String { |
||||||
|
_tmp17, err := dec.Uint64() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp18 = &_tmp17 |
||||||
|
} |
||||||
|
_tmp0.Uint64 = _tmp18 |
||||||
|
// Uint64List: |
||||||
|
var _tmp22 *uint64 |
||||||
|
if _tmp23, _tmp24, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp24 != 0 || _tmp23 != rlp.List { |
||||||
|
_tmp21, err := dec.Uint64() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp22 = &_tmp21 |
||||||
|
} |
||||||
|
_tmp0.Uint64List = _tmp22 |
||||||
|
// String: |
||||||
|
var _tmp26 *string |
||||||
|
if _tmp27, _tmp28, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp28 != 0 || _tmp27 != rlp.String { |
||||||
|
_tmp25, err := dec.String() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp26 = &_tmp25 |
||||||
|
} |
||||||
|
_tmp0.String = _tmp26 |
||||||
|
// StringList: |
||||||
|
var _tmp30 *string |
||||||
|
if _tmp31, _tmp32, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp32 != 0 || _tmp31 != rlp.List { |
||||||
|
_tmp29, err := dec.String() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp30 = &_tmp29 |
||||||
|
} |
||||||
|
_tmp0.StringList = _tmp30 |
||||||
|
// ByteArray: |
||||||
|
var _tmp34 *[3]byte |
||||||
|
if _tmp35, _tmp36, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp36 != 0 || _tmp35 != rlp.String { |
||||||
|
var _tmp33 [3]byte |
||||||
|
if err := dec.ReadBytes(_tmp33[:]); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp34 = &_tmp33 |
||||||
|
} |
||||||
|
_tmp0.ByteArray = _tmp34 |
||||||
|
// ByteArrayList: |
||||||
|
var _tmp38 *[3]byte |
||||||
|
if _tmp39, _tmp40, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp40 != 0 || _tmp39 != rlp.List { |
||||||
|
var _tmp37 [3]byte |
||||||
|
if err := dec.ReadBytes(_tmp37[:]); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp38 = &_tmp37 |
||||||
|
} |
||||||
|
_tmp0.ByteArrayList = _tmp38 |
||||||
|
// ByteSlice: |
||||||
|
var _tmp42 *[]byte |
||||||
|
if _tmp43, _tmp44, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp44 != 0 || _tmp43 != rlp.String { |
||||||
|
_tmp41, err := dec.Bytes() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp42 = &_tmp41 |
||||||
|
} |
||||||
|
_tmp0.ByteSlice = _tmp42 |
||||||
|
// ByteSliceList: |
||||||
|
var _tmp46 *[]byte |
||||||
|
if _tmp47, _tmp48, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp48 != 0 || _tmp47 != rlp.List { |
||||||
|
_tmp45, err := dec.Bytes() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp46 = &_tmp45 |
||||||
|
} |
||||||
|
_tmp0.ByteSliceList = _tmp46 |
||||||
|
// Struct: |
||||||
|
var _tmp51 *Aux |
||||||
|
if _tmp52, _tmp53, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp53 != 0 || _tmp52 != rlp.List { |
||||||
|
var _tmp49 Aux |
||||||
|
{ |
||||||
|
if _, err := dec.List(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
// A: |
||||||
|
_tmp50, err := dec.Uint32() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp49.A = _tmp50 |
||||||
|
if err := dec.ListEnd(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
_tmp51 = &_tmp49 |
||||||
|
} |
||||||
|
_tmp0.Struct = _tmp51 |
||||||
|
// StructString: |
||||||
|
var _tmp56 *Aux |
||||||
|
if _tmp57, _tmp58, err := dec.Kind(); err != nil { |
||||||
|
return err |
||||||
|
} else if _tmp58 != 0 || _tmp57 != rlp.String { |
||||||
|
var _tmp54 Aux |
||||||
|
{ |
||||||
|
if _, err := dec.List(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
// A: |
||||||
|
_tmp55, err := dec.Uint32() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp54.A = _tmp55 |
||||||
|
if err := dec.ListEnd(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
_tmp56 = &_tmp54 |
||||||
|
} |
||||||
|
_tmp0.StructString = _tmp56 |
||||||
|
if err := dec.ListEnd(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
*obj = _tmp0 |
||||||
|
return nil |
||||||
|
} |
||||||
@ -0,0 +1,17 @@ |
|||||||
|
// -*- mode: go -*- |
||||||
|
|
||||||
|
package test |
||||||
|
|
||||||
|
type Aux struct { |
||||||
|
A uint64 |
||||||
|
} |
||||||
|
|
||||||
|
type Test struct { |
||||||
|
Uint64 uint64 `rlp:"optional"` |
||||||
|
Pointer *uint64 `rlp:"optional"` |
||||||
|
String string `rlp:"optional"` |
||||||
|
Slice []uint64 `rlp:"optional"` |
||||||
|
Array [3]byte `rlp:"optional"` |
||||||
|
NamedStruct Aux `rlp:"optional"` |
||||||
|
AnonStruct struct{ A string } `rlp:"optional"` |
||||||
|
} |
||||||
@ -0,0 +1,153 @@ |
|||||||
|
package test |
||||||
|
|
||||||
|
import "github.com/ethereum/go-ethereum/rlp" |
||||||
|
import "io" |
||||||
|
|
||||||
|
func (obj *Test) EncodeRLP(_w io.Writer) error { |
||||||
|
w := rlp.NewEncoderBuffer(_w) |
||||||
|
_tmp0 := w.List() |
||||||
|
_tmp1 := obj.Uint64 != 0 |
||||||
|
_tmp2 := obj.Pointer != nil |
||||||
|
_tmp3 := obj.String != "" |
||||||
|
_tmp4 := len(obj.Slice) > 0 |
||||||
|
_tmp5 := obj.Array != ([3]byte{}) |
||||||
|
_tmp6 := obj.NamedStruct != (Aux{}) |
||||||
|
_tmp7 := obj.AnonStruct != (struct{ A string }{}) |
||||||
|
if _tmp1 || _tmp2 || _tmp3 || _tmp4 || _tmp5 || _tmp6 || _tmp7 { |
||||||
|
w.WriteUint64(obj.Uint64) |
||||||
|
} |
||||||
|
if _tmp2 || _tmp3 || _tmp4 || _tmp5 || _tmp6 || _tmp7 { |
||||||
|
if obj.Pointer == nil { |
||||||
|
w.Write([]byte{0x80}) |
||||||
|
} else { |
||||||
|
w.WriteUint64((*obj.Pointer)) |
||||||
|
} |
||||||
|
} |
||||||
|
if _tmp3 || _tmp4 || _tmp5 || _tmp6 || _tmp7 { |
||||||
|
w.WriteString(obj.String) |
||||||
|
} |
||||||
|
if _tmp4 || _tmp5 || _tmp6 || _tmp7 { |
||||||
|
_tmp8 := w.List() |
||||||
|
for _, _tmp9 := range obj.Slice { |
||||||
|
w.WriteUint64(_tmp9) |
||||||
|
} |
||||||
|
w.ListEnd(_tmp8) |
||||||
|
} |
||||||
|
if _tmp5 || _tmp6 || _tmp7 { |
||||||
|
w.WriteBytes(obj.Array[:]) |
||||||
|
} |
||||||
|
if _tmp6 || _tmp7 { |
||||||
|
_tmp10 := w.List() |
||||||
|
w.WriteUint64(obj.NamedStruct.A) |
||||||
|
w.ListEnd(_tmp10) |
||||||
|
} |
||||||
|
if _tmp7 { |
||||||
|
_tmp11 := w.List() |
||||||
|
w.WriteString(obj.AnonStruct.A) |
||||||
|
w.ListEnd(_tmp11) |
||||||
|
} |
||||||
|
w.ListEnd(_tmp0) |
||||||
|
return w.Flush() |
||||||
|
} |
||||||
|
|
||||||
|
func (obj *Test) DecodeRLP(dec *rlp.Stream) error { |
||||||
|
var _tmp0 Test |
||||||
|
{ |
||||||
|
if _, err := dec.List(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
// Uint64: |
||||||
|
if dec.MoreDataInList() { |
||||||
|
_tmp1, err := dec.Uint64() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.Uint64 = _tmp1 |
||||||
|
// Pointer: |
||||||
|
if dec.MoreDataInList() { |
||||||
|
_tmp2, err := dec.Uint64() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.Pointer = &_tmp2 |
||||||
|
// String: |
||||||
|
if dec.MoreDataInList() { |
||||||
|
_tmp3, err := dec.String() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.String = _tmp3 |
||||||
|
// Slice: |
||||||
|
if dec.MoreDataInList() { |
||||||
|
var _tmp4 []uint64 |
||||||
|
if _, err := dec.List(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
for dec.MoreDataInList() { |
||||||
|
_tmp5, err := dec.Uint64() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp4 = append(_tmp4, _tmp5) |
||||||
|
} |
||||||
|
if err := dec.ListEnd(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.Slice = _tmp4 |
||||||
|
// Array: |
||||||
|
if dec.MoreDataInList() { |
||||||
|
var _tmp6 [3]byte |
||||||
|
if err := dec.ReadBytes(_tmp6[:]); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.Array = _tmp6 |
||||||
|
// NamedStruct: |
||||||
|
if dec.MoreDataInList() { |
||||||
|
var _tmp7 Aux |
||||||
|
{ |
||||||
|
if _, err := dec.List(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
// A: |
||||||
|
_tmp8, err := dec.Uint64() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp7.A = _tmp8 |
||||||
|
if err := dec.ListEnd(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
_tmp0.NamedStruct = _tmp7 |
||||||
|
// AnonStruct: |
||||||
|
if dec.MoreDataInList() { |
||||||
|
var _tmp9 struct{ A string } |
||||||
|
{ |
||||||
|
if _, err := dec.List(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
// A: |
||||||
|
_tmp10, err := dec.String() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp9.A = _tmp10 |
||||||
|
if err := dec.ListEnd(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
_tmp0.AnonStruct = _tmp9 |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
if err := dec.ListEnd(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
*obj = _tmp0 |
||||||
|
return nil |
||||||
|
} |
||||||
@ -0,0 +1,11 @@ |
|||||||
|
// -*- mode: go -*- |
||||||
|
|
||||||
|
package test |
||||||
|
|
||||||
|
import "github.com/ethereum/go-ethereum/rlp" |
||||||
|
|
||||||
|
type Test struct { |
||||||
|
RawValue rlp.RawValue |
||||||
|
PointerToRawValue *rlp.RawValue |
||||||
|
SliceOfRawValue []rlp.RawValue |
||||||
|
} |
||||||
@ -0,0 +1,64 @@ |
|||||||
|
package test |
||||||
|
|
||||||
|
import "github.com/ethereum/go-ethereum/rlp" |
||||||
|
import "io" |
||||||
|
|
||||||
|
func (obj *Test) EncodeRLP(_w io.Writer) error { |
||||||
|
w := rlp.NewEncoderBuffer(_w) |
||||||
|
_tmp0 := w.List() |
||||||
|
w.Write(obj.RawValue) |
||||||
|
if obj.PointerToRawValue == nil { |
||||||
|
w.Write([]byte{0x80}) |
||||||
|
} else { |
||||||
|
w.Write((*obj.PointerToRawValue)) |
||||||
|
} |
||||||
|
_tmp1 := w.List() |
||||||
|
for _, _tmp2 := range obj.SliceOfRawValue { |
||||||
|
w.Write(_tmp2) |
||||||
|
} |
||||||
|
w.ListEnd(_tmp1) |
||||||
|
w.ListEnd(_tmp0) |
||||||
|
return w.Flush() |
||||||
|
} |
||||||
|
|
||||||
|
func (obj *Test) DecodeRLP(dec *rlp.Stream) error { |
||||||
|
var _tmp0 Test |
||||||
|
{ |
||||||
|
if _, err := dec.List(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
// RawValue: |
||||||
|
_tmp1, err := dec.Raw() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.RawValue = _tmp1 |
||||||
|
// PointerToRawValue: |
||||||
|
_tmp2, err := dec.Raw() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.PointerToRawValue = &_tmp2 |
||||||
|
// SliceOfRawValue: |
||||||
|
var _tmp3 []rlp.RawValue |
||||||
|
if _, err := dec.List(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
for dec.MoreDataInList() { |
||||||
|
_tmp4, err := dec.Raw() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp3 = append(_tmp3, _tmp4) |
||||||
|
} |
||||||
|
if err := dec.ListEnd(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.SliceOfRawValue = _tmp3 |
||||||
|
if err := dec.ListEnd(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
*obj = _tmp0 |
||||||
|
return nil |
||||||
|
} |
||||||
@ -0,0 +1,10 @@ |
|||||||
|
// -*- mode: go -*- |
||||||
|
|
||||||
|
package test |
||||||
|
|
||||||
|
type Test struct{ |
||||||
|
A uint8 |
||||||
|
B uint16 |
||||||
|
C uint32 |
||||||
|
D uint64 |
||||||
|
} |
||||||
@ -0,0 +1,53 @@ |
|||||||
|
package test |
||||||
|
|
||||||
|
import "github.com/ethereum/go-ethereum/rlp" |
||||||
|
import "io" |
||||||
|
|
||||||
|
func (obj *Test) EncodeRLP(_w io.Writer) error { |
||||||
|
w := rlp.NewEncoderBuffer(_w) |
||||||
|
_tmp0 := w.List() |
||||||
|
w.WriteUint64(uint64(obj.A)) |
||||||
|
w.WriteUint64(uint64(obj.B)) |
||||||
|
w.WriteUint64(uint64(obj.C)) |
||||||
|
w.WriteUint64(obj.D) |
||||||
|
w.ListEnd(_tmp0) |
||||||
|
return w.Flush() |
||||||
|
} |
||||||
|
|
||||||
|
func (obj *Test) DecodeRLP(dec *rlp.Stream) error { |
||||||
|
var _tmp0 Test |
||||||
|
{ |
||||||
|
if _, err := dec.List(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
// A: |
||||||
|
_tmp1, err := dec.Uint8() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.A = _tmp1 |
||||||
|
// B: |
||||||
|
_tmp2, err := dec.Uint16() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.B = _tmp2 |
||||||
|
// C: |
||||||
|
_tmp3, err := dec.Uint32() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.C = _tmp3 |
||||||
|
// D: |
||||||
|
_tmp4, err := dec.Uint64() |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
_tmp0.D = _tmp4 |
||||||
|
if err := dec.ListEnd(); err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
} |
||||||
|
*obj = _tmp0 |
||||||
|
return nil |
||||||
|
} |
||||||
@ -0,0 +1,98 @@ |
|||||||
|
package main |
||||||
|
|
||||||
|
import ( |
||||||
|
"fmt" |
||||||
|
"go/types" |
||||||
|
"reflect" |
||||||
|
) |
||||||
|
|
||||||
|
// typeReflectKind gives the reflect.Kind that represents typ.
|
||||||
|
func typeReflectKind(typ types.Type) reflect.Kind { |
||||||
|
switch typ := typ.(type) { |
||||||
|
case *types.Basic: |
||||||
|
k := typ.Kind() |
||||||
|
if k >= types.Bool && k <= types.Complex128 { |
||||||
|
// value order matches for Bool..Complex128
|
||||||
|
return reflect.Bool + reflect.Kind(k-types.Bool) |
||||||
|
} |
||||||
|
if k == types.String { |
||||||
|
return reflect.String |
||||||
|
} |
||||||
|
if k == types.UnsafePointer { |
||||||
|
return reflect.UnsafePointer |
||||||
|
} |
||||||
|
panic(fmt.Errorf("unhandled BasicKind %v", k)) |
||||||
|
case *types.Array: |
||||||
|
return reflect.Array |
||||||
|
case *types.Chan: |
||||||
|
return reflect.Chan |
||||||
|
case *types.Interface: |
||||||
|
return reflect.Interface |
||||||
|
case *types.Map: |
||||||
|
return reflect.Map |
||||||
|
case *types.Pointer: |
||||||
|
return reflect.Ptr |
||||||
|
case *types.Signature: |
||||||
|
return reflect.Func |
||||||
|
case *types.Slice: |
||||||
|
return reflect.Slice |
||||||
|
case *types.Struct: |
||||||
|
return reflect.Struct |
||||||
|
default: |
||||||
|
panic(fmt.Errorf("unhandled type %T", typ)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// nonZeroCheck returns the expression that checks whether 'v' is a non-zero value of type 'vtyp'.
|
||||||
|
func nonZeroCheck(v string, vtyp types.Type, qualify types.Qualifier) string { |
||||||
|
// Resolve type name.
|
||||||
|
typ := resolveUnderlying(vtyp) |
||||||
|
switch typ := typ.(type) { |
||||||
|
case *types.Basic: |
||||||
|
k := typ.Kind() |
||||||
|
switch { |
||||||
|
case k == types.Bool: |
||||||
|
return v |
||||||
|
case k >= types.Uint && k <= types.Complex128: |
||||||
|
return fmt.Sprintf("%s != 0", v) |
||||||
|
case k == types.String: |
||||||
|
return fmt.Sprintf(`%s != ""`, v) |
||||||
|
default: |
||||||
|
panic(fmt.Errorf("unhandled BasicKind %v", k)) |
||||||
|
} |
||||||
|
case *types.Array, *types.Struct: |
||||||
|
return fmt.Sprintf("%s != (%s{})", v, types.TypeString(vtyp, qualify)) |
||||||
|
case *types.Interface, *types.Pointer, *types.Signature: |
||||||
|
return fmt.Sprintf("%s != nil", v) |
||||||
|
case *types.Slice, *types.Map: |
||||||
|
return fmt.Sprintf("len(%s) > 0", v) |
||||||
|
default: |
||||||
|
panic(fmt.Errorf("unhandled type %T", typ)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// isBigInt checks whether 'typ' is "math/big".Int.
|
||||||
|
func isBigInt(typ types.Type) bool { |
||||||
|
named, ok := typ.(*types.Named) |
||||||
|
if !ok { |
||||||
|
return false |
||||||
|
} |
||||||
|
name := named.Obj() |
||||||
|
return name.Pkg().Path() == "math/big" && name.Name() == "Int" |
||||||
|
} |
||||||
|
|
||||||
|
// isByte checks whether the underlying type of 'typ' is uint8.
|
||||||
|
func isByte(typ types.Type) bool { |
||||||
|
basic, ok := resolveUnderlying(typ).(*types.Basic) |
||||||
|
return ok && basic.Kind() == types.Uint8 |
||||||
|
} |
||||||
|
|
||||||
|
func resolveUnderlying(typ types.Type) types.Type { |
||||||
|
for { |
||||||
|
t := typ.Underlying() |
||||||
|
if t == typ { |
||||||
|
return t |
||||||
|
} |
||||||
|
typ = t |
||||||
|
} |
||||||
|
} |
||||||
Loading…
Reference in new issue