Implementation of message reader for converting a message snapshot into a C structure

runtime/vm/snapshot.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_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ skipping 19 matching lines @@
 class RawField;
 class RawFourByteString;
 class RawFunction;
 class RawImmutableArray;
 class RawLibrary;
 class RawLibraryPrefix;
 class RawMint;
 class RawObject;
 class RawOneByteString;
 class RawScript;
+class RawSmi;
 class RawTokenStream;
 class RawType;
 class RawTypeParameter;
 class RawTypeArguments;
 class RawTwoByteString;
 class RawUnresolvedClass;
 class String;
 
 static const int8_t kSerializedBitsPerByte = 7;
 static const int8_t kMaxSerializedUnsignedValuePerByte = 127;
@@ skipping 136 matching lines @@
     return *current_++;
   }
 
  private:
   const uint8_t* buffer_;
   const uint8_t* current_;
   const uint8_t* end_;
 
   // SnapshotReader needs access to the private Raw classes.
   friend class SnapshotReader;
+  friend class CMessageReader;
   DISALLOW_COPY_AND_ASSIGN(ReadStream);
 };
 
 
 // Stream for writing various types into a buffer.
 class WriteStream : public ValueObject {
  public:
   static const int kBufferIncrementSize = 64 * KB;
 
   WriteStream(uint8_t** buffer, ReAlloc alloc) :
@@ skipping 85 matching lines @@
   intptr_t current_size_;
   ReAlloc alloc_;
 
   // MessageWriter and SnapshotWriter needs access to the private Raw
   // classes.
   friend class BaseWriter;
   DISALLOW_COPY_AND_ASSIGN(WriteStream);
 };
 
 
-// Reads a snapshot into objects.
-class SnapshotReader {
+class BaseReader {
  public:
-  SnapshotReader(const Snapshot* snapshot, Isolate* isolate);
-  ~SnapshotReader() { }
-
+  BaseReader(const uint8_t* buffer, intptr_t size) : stream_(buffer, size) {}
   // Reads raw data (for basic types).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
   T Read() {
     return ReadStream::Raw<sizeof(T), T>::Read(&stream_);
   }
 
   // Reads an intptr_t type value.
   intptr_t ReadIntptrValue() {
     int64_t value = Read<int64_t>();
     ASSERT((value <= kIntptrMax) && (value >= kIntptrMin));
     return value;
   }
 
+  RawSmi* ReadAsSmi();
+  intptr_t ReadSmiValue();
+
+ private:
+  ReadStream stream_;  // input stream.
+};
+
+
+// Reads a snapshot into objects.
+class SnapshotReader : public BaseReader {
+ public:
+  SnapshotReader(const Snapshot* snapshot, Isolate* isolate);
+  ~SnapshotReader() { }
+
   Isolate* isolate() const { return isolate_; }
   Heap* heap() const { return isolate_->heap(); }
   ObjectStore* object_store() const { return isolate_->object_store(); }
   Object* ObjectHandle() { return &obj_; }
   String* StringHandle() { return &str_; }
   AbstractType* TypeHandle() { return &type_; }
   AbstractTypeArguments* TypeArgumentsHandle() { return &type_arguments_; }
 
   // Reads an object.
   RawObject* ReadObject();
@@ skipping 39 matching lines @@
   // Read an object that was serialized as an Id (singleton, object store,
   // or an object that was already serialized before).
   RawObject* ReadIndexedObject(intptr_t object_id);
 
   // Read an inlined object from the stream.
   RawObject* ReadInlinedObject(intptr_t object_id);
 
   // Based on header field check to see if it is an internal VM class.
   RawClass* LookupInternalClass(intptr_t class_header);
 
-  ReadStream stream_;  // input stream.
   Snapshot::Kind kind_;  // Indicates type of snapshot(full, script, message).
   Isolate* isolate_;  // Current isolate.
   Class& cls_;  // Temporary Class handle.
   Object& obj_;  // Temporary Object handle.
   String& str_;  // Temporary String handle.
   Library& library_;  // Temporary library handle.
   AbstractType& type_;  // Temporary type handle.
   AbstractTypeArguments& type_arguments_;  // Temporary type argument handle.
   GrowableArray<Object*> backward_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotReader);
 };
 
 
+// Reads a message snapshot into C structure.
+class CMessageReader : public BaseReader {
+ public:
+  CMessageReader(const uint8_t* buffer, intptr_t length, ReAlloc alloc);
+  ~CMessageReader() { }
+
+  Dart_CObject* ReadObject();
+
+ private:
+  // Allocates a Dart_CObject object on the C heap.
+  Dart_CObject* AllocateDartValue();
+  // Allocates a Dart_CObject object with the specified type on the C heap.
+  Dart_CObject* AllocateDartValue(Dart_CObject::Type type);
+  // Allocates a Dart_CObject object for the null object on the C heap.
+  Dart_CObject* AllocateDartValueNull();
+  // Allocates a Dart_CObject object for a boolean object on the C heap.
+  Dart_CObject* AllocateDartValueBool(bool value);
+  // Allocates a Dart_CObject object for for a 32-bit integer on the C heap.
+  Dart_CObject* AllocateDartValueInt32(int32_t value);
+  // Allocates a Dart_CObject object for a double on the C heap.
+  Dart_CObject* AllocateDartValueDouble(double value);
+  // Allocates a Dart_CObject object for string data on the C heap.
+  Dart_CObject* AllocateDartValueString(intptr_t length);
+  // Allocates a C array of Dart_CObject objects on the C heap.
+  Dart_CObject* AllocateDartValueArray(intptr_t length);
+
+  intptr_t LookupInternalClass(intptr_t class_header);
+  Dart_CObject* ReadInlinedObject(intptr_t object_id);
+  Dart_CObject* ReadObjectImpl(intptr_t header);
+  Dart_CObject* ReadIndexedObject(intptr_t object_id);
+
+  ReAlloc alloc_;
+};
+
+
 class BaseWriter {
  public:
   // Size of the snapshot.
   intptr_t BytesWritten() const { return stream_.bytes_written(); }
 
   // Writes raw data to the stream (basic type).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
   void Write(T value) {
     WriteStream::Raw<sizeof(T), T>::Write(&stream_, value);
@@ skipping 155 matching lines @@
 
  private:
   SnapshotWriter* writer_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_