stack.go 3.22 KB
Newer Older
obscuren's avatar
obscuren committed
1
package vm
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

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) {
obscuren's avatar
obscuren committed
61
	ints := st.data[len(st.data)-2:]
62 63 64 65

	return ints[0], ints[1]
}

obscuren's avatar
obscuren committed
66
func (st *Stack) Swapn(n int) (*big.Int, *big.Int) {
obscuren's avatar
obscuren committed
67
	st.data[len(st.data)-n], st.data[len(st.data)-1] = st.data[len(st.data)-1], st.data[len(st.data)-n]
obscuren's avatar
obscuren committed
68

obscuren's avatar
obscuren committed
69
	return st.data[len(st.data)-n], st.data[len(st.data)-1]
obscuren's avatar
obscuren committed
70 71 72
}

func (st *Stack) Dupn(n int) *big.Int {
obscuren's avatar
obscuren committed
73
	st.Push(st.data[len(st.data)-n])
obscuren's avatar
obscuren committed
74 75 76 77

	return st.Peek()
}

78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
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
}

obscuren's avatar
obscuren committed
93 94 95 96 97 98
func (st *Stack) require(n int) {
	if st.Len() < n {
		panic(fmt.Sprintf("stack underflow (%d <=> %d)", st.Len(), n))
	}
}

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
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
}

obscuren's avatar
obscuren committed
115 116 117 118
func NewMemory() *Memory {
	return &Memory{nil}
}

obscuren's avatar
obscuren committed
119
func (m *Memory) Set(offset, size uint64, value []byte) {
obscuren's avatar
obscuren committed
120 121
	if len(value) > 0 {
		totSize := offset + size
obscuren's avatar
obscuren committed
122
		lenSize := uint64(len(m.store) - 1)
obscuren's avatar
obscuren committed
123 124 125 126 127 128 129 130 131
		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...)
			}
132
		}
obscuren's avatar
obscuren committed
133
		copy(m.store[offset:offset+size], value)
134 135 136 137 138 139 140 141 142
	}
}

func (m *Memory) Resize(size uint64) {
	if uint64(m.Len()) < size {
		m.store = append(m.store, make([]byte, size-uint64(m.Len()))...)
	}
}

obscuren's avatar
obscuren committed
143
func (self *Memory) Get(offset, size int64) (cpy []byte) {
obscuren's avatar
obscuren committed
144 145 146 147
	if size == 0 {
		return nil
	}

obscuren's avatar
obscuren committed
148 149
	if len(self.store) > int(offset) {
		cpy = make([]byte, size)
150
		copy(cpy, self.store[offset:offset+size])
obscuren's avatar
obscuren committed
151 152 153 154 155 156 157

		return
	}

	return
}

158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
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("####################")
}