Readline repl for linux & osx

ethereal/ui/gui.go

@@ -197,7 +197,7 @@ func (gui *Gui) update() {
 		case b := <-blockChan:
 			block := b.Resource.(*ethchain.Block)
 			if bytes.Compare(block.Coinbase, gui.addr) == 0 {
-				gui.setWalletValue(gui.eth.StateManager().ProcState().GetAccount(gui.addr).Amount, nil)
+				gui.setWalletValue(gui.eth.StateManager().CurrentState().GetAccount(gui.addr).Amount, nil)
 			}
 
 		case txMsg := <-txChan:

ethereum/ethereum.go

@@ -151,9 +151,9 @@ save these words so you can restore your account later: %s
 		console := NewConsole(ethereum)
 		go console.Start()
 	} else if StartJsConsole {
-		c := NewJSConsole(ethereum)
+		repl := NewJSRepl(ethereum)
 
-		go c.Start()
+		go repl.Start()
 	}
 
 	if StartRpc {

ethereum/javascript_console.go

 package main
 
 import (
-	"bufio"
 	"fmt"
 	"github.com/ethereum/eth-go"
 	"github.com/ethereum/eth-go/ethpub"
 	"github.com/robertkrimen/otto"
-	"os"
 )
 
-type JSConsole struct {
+type Repl interface {
+	Start()
+}
+
+type JSRE struct {
 	vm  *otto.Otto
 	lib *ethpub.PEthereum
 }
 
-func NewJSConsole(ethereum *eth.Ethereum) *JSConsole {
-	return &JSConsole{vm: otto.New(), lib: ethpub.NewPEthereum(ethereum)}
+func NewJSRE(ethereum *eth.Ethereum) *JSRE {
+	re := &JSRE{vm: otto.New(), lib: ethpub.NewPEthereum(ethereum)}
+
+	re.Bind("eth", &JSEthereum{re.lib, re.vm})
+
+	return re
+}
+
+func (self *JSRE) Bind(name string, v interface{}) {
+	self.vm.Set(name, v)
+}
+
+func (self *JSRE) Run(code string) (otto.Value, error) {
+	return self.vm.Run(code)
 }
 
-func (self *JSConsole) Start() {
-	self.initBindings()
+type JSRepl struct {
+	re *JSRE
+}
+
+func NewJSRepl(ethereum *eth.Ethereum) *JSRepl {
+	return &JSRepl{re: NewJSRE(ethereum)}
+}
 
+func (self *JSRepl) Start() {
 	fmt.Println("Eth JavaScript console")
-	reader := bufio.NewReader(os.Stdin)
-	for {
-		fmt.Printf("eth >>> ")
-		str, _, err := reader.ReadLine()
-		if err != nil {
-			fmt.Println("Error reading input", err)
-		} else {
-			self.ParseInput(string(str))
-		}
-	}
+	self.read()
 }
 
-func (self *JSConsole) ParseInput(code string) {
+func (self *JSRepl) parseInput(code string) {
 	defer func() {
 		if r := recover(); r != nil {
 			fmt.Println("[native] error", r)
 		}
 	}()
 
-	value, err := self.vm.Run(code)
+	value, err := self.re.Run(code)
 	if err != nil {
 		fmt.Println(err)
 		return
@@ -50,28 +61,22 @@ func (self *JSConsole) ParseInput(code string) {
 	fmt.Println(value)
 }
 
-func (self *JSConsole) initBindings() {
-	t := &JSWrapper{self.lib, self.vm}
-
-	self.vm.Set("eth", t)
-}
-
-// The JS wrapper attempts to wrap the PEthereum object and returns
-// proper javascript objects
-type JSWrapper struct {
+// The JSEthereum object attempts to wrap the PEthereum object and returns
+// meaningful javascript objects
+type JSEthereum struct {
 	*ethpub.PEthereum
 	vm *otto.Otto
 }
 
-func (self *JSWrapper) GetKey() otto.Value {
+func (self *JSEthereum) GetKey() otto.Value {
 	return self.toVal(self.PEthereum.GetKey())
 }
 
-func (self *JSWrapper) GetStateObject(addr string) otto.Value {
+func (self *JSEthereum) GetStateObject(addr string) otto.Value {
 	return self.toVal(self.PEthereum.GetStateObject(addr))
 }
 
-func (self *JSWrapper) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) otto.Value {
+func (self *JSEthereum) Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr string) otto.Value {
 	r, err := self.PEthereum.Transact(key, recipient, valueStr, gasStr, gasPriceStr, dataStr)
 	if err != nil {
 		fmt.Println(err)
@@ -82,7 +87,7 @@ func (self *JSWrapper) Transact(key, recipient, valueStr, gasStr, gasPriceStr, d
 	return self.toVal(r)
 }
 
-func (self *JSWrapper) Create(key, valueStr, gasStr, gasPriceStr, initStr, bodyStr string) otto.Value {
+func (self *JSEthereum) Create(key, valueStr, gasStr, gasPriceStr, initStr, bodyStr string) otto.Value {
 	r, err := self.PEthereum.Create(key, valueStr, gasStr, gasPriceStr, initStr, bodyStr)
 
 	if err != nil {
@@ -95,7 +100,7 @@ func (self *JSWrapper) Create(key, valueStr, gasStr, gasPriceStr, initStr, bodyS
 }
 
 // Wrapper function
-func (self *JSWrapper) toVal(v interface{}) otto.Value {
+func (self *JSEthereum) toVal(v interface{}) otto.Value {
 	result, err := self.vm.ToValue(v)
 
 	if err != nil {

ethereum/repl_darwin.go

+package main
+
+// #cgo LDFLAGS: -lreadline
+// #include <stdio.h>
+// #include <stdlib.h>
+// #include <readline/readline.h>
+// #include <readline/history.h>
+import "C"
+import "unsafe"
+
+func readLine(prompt *string) *string {
+	var p *C.char
+
+	//readline allows an empty prompt(NULL)
+	if prompt != nil {
+		p = C.CString(*prompt)
+	}
+
+	ret := C.readline(p)
+
+	if p != nil {
+		C.free(unsafe.Pointer(p))
+	}
+
+	if ret == nil {
+		return nil
+	} //EOF
+
+	s := C.GoString(ret)
+	C.free(unsafe.Pointer(ret))
+	return &s
+}
+
+func addHistory(s string) {
+	p := C.CString(s)
+	C.add_history(p)
+	C.free(unsafe.Pointer(p))
+}
+
+func (self *JSRepl) read() {
+	prompt := "eth >>> "
+
+L:
+	for {
+		switch result := readLine(&prompt); true {
+		case result == nil:
+			break L //exit loop
+
+		case *result != "": //ignore blank lines
+			addHistory(*result) //allow user to recall this line
+
+			self.parseInput(*result)
+		}
+	}
+}

ethereum/repl_linux.go

+repl_darwin.go
\ No newline at end of file

ethereum/repl_windows.go

+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+func (self *JSRepl) read() {
+	reader := bufio.NewReader(os.Stdin)
+	for {
+		fmt.Printf("eth >>> ")
+		str, _, err := reader.ReadLine()
+		if err != nil {
+			fmt.Println("Error reading input", err)
+		} else {
+			self.parseInput(string(str))
+		}
+	}
+}

utils/cmd.go

@@ -35,9 +35,11 @@ func DoMining(ethereum *eth.Ethereum) {
 		// Give it some time to connect with peers
 		time.Sleep(3 * time.Second)
 
-		for ethereum.IsUpToDate() == false {
-			time.Sleep(5 * time.Second)
-		}
+		/*
+			for ethereum.IsUpToDate() == false {
+				time.Sleep(5 * time.Second)
+			}
+		*/
 		log.Println("Miner started")
 
 		miner := ethminer.NewDefaultMiner(addr, ethereum)