convert Value::*Value() function to return Maybe results

src/api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 2625 matching lines @@
 
 #define RETURN_TO_LOCAL_UNCHECKED(maybe_local, T) \
   do {                                            \
     Local<T> result;                              \
     bool ignored = maybe_local.ToLocal(&result);  \
     USE(ignored);                                 \
     return result;                                \
   } while (false);
 
 
+#define RETURN_MAYBE_DEFAULT(maybe_value, default_value, T)  \

[Sven Panne, 2015/02/27 12:18:03]

I think this should actually be a member function of Maybe, see
https://hackage.haskell.org/package/base-4.7.0.2/docs/Data-Maybe.html#v:maybe.
But we can do this separately later.

+  do {                                                       \
+    T result;                                                \
+    if (!maybe_value.ToValue(&result)) return default_value; \
+    return result;                                           \
+  } while (false);
+
+
+static Local<Context> ContextFromHeapObject(i::Handle<i::Object> obj) {
+  return reinterpret_cast<v8::Isolate*>(i::HeapObject::cast(*obj)->GetIsolate())
+      ->GetCurrentContext();
+}
+
+
 MaybeLocal<String> Value::ToString(Local<Context> context) const {
   auto obj = Utils::OpenHandle(this);
   if (obj->IsString()) return ToApiHandle<String>(obj);
   CONTEXT_SCOPE_GET_ISOLATE(context, "ToString");
   EXCEPTION_PREAMBLE(isolate);
   Local<String> result;
   has_pending_exception =
       !ToLocal<String>(i::Execution::ToString(isolate, obj), &result);
   EXCEPTION_BAILOUT_CHECK(isolate, result);
   return result;
@@ skipping 326 matching lines @@
 
 
 void v8::RegExp::CheckCast(v8::Value* that) {
   i::Handle<i::Object> obj = Utils::OpenHandle(that);
   Utils::ApiCheck(obj->IsJSRegExp(),
                   "v8::RegExp::Cast()",
                   "Could not convert to regular expression");
 }
 
 
+Maybe<bool> Value::BooleanValue(Local<Context> context) const {
+  return maybe(Utils::OpenHandle(this)->BooleanValue());
+}
+
+
 bool Value::BooleanValue() const {
   return Utils::OpenHandle(this)->BooleanValue();
 }
 
 
+Maybe<double> Value::NumberValue(Local<Context> context) const {
+  auto obj = Utils::OpenHandle(this);
+  if (obj->IsNumber()) return maybe(obj->Number());
+  CONTEXT_SCOPE_GET_ISOLATE(context, "NumberValue");
+  EXCEPTION_PREAMBLE(isolate);
+  i::Handle<i::Object> num;
+  has_pending_exception = !i::Execution::ToNumber(isolate, obj).ToHandle(&num);
+  EXCEPTION_BAILOUT_CHECK(isolate, Maybe<double>());
+  return maybe(num->Number());
+}
+
+
 double Value::NumberValue() const {
-  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  auto obj = Utils::OpenHandle(this);
+  if (obj->IsNumber()) return obj->Number();
+  RETURN_MAYBE_DEFAULT(NumberValue(ContextFromHeapObject(obj)),
+                       std::numeric_limits<double>::quiet_NaN(), double);
+}
+
+
+Maybe<int64_t> Value::IntegerValue(Local<Context> context) const {
+  auto obj = Utils::OpenHandle(this);
   i::Handle<i::Object> num;
   if (obj->IsNumber()) {
     num = obj;
   } else {
-    i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
-    LOG_API(isolate, "NumberValue");
-    ENTER_V8(isolate);
+    CONTEXT_SCOPE_GET_ISOLATE(context, "IntegerValue");
     EXCEPTION_PREAMBLE(isolate);
-    has_pending_exception = !i::Execution::ToNumber(
-        isolate, obj).ToHandle(&num);
-    EXCEPTION_BAILOUT_CHECK(isolate, std::numeric_limits<double>::quiet_NaN());
+    has_pending_exception =
+        !i::Execution::ToInteger(isolate, obj).ToHandle(&num);
+    EXCEPTION_BAILOUT_CHECK(isolate, Maybe<int64_t>());
   }
-  return num->Number();
+  if (num->IsSmi()) {
+    return maybe(static_cast<int64_t>(i::Smi::cast(*num)->value()));
+  } else {
+    return maybe(static_cast<int64_t>(num->Number()));
+  }
 }
 
 
 int64_t Value::IntegerValue() const {
-  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  auto obj = Utils::OpenHandle(this);
+  if (obj->IsNumber()) {
+    if (obj->IsSmi()) {
+      return i::Smi::cast(*obj)->value();
+    } else {
+      return static_cast<int64_t>(obj->Number());
+    }
+  }
+  RETURN_MAYBE_DEFAULT(IntegerValue(ContextFromHeapObject(obj)), 0, int64_t);
+}
+
+
+Maybe<int32_t> Value::Int32Value(Local<Context> context) const {
+  auto obj = Utils::OpenHandle(this);
+  if (obj->IsNumber()) return maybe(NumberToInt32(*obj));
+  CONTEXT_SCOPE_GET_ISOLATE(context, "Int32Value");
+  EXCEPTION_PREAMBLE(isolate);
   i::Handle<i::Object> num;
-  if (obj->IsNumber()) {
-    num = obj;
+  has_pending_exception = !i::Execution::ToInt32(isolate, obj).ToHandle(&num);
+  EXCEPTION_BAILOUT_CHECK(isolate, Maybe<int32_t>());
+  if (num->IsSmi()) {
+    return maybe(i::Smi::cast(*num)->value());
   } else {
-    i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
-    LOG_API(isolate, "IntegerValue");
-    ENTER_V8(isolate);
-    EXCEPTION_PREAMBLE(isolate);
-    has_pending_exception = !i::Execution::ToInteger(
-        isolate, obj).ToHandle(&num);
-    EXCEPTION_BAILOUT_CHECK(isolate, 0);
+    return maybe(static_cast<int32_t>(num->Number()));
   }
+}
+
+
+int32_t Value::Int32Value() const {
+  auto obj = Utils::OpenHandle(this);
+  if (obj->IsNumber()) return NumberToInt32(*obj);
+  RETURN_MAYBE_DEFAULT(Int32Value(ContextFromHeapObject(obj)), 0, int32_t);
+}
+
+
+Maybe<uint32_t> Value::Uint32Value(Local<Context> context) const {
+  auto obj = Utils::OpenHandle(this);
+  if (obj->IsNumber()) return maybe(NumberToUint32(*obj));
+  CONTEXT_SCOPE_GET_ISOLATE(context, "Uint32Value");
+  EXCEPTION_PREAMBLE(isolate);
+  i::Handle<i::Object> num;
+  has_pending_exception = !i::Execution::ToUint32(isolate, obj).ToHandle(&num);
+  EXCEPTION_BAILOUT_CHECK(isolate, Maybe<uint32_t>());
   if (num->IsSmi()) {
-    return i::Smi::cast(*num)->value();
+    return maybe(static_cast<uint32_t>(i::Smi::cast(*num)->value()));
   } else {
-    return static_cast<int64_t>(num->Number());
+    return maybe(static_cast<uint32_t>(num->Number()));
   }
 }
 
 
+uint32_t Value::Uint32Value() const {
+  auto obj = Utils::OpenHandle(this);
+  if (obj->IsNumber()) return NumberToUint32(*obj);
+  RETURN_MAYBE_DEFAULT(Uint32Value(ContextFromHeapObject(obj)), 0, uint32_t);
+}
+
+
 Local<Uint32> Value::ToArrayIndex() const {
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   if (obj->IsSmi()) {
     if (i::Smi::cast(*obj)->value() >= 0) return Utils::Uint32ToLocal(obj);
     return Local<Uint32>();
   }
   i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
   LOG_API(isolate, "ToArrayIndex");
   ENTER_V8(isolate);
   EXCEPTION_PREAMBLE(isolate);
   i::Handle<i::Object> string_obj;
   has_pending_exception = !i::Execution::ToString(
       isolate, obj).ToHandle(&string_obj);
   EXCEPTION_BAILOUT_CHECK(isolate, Local<Uint32>());
   i::Handle<i::String> str = i::Handle<i::String>::cast(string_obj);
   uint32_t index;
   if (str->AsArrayIndex(&index)) {
     i::Handle<i::Object> value;
     if (index <= static_cast<uint32_t>(i::Smi::kMaxValue)) {
       value = i::Handle<i::Object>(i::Smi::FromInt(index), isolate);
     } else {
       value = isolate->factory()->NewNumber(index);
     }
     return Utils::Uint32ToLocal(value);
   }
   return Local<Uint32>();
 }
 
 
-int32_t Value::Int32Value() const {
-  i::Handle<i::Object> obj = Utils::OpenHandle(this);
-  if (obj->IsNumber()) {
-    return NumberToInt32(*obj);
-  } else {
-    i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
-    LOG_API(isolate, "Int32Value (slow)");
-    ENTER_V8(isolate);
-    EXCEPTION_PREAMBLE(isolate);
-    i::Handle<i::Object> num;
-    has_pending_exception = !i::Execution::ToInt32(isolate, obj).ToHandle(&num);
-    EXCEPTION_BAILOUT_CHECK(isolate, 0);
-    if (num->IsSmi()) {
-      return i::Smi::cast(*num)->value();
-    } else {
-      return static_cast<int32_t>(num->Number());
-    }
-  }
-}
-
-
 bool Value::Equals(Handle<Value> that) const {
   i::Handle<i::Object> obj = Utils::OpenHandle(this, true);
   i::Handle<i::Object> other = Utils::OpenHandle(*that);
   if (obj->IsSmi() && other->IsSmi()) {
     return obj->Number() == other->Number();
   }
   i::Object* ho = obj->IsSmi() ? *other : *obj;
   i::Isolate* isolate = i::HeapObject::cast(ho)->GetIsolate();
   if (!Utils::ApiCheck(!obj.is_null() && !that.IsEmpty(),
                        "v8::Value::Equals()",
@@ skipping 60 matching lines @@
   if (!Utils::ApiCheck(!obj.is_null() && !that.IsEmpty(),
                        "v8::Value::SameValue()",
                        "Reading from empty handle")) {
     return false;
   }
   i::Handle<i::Object> other = Utils::OpenHandle(*that);
   return obj->SameValue(*other);
 }
 
 
-uint32_t Value::Uint32Value() const {
-  i::Handle<i::Object> obj = Utils::OpenHandle(this);
-  if (obj->IsNumber()) {
-    return NumberToUint32(*obj);
-  } else {
-    i::Isolate* isolate = i::HeapObject::cast(*obj)->GetIsolate();
-    LOG_API(isolate, "Uint32Value");
-    ENTER_V8(isolate);
-    EXCEPTION_PREAMBLE(isolate);
-    i::Handle<i::Object> num;
-    has_pending_exception = !i::Execution::ToUint32(
-        isolate, obj).ToHandle(&num);
-    EXCEPTION_BAILOUT_CHECK(isolate, 0);
-    if (num->IsSmi()) {
-      return i::Smi::cast(*num)->value();
-    } else {
-      return static_cast<uint32_t>(num->Number());
-    }
-  }
-}
-
-
 bool v8::Object::Set(v8::Handle<Value> key, v8::Handle<Value> value) {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   ON_BAILOUT(isolate, "v8::Object::Set()", return false);
   ENTER_V8(isolate);
   i::HandleScope scope(isolate);
   i::Handle<i::Object> self = Utils::OpenHandle(this);
   i::Handle<i::Object> key_obj = Utils::OpenHandle(*key);
   i::Handle<i::Object> value_obj = Utils::OpenHandle(*value);
   EXCEPTION_PREAMBLE(isolate);
   has_pending_exception =
@@ skipping 4646 matching lines @@
   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 } }  // namespace v8::internal