Simplify access to peer pointer for external strings.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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 "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
@@ skipping 222 matching lines @@
   true_handle_ = Api::NewHandle(isolate, Bool::True().raw());
 
   ASSERT(false_handle_ == NULL);
   false_handle_ = Api::NewHandle(isolate, Bool::False().raw());
 
   ASSERT(null_handle_ == NULL);
   null_handle_ = Api::NewHandle(isolate, Object::null());
 }
 
 
+#define GET_PEER(type, ctype, raw_obj, peer)                                   \

[srdjan, 2013/08/15 01:47:06]

I am not certain if for only two cases it is worth to add the macro.

[siva, 2013/08/15 17:05:18]

Femoved macro and inlined the code in the other call.

On 2013/08/15 01:47:06, srdjan wrote:

+  RawExternal##type* raw_string =                                              \
+      reinterpret_cast<RawExternal##type*>(raw_obj)->ptr();                    \
+  ExternalStringData<ctype>* data = raw_string->external_data_;                \
+  *peer = data->peer();                                                        \
+  return true;                                                                 \
+
+
+#define EXTERNAL_PEER_HELPER(cid, raw_obj, peer)                               \

[srdjan, 2013/08/15 01:47:06]

Can this be a function instead of a macro?

[siva, 2013/08/15 17:05:18]

Would have loved to make it a function but that would mean we would have a raw
pointer passed in as an argument and it would have been difficult to put the
NoGcScope construct at the right place. 
By having it as a macro I am able to put a NoGCScope around this code.

On 2013/08/15 01:47:06, srdjan wrote:

+  switch (cid) {                                                               \
+    case kExternalOneByteStringCid: {                                          \
+      GET_PEER(OneByteString, uint8_t, raw_obj, peer);                         \
+    }                                                                          \
+    case kExternalTwoByteStringCid: {                                          \
+      GET_PEER(TwoByteString, uint16_t, raw_obj, peer);                        \
+    }                                                                          \
+  }                                                                            \
+  return false;                                                                \
+
+
+bool Api::ExternalStringGetPeerHelper(Dart_NativeArguments args,
+                                      int arg_index,
+                                      void** peer) {
+  NoGCScope no_gc_scope;
+  NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
+  RawObject* raw_obj = arguments->NativeArgAt(arg_index);
+  intptr_t cid = raw_obj->GetClassId();
+  EXTERNAL_PEER_HELPER(cid, raw_obj, peer);
+}
+
+
 bool Api::ExternalStringGetPeerHelper(Dart_Handle object, void** peer) {
   NoGCScope no_gc_scope;
   RawObject* raw_obj = Api::UnwrapHandle(object);
-  switch (Api::ClassId(object)) {
-    case kExternalOneByteStringCid: {
-      RawExternalOneByteString* raw_string =
-          reinterpret_cast<RawExternalOneByteString*>(raw_obj)->ptr();
-      ExternalStringData<uint8_t>* data = raw_string->external_data_;
-      *peer = data->peer();
-      return true;
-    }
-    case kExternalTwoByteStringCid: {
-      RawExternalTwoByteString* raw_string =
-          reinterpret_cast<RawExternalTwoByteString*>(raw_obj)->ptr();
-      ExternalStringData<uint16_t>* data = raw_string->external_data_;
-      *peer = data->peer();
-      return true;
-    }
-  }
-  return false;
+  EXTERNAL_PEER_HELPER(Api::ClassId(object), raw_obj, peer);
 }
 
 
 void Api::SetWeakHandleReturnValue(NativeArguments* args,
                                    Dart_WeakPersistentHandle retval) {
   args->SetReturnUnsafe(Api::UnwrapAsWeakPersistentHandle(retval)->raw());
 }
 
 
 // --- Handles ---
@@ skipping 3406 matching lines @@
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeStringArgument(Dart_NativeArguments args,
                                                      int arg_index,
                                                      void** peer) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
   CHECK_ISOLATE(isolate);
+  if (Api::ExternalStringGetPeerHelper(args, arg_index, peer)) {
+    return Api::Success();
+  }
+  *peer = NULL;
   ReusableObjectHandleScope reused_obj_handle(isolate);
   Object& obj = reused_obj_handle.Handle();
   obj = arguments->NativeArgAt(arg_index);
-  intptr_t cid = obj.GetClassId();
-  if (RawObject::IsExternalStringClassId(cid)) {
-    const String& str = String::Cast(obj);
-    *peer = str.GetPeer();
-    ASSERT(*peer != NULL);
-    return Api::Success();
-  }
-  *peer = NULL;
-  if (RawObject::IsStringClassId(cid)) {
+  if (RawObject::IsStringClassId(obj.GetClassId())) {
     return Api::NewHandle(isolate, obj.raw());
   }
   return Api::NewError("%s expects argument to be of"
                        " type String.", CURRENT_FUNC);
 }
 
 
 DART_EXPORT void Dart_SetReturnValue(Dart_NativeArguments args,
                                      Dart_Handle retval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
@@ skipping 524 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success();
 }
 
 }  // namespace dart