Bläddra i källkod

Fix for 32 bit platforms.

Dmitry Panov 9 år sedan
förälder
incheckning
df256e035d
14 ändrade filer med 201 tillägg och 213 borttagningar
  1. 44 44
      array.go
  2. 21 21
      array_sparse.go
  3. 16 15
      builtin_array.go
  4. 24 37
      builtin_string.go
  5. 7 7
      object.go
  6. 7 7
      object_gomap.go
  7. 21 21
      object_goslice.go
  8. 23 23
      object_goslice_reflect.go
  9. 3 3
      object_lazy.go
  10. 4 4
      regexp.go
  11. 2 2
      runtime.go
  12. 10 10
      string.go
  13. 10 10
      string_ascii.go
  14. 9 9
      string_unicode.go

+ 44 - 44
array.go

@@ -9,8 +9,8 @@ import (
 type arrayObject struct {
 type arrayObject struct {
 	baseObject
 	baseObject
 	values         []Value
 	values         []Value
-	length         int
-	objCount       int
+	length         int64
+	objCount       int64
 	propValueCount int
 	propValueCount int
 	lengthProp     valueProperty
 	lengthProp     valueProperty
 }
 }
@@ -23,20 +23,20 @@ func (a *arrayObject) init() {
 }
 }
 
 
 func (a *arrayObject) getLength() Value {
 func (a *arrayObject) getLength() Value {
-	return intToValue(int64(a.length))
+	return intToValue(a.length)
 }
 }
 
 
-func (a *arrayObject) _setLengthInt(l int, throw bool) bool {
+func (a *arrayObject) _setLengthInt(l int64, throw bool) bool {
 	if l >= 0 && l <= math.MaxUint32 {
 	if l >= 0 && l <= math.MaxUint32 {
 		ret := true
 		ret := true
 		if l <= a.length {
 		if l <= a.length {
 			if a.propValueCount > 0 {
 			if a.propValueCount > 0 {
 				// Slow path
 				// Slow path
-				var s int
-				if a.length < len(a.values) {
+				var s int64
+				if a.length < int64(len(a.values)) {
 					s = a.length - 1
 					s = a.length - 1
 				} else {
 				} else {
-					s = len(a.values) - 1
+					s = int64(len(a.values)) - 1
 				}
 				}
 				for i := s; i >= l; i-- {
 				for i := s; i >= l; i-- {
 					if prop, ok := a.values[i].(*valueProperty); ok {
 					if prop, ok := a.values[i].(*valueProperty); ok {
@@ -50,8 +50,8 @@ func (a *arrayObject) _setLengthInt(l int, throw bool) bool {
 				}
 				}
 			}
 			}
 		}
 		}
-		if l <= len(a.values) {
-			if l >= 16 && l < cap(a.values)>>2 {
+		if l <= int64(len(a.values)) {
+			if l >= 16 && l < int64(cap(a.values))>>2 {
 				ar := make([]Value, l)
 				ar := make([]Value, l)
 				copy(ar, a.values)
 				copy(ar, a.values)
 				a.values = ar
 				a.values = ar
@@ -73,19 +73,19 @@ func (a *arrayObject) _setLengthInt(l int, throw bool) bool {
 }
 }
 
 
 func (a *arrayObject) setLengthInt(l int64, throw bool) bool {
 func (a *arrayObject) setLengthInt(l int64, throw bool) bool {
-	if l == int64(a.length) {
+	if l == a.length {
 		return true
 		return true
 	}
 	}
 	if !a.lengthProp.writable {
 	if !a.lengthProp.writable {
 		a.val.runtime.typeErrorResult(throw, "length is not writable")
 		a.val.runtime.typeErrorResult(throw, "length is not writable")
 		return false
 		return false
 	}
 	}
-	return a._setLengthInt(int(l), throw)
+	return a._setLengthInt(l, throw)
 }
 }
 
 
 func (a *arrayObject) setLength(v Value, throw bool) bool {
 func (a *arrayObject) setLength(v Value, throw bool) bool {
 	l, ok := toIntIgnoreNegZero(v)
 	l, ok := toIntIgnoreNegZero(v)
-	if ok && l == int64(a.length) {
+	if ok && l == a.length {
 		return true
 		return true
 	}
 	}
 	if !a.lengthProp.writable {
 	if !a.lengthProp.writable {
@@ -93,13 +93,13 @@ func (a *arrayObject) setLength(v Value, throw bool) bool {
 		return false
 		return false
 	}
 	}
 	if ok {
 	if ok {
-		return a._setLengthInt(int(l), throw)
+		return a._setLengthInt(l, throw)
 	}
 	}
 	panic(a.val.runtime.newError(a.val.runtime.global.RangeError, "Invalid array length"))
 	panic(a.val.runtime.newError(a.val.runtime.global.RangeError, "Invalid array length"))
 }
 }
 
 
-func (a *arrayObject) getIdx(idx int, origNameStr string, origName Value) (v Value) {
-	if idx >= 0 && idx < len(a.values) {
+func (a *arrayObject) getIdx(idx int64, origNameStr string, origName Value) (v Value) {
+	if idx >= 0 && idx < int64(len(a.values)) {
 		v = a.values[idx]
 		v = a.values[idx]
 	}
 	}
 	if v == nil && a.prototype != nil {
 	if v == nil && a.prototype != nil {
@@ -112,11 +112,11 @@ func (a *arrayObject) getIdx(idx int, origNameStr string, origName Value) (v Val
 	return
 	return
 }
 }
 
 
-func (a *arrayObject) sortLen() int {
-	return len(a.values)
+func (a *arrayObject) sortLen() int64 {
+	return int64(len(a.values))
 }
 }
 
 
-func (a *arrayObject) sortGet(i int) Value {
+func (a *arrayObject) sortGet(i int64) Value {
 	v := a.values[i]
 	v := a.values[i]
 	if p, ok := v.(*valueProperty); ok {
 	if p, ok := v.(*valueProperty); ok {
 		v = p.get(a.val)
 		v = p.get(a.val)
@@ -124,33 +124,33 @@ func (a *arrayObject) sortGet(i int) Value {
 	return v
 	return v
 }
 }
 
 
-func (a *arrayObject) swap(i, j int) {
+func (a *arrayObject) swap(i, j int64) {
 	a.values[i], a.values[j] = a.values[j], a.values[i]
 	a.values[i], a.values[j] = a.values[j], a.values[i]
 }
 }
 
 
-func toIdx(v Value) int {
-	idx := -1
+func toIdx(v Value) (idx int64) {
+	idx = -1
 	if idxVal, ok1 := v.(valueInt); ok1 {
 	if idxVal, ok1 := v.(valueInt); ok1 {
-		idx = int(idxVal)
+		idx = int64(idxVal)
 	} else {
 	} else {
-		if i, err := strconv.Atoi(v.String()); err == nil {
+		if i, err := strconv.ParseInt(v.String(), 10, 64); err == nil {
 			idx = i
 			idx = i
 		}
 		}
 	}
 	}
 	if idx >= 0 && idx < math.MaxUint32 {
 	if idx >= 0 && idx < math.MaxUint32 {
-		return idx
+		return
 	}
 	}
 	return -1
 	return -1
 }
 }
 
 
-func strToIdx(s string) int {
-	idx := -1
-	if i, err := strconv.Atoi(s); err == nil {
+func strToIdx(s string) (idx int64) {
+	idx = -1
+	if i, err := strconv.ParseInt(s, 10, 64); err == nil {
 		idx = i
 		idx = i
 	}
 	}
 
 
 	if idx >= 0 && idx < math.MaxUint32 {
 	if idx >= 0 && idx < math.MaxUint32 {
-		return idx
+		return
 	}
 	}
 	return -1
 	return -1
 }
 }
@@ -167,7 +167,7 @@ func (a *arrayObject) getProp(n Value) Value {
 }
 }
 
 
 func (a *arrayObject) getLengthProp() Value {
 func (a *arrayObject) getLengthProp() Value {
-	a.lengthProp.value = intToValue(int64(a.length))
+	a.lengthProp.value = intToValue(a.length)
 	return &a.lengthProp
 	return &a.lengthProp
 }
 }
 
 
@@ -183,7 +183,7 @@ func (a *arrayObject) getPropStr(name string) Value {
 
 
 func (a *arrayObject) getOwnProp(name string) Value {
 func (a *arrayObject) getOwnProp(name string) Value {
 	if i := strToIdx(name); i >= 0 {
 	if i := strToIdx(name); i >= 0 {
-		if i >= 0 && i < len(a.values) {
+		if i >= 0 && i < int64(len(a.values)) {
 			return a.values[i]
 			return a.values[i]
 		}
 		}
 	}
 	}
@@ -193,9 +193,9 @@ func (a *arrayObject) getOwnProp(name string) Value {
 	return a.baseObject.getOwnProp(name)
 	return a.baseObject.getOwnProp(name)
 }
 }
 
 
-func (a *arrayObject) putIdx(idx int, val Value, throw bool, origNameStr string, origName Value) {
+func (a *arrayObject) putIdx(idx int64, val Value, throw bool, origNameStr string, origName Value) {
 	var prop Value
 	var prop Value
-	if idx < len(a.values) {
+	if idx < int64(len(a.values)) {
 		prop = a.values[idx]
 		prop = a.values[idx]
 	}
 	}
 
 
@@ -224,11 +224,11 @@ func (a *arrayObject) putIdx(idx int, val Value, throw bool, origNameStr string,
 			return
 			return
 		}
 		}
 		if idx >= a.length {
 		if idx >= a.length {
-			if !a.setLengthInt(int64(idx+1), throw) {
+			if !a.setLengthInt(idx+1, throw) {
 				return
 				return
 			}
 			}
 		}
 		}
-		if idx >= len(a.values) {
+		if idx >= int64(len(a.values)) {
 			if !a.expand(idx) {
 			if !a.expand(idx) {
 				a.val.self.(*sparseArrayObject).putIdx(idx, val, throw, origNameStr, origName)
 				a.val.self.(*sparseArrayObject).putIdx(idx, val, throw, origNameStr, origName)
 				return
 				return
@@ -309,7 +309,7 @@ func (a *arrayObject) enumerate(all, recursive bool) iterNextFunc {
 
 
 func (a *arrayObject) hasOwnProperty(n Value) bool {
 func (a *arrayObject) hasOwnProperty(n Value) bool {
 	if idx := toIdx(n); idx >= 0 {
 	if idx := toIdx(n); idx >= 0 {
-		return idx < len(a.values) && a.values[idx] != nil && a.values[idx] != _undefined
+		return idx < int64(len(a.values)) && a.values[idx] != nil && a.values[idx] != _undefined
 	} else {
 	} else {
 		return a.baseObject.hasOwnProperty(n)
 		return a.baseObject.hasOwnProperty(n)
 	}
 	}
@@ -317,16 +317,16 @@ func (a *arrayObject) hasOwnProperty(n Value) bool {
 
 
 func (a *arrayObject) hasOwnPropertyStr(name string) bool {
 func (a *arrayObject) hasOwnPropertyStr(name string) bool {
 	if idx := strToIdx(name); idx >= 0 {
 	if idx := strToIdx(name); idx >= 0 {
-		return idx < len(a.values) && a.values[idx] != nil && a.values[idx] != _undefined
+		return idx < int64(len(a.values)) && a.values[idx] != nil && a.values[idx] != _undefined
 	} else {
 	} else {
 		return a.baseObject.hasOwnPropertyStr(name)
 		return a.baseObject.hasOwnPropertyStr(name)
 	}
 	}
 }
 }
 
 
-func (a *arrayObject) expand(idx int) bool {
+func (a *arrayObject) expand(idx int64) bool {
 	targetLen := idx + 1
 	targetLen := idx + 1
-	if targetLen > len(a.values) {
-		if targetLen < cap(a.values) {
+	if targetLen > int64(len(a.values)) {
+		if targetLen < int64(cap(a.values)) {
 			a.values = a.values[:targetLen]
 			a.values = a.values[:targetLen]
 		} else {
 		} else {
 			if idx > 4096 && (a.objCount == 0 || idx/a.objCount > 10) {
 			if idx > 4096 && (a.objCount == 0 || idx/a.objCount > 10) {
@@ -342,7 +342,7 @@ func (a *arrayObject) expand(idx int) bool {
 				return false
 				return false
 			} else {
 			} else {
 				// Use the same algorithm as in runtime.growSlice
 				// Use the same algorithm as in runtime.growSlice
-				newcap := cap(a.values)
+				newcap := int64(cap(a.values))
 				doublecap := newcap + newcap
 				doublecap := newcap + newcap
 				if targetLen > doublecap {
 				if targetLen > doublecap {
 					newcap = targetLen
 					newcap = targetLen
@@ -416,13 +416,13 @@ Reject:
 func (a *arrayObject) defineOwnProperty(n Value, descr objectImpl, throw bool) bool {
 func (a *arrayObject) defineOwnProperty(n Value, descr objectImpl, throw bool) bool {
 	if idx := toIdx(n); idx >= 0 {
 	if idx := toIdx(n); idx >= 0 {
 		var existing Value
 		var existing Value
-		if idx < len(a.values) {
+		if idx < int64(len(a.values)) {
 			existing = a.values[idx]
 			existing = a.values[idx]
 		}
 		}
 		prop, ok := a.baseObject._defineOwnProperty(n, existing, descr, throw)
 		prop, ok := a.baseObject._defineOwnProperty(n, existing, descr, throw)
 		if ok {
 		if ok {
 			if idx >= a.length {
 			if idx >= a.length {
-				if !a.setLengthInt(int64(idx+1), throw) {
+				if !a.setLengthInt(idx+1, throw) {
 					return false
 					return false
 				}
 				}
 			}
 			}
@@ -445,8 +445,8 @@ func (a *arrayObject) defineOwnProperty(n Value, descr objectImpl, throw bool) b
 	}
 	}
 }
 }
 
 
-func (a *arrayObject) _deleteProp(idx int, throw bool) bool {
-	if idx < len(a.values) {
+func (a *arrayObject) _deleteProp(idx int64, throw bool) bool {
+	if idx < int64(len(a.values)) {
 		if v := a.values[idx]; v != nil {
 		if v := a.values[idx]; v != nil {
 			if p, ok := v.(*valueProperty); ok {
 			if p, ok := v.(*valueProperty); ok {
 				if !p.configurable {
 				if !p.configurable {

+ 21 - 21
array_sparse.go

@@ -8,14 +8,14 @@ import (
 )
 )
 
 
 type sparseArrayItem struct {
 type sparseArrayItem struct {
-	idx   int
+	idx   int64
 	value Value
 	value Value
 }
 }
 
 
 type sparseArrayObject struct {
 type sparseArrayObject struct {
 	baseObject
 	baseObject
 	items          []sparseArrayItem
 	items          []sparseArrayItem
-	length         int
+	length         int64
 	propValueCount int
 	propValueCount int
 	lengthProp     valueProperty
 	lengthProp     valueProperty
 }
 }
@@ -28,16 +28,16 @@ func (a *sparseArrayObject) init() {
 }
 }
 
 
 func (a *sparseArrayObject) getLength() Value {
 func (a *sparseArrayObject) getLength() Value {
-	return intToValue(int64(a.length))
+	return intToValue(a.length)
 }
 }
 
 
-func (a *sparseArrayObject) findIdx(idx int) int {
+func (a *sparseArrayObject) findIdx(idx int64) int {
 	return sort.Search(len(a.items), func(i int) bool {
 	return sort.Search(len(a.items), func(i int) bool {
 		return a.items[i].idx >= idx
 		return a.items[i].idx >= idx
 	})
 	})
 }
 }
 
 
-func (a *sparseArrayObject) _setLengthInt(l int, throw bool) bool {
+func (a *sparseArrayObject) _setLengthInt(l int64, throw bool) bool {
 	if l >= 0 && l <= math.MaxUint32 {
 	if l >= 0 && l <= math.MaxUint32 {
 		ret := true
 		ret := true
 
 
@@ -78,19 +78,19 @@ func (a *sparseArrayObject) _setLengthInt(l int, throw bool) bool {
 }
 }
 
 
 func (a *sparseArrayObject) setLengthInt(l int64, throw bool) bool {
 func (a *sparseArrayObject) setLengthInt(l int64, throw bool) bool {
-	if l == int64(a.length) {
+	if l == a.length {
 		return true
 		return true
 	}
 	}
 	if !a.lengthProp.writable {
 	if !a.lengthProp.writable {
 		a.val.runtime.typeErrorResult(throw, "length is not writable")
 		a.val.runtime.typeErrorResult(throw, "length is not writable")
 		return false
 		return false
 	}
 	}
-	return a._setLengthInt(int(l), throw)
+	return a._setLengthInt(l, throw)
 }
 }
 
 
 func (a *sparseArrayObject) setLength(v Value, throw bool) bool {
 func (a *sparseArrayObject) setLength(v Value, throw bool) bool {
 	l, ok := toIntIgnoreNegZero(v)
 	l, ok := toIntIgnoreNegZero(v)
-	if ok && l == int64(a.length) {
+	if ok && l == a.length {
 		return true
 		return true
 	}
 	}
 	if !a.lengthProp.writable {
 	if !a.lengthProp.writable {
@@ -98,12 +98,12 @@ func (a *sparseArrayObject) setLength(v Value, throw bool) bool {
 		return false
 		return false
 	}
 	}
 	if ok {
 	if ok {
-		return a._setLengthInt(int(l), throw)
+		return a._setLengthInt(l, throw)
 	}
 	}
 	panic(a.val.runtime.newError(a.val.runtime.global.RangeError, "Invalid array length"))
 	panic(a.val.runtime.newError(a.val.runtime.global.RangeError, "Invalid array length"))
 }
 }
 
 
-func (a *sparseArrayObject) getIdx(idx int, origNameStr string, origName Value) (v Value) {
+func (a *sparseArrayObject) getIdx(idx int64, origNameStr string, origName Value) (v Value) {
 	i := a.findIdx(idx)
 	i := a.findIdx(idx)
 	if i < len(a.items) && a.items[i].idx == idx {
 	if i < len(a.items) && a.items[i].idx == idx {
 		return a.items[i].value
 		return a.items[i].value
@@ -131,7 +131,7 @@ func (a *sparseArrayObject) getProp(n Value) Value {
 }
 }
 
 
 func (a *sparseArrayObject) getLengthProp() Value {
 func (a *sparseArrayObject) getLengthProp() Value {
-	a.lengthProp.value = intToValue(int64(a.length))
+	a.lengthProp.value = intToValue(a.length)
 	return &a.lengthProp
 	return &a.lengthProp
 }
 }
 
 
@@ -159,7 +159,7 @@ func (a *sparseArrayObject) getPropStr(name string) Value {
 	return a.baseObject.getPropStr(name)
 	return a.baseObject.getPropStr(name)
 }
 }
 
 
-func (a *sparseArrayObject) putIdx(idx int, val Value, throw bool, origNameStr string, origName Value) {
+func (a *sparseArrayObject) putIdx(idx int64, val Value, throw bool, origNameStr string, origName Value) {
 	var prop Value
 	var prop Value
 	i := a.findIdx(idx)
 	i := a.findIdx(idx)
 	if i < len(a.items) && a.items[i].idx == idx {
 	if i < len(a.items) && a.items[i].idx == idx {
@@ -192,7 +192,7 @@ func (a *sparseArrayObject) putIdx(idx int, val Value, throw bool, origNameStr s
 		}
 		}
 
 
 		if idx >= a.length {
 		if idx >= a.length {
-			if !a.setLengthInt(int64(idx+1), throw) {
+			if !a.setLengthInt(idx+1, throw) {
 				return
 				return
 			}
 			}
 		}
 		}
@@ -286,7 +286,7 @@ func (a *sparseArrayObject) setValues(values []Value) {
 	for i, val := range values {
 	for i, val := range values {
 		if val != nil {
 		if val != nil {
 			a.items = append(a.items, sparseArrayItem{
 			a.items = append(a.items, sparseArrayItem{
-				idx:   i,
+				idx:   int64(i),
 				value: val,
 				value: val,
 			})
 			})
 		}
 		}
@@ -323,7 +323,7 @@ func (a *sparseArrayObject) expand() bool {
 			//log.Println("Switching sparse->standard")
 			//log.Println("Switching sparse->standard")
 			ar := &arrayObject{
 			ar := &arrayObject{
 				baseObject:     a.baseObject,
 				baseObject:     a.baseObject,
-				length:         int(a.length),
+				length:         a.length,
 				propValueCount: a.propValueCount,
 				propValueCount: a.propValueCount,
 			}
 			}
 			ar.setValuesFromSparse(a.items)
 			ar.setValuesFromSparse(a.items)
@@ -346,7 +346,7 @@ func (a *sparseArrayObject) defineOwnProperty(n Value, descr objectImpl, throw b
 		prop, ok := a.baseObject._defineOwnProperty(n, existing, descr, throw)
 		prop, ok := a.baseObject._defineOwnProperty(n, existing, descr, throw)
 		if ok {
 		if ok {
 			if idx >= a.length {
 			if idx >= a.length {
-				if !a.setLengthInt(int64(idx+1), throw) {
+				if !a.setLengthInt(idx+1, throw) {
 					return false
 					return false
 				}
 				}
 			}
 			}
@@ -380,7 +380,7 @@ func (a *sparseArrayObject) defineOwnProperty(n Value, descr objectImpl, throw b
 	}
 	}
 }
 }
 
 
-func (a *sparseArrayObject) _deleteProp(idx int, throw bool) bool {
+func (a *sparseArrayObject) _deleteProp(idx int64, throw bool) bool {
 	i := a.findIdx(idx)
 	i := a.findIdx(idx)
 	if i < len(a.items) && a.items[i].idx == idx {
 	if i < len(a.items) && a.items[i].idx == idx {
 		if p, ok := a.items[i].value.(*valueProperty); ok {
 		if p, ok := a.items[i].value.(*valueProperty); ok {
@@ -411,15 +411,15 @@ func (a *sparseArrayObject) deleteStr(name string, throw bool) bool {
 	return a.baseObject.deleteStr(name, throw)
 	return a.baseObject.deleteStr(name, throw)
 }
 }
 
 
-func (a *sparseArrayObject) sortLen() int {
+func (a *sparseArrayObject) sortLen() int64 {
 	if len(a.items) > 0 {
 	if len(a.items) > 0 {
-		return int(a.items[len(a.items)-1].idx) + 1
+		return a.items[len(a.items)-1].idx + 1
 	}
 	}
 
 
 	return 0
 	return 0
 }
 }
 
 
-func (a *sparseArrayObject) sortGet(i int) Value {
+func (a *sparseArrayObject) sortGet(i int64) Value {
 	idx := a.findIdx(i)
 	idx := a.findIdx(i)
 	if idx < len(a.items) && a.items[idx].idx == i {
 	if idx < len(a.items) && a.items[idx].idx == i {
 		v := a.items[idx].value
 		v := a.items[idx].value
@@ -431,7 +431,7 @@ func (a *sparseArrayObject) sortGet(i int) Value {
 	return nil
 	return nil
 }
 }
 
 
-func (a *sparseArrayObject) swap(i, j int) {
+func (a *sparseArrayObject) swap(i, j int64) {
 	idxI := a.findIdx(i)
 	idxI := a.findIdx(i)
 	idxJ := a.findIdx(j)
 	idxJ := a.findIdx(j)
 
 

+ 16 - 15
builtin_array.go

@@ -67,7 +67,7 @@ func (r *Runtime) arrayproto_pop(call FunctionCall) Value {
 		if l > 0 {
 		if l > 0 {
 			var val Value
 			var val Value
 			l--
 			l--
-			if l < len(a.values) {
+			if l < int64(len(a.values)) {
 				val = a.values[l]
 				val = a.values[l]
 			}
 			}
 			if val == nil {
 			if val == nil {
@@ -168,13 +168,13 @@ func (r *Runtime) arrayproto_toLocaleString(call FunctionCall) Value {
 	array := call.This.ToObject(r)
 	array := call.This.ToObject(r)
 	if a, ok := array.self.(*arrayObject); ok {
 	if a, ok := array.self.(*arrayObject); ok {
 		var buf bytes.Buffer
 		var buf bytes.Buffer
-		for i := 0; i < a.length; i++ {
+		for i := int64(0); i < a.length; i++ {
 			var item Value
 			var item Value
-			if i < len(a.values) {
+			if i < int64(len(a.values)) {
 				item = a.values[i]
 				item = a.values[i]
 			}
 			}
 			if item == nil {
 			if item == nil {
-				return r.arrayproto_toLocaleString_generic(array, int64(i), &buf)
+				return r.arrayproto_toLocaleString_generic(array, i, &buf)
 			}
 			}
 			if prop, ok := item.(*valueProperty); ok {
 			if prop, ok := item.(*valueProperty); ok {
 				item = prop.get(array)
 				item = prop.get(array)
@@ -532,7 +532,7 @@ func (r *Runtime) arrayproto_map(call FunctionCall) Value {
 			Arguments: []Value{nil, nil, o},
 			Arguments: []Value{nil, nil, o},
 		}
 		}
 		a := r.newArrayObject()
 		a := r.newArrayObject()
-		a._setLengthInt(int(length), true)
+		a._setLengthInt(length, true)
 		a.values = make([]Value, length)
 		a.values = make([]Value, length)
 		for k := int64(0); k < length; k++ {
 		for k := int64(0); k < length; k++ {
 			idx := intToValue(k)
 			idx := intToValue(k)
@@ -570,7 +570,7 @@ func (r *Runtime) arrayproto_filter(call FunctionCall) Value {
 				}
 				}
 			}
 			}
 		}
 		}
-		a.length = len(a.values)
+		a.length = int64(len(a.values))
 		a.objCount = a.length
 		a.objCount = a.length
 		return a.val
 		return a.val
 	} else {
 	} else {
@@ -697,10 +697,11 @@ func (r *Runtime) arrayproto_reverse(call FunctionCall) Value {
 	if a, ok := o.self.(*arrayObject); ok {
 	if a, ok := o.self.(*arrayObject); ok {
 		l := a.length
 		l := a.length
 		middle := l / 2
 		middle := l / 2
-		for lower := 0; lower != middle; lower++ {
+		al := int64(len(a.values))
+		for lower := int64(0); lower != middle; lower++ {
 			upper := l - lower - 1
 			upper := l - lower - 1
 			var lowerValue, upperValue Value
 			var lowerValue, upperValue Value
-			if upper >= len(a.values) || lower >= len(a.values) {
+			if upper >= al || lower >= al {
 				goto bailout
 				goto bailout
 			}
 			}
 			lowerValue = a.values[lower]
 			lowerValue = a.values[lower]
@@ -721,7 +722,7 @@ func (r *Runtime) arrayproto_reverse(call FunctionCall) Value {
 			a.values[lower], a.values[upper] = upperValue, lowerValue
 			a.values[lower], a.values[upper] = upperValue, lowerValue
 			continue
 			continue
 		bailout:
 		bailout:
-			arrayproto_reverse_generic_step(o, int64(lower), int64(upper))
+			arrayproto_reverse_generic_step(o, lower, upper)
 		}
 		}
 		//TODO: go arrays
 		//TODO: go arrays
 	} else {
 	} else {
@@ -820,9 +821,9 @@ func (r *Runtime) initArray() {
 }
 }
 
 
 type sortable interface {
 type sortable interface {
-	sortLen() int
-	sortGet(int) Value
-	swap(int, int)
+	sortLen() int64
+	sortGet(int64) Value
+	swap(int64, int64)
 }
 }
 
 
 type arraySortCtx struct {
 type arraySortCtx struct {
@@ -867,13 +868,13 @@ func (ctx *arraySortCtx) sortCompare(x, y Value) int {
 // sort.Interface
 // sort.Interface
 
 
 func (a *arraySortCtx) Len() int {
 func (a *arraySortCtx) Len() int {
-	return a.obj.sortLen()
+	return int(a.obj.sortLen())
 }
 }
 
 
 func (a *arraySortCtx) Less(j, k int) bool {
 func (a *arraySortCtx) Less(j, k int) bool {
-	return a.sortCompare(a.obj.sortGet(j), a.obj.sortGet(k)) == -1
+	return a.sortCompare(a.obj.sortGet(int64(j)), a.obj.sortGet(int64(k))) == -1
 }
 }
 
 
 func (a *arraySortCtx) Swap(j, k int) {
 func (a *arraySortCtx) Swap(j, k int) {
-	a.obj.swap(j, k)
+	a.obj.swap(int64(j), int64(k))
 }
 }

+ 24 - 37
builtin_string.go

@@ -53,19 +53,6 @@ func (r *Runtime) builtin_newString(args []Value) *Object {
 	return r._newString(s)
 	return r._newString(s)
 }
 }
 
 
-func searchSubstring(str, search valueString) (ret [][]int) {
-	searchPos := 0
-	l := str.length()
-	if searchPos < l {
-		p := str.index(search, searchPos)
-		if p != -1 {
-			searchPos = p + search.length()
-			ret = append(ret, []int{p, searchPos})
-		}
-	}
-	return
-}
-
 func searchSubstringUTF8(str, search string) (ret [][]int) {
 func searchSubstringUTF8(str, search string) (ret [][]int) {
 	searchPos := 0
 	searchPos := 0
 	l := len(str)
 	l := len(str)
@@ -127,20 +114,20 @@ func (r *Runtime) stringproto_charAt(call FunctionCall) Value {
 	r.checkObjectCoercible(call.This)
 	r.checkObjectCoercible(call.This)
 	s := call.This.ToString()
 	s := call.This.ToString()
 	pos := call.Argument(0).ToInteger()
 	pos := call.Argument(0).ToInteger()
-	if pos < 0 || pos >= int64(s.length()) {
+	if pos < 0 || pos >= s.length() {
 		return stringEmpty
 		return stringEmpty
 	}
 	}
-	return newStringValue(string(s.charAt(int(pos))))
+	return newStringValue(string(s.charAt(pos)))
 }
 }
 
 
 func (r *Runtime) stringproto_charCodeAt(call FunctionCall) Value {
 func (r *Runtime) stringproto_charCodeAt(call FunctionCall) Value {
 	r.checkObjectCoercible(call.This)
 	r.checkObjectCoercible(call.This)
 	s := call.This.ToString()
 	s := call.This.ToString()
 	pos := call.Argument(0).ToInteger()
 	pos := call.Argument(0).ToInteger()
-	if pos < 0 || pos >= int64(s.length()) {
+	if pos < 0 || pos >= s.length() {
 		return _NaN
 		return _NaN
 	}
 	}
-	return intToValue(int64(s.charAt(int(pos)) & 0xFFFF))
+	return intToValue(int64(s.charAt(pos) & 0xFFFF))
 }
 }
 
 
 func (r *Runtime) stringproto_concat(call FunctionCall) Value {
 func (r *Runtime) stringproto_concat(call FunctionCall) Value {
@@ -166,7 +153,7 @@ func (r *Runtime) stringproto_concat(call FunctionCall) Value {
 		return asciiString(buf.String())
 		return asciiString(buf.String())
 	} else {
 	} else {
 		buf := make([]uint16, totalLen)
 		buf := make([]uint16, totalLen)
-		pos := 0
+		pos := int64(0)
 		for _, s := range strs {
 		for _, s := range strs {
 			switch s := s.(type) {
 			switch s := s.(type) {
 			case asciiString:
 			case asciiString:
@@ -187,7 +174,7 @@ func (r *Runtime) stringproto_indexOf(call FunctionCall) Value {
 	r.checkObjectCoercible(call.This)
 	r.checkObjectCoercible(call.This)
 	value := call.This.ToString()
 	value := call.This.ToString()
 	target := call.Argument(0).ToString()
 	target := call.Argument(0).ToString()
-	pos := int(call.Argument(1).ToInteger())
+	pos := call.Argument(1).ToInteger()
 
 
 	if pos < 0 {
 	if pos < 0 {
 		pos = 0
 		pos = 0
@@ -198,7 +185,7 @@ func (r *Runtime) stringproto_indexOf(call FunctionCall) Value {
 		}
 		}
 	}
 	}
 
 
-	return intToValue(int64(value.index(target, pos)))
+	return intToValue(value.index(target, pos))
 }
 }
 
 
 func (r *Runtime) stringproto_lastIndexOf(call FunctionCall) Value {
 func (r *Runtime) stringproto_lastIndexOf(call FunctionCall) Value {
@@ -207,11 +194,11 @@ func (r *Runtime) stringproto_lastIndexOf(call FunctionCall) Value {
 	target := call.Argument(0).ToString()
 	target := call.Argument(0).ToString()
 	numPos := call.Argument(1).ToNumber()
 	numPos := call.Argument(1).ToNumber()
 
 
-	var pos int
+	var pos int64
 	if f, ok := numPos.assertFloat(); ok && math.IsNaN(f) {
 	if f, ok := numPos.assertFloat(); ok && math.IsNaN(f) {
-		pos = int(value.length())
+		pos = value.length()
 	} else {
 	} else {
-		pos = int(numPos.ToInteger())
+		pos = numPos.ToInteger()
 		if pos < 0 {
 		if pos < 0 {
 			pos = 0
 			pos = 0
 		} else {
 		} else {
@@ -222,7 +209,7 @@ func (r *Runtime) stringproto_lastIndexOf(call FunctionCall) Value {
 		}
 		}
 	}
 	}
 
 
-	return intToValue(int64(value.lastIndex(target, pos)))
+	return intToValue(value.lastIndex(target, pos))
 }
 }
 
 
 func (r *Runtime) stringproto_localeCompare(call FunctionCall) Value {
 func (r *Runtime) stringproto_localeCompare(call FunctionCall) Value {
@@ -261,7 +248,7 @@ func (r *Runtime) stringproto_match(call FunctionCall) Value {
 			} else {
 			} else {
 				previousLastIndex = thisIndex
 				previousLastIndex = thisIndex
 			}
 			}
-			a = append(a, s.substring(result[0], result[1]))
+			a = append(a, s.substring(int64(result[0]), int64(result[1])))
 		}
 		}
 		if len(a) == 0 {
 		if len(a) == 0 {
 			return _null
 			return _null
@@ -439,10 +426,10 @@ func (r *Runtime) stringproto_slice(call FunctionCall) Value {
 	s := call.This.ToString()
 	s := call.This.ToString()
 
 
 	l := s.length()
 	l := s.length()
-	start := int(call.Argument(0).ToInteger())
-	var end int
+	start := call.Argument(0).ToInteger()
+	var end int64
 	if arg1 := call.Argument(1); arg1 != _undefined {
 	if arg1 := call.Argument(1); arg1 != _undefined {
-		end = int(arg1.ToInteger())
+		end = arg1.ToInteger()
 	} else {
 	} else {
 		end = l
 		end = l
 	}
 	}
@@ -509,13 +496,13 @@ func (r *Runtime) stringproto_split(call FunctionCall) Value {
 		for _, match := range result {
 		for _, match := range result {
 			if match[0] == match[1] {
 			if match[0] == match[1] {
 				// FIXME Ugh, this is a hack
 				// FIXME Ugh, this is a hack
-				if match[0] == 0 || match[0] == targetLength {
+				if match[0] == 0 || int64(match[0]) == targetLength {
 					continue
 					continue
 				}
 				}
 			}
 			}
 
 
 			if lastIndex != match[0] {
 			if lastIndex != match[0] {
-				valueArray = append(valueArray, s.substring(lastIndex, match[0]))
+				valueArray = append(valueArray, s.substring(int64(lastIndex), int64(match[0])))
 				found++
 				found++
 			} else if lastIndex == match[0] {
 			} else if lastIndex == match[0] {
 				if lastIndex != -1 {
 				if lastIndex != -1 {
@@ -534,7 +521,7 @@ func (r *Runtime) stringproto_split(call FunctionCall) Value {
 				offset := index * 2
 				offset := index * 2
 				var value Value
 				var value Value
 				if match[offset] != -1 {
 				if match[offset] != -1 {
-					value = s.substring(match[offset], match[offset+1])
+					value = s.substring(int64(match[offset]), int64(match[offset+1]))
 				} else {
 				} else {
 					value = _undefined
 					value = _undefined
 				}
 				}
@@ -547,8 +534,8 @@ func (r *Runtime) stringproto_split(call FunctionCall) Value {
 		}
 		}
 
 
 		if found != limit {
 		if found != limit {
-			if lastIndex != targetLength {
-				valueArray = append(valueArray, s.substring(lastIndex, targetLength))
+			if int64(lastIndex) != targetLength {
+				valueArray = append(valueArray, s.substring(int64(lastIndex), targetLength))
 			} else {
 			} else {
 				valueArray = append(valueArray, stringEmpty)
 				valueArray = append(valueArray, stringEmpty)
 			}
 			}
@@ -592,10 +579,10 @@ func (r *Runtime) stringproto_substring(call FunctionCall) Value {
 	s := call.This.ToString()
 	s := call.This.ToString()
 
 
 	l := s.length()
 	l := s.length()
-	intStart := int(call.Argument(0).ToInteger())
-	var intEnd int
+	intStart := call.Argument(0).ToInteger()
+	var intEnd int64
 	if end := call.Argument(1); end != _undefined {
 	if end := call.Argument(1); end != _undefined {
-		intEnd = int(end.ToInteger())
+		intEnd = end.ToInteger()
 	} else {
 	} else {
 		intEnd = l
 		intEnd = l
 	}
 	}
@@ -659,7 +646,7 @@ func (r *Runtime) stringproto_substr(call FunctionCall) Value {
 		return stringEmpty
 		return stringEmpty
 	}
 	}
 
 
-	return s.substring(int(start), int(start+length))
+	return s.substring(start, start+length)
 }
 }
 
 
 func (r *Runtime) initString() {
 func (r *Runtime) initString() {

+ 7 - 7
object.go

@@ -524,17 +524,17 @@ func (o *baseObject) preventExtensions() {
 	o.extensible = false
 	o.extensible = false
 }
 }
 
 
-func (o *baseObject) sortLen() int {
-	return int(toLength(o.val.self.getStr("length")))
+func (o *baseObject) sortLen() int64 {
+	return toLength(o.val.self.getStr("length"))
 }
 }
 
 
-func (o *baseObject) sortGet(i int) Value {
-	return o.val.self.get(intToValue(int64(i)))
+func (o *baseObject) sortGet(i int64) Value {
+	return o.val.self.get(intToValue(i))
 }
 }
 
 
-func (o *baseObject) swap(i, j int) {
-	ii := intToValue(int64(i))
-	jj := intToValue(int64(j))
+func (o *baseObject) swap(i, j int64) {
+	ii := intToValue(i)
+	jj := intToValue(j)
 
 
 	x := o.val.self.get(ii)
 	x := o.val.self.get(ii)
 	y := o.val.self.get(jj)
 	y := o.val.self.get(jj)

+ 7 - 7
object_gomap.go

@@ -200,17 +200,17 @@ func (o *objectGoMapSimple) equal(other objectImpl) bool {
 	return false
 	return false
 }
 }
 
 
-func (o *objectGoMapSimple) sortLen() int {
-	return len(o.data)
+func (o *objectGoMapSimple) sortLen() int64 {
+	return int64(len(o.data))
 }
 }
 
 
-func (o *objectGoMapSimple) sortGet(i int) Value {
-	return o.getStr(strconv.Itoa(i))
+func (o *objectGoMapSimple) sortGet(i int64) Value {
+	return o.getStr(strconv.FormatInt(i, 10))
 }
 }
 
 
-func (o *objectGoMapSimple) swap(i, j int) {
-	ii := strconv.Itoa(i)
-	jj := strconv.Itoa(j)
+func (o *objectGoMapSimple) swap(i, j int64) {
+	ii := strconv.FormatInt(i, 10)
+	jj := strconv.FormatInt(j, 10)
 	x := o.getStr(ii)
 	x := o.getStr(ii)
 	y := o.getStr(jj)
 	y := o.getStr(jj)
 
 

+ 21 - 21
object_goslice.go

@@ -25,8 +25,8 @@ func (o *objectGoSlice) _setLen() {
 	o.lengthProp.value = intToValue(int64(len(*o.data)))
 	o.lengthProp.value = intToValue(int64(len(*o.data)))
 }
 }
 
 
-func (o *objectGoSlice) getIdx(idx int) Value {
-	if idx < len(*o.data) {
+func (o *objectGoSlice) getIdx(idx int64) Value {
+	if idx < int64(len(*o.data)) {
 		return o.val.runtime.ToValue((*o.data)[idx])
 		return o.val.runtime.ToValue((*o.data)[idx])
 	}
 	}
 	return nil
 	return nil
@@ -85,8 +85,8 @@ func (o *objectGoSlice) getOwnProp(name string) Value {
 	return o.baseObject.getOwnProp(name)
 	return o.baseObject.getOwnProp(name)
 }
 }
 
 
-func (o *objectGoSlice) grow(size int) {
-	newcap := cap(*o.data)
+func (o *objectGoSlice) grow(size int64) {
+	newcap := int64(cap(*o.data))
 	if newcap < size {
 	if newcap < size {
 		// Use the same algorithm as in runtime.growSlice
 		// Use the same algorithm as in runtime.growSlice
 		doublecap := newcap + newcap
 		doublecap := newcap + newcap
@@ -111,8 +111,8 @@ func (o *objectGoSlice) grow(size int) {
 	o._setLen()
 	o._setLen()
 }
 }
 
 
-func (o *objectGoSlice) putIdx(idx int, v Value, throw bool) {
-	if idx >= len(*o.data) {
+func (o *objectGoSlice) putIdx(idx int64, v Value, throw bool) {
+	if idx >= int64(len(*o.data)) {
 		if !o.sliceExtensible {
 		if !o.sliceExtensible {
 			o.val.runtime.typeErrorResult(throw, "Cannot extend Go slice")
 			o.val.runtime.typeErrorResult(throw, "Cannot extend Go slice")
 			return
 			return
@@ -142,14 +142,14 @@ func (o *objectGoSlice) putStr(name string, val Value, throw bool) {
 
 
 func (o *objectGoSlice) _has(n Value) bool {
 func (o *objectGoSlice) _has(n Value) bool {
 	if idx := toIdx(n); idx >= 0 {
 	if idx := toIdx(n); idx >= 0 {
-		return idx < len(*o.data)
+		return idx < int64(len(*o.data))
 	}
 	}
 	return false
 	return false
 }
 }
 
 
 func (o *objectGoSlice) _hasStr(name string) bool {
 func (o *objectGoSlice) _hasStr(name string) bool {
 	if idx := strToIdx(name); idx >= 0 {
 	if idx := strToIdx(name); idx >= 0 {
-		return idx < len(*o.data)
+		return idx < int64(len(*o.data))
 	}
 	}
 	return false
 	return false
 }
 }
@@ -217,7 +217,7 @@ func (o *objectGoSlice) toPrimitive() Value {
 }
 }
 
 
 func (o *objectGoSlice) deleteStr(name string, throw bool) bool {
 func (o *objectGoSlice) deleteStr(name string, throw bool) bool {
-	if idx := strToIdx(name); idx >= 0 && idx < len(*o.data) {
+	if idx := strToIdx(name); idx >= 0 && idx < int64(len(*o.data)) {
 		(*o.data)[idx] = nil
 		(*o.data)[idx] = nil
 		return true
 		return true
 	}
 	}
@@ -225,7 +225,7 @@ func (o *objectGoSlice) deleteStr(name string, throw bool) bool {
 }
 }
 
 
 func (o *objectGoSlice) delete(name Value, throw bool) bool {
 func (o *objectGoSlice) delete(name Value, throw bool) bool {
-	if idx := toIdx(name); idx >= 0 && idx < len(*o.data) {
+	if idx := toIdx(name); idx >= 0 && idx < int64(len(*o.data)) {
 		(*o.data)[idx] = nil
 		(*o.data)[idx] = nil
 		return true
 		return true
 	}
 	}
@@ -284,20 +284,20 @@ func (o *objectGoSlice) equal(other objectImpl) bool {
 	return false
 	return false
 }
 }
 
 
-func (o *objectGoSlice) sortLen() int {
-	return len(*o.data)
+func (o *objectGoSlice) sortLen() int64 {
+	return int64(len(*o.data))
 }
 }
 
 
-func (o *objectGoSlice) sortGet(i int) Value {
-	return o.getStr(strconv.Itoa(i))
+func (o *objectGoSlice) sortGet(i int64) Value {
+	return o.get(intToValue(i))
 }
 }
 
 
-func (o *objectGoSlice) swap(i, j int) {
-	ii := strconv.Itoa(i)
-	jj := strconv.Itoa(j)
-	x := o.getStr(ii)
-	y := o.getStr(jj)
+func (o *objectGoSlice) swap(i, j int64) {
+	ii := intToValue(i)
+	jj := intToValue(j)
+	x := o.get(ii)
+	y := o.get(jj)
 
 
-	o.putStr(ii, y, false)
-	o.putStr(jj, x, false)
+	o.put(ii, y, false)
+	o.put(jj, x, false)
 }
 }

+ 23 - 23
object_goslice_reflect.go

@@ -25,21 +25,21 @@ func (o *objectGoSliceReflect) _setLen() {
 
 
 func (o *objectGoSliceReflect) _has(n Value) bool {
 func (o *objectGoSliceReflect) _has(n Value) bool {
 	if idx := toIdx(n); idx >= 0 {
 	if idx := toIdx(n); idx >= 0 {
-		return idx < o.value.Len()
+		return idx < int64(o.value.Len())
 	}
 	}
 	return false
 	return false
 }
 }
 
 
 func (o *objectGoSliceReflect) _hasStr(name string) bool {
 func (o *objectGoSliceReflect) _hasStr(name string) bool {
 	if idx := strToIdx(name); idx >= 0 {
 	if idx := strToIdx(name); idx >= 0 {
-		return idx < o.value.Len()
+		return idx < int64(o.value.Len())
 	}
 	}
 	return false
 	return false
 }
 }
 
 
-func (o *objectGoSliceReflect) getIdx(idx int) Value {
-	if idx < o.value.Len() {
-		return o.val.runtime.ToValue(o.value.Index(idx).Interface())
+func (o *objectGoSliceReflect) getIdx(idx int64) Value {
+	if idx < int64(o.value.Len()) {
+		return o.val.runtime.ToValue(o.value.Index(int(idx)).Interface())
 	}
 	}
 	return nil
 	return nil
 }
 }
@@ -86,8 +86,8 @@ func (o *objectGoSliceReflect) getOwnProp(name string) Value {
 	return o.objectGoReflect.getOwnProp(name)
 	return o.objectGoReflect.getOwnProp(name)
 }
 }
 
 
-func (o *objectGoSliceReflect) putIdx(idx int, v Value, throw bool) {
-	if idx >= o.value.Len() {
+func (o *objectGoSliceReflect) putIdx(idx int64, v Value, throw bool) {
+	if idx >= int64(o.value.Len()) {
 		o.val.runtime.typeErrorResult(throw, "Cannot extend a Go reflect slice")
 		o.val.runtime.typeErrorResult(throw, "Cannot extend a Go reflect slice")
 		return
 		return
 	}
 	}
@@ -96,7 +96,7 @@ func (o *objectGoSliceReflect) putIdx(idx int, v Value, throw bool) {
 		o.val.runtime.typeErrorResult(throw, "Go type conversion error: %v", err)
 		o.val.runtime.typeErrorResult(throw, "Go type conversion error: %v", err)
 		return
 		return
 	}
 	}
-	o.value.Index(idx).Set(val)
+	o.value.Index(int(idx)).Set(val)
 }
 }
 
 
 func (o *objectGoSliceReflect) put(n Value, val Value, throw bool) {
 func (o *objectGoSliceReflect) put(n Value, val Value, throw bool) {
@@ -174,16 +174,16 @@ func (o *objectGoSliceReflect) toPrimitive() Value {
 }
 }
 
 
 func (o *objectGoSliceReflect) deleteStr(name string, throw bool) bool {
 func (o *objectGoSliceReflect) deleteStr(name string, throw bool) bool {
-	if idx := strToIdx(name); idx >= 0 && idx < o.value.Len() {
-		o.value.Index(idx).Set(reflect.Zero(o.value.Type().Elem()))
+	if idx := strToIdx(name); idx >= 0 && idx < int64(o.value.Len()) {
+		o.value.Index(int(idx)).Set(reflect.Zero(o.value.Type().Elem()))
 		return true
 		return true
 	}
 	}
 	return o.objectGoReflect.deleteStr(name, throw)
 	return o.objectGoReflect.deleteStr(name, throw)
 }
 }
 
 
 func (o *objectGoSliceReflect) delete(name Value, throw bool) bool {
 func (o *objectGoSliceReflect) delete(name Value, throw bool) bool {
-	if idx := toIdx(name); idx >= 0 && idx < o.value.Len() {
-		o.value.Index(idx).Set(reflect.Zero(o.value.Type().Elem()))
+	if idx := toIdx(name); idx >= 0 && idx < int64(o.value.Len()) {
+		o.value.Index(int(idx)).Set(reflect.Zero(o.value.Type().Elem()))
 		return true
 		return true
 	}
 	}
 	return true
 	return true
@@ -232,20 +232,20 @@ func (o *objectGoSliceReflect) equal(other objectImpl) bool {
 	return false
 	return false
 }
 }
 
 
-func (o *objectGoSliceReflect) sortLen() int {
-	return o.value.Len()
+func (o *objectGoSliceReflect) sortLen() int64 {
+	return int64(o.value.Len())
 }
 }
 
 
-func (o *objectGoSliceReflect) sortGet(i int) Value {
-	return o.getStr(strconv.Itoa(i))
+func (o *objectGoSliceReflect) sortGet(i int64) Value {
+	return o.get(intToValue(i))
 }
 }
 
 
-func (o *objectGoSliceReflect) swap(i, j int) {
-	ii := strconv.Itoa(i)
-	jj := strconv.Itoa(j)
-	x := o.getStr(ii)
-	y := o.getStr(jj)
+func (o *objectGoSliceReflect) swap(i, j int64) {
+	ii := intToValue(i)
+	jj := intToValue(j)
+	x := o.get(ii)
+	y := o.get(jj)
 
 
-	o.putStr(ii, y, false)
-	o.putStr(jj, x, false)
+	o.put(ii, y, false)
+	o.put(jj, x, false)
 }
 }

+ 3 - 3
object_lazy.go

@@ -181,19 +181,19 @@ func (o *lazyObject) equal(other objectImpl) bool {
 	return obj.equal(other)
 	return obj.equal(other)
 }
 }
 
 
-func (o *lazyObject) sortLen() int {
+func (o *lazyObject) sortLen() int64 {
 	obj := o.create(o.val)
 	obj := o.create(o.val)
 	o.val.self = obj
 	o.val.self = obj
 	return obj.sortLen()
 	return obj.sortLen()
 }
 }
 
 
-func (o *lazyObject) sortGet(i int) Value {
+func (o *lazyObject) sortGet(i int64) Value {
 	obj := o.create(o.val)
 	obj := o.create(o.val)
 	o.val.self = obj
 	o.val.self = obj
 	return obj.sortGet(i)
 	return obj.sortGet(i)
 }
 }
 
 
-func (o *lazyObject) swap(i, j int) {
+func (o *lazyObject) swap(i, j int64) {
 	obj := o.create(o.val)
 	obj := o.create(o.val)
 	o.val.self = obj
 	o.val.self = obj
 	obj.swap(i, j)
 	obj.swap(i, j)

+ 4 - 4
regexp.go

@@ -287,7 +287,7 @@ func (r *regexpObject) execResultToArray(target valueString, result []int) Value
 	for index := 0; index < captureCount; index++ {
 	for index := 0; index < captureCount; index++ {
 		offset := index << 1
 		offset := index << 1
 		if result[offset] >= lowerBound {
 		if result[offset] >= lowerBound {
-			valueArray[index] = target.substring(result[offset], result[offset+1])
+			valueArray[index] = target.substring(int64(result[offset]), int64(result[offset+1]))
 			lowerBound = result[offset]
 			lowerBound = result[offset]
 		} else {
 		} else {
 			valueArray[index] = _undefined
 			valueArray[index] = _undefined
@@ -300,9 +300,9 @@ func (r *regexpObject) execResultToArray(target valueString, result []int) Value
 }
 }
 
 
 func (r *regexpObject) execRegexp(target valueString) (match bool, result []int) {
 func (r *regexpObject) execRegexp(target valueString) (match bool, result []int) {
-	lastIndex := 0
+	lastIndex := int64(0)
 	if p := r.getStr("lastIndex"); p != nil {
 	if p := r.getStr("lastIndex"); p != nil {
-		lastIndex = int(p.ToInteger())
+		lastIndex = p.ToInteger()
 		if lastIndex < 0 {
 		if lastIndex < 0 {
 			lastIndex = 0
 			lastIndex = 0
 		}
 		}
@@ -312,7 +312,7 @@ func (r *regexpObject) execRegexp(target valueString) (match bool, result []int)
 		index = 0
 		index = 0
 	}
 	}
 	if index >= 0 && index <= target.length() {
 	if index >= 0 && index <= target.length() {
-		result = r.pattern.FindSubmatchIndex(target, index)
+		result = r.pattern.FindSubmatchIndex(target, int(index))
 	}
 	}
 	if result == nil {
 	if result == nil {
 		r.putStr("lastIndex", intToValue(0), true)
 		r.putStr("lastIndex", intToValue(0), true)

+ 2 - 2
runtime.go

@@ -251,7 +251,7 @@ func (r *Runtime) newArrayValues(values []Value) *Object {
 	a.prototype = r.global.ArrayPrototype
 	a.prototype = r.global.ArrayPrototype
 	a.init()
 	a.init()
 	a.values = values
 	a.values = values
-	a.length = len(values)
+	a.length = int64(len(values))
 	a.objCount = a.length
 	a.objCount = a.length
 	return v
 	return v
 }
 }
@@ -811,7 +811,7 @@ func (r *Runtime) ToValue(i interface{}) Value {
 	case int64:
 	case int64:
 		return intToValue(i)
 		return intToValue(i)
 	case uint:
 	case uint:
-		if i <= math.MaxInt64 {
+		if int64(i) <= math.MaxInt64 {
 			return intToValue(int64(i))
 			return intToValue(int64(i))
 		} else {
 		} else {
 			return floatToValue(float64(i))
 			return floatToValue(float64(i))

+ 10 - 10
string.go

@@ -42,14 +42,14 @@ var (
 
 
 type valueString interface {
 type valueString interface {
 	Value
 	Value
-	charAt(int) rune
-	length() int
+	charAt(int64) rune
+	length() int64
 	concat(valueString) valueString
 	concat(valueString) valueString
-	substring(start, end int) valueString
+	substring(start, end int64) valueString
 	compareTo(valueString) int
 	compareTo(valueString) int
 	reader(start int) io.RuneReader
 	reader(start int) io.RuneReader
-	index(valueString, int) int
-	lastIndex(valueString, int) int
+	index(valueString, int64) int64
+	lastIndex(valueString, int64) int64
 	toLower() valueString
 	toLower() valueString
 	toUpper() valueString
 	toUpper() valueString
 	toTrimmedUTF8() string
 	toTrimmedUTF8() string
@@ -58,7 +58,7 @@ type valueString interface {
 type stringObject struct {
 type stringObject struct {
 	baseObject
 	baseObject
 	value      valueString
 	value      valueString
-	length     int
+	length     int64
 	lengthProp valueProperty
 	lengthProp valueProperty
 }
 }
 
 
@@ -84,7 +84,7 @@ func (s *stringObject) setLength() {
 	if s.value != nil {
 	if s.value != nil {
 		s.length = s.value.length()
 		s.length = s.value.length()
 	}
 	}
-	s.lengthProp.value = intToValue(int64(s.length))
+	s.lengthProp.value = intToValue(s.length)
 	s._put("length", &s.lengthProp)
 	s._put("length", &s.lengthProp)
 }
 }
 
 
@@ -128,7 +128,7 @@ func (s *stringObject) getOwnProp(name string) Value {
 	return s.baseObject.getOwnProp(name)
 	return s.baseObject.getOwnProp(name)
 }
 }
 
 
-func (s *stringObject) getIdx(idx int) Value {
+func (s *stringObject) getIdx(idx int64) Value {
 	return s.value.substring(idx, idx+1)
 	return s.value.substring(idx, idx+1)
 }
 }
 
 
@@ -162,13 +162,13 @@ func (s *stringObject) defineOwnProperty(n Value, descr objectImpl, throw bool)
 type stringPropIter struct {
 type stringPropIter struct {
 	str         valueString // separate, because obj can be the singleton
 	str         valueString // separate, because obj can be the singleton
 	obj         *stringObject
 	obj         *stringObject
-	idx, length int
+	idx, length int64
 	recursive   bool
 	recursive   bool
 }
 }
 
 
 func (i *stringPropIter) next() (propIterItem, iterNextFunc) {
 func (i *stringPropIter) next() (propIterItem, iterNextFunc) {
 	if i.idx < i.length {
 	if i.idx < i.length {
-		name := strconv.Itoa(i.idx)
+		name := strconv.FormatInt(i.idx, 10)
 		i.idx++
 		i.idx++
 		return propIterItem{name: name, enumerable: _ENUM_TRUE}, i.next
 		return propIterItem{name: name, enumerable: _ENUM_TRUE}, i.next
 	}
 	}

+ 10 - 10
string_ascii.go

@@ -225,12 +225,12 @@ func (s asciiString) baseObject(r *Runtime) *Object {
 	return ss.val
 	return ss.val
 }
 }
 
 
-func (s asciiString) charAt(idx int) rune {
+func (s asciiString) charAt(idx int64) rune {
 	return rune(s[idx])
 	return rune(s[idx])
 }
 }
 
 
-func (s asciiString) length() int {
-	return len(s)
+func (s asciiString) length() int64 {
+	return int64(len(s))
 }
 }
 
 
 func (s asciiString) concat(other valueString) valueString {
 func (s asciiString) concat(other valueString) valueString {
@@ -253,7 +253,7 @@ func (s asciiString) concat(other valueString) valueString {
 	}
 	}
 }
 }
 
 
-func (s asciiString) substring(start, end int) valueString {
+func (s asciiString) substring(start, end int64) valueString {
 	return asciiString(s[start:end])
 	return asciiString(s[start:end])
 }
 }
 
 
@@ -268,9 +268,9 @@ func (s asciiString) compareTo(other valueString) int {
 	}
 	}
 }
 }
 
 
-func (s asciiString) index(substr valueString, start int) int {
+func (s asciiString) index(substr valueString, start int64) int64 {
 	if substr, ok := substr.(asciiString); ok {
 	if substr, ok := substr.(asciiString); ok {
-		p := strings.Index(string(s[start:]), string(substr))
+		p := int64(strings.Index(string(s[start:]), string(substr)))
 		if p >= 0 {
 		if p >= 0 {
 			return p + start
 			return p + start
 		}
 		}
@@ -278,16 +278,16 @@ func (s asciiString) index(substr valueString, start int) int {
 	return -1
 	return -1
 }
 }
 
 
-func (s asciiString) lastIndex(substr valueString, pos int) int {
+func (s asciiString) lastIndex(substr valueString, pos int64) int64 {
 	if substr, ok := substr.(asciiString); ok {
 	if substr, ok := substr.(asciiString); ok {
-		end := pos + len(substr)
+		end := pos + int64(len(substr))
 		var ss string
 		var ss string
-		if end > len(s) {
+		if end > int64(len(s)) {
 			ss = string(s)
 			ss = string(s)
 		} else {
 		} else {
 			ss = string(s[:end])
 			ss = string(s[:end])
 		}
 		}
-		return strings.LastIndex(ss, string(substr))
+		return int64(strings.LastIndex(ss, string(substr)))
 	}
 	}
 	return -1
 	return -1
 }
 }

+ 9 - 9
string_unicode.go

@@ -173,12 +173,12 @@ func (s unicodeString) baseObject(r *Runtime) *Object {
 	return ss.val
 	return ss.val
 }
 }
 
 
-func (s unicodeString) charAt(idx int) rune {
+func (s unicodeString) charAt(idx int64) rune {
 	return rune(s[idx])
 	return rune(s[idx])
 }
 }
 
 
-func (s unicodeString) length() int {
-	return len(s)
+func (s unicodeString) length() int64 {
+	return int64(len(s))
 }
 }
 
 
 func (s unicodeString) concat(other valueString) valueString {
 func (s unicodeString) concat(other valueString) valueString {
@@ -198,7 +198,7 @@ func (s unicodeString) concat(other valueString) valueString {
 	}
 	}
 }
 }
 
 
-func (s unicodeString) substring(start, end int) valueString {
+func (s unicodeString) substring(start, end int64) valueString {
 	ss := s[start:end]
 	ss := s[start:end]
 	for _, c := range ss {
 	for _, c := range ss {
 		if c >= utf8.RuneSelf {
 		if c >= utf8.RuneSelf {
@@ -220,7 +220,7 @@ func (s unicodeString) compareTo(other valueString) int {
 	return strings.Compare(s.String(), other.String())
 	return strings.Compare(s.String(), other.String())
 }
 }
 
 
-func (s unicodeString) index(substr valueString, start int) int {
+func (s unicodeString) index(substr valueString, start int64) int64 {
 	var ss []uint16
 	var ss []uint16
 	switch substr := substr.(type) {
 	switch substr := substr.(type) {
 	case unicodeString:
 	case unicodeString:
@@ -235,9 +235,9 @@ func (s unicodeString) index(substr valueString, start int) int {
 	}
 	}
 
 
 	// TODO: optimise
 	// TODO: optimise
-	end := len(s) - len(ss)
+	end := int64(len(s) - len(ss))
 	for start < end {
 	for start < end {
-		for i := 0; i < len(ss); i++ {
+		for i := int64(0); i < int64(len(ss)); i++ {
 			if s[start+i] != ss[i] {
 			if s[start+i] != ss[i] {
 				goto nomatch
 				goto nomatch
 			}
 			}
@@ -250,7 +250,7 @@ func (s unicodeString) index(substr valueString, start int) int {
 	return -1
 	return -1
 }
 }
 
 
-func (s unicodeString) lastIndex(substr valueString, start int) int {
+func (s unicodeString) lastIndex(substr valueString, start int64) int64 {
 	var ss []uint16
 	var ss []uint16
 	switch substr := substr.(type) {
 	switch substr := substr.(type) {
 	case unicodeString:
 	case unicodeString:
@@ -266,7 +266,7 @@ func (s unicodeString) lastIndex(substr valueString, start int) int {
 
 
 	// TODO: optimise
 	// TODO: optimise
 	for start >= 0 {
 	for start >= 0 {
-		for i := 0; i < len(ss); i++ {
+		for i := int64(0); i < int64(len(ss)); i++ {
 			if s[start+i] != ss[i] {
 			if s[start+i] != ss[i] {
 				goto nomatch
 				goto nomatch
 			}
 			}