1/*
2 * Copyright (C) 1999-2001 Harri Porten ([email protected])
3 * Copyright (C) 2003, 2007, 2008, 2009 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 Library 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 * Library General Public License for more details.
14 *
15 * You should have received a copy of the GNU Library General Public License
16 * along with this library; see the file COPYING.LIB. If not, write to
17 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18 * Boston, MA 02110-1301, USA.
19 *
20 */
21
22#ifndef ArgList_h
23#define ArgList_h
24
25#include "Register.h"
26#include <wtf/HashSet.h>
27#include <wtf/Noncopyable.h>
28#include <wtf/Vector.h>
29
30namespace JSC {
31
32 class MarkStack;
33
34 class MarkedArgumentBuffer : public Noncopyable {
35 private:
36 static const unsigned inlineCapacity = 8;
37 typedef Vector<Register, inlineCapacity> VectorType;
38 typedef HashSet<MarkedArgumentBuffer*> ListSet;
39
40 public:
41 typedef VectorType::iterator iterator;
42 typedef VectorType::const_iterator const_iterator;
43
44 // Constructor for a read-write list, to which you may append values.
45 // FIXME: Remove all clients of this API, then remove this API.
46 MarkedArgumentBuffer()
47 : m_isUsingInlineBuffer(true)
48 , m_markSet(0)
49#ifndef NDEBUG
50 , m_isReadOnly(false)
51#endif
52 {
53 m_buffer = m_vector.data();
54 m_size = 0;
55 }
56
57 // Constructor for a read-only list whose data has already been allocated elsewhere.
58 MarkedArgumentBuffer(Register* buffer, size_t size)
59 : m_buffer(buffer)
60 , m_size(size)
61 , m_isUsingInlineBuffer(true)
62 , m_markSet(0)
63#ifndef NDEBUG
64 , m_isReadOnly(true)
65#endif
66 {
67 }
68
69 void initialize(Register* buffer, size_t size)
70 {
71 ASSERT(!m_markSet);
72 ASSERT(isEmpty());
73
74 m_buffer = buffer;
75 m_size = size;
76#ifndef NDEBUG
77 m_isReadOnly = true;
78#endif
79 }
80
81 ~MarkedArgumentBuffer()
82 {
83 if (m_markSet)
84 m_markSet->remove(value: this);
85 }
86
87 size_t size() const { return m_size; }
88 bool isEmpty() const { return !m_size; }
89
90 JSValue at(size_t i) const
91 {
92 if (i < m_size)
93 return m_buffer[i].jsValue();
94 return jsUndefined();
95 }
96
97 void clear()
98 {
99 m_vector.clear();
100 m_buffer = 0;
101 m_size = 0;
102 }
103
104 void append(JSValue v)
105 {
106 ASSERT(!m_isReadOnly);
107
108#if ENABLE(JSC_ZOMBIES)
109 ASSERT(!v.isZombie());
110#endif
111
112 if (m_isUsingInlineBuffer && m_size < inlineCapacity) {
113 m_vector.uncheckedAppend(val: v);
114 ++m_size;
115 } else {
116 // Putting this case all in one function measurably improves
117 // the performance of the fast "just append to inline buffer" case.
118 slowAppend(v);
119 ++m_size;
120 m_isUsingInlineBuffer = false;
121 }
122 }
123
124 void removeLast()
125 {
126 ASSERT(m_size);
127 m_size--;
128 m_vector.removeLast();
129 }
130
131 JSValue last()
132 {
133 ASSERT(m_size);
134 return m_buffer[m_size - 1].jsValue();
135 }
136
137 iterator begin() { return m_buffer; }
138 iterator end() { return m_buffer + m_size; }
139
140 const_iterator begin() const { return m_buffer; }
141 const_iterator end() const { return m_buffer + m_size; }
142
143 static void markLists(MarkStack&, ListSet&);
144
145 private:
146 void slowAppend(JSValue);
147
148 Register* m_buffer;
149 size_t m_size;
150 bool m_isUsingInlineBuffer;
151
152 VectorType m_vector;
153 ListSet* m_markSet;
154#ifndef NDEBUG
155 bool m_isReadOnly;
156#endif
157
158 private:
159 // Prohibits new / delete, which would break GC.
160 friend class JSGlobalData;
161
162 void* operator new(size_t size)
163 {
164 return fastMalloc(size);
165 }
166 void operator delete(void* p)
167 {
168 fastFree(p);
169 }
170
171 void* operator new[](size_t);
172 void operator delete[](void*);
173
174 void* operator new(size_t, void*);
175 void operator delete(void*, size_t);
176 };
177
178 class ArgList {
179 friend class JIT;
180 public:
181 typedef JSValue* iterator;
182 typedef const JSValue* const_iterator;
183
184 ArgList()
185 : m_args(0)
186 , m_argCount(0)
187 {
188 }
189
190 ArgList(JSValue* args, unsigned argCount)
191 : m_args(args)
192 , m_argCount(argCount)
193 {
194#if ENABLE(JSC_ZOMBIES)
195 for (size_t i = 0; i < argCount; i++)
196 ASSERT(!m_args[i].isZombie());
197#endif
198 }
199
200 ArgList(Register* args, int argCount)
201 : m_args(reinterpret_cast<JSValue*>(args))
202 , m_argCount(argCount)
203 {
204 ASSERT(argCount >= 0);
205 }
206
207 ArgList(const MarkedArgumentBuffer& args)
208 : m_args(reinterpret_cast<JSValue*>(const_cast<Register*>(args.begin())))
209 , m_argCount(args.size())
210 {
211 }
212
213 JSValue at(size_t idx) const
214 {
215 if (idx < m_argCount)
216 return m_args[idx];
217 return jsUndefined();
218 }
219
220 bool isEmpty() const { return !m_argCount; }
221
222 size_t size() const { return m_argCount; }
223
224 iterator begin() { return m_args; }
225 iterator end() { return m_args + m_argCount; }
226
227 const_iterator begin() const { return m_args; }
228 const_iterator end() const { return m_args + m_argCount; }
229
230 void getSlice(int startIndex, ArgList& result) const;
231 private:
232 JSValue* m_args;
233 size_t m_argCount;
234 };
235
236} // namespace JSC
237
238#endif // ArgList_h
239

source code of qtscript/src/3rdparty/javascriptcore/JavaScriptCore/runtime/ArgList.h