forked from robertkrimen/otto
/
otto_.go
138 lines (123 loc) · 2.77 KB
/
otto_.go
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
package otto
import (
"fmt"
"math"
"regexp"
runtime_ "runtime"
"strconv"
"strings"
)
var isIdentifier_Regexp *regexp.Regexp = regexp.MustCompile(`^[a-zA-Z\$][a-zA-Z0-9\$]*$`)
func isIdentifier(string_ string) bool {
return isIdentifier_Regexp.MatchString(string_)
}
func toValueArray(arguments ...interface{}) []Value {
length := len(arguments)
if length == 1 {
if valueArray, ok := arguments[0].([]Value); ok {
return valueArray
}
return []Value{toValue(arguments[0])}
}
valueArray := make([]Value, length)
for index, value := range arguments {
valueArray[index] = toValue(value)
}
return valueArray
}
func stringToArrayIndex(name string) int64 {
index, err := strconv.ParseInt(name, 10, 64)
if err != nil {
return -1
}
if index < 0 {
return -1
}
if index > integer_2_32 {
return -1 // Bigger than an unsigned 32-bit integer
}
return index
}
func arrayIndexToString(index uint) string {
return strconv.FormatInt(int64(index), 10)
}
func valueOfArrayIndex(list []Value, index int) Value {
if index >= 0 && index < len(list) {
value := list[index]
if !value.isEmpty() {
return value
}
}
return UndefinedValue()
}
func valueToArrayIndex(indexValue Value, length uint, negativeIsZero bool) uint {
index := toIntegerFloat(indexValue)
if !negativeIsZero {
if 0 > length {
return uint(index)
}
if 0 > index {
index = math.Max(index+float64(length), 0)
} else {
index = math.Min(index, float64(length))
}
return uint(index)
}
{
index := uint(math.Max(index, 0))
if 0 > length {
return index
}
// minimum(index, length)
if index > length {
return length
}
return index
}
}
func dbg(arguments ...interface{}) {
output := []string{}
for _, argument := range arguments {
output = append(output, fmt.Sprintf("%v", argument))
}
fmt.Println(strings.Join(output, " "))
}
func boolFields(input string) (result map[string]bool) {
result = map[string]bool{}
for _, word := range strings.Fields(input) {
result[word] = true
}
return result
}
func hereBeDragons(arguments ...interface{}) string {
pc, _, _, _ := runtime_.Caller(1)
name := runtime_.FuncForPC(pc).Name()
message := fmt.Sprintf("Here be dragons -- %s", name)
if len(arguments) > 0 {
message += ": "
argument0 := fmt.Sprintf("%s", arguments[0])
if len(arguments) == 1 {
message += argument0
} else {
message += fmt.Sprintf(argument0, arguments[1:]...)
}
} else {
message += "."
}
return message
}
func throwHereBeDragons(arguments ...interface{}) {
panic(hereBeDragons(arguments...))
}
func eachPair(list []interface{}, fn func(_0, _1 interface{})) {
for len(list) > 0 {
var _0, _1 interface{}
_0 = list[0]
list = list[1:] // Pop off first
if len(list) > 0 {
_1 = list[0]
list = list[1:] // Pop off second
}
fn(_0, _1)
}
}