- Add a minimal implementation of Capability.

runtime/vm/raw_object.h

 // 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.
 
 #ifndef VM_RAW_OBJECT_H_
 #define VM_RAW_OBJECT_H_
 
 #include "platform/assert.h"
 #include "vm/globals.h"
 #include "vm/token.h"
@@ skipping 42 matching lines @@
       V(BoundedType)                                                           \
       V(MixinAppType)                                                          \
     V(Number)                                                                  \
       V(Integer)                                                               \
         V(Smi)                                                                 \
         V(Mint)                                                                \
         V(Bigint)                                                              \
       V(Double)                                                                \
     V(Bool)                                                                    \
     V(GrowableObjectArray)                                                     \
+    V(Float32x4)                                                               \
+    V(Int32x4)                                                                 \
+    V(Float64x2)                                                               \
     V(TypedData)                                                               \
     V(ExternalTypedData)                                                       \
+    V(Capability)                                                              \
+    V(ReceivePort)                                                             \
+    V(SendPort)                                                                \
     V(Stacktrace)                                                              \
     V(JSRegExp)                                                                \
     V(WeakProperty)                                                            \
     V(MirrorReference)                                                         \
-    V(Float32x4)                                                               \
-    V(Int32x4)                                                                 \
-    V(Float64x2)                                                               \
     V(UserTag)                                                                 \
 
 #define CLASS_LIST_ARRAYS(V)                                                   \
   V(Array)                                                                     \
     V(ImmutableArray)                                                          \
 
 #define CLASS_LIST_STRINGS(V)                                                  \
   V(String)                                                                    \
     V(OneByteString)                                                           \
     V(TwoByteString)                                                           \
@@ skipping 1415 matching lines @@
   RawObject** from() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
   RawSmi* length_;
   RawObject** to() { return reinterpret_cast<RawObject**>(&ptr()->length_); }
 
   uint8_t* data_;
 
   friend class TokenStream;
   friend class RawTokenStream;
 };
 
+// VM implementations of the basic types in the isolate.
+class RawCapability : public RawInstance {
+  RAW_HEAP_OBJECT_IMPLEMENTATION(Capability);
+  uint64_t id_;
+};
+
+
+class RawSendPort : public RawInstance {
+  RAW_HEAP_OBJECT_IMPLEMENTATION(SendPort);
+  Dart_Port id_;
+
+  friend class ReceivePort;
+};
+
+
+class RawReceivePort : public RawInstance {
+  RAW_HEAP_OBJECT_IMPLEMENTATION(ReceivePort);
+
+  RawObject** from() {
+    return reinterpret_cast<RawObject**>(&ptr()->send_port_);
+  }
+  RawSendPort* send_port_;
+  RawInstance* handler_;
+  RawObject** to() {
+    return reinterpret_cast<RawObject**>(&ptr()->handler_);
+  }
+};
+
 
 // VM type for capturing stacktraces when exceptions are thrown,
 // Currently we don't have any interface that this object is supposed
 // to implement so we just support the 'toString' method which
 // converts the stack trace into a string.
 class RawStacktrace : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Stacktrace);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->code_array_);
@@ skipping 161 matching lines @@
          kTwoByteStringCid == kStringCid + 2 &&
          kExternalOneByteStringCid == kStringCid + 3 &&
          kExternalTwoByteStringCid == kStringCid + 4);
   return (index == kExternalOneByteStringCid ||
           index == kExternalTwoByteStringCid);
 }
 
 
 inline bool RawObject::IsBuiltinListClassId(intptr_t index) {
   // Make sure this function is updated when new builtin List types are added.
-  ASSERT(kImmutableArrayCid == kArrayCid + 1 &&
-         kTypedDataCid == kGrowableObjectArrayCid + 1);
+  ASSERT(kImmutableArrayCid == kArrayCid + 1);
   return ((index >= kArrayCid && index <= kImmutableArrayCid) ||
-          (index >= kGrowableObjectArrayCid && index < kTypedDataCid) ||
+          (index == kGrowableObjectArrayCid) ||
           IsTypedDataClassId(index) ||
           IsTypedDataViewClassId(index) ||
           IsExternalTypedDataClassId(index));
 }
 
 
 inline bool RawObject::IsTypedDataClassId(intptr_t index) {
   // Make sure this is updated when new TypedData types are added.
   ASSERT(kTypedDataUint8ArrayCid == kTypedDataInt8ArrayCid + 1 &&
          kTypedDataUint8ClampedArrayCid == kTypedDataInt8ArrayCid + 2 &&
@@ skipping 103 matching lines @@
   // Make sure this is updated when new TypedData types are added.
   ASSERT(kTypedDataInt8ArrayViewCid == kTypedDataInt8ArrayCid + 14);
   ASSERT(kExternalTypedDataInt8ArrayCid == kTypedDataInt8ArrayViewCid + 15);
   ASSERT(kNullCid == kExternalTypedDataInt8ArrayCid + 14);
   return (kNullCid - kTypedDataInt8ArrayCid);
 }
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_