Various API changes

src/api.cc

 // Copyright 2007-2008 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 1066 matching lines @@
       capture_message_(true) {
   i::Top::RegisterTryCatchHandler(this);
 }
 
 
 v8::TryCatch::~TryCatch() {
   i::Top::UnregisterTryCatchHandler(this);
 }
 
 
-bool v8::TryCatch::HasCaught() {
+bool v8::TryCatch::HasCaught() const {
   return !reinterpret_cast<i::Object*>(exception_)->IsTheHole();
 }
 
 
-v8::Local<Value> v8::TryCatch::Exception() {
+v8::Local<Value> v8::TryCatch::Exception() const {
   if (HasCaught()) {
     // Check for out of memory exception.
     i::Object* exception = reinterpret_cast<i::Object*>(exception_);
     return v8::Utils::ToLocal(i::Handle<i::Object>(exception));
   } else {
     return v8::Local<Value>();
   }
 }
 
 
-v8::Local<v8::Message> v8::TryCatch::Message() {
+v8::Local<v8::Message> v8::TryCatch::Message() const {
   if (HasCaught() && message_ != i::Smi::FromInt(0)) {
     i::Object* message = reinterpret_cast<i::Object*>(message_);
     return v8::Utils::MessageToLocal(i::Handle<i::Object>(message));
   } else {
     return v8::Local<v8::Message>();
   }
 }
 
 
 void v8::TryCatch::Reset() {
@@ skipping 18 matching lines @@
 Local<String> Message::Get() {
   ON_BAILOUT("v8::Message::Get()", return Local<String>());
   HandleScope scope;
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   i::Handle<i::String> raw_result = i::MessageHandler::GetMessage(obj);
   Local<String> result = Utils::ToLocal(raw_result);
   return scope.Close(result);
 }
 
 
-v8::Handle<String> Message::GetScriptResourceName() {
+v8::Handle<Value> Message::GetScriptResourceName() {
   if (IsDeadCheck("v8::Message::GetScriptResourceName()")) {
     return Local<String>();
   }
   HandleScope scope;
   i::Handle<i::JSObject> obj =
       i::Handle<i::JSObject>::cast(Utils::OpenHandle(this));
   // Return this.script.name.
   i::Handle<i::JSValue> script =
       i::Handle<i::JSValue>::cast(GetProperty(obj, "script"));
   i::Handle<i::Object> resource_name(i::Script::cast(script->value())->name());
-  if (!resource_name->IsString()) {
-    return Local<String>();
-  }
-  Local<String> result =
-      Utils::ToLocal(i::Handle<i::String>::cast(resource_name));
-  return scope.Close(result);
+  return scope.Close(Utils::ToLocal(resource_name));
 }
 
 
-// TODO(1240903): Remove this when no longer used in WebKit V8 bindings.
-Handle<Value> Message::GetSourceData() {
-  Handle<String> data = GetScriptResourceName();
-  if (data.IsEmpty()) return v8::Undefined();
-  return data;
-}
-
 static i::Handle<i::Object> CallV8HeapFunction(const char* name,
                                                i::Handle<i::Object> recv,
                                                int argc,
                                                i::Object** argv[],
                                                bool* has_pending_exception) {
   i::Handle<i::String> fmt_str = i::Factory::LookupAsciiSymbol(name);
   i::Object* object_fun = i::Top::builtins()->GetProperty(*fmt_str);
   i::Handle<i::JSFunction> fun =
       i::Handle<i::JSFunction>(i::JSFunction::cast(object_fun));
   i::Handle<i::Object> value =
@@ skipping 82 matching lines @@
                                                    &has_pending_exception);
   EXCEPTION_BAILOUT_CHECK(Local<v8::String>());
   if (result->IsString()) {
     return scope.Close(Utils::ToLocal(i::Handle<i::String>::cast(result)));
   } else {
     return Local<String>();
   }
 }
 
 
-char* Message::GetUnderline(char* source_line, char underline_char) {
-  if (IsDeadCheck("v8::Message::GetUnderline()")) return 0;
-  HandleScope scope;
-
-  i::Handle<i::JSObject> data_obj = Utils::OpenHandle(this);
-  int start_pos = static_cast<int>(GetProperty(data_obj, "startPos")->Number());
-  int end_pos = static_cast<int>(GetProperty(data_obj, "endPos")->Number());
-  EXCEPTION_PREAMBLE();
-  i::Handle<i::Object> start_col_obj = CallV8HeapFunction(
-      "GetPositionInLine",
-      data_obj,
-      &has_pending_exception);
-  EXCEPTION_BAILOUT_CHECK(0);
-  int start_col = static_cast<int>(start_col_obj->Number());
-  int end_col = start_col + (end_pos - start_pos);
-
-  // Any tabs before or between the selected columns have to be
-  // expanded into spaces.  We assume that a tab character advances
-  // the cursor up until the next 8-character boundary and at least
-  // one character.
-  int real_start_col = 0;
-  for (int i = 0; i < start_col; i++) {
-    real_start_col++;
-    if (source_line[i] == '\t') {
-      real_start_col++;
-      while (real_start_col % 8 != 0)
-        real_start_col++;
-    }
-  }
-  int real_end_col = real_start_col;
-  for (int i = start_col; i < end_col; i++) {
-    real_end_col++;
-    if (source_line[i] == '\t') {
-      while (real_end_col % 8 != 0)
-        real_end_col++;
-    }
-  }
-  char* result = i::NewArray<char>(real_end_col + 1);
-  for (int i = 0; i < real_start_col; i++)
-    result[i] = ' ';
-  for (int i = real_start_col; i < real_end_col; i++)
-    result[i] = underline_char;
-  result[real_end_col] = '\0';
-  return result;
-}
-
-
 void Message::PrintCurrentStackTrace(FILE* out) {
   if (IsDeadCheck("v8::Message::PrintCurrentStackTrace()")) return;
   i::Top::PrintCurrentStackTrace(out);
 }
 
 
 // --- D a t a ---
 
 bool Value::IsUndefined() {
   if (IsDeadCheck("v8::Value::IsUndefined()")) return false;
@@ skipping 66 matching lines @@
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   if (obj->IsSmi()) return true;
   if (obj->IsNumber()) {
     double value = obj->Number();
     return i::FastI2D(i::FastD2I(value)) == value;
   }
   return false;
 }
 
 
+bool Value::IsDate() {
+  if (IsDeadCheck("v8::Value::IsDate()")) return false;
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  return obj->HasSpecificClassOf(i::Heap::Date_symbol());
+}
+
+
 Local<String> Value::ToString() {
   if (IsDeadCheck("v8::Value::ToString()")) return Local<String>();
   LOG_API("ToString");
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   i::Handle<i::Object> str;
   if (obj->IsString()) {
     str = obj;
   } else {
     EXCEPTION_PREAMBLE();
     str = i::Execution::ToString(obj, &has_pending_exception);
@@ skipping 140 matching lines @@
 v8::Array* v8::Array::Cast(Value* that) {
   if (IsDeadCheck("v8::Array::Cast()")) return 0;
   i::Handle<i::Object> obj = Utils::OpenHandle(that);
   ApiCheck(obj->IsJSArray(),
            "v8::Array::Cast()",
            "Could not convert to array");
   return static_cast<v8::Array*>(that);
 }
 
 
+v8::Date* v8::Date::Cast(v8::Value* that) {
+  if (IsDeadCheck("v8::Date::Cast()")) return 0;
+  i::Handle<i::Object> obj = Utils::OpenHandle(that);
+  ApiCheck(obj->HasSpecificClassOf(i::Heap::Date_symbol()),
+           "v8::Date::Cast()",
+           "Could not convert to date");
+  return static_cast<v8::Date*>(that);
+}
+
+
 bool Value::BooleanValue() {
   if (IsDeadCheck("v8::Value::BooleanValue()")) return false;
   LOG_API("BooleanValue");
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   i::Handle<i::Object> value =
       obj->IsBoolean() ? obj : i::Execution::ToBoolean(obj);
   return value->IsTrue();
 }
 
 
@@ skipping 881 matching lines @@
 
 
 i::Handle<i::String> NewExternalAsciiStringHandle(
       v8::String::ExternalAsciiStringResource* resource) {
   i::Handle<i::String> result =
       i::Factory::NewExternalStringFromAscii(resource);
   return result;
 }
 
 
-static void DisposeExternalString(v8::Persistent<v8::Object> obj,
+static void DisposeExternalString(v8::Persistent<v8::Value> obj,
                                   void* parameter) {
   v8::String::ExternalStringResource* resource =
     reinterpret_cast<v8::String::ExternalStringResource*>(parameter);
   const size_t total_size = resource->length() * sizeof(*resource->data());
   i::Counters::total_external_string_memory.Decrement(total_size);
   delete resource;
   obj.Dispose();
 }
 
 
-static void DisposeExternalAsciiString(v8::Persistent<v8::Object> obj,
+static void DisposeExternalAsciiString(v8::Persistent<v8::Value> obj,
                                        void* parameter) {
   v8::String::ExternalAsciiStringResource* resource =
     reinterpret_cast<v8::String::ExternalAsciiStringResource*>(parameter);
   const size_t total_size = resource->length() * sizeof(*resource->data());
   i::Counters::total_external_string_memory.Decrement(total_size);
   delete resource;
   obj.Dispose();
 }
 
 
@@ skipping 40 matching lines @@
   EnsureInitialized("v8::Date::New()");
   LOG_API("Date::New");
   EXCEPTION_PREAMBLE();
   i::Handle<i::Object> obj =
       i::Execution::NewDate(time, &has_pending_exception);
   EXCEPTION_BAILOUT_CHECK(Local<v8::Value>());
   return Utils::ToLocal(obj);
 }
 
 
+double v8::Date::NumberValue() {
+  if (IsDeadCheck("v8::Date::NumberValue()")) return 0;
+  LOG_API("Date::NumberValue");
+  i::Handle<i::Object> obj = Utils::OpenHandle(this);
+  i::Handle<i::JSValue> jsvalue = i::Handle<i::JSValue>::cast(obj);
+  return jsvalue->value()->Number();
+}
+
+
 Local<v8::Array> v8::Array::New(int length) {
   EnsureInitialized("v8::Array::New()");
   LOG_API("Array::New");
   i::Handle<i::JSArray> obj = i::Factory::NewJSArray(length);
   return Utils::ToLocal(obj);
 }
 
 
 uint32_t v8::Array::Length() {
   if (IsDeadCheck("v8::Array::Length()")) return 0;
@@ skipping 429 matching lines @@
       reinterpret_cast<HandleScopeImplementer*>(storage);
   List<void**>* blocks_of_archived_thread = thread_local->Blocks();
   ImplementationUtilities::HandleScopeData* handle_data_of_archived_thread =
       &thread_local->handle_scope_data_;
   Iterate(v, blocks_of_archived_thread, handle_data_of_archived_thread);
 
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal