package otto
import (
"fmt"
"math"
"regexp"
"strconv"
"strings"
)
var stringToNumberParseInteger = regexp.MustCompile(`^(?:0[xX])`)
func parseNumber(value string) float64 {
value = strings.Trim(value, builtinString_trim_whitespace)
if value == "" {
return 0
}
parseFloat := false
if strings.IndexRune(value, '.') != -1 {
parseFloat = true
} else if stringToNumberParseInteger.MatchString(value) {
parseFloat = false
} else {
parseFloat = true
}
if parseFloat {
number, err := strconv.ParseFloat(value, 64)
if err != nil && err.(*strconv.NumError).Err != strconv.ErrRange {
return math.NaN()
}
return number
}
number, err := strconv.ParseInt(value, 0, 64)
if err != nil {
return math.NaN()
}
return float64(number)
}
func (value Value) float64() float64 {
switch value.kind {
case valueUndefined:
return math.NaN()
case valueNull:
return 0
}
switch value := value.value.(type) {
case bool:
if value {
return 1
}
return 0
case int:
return float64(value)
case int8:
return float64(value)
case int16:
return float64(value)
case int32:
return float64(value)
case int64:
return float64(value)
case uint:
return float64(value)
case uint8:
return float64(value)
case uint16:
return float64(value)
case uint32:
return float64(value)
case uint64:
return float64(value)
case float64:
return value
case string:
return parseNumber(value)
case *_object:
return value.DefaultValue(defaultValueHintNumber).float64()
}
panic(fmt.Errorf("toFloat(%T)", value.value))
}
const (
float_2_64 float64 = 18446744073709551616.0
float_2_63 float64 = 9223372036854775808.0
float_2_32 float64 = 4294967296.0
float_2_31 float64 = 2147483648.0
float_2_16 float64 = 65536.0
integer_2_32 int64 = 4294967296
integer_2_31 int64 = 2146483648
sqrt1_2 float64 = math.Sqrt2 / 2
)
const (
maxInt8 = math.MaxInt8
minInt8 = math.MinInt8
maxInt16 = math.MaxInt16
minInt16 = math.MinInt16
maxInt32 = math.MaxInt32
minInt32 = math.MinInt32
maxInt64 = math.MaxInt64
minInt64 = math.MinInt64
maxUint8 = math.MaxUint8
maxUint16 = math.MaxUint16
maxUint32 = math.MaxUint32
maxUint64 = math.MaxUint64
maxUint = ^uint(0)
minUint = 0
maxInt = int(^uint(0) >> 1)
minInt = -maxInt - 1
// int64
int64_maxInt int64 = int64(maxInt)
int64_minInt int64 = int64(minInt)
int64_maxInt8 int64 = math.MaxInt8
int64_minInt8 int64 = math.MinInt8
int64_maxInt16 int64 = math.MaxInt16
int64_minInt16 int64 = math.MinInt16
int64_maxInt32 int64 = math.MaxInt32
int64_minInt32 int64 = math.MinInt32
int64_maxUint8 int64 = math.MaxUint8
int64_maxUint16 int64 = math.MaxUint16
int64_maxUint32 int64 = math.MaxUint32
// float64
float_maxInt float64 = float64(int(^uint(0) >> 1))
float_minInt float64 = float64(int(-maxInt - 1))
float_minUint float64 = float64(0)
float_maxUint float64 = float64(uint(^uint(0)))
float_minUint64 float64 = float64(0)
float_maxUint64 float64 = math.MaxUint64
float_maxInt64 float64 = math.MaxInt64
float_minInt64 float64 = math.MinInt64
)
func toIntegerFloat(value Value) float64 {
float := value.float64()
if math.IsInf(float, 0) {
} else if math.IsNaN(float) {
float = 0
} else if float > 0 {
float = math.Floor(float)
} else {
float = math.Ceil(float)
}
return float
}
type _numberKind int
const (
numberInteger _numberKind = iota // 3.0 => 3.0
numberFloat // 3.14159 => 3.0, 1+2**63 > 2**63-1
numberInfinity // Infinity => 2**63-1
numberNaN // NaN => 0
)
type _number struct {
kind _numberKind
int64 int64
float64 float64
}
// FIXME
// http://www.goinggo.net/2013/08/gustavos-ieee-754-brain-teaser.html
// http://bazaar.launchpad.net/~niemeyer/strepr/trunk/view/6/strepr.go#L160
func (value Value) number() (number _number) {
switch value := value.value.(type) {
case int8:
number.int64 = int64(value)
return
case int16:
number.int64 = int64(value)
return
case uint8:
number.int64 = int64(value)
return
case uint16:
number.int64 = int64(value)
return
case uint32:
number.int64 = int64(value)
return
case int:
number.int64 = int64(value)
return
case int64:
number.int64 = value
return
}
float := value.float64()
if float == 0 {
return
}
number.kind = numberFloat
number.float64 = float
if math.IsNaN(float) {
number.kind = numberNaN
return
}
if math.IsInf(float, 0) {
number.kind = numberInfinity
}
if float >= float_maxInt64 {
number.int64 = math.MaxInt64
return
}
if float <= float_minInt64 {
number.int64 = math.MinInt64
return
}
integer := float64(0)
if float > 0 {
integer = math.Floor(float)
} else {
integer = math.Ceil(float)
}
if float == integer {
number.kind = numberInteger
}
number.int64 = int64(float)
return
}
// ECMA 262: 9.5
func toInt32(value Value) int32 {
{
switch value := value.value.(type) {
case int8:
return int32(value)
case int16:
return int32(value)
case int32:
return value
}
}
floatValue := value.float64()
if math.IsNaN(floatValue) || math.IsInf(floatValue, 0) {
return 0
}
if floatValue == 0 { // This will work for +0 & -0
return 0
}
remainder := math.Mod(floatValue, float_2_32)
if remainder > 0 {
remainder = math.Floor(remainder)
} else {
remainder = math.Ceil(remainder) + float_2_32
}
if remainder > float_2_31 {
return int32(remainder - float_2_32)
}
return int32(remainder)
}
func toUint32(value Value) uint32 {
{
switch value := value.value.(type) {
case int8:
return uint32(value)
case int16:
return uint32(value)
case uint8:
return uint32(value)
case uint16:
return uint32(value)
case uint32:
return value
}
}
floatValue := value.float64()
if math.IsNaN(floatValue) || math.IsInf(floatValue, 0) {
return 0
}
if floatValue == 0 {
return 0
}
remainder := math.Mod(floatValue, float_2_32)
if remainder > 0 {
remainder = math.Floor(remainder)
} else {
remainder = math.Ceil(remainder) + float_2_32
}
return uint32(remainder)
}
func toUint16(value Value) uint16 {
{
switch value := value.value.(type) {
case int8:
return uint16(value)
case uint8:
return uint16(value)
case uint16:
return value
}
}
floatValue := value.float64()
if math.IsNaN(floatValue) || math.IsInf(floatValue, 0) {
return 0
}
if floatValue == 0 {
return 0
}
remainder := math.Mod(floatValue, float_2_16)
if remainder > 0 {
remainder = math.Floor(remainder)
} else {
remainder = math.Ceil(remainder) + float_2_16
}
return uint16(remainder)
}