Rename fletch -> dartino

src/vm/snapshot.cc

 // Copyright (c) 2014, the Dartino 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.md file.
 
 #include "src/vm/snapshot.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 
 #include "src/shared/assert.h"
 #include "src/shared/bytecodes.h"
 #include "src/shared/utils.h"
 #include "src/shared/version.h"
 
 #include "src/vm/object.h"
 #include "src/vm/program.h"
 
-namespace fletch {
+namespace dartino {
 
 static const int kSupportedSizeOfDouble = 8;
 static const int kReferenceTableSizeBytes = 4;
 static const int kHeapSizeBytes = 4;
 
 class Header {
  public:
   explicit Header(int64 value) : value_(value) {}
 
   static Header FromSmi(Smi* value) {
@@ skipping 275 matching lines @@
   // Read the required backward reference table size.
   int references = 0;
   for (int i = 0; i < kReferenceTableSizeBytes; i++) {
     references = (references << 8) | ReadByte();
   }
 
   Program* program = new Program(Program::kLoadedFromSnapshot, hashtag);
 
   // Read the heap size and allocate an area for it.
   int size_position;
-  if (kPointerSize == 8 && sizeof(fletch_double) == 8) {
+  if (kPointerSize == 8 && sizeof(dartino_double) == 8) {
     size_position = position_ + 0 * kHeapSizeBytes;
-  } else if (kPointerSize == 8 && sizeof(fletch_double) == 4) {
+  } else if (kPointerSize == 8 && sizeof(dartino_double) == 4) {
     size_position = position_ + 1 * kHeapSizeBytes;
-  } else if (kPointerSize == 4 && sizeof(fletch_double) == 8) {
+  } else if (kPointerSize == 4 && sizeof(dartino_double) == 8) {
     size_position = position_ + 2 * kHeapSizeBytes;
   } else {
-    ASSERT(kPointerSize == 4 && sizeof(fletch_double) == 4);
+    ASSERT(kPointerSize == 4 && sizeof(dartino_double) == 4);
     size_position = position_ + 3 * kHeapSizeBytes;
   }
   position_ += 4 * kHeapSizeBytes;
   int heap_size = ReadHeapSizeFrom(size_position);
   // Make sure to make room for the filler at the end of the program space.
   memory_ =
       ObjectMemory::AllocateChunk(program->heap()->space(), heap_size + 1);
   top_ = memory_->base();
 
   // Allocate space for the backward references.
@@ skipping 402 matching lines @@
   }
 }
 
 void Class::ClassReadFrom(SnapshotReader* reader) {
   int size = AllocationSize();
   for (int offset = HeapObject::kSize; offset < size; offset += kPointerSize) {
     at_put(offset, reader->ReadObject());
   }
 }
 
-#ifdef FLETCH_TARGET_X64
+#ifdef DARTINO_TARGET_X64
 void Function::WriteByteCodes(SnapshotWriter* writer) {
   ASSERT(kPointerSize == 8);
   uint8* bcp = bytecode_address_for(0);
   int i = 0;
   while (i < bytecode_size()) {
     Opcode opcode = static_cast<Opcode>(bcp[i]);
     switch (opcode) {
       case kLoadConst:
       case kAllocate:
       case kAllocateImmutable:
@@ skipping 34 matching lines @@
     }
   }
 }
 #else
 void Function::WriteByteCodes(SnapshotWriter* writer) {
   ASSERT(kPointerSize == 4);
   writer->WriteBytes(bytecode_size(), bytecode_address_for(0));
 }
 #endif
 
-#ifdef FLETCH_TARGET_X64
+#ifdef DARTINO_TARGET_X64
 void Function::ReadByteCodes(SnapshotReader* reader) {
   ASSERT(kPointerSize == 8);
   uint8* bcp = bytecode_address_for(0);
   int i = 0;
   while (i < bytecode_size()) {
     uint8 raw_opcode = reader->ReadByte();
     Opcode opcode = static_cast<Opcode>(raw_opcode);
     switch (opcode) {
       case kLoadConst:
       case kAllocate:
@@ skipping 127 matching lines @@
   writer->WriteInt64(selector());
 }
 
 void DispatchTableEntry::DispatchTableEntryReadFrom(SnapshotReader* reader) {
   set_target(Function::cast(reader->ReadObject()));
   set_code(NULL);
   set_offset(Smi::cast(reader->ReadObject()));
   set_selector(reader->ReadInt64());
 }
 
-}  // namespace fletch
+}  // namespace dartino