Add an external array type to support typed arrays.

runtime/vm/raw_object.h

 // Copyright (c) 2011, 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 "vm/assert.h"
 #include "vm/globals.h"
 #include "vm/snapshot.h"
@@ skipping 34 matching lines @@
         V(Mint)                                                                \
         V(Bigint)                                                              \
       V(Double)                                                                \
     V(String)                                                                  \
       V(OneByteString)                                                         \
       V(TwoByteString)                                                         \
       V(FourByteString)                                                        \
     V(Bool)                                                                    \
     V(Array)                                                                   \
       V(ImmutableArray)                                                        \
+    V(ExternalArray)                                                           \
     V(Closure)                                                                 \
     V(Stacktrace)                                                              \
     V(JSRegExp)                                                                \
 
 #define CLASS_LIST(V)                                                          \
   V(Object)                                                                    \
   CLASS_LIST_NO_OBJECT(V)
 
 
 // Forward declarations.
@@ skipping 647 matching lines @@
 
   friend class RawImmutableArray;
 };
 
 
 class RawImmutableArray : public RawArray {
   RAW_HEAP_OBJECT_IMPLEMENTATION(ImmutableArray);
 };
 
 
+class RawExternalArray : public RawInstance {
+  RAW_HEAP_OBJECT_IMPLEMENTATION(ExternalArray);
+
+  RawSmi* length_;

[siva, 2011/11/02 17:05:31]

Do we want this to be RawSmi or intptr_t i.e have a restriction on how big the
external array can be or let it be larger than what Smi can hold?

Also missing from() and to() methods, even though you might have only a RawSmi
in here it is probably a good idea to add the from and to so that it is
consistent with the others and if somebody decides to add a field in here later
it is not overlooked. 

[cshapiro, 2011/11/04 18:16:21]

I am partial to having the length parameter to be a Smi as the type should
implement List and Collection and the extant implementations of these types are
limit to Smi indices.  I am not sure how to reconcile this disparity in reach. 
What do you think?

As for the from and to methods, I will go ahead add that.

+  uint8_t* data_;
+};
+
+
 class RawClosure : public RawInstance {
   RAW_HEAP_OBJECT_IMPLEMENTATION(Closure);
 
   RawObject** from() {
     return reinterpret_cast<RawObject**>(&ptr()->type_arguments_);
   }
   RawTypeArguments* type_arguments_;
   RawFunction* function_;
   RawContext* context_;
   // TODO(iposva): Remove this temporary hack.
@@ skipping 38 matching lines @@
   intptr_t type_;  // Uninitialized, simple or complex.
   intptr_t flags_;  // Represents global/local, case insensitive, multiline.
 
   // Variable length data follows here.
   uint8_t data_[0];
 };
 
 }  // namespace dart
 
 #endif  // VM_RAW_OBJECT_H_