JavaScriptCore:
[WebKit-https.git] / JavaScriptCore / runtime / JSArray.h
1 /*
2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2003, 2007, 2008 Apple Inc. All rights reserved.
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Lesser General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Lesser General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Lesser General Public
16  *  License along with this library; if not, write to the Free Software
17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18  *
19  */
20
21 #ifndef JSArray_h
22 #define JSArray_h
23
24 #include "JSObject.h"
25
26 namespace JSC {
27
28     typedef HashMap<unsigned, JSValuePtr> SparseArrayValueMap;
29
30     struct ArrayStorage {
31         unsigned m_length;
32         unsigned m_vectorLength;
33         unsigned m_numValuesInVector;
34         SparseArrayValueMap* m_sparseValueMap;
35         void* lazyCreationData; // A JSArray subclass can use this to fill the vector lazily.
36         JSValuePtr m_vector[1];
37     };
38
39     class JSArray : public JSObject {
40         friend class JIT;
41
42     public:
43         explicit JSArray(PassRefPtr<Structure>);
44         JSArray(PassRefPtr<Structure>, unsigned initialLength);
45         JSArray(ExecState*, PassRefPtr<Structure>, const ArgList& initialValues);
46         virtual ~JSArray();
47
48         virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
49         virtual bool getOwnPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
50         virtual void put(ExecState*, unsigned propertyName, JSValuePtr); // FIXME: Make protected and add setItem.
51
52         static const ClassInfo info;
53
54         unsigned length() const { return m_storage->m_length; }
55         void setLength(unsigned); // OK to use on new arrays, but not if it might be a RegExpMatchArray.
56
57         void sort(ExecState*);
58         void sort(ExecState*, JSValuePtr compareFunction, CallType, const CallData&);
59         void sortNumeric(ExecState*, JSValuePtr compareFunction, CallType, const CallData&);
60
61         void push(ExecState*, JSValuePtr);
62         JSValuePtr pop();
63
64         bool canGetIndex(unsigned i) { return i < m_fastAccessCutoff; }
65         JSValuePtr getIndex(unsigned i)
66         {
67             ASSERT(canGetIndex(i));
68             return m_storage->m_vector[i];
69         }
70
71         bool canSetIndex(unsigned i) { return i < m_fastAccessCutoff; }
72         JSValuePtr setIndex(unsigned i, JSValuePtr v)
73         {
74             ASSERT(canSetIndex(i));
75             return m_storage->m_vector[i] = v;
76         }
77
78         void fillArgList(ExecState*, ArgList&);
79
80         static PassRefPtr<Structure> createStructure(JSValuePtr prototype)
81         {
82             return Structure::create(prototype, TypeInfo(ObjectType));
83         }
84
85     protected:
86         virtual void put(ExecState*, const Identifier& propertyName, JSValuePtr, PutPropertySlot&);
87         virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
88         virtual bool deleteProperty(ExecState*, unsigned propertyName);
89         virtual void getPropertyNames(ExecState*, PropertyNameArray&);
90         virtual void mark();
91
92         void* lazyCreationData();
93         void setLazyCreationData(void*);
94
95     private:
96         virtual const ClassInfo* classInfo() const { return &info; }
97
98         bool getOwnPropertySlotSlowCase(ExecState*, unsigned propertyName, PropertySlot&);
99         void putSlowCase(ExecState*, unsigned propertyName, JSValuePtr);
100
101         bool increaseVectorLength(unsigned newLength);
102         
103         unsigned compactForSorting();
104
105         enum ConsistencyCheckType { NormalConsistencyCheck, DestructorConsistencyCheck, SortConsistencyCheck };
106         void checkConsistency(ConsistencyCheckType = NormalConsistencyCheck);
107
108         unsigned m_fastAccessCutoff;
109         ArrayStorage* m_storage;
110     };
111
112     JSArray* asArray(JSValuePtr);
113
114     JSArray* constructEmptyArray(ExecState*);
115     JSArray* constructEmptyArray(ExecState*, unsigned initialLength);
116     JSArray* constructArray(ExecState*, JSValuePtr singleItemValue);
117     JSArray* constructArray(ExecState*, const ArgList& values);
118
119     inline JSArray* asArray(JSValuePtr value)
120     {
121         ASSERT(asObject(value)->inherits(&JSArray::info));
122         return static_cast<JSArray*>(asObject(value));
123     }
124
125 } // namespace JSC
126
127 #endif // JSArray_h