179 lines
3.2 KiB
Go
179 lines
3.2 KiB
Go
package vm
|
|
|
|
import (
|
|
"fmt"
|
|
"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{}
|
|
}
|
|
|
|
func (st *Stack) Data() []*big.Int {
|
|
return st.data
|
|
}
|
|
|
|
func (st *Stack) Len() int {
|
|
return len(st.data)
|
|
}
|
|
|
|
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[len(st.data)-2:]
|
|
|
|
return ints[0], ints[1]
|
|
}
|
|
|
|
func (st *Stack) Swapn(n int) (*big.Int, *big.Int) {
|
|
st.data[len(st.data)-n], st.data[len(st.data)-1] = st.data[len(st.data)-1], st.data[len(st.data)-n]
|
|
|
|
return st.data[len(st.data)-n], st.data[len(st.data)-1]
|
|
}
|
|
|
|
func (st *Stack) Dupn(n int) *big.Int {
|
|
st.Push(st.data[len(st.data)-n])
|
|
|
|
return st.Peek()
|
|
}
|
|
|
|
func (st *Stack) Push(d *big.Int) {
|
|
st.data = append(st.data, new(big.Int).Set(d))
|
|
}
|
|
|
|
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) require(n int) {
|
|
if st.Len() < n {
|
|
panic(fmt.Sprintf("stack underflow (%d <=> %d)", st.Len(), n))
|
|
}
|
|
}
|
|
|
|
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("#############")
|
|
}
|
|
|
|
type Memory struct {
|
|
store []byte
|
|
}
|
|
|
|
func NewMemory() *Memory {
|
|
return &Memory{nil}
|
|
}
|
|
|
|
func (m *Memory) Set(offset, size uint64, value []byte) {
|
|
if len(value) > 0 {
|
|
totSize := offset + size
|
|
lenSize := uint64(len(m.store) - 1)
|
|
if totSize > lenSize {
|
|
// Calculate the diff between the sizes
|
|
diff := totSize - lenSize
|
|
if diff > 0 {
|
|
// Create a new empty slice and append it
|
|
newSlice := make([]byte, diff-1)
|
|
// Resize slice
|
|
m.store = append(m.store, newSlice...)
|
|
}
|
|
}
|
|
copy(m.store[offset:offset+size], value)
|
|
}
|
|
}
|
|
|
|
func (m *Memory) Resize(size uint64) {
|
|
if uint64(m.Len()) < size {
|
|
m.store = append(m.store, make([]byte, size-uint64(m.Len()))...)
|
|
}
|
|
}
|
|
|
|
func (self *Memory) Get(offset, size int64) (cpy []byte) {
|
|
if size == 0 {
|
|
return nil
|
|
}
|
|
|
|
if len(self.store) > int(offset) {
|
|
cpy = make([]byte, size)
|
|
copy(cpy, self.store[offset:offset+size])
|
|
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (m *Memory) Len() int {
|
|
return len(m.store)
|
|
}
|
|
|
|
func (m *Memory) Data() []byte {
|
|
return m.store
|
|
}
|
|
|
|
func (m *Memory) Print() {
|
|
fmt.Printf("### mem %d bytes ###\n", len(m.store))
|
|
if len(m.store) > 0 {
|
|
addr := 0
|
|
for i := 0; i+32 <= len(m.store); i += 32 {
|
|
fmt.Printf("%03d: % x\n", addr, m.store[i:i+32])
|
|
addr++
|
|
}
|
|
} else {
|
|
fmt.Println("-- empty --")
|
|
}
|
|
fmt.Println("####################")
|
|
}
|