--- /dev/null
+/*
+ * Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
+ * Copyright (C) 2001 Peter Kelly (pmk@post.com)
+ * Copyright (C) 2003, 2004, 2005, 2007, 2008 Apple Inc. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB. If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include <stddef.h> // for size_t
+#include <stdint.h>
+
+#ifndef JSValue_h
+#define JSValue_h
+
+#include "CallData.h"
+#include "ConstructData.h"
+
+namespace JSC {
+
+ class Identifier;
+ class JSCell;
+ class JSObject;
+ class JSString;
+ class PropertySlot;
+ class PutPropertySlot;
+ class UString;
+
+ struct ClassInfo;
+ struct Instruction;
+
+ enum PreferredPrimitiveType { NoPreference, PreferNumber, PreferString };
+
+ class JSImmediate;
+ class JSValueEncodedAsPointer;
+
+ class JSValuePtr {
+ friend class JSImmediate;
+
+ static JSValuePtr makeImmediate(intptr_t value)
+ {
+ return JSValuePtr(reinterpret_cast<JSCell*>(value));
+ }
+
+ intptr_t immediateValue()
+ {
+ return reinterpret_cast<intptr_t>(m_ptr);
+ }
+
+ public:
+ JSValuePtr()
+ : m_ptr(0)
+ {
+ }
+
+ JSValuePtr(JSCell* ptr)
+ : m_ptr(ptr)
+ {
+ }
+
+ JSValuePtr(const JSCell* ptr)
+ : m_ptr(const_cast<JSCell*>(ptr))
+ {
+ }
+
+ operator bool() const
+ {
+ return m_ptr;
+ }
+
+ bool operator==(const JSValuePtr other) const
+ {
+ return m_ptr == other.m_ptr;
+ }
+
+ bool operator!=(const JSValuePtr other) const
+ {
+ return m_ptr != other.m_ptr;
+ }
+
+ static JSValueEncodedAsPointer* encode(JSValuePtr value)
+ {
+ return reinterpret_cast<JSValueEncodedAsPointer*>(value.m_ptr);
+ }
+
+ static JSValuePtr decode(JSValueEncodedAsPointer* ptr)
+ {
+ return JSValuePtr(reinterpret_cast<JSCell*>(ptr));
+ }
+
+ // Querying the type.
+ bool isUndefined() const;
+ bool isNull() const;
+ bool isUndefinedOrNull() const;
+ bool isBoolean() const;
+ bool isNumber() const;
+ bool isString() const;
+ bool isGetterSetter() const;
+ bool isObject() const;
+ bool isObject(const ClassInfo*) const;
+
+ // Extracting the value.
+ bool getBoolean(bool&) const;
+ bool getBoolean() const; // false if not a boolean
+ bool getNumber(double&) const;
+ double uncheckedGetNumber() const;
+ bool getString(UString&) const;
+ UString getString() const; // null string if not a string
+ JSObject* getObject() const; // 0 if not an object
+
+ CallType getCallData(CallData&);
+ ConstructType getConstructData(ConstructData&);
+
+ // Extracting integer values.
+ bool getUInt32(uint32_t&) const;
+ bool getTruncatedInt32(int32_t&) const;
+ bool getTruncatedUInt32(uint32_t&) const;
+
+ // Basic conversions.
+ JSValuePtr toPrimitive(ExecState*, PreferredPrimitiveType = NoPreference) const;
+ bool getPrimitiveNumber(ExecState*, double& number, JSValuePtr&);
+
+ bool toBoolean(ExecState*) const;
+
+ // toNumber conversion is expected to be side effect free if an exception has
+ // been set in the ExecState already.
+ double toNumber(ExecState*) const;
+ JSValuePtr toJSNumber(ExecState*) const; // Fast path for when you expect that the value is an immediate number.
+ UString toString(ExecState*) const;
+ JSObject* toObject(ExecState*) const;
+
+ // Integer conversions.
+ // 'x.numberToInt32(output)' is equivalent to 'x.isNumber() && x.toInt32(output)'
+ double toInteger(ExecState*) const;
+ double toIntegerPreserveNaN(ExecState*) const;
+ int32_t toInt32(ExecState*) const;
+ int32_t toInt32(ExecState*, bool& ok) const;
+ bool numberToInt32(int32_t& arg);
+ uint32_t toUInt32(ExecState*) const;
+ uint32_t toUInt32(ExecState*, bool& ok) const;
+ bool numberToUInt32(uint32_t& arg);
+
+ // Fast integer operations; these values return results where the value is trivially available
+ // in a convenient form, for use in optimizations. No assumptions should be made based on the
+ // results of these operations, for example !isInt32Fast() does not necessarily indicate the
+ // result of getNumber will not be 0.
+ bool isInt32Fast() const;
+ int32_t getInt32Fast() const;
+ bool isUInt32Fast() const;
+ uint32_t getUInt32Fast() const;
+ static JSValuePtr makeInt32Fast(int32_t);
+ static bool areBothInt32Fast(JSValuePtr, JSValuePtr);
+
+ // Floating point conversions (this is a convenience method for webcore;
+ // signle precision float is not a representation used in JS or JSC).
+ float toFloat(ExecState* exec) const { return static_cast<float>(toNumber(exec)); }
+
+ // Garbage collection.
+ void mark();
+ bool marked() const;
+
+ // Object operations, with the toObject operation included.
+ JSValuePtr get(ExecState*, const Identifier& propertyName) const;
+ JSValuePtr get(ExecState*, const Identifier& propertyName, PropertySlot&) const;
+ JSValuePtr get(ExecState*, unsigned propertyName) const;
+ JSValuePtr get(ExecState*, unsigned propertyName, PropertySlot&) const;
+ void put(ExecState*, const Identifier& propertyName, JSValuePtr, PutPropertySlot&);
+ void put(ExecState*, unsigned propertyName, JSValuePtr);
+
+ bool needsThisConversion() const;
+ JSObject* toThisObject(ExecState*) const;
+ UString toThisString(ExecState*) const;
+ JSString* toThisJSString(ExecState*);
+
+ static bool equal(ExecState* exec, JSValuePtr v1, JSValuePtr v2);
+ static bool equalSlowCase(ExecState* exec, JSValuePtr v1, JSValuePtr v2);
+ static bool equalSlowCaseInline(ExecState* exec, JSValuePtr v1, JSValuePtr v2);
+ static bool strictEqual(JSValuePtr v1, JSValuePtr v2);
+ static bool strictEqualSlowCase(JSValuePtr v1, JSValuePtr v2);
+ static bool strictEqualSlowCaseInline(JSValuePtr v1, JSValuePtr v2);
+
+ JSValuePtr getJSNumber(); // noValue() if this is not a JSNumber or number object
+
+ bool isCell() const;
+ JSCell* asCell() const;
+
+ private:
+ inline const JSValuePtr asValue() const { return *this; }
+
+ bool isDoubleNumber() const;
+ double getDoubleNumber() const;
+
+ JSCell* m_ptr;
+ };
+
+ inline JSValuePtr noValue()
+ {
+ return JSValuePtr();
+ }
+
+ inline bool operator==(const JSValuePtr a, const JSCell* b) { return a == JSValuePtr(b); }
+ inline bool operator==(const JSCell* a, const JSValuePtr b) { return JSValuePtr(a) == b; }
+
+ inline bool operator!=(const JSValuePtr a, const JSCell* b) { return a != JSValuePtr(b); }
+ inline bool operator!=(const JSCell* a, const JSValuePtr b) { return JSValuePtr(a) != b; }
+
+} // namespace JSC
+
+#endif // JSValue_h
projects / apple / javascriptcore.git / blobdiff