path: root/ethchain/asm.go

package ethchain

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

func CompileInstr(s interface{}) ([]byte, error) {
    switch s.(type) {
    case string:
        str := s.(string)
        isOp := IsOpCode(str)
        if isOp {
            return []byte{OpCodes[str]}, nil
        }

        num := new(big.Int)
        _, success := num.SetString(str, 0)
        // Assume regular bytes during compilation
        if !success {
            num.SetBytes([]byte(str))
        } else {
            // tmp fix for 32 bytes
            n := ethutil.BigToBytes(num, 256)
            return n, nil
        }

        return num.Bytes(), nil
    case int:
        num := ethutil.BigToBytes(big.NewInt(int64(s.(int))), 256)
        return num, nil
    case []byte:
        return ethutil.BigD(s.([]byte)).Bytes(), nil
    }

    return nil, nil
}

// Script compilation functions
// Compiles strings to machine code
func Assemble(instructions ...interface{}) (script []byte) {
    //script = make([]string, len(instructions))

    for _, val := range instructions {
        instr, _ := CompileInstr(val)

        //script[i] = string(instr)
        script = append(script, instr...)
    }

    return
}

func Disassemble(script []byte) (asm []string) {
    pc := new(big.Int)
    for {
        if pc.Cmp(big.NewInt(int64(len(script)))) >= 0 {
            return
        }

        // Get the memory location of pc
        val := script[pc.Int64()]
        // Get the opcode (it must be an opcode!)
        op := OpCode(val)

        asm = append(asm, fmt.Sprintf("%v", op))

        switch op {
        case oPUSH: // Push PC+1 on to the stack
            pc.Add(pc, ethutil.Big1)
            data := script[pc.Int64() : pc.Int64()+32]
            val := ethutil.BigD(data)

            var b []byte
            if val.Int64() == 0 {
                b = []byte{0}
            } else {
                b = val.Bytes()
            }

            asm = append(asm, fmt.Sprintf("0x%x", b))

            pc.Add(pc, big.NewInt(31))
        case oPUSH20:
            pc.Add(pc, ethutil.Big1)
            data := script[pc.Int64() : pc.Int64()+20]
            val := ethutil.BigD(data)
            var b []byte
            if val.Int64() == 0 {
                b = []byte{0}
            } else {
                b = val.Bytes()
            }

            asm = append(asm, fmt.Sprintf("0x%x", b))

            pc.Add(pc, big.NewInt(19))
        }

        pc.Add(pc, ethutil.Big1)
    }

    return
}

func PreProcess(data string) (mainInput, initInput string) {
    // Regexp for parsing anything between brackets
    reg := "\\(\\)\\s*{([\\d\\w\\W\\n\\s]+?)}"
    mainReg := regexp.MustCompile("main" + reg)
    initReg := regexp.MustCompile("init" + reg)

    main := mainReg.FindStringSubmatch(data)
    if len(main) > 0 {
        mainInput = main[1]
    } else {
        mainInput = data
    }

    init := initReg.FindStringSubmatch(data)
    if len(init) > 0 {
        initInput = init[1]
    }

    return
}