128 lines
2.4 KiB
Go
128 lines
2.4 KiB
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
|
|
}
|