Implement Number.prototype.toPrecision()

jerry-core/ecma/base/ecma-magic-strings.inc.h

@@ -205,6 +205,7 @@ ECMA_MAGIC_STRING_DEF (ECMA_MAGIC_STRING_EXEC, "exec")
 ECMA_MAGIC_STRING_DEF (ECMA_MAGIC_STRING_TEST, "test")
 ECMA_MAGIC_STRING_DEF (ECMA_MAGIC_STRING_NAME, "name")
 ECMA_MAGIC_STRING_DEF (ECMA_MAGIC_STRING_MESSAGE, "message")
+ECMA_MAGIC_STRING_DEF (ECMA_MAGIC_STRING_MINUS_CHAR, "-")
 ECMA_MAGIC_STRING_DEF (ECMA_MAGIC_STRING_LEFT_SQUARE_CHAR, "[")
 ECMA_MAGIC_STRING_DEF (ECMA_MAGIC_STRING_RIGHT_SQUARE_CHAR, "]")
 ECMA_MAGIC_STRING_DEF (ECMA_MAGIC_STRING_COLON_CHAR, ":")

jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.cpp

@@ -405,7 +405,223 @@ static ecma_completion_value_t
 ecma_builtin_number_prototype_object_to_precision (ecma_value_t this_arg, /**< this argument */
                                                    ecma_value_t arg) /**< routine's argument */
 {
-  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  /* 1. */
+  ECMA_OP_TO_NUMBER_TRY_CATCH (this_num, this_arg, ret_value);
+
+  /* 2. */
+  if (ecma_is_value_undefined (arg))
+  {
+    ret_value = ecma_builtin_number_prototype_object_to_string (this_arg, NULL, 0);
+  }
+  else
+  {
+    /* 3. */
+    ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
+
+    /* 4. */
+    if (ecma_number_is_nan (this_num))
+    {
+      ecma_string_t *nan_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_NAN);
+      ret_value = ecma_make_normal_completion_value (ecma_make_string_value (nan_str_p));
+    }
+    else
+    {
+      bool is_negative = false;
+
+      /* 6. */
+      if (ecma_number_is_negative (this_num) && !ecma_number_is_zero (this_num))
+      {
+        is_negative = true;
+        this_num *= -1;
+      }
+
+      /* 7. */
+      if (ecma_number_is_infinity (this_num))
+      {
+        ecma_string_t *infinity_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_INFINITY_UL);
+
+        if (is_negative)
+        {
+          ecma_string_t *neg_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_MINUS_CHAR);
+          ecma_string_t *neg_inf_str_p = ecma_concat_ecma_strings (neg_str_p, infinity_str_p);
+          ecma_deref_ecma_string (infinity_str_p);
+          ecma_deref_ecma_string (neg_str_p);
+          ret_value = ecma_make_normal_completion_value (ecma_make_string_value (neg_inf_str_p));
+        }
+        else
+        {
+          ret_value = ecma_make_normal_completion_value (ecma_make_string_value (infinity_str_p));
+        }
+      }
+      /* 8. */
+      else if (arg_num < 1.0 || arg_num >= 22.0)
+      {
+        ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_RANGE));
+      }
+      else
+      {
+        uint64_t digits = 0;
+        int32_t num_digits = 0;
+        int32_t exponent = 1;
+
+        int32_t precision = ecma_number_to_int32 (arg_num);
+
+        /* Get the parameters of the number if non-zero. */
+        if (!ecma_number_is_zero (this_num))
+        {
+          ecma_number_to_decimal (this_num, &digits, &num_digits, &exponent);
+        }
+
+        digits = ecma_builtin_number_prototype_helper_round (digits, num_digits - precision);
+
+        int buffer_size;
+        if (exponent  < -5 || exponent > precision)
+        {
+          /* Exponential notation, precision + 1 digits for number, 5 for exponent, 1 for \0 */
+          buffer_size = precision + 1 + 5 + 1;
+        }
+        else if (exponent <= 0)
+        {
+          /* Fixed notation, -exponent + 2 digits for leading zeros, precision digits, 1 for \0 */
+          buffer_size = -exponent + 2 + precision + 1;
+        }
+        else
+        {
+          /* Fixed notation, precision + 1 digits for number, 1 for \0 */
+          buffer_size = precision + 1 + 1;
+        }
+
+        if (is_negative)
+        {
+          buffer_size++;
+        }
+
+        MEM_DEFINE_LOCAL_ARRAY (buff, buffer_size, ecma_char_t);
+        ecma_char_t *actual_char_p = buff;
+
+        uint64_t scale = 1;
+
+        /* Calculate the magnitude of the number. This is used to get the digits from left to right. */
+        while (scale <= digits)
+        {
+          scale *= 10;
+        }
+
+        if (is_negative)
+        {
+          *actual_char_p++ = '-';
+        }
+
+        int digit = 0;
+
+        /* 10.c, Exponential notation.*/
+        if (exponent < -5 || exponent > precision)
+        {
+          /* Add significant digits. */
+          for (int i = 1; i <= precision; i++)
+          {
+            digit = 0;
+            scale /= 10;
+            while (digits >= scale && scale > 0)
+            {
+              digits -= scale;
+              digit++;
+            }
+
+            *actual_char_p++ = (ecma_char_t) (digit + '0');
+
+            if (i == 1 && i != precision)
+            {
+              *actual_char_p++ = '.';
+            }
+          }
+
+          *actual_char_p++ = 'e';
+
+          exponent--;
+          if (exponent < 0)
+          {
+            exponent *= -1;
+            *actual_char_p++ = '-';
+          }
+          else
+          {
+            *actual_char_p++ = '+';
+          }
+
+          /* Get magnitude of exponent. */
+          int32_t scale_expt = 1;
+          while (scale_expt <= exponent)
+          {
+            scale_expt *= 10;
+          }
+          scale_expt /= 10;
+
+          /* Add exponent digits. */
+          if (exponent == 0)
+          {
+            *actual_char_p++ = '0';
+          }
+          else
+          {
+            while (scale_expt > 0)
+            {
+              digit = exponent / scale_expt;
+              exponent %= scale_expt;
+              *actual_char_p++ = (ecma_char_t) (digit + '0');
+              scale_expt /= 10;
+            }
+          }
+        }
+        /* Fixed notation. */
+        else
+        {
+          /* Add leading zeros if neccessary. */
+          if (exponent <= 0)
+          {
+            *actual_char_p++ = '0';
+            *actual_char_p++ = '.';
+            for (int i = exponent; i < 0; i++)
+            {
+              *actual_char_p++ = '0';
+            }
+          }
+
+          /* Add significant digits. */
+          for (int i = 1; i <= precision; i++)
+          {
+            digit = 0;
+            scale /= 10;
+            while (digits >= scale && scale > 0)
+            {
+              digits -= scale;
+              digit++;
+            }
+
+            *actual_char_p++ = (ecma_char_t) (digit + '0');
+
+            if (i == exponent && i != precision)
+            {
+              *actual_char_p++ = '.';
+            }
+          }
+        }
+
+        JERRY_ASSERT (actual_char_p - buff < buffer_size);
+        *actual_char_p = '\0';
+        ecma_string_t *str_p = ecma_new_ecma_string ((ecma_char_t *) buff);
+
+        ret_value = ecma_make_normal_completion_value (ecma_make_string_value (str_p));
+        MEM_FINALIZE_LOCAL_ARRAY (buff);
+      }
+    }
+    ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+  }
+  ECMA_OP_TO_NUMBER_FINALIZE (this_num);
+
+  return ret_value;
 } /* ecma_builtin_number_prototype_object_to_precision */
 
 /**

tests/jerry/number-prototype-to-precision.js

@@ -0,0 +1,54 @@
+// Copyright 2015 Samsung Electronics Co., Ltd.
+// Copyright 2015 University of Szeged.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//This test will not pass on FLOAT32 due to precision issues
+
+assert((123.56).toPrecision() === "123.56");
+assert((123.56).toPrecision(1) === "1e+2");
+assert((123.56).toPrecision(2) === "1.2e+2");
+assert((123.56).toPrecision(6) === "123.560");
+assert((-1.23).toPrecision(1) === "-1");
+assert((0.00023).toPrecision(1) === "0.0002");
+assert((0.356).toPrecision(2) === "0.36");
+assert((0.0000356).toPrecision(5) === "0.000035600");
+assert((0.000030056).toPrecision(4) === "0.00003006");
+assert(Infinity.toPrecision(1) === "Infinity");
+assert((-Infinity).toPrecision(1) === "-Infinity");
+assert(NaN.toPrecision(1) === "NaN");
+assert((0.0).toPrecision(1) === "0");
+assert((-0.0).toPrecision(1) === "0");
+assert((0.0).toPrecision(6) === "0.00000");
+assert((123456789012345678901.0).toPrecision(20) === "1.2345678901234568000e+20");
+assert((123456789012345678901.0).toPrecision(21) === "123456789012345680000");
+assert((123456789012345678901.0).toPrecision("6") === "1.23457e+20");
+
+var obj = { toPrecision : Number.prototype.toPrecision };
+assert(obj.toPrecision(1) === "NaN");
+assert((123.56).toPrecision(1.3) === "1e+2");
+assert((123.56).toPrecision(21.9) === "123.560000000000000000");
+
+try {
+    (12).toPrecision(0);
+    assert(false);
+} catch (e) {
+    assert(e instanceof RangeError)
+}
+
+try {
+    (12).toPrecision(22);
+    assert(false);
+} catch (e) {
+    assert(e instanceof RangeError)
+}