c88bcbc57ba8f6149510a80ecb7bad736f479361
[WebKit-https.git] / JavaScriptCore / kjs / number_object.cpp
1 // -*- c-basic-offset: 2 -*-
2 /*
3  *  Copyright (C) 1999-2000,2003 Harri Porten (porten@kde.org)
4  *  Copyright (C) 2007 Apple Inc. All rights reserved.
5  *
6  *  This library is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU Lesser General Public
8  *  License as published by the Free Software Foundation; either
9  *  version 2 of the License, or (at your option) any later version.
10  *
11  *  This library is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  *  Lesser General Public License for more details.
15  *
16  *  You should have received a copy of the GNU Lesser General Public
17  *  License along with this library; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
19  *  USA
20  *
21  */
22
23 #include "config.h"
24 #include "number_object.h"
25 #include "number_object.lut.h"
26
27 #include "dtoa.h"
28 #include "error_object.h"
29 #include "operations.h"
30 #include <wtf/Assertions.h>
31 #include <wtf/MathExtras.h>
32 #include <wtf/Vector.h>
33
34 namespace KJS {
35
36 // ------------------------------ NumberInstance ----------------------------
37
38 const ClassInfo NumberInstance::info = { "Number", 0, 0 };
39
40 NumberInstance::NumberInstance(JSObject* proto)
41     : JSWrapperObject(proto)
42 {
43 }
44 // ------------------------------ NumberPrototype ---------------------------
45
46 // ECMA 15.7.4
47
48 NumberPrototype::NumberPrototype(ExecState* exec, ObjectPrototype* objProto, FunctionPrototype* funcProto)
49     : NumberInstance(objProto)
50 {
51     setInternalValue(jsNumber(0));
52
53     // The constructor will be added later, after NumberObjectImp has been constructed
54
55     putDirectFunction(new NumberProtoFunc(exec, funcProto, NumberProtoFunc::ToString,       1, exec->propertyNames().toString), DontEnum);
56     putDirectFunction(new NumberProtoFunc(exec, funcProto, NumberProtoFunc::ToLocaleString, 0, exec->propertyNames().toLocaleString), DontEnum);
57     putDirectFunction(new NumberProtoFunc(exec, funcProto, NumberProtoFunc::ValueOf,        0, exec->propertyNames().valueOf), DontEnum);
58     putDirectFunction(new NumberProtoFunc(exec, funcProto, NumberProtoFunc::ToFixed,        1, exec->propertyNames().toFixed), DontEnum);
59     putDirectFunction(new NumberProtoFunc(exec, funcProto, NumberProtoFunc::ToExponential,  1, exec->propertyNames().toExponential), DontEnum);
60     putDirectFunction(new NumberProtoFunc(exec, funcProto, NumberProtoFunc::ToPrecision,    1, exec->propertyNames().toPrecision), DontEnum);
61 }
62
63
64 // ------------------------------ NumberProtoFunc ---------------------------
65
66 NumberProtoFunc::NumberProtoFunc(ExecState* exec, FunctionPrototype* funcProto, int i, int len, const Identifier& name)
67     : InternalFunctionImp(funcProto, name)
68     , id(i)
69 {
70     putDirect(exec->propertyNames().length, len, DontDelete|ReadOnly|DontEnum);
71 }
72
73 static UString integer_part_noexp(double d)
74 {
75     int decimalPoint;
76     int sign;
77     char* result = kjs_dtoa(d, 0, 0, &decimalPoint, &sign, NULL);
78     bool resultIsInfOrNan = (decimalPoint == 9999);
79     size_t length = strlen(result);
80
81     UString str = sign ? "-" : "";
82     if (resultIsInfOrNan)
83         str += result;
84     else if (decimalPoint <= 0)
85         str += "0";
86     else {
87         Vector<char, 1024> buf(decimalPoint + 1);
88
89         if (static_cast<int>(length) <= decimalPoint) {
90             strcpy(buf.data(), result);
91             memset(buf.data() + length, '0', decimalPoint - length);
92         } else
93             strncpy(buf.data(), result, decimalPoint);
94
95         buf[decimalPoint] = '\0';
96         str += UString(buf.data());
97     }
98
99     kjs_freedtoa(result);
100
101     return str;
102 }
103
104 static UString char_sequence(char c, int count)
105 {
106     Vector<char, 2048> buf(count + 1, c);
107     buf[count] = '\0';
108
109     return UString(buf.data());
110 }
111
112 static double intPow10(int e)
113 {
114     // This function uses the "exponentiation by squaring" algorithm and
115     // long double to quickly and precisely calculate integer powers of 10.0.
116
117     // This is a handy workaround for <rdar://problem/4494756>
118
119     if (e == 0)
120         return 1.0;
121
122     bool negative = e < 0;
123     unsigned exp = negative ? -e : e;
124
125     long double result = 10.0;
126     bool foundOne = false;
127     for (int bit = 31; bit >= 0; bit--) {
128         if (!foundOne) {
129             if ((exp >> bit) & 1)
130                 foundOne = true;
131         } else {
132             result = result * result;
133             if ((exp >> bit) & 1)
134                 result = result * 10.0;
135         }
136     }
137
138     if (negative)
139         return static_cast<double>(1.0 / result);
140     return static_cast<double>(result);
141 }
142
143 static JSValue* numberToString(ExecState* exec, JSValue* v, const List& args)
144 {
145     double radixAsDouble = args[0]->toInteger(exec); // nan -> 0
146     if (radixAsDouble == 10 || args[0]->isUndefined())
147         return jsString(v->toString(exec));
148
149     if (radixAsDouble < 2 || radixAsDouble > 36)
150         return throwError(exec, RangeError, "toString() radix argument must be between 2 and 36");
151
152     int radix = static_cast<int>(radixAsDouble);
153     const char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
154     // INT_MAX results in 1024 characters left of the dot with radix 2
155     // give the same space on the right side. safety checks are in place
156     // unless someone finds a precise rule.
157     char s[2048 + 3];
158     const char* lastCharInString = s + sizeof(s) - 1;
159     double x = v->toNumber(exec);
160     if (isnan(x) || isinf(x))
161         return jsString(UString::from(x));
162
163     bool isNegative = x < 0.0;
164     if (isNegative)
165         x = -x;
166
167     double integerPart = floor(x);
168     char* decimalPoint = s + sizeof(s) / 2;
169
170     // convert integer portion
171     char* p = decimalPoint;
172     double d = integerPart;
173     do {
174         int remainderDigit = static_cast<int>(fmod(d, radix));
175         *--p = digits[remainderDigit];
176         d /= radix;
177     } while ((d <= -1.0 || d >= 1.0) && s < p);
178
179     if (isNegative)
180         *--p = '-';
181     char* startOfResultString = p;
182     ASSERT(s <= startOfResultString);
183
184     d = x - integerPart;
185     p = decimalPoint;
186     const double epsilon = 0.001; // TODO: guessed. base on radix ?
187     bool hasFractionalPart = (d < -epsilon || d > epsilon);
188     if (hasFractionalPart) {
189         *p++ = '.';
190         do {
191             d *= radix;
192             const int digit = static_cast<int>(d);
193             *p++ = digits[digit];
194             d -= digit;
195         } while ((d < -epsilon || d > epsilon) && p < lastCharInString);
196     }
197     *p = '\0';
198     ASSERT(p < s + sizeof(s));
199
200     return jsString(startOfResultString);
201 }
202
203 static JSValue* numberToFixed(ExecState* exec, JSValue* v, const List& args)
204 {
205     JSValue* fractionDigits = args[0];
206     double df = fractionDigits->toInteger(exec);
207     if (!(df >= 0 && df <= 20))
208         return throwError(exec, RangeError, "toFixed() digits argument must be between 0 and 20");
209     int f = (int)df;
210
211     double x = v->toNumber(exec);
212     if (isnan(x))
213         return jsString("NaN");
214
215     UString s;
216     if (x < 0) {
217         s.append('-');
218         x = -x;
219     } else if (x == -0.0)
220         x = 0;
221
222     if (x >= pow(10.0, 21.0))
223         return jsString(s + UString::from(x));
224
225     const double tenToTheF = pow(10.0, f);
226     double n = floor(x * tenToTheF);
227     if (fabs(n / tenToTheF - x) >= fabs((n + 1) / tenToTheF - x))
228         n++;
229
230     UString m = integer_part_noexp(n);
231
232     int k = m.size();
233     if (k <= f) {
234         UString z;
235         for (int i = 0; i < f + 1 - k; i++)
236             z.append('0');
237         m = z + m;
238         k = f + 1;
239         ASSERT(k == m.size());
240     }
241     int kMinusf = k - f;
242     if (kMinusf < m.size())
243         return jsString(s + m.substr(0, kMinusf) + "." + m.substr(kMinusf));
244     return jsString(s + m.substr(0, kMinusf));
245 }
246
247 void fractionalPartToString(char* buf, int& i, const char* result, int resultLength, int fractionalDigits)
248 {
249     if (fractionalDigits <= 0)
250         return;
251
252     int fDigitsInResult = static_cast<int>(resultLength) - 1;
253     buf[i++] = '.';
254     if (fDigitsInResult > 0) {
255         if (fractionalDigits < fDigitsInResult) {
256             strncpy(buf + i, result + 1, fractionalDigits);
257             i += fractionalDigits;
258         } else {
259             strcpy(buf + i, result + 1);
260             i += static_cast<int>(resultLength) - 1;
261         }
262     }
263
264     for (int j = 0; j < fractionalDigits - fDigitsInResult; j++)
265         buf[i++] = '0';
266 }
267
268 void exponentialPartToString(char* buf, int& i, int decimalPoint)
269 {
270     buf[i++] = 'e';
271     buf[i++] = (decimalPoint >= 0) ? '+' : '-';
272     // decimalPoint can't be more than 3 digits decimal given the
273     // nature of float representation
274     int exponential = decimalPoint - 1;
275     if (exponential < 0)
276         exponential *= -1;
277     if (exponential >= 100)
278         buf[i++] = static_cast<char>('0' + exponential / 100);
279     if (exponential >= 10)
280         buf[i++] = static_cast<char>('0' + (exponential % 100) / 10);
281     buf[i++] = static_cast<char>('0' + exponential % 10);
282 }
283
284 static JSValue* numberToExponential(ExecState* exec, JSValue* v, const List& args)
285 {
286     double x = v->toNumber(exec);
287
288     if (isnan(x) || isinf(x))
289         return jsString(UString::from(x));
290
291     JSValue* fractionalDigitsValue = args[0];
292     double df = fractionalDigitsValue->toInteger(exec);
293     if (!(df >= 0 && df <= 20))
294         return throwError(exec, RangeError, "toExponential() argument must between 0 and 20");
295     int fractionalDigits = (int)df;
296     bool includeAllDigits = fractionalDigitsValue->isUndefined();
297
298     int decimalAdjust = 0;
299     if (x && !includeAllDigits) {
300         double logx = floor(log10(fabs(x)));
301         x /= pow(10.0, logx);
302         const double tenToTheF = pow(10.0, fractionalDigits);
303         double fx = floor(x * tenToTheF) / tenToTheF;
304         double cx = ceil(x * tenToTheF) / tenToTheF;
305
306         if (fabs(fx - x) < fabs(cx - x))
307             x = fx;
308         else
309             x = cx;
310
311         decimalAdjust = static_cast<int>(logx);
312     }
313
314     if (isnan(x))
315         return jsString("NaN");
316
317     if (x == -0.0) // (-0.0).toExponential() should print as 0 instead of -0
318         x = 0;
319
320     int decimalPoint;
321     int sign;
322     char* result = kjs_dtoa(x, 0, 0, &decimalPoint, &sign, NULL);
323     size_t resultLength = strlen(result);
324     decimalPoint += decimalAdjust;
325
326     int i = 0;
327     char buf[80]; // digit + '.' + fractionDigits (max 20) + 'e' + sign + exponent (max?)
328     if (sign)
329         buf[i++] = '-';
330
331     if (decimalPoint == 999) // ? 9999 is the magical "result is Inf or NaN" value.  what's 999??
332         strcpy(buf + i, result);
333     else {
334         buf[i++] = result[0];
335
336         if (includeAllDigits)
337             fractionalDigits = static_cast<int>(resultLength) - 1;
338
339         fractionalPartToString(buf, i, result, resultLength, fractionalDigits);
340         exponentialPartToString(buf, i, decimalPoint);
341         buf[i++] = '\0';
342     }
343     ASSERT(i <= 80);
344
345     kjs_freedtoa(result);
346
347     return jsString(buf);
348 }
349     
350 static JSValue* numberToPrecision(ExecState* exec, JSValue* v, const List& args)
351 {
352     double doublePrecision = args[0]->toIntegerPreserveNaN(exec);
353     double x = v->toNumber(exec);
354     if (args[0]->isUndefined() || isnan(x) || isinf(x))
355         return jsString(v->toString(exec));
356
357     UString s;
358     if (x < 0) {
359         s = "-";
360         x = -x;
361     }
362
363     if (!(doublePrecision >= 1 && doublePrecision <= 21)) // true for NaN
364         return throwError(exec, RangeError, "toPrecision() argument must be between 1 and 21");
365     int precision = (int)doublePrecision;
366
367     int e = 0;
368     UString m;
369     if (x) {
370         e = static_cast<int>(log10(x));
371         double tens = intPow10(e - precision + 1);
372         double n = floor(x / tens);
373         if (n < intPow10(precision - 1)) {
374             e = e - 1;
375             tens = intPow10(e - precision + 1);
376             n = floor(x / tens);
377         }
378
379         if (fabs((n + 1.0) * tens - x) <= fabs(n * tens - x))
380             ++n;
381         // maintain n < 10^(precision)
382         if (n >= intPow10(precision)) {
383             n /= 10.0;
384             e += 1;
385         }
386         ASSERT(intPow10(precision - 1) <= n);
387         ASSERT(n < intPow10(precision));
388
389         m = integer_part_noexp(n);
390         if (e < -6 || e >= precision) {
391             if (m.size() > 1)
392                 m = m.substr(0, 1) + "." + m.substr(1);
393             if (e >= 0)
394                 return jsString(s + m + "e+" + UString::from(e));
395             return jsString(s + m + "e-" + UString::from(-e));
396         }
397     } else {
398         m = char_sequence('0', precision);
399         e = 0;
400     }
401
402     if (e == precision - 1)
403         return jsString(s + m);
404     else if (e >= 0) {
405         if (e + 1 < m.size())
406             return jsString(s + m.substr(0, e + 1) + "." + m.substr(e + 1));
407         return jsString(s + m);
408     }
409     return jsString(s + "0." + char_sequence('0', -(e + 1)) + m);
410 }
411
412 // ECMA 15.7.4.2 - 15.7.4.7
413 JSValue* NumberProtoFunc::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
414 {
415     // no generic function. "this" has to be a Number object
416     if (!thisObj->inherits(&NumberInstance::info))
417         return throwError(exec, TypeError);
418
419     JSValue* v = static_cast<NumberInstance*>(thisObj)->internalValue();
420     switch (id) {
421     case ToString:
422         return numberToString(exec, v, args);
423     case ToLocaleString: /* TODO */
424         return jsString(v->toString(exec));
425     case ValueOf:
426         return v->toJSNumber(exec);
427     case ToFixed:
428         return numberToFixed(exec, v, args);
429     case ToExponential:
430         return numberToExponential(exec, v, args);
431     case ToPrecision:
432         return numberToPrecision(exec, v, args);
433     }
434     return 0;
435 }
436
437 // ------------------------------ NumberObjectImp ------------------------------
438
439 const ClassInfo NumberObjectImp::info = { "Function", &InternalFunctionImp::info, &numberTable };
440
441 /* Source for number_object.lut.h
442 @begin numberTable 5
443   NaN                   NumberObjectImp::NaNValue       DontEnum|DontDelete|ReadOnly
444   NEGATIVE_INFINITY     NumberObjectImp::NegInfinity    DontEnum|DontDelete|ReadOnly
445   POSITIVE_INFINITY     NumberObjectImp::PosInfinity    DontEnum|DontDelete|ReadOnly
446   MAX_VALUE             NumberObjectImp::MaxValue       DontEnum|DontDelete|ReadOnly
447   MIN_VALUE             NumberObjectImp::MinValue       DontEnum|DontDelete|ReadOnly
448 @end
449 */
450 NumberObjectImp::NumberObjectImp(ExecState* exec, FunctionPrototype* funcProto, NumberPrototype* numberProto)
451     : InternalFunctionImp(funcProto)
452 {
453     // Number.Prototype
454     putDirect(exec->propertyNames().prototype, numberProto, DontEnum|DontDelete|ReadOnly);
455
456     // no. of arguments for constructor
457     putDirect(exec->propertyNames().length, jsNumber(1), ReadOnly|DontDelete|DontEnum);
458 }
459
460 bool NumberObjectImp::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
461 {
462     return getStaticValueSlot<NumberObjectImp, InternalFunctionImp>(exec, &numberTable, this, propertyName, slot);
463 }
464
465 JSValue* NumberObjectImp::getValueProperty(ExecState*, int token) const
466 {
467     // ECMA 15.7.3
468     switch (token) {
469     case NaNValue:
470         return jsNaN();
471     case NegInfinity:
472         return jsNumberCell(-Inf);
473     case PosInfinity:
474         return jsNumberCell(Inf);
475     case MaxValue:
476         return jsNumberCell(1.7976931348623157E+308);
477     case MinValue:
478         return jsNumberCell(5E-324);
479     }
480     return jsNull();
481 }
482
483 bool NumberObjectImp::implementsConstruct() const
484 {
485     return true;
486 }
487
488 // ECMA 15.7.1
489 JSObject* NumberObjectImp::construct(ExecState* exec, const List& args)
490 {
491     JSObject* proto = exec->lexicalGlobalObject()->numberPrototype();
492     NumberInstance* obj = new NumberInstance(proto);
493
494     double n = args.isEmpty() ? 0 : args[0]->toNumber(exec);
495     obj->setInternalValue(jsNumber(n));
496     return obj;
497 }
498
499 // ECMA 15.7.2
500 JSValue* NumberObjectImp::callAsFunction(ExecState* exec, JSObject*, const List& args)
501 {
502     double n = args.isEmpty() ? 0 : args[0]->toNumber(exec);
503     return jsNumber(n);
504 }
505
506 } // namespace KJS