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