Value.cpp 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369
  1. /*
  2. * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
  3. * All rights reserved.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. *
  8. * 1. Redistributions of source code must retain the above copyright notice, this
  9. * list of conditions and the following disclaimer.
  10. *
  11. * 2. Redistributions in binary form must reproduce the above copyright notice,
  12. * this list of conditions and the following disclaimer in the documentation
  13. * and/or other materials provided with the distribution.
  14. *
  15. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  16. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  18. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  19. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  21. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  22. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  23. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25. */
  26. #include <AK/FlyString.h>
  27. #include <AK/String.h>
  28. #include <LibJS/Heap/Heap.h>
  29. #include <LibJS/Interpreter.h>
  30. #include <LibJS/Runtime/Array.h>
  31. #include <LibJS/Runtime/BooleanObject.h>
  32. #include <LibJS/Runtime/Error.h>
  33. #include <LibJS/Runtime/NumberObject.h>
  34. #include <LibJS/Runtime/Object.h>
  35. #include <LibJS/Runtime/PrimitiveString.h>
  36. #include <LibJS/Runtime/StringObject.h>
  37. #include <LibJS/Runtime/Value.h>
  38. #include <math.h>
  39. namespace JS {
  40. bool Value::is_array() const
  41. {
  42. return is_object() && as_object().is_array();
  43. }
  44. String Value::to_string() const
  45. {
  46. if (is_boolean())
  47. return as_bool() ? "true" : "false";
  48. if (is_null())
  49. return "null";
  50. if (is_undefined())
  51. return "undefined";
  52. if (is_number()) {
  53. if (is_nan())
  54. return "NaN";
  55. if (is_infinity())
  56. return as_double() < 0 ? "-Infinity" : "Infinity";
  57. // FIXME: This needs improvement.
  58. if ((double)to_i32() == as_double())
  59. return String::number(to_i32());
  60. return String::format("%.4f", as_double());
  61. }
  62. if (is_object())
  63. return as_object().to_primitive(Object::PreferredType::String).to_string();
  64. if (is_string())
  65. return m_value.as_string->string();
  66. ASSERT_NOT_REACHED();
  67. }
  68. bool Value::to_boolean() const
  69. {
  70. switch (m_type) {
  71. case Type::Boolean:
  72. return m_value.as_bool;
  73. case Type::Number:
  74. if (is_nan()) {
  75. return false;
  76. }
  77. return !(m_value.as_double == 0 || m_value.as_double == -0);
  78. case Type::Null:
  79. case Type::Undefined:
  80. return false;
  81. case Type::String:
  82. return !as_string()->string().is_empty();
  83. case Type::Object:
  84. return true;
  85. default:
  86. ASSERT_NOT_REACHED();
  87. }
  88. }
  89. Object* Value::to_object(Heap& heap) const
  90. {
  91. if (is_object())
  92. return &const_cast<Object&>(as_object());
  93. if (is_string())
  94. return heap.allocate<StringObject>(m_value.as_string);
  95. if (is_number())
  96. return heap.allocate<NumberObject>(m_value.as_double);
  97. if (is_boolean())
  98. return heap.allocate<BooleanObject>(m_value.as_bool);
  99. if (is_null() || is_undefined()) {
  100. heap.interpreter().throw_exception<TypeError>("ToObject on null or undefined.");
  101. return nullptr;
  102. }
  103. dbg() << "Dying because I can't to_object() on " << *this;
  104. ASSERT_NOT_REACHED();
  105. }
  106. Value Value::to_number() const
  107. {
  108. switch (m_type) {
  109. case Type::Empty:
  110. ASSERT_NOT_REACHED();
  111. return {};
  112. case Type::Boolean:
  113. return Value(m_value.as_bool ? 1 : 0);
  114. case Type::Number:
  115. return Value(m_value.as_double);
  116. case Type::Null:
  117. return Value(0);
  118. case Type::String: {
  119. // FIXME: Trim whitespace beforehand
  120. auto& string = as_string()->string();
  121. if (string.is_empty())
  122. return Value(0);
  123. if (string == "Infinity" || string == "+Infinity")
  124. return js_infinity();
  125. if (string == "-Infinity")
  126. return js_negative_infinity();
  127. bool ok;
  128. //FIXME: Parse in a better way
  129. auto parsed_int = string.to_int(ok);
  130. if (ok)
  131. return Value(parsed_int);
  132. return js_nan();
  133. }
  134. case Type::Undefined:
  135. return js_nan();
  136. case Type::Object:
  137. if (m_value.as_object->is_array()) {
  138. auto& array = *static_cast<Array*>(m_value.as_object);
  139. if (array.length() == 0)
  140. return Value(0);
  141. if (array.length() > 1)
  142. return js_nan();
  143. return array.elements()[0].to_number();
  144. } else {
  145. return m_value.as_object->to_primitive(Object::PreferredType::Number).to_number();
  146. }
  147. }
  148. ASSERT_NOT_REACHED();
  149. }
  150. i32 Value::to_i32() const
  151. {
  152. return static_cast<i32>(to_number().as_double());
  153. }
  154. double Value::to_double() const
  155. {
  156. return to_number().as_double();
  157. }
  158. Value greater_than(Value lhs, Value rhs)
  159. {
  160. return Value(lhs.to_number().as_double() > rhs.to_number().as_double());
  161. }
  162. Value greater_than_equals(Value lhs, Value rhs)
  163. {
  164. return Value(lhs.to_number().as_double() >= rhs.to_number().as_double());
  165. }
  166. Value less_than(Value lhs, Value rhs)
  167. {
  168. return Value(lhs.to_number().as_double() < rhs.to_number().as_double());
  169. }
  170. Value less_than_equals(Value lhs, Value rhs)
  171. {
  172. return Value(lhs.to_number().as_double() <= rhs.to_number().as_double());
  173. }
  174. Value bitwise_and(Value lhs, Value rhs)
  175. {
  176. return Value((i32)lhs.to_number().as_double() & (i32)rhs.to_number().as_double());
  177. }
  178. Value bitwise_or(Value lhs, Value rhs)
  179. {
  180. bool lhs_invalid = lhs.is_undefined() || lhs.is_null() || lhs.is_nan() || lhs.is_infinity();
  181. bool rhs_invalid = rhs.is_undefined() || rhs.is_null() || rhs.is_nan() || rhs.is_infinity();
  182. if (lhs_invalid && rhs_invalid)
  183. return Value(0);
  184. if (lhs_invalid || rhs_invalid)
  185. return lhs_invalid ? rhs.to_number() : lhs.to_number();
  186. if (!rhs.is_number() && !lhs.is_number())
  187. return Value(0);
  188. return Value((i32)lhs.to_number().as_double() | (i32)rhs.to_number().as_double());
  189. }
  190. Value bitwise_xor(Value lhs, Value rhs)
  191. {
  192. return Value((i32)lhs.to_number().as_double() ^ (i32)rhs.to_number().as_double());
  193. }
  194. Value bitwise_not(Value lhs)
  195. {
  196. return Value(~(i32)lhs.to_number().as_double());
  197. }
  198. Value unary_plus(Value lhs)
  199. {
  200. return lhs.to_number();
  201. }
  202. Value unary_minus(Value lhs)
  203. {
  204. if (lhs.to_number().is_nan())
  205. return js_nan();
  206. return Value(-lhs.to_number().as_double());
  207. }
  208. Value left_shift(Value lhs, Value rhs)
  209. {
  210. return Value((i32)lhs.to_number().as_double() << (i32)rhs.to_number().as_double());
  211. }
  212. Value right_shift(Value lhs, Value rhs)
  213. {
  214. return Value((i32)lhs.to_number().as_double() >> (i32)rhs.to_number().as_double());
  215. }
  216. Value add(Value lhs, Value rhs)
  217. {
  218. if (lhs.is_string() || rhs.is_string())
  219. return js_string((lhs.is_string() ? lhs : rhs).as_string()->heap(), String::format("%s%s", lhs.to_string().characters(), rhs.to_string().characters()));
  220. return Value(lhs.to_number().as_double() + rhs.to_number().as_double());
  221. }
  222. Value sub(Value lhs, Value rhs)
  223. {
  224. return Value(lhs.to_number().as_double() - rhs.to_number().as_double());
  225. }
  226. Value mul(Value lhs, Value rhs)
  227. {
  228. return Value(lhs.to_number().as_double() * rhs.to_number().as_double());
  229. }
  230. Value div(Value lhs, Value rhs)
  231. {
  232. return Value(lhs.to_number().as_double() / rhs.to_number().as_double());
  233. }
  234. Value mod(Value lhs, Value rhs)
  235. {
  236. if (lhs.to_number().is_nan() || rhs.to_number().is_nan())
  237. return js_nan();
  238. double index = lhs.to_number().as_double();
  239. double period = rhs.to_number().as_double();
  240. double trunc = (double)(i32) (index / period);
  241. return Value(index - trunc * period);
  242. }
  243. Value exp(Value lhs, Value rhs)
  244. {
  245. return Value(pow(lhs.to_number().as_double(), rhs.to_number().as_double()));
  246. }
  247. Value typed_eq(Value lhs, Value rhs)
  248. {
  249. if (rhs.type() != lhs.type())
  250. return Value(false);
  251. switch (lhs.type()) {
  252. case Value::Type::Empty:
  253. ASSERT_NOT_REACHED();
  254. return {};
  255. case Value::Type::Undefined:
  256. return Value(true);
  257. case Value::Type::Null:
  258. return Value(true);
  259. case Value::Type::Number:
  260. return Value(lhs.as_double() == rhs.as_double());
  261. case Value::Type::String:
  262. return Value(lhs.as_string()->string() == rhs.as_string()->string());
  263. case Value::Type::Boolean:
  264. return Value(lhs.as_bool() == rhs.as_bool());
  265. case Value::Type::Object:
  266. return Value(&lhs.as_object() == &rhs.as_object());
  267. }
  268. ASSERT_NOT_REACHED();
  269. }
  270. Value eq(Value lhs, Value rhs)
  271. {
  272. if (lhs.type() == rhs.type())
  273. return typed_eq(lhs, rhs);
  274. if ((lhs.is_undefined() || lhs.is_null()) && (rhs.is_undefined() || rhs.is_null()))
  275. return Value(true);
  276. if (lhs.is_object() && rhs.is_boolean())
  277. return eq(lhs.as_object().to_primitive(), rhs.to_number());
  278. if (lhs.is_boolean() && rhs.is_object())
  279. return eq(lhs.to_number(), rhs.as_object().to_primitive());
  280. if (lhs.is_object())
  281. return eq(lhs.as_object().to_primitive(), rhs);
  282. if (rhs.is_object())
  283. return eq(lhs, rhs.as_object().to_primitive());
  284. if (lhs.is_number() || rhs.is_number())
  285. return Value(lhs.to_number().as_double() == rhs.to_number().as_double());
  286. if ((lhs.is_string() && rhs.is_boolean()) || (lhs.is_string() && rhs.is_boolean()))
  287. return Value(lhs.to_number().as_double() == rhs.to_number().as_double());
  288. return Value(false);
  289. }
  290. Value instance_of(Value lhs, Value rhs)
  291. {
  292. if (!lhs.is_object() || !rhs.is_object())
  293. return Value(false);
  294. auto constructor_prototype_property = rhs.as_object().get("prototype");
  295. if (!constructor_prototype_property.has_value() || !constructor_prototype_property.value().is_object())
  296. return Value(false);
  297. return Value(lhs.as_object().has_prototype(&constructor_prototype_property.value().as_object()));
  298. }
  299. const LogStream& operator<<(const LogStream& stream, const Value& value)
  300. {
  301. return stream << value.to_string();
  302. }
  303. }