1763b20fd0af4c374202d08a232f53da7fe52fc1
[WebKit.git] / Source / JavaScriptCore / builtins / TypedArrayConstructor.js
1 /*
2  * Copyright (C) 2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 // According to the spec we are supposed to crawl the prototype chain looking
27 // for the a TypedArray constructor. The way we implement this is with a
28 // private function, @alloctateTypedArray, on each of the prototypes.
29 // This enables us to optimize this lookup in the inline cache.
30
31 function of(/* items... */)
32 {
33     "use strict";
34     let len = arguments.length;
35     let constructFunction = this.@allocateTypedArray;
36     if (constructFunction === @undefined)
37         @throwTypeError("TypedArray.of requires its this argument to subclass a TypedArray constructor");
38
39     let result = constructFunction(len);
40
41     for (let i = 0; i < len; i++)
42         result[i] = arguments[i];
43
44     return result;
45 }
46
47 function from(items /* [ , mapfn [ , thisArg ] ] */)
48 {
49     "use strict";
50
51     let mapFn = arguments[1];
52
53     let thisArg;
54
55     if (mapFn !== @undefined) {
56         if (typeof mapFn !== "function")
57             @throwTypeError("TypedArray.from requires that the second argument, when provided, be a function");
58
59         if (arguments.length > 2)
60             thisArg = arguments[2];
61     }
62
63     if (items == null)
64         @throwTypeError("TypedArray.from requires an array-like object - not null or undefined");
65
66     let iteratorMethod = items.@iteratorSymbol;
67     if (iteratorMethod != null) {
68         if (typeof iteratorMethod !== "function")
69             @throwTypeError("TypedArray.from requires that the property of the first argument, items[Symbol.iterator], when exists, be a function");
70
71         let accumulator = [];
72
73         let k = 0;
74         let iterator = iteratorMethod.@call(items);
75
76         // Since for-of loop once more looks up the @@iterator property of a given iterable,
77         // it could be observable if the user defines a getter for @@iterator.
78         // To avoid this situation, we define a wrapper object that @@iterator just returns a given iterator.
79         let wrapper = {};
80         wrapper.@iteratorSymbol = function() { return iterator; }
81
82         for (let value of wrapper) {
83             if (mapFn)
84                 @putByValDirect(accumulator, k, thisArg === @undefined ? mapFn(value, k) : mapFn.@call(thisArg, value, k));
85             else
86                 @putByValDirect(accumulator, k, value);
87             k++;
88         }
89
90         let constructFunction = this.@allocateTypedArray;
91         if (constructFunction === @undefined)
92             @throwTypeError("TypedArray.from requires its this argument subclass a TypedArray constructor");
93
94         let result = constructFunction(k);
95
96         for (let i = 0; i < k; i++) 
97             result[i] = accumulator[i];
98
99
100         return result;
101     }
102
103     let arrayLike = @Object(items);
104     let arrayLikeLength = @toLength(arrayLike.length);
105
106     let constructFunction = this.@allocateTypedArray;
107     if (constructFunction === @undefined)
108         @throwTypeError("this does not subclass a TypedArray constructor");
109
110     let result = constructFunction(arrayLikeLength);
111
112     let k = 0;
113     while (k < arrayLikeLength) {
114         let value = arrayLike[k];
115         if (mapFn)
116             result[k] = thisArg === @undefined ? mapFn(value, k) : mapFn.@call(thisArg, value, k);
117         else
118             result[k] = value;
119         k++;
120     }
121
122     return result;
123 }
124
125 function allocateInt8Array(length)
126 {
127     return new @Int8Array(length);
128 }
129
130 function allocateInt16Array(length)
131 {
132     return new @Int16Array(length);    
133 }
134
135 function allocateInt32Array(length)
136 {
137     return new @Int32Array(length);   
138 }
139
140 function allocateUint32Array(length)
141 {
142     return new @Uint32Array(length);
143 }
144
145 function allocateUint16Array(length)
146 {
147     return new @Uint16Array(length);   
148 }
149
150 function allocateUint8Array(length)
151 {
152     return new @Uint8Array(length);   
153 }
154
155 function allocateUint8ClampedArray(length)
156 {
157     return new @Uint8ClampedArray(length);
158 }
159
160 function allocateFloat32Array(length)
161 {
162     return new @Float32Array(length);
163 }
164
165 function allocateFloat64Array(length)
166 {
167     return new @Float64Array(length);
168 }