Changes to shrink the token stream representation from two words to one word.

vm/raw_object_snapshot.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 "vm/bigint_operations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/visitor.h"
 
@@ skipping 554 matching lines @@
   writer->Write<bool>(ptr()->is_static_);
   writer->Write<bool>(ptr()->is_final_);
   writer->Write<bool>(ptr()->has_initializer_);
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to());
 }
 
 
+RawLiteralToken* LiteralToken::ReadFrom(SnapshotReader* reader,
+                                        intptr_t object_id,
+                                        intptr_t tags,
+                                        Snapshot::Kind kind) {
+  ASSERT(reader != NULL);
+  ASSERT(kind != Snapshot::kMessage);
+
+  // Create the literal token object.
+  LiteralToken& literal_token = LiteralToken::ZoneHandle(
+      reader->isolate(), NEW_OBJECT(LiteralToken));
+  reader->AddBackwardReference(object_id, &literal_token);
+
+  // Set the object tags.
+  literal_token.set_tags(tags);
+
+  // Read the token attributes.
+  Token::Kind token_kind = static_cast<Token::Kind>(reader->ReadIntptrValue());
+  literal_token.set_kind(token_kind);
+  *reader->StringHandle() ^= reader->ReadObject();
+  literal_token.set_literal(*reader->StringHandle());
+  *reader->ObjectHandle() = reader->ReadObject();
+  literal_token.set_value(*reader->ObjectHandle());
+
+  // If object needs to be a canonical object, Canonicalize it.
+  if ((kind != Snapshot::kFull) && literal_token.IsCanonical()) {
+    literal_token ^= literal_token.Canonicalize();
+  }
+  return literal_token.raw();
+}
+
+
+void RawLiteralToken::WriteTo(SnapshotWriter* writer,
+                              intptr_t object_id,
+                              Snapshot::Kind kind) {
+  ASSERT(writer != NULL);
+  ASSERT(kind != Snapshot::kMessage);
+
+  // Write out the serialization header value for this object.
+  writer->WriteSerializationMarker(kInlined, object_id);
+
+  // Write out the class and tags information.
+  writer->WriteObjectHeader(Object::kLiteralTokenClass, ptr()->tags_);
+
+  // Write out the kind field.
+  writer->Write<intptr_t>(ptr()->kind_);
+
+  // Write out literal and value fields.
+  writer->WriteObject(ptr()->literal_);
+  writer->WriteObject(ptr()->value_);
+}
+
+
 RawTokenStream* TokenStream::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Read the length so that we can determine number of tokens to read.
   intptr_t len = reader->ReadSmiValue();
 
   // Create the token stream object.
   TokenStream& token_stream = TokenStream::ZoneHandle(
       reader->isolate(), NEW_OBJECT_WITH_LEN(TokenStream, len));
   reader->AddBackwardReference(object_id, &token_stream);
 
   // Set the object tags.
   token_stream.set_tags(tags);
 
   // Read the token stream into the TokenStream.
   for (intptr_t i = 0; i < len; i++) {
-    Token::Kind kind = static_cast<Token::Kind>(reader->ReadSmiValue());
-    *reader->StringHandle() ^= reader->ReadObject();
-    token_stream.SetTokenAt(i, kind, *reader->StringHandle());
+    *reader->ObjectHandle() = reader->ReadObject();
+    token_stream.SetTokenAt(i, *reader->ObjectHandle());
   }
   return token_stream.raw();
 }
 
 
 void RawTokenStream::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage && !IsCreatedFromSnapshot());
@@ skipping 1250 matching lines @@
 
 
 void RawICData::WriteTo(SnapshotWriter* writer,
                         intptr_t object_id,
                         Snapshot::Kind kind) {
   UNIMPLEMENTED();
 }
 
 
 }  // namespace dart