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(0));
  59
  60     // The constructor will be added later, after NumberObjectImp has been constructed
  61
  62     putDirectFunction(new PrototypeFunction(exec, functionPrototype, 1, exec->propertyNames().toString, numberProtoFuncToString), DontEnum);
  63     putDirectFunction(new PrototypeFunction(exec, functionPrototype, 0, exec->propertyNames().toLocaleString, numberProtoFuncToLocaleString), DontEnum);
  64     putDirectFunction(new PrototypeFunction(exec, functionPrototype, 0, exec->propertyNames().valueOf, numberProtoFuncValueOf), DontEnum);
  65     putDirectFunction(new PrototypeFunction(exec, functionPrototype, 1, exec->propertyNames().toFixed, numberProtoFuncToFixed), DontEnum);
  66     putDirectFunction(new PrototypeFunction(exec, functionPrototype, 1, exec->propertyNames().toExponential, numberProtoFuncToExponential), DontEnum);
  67     putDirectFunction(new 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(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(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(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(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("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(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(s + m.substr(0, kMinusf) + "." + m.substr(kMinusf));
 273     return jsString(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(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("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(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(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(s + m + "e+" + UString::from(e));
 434             return jsString(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(s + m);
 443     if (e >= 0) {
 444         if (e + 1 < m.size())
 445             return jsString(s + m.substr(0, e + 1) + "." + m.substr(e + 1));
 446         return jsString(s + m);
 447     }
 448     return jsString(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(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*, int token) const
 480 {
 481     // ECMA 15.7.3
 482     switch (token) {
 483         case NaNValue:
 484             return jsNaN();
 485         case NegInfinity:
 486             return jsNumberCell(-Inf);
 487         case PosInfinity:
 488             return jsNumberCell(Inf);
 489         case MaxValue:
 490             return jsNumberCell(1.7976931348623157E+308);
 491         case MinValue:
 492             return jsNumberCell(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 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(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(args.isEmpty() ? 0 : args[0]->toNumber(exec));
 520 }
 521
 522 } // namespace KJS