#ifndef KJS_JS_IMMEDIATE_H
#define KJS_JS_IMMEDIATE_H
#include "JSType.h"
#include <wtf/Assertions.h>
#include <stdint.h>
#include <stdlib.h>
namespace KJS {
class ExecState;
class JSObject;
class JSValue;
class UString;
class JSImmediate {
public:
static bool isImmediate(const JSValue *v)
{
return getTag(v) != 0;
}
static bool isNumber(const JSValue *v)
{
return (getTag(v) == NumberType);
}
static bool isBoolean(const JSValue *v)
{
return (getTag(v) == BooleanType);
}
static bool isUndefinedOrNull(const JSValue *v)
{
return (getTag(v) == UndefinedType);
}
static JSValue *fromDouble(double d)
{
if (is32bit()) {
FloatUnion floatUnion;
floatUnion.asFloat = d;
if ((floatUnion.asBits & TagMask) != 0)
return 0;
DoubleUnion doubleUnion1, doubleUnion2;
doubleUnion1.asDouble = floatUnion.asFloat;
doubleUnion2.asDouble = d;
if (doubleUnion1.asBits != doubleUnion2.asBits)
return 0;
return tag(floatUnion.asBits, NumberType);
} else if (is64bit()) {
DoubleUnion doubleUnion;
doubleUnion.asDouble = d;
if ((doubleUnion.asBits & TagMask) != 0)
return 0;
return tag(doubleUnion.asBits, NumberType);
} else {
abort();
return 0;
}
}
static double toDouble(const JSValue *v)
{
ASSERT(isImmediate(v));
if (is32bit()) {
FloatUnion floatUnion;
floatUnion.asBits = unTag(v);
return floatUnion.asFloat;
} else if (is64bit()) {
DoubleUnion doubleUnion;
doubleUnion.asBits = unTag(v);
return doubleUnion.asDouble;
} else {
abort();
return 0;
}
}
static bool toBoolean(const JSValue *v)
{
ASSERT(isImmediate(v));
uintptr_t bits = unTag(v);
if ((bits << 1) == 0) return false;
return bits != NanAsBits();
}
static JSObject *toObject(const JSValue *, ExecState *);
static UString toString(const JSValue *);
static JSType type(const JSValue *);
static JSValue *trueImmediate() { return tag(oneAsBits(), BooleanType); }
static JSValue *falseImmediate() { return tag(zeroAsBits(), BooleanType); }
static JSValue *NaNImmediate() { return tag(NanAsBits(), NumberType); }
static JSValue *undefinedImmediate() { return tag(NanAsBits(), UndefinedType); }
static JSValue *nullImmediate() { return tag(zeroAsBits(), UndefinedType); }
private:
static const uintptr_t TagMask = 3;
static JSValue *tag(uintptr_t bits, uintptr_t tag)
{
return reinterpret_cast<JSValue *>(bits | tag);
}
static uintptr_t unTag(const JSValue *v)
{
return reinterpret_cast<uintptr_t>(v) & ~TagMask;
}
static uintptr_t getTag(const JSValue *v)
{
return reinterpret_cast<uintptr_t>(v) & TagMask;
}
union FloatUnion {
uint32_t asBits;
float asFloat;
};
union DoubleUnion {
uint64_t asBits;
double asDouble;
};
static bool is32bit()
{
return sizeof(float) == sizeof(uint32_t) && sizeof(double) == sizeof(uint64_t) && sizeof(uintptr_t) == sizeof(uint32_t);
}
static bool is64bit()
{
return sizeof(float) == sizeof(uint32_t) && sizeof(double) == sizeof(uint64_t) && sizeof(uintptr_t) == sizeof(uint64_t);
}
static uintptr_t NanAsBits()
{
const uint32_t NaN32AsBits = 0x7fc00000;
const uint64_t NaN64AsBits = 0x7ff80000ULL << 32;
if (JSImmediate::is32bit())
return NaN32AsBits;
else if (JSImmediate::is64bit())
return NaN64AsBits;
else {
abort();
return 0;
}
}
static uintptr_t zeroAsBits()
{
return 0x0;
}
static uintptr_t oneAsBits()
{
const uint32_t One32AsBits = 0x3f800000;
const uint64_t One64AsBits = 0x3ff00000ULL << 32;
if (JSImmediate::is32bit())
return One32AsBits;
else if (JSImmediate::is64bit())
return One64AsBits;
else {
abort();
return 0;
}
}
};
}
#endif