Add StackOverflowError and expose error type to api.

src/api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2444 matching lines @@
 }
 
 
 bool Value::IsNumberObject() const {
   i::Isolate* isolate = i::Isolate::Current();
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   return obj->HasSpecificClassOf(isolate->heap()->Number_string());
 }
 
 
-static i::Object* LookupBuiltin(i::Isolate* isolate,
-                                const char* builtin_name) {
-  i::Handle<i::String> string =
-      isolate->factory()->InternalizeUtf8String(builtin_name);
-  i::Handle<i::JSBuiltinsObject> builtins = isolate->js_builtins_object();
-  return builtins->GetPropertyNoExceptionThrown(*string);
-}
-
-
-static bool CheckConstructor(i::Isolate* isolate,
-                             i::Handle<i::JSObject> obj,
-                             const char* class_name) {
-  i::Object* constr = obj->map()->constructor();
-  if (!constr->IsJSFunction()) return false;
-  i::JSFunction* func = i::JSFunction::cast(constr);
-  return func->shared()->native() &&
-      constr == LookupBuiltin(isolate, class_name);
-}
-
-
 bool Value::IsNativeError() const {
-  i::Isolate* isolate = i::Isolate::Current();
-  i::Handle<i::Object> obj = Utils::OpenHandle(this);
-  if (obj->IsJSObject()) {
-    i::Handle<i::JSObject> js_obj(i::JSObject::cast(*obj));
-    return CheckConstructor(isolate, js_obj, "$Error") ||
-        CheckConstructor(isolate, js_obj, "$EvalError") ||
-        CheckConstructor(isolate, js_obj, "$RangeError") ||
-        CheckConstructor(isolate, js_obj, "$ReferenceError") ||
-        CheckConstructor(isolate, js_obj, "$SyntaxError") ||
-        CheckConstructor(isolate, js_obj, "$TypeError") ||
-        CheckConstructor(isolate, js_obj, "$URIError");
-  } else {
-    return false;
-  }
+  Local<Value> handle = Utils::ToLocal(Utils::OpenHandle(this));
+  return Exception::NativeErrorType(handle) != Exception::kNoError;
 }
 
 
 bool Value::IsBooleanObject() const {
   i::Isolate* isolate = i::Isolate::Current();
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   return obj->HasSpecificClassOf(isolate->heap()->Boolean_string());
 }
 
 
@@ skipping 3945 matching lines @@
   str_ = i::NewArray<uint16_t>(length_ + 1);
   str->Write(str_);
 }
 
 
 String::Value::~Value() {
   i::DeleteArray(str_);
 }
 
 
-Local<Value> Exception::RangeError(v8::Handle<v8::String> raw_message) {
+Exception::ErrorType Exception::NativeErrorType(Local<Value> value) {
+  i::Handle<i::Object> exception = Utils::OpenHandle(*value);
+  if (!exception->IsJSObject()) return kNoError;
+  i::Handle<i::JSObject> js_obj = i::Handle<i::JSObject>::cast(exception);
+  i::Isolate* isolate = js_obj->GetIsolate();
+  i::LookupResult lookup(isolate);
+  js_obj->LocalLookup(isolate->heap()->error_type(), &lookup, false);
+  if (!lookup.IsFound()) return kNoError;
+  i::Object* val = lookup.GetLazyValue();
+  if (!val->IsSmi() || val == isolate->heap()->the_hole_value()) {
+    return kNoError;
+  }
+  return static_cast<Exception::ErrorType>(i::Smi::cast(val)->value());
+}
+
+
+static Local<Value> NewError(Exception::ErrorType error_type,
+                             v8::Handle<v8::String> raw_message) {
   i::Isolate* isolate = i::Isolate::Current();
-  LOG_API(isolate, "RangeError");
-  ON_BAILOUT(isolate, "v8::Exception::RangeError()", return Local<Value>());
+  LOG_API(isolate, "NewError");
+  ON_BAILOUT(isolate, "v8::Exception::NewError()", return Local<Value>());
   ENTER_V8(isolate);
   i::Object* error;
   {
     i::HandleScope scope(isolate);
     i::Handle<i::String> message = Utils::OpenHandle(*raw_message);
-    i::Handle<i::Object> result = isolate->factory()->NewRangeError(message);
+    i::Handle<i::Object> result;
+    switch (error_type) {
+      case Exception::kError:
+        result = isolate->factory()->NewError(message);
+        break;
+      case Exception::kTypeError:
+        result = isolate->factory()->NewTypeError(message);
+        break;
+      case Exception::kRangeError:
+        result = isolate->factory()->NewRangeError(message);
+        break;
+      case Exception::kSyntaxError:
+         result = isolate->factory()->NewSyntaxError(message);
+         break;
+      case Exception::kReferenceError:
+         result = isolate->factory()->NewReferenceError(message);
+         break;
+      case Exception::kStackOverflowError:
+        result = isolate->factory()->NewStackOverflowError(message);
+        break;
+      case Exception::kURIError:
+        result = isolate->factory()->NewURIError(message);
+        break;
+      case Exception::kEvalError:
+        result = isolate->factory()->NewEvalError(message);
+        break;
+      case Exception::kNoError:
+        UNREACHABLE();
+        break;
+    }
     error = *result;
   }
   i::Handle<i::Object> result(error, isolate);
-  return Utils::ToLocal(result);
-}
-
-
-Local<Value> Exception::ReferenceError(v8::Handle<v8::String> raw_message) {
-  i::Isolate* isolate = i::Isolate::Current();
-  LOG_API(isolate, "ReferenceError");
-  ON_BAILOUT(isolate, "v8::Exception::ReferenceError()", return Local<Value>());
-  ENTER_V8(isolate);
-  i::Object* error;
-  {
-    i::HandleScope scope(isolate);
-    i::Handle<i::String> message = Utils::OpenHandle(*raw_message);
-    i::Handle<i::Object> result =
-        isolate->factory()->NewReferenceError(message);
-    error = *result;
-  }
-  i::Handle<i::Object> result(error, isolate);
   return Utils::ToLocal(result);
 }
 
 
+Local<Value> Exception::RangeError(v8::Handle<v8::String> raw_message) {
+  return NewError(kRangeError, raw_message);
+}
+
+
+Local<Value> Exception::ReferenceError(v8::Handle<v8::String> raw_message) {
+  return NewError(kReferenceError, raw_message);
+}
+
+
 Local<Value> Exception::SyntaxError(v8::Handle<v8::String> raw_message) {
-  i::Isolate* isolate = i::Isolate::Current();
-  LOG_API(isolate, "SyntaxError");
-  ON_BAILOUT(isolate, "v8::Exception::SyntaxError()", return Local<Value>());
-  ENTER_V8(isolate);
-  i::Object* error;
-  {
-    i::HandleScope scope(isolate);
-    i::Handle<i::String> message = Utils::OpenHandle(*raw_message);
-    i::Handle<i::Object> result = isolate->factory()->NewSyntaxError(message);
-    error = *result;
-  }
-  i::Handle<i::Object> result(error, isolate);
-  return Utils::ToLocal(result);
+  return NewError(kSyntaxError, raw_message);
 }
 
 
 Local<Value> Exception::TypeError(v8::Handle<v8::String> raw_message) {
-  i::Isolate* isolate = i::Isolate::Current();
-  LOG_API(isolate, "TypeError");
-  ON_BAILOUT(isolate, "v8::Exception::TypeError()", return Local<Value>());
-  ENTER_V8(isolate);
-  i::Object* error;
-  {
-    i::HandleScope scope(isolate);
-    i::Handle<i::String> message = Utils::OpenHandle(*raw_message);
-    i::Handle<i::Object> result = isolate->factory()->NewTypeError(message);
-    error = *result;
-  }
-  i::Handle<i::Object> result(error, isolate);
-  return Utils::ToLocal(result);
+  return NewError(kTypeError, raw_message);
+}
+
+
+Local<Value> Exception::EvalError(v8::Handle<v8::String> raw_message) {
+  return NewError(kEvalError, raw_message);
+}
+
+
+Local<Value> Exception::URIError(v8::Handle<v8::String> raw_message) {
+  return NewError(kURIError, raw_message);
 }
 
 
 Local<Value> Exception::Error(v8::Handle<v8::String> raw_message) {
-  i::Isolate* isolate = i::Isolate::Current();
-  LOG_API(isolate, "Error");
-  ON_BAILOUT(isolate, "v8::Exception::Error()", return Local<Value>());
-  ENTER_V8(isolate);
-  i::Object* error;
-  {
-    i::HandleScope scope(isolate);
-    i::Handle<i::String> message = Utils::OpenHandle(*raw_message);
-    i::Handle<i::Object> result = isolate->factory()->NewError(message);
-    error = *result;
-  }
-  i::Handle<i::Object> result(error, isolate);
-  return Utils::ToLocal(result);
+  return NewError(kError, raw_message);
 }
 
 
+Local<Value> Exception::StackOverflowError(
+    v8::Handle<v8::String> raw_message) {
+  return NewError(kStackOverflowError, raw_message);
+}
+
+
 // --- D e b u g   S u p p o r t ---
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 
 bool Debug::SetDebugEventListener2(EventCallback2 that, Handle<Value> data) {
   i::Isolate* isolate = i::Isolate::Current();
   EnsureInitializedForIsolate(isolate, "v8::Debug::SetDebugEventListener2()");
   ON_BAILOUT(isolate, "v8::Debug::SetDebugEventListener2()", return false);
   ENTER_V8(isolate);
   i::HandleScope scope(isolate);
@@ skipping 816 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