Foo::s_info should be Foo::info(), so that you can change how the s_info is actually...
[WebKit-https.git] / Source / JavaScriptCore / JSCTypedArrayStubs.h
1 /*
2  * Copyright (C) 2012 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 #ifndef JSCTypedArrayStubs_h
27 #define JSCTypedArrayStubs_h
28
29 #include "Float32Array.h"
30 #include "Float64Array.h"
31 #include "Int16Array.h"
32 #include "Int32Array.h"
33 #include "Int8Array.h"
34 #include "JSDestructibleObject.h"
35 #include "ObjectPrototype.h"
36 #include "Operations.h"
37 #include "Uint16Array.h"
38 #include "Uint32Array.h"
39 #include "Uint8Array.h"
40 #include "Uint8ClampedArray.h"
41
42 #include <wtf/Forward.h>
43
44 namespace JSC {
45     
46 #define TYPED_ARRAY(name, type) \
47 class JS##name##Array : public JSDestructibleObject { \
48 public: \
49     typedef JSDestructibleObject Base; \
50     static JS##name##Array* create(JSC::Structure* structure, JSGlobalObject* globalObject, PassRefPtr<name##Array> impl) \
51     { \
52         JS##name##Array* ptr = new (NotNull, JSC::allocateCell<JS##name##Array>(globalObject->vm().heap)) JS##name##Array(structure, globalObject, impl); \
53         ptr->finishCreation(globalObject->vm()); \
54         return ptr; \
55     }\
56 \
57     static bool getOwnPropertySlot(JSC::JSObject*, JSC::ExecState*, JSC::PropertyName propertyName, JSC::PropertySlot&);\
58     static bool getOwnPropertyDescriptor(JSC::JSObject*, JSC::ExecState*, JSC::PropertyName propertyName, JSC::PropertyDescriptor&);\
59     static bool getOwnPropertySlotByIndex(JSC::JSObject*, JSC::ExecState*, unsigned propertyName, JSC::PropertySlot&);\
60     static void put(JSC::JSCell*, JSC::ExecState*, JSC::PropertyName propertyName, JSC::JSValue, JSC::PutPropertySlot&);\
61     static void putByIndex(JSC::JSCell*, JSC::ExecState*, unsigned propertyName, JSC::JSValue, bool);\
62     DECLARE_INFO;\
63 \
64     static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)\
65     {\
66         return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());\
67     }\
68 \
69     static void getOwnPropertyNames(JSC::JSObject*, JSC::ExecState*, JSC::PropertyNameArray&, JSC::EnumerationMode mode = JSC::ExcludeDontEnumProperties);\
70     static JSC::JSValue getConstructor(JSC::ExecState*, JSC::JSGlobalObject*);\
71 \
72     static const JSC::TypedArrayType TypedArrayStorageType = JSC::TypedArray##name;\
73     uint32_t m_storageLength;\
74     type* m_storage;\
75     RefPtr<name##Array> m_impl;\
76 protected:\
77     JS##name##Array(JSC::Structure*, JSGlobalObject*, PassRefPtr<name##Array>);\
78     void finishCreation(JSC::VM&);\
79     static const unsigned StructureFlags = JSC::OverridesGetPropertyNames | JSC::InterceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero | JSC::OverridesGetOwnPropertySlot | Base::StructureFlags; \
80     JSC::JSValue getByIndex(JSC::ExecState*, unsigned index);\
81     void indexSetter(JSC::ExecState*, unsigned index, JSC::JSValue);\
82 };\
83 \
84 const ClassInfo JS##name##Array::s_info = { #name "Array" , &Base::s_info, 0, 0, CREATE_METHOD_TABLE(JS##name##Array) };\
85 \
86 JS##name##Array::JS##name##Array(Structure* structure, JSGlobalObject* globalObject, PassRefPtr<name##Array> impl)\
87     : Base(globalObject->vm(), structure)\
88     , m_impl(impl)\
89 {\
90 }\
91 \
92 void JS##name##Array::finishCreation(VM& vm)\
93 {\
94     Base::finishCreation(vm);\
95     TypedArrayDescriptor descriptor(&JS##name##Array::s_info, OBJECT_OFFSETOF(JS##name##Array, m_storage), OBJECT_OFFSETOF(JS##name##Array, m_storageLength));\
96     vm.registerTypedArrayDescriptor(m_impl.get(), descriptor);\
97     m_storage = m_impl->data();\
98     m_storageLength = m_impl->length();\
99     putDirect(vm, vm.propertyNames->length, jsNumber(m_storageLength), DontDelete | ReadOnly | DontEnum); \
100     ASSERT(inherits(info()));\
101 }\
102 \
103 bool JS##name##Array::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot)\
104 {\
105     JS##name##Array* thisObject = jsCast<JS##name##Array*>(object);\
106     ASSERT_GC_OBJECT_INHERITS(thisObject, info());\
107     unsigned index = propertyName.asIndex();\
108     if (index < thisObject->m_storageLength) {\
109         ASSERT(index != PropertyName::NotAnIndex);\
110         slot.setValue(thisObject->getByIndex(exec, index));\
111         return true;\
112     }\
113     return Base::getOwnPropertySlot(object, exec, propertyName, slot);\
114 }\
115 \
116 bool JS##name##Array::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)\
117 {\
118     JS##name##Array* thisObject = jsCast<JS##name##Array*>(object);\
119     ASSERT_GC_OBJECT_INHERITS(thisObject, info());\
120     unsigned index = propertyName.asIndex();\
121     if (index < thisObject->m_storageLength) {\
122         ASSERT(index != PropertyName::NotAnIndex);\
123         descriptor.setDescriptor(thisObject->getByIndex(exec, index), DontDelete);\
124         return true;\
125     }\
126     return Base::getOwnPropertyDescriptor(object, exec, propertyName, descriptor);\
127 }\
128 \
129 bool JS##name##Array::getOwnPropertySlotByIndex(JSObject* object, ExecState* exec, unsigned propertyName, PropertySlot& slot)\
130 {\
131     JS##name##Array* thisObject = jsCast<JS##name##Array*>(object);\
132     ASSERT_GC_OBJECT_INHERITS(thisObject, info());\
133     if (propertyName < thisObject->m_storageLength) {\
134         slot.setValue(thisObject->getByIndex(exec, propertyName));\
135         return true;\
136     }\
137     return thisObject->methodTable()->getOwnPropertySlot(thisObject, exec, Identifier::from(exec, propertyName), slot);\
138 }\
139 \
140 void JS##name##Array::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)\
141 {\
142     JS##name##Array* thisObject = jsCast<JS##name##Array*>(cell);\
143     ASSERT_GC_OBJECT_INHERITS(thisObject, info());\
144     unsigned index = propertyName.asIndex();\
145     if (index != PropertyName::NotAnIndex) {\
146         thisObject->indexSetter(exec, index, value);\
147         return;\
148     }\
149     Base::put(thisObject, exec, propertyName, value, slot);\
150 }\
151 \
152 void JS##name##Array::indexSetter(JSC::ExecState* exec, unsigned index, JSC::JSValue value) \
153 {\
154     m_impl->set(index, value.toNumber(exec));\
155 }\
156 \
157 void JS##name##Array::putByIndex(JSCell* cell, ExecState* exec, unsigned propertyName, JSValue value, bool)\
158 {\
159     JS##name##Array* thisObject = jsCast<JS##name##Array*>(cell);\
160     ASSERT_GC_OBJECT_INHERITS(thisObject, info());\
161     thisObject->indexSetter(exec, propertyName, value);\
162     return;\
163 }\
164 \
165 void JS##name##Array::getOwnPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& propertyNames, EnumerationMode mode)\
166 {\
167     JS##name##Array* thisObject = jsCast<JS##name##Array*>(object);\
168     ASSERT_GC_OBJECT_INHERITS(thisObject, info());\
169     for (unsigned i = 0; i < thisObject->m_storageLength; ++i)\
170         propertyNames.add(Identifier::from(exec, i));\
171     Base::getOwnPropertyNames(thisObject, exec, propertyNames, mode);\
172 }\
173 \
174 JSValue JS##name##Array::getByIndex(ExecState*, unsigned index)\
175 {\
176     ASSERT_GC_OBJECT_INHERITS(this, info());\
177     type result = m_impl->item(index);\
178     if (std::isnan((double)result))\
179         return jsNaN();\
180     return JSValue(result);\
181 }\
182 static EncodedJSValue JSC_HOST_CALL constructJS##name##Array(ExecState* callFrame) { \
183     if (callFrame->argumentCount() < 1) \
184         return JSValue::encode(jsUndefined()); \
185     int32_t length = callFrame->argument(0).toInt32(callFrame); \
186     if (length < 0) \
187         return JSValue::encode(jsUndefined()); \
188     Structure* structure = JS##name##Array::createStructure(callFrame->vm(), callFrame->lexicalGlobalObject(), callFrame->lexicalGlobalObject()->objectPrototype()); \
189     RefPtr<name##Array> buffer = name##Array::create(length); \
190     if (!buffer) \
191         return throwVMError(callFrame, createRangeError(callFrame, "ArrayBuffer size is not a small enough positive integer.")); \
192     return JSValue::encode(JS##name##Array::create(structure, callFrame->lexicalGlobalObject(), buffer.release())); \
193 }
194
195 TYPED_ARRAY(Uint8, uint8_t);
196 TYPED_ARRAY(Uint8Clamped, uint8_t);
197 TYPED_ARRAY(Uint16, uint16_t);
198 TYPED_ARRAY(Uint32, uint32_t);
199 TYPED_ARRAY(Int8, int8_t);
200 TYPED_ARRAY(Int16, int16_t);
201 TYPED_ARRAY(Int32, int32_t);
202 TYPED_ARRAY(Float32, float);
203 TYPED_ARRAY(Float64, double);
204
205 }
206
207 #endif