Value.cpp 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711
  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 <AK/StringBuilder.h>
  29. #include <AK/Utf8View.h>
  30. #include <LibJS/Heap/Heap.h>
  31. #include <LibJS/Interpreter.h>
  32. #include <LibJS/Runtime/Accessor.h>
  33. #include <LibJS/Runtime/Array.h>
  34. #include <LibJS/Runtime/BooleanObject.h>
  35. #include <LibJS/Runtime/Error.h>
  36. #include <LibJS/Runtime/Function.h>
  37. #include <LibJS/Runtime/NumberObject.h>
  38. #include <LibJS/Runtime/Object.h>
  39. #include <LibJS/Runtime/PrimitiveString.h>
  40. #include <LibJS/Runtime/StringObject.h>
  41. #include <LibJS/Runtime/Symbol.h>
  42. #include <LibJS/Runtime/SymbolObject.h>
  43. #include <LibJS/Runtime/Value.h>
  44. #include <math.h>
  45. namespace JS {
  46. bool Value::is_array() const
  47. {
  48. return is_object() && as_object().is_array();
  49. }
  50. bool Value::is_function() const
  51. {
  52. return is_object() && as_object().is_function();
  53. }
  54. Function& Value::as_function()
  55. {
  56. ASSERT(is_function());
  57. return static_cast<Function&>(as_object());
  58. }
  59. String Value::to_string_without_side_effects() const
  60. {
  61. switch (m_type) {
  62. case Type::Undefined:
  63. return "undefined";
  64. case Type::Null:
  65. return "null";
  66. case Type::Boolean:
  67. return m_value.as_bool ? "true" : "false";
  68. case Type::Number:
  69. if (is_nan())
  70. return "NaN";
  71. if (is_infinity())
  72. return is_negative_infinity() ? "-Infinity" : "Infinity";
  73. if (is_integer())
  74. return String::number(as_i32());
  75. return String::format("%.4f", m_value.as_double);
  76. case Type::String:
  77. return m_value.as_string->string();
  78. case Type::Symbol:
  79. return m_value.as_symbol->to_string();
  80. case Type::Object:
  81. return String::format("[object %s]", as_object().class_name());
  82. case Type::Accessor:
  83. return "<accessor>";
  84. default:
  85. ASSERT_NOT_REACHED();
  86. }
  87. }
  88. PrimitiveString* Value::to_primitive_string(Interpreter& interpreter)
  89. {
  90. if (is_string())
  91. return &as_string();
  92. auto string = to_string(interpreter);
  93. if (interpreter.exception())
  94. return nullptr;
  95. return js_string(interpreter, string);
  96. }
  97. String Value::to_string(Interpreter& interpreter) const
  98. {
  99. switch (m_type) {
  100. case Type::Undefined:
  101. return "undefined";
  102. case Type::Null:
  103. return "null";
  104. case Type::Boolean:
  105. return m_value.as_bool ? "true" : "false";
  106. case Type::Number:
  107. if (is_nan())
  108. return "NaN";
  109. if (is_infinity())
  110. return is_negative_infinity() ? "-Infinity" : "Infinity";
  111. if (is_integer())
  112. return String::number(as_i32());
  113. return String::format("%.4f", m_value.as_double);
  114. case Type::String:
  115. return m_value.as_string->string();
  116. case Type::Symbol:
  117. interpreter.throw_exception<TypeError>("Can't convert symbol to string");
  118. return {};
  119. case Type::Object: {
  120. auto primitive_value = as_object().to_primitive(PreferredType::String);
  121. if (interpreter.exception())
  122. return {};
  123. return primitive_value.to_string(interpreter);
  124. }
  125. default:
  126. ASSERT_NOT_REACHED();
  127. }
  128. }
  129. bool Value::to_boolean() const
  130. {
  131. switch (m_type) {
  132. case Type::Undefined:
  133. case Type::Null:
  134. return false;
  135. case Type::Boolean:
  136. return m_value.as_bool;
  137. case Type::Number:
  138. if (is_nan())
  139. return false;
  140. return m_value.as_double != 0;
  141. case Type::String:
  142. return !m_value.as_string->string().is_empty();
  143. case Type::Symbol:
  144. case Type::Object:
  145. return true;
  146. default:
  147. ASSERT_NOT_REACHED();
  148. }
  149. }
  150. Value Value::to_primitive(Interpreter&, PreferredType preferred_type) const
  151. {
  152. if (is_object())
  153. return as_object().to_primitive(preferred_type);
  154. return *this;
  155. }
  156. Object* Value::to_object(Interpreter& interpreter) const
  157. {
  158. switch (m_type) {
  159. case Type::Undefined:
  160. case Type::Null:
  161. interpreter.throw_exception<TypeError>("ToObject on null or undefined.");
  162. return nullptr;
  163. case Type::Boolean:
  164. return BooleanObject::create(interpreter.global_object(), m_value.as_bool);
  165. case Type::Number:
  166. return NumberObject::create(interpreter.global_object(), m_value.as_double);
  167. case Type::String:
  168. return StringObject::create(interpreter.global_object(), *m_value.as_string);
  169. case Type::Symbol:
  170. return SymbolObject::create(interpreter.global_object(), *m_value.as_symbol);
  171. case Type::Object:
  172. return &const_cast<Object&>(as_object());
  173. default:
  174. dbg() << "Dying because I can't to_object() on " << *this;
  175. ASSERT_NOT_REACHED();
  176. }
  177. }
  178. Value Value::to_number(Interpreter& interpreter) const
  179. {
  180. switch (m_type) {
  181. case Type::Undefined:
  182. return js_nan();
  183. case Type::Null:
  184. return Value(0);
  185. case Type::Boolean:
  186. return Value(m_value.as_bool ? 1 : 0);
  187. case Type::Number:
  188. return Value(m_value.as_double);
  189. case Type::String: {
  190. auto string = as_string().string().trim_whitespace();
  191. if (string.is_empty())
  192. return Value(0);
  193. if (string == "Infinity" || string == "+Infinity")
  194. return js_infinity();
  195. if (string == "-Infinity")
  196. return js_negative_infinity();
  197. char* endptr;
  198. auto parsed_double = strtod(string.characters(), &endptr);
  199. if (*endptr)
  200. return js_nan();
  201. return Value(parsed_double);
  202. }
  203. case Type::Symbol:
  204. interpreter.throw_exception<TypeError>("Can't convert symbol to number");
  205. return {};
  206. case Type::Object: {
  207. auto primitive = m_value.as_object->to_primitive(PreferredType::Number);
  208. if (interpreter.exception())
  209. return {};
  210. return primitive.to_number(interpreter);
  211. }
  212. default:
  213. ASSERT_NOT_REACHED();
  214. }
  215. }
  216. i32 Value::as_i32() const
  217. {
  218. return static_cast<i32>(as_double());
  219. }
  220. size_t Value::as_size_t() const
  221. {
  222. ASSERT(as_double() >= 0);
  223. return min((double)as_i32(), MAX_ARRAY_LIKE_INDEX);
  224. }
  225. double Value::to_double(Interpreter& interpreter) const
  226. {
  227. auto number = to_number(interpreter);
  228. if (interpreter.exception())
  229. return 0;
  230. return number.as_double();
  231. }
  232. i32 Value::to_i32(Interpreter& interpreter) const
  233. {
  234. auto number = to_number(interpreter);
  235. if (interpreter.exception())
  236. return 0;
  237. if (number.is_nan())
  238. return 0;
  239. // FIXME: What about infinity though - that's UB...
  240. // Maybe NumericLimits<i32>::max() for +Infinity and NumericLimits<i32>::min() for -Infinity?
  241. return number.as_i32();
  242. }
  243. size_t Value::to_size_t(Interpreter& interpreter) const
  244. {
  245. if (is_empty())
  246. return 0;
  247. auto number = to_number(interpreter);
  248. if (interpreter.exception())
  249. return 0;
  250. if (number.is_nan())
  251. return 0;
  252. if (number.as_double() <= 0)
  253. return 0;
  254. return number.as_size_t();
  255. }
  256. Value greater_than(Interpreter& interpreter, Value lhs, Value rhs)
  257. {
  258. TriState relation = abstract_relation(interpreter, false, lhs, rhs);
  259. if (relation == TriState::Unknown)
  260. return Value(false);
  261. return Value(relation == TriState::True);
  262. }
  263. Value greater_than_equals(Interpreter& interpreter, Value lhs, Value rhs)
  264. {
  265. TriState relation = abstract_relation(interpreter, true, lhs, rhs);
  266. if (relation == TriState::Unknown || relation == TriState::True)
  267. return Value(false);
  268. return Value(true);
  269. }
  270. Value less_than(Interpreter& interpreter, Value lhs, Value rhs)
  271. {
  272. TriState relation = abstract_relation(interpreter, true, lhs, rhs);
  273. if (relation == TriState::Unknown)
  274. return Value(false);
  275. return Value(relation == TriState::True);
  276. }
  277. Value less_than_equals(Interpreter& interpreter, Value lhs, Value rhs)
  278. {
  279. TriState relation = abstract_relation(interpreter, false, lhs, rhs);
  280. if (relation == TriState::Unknown || relation == TriState::True)
  281. return Value(false);
  282. return Value(true);
  283. }
  284. Value bitwise_and(Interpreter& interpreter, Value lhs, Value rhs)
  285. {
  286. auto lhs_number = lhs.to_number(interpreter);
  287. if (interpreter.exception())
  288. return {};
  289. auto rhs_number = rhs.to_number(interpreter);
  290. if (interpreter.exception())
  291. return {};
  292. return Value((i32)lhs_number.as_double() & (i32)rhs_number.as_double());
  293. }
  294. Value bitwise_or(Interpreter& interpreter, Value lhs, Value rhs)
  295. {
  296. bool lhs_invalid = lhs.is_undefined() || lhs.is_null() || lhs.is_nan() || lhs.is_infinity();
  297. bool rhs_invalid = rhs.is_undefined() || rhs.is_null() || rhs.is_nan() || rhs.is_infinity();
  298. if (lhs_invalid && rhs_invalid)
  299. return Value(0);
  300. if (lhs_invalid || rhs_invalid)
  301. return lhs_invalid ? rhs.to_number(interpreter) : lhs.to_number(interpreter);
  302. if (!rhs.is_number() && !lhs.is_number())
  303. return Value(0);
  304. auto lhs_number = lhs.to_number(interpreter);
  305. if (interpreter.exception())
  306. return {};
  307. auto rhs_number = rhs.to_number(interpreter);
  308. if (interpreter.exception())
  309. return {};
  310. return Value((i32)lhs_number.as_double() | (i32)rhs_number.as_double());
  311. }
  312. Value bitwise_xor(Interpreter& interpreter, Value lhs, Value rhs)
  313. {
  314. auto lhs_number = lhs.to_number(interpreter);
  315. if (interpreter.exception())
  316. return {};
  317. auto rhs_number = rhs.to_number(interpreter);
  318. if (interpreter.exception())
  319. return {};
  320. return Value((i32)lhs_number.as_double() ^ (i32)rhs_number.as_double());
  321. }
  322. Value bitwise_not(Interpreter& interpreter, Value lhs)
  323. {
  324. auto lhs_number = lhs.to_number(interpreter);
  325. if (interpreter.exception())
  326. return {};
  327. return Value(~(i32)lhs_number.as_double());
  328. }
  329. Value unary_plus(Interpreter& interpreter, Value lhs)
  330. {
  331. return lhs.to_number(interpreter);
  332. }
  333. Value unary_minus(Interpreter& interpreter, Value lhs)
  334. {
  335. auto lhs_number = lhs.to_number(interpreter);
  336. if (interpreter.exception())
  337. return {};
  338. if (lhs_number.is_nan())
  339. return js_nan();
  340. return Value(-lhs_number.as_double());
  341. }
  342. Value left_shift(Interpreter& interpreter, Value lhs, Value rhs)
  343. {
  344. auto lhs_number = lhs.to_number(interpreter);
  345. if (interpreter.exception())
  346. return {};
  347. if (!lhs_number.is_finite_number())
  348. return Value(0);
  349. auto rhs_number = rhs.to_number(interpreter);
  350. if (interpreter.exception())
  351. return {};
  352. if (!rhs_number.is_finite_number())
  353. return lhs_number;
  354. return Value((i32)lhs_number.as_double() << (i32)rhs_number.as_double());
  355. }
  356. Value right_shift(Interpreter& interpreter, Value lhs, Value rhs)
  357. {
  358. auto lhs_number = lhs.to_number(interpreter);
  359. if (interpreter.exception())
  360. return {};
  361. if (!lhs_number.is_finite_number())
  362. return Value(0);
  363. auto rhs_number = rhs.to_number(interpreter);
  364. if (interpreter.exception())
  365. return {};
  366. if (!rhs_number.is_finite_number())
  367. return lhs_number;
  368. return Value((i32)lhs_number.as_double() >> (i32)rhs_number.as_double());
  369. }
  370. Value unsigned_right_shift(Interpreter& interpreter, Value lhs, Value rhs)
  371. {
  372. auto lhs_number = lhs.to_number(interpreter);
  373. if (interpreter.exception())
  374. return {};
  375. if (!lhs_number.is_finite_number())
  376. return Value(0);
  377. auto rhs_number = rhs.to_number(interpreter);
  378. if (interpreter.exception())
  379. return {};
  380. if (!rhs_number.is_finite_number())
  381. return lhs_number;
  382. return Value((unsigned)lhs_number.as_double() >> (i32)rhs_number.as_double());
  383. }
  384. Value add(Interpreter& interpreter, Value lhs, Value rhs)
  385. {
  386. auto lhs_primitive = lhs.to_primitive(interpreter);
  387. if (interpreter.exception())
  388. return {};
  389. auto rhs_primitive = rhs.to_primitive(interpreter);
  390. if (interpreter.exception())
  391. return {};
  392. if (lhs_primitive.is_string() || rhs_primitive.is_string()) {
  393. auto lhs_string = lhs_primitive.to_string(interpreter);
  394. if (interpreter.exception())
  395. return {};
  396. auto rhs_string = rhs_primitive.to_string(interpreter);
  397. if (interpreter.exception())
  398. return {};
  399. StringBuilder builder(lhs_string.length() + rhs_string.length());
  400. builder.append(lhs_string);
  401. builder.append(rhs_string);
  402. return js_string(interpreter, builder.to_string());
  403. }
  404. auto lhs_number = lhs_primitive.to_number(interpreter);
  405. if (interpreter.exception())
  406. return {};
  407. auto rhs_number = rhs_primitive.to_number(interpreter);
  408. if (interpreter.exception())
  409. return {};
  410. return Value(lhs_number.as_double() + rhs_number.as_double());
  411. }
  412. Value sub(Interpreter& interpreter, Value lhs, Value rhs)
  413. {
  414. auto lhs_number = lhs.to_number(interpreter);
  415. if (interpreter.exception())
  416. return {};
  417. auto rhs_number = rhs.to_number(interpreter);
  418. if (interpreter.exception())
  419. return {};
  420. return Value(lhs_number.as_double() - rhs_number.as_double());
  421. }
  422. Value mul(Interpreter& interpreter, Value lhs, Value rhs)
  423. {
  424. auto lhs_number = lhs.to_number(interpreter);
  425. if (interpreter.exception())
  426. return {};
  427. auto rhs_number = rhs.to_number(interpreter);
  428. if (interpreter.exception())
  429. return {};
  430. return Value(lhs_number.as_double() * rhs_number.as_double());
  431. }
  432. Value div(Interpreter& interpreter, Value lhs, Value rhs)
  433. {
  434. auto lhs_number = lhs.to_number(interpreter);
  435. if (interpreter.exception())
  436. return {};
  437. auto rhs_number = rhs.to_number(interpreter);
  438. if (interpreter.exception())
  439. return {};
  440. return Value(lhs_number.as_double() / rhs_number.as_double());
  441. }
  442. Value mod(Interpreter& interpreter, Value lhs, Value rhs)
  443. {
  444. auto lhs_number = lhs.to_number(interpreter);
  445. if (interpreter.exception())
  446. return {};
  447. auto rhs_number = rhs.to_number(interpreter);
  448. if (interpreter.exception())
  449. return {};
  450. if (lhs_number.is_nan() || rhs_number.is_nan())
  451. return js_nan();
  452. auto index = lhs_number.as_double();
  453. auto period = rhs_number.as_double();
  454. auto trunc = (double)(i32)(index / period);
  455. return Value(index - trunc * period);
  456. }
  457. Value exp(Interpreter& interpreter, Value lhs, Value rhs)
  458. {
  459. auto lhs_number = lhs.to_number(interpreter);
  460. if (interpreter.exception())
  461. return {};
  462. auto rhs_number = rhs.to_number(interpreter);
  463. if (interpreter.exception())
  464. return {};
  465. return Value(pow(lhs_number.as_double(), rhs_number.as_double()));
  466. }
  467. Value in(Interpreter& interpreter, Value lhs, Value rhs)
  468. {
  469. if (!rhs.is_object())
  470. return interpreter.throw_exception<TypeError>("'in' operator must be used on object");
  471. auto lhs_string = lhs.to_string(interpreter);
  472. if (interpreter.exception())
  473. return {};
  474. return Value(rhs.as_object().has_property(lhs_string));
  475. }
  476. Value instance_of(Interpreter&, Value lhs, Value rhs)
  477. {
  478. if (!lhs.is_object() || !rhs.is_object())
  479. return Value(false);
  480. auto constructor_prototype_property = rhs.as_object().get("prototype");
  481. if (!constructor_prototype_property.is_object())
  482. return Value(false);
  483. return Value(lhs.as_object().has_prototype(&constructor_prototype_property.as_object()));
  484. }
  485. const LogStream& operator<<(const LogStream& stream, const Value& value)
  486. {
  487. return stream << (value.is_empty() ? "<empty>" : value.to_string_without_side_effects());
  488. }
  489. bool same_value(Interpreter& interpreter, Value lhs, Value rhs)
  490. {
  491. if (lhs.type() != rhs.type())
  492. return false;
  493. if (lhs.is_number()) {
  494. if (lhs.is_nan() && rhs.is_nan())
  495. return true;
  496. if (lhs.is_positive_zero() && rhs.is_negative_zero())
  497. return false;
  498. if (lhs.is_negative_zero() && rhs.is_positive_zero())
  499. return false;
  500. return lhs.as_double() == rhs.as_double();
  501. }
  502. return same_value_non_numeric(interpreter, lhs, rhs);
  503. }
  504. bool same_value_zero(Interpreter& interpreter, Value lhs, Value rhs)
  505. {
  506. if (lhs.type() != rhs.type())
  507. return false;
  508. if (lhs.is_number()) {
  509. if (lhs.is_nan() && rhs.is_nan())
  510. return true;
  511. if ((lhs.is_positive_zero() || lhs.is_negative_zero()) && (rhs.is_positive_zero() || rhs.is_negative_zero()))
  512. return true;
  513. return lhs.as_double() == rhs.as_double();
  514. }
  515. return same_value_non_numeric(interpreter, lhs, rhs);
  516. }
  517. bool same_value_non_numeric(Interpreter&, Value lhs, Value rhs)
  518. {
  519. ASSERT(!lhs.is_number());
  520. ASSERT(lhs.type() == rhs.type());
  521. switch (lhs.type()) {
  522. case Value::Type::Undefined:
  523. case Value::Type::Null:
  524. return true;
  525. case Value::Type::String:
  526. return lhs.as_string().string() == rhs.as_string().string();
  527. case Value::Type::Symbol:
  528. return &lhs.as_symbol() == &rhs.as_symbol();
  529. case Value::Type::Boolean:
  530. return lhs.as_bool() == rhs.as_bool();
  531. case Value::Type::Object:
  532. return &lhs.as_object() == &rhs.as_object();
  533. default:
  534. ASSERT_NOT_REACHED();
  535. }
  536. }
  537. bool strict_eq(Interpreter& interpreter, Value lhs, Value rhs)
  538. {
  539. if (lhs.type() != rhs.type())
  540. return false;
  541. if (lhs.is_number()) {
  542. if (lhs.is_nan() || rhs.is_nan())
  543. return false;
  544. if (lhs.as_double() == rhs.as_double())
  545. return true;
  546. if ((lhs.is_positive_zero() || lhs.is_negative_zero()) && (rhs.is_positive_zero() || rhs.is_negative_zero()))
  547. return true;
  548. return false;
  549. }
  550. return same_value_non_numeric(interpreter, lhs, rhs);
  551. }
  552. bool abstract_eq(Interpreter& interpreter, Value lhs, Value rhs)
  553. {
  554. if (lhs.type() == rhs.type())
  555. return strict_eq(interpreter, lhs, rhs);
  556. if ((lhs.is_undefined() || lhs.is_null()) && (rhs.is_undefined() || rhs.is_null()))
  557. return true;
  558. if (lhs.is_number() && rhs.is_string())
  559. return abstract_eq(interpreter, lhs, rhs.to_number(interpreter));
  560. if (lhs.is_string() && rhs.is_number())
  561. return abstract_eq(interpreter, lhs.to_number(interpreter), rhs);
  562. if (lhs.is_boolean())
  563. return abstract_eq(interpreter, lhs.to_number(interpreter), rhs);
  564. if (rhs.is_boolean())
  565. return abstract_eq(interpreter, lhs, rhs.to_number(interpreter));
  566. if ((lhs.is_string() || lhs.is_number() || lhs.is_symbol()) && rhs.is_object())
  567. return abstract_eq(interpreter, lhs, rhs.to_primitive(interpreter));
  568. if (lhs.is_object() && (rhs.is_string() || rhs.is_number() || rhs.is_symbol()))
  569. return abstract_eq(interpreter, lhs.to_primitive(interpreter), rhs);
  570. return false;
  571. }
  572. TriState abstract_relation(Interpreter& interpreter, bool left_first, Value lhs, Value rhs)
  573. {
  574. Value x_primitive = {};
  575. Value y_primitive = {};
  576. if (left_first) {
  577. x_primitive = lhs.to_primitive(interpreter, Value::PreferredType::Number);
  578. if (interpreter.exception())
  579. return {};
  580. y_primitive = rhs.to_primitive(interpreter, Value::PreferredType::Number);
  581. if (interpreter.exception())
  582. return {};
  583. } else {
  584. y_primitive = lhs.to_primitive(interpreter, Value::PreferredType::Number);
  585. if (interpreter.exception())
  586. return {};
  587. x_primitive = rhs.to_primitive(interpreter, Value::PreferredType::Number);
  588. if (interpreter.exception())
  589. return {};
  590. }
  591. if (x_primitive.is_string() && y_primitive.is_string()) {
  592. auto x_string = x_primitive.as_string().string();
  593. auto y_string = y_primitive.as_string().string();
  594. if (x_string.starts_with(y_string))
  595. return TriState::False;
  596. if (y_string.starts_with(x_string))
  597. return TriState::True;
  598. Utf8View x_codepoints { x_string };
  599. Utf8View y_codepoints { y_string };
  600. for (auto k = x_codepoints.begin(), l = y_codepoints.begin();
  601. k != x_codepoints.end() && l != y_codepoints.end();
  602. ++k, ++l) {
  603. if (*k != *l) {
  604. if (*k < *l) {
  605. return TriState::True;
  606. } else {
  607. return TriState::False;
  608. }
  609. }
  610. }
  611. ASSERT_NOT_REACHED();
  612. }
  613. // FIXME add BigInt cases here once we have BigInt
  614. auto x_numeric = x_primitive.to_number(interpreter);
  615. if (interpreter.exception())
  616. return {};
  617. auto y_numeric = y_primitive.to_number(interpreter);
  618. if (interpreter.exception())
  619. return {};
  620. if (x_numeric.is_nan() || y_numeric.is_nan())
  621. return TriState::Unknown;
  622. if (x_numeric.is_positive_infinity() || y_numeric.is_negative_infinity())
  623. return TriState::False;
  624. if (x_numeric.is_negative_infinity() || y_numeric.is_positive_infinity())
  625. return TriState::True;
  626. auto x_value = x_numeric.as_double();
  627. auto y_value = y_numeric.as_double();
  628. if (x_value < y_value)
  629. return TriState::True;
  630. else
  631. return TriState::False;
  632. }
  633. }