plugeth/ethchain/stack.go

145 lines
2.6 KiB
Go
Raw Normal View History

2014-02-14 22:56:09 +00:00
package ethchain
import (
"fmt"
2014-03-20 21:51:20 +00:00
_ "github.com/ethereum/eth-go/ethutil"
2014-02-14 22:56:09 +00:00
"math/big"
)
type OpType int
const (
tNorm = iota
tData
tExtro
tCrypto
)
type TxCallback func(opType OpType) bool
// Simple push/pop stack mechanism
type Stack struct {
data []*big.Int
}
func NewStack() *Stack {
return &Stack{}
}
2014-04-11 17:29:57 +00:00
func (st *Stack) Data() []*big.Int {
return st.data
}
func (st *Stack) Len() int {
return len(st.data)
}
2014-02-14 22:56:09 +00:00
func (st *Stack) Pop() *big.Int {
str := st.data[len(st.data)-1]
copy(st.data[:len(st.data)-1], st.data[:len(st.data)-1])
st.data = st.data[:len(st.data)-1]
return str
}
func (st *Stack) Popn() (*big.Int, *big.Int) {
ints := st.data[len(st.data)-2:]
copy(st.data[:len(st.data)-2], st.data[:len(st.data)-2])
st.data = st.data[:len(st.data)-2]
return ints[0], ints[1]
}
func (st *Stack) Peek() *big.Int {
str := st.data[len(st.data)-1]
return str
}
func (st *Stack) Peekn() (*big.Int, *big.Int) {
ints := st.data[:2]
return ints[0], ints[1]
}
func (st *Stack) Push(d *big.Int) {
st.data = append(st.data, new(big.Int).Set(d))
}
2014-04-27 14:50:44 +00:00
func (st *Stack) Get(amount *big.Int) []*big.Int {
// offset + size <= len(data)
length := big.NewInt(int64(len(st.data)))
if amount.Cmp(length) <= 0 {
start := new(big.Int).Sub(length, amount)
return st.data[start.Int64():length.Int64()]
}
return nil
}
func (st *Stack) Print() {
fmt.Println("### stack ###")
if len(st.data) > 0 {
for i, val := range st.data {
fmt.Printf("%-3d %v\n", i, val)
}
} else {
fmt.Println("-- empty --")
}
fmt.Println("#############")
}
2014-03-20 21:51:20 +00:00
type Memory struct {
store []byte
2014-02-20 22:10:16 +00:00
}
2014-03-20 21:51:20 +00:00
func (m *Memory) Set(offset, size int64, value []byte) {
totSize := offset + size
2014-03-21 10:54:36 +00:00
lenSize := int64(len(m.store) - 1)
2014-03-20 21:51:20 +00:00
if totSize > lenSize {
// Calculate the diff between the sizes
diff := totSize - lenSize
if diff > 0 {
// Create a new empty slice and append it
2014-03-21 10:54:36 +00:00
newSlice := make([]byte, diff-1)
2014-03-20 21:51:20 +00:00
// Resize slice
m.store = append(m.store, newSlice...)
2014-02-19 10:35:17 +00:00
}
}
2014-03-21 10:54:36 +00:00
copy(m.store[offset:offset+size], value)
2014-03-20 21:51:20 +00:00
}
2014-06-13 10:45:11 +00:00
func (m *Memory) Resize(size uint64) {
if uint64(m.Len()) < size {
m.store = append(m.store, make([]byte, size-uint64(m.Len()))...)
}
}
2014-03-20 21:51:20 +00:00
func (m *Memory) Get(offset, size int64) []byte {
return m.store[offset : offset+size]
2014-02-14 22:56:09 +00:00
}
2014-03-21 10:54:36 +00:00
func (m *Memory) Len() int {
return len(m.store)
}
2014-04-11 17:29:57 +00:00
func (m *Memory) Data() []byte {
return m.store
}
2014-03-21 10:54:36 +00:00
func (m *Memory) Print() {
fmt.Printf("### mem %d bytes ###\n", len(m.store))
2014-03-21 10:54:36 +00:00
if len(m.store) > 0 {
addr := 0
for i := 0; i+32 <= len(m.store); i += 32 {
2014-04-11 01:03:14 +00:00
fmt.Printf("%03d: % x\n", addr, m.store[i:i+32])
addr++
}
2014-03-21 10:54:36 +00:00
} else {
fmt.Println("-- empty --")
}
fmt.Println("####################")
2014-03-21 10:54:36 +00:00
}