1/****************************************************************************
2**
3** Copyright (C) 2016 The Qt Company Ltd.
4** Contact: https://www.qt.io/licensing/
5**
6** This file is part of the QtQml module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial License Usage
10** Licensees holding valid commercial Qt licenses may use this file in
11** accordance with the commercial license agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and The Qt Company. For licensing terms
14** and conditions see https://www.qt.io/terms-conditions. For further
15** information use the contact form at https://www.qt.io/contact-us.
16**
17** GNU Lesser General Public License Usage
18** Alternatively, this file may be used under the terms of the GNU Lesser
19** General Public License version 3 as published by the Free Software
20** Foundation and appearing in the file LICENSE.LGPL3 included in the
21** packaging of this file. Please review the following information to
22** ensure the GNU Lesser General Public License version 3 requirements
23** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24**
25** GNU General Public License Usage
26** Alternatively, this file may be used under the terms of the GNU
27** General Public License version 2.0 or (at your option) the GNU General
28** Public license version 3 or any later version approved by the KDE Free
29** Qt Foundation. The licenses are as published by the Free Software
30** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31** included in the packaging of this file. Please review the following
32** information to ensure the GNU General Public License requirements will
33** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34** https://www.gnu.org/licenses/gpl-3.0.html.
35**
36** $QT_END_LICENSE$
37**
38****************************************************************************/
39
40#ifndef QV4GLOBAL_H
41#define QV4GLOBAL_H
42
43//
44// W A R N I N G
45// -------------
46//
47// This file is not part of the Qt API. It exists purely as an
48// implementation detail. This header file may change from version to
49// version without notice, or even be removed.
50//
51// We mean it.
52//
53
54#include <QtCore/qglobal.h>
55#include <private/qv4compilerglobal_p.h>
56#include <QString>
57
58#ifdef QT_NO_DEBUG
59#define QML_NEARLY_ALWAYS_INLINE Q_ALWAYS_INLINE
60#else
61#define QML_NEARLY_ALWAYS_INLINE inline
62#endif
63
64#include <qtqmlglobal.h>
65#include <private/qtqmlglobal_p.h>
66
67#if defined(Q_CC_MSVC)
68#include <float.h>
69#include <math.h>
70
71namespace std {
72
73inline bool isinf(double d) { return !_finite(d) && !_isnan(d); }
74inline bool isnan(double d) { return !!_isnan(d); }
75inline bool isfinite(double d) { return _finite(d); }
76
77} // namespace std
78
79inline double trunc(double d) { return d > 0 ? floor(d) : ceil(d); }
80#endif
81
82// Do certain things depending on whether the JIT is enabled or disabled
83
84#if QT_CONFIG(qml_jit)
85#define ENABLE_YARR_JIT 1
86#define ENABLE_JIT 1
87#define ENABLE_ASSEMBLER 1
88#else
89#define ENABLE_YARR_JIT 0
90#define ENABLE_ASSEMBLER 0
91#define ENABLE_JIT 0
92#endif
93
94#if defined(Q_OS_QNX) && defined(_CPPLIB_VER)
95#include <math.h>
96#undef isnan
97#undef isfinite
98#undef isinf
99#undef signbit
100#endif
101
102QT_BEGIN_NAMESPACE
103
104namespace QV4 {
105
106namespace Compiler {
107 struct Module;
108 struct Context;
109 struct JSUnitGenerator;
110 class Codegen;
111}
112
113namespace Moth {
114 class BytecodeGenerator;
115}
116
117namespace Heap {
118 struct Base;
119 struct MemberData;
120 struct ArrayData;
121
122 struct StringOrSymbol;
123 struct String;
124 struct Symbol;
125 struct Object;
126 struct ObjectPrototype;
127
128 struct ExecutionContext;
129 struct CallContext;
130 struct QmlContext;
131 struct ScriptFunction;
132 struct InternalClass;
133
134 struct BooleanObject;
135 struct NumberObject;
136 struct StringObject;
137 struct ArrayObject;
138 struct DateObject;
139 struct FunctionObject;
140 struct ErrorObject;
141 struct ArgumentsObject;
142 struct QObjectWrapper;
143 struct RegExpObject;
144 struct RegExp;
145 struct EvalFunction;
146
147 struct SharedArrayBuffer;
148 struct ArrayBuffer;
149 struct DataView;
150 struct TypedArray;
151
152 struct MapObject;
153 struct SetObject;
154
155 struct PromiseObject;
156 struct PromiseCapability;
157
158 template <typename T, size_t> struct Pointer;
159}
160
161struct CppStackFrame;
162class MemoryManager;
163class ExecutableAllocator;
164struct PropertyKey;
165struct StringOrSymbol;
166struct String;
167struct Symbol;
168struct Object;
169struct ObjectPrototype;
170struct ObjectIterator;
171struct ExecutionContext;
172struct CallContext;
173struct QmlContext;
174struct ScriptFunction;
175struct InternalClass;
176struct Property;
177struct Value;
178template<size_t> struct HeapValue;
179template<size_t> struct ValueArray;
180struct Lookup;
181struct ArrayData;
182struct VTable;
183struct Function;
184
185struct BooleanObject;
186struct NumberObject;
187struct StringObject;
188struct ArrayObject;
189struct DateObject;
190struct FunctionObject;
191struct ErrorObject;
192struct ArgumentsObject;
193struct Managed;
194struct ExecutionEngine;
195struct QObjectWrapper;
196struct RegExpObject;
197struct RegExp;
198struct EvalFunction;
199
200struct SharedArrayBuffer;
201struct ArrayBuffer;
202struct DataView;
203struct TypedArray;
204
205struct MapObject;
206struct SetMapObject;
207
208struct PromiseObject;
209struct PromiseCapability;
210
211struct CallData;
212struct Scope;
213struct ScopedValue;
214template<typename T> struct Scoped;
215typedef Scoped<String> ScopedString;
216typedef Scoped<StringOrSymbol> ScopedStringOrSymbol;
217typedef Scoped<Object> ScopedObject;
218typedef Scoped<ArrayObject> ScopedArrayObject;
219typedef Scoped<FunctionObject> ScopedFunctionObject;
220typedef Scoped<ExecutionContext> ScopedContext;
221
222struct PersistentValueStorage;
223class PersistentValue;
224class WeakValue;
225struct MarkStack;
226
227struct IdentifierTable;
228class RegExpCache;
229class MultiplyWrappedQObjectMap;
230
231enum PropertyFlag {
232 Attr_Data = 0,
233 Attr_Accessor = 0x1,
234 Attr_NotWritable = 0x2,
235 Attr_NotEnumerable = 0x4,
236 Attr_NotConfigurable = 0x8,
237 Attr_ReadOnly = Attr_NotWritable|Attr_NotEnumerable|Attr_NotConfigurable,
238 Attr_ReadOnly_ButConfigurable = Attr_NotWritable|Attr_NotEnumerable,
239 Attr_Invalid = 0xff
240};
241
242Q_DECLARE_FLAGS(PropertyFlags, PropertyFlag)
243Q_DECLARE_OPERATORS_FOR_FLAGS(PropertyFlags)
244
245struct PropertyAttributes
246{
247 union {
248 uchar m_all;
249 struct {
250 uchar m_flags : 4;
251 uchar m_mask : 4;
252 };
253 struct {
254 uchar m_type : 1;
255 uchar m_writable : 1;
256 uchar m_enumerable : 1;
257 uchar m_configurable : 1;
258 uchar type_set : 1;
259 uchar writable_set : 1;
260 uchar enumerable_set : 1;
261 uchar configurable_set : 1;
262 };
263 };
264
265 enum Type {
266 Data = 0,
267 Accessor = 1,
268 Generic = 2
269 };
270
271 PropertyAttributes() : m_all(0) {}
272 PropertyAttributes(PropertyFlag f) : m_all(0) {
273 if (f != Attr_Invalid) {
274 setType(f & Attr_Accessor ? Accessor : Data);
275 if (!(f & Attr_Accessor))
276 setWritable(!(f & Attr_NotWritable));
277 setEnumerable(!(f & Attr_NotEnumerable));
278 setConfigurable(!(f & Attr_NotConfigurable));
279 }
280 }
281 PropertyAttributes(PropertyFlags f) : m_all(0) {
282 if (f != Attr_Invalid) {
283 setType(f & Attr_Accessor ? Accessor : Data);
284 if (!(f & Attr_Accessor))
285 setWritable(!(f & Attr_NotWritable));
286 setEnumerable(!(f & Attr_NotEnumerable));
287 setConfigurable(!(f & Attr_NotConfigurable));
288 }
289 }
290
291 void setType(Type t) { m_type = t; type_set = true; }
292 Type type() const { return type_set ? (Type)m_type : Generic; }
293
294 bool isData() const { return type() == PropertyAttributes::Data || writable_set; }
295 bool isAccessor() const { return type() == PropertyAttributes::Accessor; }
296 bool isGeneric() const { return type() == PropertyAttributes::Generic && !writable_set; }
297
298 bool hasType() const { return type_set; }
299 bool hasWritable() const { return writable_set; }
300 bool hasConfigurable() const { return configurable_set; }
301 bool hasEnumerable() const { return enumerable_set; }
302
303 void setWritable(bool b) { m_writable = b; writable_set = true; }
304 void setConfigurable(bool b) { m_configurable = b; configurable_set = true; }
305 void setEnumerable(bool b) { m_enumerable = b; enumerable_set = true; }
306
307 void resolve() { m_mask = 0xf; if (m_type == Accessor) { m_writable = false; writable_set = false; } }
308
309 bool isWritable() const { return m_type != Data || m_writable; }
310 bool isEnumerable() const { return m_enumerable; }
311 bool isConfigurable() const { return m_configurable; }
312
313 void clearType() { m_type = Data; type_set = false; }
314 void clearWritable() { m_writable = false; writable_set = false; }
315 void clearEnumerable() { m_enumerable = false; enumerable_set = false; }
316 void clearConfigurable() { m_configurable = false; configurable_set = false; }
317
318 void clear() { m_all = 0; }
319 bool isEmpty() const { return !m_all; }
320
321 uint flags() const { return m_flags; }
322 uint all() const { return m_all; }
323
324 bool operator==(PropertyAttributes other) {
325 return m_all == other.m_all;
326 }
327 bool operator!=(PropertyAttributes other) {
328 return m_all != other.m_all;
329 }
330};
331
332struct Q_QML_EXPORT StackFrame {
333 QString source;
334 QString function;
335 int line = -1;
336 int column = -1;
337};
338typedef QVector<StackFrame> StackTrace;
339
340namespace JIT {
341
342enum class CallResultDestination {
343 Ignore,
344 InAccumulator,
345};
346
347} // JIT namespace
348
349} // QV4 namespace
350
351Q_DECLARE_TYPEINFO(QV4::PropertyAttributes, Q_PRIMITIVE_TYPE);
352
353QT_END_NAMESPACE
354
355#endif // QV4GLOBAL_H
356