Temp hax.

vm/dart_api_impl.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 82 matching lines @@
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   LocalHandles* local_handles = scope->local_handles();
   ASSERT(local_handles != NULL);
   LocalHandle* ref = local_handles->AllocateHandle();
   ref->set_raw(object);
   return reinterpret_cast<Dart_Handle>(ref);
 }
 
+Dart_Handle Api::NewLocalHandle(Isolate* isolate, RawObject* object) {
+  ASSERT(isolate != NULL);
+  ApiState* state = isolate->api_state();
+  ASSERT(state != NULL);
+  ApiLocalScope* scope = state->top_scope();
+  ASSERT(scope != NULL);
+  LocalHandles* local_handles = scope->local_handles();
+  ASSERT(local_handles != NULL);
+  LocalHandle* ref = local_handles->AllocateHandle();
+  ref->set_raw(object);
+  return reinterpret_cast<Dart_Handle>(ref);
+}
+
 RawObject* Api::UnwrapHandle(Dart_Handle object) {
 #ifdef DEBUG
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ASSERT(state->IsValidPrologueWeakPersistentHandle(object) ||
          state->IsValidWeakPersistentHandle(object) ||
          state->IsValidPersistentHandle(object) ||
          state->IsValidLocalHandle(object));
@@ skipping 137 matching lines @@
   ASSERT(api_native_key_ == Thread::kUnsetThreadLocalKey);
   api_native_key_ = Thread::CreateThreadLocal();
   ASSERT(api_native_key_ != Thread::kUnsetThreadLocalKey);
 }
 
 
 // --- Handles ---
 
 
 DART_EXPORT bool Dart_IsError(Dart_Handle handle) {
+  RawObject* raw_obj = ((LocalHandle*)handle)->raw();
+  if (!raw_obj->IsHeapObject()) {
+    return false;
+  }
+  uword raw_addr = RawObject::ToAddr(raw_obj);
+  RawClass* header = (RawClass*)*reinterpret_cast<uword*>(raw_addr);
+  return (header == Object::language_error_class() ||
+          header == Object::api_error_class() ||
+          header == Object::unhandled_exception_class() ||
+          header == Object::unwind_error_class());
+#if 0
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   return obj.IsError();
+#endif
 }
 
 
 DART_EXPORT const char* Dart_GetError(Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
   if (obj.IsError()) {
     Error& error = Error::Handle(isolate);
     error ^= obj.raw();
@@ skipping 819 matching lines @@
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return obj.IsNumber();
 }
 
 
 // --- Integers ----
 
 
 DART_EXPORT bool Dart_IsInteger(Dart_Handle object) {
+  RawObject* raw_obj = ((LocalHandle*)object)->raw();
+  if (!raw_obj->IsHeapObject()) {
+    return true;
+  }
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return obj.IsInteger();
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoInt64(Dart_Handle integer,
                                                   bool* fits) {
   Isolate* isolate = Isolate::Current();
+  RawObject* raw_obj = ((LocalHandle*)integer)->raw();
+  if (!raw_obj->IsHeapObject()) {
+    *fits = true;
+    return Api::Success(isolate);
+  }
   DARTSCOPE(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     *fits = true;
   } else {
     ASSERT(int_obj.IsBigint());
 #if defined(DEBUG)
@@ skipping 22 matching lines @@
     Bigint& bigint = Bigint::Handle(isolate);
     bigint ^= int_obj.raw();
     *fits = BigintOperations::FitsIntoUint64(bigint);
   }
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value) {
   Isolate* isolate = Isolate::Current();
+#if 0
   DARTSCOPE(isolate);
   const Integer& obj = Integer::Handle(isolate, Integer::New(value));
   return Api::NewLocalHandle(isolate, obj);
+#endif
+  return Api::NewLocalHandle(isolate, Integer::New(value));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char* str) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& str_obj = String::Handle(isolate, String::New(str));
   const Integer& obj = Integer::Handle(isolate, Integer::New(str_obj));
   return Api::NewLocalHandle(isolate, obj);
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToInt64(Dart_Handle integer,
                                             int64_t* value) {
   Isolate* isolate = Isolate::Current();
+  RawObject* raw_obj = ((LocalHandle*)integer)->raw();
+  if (!raw_obj->IsHeapObject()) {
+    *value = ((int64_t)raw_obj) >> kSmiTagShift;
+    return Api::Success(isolate);
+  }
   DARTSCOPE(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     *value = int_obj.AsInt64Value();
     return Api::Success(isolate);
   } else {
     ASSERT(int_obj.IsBigint());
@@ skipping 1863 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_GetNativeArgument(Dart_NativeArguments args,
                                                int index) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   if (index < 0 || index >= arguments->Count()) {
     return Api::NewError(
         "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
         CURRENT_FUNC, arguments->Count() - 1, index);
   }
   Isolate* isolate = arguments->isolate();
+  return Api::NewLocalHandle(isolate, arguments->At(index));
+#if 0
+  Isolate* isolate = arguments->isolate();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, arguments->At(index));
   return Api::NewLocalHandle(isolate, obj);
+#endif
 }
 
 
 DART_EXPORT int Dart_GetNativeArgumentCount(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   CHECK_ISOLATE(arguments->isolate());
   return arguments->Count();
 }
 
 
 DART_EXPORT void Dart_SetReturnValue(Dart_NativeArguments args,
                                      Dart_Handle retval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
+#if 0
   Isolate* isolate = arguments->isolate();
   DARTSCOPE(isolate);
   arguments->SetReturn(Object::Handle(isolate, Api::UnwrapHandle(retval)));
+#endif
+  arguments->SetReturn(Api::UnwrapHandle(retval));
 }
 
 
 // --- Scripts and Libraries ---
 
 
 // NOTE: Need to pass 'result' as a parameter here in order to avoid
 // warning: variable 'result' might be clobbered by 'longjmp' or 'vfork'
 // which shows up because of the use of setjmp.
 static void CompileSource(Isolate* isolate,
@@ skipping 321 matching lines @@
       *buffer = NULL;
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 }  // namespace dart