/* | |
* Copyright (C) 1999-2000,2003 Harri Porten (porten@kde.org) | |
* Copyright (C) 2007, 2008 Apple Inc. All rights reserved. | |
* | |
* This library is free software; you can redistribute it and/or | |
* modify it under the terms of the GNU Lesser General Public | |
* License as published by the Free Software Foundation; either | |
* version 2 of the License, or (at your option) any later version. | |
* | |
* This library is distributed in the hope that it will be useful, | |
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
* Lesser General Public License for more details. | |
* | |
* You should have received a copy of the GNU Lesser General Public | |
* License along with this library; if not, write to the Free Software | |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 | |
* USA | |
* | |
*/ | |
#include "config.h" | |
#include "NumberPrototype.h" | |
#include "Error.h" | |
#include "JSFunction.h" | |
#include "JSString.h" | |
#include "Operations.h" | |
#include "PrototypeFunction.h" | |
#include "StringBuilder.h" | |
#include "dtoa.h" | |
#include <wtf/Assertions.h> | |
#include <wtf/MathExtras.h> | |
#include <wtf/Vector.h> | |
namespace JSC { | |
ASSERT_CLASS_FITS_IN_CELL(NumberPrototype); | |
static JSValue JSC_HOST_CALL numberProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&); | |
static JSValue JSC_HOST_CALL numberProtoFuncToLocaleString(ExecState*, JSObject*, JSValue, const ArgList&); | |
static JSValue JSC_HOST_CALL numberProtoFuncValueOf(ExecState*, JSObject*, JSValue, const ArgList&); | |
static JSValue JSC_HOST_CALL numberProtoFuncToFixed(ExecState*, JSObject*, JSValue, const ArgList&); | |
static JSValue JSC_HOST_CALL numberProtoFuncToExponential(ExecState*, JSObject*, JSValue, const ArgList&); | |
static JSValue JSC_HOST_CALL numberProtoFuncToPrecision(ExecState*, JSObject*, JSValue, const ArgList&); | |
// ECMA 15.7.4 | |
NumberPrototype::NumberPrototype(ExecState* exec, NonNullPassRefPtr<Structure> structure, Structure* prototypeFunctionStructure) | |
: NumberObject(structure) | |
{ | |
setInternalValue(jsNumber(exec, 0)); | |
// The constructor will be added later, after NumberConstructor has been constructed | |
putDirectFunctionWithoutTransition(exec, new (exec) NativeFunctionWrapper(exec, prototypeFunctionStructure, 1, exec->propertyNames().toString, numberProtoFuncToString), DontEnum); | |
putDirectFunctionWithoutTransition(exec, new (exec) NativeFunctionWrapper(exec, prototypeFunctionStructure, 0, exec->propertyNames().toLocaleString, numberProtoFuncToLocaleString), DontEnum); | |
putDirectFunctionWithoutTransition(exec, new (exec) NativeFunctionWrapper(exec, prototypeFunctionStructure, 0, exec->propertyNames().valueOf, numberProtoFuncValueOf), DontEnum); | |
putDirectFunctionWithoutTransition(exec, new (exec) NativeFunctionWrapper(exec, prototypeFunctionStructure, 1, exec->propertyNames().toFixed, numberProtoFuncToFixed), DontEnum); | |
putDirectFunctionWithoutTransition(exec, new (exec) NativeFunctionWrapper(exec, prototypeFunctionStructure, 1, exec->propertyNames().toExponential, numberProtoFuncToExponential), DontEnum); | |
putDirectFunctionWithoutTransition(exec, new (exec) NativeFunctionWrapper(exec, prototypeFunctionStructure, 1, exec->propertyNames().toPrecision, numberProtoFuncToPrecision), DontEnum); | |
} | |
// ------------------------------ Functions --------------------------- | |
// ECMA 15.7.4.2 - 15.7.4.7 | |
static UString integerPartNoExp(double d) | |
{ | |
int decimalPoint; | |
int sign; | |
char result[80]; | |
WTF::dtoa(result, d, 0, &decimalPoint, &sign, NULL); | |
bool resultIsInfOrNan = (decimalPoint == 9999); | |
size_t length = strlen(result); | |
StringBuilder builder; | |
builder.append(sign ? "-" : ""); | |
if (resultIsInfOrNan) | |
builder.append((const char*)result); | |
else if (decimalPoint <= 0) | |
builder.append("0"); | |
else { | |
Vector<char, 1024> buf(decimalPoint + 1); | |
if (static_cast<int>(length) <= decimalPoint) { | |
ASSERT(decimalPoint < 1024); | |
memcpy(buf.data(), result, length); | |
memset(buf.data() + length, '0', decimalPoint - length); | |
} else | |
strncpy(buf.data(), result, decimalPoint); | |
buf[decimalPoint] = '\0'; | |
builder.append((const char*)(buf.data())); | |
} | |
return builder.release(); | |
} | |
static UString charSequence(char c, int count) | |
{ | |
Vector<char, 2048> buf(count + 1, c); | |
buf[count] = '\0'; | |
return UString(buf.data()); | |
} | |
static double intPow10(int e) | |
{ | |
// This function uses the "exponentiation by squaring" algorithm and | |
// long double to quickly and precisely calculate integer powers of 10.0. | |
// This is a handy workaround for <rdar://problem/4494756> | |
if (e == 0) | |
return 1.0; | |
bool negative = e < 0; | |
unsigned exp = negative ? -e : e; | |
long double result = 10.0; | |
bool foundOne = false; | |
for (int bit = 31; bit >= 0; bit--) { | |
if (!foundOne) { | |
if ((exp >> bit) & 1) | |
foundOne = true; | |
} else { | |
result = result * result; | |
if ((exp >> bit) & 1) | |
result = result * 10.0; | |
} | |
} | |
if (negative) | |
return static_cast<double>(1.0 / result); | |
return static_cast<double>(result); | |
} | |
JSValue JSC_HOST_CALL numberProtoFuncToString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args) | |
{ | |
JSValue v = thisValue.getJSNumber(); | |
if (!v) | |
return throwError(exec, TypeError); | |
double radixAsDouble = args.at(0).toInteger(exec); // nan -> 0 | |
if (radixAsDouble == 10 || args.at(0).isUndefined()) | |
return jsString(exec, v.toString(exec)); | |
if (radixAsDouble < 2 || radixAsDouble > 36) | |
return throwError(exec, RangeError, "toString() radix argument must be between 2 and 36"); | |
int radix = static_cast<int>(radixAsDouble); | |
const char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; | |
// INT_MAX results in 1024 characters left of the dot with radix 2 | |
// give the same space on the right side. safety checks are in place | |
// unless someone finds a precise rule. | |
char s[2048 + 3]; | |
const char* lastCharInString = s + sizeof(s) - 1; | |
double x = v.uncheckedGetNumber(); | |
if (isnan(x) || isinf(x)) | |
return jsString(exec, UString::from(x)); | |
bool isNegative = x < 0.0; | |
if (isNegative) | |
x = -x; | |
double integerPart = floor(x); | |
char* decimalPoint = s + sizeof(s) / 2; | |
// convert integer portion | |
char* p = decimalPoint; | |
double d = integerPart; | |
do { | |
int remainderDigit = static_cast<int>(fmod(d, radix)); | |
*--p = digits[remainderDigit]; | |
d /= radix; | |
} while ((d <= -1.0 || d >= 1.0) && s < p); | |
if (isNegative) | |
*--p = '-'; | |
char* startOfResultString = p; | |
ASSERT(s <= startOfResultString); | |
d = x - integerPart; | |
p = decimalPoint; | |
const double epsilon = 0.001; // TODO: guessed. base on radix ? | |
bool hasFractionalPart = (d < -epsilon || d > epsilon); | |
if (hasFractionalPart) { | |
*p++ = '.'; | |
do { | |
d *= radix; | |
const int digit = static_cast<int>(d); | |
*p++ = digits[digit]; | |
d -= digit; | |
} while ((d < -epsilon || d > epsilon) && p < lastCharInString); | |
} | |
*p = '\0'; | |
ASSERT(p < s + sizeof(s)); | |
return jsString(exec, startOfResultString); | |
} | |
JSValue JSC_HOST_CALL numberProtoFuncToLocaleString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&) | |
{ | |
// FIXME: Not implemented yet. | |
JSValue v = thisValue.getJSNumber(); | |
if (!v) | |
return throwError(exec, TypeError); | |
return jsString(exec, v.toString(exec)); | |
} | |
JSValue JSC_HOST_CALL numberProtoFuncValueOf(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&) | |
{ | |
JSValue v = thisValue.getJSNumber(); | |
if (!v) | |
return throwError(exec, TypeError); | |
return v; | |
} | |
JSValue JSC_HOST_CALL numberProtoFuncToFixed(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args) | |
{ | |
JSValue v = thisValue.getJSNumber(); | |
if (!v) | |
return throwError(exec, TypeError); | |
JSValue fractionDigits = args.at(0); | |
double df = fractionDigits.toInteger(exec); | |
if (!(df >= 0 && df <= 20)) | |
return throwError(exec, RangeError, "toFixed() digits argument must be between 0 and 20"); | |
int f = static_cast<int>(df); | |
double x = v.uncheckedGetNumber(); | |
if (isnan(x)) | |
return jsNontrivialString(exec, "NaN"); | |
UString s; | |
if (x < 0) { | |
s = "-"; | |
x = -x; | |
} else { | |
s = ""; | |
if (x == -0.0) | |
x = 0; | |
} | |
if (x >= pow(10.0, 21.0)) | |
return jsString(exec, makeString(s, UString::from(x))); | |
const double tenToTheF = pow(10.0, f); | |
double n = floor(x * tenToTheF); | |
if (fabs(n / tenToTheF - x) >= fabs((n + 1) / tenToTheF - x)) | |
n++; | |
UString m = integerPartNoExp(n); | |
int k = m.size(); | |
if (k <= f) { | |
StringBuilder z; | |
for (int i = 0; i < f + 1 - k; i++) | |
z.append('0'); | |
z.append(m); | |
m = z.release(); | |
k = f + 1; | |
ASSERT(k == m.size()); | |
} | |
int kMinusf = k - f; | |
if (kMinusf < m.size()) | |
return jsString(exec, makeString(s, m.substr(0, kMinusf), ".", m.substr(kMinusf))); | |
return jsString(exec, makeString(s, m.substr(0, kMinusf))); | |
} | |
static void fractionalPartToString(char* buf, int& i, const char* result, int resultLength, int fractionalDigits) | |
{ | |
if (fractionalDigits <= 0) | |
return; | |
int fDigitsInResult = static_cast<int>(resultLength) - 1; | |
buf[i++] = '.'; | |
if (fDigitsInResult > 0) { | |
if (fractionalDigits < fDigitsInResult) { | |
strncpy(buf + i, result + 1, fractionalDigits); | |
i += fractionalDigits; | |
} else { | |
ASSERT(i + resultLength - 1 < 80); | |
memcpy(buf + i, result + 1, resultLength - 1); | |
i += static_cast<int>(resultLength) - 1; | |
} | |
} | |
for (int j = 0; j < fractionalDigits - fDigitsInResult; j++) | |
buf[i++] = '0'; | |
} | |
static void exponentialPartToString(char* buf, int& i, int decimalPoint) | |
{ | |
buf[i++] = 'e'; | |
// decimalPoint can't be more than 3 digits decimal given the | |
// nature of float representation | |
int exponential = decimalPoint - 1; | |
buf[i++] = (exponential >= 0) ? '+' : '-'; | |
if (exponential < 0) | |
exponential *= -1; | |
if (exponential >= 100) | |
buf[i++] = static_cast<char>('0' + exponential / 100); | |
if (exponential >= 10) | |
buf[i++] = static_cast<char>('0' + (exponential % 100) / 10); | |
buf[i++] = static_cast<char>('0' + exponential % 10); | |
} | |
JSValue JSC_HOST_CALL numberProtoFuncToExponential(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args) | |
{ | |
JSValue v = thisValue.getJSNumber(); | |
if (!v) | |
return throwError(exec, TypeError); | |
double x = v.uncheckedGetNumber(); | |
if (isnan(x) || isinf(x)) | |
return jsString(exec, UString::from(x)); | |
JSValue fractionalDigitsValue = args.at(0); | |
double df = fractionalDigitsValue.toInteger(exec); | |
if (!(df >= 0 && df <= 20)) | |
return throwError(exec, RangeError, "toExponential() argument must between 0 and 20"); | |
int fractionalDigits = static_cast<int>(df); | |
bool includeAllDigits = fractionalDigitsValue.isUndefined(); | |
int decimalAdjust = 0; | |
if (x && !includeAllDigits) { | |
double logx = floor(log10(fabs(x))); | |
x /= pow(10.0, logx); | |
const double tenToTheF = pow(10.0, fractionalDigits); | |
double fx = floor(x * tenToTheF) / tenToTheF; | |
double cx = ceil(x * tenToTheF) / tenToTheF; | |
if (fabs(fx - x) < fabs(cx - x)) | |
x = fx; | |
else | |
x = cx; | |
decimalAdjust = static_cast<int>(logx); | |
} | |
if (isnan(x)) | |
return jsNontrivialString(exec, "NaN"); | |
if (x == -0.0) // (-0.0).toExponential() should print as 0 instead of -0 | |
x = 0; | |
int decimalPoint; | |
int sign; | |
char result[80]; | |
WTF::dtoa(result, x, 0, &decimalPoint, &sign, NULL); | |
size_t resultLength = strlen(result); | |
decimalPoint += decimalAdjust; | |
int i = 0; | |
char buf[80]; // digit + '.' + fractionDigits (max 20) + 'e' + sign + exponent (max?) | |
if (sign) | |
buf[i++] = '-'; | |
// ? 9999 is the magical "result is Inf or NaN" value. what's 999?? | |
if (decimalPoint == 999) { | |
ASSERT(i + resultLength < 80); | |
memcpy(buf + i, result, resultLength); | |
buf[i + resultLength] = '\0'; | |
} else { | |
buf[i++] = result[0]; | |
if (includeAllDigits) | |
fractionalDigits = static_cast<int>(resultLength) - 1; | |
fractionalPartToString(buf, i, result, resultLength, fractionalDigits); | |
exponentialPartToString(buf, i, decimalPoint); | |
buf[i++] = '\0'; | |
} | |
ASSERT(i <= 80); | |
return jsString(exec, buf); | |
} | |
JSValue JSC_HOST_CALL numberProtoFuncToPrecision(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args) | |
{ | |
JSValue v = thisValue.getJSNumber(); | |
if (!v) | |
return throwError(exec, TypeError); | |
double doublePrecision = args.at(0).toIntegerPreserveNaN(exec); | |
double x = v.uncheckedGetNumber(); | |
if (args.at(0).isUndefined() || isnan(x) || isinf(x)) | |
return jsString(exec, v.toString(exec)); | |
UString s; | |
if (x < 0) { | |
s = "-"; | |
x = -x; | |
} else | |
s = ""; | |
if (!(doublePrecision >= 1 && doublePrecision <= 21)) // true for NaN | |
return throwError(exec, RangeError, "toPrecision() argument must be between 1 and 21"); | |
int precision = static_cast<int>(doublePrecision); | |
int e = 0; | |
UString m; | |
if (x) { | |
e = static_cast<int>(log10(x)); | |
double tens = intPow10(e - precision + 1); | |
double n = floor(x / tens); | |
if (n < intPow10(precision - 1)) { | |
e = e - 1; | |
tens = intPow10(e - precision + 1); | |
n = floor(x / tens); | |
} | |
if (fabs((n + 1.0) * tens - x) <= fabs(n * tens - x)) | |
++n; | |
// maintain n < 10^(precision) | |
if (n >= intPow10(precision)) { | |
n /= 10.0; | |
e += 1; | |
} | |
ASSERT(intPow10(precision - 1) <= n); | |
ASSERT(n < intPow10(precision)); | |
m = integerPartNoExp(n); | |
if (e < -6 || e >= precision) { | |
if (m.size() > 1) | |
m = makeString(m.substr(0, 1), ".", m.substr(1)); | |
if (e >= 0) | |
return jsNontrivialString(exec, makeString(s, m, "e+", UString::from(e))); | |
return jsNontrivialString(exec, makeString(s, m, "e-", UString::from(-e))); | |
} | |
} else { | |
m = charSequence('0', precision); | |
e = 0; | |
} | |
if (e == precision - 1) | |
return jsString(exec, makeString(s, m)); | |
if (e >= 0) { | |
if (e + 1 < m.size()) | |
return jsString(exec, makeString(s, m.substr(0, e + 1), ".", m.substr(e + 1))); | |
return jsString(exec, makeString(s, m)); | |
} | |
return jsNontrivialString(exec, makeString(s, "0.", charSequence('0', -(e + 1)), m)); | |
} | |
} // namespace JSC |