Changes 'compiler' to work with any type

2 files changed, 49 insertions, 27 deletions

diff --git a/ethchain/vm_test.go b/ethchain/vm_test.go
index 16cbf51b7..047531e09 100644
--- a/ethchain/vm_test.go
+++ b/ethchain/vm_test.go
@@ -2,7 +2,6 @@ package ethchain
 
 import (
 	"bytes"
-	"fmt"
 	"github.com/ethereum/eth-go/ethdb"
 	"github.com/ethereum/eth-go/ethutil"
 	"math/big"
@@ -130,27 +129,26 @@ func TestRun3(t *testing.T) {
 	})
 	tx := NewTransaction(ContractAddr, ethutil.Big("100000000000000000000000000000000000000000000000000"), script)
 	addr := tx.Hash()[12:]
-	fmt.Printf("addr contract %x\n", addr)
 	contract := MakeContract(tx, state)
 	state.UpdateContract(contract)
 
-	callerScript := Compile([]string{
-		"PUSH", "1337", // Argument
-		"PUSH", "65", // argument mem offset
+	callerScript := ethutil.Compile(
+		"PUSH", 1337, // Argument
+		"PUSH", 65, // argument mem offset
 		"MSTORE",
-		"PUSH", "64", // ret size
-		"PUSH", "0", // ret offset
-
-		"PUSH", "32", // arg size
-		"PUSH", "65", // arg offset
-		"PUSH", "1000", /// Gas
-		"PUSH", "0", /// value
-		"PUSH", string(addr), // Sender
+		"PUSH", 64, // ret size
+		"PUSH", 0, // ret offset
+
+		"PUSH", 32, // arg size
+		"PUSH", 65, // arg offset
+		"PUSH", 1000, /// Gas
+		"PUSH", 0, /// value
+		"PUSH", addr, // Sender
 		"CALL",
-		"PUSH", "64",
-		"PUSH", "0",
+		"PUSH", 64,
+		"PUSH", 0,
 		"RETURN",
-	})
+	)
 	callerTx := NewTransaction(ContractAddr, ethutil.Big("100000000000000000000000000000000000000000000000000"), callerScript)
 
 	// Contract addr as test address
diff --git a/ethutil/parsing.go b/ethutil/parsing.go
index f24402623..8929f0829 100644
--- a/ethutil/parsing.go
+++ b/ethutil/parsing.go
@@ -84,20 +84,30 @@ func IsOpCode(s string) bool {
 	return false
 }
 
-func CompileInstr(s string) ([]byte, error) {
-	isOp := IsOpCode(s)
-	if isOp {
-		return []byte{OpCodes[s]}, nil
-	}
+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))
+		}
 
-	num := new(big.Int)
-	_, success := num.SetString(s, 0)
-	// Assume regular bytes during compilation
-	if !success {
-		num.SetBytes([]byte(s))
+		return num.Bytes(), nil
+	case int:
+		return big.NewInt(int64(s.(int))).Bytes(), nil
+	case []byte:
+		return BigD(s.([]byte)).Bytes(), nil
 	}
 
-	return num.Bytes(), nil
+	return nil, nil
 }
 
 func Instr(instr string) (int, []string, error) {
@@ -118,3 +128,17 @@ func Instr(instr string) (int, []string, error) {
 
 	return op, args[1:7], nil
 }
+
+// Script compilation functions
+// Compiles strings to machine code
+func Compile(instructions ...interface{}) (script []string) {
+	script = make([]string, len(instructions))
+
+	for i, val := range instructions {
+		instr, _ := CompileInstr(val)
+
+		script[i] = string(instr)
+	}
+
+	return
+}