go-ethereum/core/vm/stack.go

这个包是对虚拟机堆的定义，只用了fmt和math/big。

stack是堆栈操作的对象，出栈的Item被用作修改。

type Stack struct {
	data []*big.Int
}

这里可以看到，栈结构是big.Int的数组。Stack由于开头是大写，所以可以被包外访问。

func newstack() *Stack {
	return &Stack{data: make([]*big.Int, 0, 1024)}
}

创建一个新的栈结构，返回栈对象的指针。这里指定了1024为栈的深度，这也就是为什么以太坊的虚拟机调用层次不能超过1024。

func (st *Stack) Data() []*big.Int {
	return st.data
}

返回栈的data数组指针（其实就是栈的指针）。

func (st *Stack) push(d *big.Int) {
	// NOTE push limit (1024) is checked in baseCheck
	//stackItem := new(big.Int).Set(d)
	//st.data = append(st.data, stackItem)
	st.data = append(st.data, d)
}

需要一个big.Int的参数d,压入栈中，返回栈的指针。

func (st *Stack) pushN(ds ...*big.Int) {
	st.data = append(st.data, ds...)
}

压入多个值。

func (st *Stack) pop() (ret *big.Int) {
	ret = st.data[len(st.data)-1]
	st.data = st.data[:len(st.data)-1]
	return
}

弹出栈中的值，重定义栈为len-1的长度。

func (st *Stack) len() int {
	return len(st.data)
}

取栈的长度。

func (st *Stack) swap(n int) {
	st.data[st.len()-n], st.data[st.len()-1] = st.data[st.len()-1], st.data[st.len()-n]
}

交换栈顶元素和距离栈顶元素n距离的元素。

func (st *Stack) dup(pool *intPool, n int) {
	st.push(pool.get().Set(st.data[st.len()-n]))
}

intpool在这里定义go-ethereum/core/vm/intpool.go  ， intPool是一个大整数池，可以被所有big.Int操作重用。（不知道这样写有什么用）

func (st *Stack) peek() *big.Int {
	return st.data[st.len()-1]
}

返回栈顶元素的值，与pop不同，这时栈顶不变。

// Back returns the n'th item in stack
func (st *Stack) Back(n int) *big.Int {
	return st.data[st.len()-n-1]
}

返回距离栈顶元素n个的big.Int数值。

func (st *Stack) require(n int) error {
	if st.len() < n {
		return fmt.Errorf("stack underflow (%d <=> %d)", len(st.data), n)
	}
	return nil
}

如果栈长小于n，提示下溢，否则，返回nil（nil=NULL）。

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("#############")
}

输出栈的每一个元素值。

实现了栈的各种操作。