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 };
  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 = kjs_dtoa(d, 0, 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         // FIXME: Remove use of strcpy() and strncpy()
  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 static 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             // FIXME: Remove use of strcpy()
 290             strcpy(buf + i, result + 1);
 291             i += static_cast<int>(resultLength) - 1;
 292         }
 293     }
 294
 295     for (int j = 0; j < fractionalDigits - fDigitsInResult; j++)
 296         buf[i++] = '0';
 297 }
 298
 299 static void exponentialPartToString(char* buf, int& i, int decimalPoint)
 300 {
 301     buf[i++] = 'e';
 302     buf[i++] = (decimalPoint >= 0) ? '+' : '-';
 303     // decimalPoint can't be more than 3 digits decimal given the
 304     // nature of float representation
 305     int exponential = decimalPoint - 1;
 306     if (exponential < 0)
 307         exponential *= -1;
 308     if (exponential >= 100)
 309         buf[i++] = static_cast<char>('0' + exponential / 100);
 310     if (exponential >= 10)
 311         buf[i++] = static_cast<char>('0' + (exponential % 100) / 10);
 312     buf[i++] = static_cast<char>('0' + exponential % 10);
 313 }
 314
 315 JSValue* numberProtoFuncToExponential(ExecState* exec, JSObject* thisObj, const List& args)
 316 {
 317     if (!thisObj->inherits(&NumberInstance::info))
 318         return throwError(exec, TypeError);
 319
 320     JSValue* v = static_cast<NumberInstance*>(thisObj)->internalValue();
 321
 322     double x = v->toNumber(exec);
 323
 324     if (isnan(x) || isinf(x))
 325         return jsString(UString::from(x));
 326
 327     JSValue* fractionalDigitsValue = args[0];
 328     double df = fractionalDigitsValue->toInteger(exec);
 329     if (!(df >= 0 && df <= 20))
 330         return throwError(exec, RangeError, "toExponential() argument must between 0 and 20");
 331     int fractionalDigits = (int)df;
 332     bool includeAllDigits = fractionalDigitsValue->isUndefined();
 333
 334     int decimalAdjust = 0;
 335     if (x && !includeAllDigits) {
 336         double logx = floor(log10(fabs(x)));
 337         x /= pow(10.0, logx);
 338         const double tenToTheF = pow(10.0, fractionalDigits);
 339         double fx = floor(x * tenToTheF) / tenToTheF;
 340         double cx = ceil(x * tenToTheF) / tenToTheF;
 341
 342         if (fabs(fx - x) < fabs(cx - x))
 343             x = fx;
 344         else
 345             x = cx;
 346
 347         decimalAdjust = static_cast<int>(logx);
 348     }
 349
 350     if (isnan(x))
 351         return jsString("NaN");
 352
 353     if (x == -0.0) // (-0.0).toExponential() should print as 0 instead of -0
 354         x = 0;
 355
 356     int decimalPoint;
 357     int sign;
 358     char* result = kjs_dtoa(x, 0, 0, &decimalPoint, &sign, NULL);
 359     size_t resultLength = strlen(result);
 360     decimalPoint += decimalAdjust;
 361
 362     int i = 0;
 363     char buf[80]; // digit + '.' + fractionDigits (max 20) + 'e' + sign + exponent (max?)
 364     if (sign)
 365         buf[i++] = '-';
 366
 367     if (decimalPoint == 999) // ? 9999 is the magical "result is Inf or NaN" value.  what's 999??
 368         // FIXME: Remove magic number 80
 369         strlcpy(buf + i, result, 80 - i);
 370     else {
 371         buf[i++] = result[0];
 372
 373         if (includeAllDigits)
 374             fractionalDigits = static_cast<int>(resultLength) - 1;
 375
 376         fractionalPartToString(buf, i, result, resultLength, fractionalDigits);
 377         exponentialPartToString(buf, i, decimalPoint);
 378         buf[i++] = '\0';
 379     }
 380     ASSERT(i <= 80);
 381
 382     kjs_freedtoa(result);
 383
 384     return jsString(buf);
 385 }
 386
 387 JSValue* numberProtoFuncToPrecision(ExecState* exec, JSObject* thisObj, const List& args)
 388 {
 389     if (!thisObj->inherits(&NumberInstance::info))
 390         return throwError(exec, TypeError);
 391
 392     JSValue* v = static_cast<NumberInstance*>(thisObj)->internalValue();
 393
 394     double doublePrecision = args[0]->toIntegerPreserveNaN(exec);
 395     double x = v->toNumber(exec);
 396     if (args[0]->isUndefined() || isnan(x) || isinf(x))
 397         return jsString(v->toString(exec));
 398
 399     UString s;
 400     if (x < 0) {
 401         s = "-";
 402         x = -x;
 403     }
 404
 405     if (!(doublePrecision >= 1 && doublePrecision <= 21)) // true for NaN
 406         return throwError(exec, RangeError, "toPrecision() argument must be between 1 and 21");
 407     int precision = (int)doublePrecision;
 408
 409     int e = 0;
 410     UString m;
 411     if (x) {
 412         e = static_cast<int>(log10(x));
 413         double tens = intPow10(e - precision + 1);
 414         double n = floor(x / tens);
 415         if (n < intPow10(precision - 1)) {
 416             e = e - 1;
 417             tens = intPow10(e - precision + 1);
 418             n = floor(x / tens);
 419         }
 420
 421         if (fabs((n + 1.0) * tens - x) <= fabs(n * tens - x))
 422             ++n;
 423         // maintain n < 10^(precision)
 424         if (n >= intPow10(precision)) {
 425             n /= 10.0;
 426             e += 1;
 427         }
 428         ASSERT(intPow10(precision - 1) <= n);
 429         ASSERT(n < intPow10(precision));
 430
 431         m = integer_part_noexp(n);
 432         if (e < -6 || e >= precision) {
 433             if (m.size() > 1)
 434                 m = m.substr(0, 1) + "." + m.substr(1);
 435             if (e >= 0)
 436                 return jsString(s + m + "e+" + UString::from(e));
 437             return jsString(s + m + "e-" + UString::from(-e));
 438         }
 439     } else {
 440         m = char_sequence('0', precision);
 441         e = 0;
 442     }
 443
 444     if (e == precision - 1)
 445         return jsString(s + m);
 446     if (e >= 0) {
 447         if (e + 1 < m.size())
 448             return jsString(s + m.substr(0, e + 1) + "." + m.substr(e + 1));
 449         return jsString(s + m);
 450     }
 451     return jsString(s + "0." + char_sequence('0', -(e + 1)) + m);
 452 }
 453
 454 // ------------------------------ NumberObjectImp ------------------------------
 455
 456 const ClassInfo NumberObjectImp::info = { "Function", &InternalFunctionImp::info, &numberTable };
 457
 458 /* Source for number_object.lut.h
 459 @begin numberTable 5
 460   NaN                   NumberObjectImp::NaNValue       DontEnum|DontDelete|ReadOnly
 461   NEGATIVE_INFINITY     NumberObjectImp::NegInfinity    DontEnum|DontDelete|ReadOnly
 462   POSITIVE_INFINITY     NumberObjectImp::PosInfinity    DontEnum|DontDelete|ReadOnly
 463   MAX_VALUE             NumberObjectImp::MaxValue       DontEnum|DontDelete|ReadOnly
 464   MIN_VALUE             NumberObjectImp::MinValue       DontEnum|DontDelete|ReadOnly
 465 @end
 466 */
 467 NumberObjectImp::NumberObjectImp(ExecState* exec, FunctionPrototype* funcProto, NumberPrototype* numberProto)
 468     : InternalFunctionImp(funcProto, numberProto->classInfo()->className)
 469 {
 470     // Number.Prototype
 471     putDirect(exec->propertyNames().prototype, numberProto, DontEnum|DontDelete|ReadOnly);
 472
 473     // no. of arguments for constructor
 474     putDirect(exec->propertyNames().length, jsNumber(1), ReadOnly|DontDelete|DontEnum);
 475 }
 476
 477 bool NumberObjectImp::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 478 {
 479     return getStaticValueSlot<NumberObjectImp, InternalFunctionImp>(exec, &numberTable, this, propertyName, slot);
 480 }
 481
 482 JSValue* NumberObjectImp::getValueProperty(ExecState*, int token) const
 483 {
 484     // ECMA 15.7.3
 485     switch (token) {
 486         case NaNValue:
 487             return jsNaN();
 488         case NegInfinity:
 489             return jsNumberCell(-Inf);
 490         case PosInfinity:
 491             return jsNumberCell(Inf);
 492         case MaxValue:
 493             return jsNumberCell(1.7976931348623157E+308);
 494         case MinValue:
 495             return jsNumberCell(5E-324);
 496     }
 497     ASSERT_NOT_REACHED();
 498     return jsNull();
 499 }
 500
 501 bool NumberObjectImp::implementsConstruct() const
 502 {
 503     return true;
 504 }
 505
 506 // ECMA 15.7.1
 507 JSObject* NumberObjectImp::construct(ExecState* exec, const List& args)
 508 {
 509     JSObject* proto = exec->lexicalGlobalObject()->numberPrototype();
 510     NumberInstance* obj = new NumberInstance(proto);
 511
 512     // FIXME: Check args[0]->isUndefined() instead of args.isEmpty()?
 513     double n = args.isEmpty() ? 0 : args[0]->toNumber(exec);
 514     obj->setInternalValue(jsNumber(n));
 515     return obj;
 516 }
 517
 518 // ECMA 15.7.2
 519 JSValue* NumberObjectImp::callAsFunction(ExecState* exec, JSObject*, const List& args)
 520 {
 521     // FIXME: Check args[0]->isUndefined() instead of args.isEmpty()?
 522     return jsNumber(args.isEmpty() ? 0 : args[0]->toNumber(exec));
 523 }
 524
 525 } // namespace KJS