aboutsummaryrefslogtreecommitdiffstats
path: root/ethereum/repl_darwin.go
blob: 1b98c2150028a65809931d441ab0abefd3e09c1d (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
package main

// #cgo LDFLAGS: -lreadline
// #include <stdio.h>
// #include <stdlib.h>
// #include <readline/readline.h>
// #include <readline/history.h>
import "C"

import (
    "strings"
    "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))
}

var indentCount = 0
var str = ""

func (self *JSRepl) setIndent() {
    open := strings.Count(str, "{")
    open += strings.Count(str, "(")
    closed := strings.Count(str, "}")
    closed += strings.Count(str, ")")
    indentCount = open - closed
    if indentCount <= 0 {
        self.prompt = "> "
    } else {
        self.prompt = strings.Join(make([]string, indentCount*2), "..")
        self.prompt += " "
    }
}

func (self *JSRepl) read() {
L:
    for {
        switch result := readLine(&self.prompt); true {
        case result == nil:
            break L

        case *result != "":
            str += *result + "\n"

            self.setIndent()

            if indentCount <= 0 {
                if *result == "exit" {
                    self.Stop()
                    break L
                }

                addHistory(str) //allow user to recall this line

                self.parseInput(str)

                str = ""
            }
        }
    }
}

func (self *JSRepl) PrintValue(v interface{}) {
    method, _ := self.re.vm.Get("prettyPrint")
    v, err := self.re.vm.ToValue(v)
    if err == nil {
        method.Call(method, v)
    }
}