path: root/stack.go

package main

import (
    "fmt"
    "github.com/ethereum/ethutil-go"
    "math/big"
)

type OpCode byte

// Op codes
const (
    oSTOP           OpCode = 0x00
    oADD            OpCode = 0x01
    oMUL            OpCode = 0x02
    oSUB            OpCode = 0x03
    oDIV            OpCode = 0x04
    oSDIV           OpCode = 0x05
    oMOD            OpCode = 0x06
    oSMOD           OpCode = 0x07
    oEXP            OpCode = 0x08
    oNEG            OpCode = 0x09
    oLT             OpCode = 0x0a
    oLE             OpCode = 0x0b
    oGT             OpCode = 0x0c
    oGE             OpCode = 0x0d
    oEQ             OpCode = 0x0e
    oNOT            OpCode = 0x0f
    oMYADDRESS      OpCode = 0x10
    oTXSENDER       OpCode = 0x11
    oTXVALUE        OpCode = 0x12
    oTXFEE          OpCode = 0x13
    oTXDATAN        OpCode = 0x14
    oTXDATA         OpCode = 0x15
    oBLK_PREVHASH   OpCode = 0x16
    oBLK_COINBASE   OpCode = 0x17
    oBLK_TIMESTAMP  OpCode = 0x18
    oBLK_NUMBER     OpCode = 0x19
    oBLK_DIFFICULTY OpCode = 0x1a
    oSHA256         OpCode = 0x20
    oRIPEMD160      OpCode = 0x21
    oECMUL          OpCode = 0x22
    oECADD          OpCode = 0x23
    oECSIGN         OpCode = 0x24
    oECRECOVER      OpCode = 0x25
    oECVALID        OpCode = 0x26
    oPUSH           OpCode = 0x30
    oPOP            OpCode = 0x31
    oDUP            OpCode = 0x32
    oDUPN           OpCode = 0x33
    oSWAP           OpCode = 0x34
    oSWAPN          OpCode = 0x35
    oLOAD           OpCode = 0x36
    oSTORE          OpCode = 0x37
    oJMP            OpCode = 0x40
    oJMPI           OpCode = 0x41
    oIND            OpCode = 0x42
    oEXTRO          OpCode = 0x50
    oBALANCE        OpCode = 0x51
    oMKTX           OpCode = 0x60
    oSUICIDE        OpCode = 0xff
)

// Since the opcodes aren't all in order we can't use a regular slice
var opCodeToString = map[OpCode]string{
    oSTOP:           "STOP",
    oADD:            "ADD",
    oMUL:            "MUL",
    oSUB:            "SUB",
    oDIV:            "DIV",
    oSDIV:           "SDIV",
    oMOD:            "MOD",
    oSMOD:           "SMOD",
    oEXP:            "EXP",
    oNEG:            "NEG",
    oLT:             "LT",
    oLE:             "LE",
    oGT:             "GT",
    oGE:             "GE",
    oEQ:             "EQ",
    oNOT:            "NOT",
    oMYADDRESS:      "MYADDRESS",
    oTXSENDER:       "TXSENDER",
    oTXVALUE:        "TXVALUE",
    oTXFEE:          "TXFEE",
    oTXDATAN:        "TXDATAN",
    oTXDATA:         "TXDATA",
    oBLK_PREVHASH:   "BLK_PREVHASH",
    oBLK_COINBASE:   "BLK_COINBASE",
    oBLK_TIMESTAMP:  "BLK_TIMESTAMP",
    oBLK_NUMBER:     "BLK_NUMBER",
    oBLK_DIFFICULTY: "BLK_DIFFIFULTY",
    oSHA256:         "SHA256",
    oRIPEMD160:      "RIPEMD160",
    oECMUL:          "ECMUL",
    oECADD:          "ECADD",
    oECSIGN:         "ECSIGN",
    oECRECOVER:      "ECRECOVER",
    oECVALID:        "ECVALID",
    oPUSH:           "PUSH",
    oPOP:            "POP",
    oDUP:            "DUP",
    oDUPN:           "DUPN",
    oSWAP:           "SWAP",
    oSWAPN:          "SWAPN",
    oLOAD:           "LOAD",
    oSTORE:          "STORE",
    oJMP:            "JMP",
    oJMPI:           "JMPI",
    oIND:            "IND",
    oEXTRO:          "EXTRO",
    oBALANCE:        "BALANCE",
    oMKTX:           "MKTX",
    oSUICIDE:        "SUICIDE",
}

func (o OpCode) String() string {
    return opCodeToString[o]
}

type OpType int

const (
    tNorm = iota
    tData
    tExtro
    tCrypto
)

type TxCallback func(opType OpType) bool

// Simple push/pop stack mechanism
type Stack struct {
    data []string
}

func NewStack() *Stack {
    return &Stack{}
}

func (st *Stack) Pop() string {
    s := len(st.data)

    str := st.data[s-1]
    st.data = st.data[:s-1]

    return str
}

func (st *Stack) Popn() (*big.Int, *big.Int) {
    s := len(st.data)

    strs := st.data[s-2:]
    st.data = st.data[:s-2]

    return ethutil.Big(strs[0]), ethutil.Big(strs[1])
}

func (st *Stack) Push(d string) {
    st.data = append(st.data, d)
}
func (st *Stack) Print() {
    fmt.Println(st.data)
}