NumberConstructor.cpp 5.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138
  1. /*
  2. * Copyright (c) 2020-2021, Linus Groh <linusg@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Math.h>
  7. #include <LibJS/Runtime/AbstractOperations.h>
  8. #include <LibJS/Runtime/Error.h>
  9. #include <LibJS/Runtime/GlobalObject.h>
  10. #include <LibJS/Runtime/NumberConstructor.h>
  11. #include <LibJS/Runtime/NumberObject.h>
  12. #ifdef __clang__
  13. # define EPSILON_VALUE AK::exp2(-52.)
  14. # define MAX_SAFE_INTEGER_VALUE AK::exp2(53.) - 1
  15. # define MIN_SAFE_INTEGER_VALUE -(AK::exp2(53.) - 1)
  16. #else
  17. constexpr const double EPSILON_VALUE { __builtin_exp2(-52) };
  18. constexpr const double MAX_SAFE_INTEGER_VALUE { __builtin_exp2(53) - 1 };
  19. constexpr const double MIN_SAFE_INTEGER_VALUE { -(__builtin_exp2(53) - 1) };
  20. #endif
  21. namespace JS {
  22. NumberConstructor::NumberConstructor(GlobalObject& global_object)
  23. : NativeFunction(vm().names.Number.as_string(), *global_object.function_prototype())
  24. {
  25. }
  26. void NumberConstructor::initialize(GlobalObject& global_object)
  27. {
  28. auto& vm = this->vm();
  29. NativeFunction::initialize(global_object);
  30. // 21.1.2.15 Number.prototype, https://tc39.es/ecma262/#sec-number.prototype
  31. define_direct_property(vm.names.prototype, global_object.number_prototype(), 0);
  32. u8 attr = Attribute::Writable | Attribute::Configurable;
  33. define_native_function(vm.names.isFinite, is_finite, 1, attr);
  34. define_native_function(vm.names.isInteger, is_integer, 1, attr);
  35. define_native_function(vm.names.isNaN, is_nan, 1, attr);
  36. define_native_function(vm.names.isSafeInteger, is_safe_integer, 1, attr);
  37. define_direct_property(vm.names.parseInt, global_object.get_without_side_effects(vm.names.parseInt), attr);
  38. define_direct_property(vm.names.parseFloat, global_object.get_without_side_effects(vm.names.parseFloat), attr);
  39. define_direct_property(vm.names.EPSILON, Value(EPSILON_VALUE), 0);
  40. define_direct_property(vm.names.MAX_VALUE, Value(NumericLimits<double>::max()), 0);
  41. define_direct_property(vm.names.MIN_VALUE, Value(NumericLimits<double>::min()), 0);
  42. define_direct_property(vm.names.MAX_SAFE_INTEGER, Value(MAX_SAFE_INTEGER_VALUE), 0);
  43. define_direct_property(vm.names.MIN_SAFE_INTEGER, Value(MIN_SAFE_INTEGER_VALUE), 0);
  44. define_direct_property(vm.names.NEGATIVE_INFINITY, js_negative_infinity(), 0);
  45. define_direct_property(vm.names.POSITIVE_INFINITY, js_infinity(), 0);
  46. define_direct_property(vm.names.NaN, js_nan(), 0);
  47. define_direct_property(vm.names.length, Value(1), Attribute::Configurable);
  48. }
  49. NumberConstructor::~NumberConstructor()
  50. {
  51. }
  52. // Most of 21.1.1.1 Number ( value ) factored into a separate function for sharing between call() and construct().
  53. static Value get_value_from_constructor_argument(GlobalObject& global_object)
  54. {
  55. auto& vm = global_object.vm();
  56. Value number;
  57. if (vm.argument_count() > 0) {
  58. auto primitive = vm.argument(0).to_numeric(global_object);
  59. if (vm.exception())
  60. return {};
  61. if (primitive.is_bigint()) {
  62. // FIXME: How should huge values be handled here?
  63. auto& big_integer = primitive.as_bigint().big_integer();
  64. number = Value(static_cast<double>(big_integer.unsigned_value().to_u64()) * (big_integer.is_negative() ? -1.0 : 1.0));
  65. } else {
  66. number = primitive;
  67. }
  68. } else {
  69. number = Value(0);
  70. }
  71. return number;
  72. }
  73. // 21.1.1.1 Number ( value ), https://tc39.es/ecma262/#sec-number-constructor-number-value
  74. Value NumberConstructor::call()
  75. {
  76. auto& vm = this->vm();
  77. auto& global_object = this->global_object();
  78. auto number = get_value_from_constructor_argument(global_object);
  79. if (vm.exception())
  80. return {};
  81. return number;
  82. }
  83. // 21.1.1.1 Number ( value ), https://tc39.es/ecma262/#sec-number-constructor-number-value
  84. Value NumberConstructor::construct(FunctionObject& new_target)
  85. {
  86. auto& vm = this->vm();
  87. auto& global_object = this->global_object();
  88. auto number = get_value_from_constructor_argument(global_object);
  89. if (vm.exception())
  90. return {};
  91. return TRY_OR_DISCARD(ordinary_create_from_constructor<NumberObject>(global_object, new_target, &GlobalObject::number_prototype, number.as_double()));
  92. }
  93. // 21.1.2.2 Number.isFinite ( number ), https://tc39.es/ecma262/#sec-number.isfinite
  94. JS_DEFINE_NATIVE_FUNCTION(NumberConstructor::is_finite)
  95. {
  96. return Value(vm.argument(0).is_finite_number());
  97. }
  98. // 21.1.2.3 Number.isInteger ( number ), https://tc39.es/ecma262/#sec-number.isinteger
  99. JS_DEFINE_NATIVE_FUNCTION(NumberConstructor::is_integer)
  100. {
  101. return Value(vm.argument(0).is_integral_number());
  102. }
  103. // 21.1.2.4 Number.isNaN ( number ), https://tc39.es/ecma262/#sec-number.isnan
  104. JS_DEFINE_NATIVE_FUNCTION(NumberConstructor::is_nan)
  105. {
  106. return Value(vm.argument(0).is_nan());
  107. }
  108. // 21.1.2.5 Number.isSafeInteger ( number ), https://tc39.es/ecma262/#sec-number.issafeinteger
  109. JS_DEFINE_NATIVE_FUNCTION(NumberConstructor::is_safe_integer)
  110. {
  111. if (!vm.argument(0).is_number())
  112. return Value(false);
  113. if (!vm.argument(0).is_integral_number())
  114. return Value(false);
  115. auto value = vm.argument(0).as_double();
  116. return Value(value >= MIN_SAFE_INTEGER_VALUE && value <= MAX_SAFE_INTEGER_VALUE);
  117. }
  118. }