#include "src/base/platform/platform.h"
#include "src/conversions.h"
#include "src/double.h"
+#include "src/objects-inl.h"
#include "src/scanner.h"
#include "src/strtod.h"
}
+bool IsSmiDouble(double value) {
+ return !IsMinusZero(value) && value >= Smi::kMinValue &&
+ value <= Smi::kMaxValue && value == FastI2D(FastD2I(value));
+}
+
+
+bool IsInt32Double(double value) {
+ return !IsMinusZero(value) && value >= kMinInt && value <= kMaxInt &&
+ value == FastI2D(FastD2I(value));
+}
+
+
+bool IsUint32Double(double value) {
+ return !IsMinusZero(value) && value >= 0 && value <= kMaxUInt32 &&
+ value == FastUI2D(FastD2UI(value));
+}
+
+
+int32_t NumberToInt32(Object* number) {
+ if (number->IsSmi()) return Smi::cast(number)->value();
+ return DoubleToInt32(number->Number());
+}
+
+
+uint32_t NumberToUint32(Object* number) {
+ if (number->IsSmi()) return Smi::cast(number)->value();
+ return DoubleToUint32(number->Number());
+}
+
+
+bool TryNumberToSize(Isolate* isolate, Object* number, size_t* result) {
+ SealHandleScope shs(isolate);
+ if (number->IsSmi()) {
+ int value = Smi::cast(number)->value();
+ DCHECK(static_cast<unsigned>(Smi::kMaxValue) <=
+ std::numeric_limits<size_t>::max());
+ if (value >= 0) {
+ *result = static_cast<size_t>(value);
+ return true;
+ }
+ return false;
+ } else {
+ DCHECK(number->IsHeapNumber());
+ double value = HeapNumber::cast(number)->value();
+ if (value >= 0 && value <= std::numeric_limits<size_t>::max()) {
+ *result = static_cast<size_t>(value);
+ return true;
+ } else {
+ return false;
+ }
+ }
+}
+
+
+size_t NumberToSize(Isolate* isolate, Object* number) {
+ size_t result = 0;
+ bool is_valid = TryNumberToSize(isolate, number, &result);
+ CHECK(is_valid);
+ return result;
+}
+
+
template <class Iterator, class EndMark>
bool SubStringEquals(Iterator* current,
EndMark end,
#include "src/base/logging.h"
#include "src/handles.h"
-#include "src/objects.h"
#include "src/utils.h"
namespace v8 {
}
-static inline bool IsSmiDouble(double value) {
- return !IsMinusZero(value) && value >= Smi::kMinValue &&
- value <= Smi::kMaxValue && value == FastI2D(FastD2I(value));
-}
+static inline bool IsSmiDouble(double value);
// Integer32 is an integer that can be represented as a signed 32-bit
// integer. It has to be in the range [-2^31, 2^31 - 1].
// We also have to check for negative 0 as it is not an Integer32.
-static inline bool IsInt32Double(double value) {
- return !IsMinusZero(value) &&
- value >= kMinInt &&
- value <= kMaxInt &&
- value == FastI2D(FastD2I(value));
-}
+static inline bool IsInt32Double(double value);
// UInteger32 is an integer that can be represented as an unsigned 32-bit
// integer. It has to be in the range [0, 2^32 - 1].
// We also have to check for negative 0 as it is not a UInteger32.
-static inline bool IsUint32Double(double value) {
- return !IsMinusZero(value) &&
- value >= 0 &&
- value <= kMaxUInt32 &&
- value == FastUI2D(FastD2UI(value));
-}
+static inline bool IsUint32Double(double value);
// Convert from Number object to C integer.
-inline int32_t NumberToInt32(Object* number) {
- if (number->IsSmi()) return Smi::cast(number)->value();
- return DoubleToInt32(number->Number());
-}
-
-
-inline uint32_t NumberToUint32(Object* number) {
- if (number->IsSmi()) return Smi::cast(number)->value();
- return DoubleToUint32(number->Number());
-}
+inline int32_t NumberToInt32(Object* number);
+inline uint32_t NumberToUint32(Object* number);
double StringToDouble(UnicodeCache* unicode_cache, Handle<String> string,
int flags, double empty_string_val = 0.0);
-inline bool TryNumberToSize(Isolate* isolate,
- Object* number, size_t* result) {
- SealHandleScope shs(isolate);
- if (number->IsSmi()) {
- int value = Smi::cast(number)->value();
- DCHECK(static_cast<unsigned>(Smi::kMaxValue)
- <= std::numeric_limits<size_t>::max());
- if (value >= 0) {
- *result = static_cast<size_t>(value);
- return true;
- }
- return false;
- } else {
- DCHECK(number->IsHeapNumber());
- double value = HeapNumber::cast(number)->value();
- if (value >= 0 &&
- value <= std::numeric_limits<size_t>::max()) {
- *result = static_cast<size_t>(value);
- return true;
- } else {
- return false;
- }
- }
-}
+inline bool TryNumberToSize(Isolate* isolate, Object* number, size_t* result);
+
// Converts a number into size_t.
-inline size_t NumberToSize(Isolate* isolate,
- Object* number) {
- size_t result = 0;
- bool is_valid = TryNumberToSize(isolate, number, &result);
- CHECK(is_valid);
- return result;
-}
+inline size_t NumberToSize(Isolate* isolate, Object* number);
// returns DoubleToString(StringToDouble(string)) == string
bool IsSpecialIndex(UnicodeCache* unicode_cache, String* string);
-} } // namespace v8::internal
+
+} // namespace internal
+} // namespace v8
#endif // V8_CONVERSIONS_H_
}
+LayoutDescriptor* LayoutDescriptor::SetRawData(int field_index) {
+ return SetTagged(field_index, false);
+}
+
+
LayoutDescriptor* LayoutDescriptor::SetTagged(int field_index, bool tagged) {
int layout_word_index;
int layout_bit_index;
V8_INLINE bool GetIndexes(int field_index, int* layout_word_index,
int* layout_bit_index);
- V8_INLINE MUST_USE_RESULT LayoutDescriptor* SetRawData(int field_index) {
- return SetTagged(field_index, false);
- }
+ V8_INLINE MUST_USE_RESULT LayoutDescriptor* SetRawData(int field_index);
V8_INLINE MUST_USE_RESULT LayoutDescriptor* SetTagged(int field_index,
bool tagged);
// static
template<class T>
-T* ZoneTypeConfig::null_handle() {
- return NULL;
-}
-
-
-// static
-template<class T>
T* ZoneTypeConfig::handle(T* type) {
return type;
}
// static
template<class T>
-i::Handle<T> HeapTypeConfig::null_handle() {
- return i::Handle<T>();
-}
-
-
-// static
-template<class T>
i::Handle<T> HeapTypeConfig::handle(T* type) {
return i::handle(type, i::HeapObject::cast(type)->GetIsolate());
}
#define V8_TYPES_H_
#include "src/conversions.h"
-#include "src/factory.h"
#include "src/handles.h"
+#include "src/objects.h"
#include "src/ostreams.h"
namespace v8 {
static const int kRangeStructTag = 0x1000;
- template<class T> static inline T* null_handle();
+ template<class T> static inline T* null_handle() { return nullptr; }
template<class T> static inline T* handle(T* type);
template<class T> static inline T* cast(Type* type);
static const int kRangeStructTag = 0xffff;
- template<class T> static inline i::Handle<T> null_handle();
+ template<class T> static inline i::Handle<T> null_handle() {
+ return i::Handle<T>();
+ }
template<class T> static inline i::Handle<T> handle(T* type);
template<class T> static inline i::Handle<T> cast(i::Handle<Type> type);