ArrayPrototype.cs 34 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058
  1. using System;
  2. using System.Collections.Generic;
  3. using Jint.Native.Object;
  4. using Jint.Runtime;
  5. using Jint.Runtime.Descriptors;
  6. using Jint.Runtime.Descriptors.Specialized;
  7. using Jint.Runtime.Interop;
  8. namespace Jint.Native.Array
  9. {
  10. /// <summary>
  11. /// http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4
  12. /// </summary>
  13. public sealed class ArrayPrototype : ArrayInstance
  14. {
  15. private ArrayPrototype(Engine engine) : base(engine)
  16. {
  17. }
  18. public static ArrayPrototype CreatePrototypeObject(Engine engine, ArrayConstructor arrayConstructor)
  19. {
  20. var obj = new ArrayPrototype(engine)
  21. {
  22. Extensible = true,
  23. Prototype = engine.Object.PrototypeObject
  24. };
  25. obj.FastAddProperty("length", 0, true, false, false);
  26. obj.SetOwnProperty("constructor", new NonEnumerablePropertyDescriptor(arrayConstructor));
  27. return obj;
  28. }
  29. public void Configure()
  30. {
  31. FastAddProperty("toString", new ClrFunctionInstance(Engine, ToString, 0), true, false, true);
  32. FastAddProperty("toLocaleString", new ClrFunctionInstance(Engine, ToLocaleString), true, false, true);
  33. FastAddProperty("concat", new ClrFunctionInstance(Engine, Concat, 1), true, false, true);
  34. FastAddProperty("join", new ClrFunctionInstance(Engine, Join, 1), true, false, true);
  35. FastAddProperty("pop", new ClrFunctionInstance(Engine, Pop), true, false, true);
  36. FastAddProperty("push", new ClrFunctionInstance(Engine, Push, 1), true, false, true);
  37. FastAddProperty("reverse", new ClrFunctionInstance(Engine, Reverse), true, false, true);
  38. FastAddProperty("shift", new ClrFunctionInstance(Engine, Shift), true, false, true);
  39. FastAddProperty("slice", new ClrFunctionInstance(Engine, Slice, 2), true, false, true);
  40. FastAddProperty("sort", new ClrFunctionInstance(Engine, Sort, 1), true, false, true);
  41. FastAddProperty("splice", new ClrFunctionInstance(Engine, Splice, 2), true, false, true);
  42. FastAddProperty("unshift", new ClrFunctionInstance(Engine, Unshift, 1), true, false, true);
  43. FastAddProperty("indexOf", new ClrFunctionInstance(Engine, IndexOf, 1), true, false, true);
  44. FastAddProperty("lastIndexOf", new ClrFunctionInstance(Engine, LastIndexOf, 1), true, false, true);
  45. FastAddProperty("every", new ClrFunctionInstance(Engine, Every, 1), true, false, true);
  46. FastAddProperty("some", new ClrFunctionInstance(Engine, Some, 1), true, false, true);
  47. FastAddProperty("forEach", new ClrFunctionInstance(Engine, ForEach, 1), true, false, true);
  48. FastAddProperty("map", new ClrFunctionInstance(Engine, Map, 1), true, false, true);
  49. FastAddProperty("filter", new ClrFunctionInstance(Engine, Filter, 1), true, false, true);
  50. FastAddProperty("reduce", new ClrFunctionInstance(Engine, Reduce, 1), true, false, true);
  51. FastAddProperty("reduceRight", new ClrFunctionInstance(Engine, ReduceRight, 1), true, false, true);
  52. }
  53. private JsValue LastIndexOf(JsValue thisObj, JsValue[] arguments)
  54. {
  55. var o = ArrayOperations.For(Engine, thisObj);
  56. var len = o.GetLength();
  57. if (len == 0)
  58. {
  59. return -1;
  60. }
  61. var n = arguments.Length > 1 ? TypeConverter.ToInteger(arguments[1]) : len - 1;
  62. double k;
  63. if (n >= 0)
  64. {
  65. k = System.Math.Min(n, len - 1); // min
  66. }
  67. else
  68. {
  69. k = len - System.Math.Abs(n);
  70. }
  71. if (k < 0 || k > uint.MaxValue)
  72. {
  73. return -1;
  74. }
  75. var searchElement = arguments.At(0);
  76. var i = (uint) k;
  77. for (;; i--)
  78. {
  79. if (o.TryGetValue(i, out var value))
  80. {
  81. var same = ExpressionInterpreter.StrictlyEqual(value, searchElement);
  82. if (same)
  83. {
  84. return i;
  85. }
  86. }
  87. if (i == 0)
  88. {
  89. break;
  90. }
  91. }
  92. return -1;
  93. }
  94. private JsValue Reduce(JsValue thisObj, JsValue[] arguments)
  95. {
  96. var callbackfn = arguments.At(0);
  97. var initialValue = arguments.At(1);
  98. var o = ArrayOperations.For(Engine, thisObj);
  99. var len = o.GetLength();
  100. var callable = callbackfn.TryCast<ICallable>(x => throw new JavaScriptException(Engine.TypeError, "Argument must be callable"));
  101. if (len == 0 && arguments.Length < 2)
  102. {
  103. throw new JavaScriptException(Engine.TypeError);
  104. }
  105. var k = 0;
  106. JsValue accumulator = Undefined;
  107. if (arguments.Length > 1)
  108. {
  109. accumulator = initialValue;
  110. }
  111. else
  112. {
  113. var kPresent = false;
  114. while (kPresent == false && k < len)
  115. {
  116. if (kPresent = o.TryGetValue((uint) k, out var temp))
  117. {
  118. accumulator = temp;
  119. }
  120. k++;
  121. }
  122. if (kPresent == false)
  123. {
  124. throw new JavaScriptException(Engine.TypeError);
  125. }
  126. }
  127. var args = new JsValue[4];
  128. while (k < len)
  129. {
  130. var i = (uint) k;
  131. if (o.TryGetValue(i, out var kvalue))
  132. {
  133. args[0] = accumulator;
  134. args[1] = kvalue;
  135. args[2] = i;
  136. args[3] = o.Target;
  137. accumulator = callable.Call(Undefined, args);
  138. }
  139. k++;
  140. }
  141. return accumulator;
  142. }
  143. private JsValue Filter(JsValue thisObj, JsValue[] arguments)
  144. {
  145. var callbackfn = arguments.At(0);
  146. var thisArg = arguments.At(1);
  147. var o = ArrayOperations.For(Engine, thisObj);
  148. var len = o.GetLength();
  149. var callable = callbackfn.TryCast<ICallable>(x => throw new JavaScriptException(Engine.TypeError, "Argument must be callable"));
  150. var a = (ArrayInstance) Engine.Array.Construct(Arguments.Empty);
  151. uint to = 0;
  152. var args = new JsValue[3];
  153. for (uint k = 0; k < len; k++)
  154. {
  155. if (o.TryGetValue(k, out var kvalue))
  156. {
  157. args[0] = kvalue;
  158. args[1] = k;
  159. args[2] = o.Target;
  160. var selected = callable.Call(thisArg, args);
  161. if (TypeConverter.ToBoolean(selected))
  162. {
  163. a.SetIndexValue(to, kvalue, throwOnError: false);
  164. to++;
  165. }
  166. }
  167. }
  168. return a;
  169. }
  170. private JsValue Map(JsValue thisObj, JsValue[] arguments)
  171. {
  172. var callbackfn = arguments.At(0);
  173. var thisArg = arguments.At(1);
  174. var o = ArrayOperations.For(Engine, thisObj);
  175. var len = o.GetLength();
  176. var callable = callbackfn.TryCast<ICallable>(x => throw new JavaScriptException(Engine.TypeError, "Argument must be callable"));
  177. var a = Engine.Array.Construct(new JsValue[] {len}, len);
  178. var args = new JsValue[3];
  179. for (uint k = 0; k < len; k++)
  180. {
  181. if (o.TryGetValue(k, out var kvalue))
  182. {
  183. args[0] = kvalue;
  184. args[1] = k;
  185. args[2] = o.Target;
  186. var mappedValue = callable.Call(thisArg, args);
  187. a.SetIndexValue(k, mappedValue, throwOnError: false);
  188. }
  189. }
  190. return a;
  191. }
  192. private JsValue ForEach(JsValue thisObj, JsValue[] arguments)
  193. {
  194. var callbackfn = arguments.At(0);
  195. var thisArg = arguments.At(1);
  196. var o = ArrayOperations.For(Engine, thisObj);
  197. var len = o.GetLength();
  198. var callable = callbackfn.TryCast<ICallable>(x => throw new JavaScriptException(Engine.TypeError, "Argument must be callable"));
  199. var args = new JsValue[3];
  200. for (uint k = 0; k < len; k++)
  201. {
  202. if (o.TryGetValue(k, out var kvalue))
  203. {
  204. args[0] = kvalue;
  205. args[1] = k;
  206. args[2] = o.Target;
  207. callable.Call(thisArg, args);
  208. }
  209. }
  210. return Undefined;
  211. }
  212. private JsValue Some(JsValue thisObj, JsValue[] arguments)
  213. {
  214. var callbackfn = arguments.At(0);
  215. var thisArg = arguments.At(1);
  216. var o = ArrayOperations.For(Engine, thisObj);
  217. var len = o.GetLength();
  218. var callable = callbackfn.TryCast<ICallable>(x => throw new JavaScriptException(Engine.TypeError, "Argument must be callable"));
  219. var args = new JsValue[3];
  220. for (uint k = 0; k < len; k++)
  221. {
  222. if (o.TryGetValue(k, out var kvalue))
  223. {
  224. args[0] = kvalue;
  225. args[1] = k;
  226. args[2] = o.Target;
  227. var testResult = callable.Call(thisArg, args);
  228. if (TypeConverter.ToBoolean(testResult))
  229. {
  230. return true;
  231. }
  232. }
  233. }
  234. return false;
  235. }
  236. private JsValue Every(JsValue thisObj, JsValue[] arguments)
  237. {
  238. var callbackfn = arguments.At(0);
  239. var thisArg = arguments.At(1);
  240. var o = ArrayOperations.For(Engine, thisObj);
  241. var len = o.GetLength();
  242. var callable = callbackfn.TryCast<ICallable>(x => throw new JavaScriptException(Engine.TypeError, "Argument must be callable"));
  243. var args = new JsValue[3];
  244. for (uint k = 0; k < len; k++)
  245. {
  246. if (o.TryGetValue(k, out var kvalue))
  247. {
  248. args[0] = kvalue;
  249. args[1] = k;
  250. args[2] = o.Target;
  251. var testResult = callable.Call(thisArg, args);
  252. if (false == TypeConverter.ToBoolean(testResult))
  253. {
  254. return JsBoolean.False;
  255. }
  256. }
  257. }
  258. return JsBoolean.True;
  259. }
  260. private JsValue IndexOf(JsValue thisObj, JsValue[] arguments)
  261. {
  262. var o = ArrayOperations.For(Engine, thisObj);
  263. var len = o.GetLength();
  264. if (len == 0)
  265. {
  266. return -1;
  267. }
  268. var startIndex = arguments.Length > 1 ? TypeConverter.ToInteger(arguments[1]) : 0;
  269. if (startIndex > uint.MaxValue)
  270. {
  271. return -1;
  272. }
  273. uint k;
  274. if (startIndex < 0)
  275. {
  276. var abs = System.Math.Abs(startIndex);
  277. long temp = len - (uint) abs;
  278. if (abs > len || temp < 0)
  279. {
  280. temp = 0;
  281. }
  282. k = (uint) temp;
  283. }
  284. else
  285. {
  286. k = (uint) startIndex;
  287. }
  288. if (k >= len)
  289. {
  290. return -1;
  291. }
  292. uint smallestIndex = o.GetSmallestIndex();
  293. if (smallestIndex > k)
  294. {
  295. k = smallestIndex;
  296. }
  297. var searchElement = arguments.At(0);
  298. for (; k < len; k++)
  299. {
  300. if (o.TryGetValue(k, out var elementK))
  301. {
  302. var same = ExpressionInterpreter.StrictlyEqual(elementK, searchElement);
  303. if (same)
  304. {
  305. return k;
  306. }
  307. }
  308. }
  309. return -1;
  310. }
  311. private JsValue Splice(JsValue thisObj, JsValue[] arguments)
  312. {
  313. var start = arguments.At(0);
  314. var deleteCount = arguments.At(1);
  315. var o = ArrayOperations.For(Engine, thisObj);
  316. var len = o.GetLength();
  317. var relativeStart = TypeConverter.ToInteger(start);
  318. uint actualStart;
  319. if (relativeStart < 0)
  320. {
  321. actualStart = (uint) System.Math.Max(len + relativeStart, 0);
  322. }
  323. else
  324. {
  325. actualStart = (uint) System.Math.Min(relativeStart, len);
  326. }
  327. var actualDeleteCount = (uint) System.Math.Min(System.Math.Max(TypeConverter.ToInteger(deleteCount), 0), len - actualStart);
  328. var a = Engine.Array.Construct(actualDeleteCount);
  329. for (uint k = 0; k < actualDeleteCount; k++)
  330. {
  331. if (o.TryGetValue(actualStart + k, out var fromValue))
  332. {
  333. a.SetIndexValue(k, fromValue, throwOnError: false);
  334. }
  335. }
  336. var items = System.Array.Empty<JsValue>();
  337. if (arguments.Length > 2)
  338. {
  339. items = new JsValue[arguments.Length - 2];
  340. System.Array.Copy(arguments, 2, items, 0, items.Length);
  341. }
  342. var length = len - actualDeleteCount + (uint) items.Length;
  343. o.EnsureCapacity(length);
  344. if (items.Length < actualDeleteCount)
  345. {
  346. for (uint k = actualStart; k < len - actualDeleteCount; k++)
  347. {
  348. var from = k + actualDeleteCount;
  349. var to = (uint) (k + items.Length);
  350. if (o.TryGetValue(from, out var fromValue))
  351. {
  352. o.Put(to, fromValue, true);
  353. }
  354. else
  355. {
  356. o.DeleteAt(to);
  357. }
  358. }
  359. for (var k = len; k > len - actualDeleteCount + items.Length; k--)
  360. {
  361. o.DeleteAt(k - 1);
  362. }
  363. }
  364. else if (items.Length > actualDeleteCount)
  365. {
  366. for (var k = len - actualDeleteCount; k > actualStart; k--)
  367. {
  368. var from = k + actualDeleteCount - 1;
  369. uint to = (uint) (k + items.Length - 1);
  370. if (o.TryGetValue(from, out var fromValue))
  371. {
  372. o.Put(to, fromValue, true);
  373. }
  374. else
  375. {
  376. o.DeleteAt(to);
  377. }
  378. }
  379. }
  380. for (uint k = 0; k < items.Length; k++)
  381. {
  382. var e = items[k];
  383. o.Put(k + actualStart, e, true);
  384. }
  385. o.SetLength(length);
  386. return a;
  387. }
  388. private JsValue Unshift(JsValue thisObj, JsValue[] arguments)
  389. {
  390. var o = ArrayOperations.For(Engine, thisObj);
  391. var len = o.GetLength();
  392. var argCount = (uint) arguments.Length;
  393. o.EnsureCapacity(len + argCount);
  394. for (var k = len; k > 0; k--)
  395. {
  396. var from = k - 1;
  397. var to = k + argCount - 1;
  398. if (o.TryGetValue(from, out var fromValue))
  399. {
  400. o.Put(to, fromValue, true);
  401. }
  402. else
  403. {
  404. o.DeleteAt(to);
  405. }
  406. }
  407. for (uint j = 0; j < argCount; j++)
  408. {
  409. o.Put(j, arguments[j], true);
  410. }
  411. o.SetLength(len + argCount);
  412. return len + argCount;
  413. }
  414. private JsValue Sort(JsValue thisObj, JsValue[] arguments)
  415. {
  416. if (!thisObj.IsObject())
  417. {
  418. throw new JavaScriptException(Engine.TypeError, "Array.prorotype.sort can only be applied on objects");
  419. }
  420. var obj = ArrayOperations.For(thisObj.AsObject());
  421. var len = obj.GetLength();
  422. if (len <= 1)
  423. {
  424. return obj.Target;
  425. }
  426. var compareArg = arguments.At(0);
  427. ICallable compareFn = null;
  428. if (compareArg != Undefined)
  429. {
  430. compareFn = compareArg.TryCast<ICallable>(x => throw new JavaScriptException(Engine.TypeError, "The sort argument must be a function"));
  431. }
  432. int Comparer(JsValue x, JsValue y)
  433. {
  434. if (ReferenceEquals(x, Undefined) && ReferenceEquals(y, Undefined))
  435. {
  436. return 0;
  437. }
  438. if (ReferenceEquals(x, Undefined))
  439. {
  440. return 1;
  441. }
  442. if (ReferenceEquals(y, Undefined))
  443. {
  444. return -1;
  445. }
  446. if (compareFn != null)
  447. {
  448. var s = TypeConverter.ToNumber(compareFn.Call(Undefined, new[] {x, y}));
  449. if (s < 0)
  450. {
  451. return -1;
  452. }
  453. if (s > 0)
  454. {
  455. return 1;
  456. }
  457. return 0;
  458. }
  459. var xString = TypeConverter.ToString(x);
  460. var yString = TypeConverter.ToString(y);
  461. var r = System.String.CompareOrdinal(xString, yString);
  462. return r;
  463. }
  464. var array = new JsValue[len];
  465. for (uint i = 0; i < len; ++i)
  466. {
  467. array[i] = obj.Get(i);
  468. }
  469. // don't eat inner exceptions
  470. try
  471. {
  472. System.Array.Sort(array, Comparer);
  473. }
  474. catch (InvalidOperationException e)
  475. {
  476. throw e.InnerException;
  477. }
  478. for (uint i = 0; i < len; ++i)
  479. {
  480. obj.Put(i, array[i], false);
  481. }
  482. return obj.Target;
  483. }
  484. private JsValue Slice(JsValue thisObj, JsValue[] arguments)
  485. {
  486. var start = arguments.At(0);
  487. var end = arguments.At(1);
  488. var o = ArrayOperations.For(Engine, thisObj);
  489. var len = o.GetLength();
  490. var relativeStart = TypeConverter.ToInteger(start);
  491. uint k;
  492. if (relativeStart < 0)
  493. {
  494. k = (uint) System.Math.Max(len + relativeStart, 0);
  495. }
  496. else
  497. {
  498. k = (uint) System.Math.Min(TypeConverter.ToInteger(start), len);
  499. }
  500. uint final;
  501. if (ReferenceEquals(end, Undefined))
  502. {
  503. final = TypeConverter.ToUint32(len);
  504. }
  505. else
  506. {
  507. double relativeEnd = TypeConverter.ToInteger(end);
  508. if (relativeEnd < 0)
  509. {
  510. final = (uint) System.Math.Max(len + relativeEnd, 0);
  511. }
  512. else
  513. {
  514. final = (uint) System.Math.Min(TypeConverter.ToInteger(relativeEnd), len);
  515. }
  516. }
  517. var a = Engine.Array.Construct(final - k);
  518. uint n = 0;
  519. for (; k < final; k++)
  520. {
  521. if (o.TryGetValue(k, out var kValue))
  522. {
  523. a.SetIndexValue(n, kValue, throwOnError: false);
  524. }
  525. n++;
  526. }
  527. return a;
  528. }
  529. private JsValue Shift(JsValue thisObj, JsValue[] arg2)
  530. {
  531. var o = ArrayOperations.For(Engine, thisObj);
  532. var len = o.GetLength();
  533. if (len == 0)
  534. {
  535. o.SetLength(0);
  536. return Undefined;
  537. }
  538. var first = o.Get(0);
  539. for (uint k = 1; k < len; k++)
  540. {
  541. var to = k - 1;
  542. if (o.TryGetValue(k, out var fromVal))
  543. {
  544. o.Put(to, fromVal, true);
  545. }
  546. else
  547. {
  548. o.DeleteAt(to);
  549. }
  550. }
  551. o.DeleteAt(len - 1);
  552. o.SetLength(len - 1);
  553. return first;
  554. }
  555. private JsValue Reverse(JsValue thisObj, JsValue[] arguments)
  556. {
  557. var o = ArrayOperations.For(Engine, thisObj);
  558. var len = o.GetLength();
  559. var middle = (uint) System.Math.Floor(len / 2.0);
  560. uint lower = 0;
  561. while (lower != middle)
  562. {
  563. var upper = len - lower - 1;
  564. var lowerExists = o.TryGetValue(lower, out var lowerValue);
  565. var upperExists = o.TryGetValue(upper, out var upperValue);
  566. if (lowerExists && upperExists)
  567. {
  568. o.Put(lower, upperValue, true);
  569. o.Put(upper, lowerValue, true);
  570. }
  571. if (!lowerExists && upperExists)
  572. {
  573. o.Put(lower, upperValue, true);
  574. o.DeleteAt(upper);
  575. }
  576. if (lowerExists && !upperExists)
  577. {
  578. o.DeleteAt(lower);
  579. o.Put(upper, lowerValue, true);
  580. }
  581. lower++;
  582. }
  583. return o.Target;
  584. }
  585. private JsValue Join(JsValue thisObj, JsValue[] arguments)
  586. {
  587. var separator = arguments.At(0);
  588. var o = ArrayOperations.For(Engine, thisObj);
  589. var len = o.GetLength();
  590. if (ReferenceEquals(separator, Undefined))
  591. {
  592. separator = ",";
  593. }
  594. var sep = TypeConverter.ToString(separator);
  595. // as per the spec, this has to be called after ToString(separator)
  596. if (len == 0)
  597. {
  598. return "";
  599. }
  600. string StringFromJsValue(JsValue value)
  601. {
  602. return ReferenceEquals(value, Undefined) || ReferenceEquals(value, Null)
  603. ? ""
  604. : TypeConverter.ToString(value);
  605. }
  606. var s = StringFromJsValue(o.Get(0));
  607. if (len == 1)
  608. {
  609. return s;
  610. }
  611. var sb = ArrayExecutionContext.Current.StringBuilder;
  612. sb.Clear();
  613. sb.Append(s);
  614. for (uint k = 1; k < len; k++)
  615. {
  616. sb.Append(sep);
  617. sb.Append(StringFromJsValue(o.Get(k)));
  618. }
  619. return sb.ToString();
  620. }
  621. private JsValue ToLocaleString(JsValue thisObj, JsValue[] arguments)
  622. {
  623. var array = ArrayOperations.For(Engine, thisObj);
  624. var len = array.GetLength();
  625. const string separator = ",";
  626. if (len == 0)
  627. {
  628. return "";
  629. }
  630. JsValue r;
  631. if (!array.TryGetValue(0, out var firstElement) || ReferenceEquals(firstElement, Null) || ReferenceEquals(firstElement, Undefined))
  632. {
  633. r = "";
  634. }
  635. else
  636. {
  637. var elementObj = TypeConverter.ToObject(Engine, firstElement);
  638. var func = elementObj.Get("toLocaleString").TryCast<ICallable>(x => throw new JavaScriptException(Engine.TypeError));
  639. r = func.Call(elementObj, Arguments.Empty);
  640. }
  641. for (uint k = 1; k < len; k++)
  642. {
  643. string s = r + separator;
  644. if (!array.TryGetValue(k, out var nextElement) || ReferenceEquals(nextElement, Null))
  645. {
  646. r = "";
  647. }
  648. else
  649. {
  650. var elementObj = TypeConverter.ToObject(Engine, nextElement);
  651. var func = elementObj.Get("toLocaleString").TryCast<ICallable>(x => throw new JavaScriptException(Engine.TypeError));
  652. r = func.Call(elementObj, Arguments.Empty);
  653. }
  654. r = s + r;
  655. }
  656. return r;
  657. }
  658. private JsValue Concat(JsValue thisObj, JsValue[] arguments)
  659. {
  660. var o = TypeConverter.ToObject(Engine, thisObj);
  661. uint n = 0;
  662. var items = new List<JsValue>(arguments.Length + 1) {o};
  663. items.AddRange(arguments);
  664. // try to find best capacity
  665. uint capacity = 0;
  666. foreach (var e in items)
  667. {
  668. var eArray = e.TryCast<ArrayInstance>();
  669. capacity += eArray?.GetLength() ?? (uint) 1;
  670. }
  671. var a = Engine.Array.Construct(Arguments.Empty, capacity);
  672. foreach (var e in items)
  673. {
  674. var eArray = e.TryCast<ArrayInstance>();
  675. if (eArray != null)
  676. {
  677. var len = eArray.GetLength();
  678. for (uint k = 0; k < len; k++)
  679. {
  680. if (eArray.TryGetValue(k, out var subElement))
  681. {
  682. a.SetIndexValue(n, subElement, throwOnError: false);
  683. }
  684. n++;
  685. }
  686. }
  687. else
  688. {
  689. a.SetIndexValue(n, e, throwOnError: false);
  690. n++;
  691. }
  692. }
  693. // this is not in the specs, but is necessary in case the last element of the last
  694. // array doesn't exist, and thus the length would not be incremented
  695. a.DefineOwnProperty("length", new NullConfigurationPropertyDescriptor(n), false);
  696. return a;
  697. }
  698. private JsValue ToString(JsValue thisObj, JsValue[] arguments)
  699. {
  700. var array = TypeConverter.ToObject(Engine, thisObj);
  701. ICallable func;
  702. func = array.Get("join").TryCast<ICallable>(x => { func = Engine.Object.PrototypeObject.Get("toString").TryCast<ICallable>(y => throw new ArgumentException()); });
  703. return func.Call(array, Arguments.Empty);
  704. }
  705. private JsValue ReduceRight(JsValue thisObj, JsValue[] arguments)
  706. {
  707. var callbackfn = arguments.At(0);
  708. var initialValue = arguments.At(1);
  709. var o = TypeConverter.ToObject(Engine, thisObj);
  710. var lenValue = o.Get("length");
  711. var len = TypeConverter.ToUint32(lenValue);
  712. var callable = callbackfn.TryCast<ICallable>(x => { throw new JavaScriptException(Engine.TypeError, "Argument must be callable"); });
  713. if (len == 0 && arguments.Length < 2)
  714. {
  715. throw new JavaScriptException(Engine.TypeError);
  716. }
  717. int k = (int) len - 1;
  718. JsValue accumulator = Undefined;
  719. if (arguments.Length > 1)
  720. {
  721. accumulator = initialValue;
  722. }
  723. else
  724. {
  725. var kPresent = false;
  726. while (kPresent == false && k >= 0)
  727. {
  728. var pk = TypeConverter.ToString(k);
  729. kPresent = o.HasProperty(pk);
  730. if (kPresent)
  731. {
  732. accumulator = o.Get(pk);
  733. }
  734. k--;
  735. }
  736. if (kPresent == false)
  737. {
  738. throw new JavaScriptException(Engine.TypeError);
  739. }
  740. }
  741. for (; k >= 0; k--)
  742. {
  743. var pk = TypeConverter.ToString(k);
  744. var kPresent = o.HasProperty(pk);
  745. if (kPresent)
  746. {
  747. var kvalue = o.Get(pk);
  748. accumulator = callable.Call(Undefined, new[] {accumulator, kvalue, k, o});
  749. }
  750. }
  751. return accumulator;
  752. }
  753. public JsValue Push(JsValue thisObject, JsValue[] arguments)
  754. {
  755. var o = ArrayOperations.For(Engine, thisObject);
  756. var lenVal = TypeConverter.ToNumber(o.Target.Get("length"));
  757. // cast to double as we need to prevent an overflow
  758. double n = TypeConverter.ToUint32(lenVal);
  759. var arrayInstance = o.Target as ArrayInstance;
  760. for (var i = 0; i < arguments.Length; i++)
  761. {
  762. JsValue e = arguments[i];
  763. if (arrayInstance != null && n >= 0 && n < uint.MaxValue)
  764. {
  765. // try to optimize a bit
  766. arrayInstance.SetIndexValue((uint) n, e, true);
  767. }
  768. else
  769. {
  770. o.Target.Put(TypeConverter.ToString(n), e, true);
  771. }
  772. n++;
  773. }
  774. o.Target.Put("length", n, true);
  775. return n;
  776. }
  777. public JsValue Pop(JsValue thisObject, JsValue[] arguments)
  778. {
  779. var o = ArrayOperations.For(Engine, thisObject);
  780. var lenVal = TypeConverter.ToNumber(o.Target.Get("length"));
  781. uint len = TypeConverter.ToUint32(lenVal);
  782. if (len == 0)
  783. {
  784. o.SetLength(0);
  785. return Undefined;
  786. }
  787. len = len - 1;
  788. string indx = TypeConverter.ToString(len);
  789. JsValue element = o.Target.Get(indx);
  790. o.Target.Delete(indx, true);
  791. o.Target.Put("length", len, true);
  792. return element;
  793. }
  794. /// <summary>
  795. /// Adapter to use optimized array operations when possible.
  796. /// Gaps the difference between ArgumensInstance and ArrayInstance.
  797. /// </summary>
  798. private abstract class ArrayOperations
  799. {
  800. public abstract ObjectInstance Target { get; }
  801. public virtual uint GetSmallestIndex() => 0;
  802. public abstract uint GetLength();
  803. public abstract void SetLength(uint length);
  804. public virtual void EnsureCapacity(uint capacity)
  805. {
  806. }
  807. public abstract JsValue Get(uint index);
  808. public abstract bool TryGetValue(uint index, out JsValue value);
  809. public abstract void Put(uint index, JsValue value, bool throwOnError);
  810. public abstract void DeleteAt(uint index);
  811. public static ArrayOperations For(Engine engine, JsValue thisObj)
  812. {
  813. var instance = TypeConverter.ToObject(engine, thisObj);
  814. return For(instance);
  815. }
  816. public static ArrayOperations For(ObjectInstance instance)
  817. {
  818. if (instance is ArrayInstance arrayInstance)
  819. {
  820. return new ArrayInstanceOperations(arrayInstance);
  821. }
  822. return new ObjectInstanceOperations(instance);
  823. }
  824. private class ObjectInstanceOperations : ArrayOperations
  825. {
  826. private readonly ObjectInstance _instance;
  827. public ObjectInstanceOperations(ObjectInstance instance)
  828. {
  829. _instance = instance;
  830. }
  831. public override ObjectInstance Target => _instance;
  832. public override uint GetLength()
  833. {
  834. var desc = _instance.GetProperty("length");
  835. if (desc.IsDataDescriptor() && desc.Value != null)
  836. {
  837. return TypeConverter.ToUint32(desc.Value);
  838. }
  839. var getter = desc.Get != null ? desc.Get : Undefined;
  840. if (getter.IsUndefined())
  841. {
  842. return 0;
  843. }
  844. // if getter is not undefined it must be ICallable
  845. var callable = getter.TryCast<ICallable>();
  846. var value = callable.Call(_instance, Arguments.Empty);
  847. return TypeConverter.ToUint32(value);
  848. }
  849. public override void SetLength(uint length) => _instance.Put("length", length, true);
  850. public override JsValue Get(uint index) => _instance.Get(TypeConverter.ToString(index));
  851. public override bool TryGetValue(uint index, out JsValue value)
  852. {
  853. var property = TypeConverter.ToString(index);
  854. var kPresent = _instance.HasProperty(property);
  855. value = kPresent ? _instance.Get(property) : JsValue.Undefined;
  856. return kPresent;
  857. }
  858. public override void Put(uint index, JsValue value, bool throwOnError) => _instance.Put(TypeConverter.ToString(index), value, throwOnError);
  859. public override void DeleteAt(uint index) => _instance.Delete(TypeConverter.ToString(index), true);
  860. }
  861. private class ArrayInstanceOperations : ArrayOperations
  862. {
  863. private readonly ArrayInstance _array;
  864. public ArrayInstanceOperations(ArrayInstance array)
  865. {
  866. _array = array;
  867. }
  868. public override ObjectInstance Target => _array;
  869. public override uint GetSmallestIndex() => _array.GetSmallestIndex();
  870. public override uint GetLength() => _array.GetLength();
  871. public override void SetLength(uint length) => _array.Put("length", length, true);
  872. public override void EnsureCapacity(uint capacity)
  873. {
  874. _array.EnsureCapacity(capacity);
  875. }
  876. public override bool TryGetValue(uint index, out JsValue value)
  877. {
  878. return _array.TryGetValue(index, out value);
  879. }
  880. public override JsValue Get(uint index) => _array.Get(TypeConverter.ToString(index));
  881. public override void DeleteAt(uint index) => _array.DeleteAt(index);
  882. public override void Put(uint index, JsValue value, bool throwOnError) => _array.SetIndexValue(index, value, throwOnError);
  883. }
  884. }
  885. }
  886. }