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