Rename fletch -> dartino

src/vm/object_memory.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/object_memory.h"
 
 #include <stdlib.h>
 #include <stdio.h>
 
 #include "src/shared/assert.h"
 #include "src/shared/platform.h"
 #include "src/shared/utils.h"
 
 #include "src/vm/frame.h"
 #include "src/vm/heap.h"
 #include "src/vm/mark_sweep.h"
 #include "src/vm/object.h"
 
-#ifdef FLETCH_TARGET_OS_LK
+#ifdef DARTINO_TARGET_OS_LK
 #include "lib/page_alloc.h"
 #endif
 
-#ifdef FLETCH_TARGET_OS_CMSIS
+#ifdef DARTINO_TARGET_OS_CMSIS
 // TODO(sgjesse): Put this into an .h file
 #define PAGE_SIZE_SHIFT 12
 #define PAGE_SIZE (1 << PAGE_SIZE_SHIFT)
 extern "C" void* page_alloc(size_t pages);
 extern "C" void page_free(void* start, size_t pages);
 #endif
 
-namespace fletch {
+namespace dartino {
 
 static Smi* chunk_end_sentinel() { return Smi::zero(); }
 
 static bool HasSentinelAt(uword address) {
   return *reinterpret_cast<Object**>(address) == chunk_end_sentinel();
 }
 
 Chunk::~Chunk() {
   // If the memory for this chunk is external we leave it alone
   // and let the embedder deallocate it.
   if (is_external()) return;
-#if defined(FLETCH_TARGET_OS_CMSIS) || defined(FLETCH_TARGET_OS_LK)
+#if defined(DARTINO_TARGET_OS_CMSIS) || defined(DARTINO_TARGET_OS_LK)
   page_free(reinterpret_cast<void*>(base()), size() >> PAGE_SIZE_SHIFT);
-#elif defined(FLETCH_TARGET_OS_WIN)
+#elif defined(DARTINO_TARGET_OS_WIN)
   _aligned_free(reinterpret_cast<void*>(base()));
 #else
   free(reinterpret_cast<void*>(base()));
 #endif
 }
 
 Space::~Space() { FreeAllChunks(); }
 
 void Space::FreeAllChunks() {
   Chunk* current = first();
@@ skipping 96 matching lines @@
 }
 
 void PageDirectory::Delete() {
   for (unsigned i = 0; i < ARRAY_SIZE(tables_); i++) {
     delete tables_[i];
   }
   Clear();
 }
 
 Mutex* ObjectMemory::mutex_;
-#ifdef FLETCH32
+#ifdef DARTINO32
 PageDirectory ObjectMemory::page_directory_;
 #else
 PageDirectory* ObjectMemory::page_directories_[1 << 13];
 #endif
 Atomic<uword> ObjectMemory::allocated_;
 
 void ObjectMemory::Setup() {
   mutex_ = Platform::CreateMutex();
   allocated_ = 0;
-#ifdef FLETCH32
+#ifdef DARTINO32
   page_directory_.Clear();
 #else
   memset(&page_directories_, 0, kPointerSize * ARRAY_SIZE(page_directories_));
 #endif
 }
 
 void ObjectMemory::TearDown() {
-#ifdef FLETCH32
+#ifdef DARTINO32
   page_directory_.Delete();
 #else
   for (unsigned i = 0; i < ARRAY_SIZE(page_directories_); i++) {
     PageDirectory* directory = page_directories_[i];
     if (directory == NULL) continue;
     directory->Delete();
     page_directories_[i] = NULL;
     delete directory;
   }
 #endif
@@ skipping 23 matching lines @@
 
 Chunk* ObjectMemory::AllocateChunk(Space* owner, int size) {
   ASSERT(owner != NULL);
 
   size = Utils::RoundUp(size, kPageSize);
   void* memory;
 #if defined(__ANDROID__)
   // posix_memalign doesn't exist on Android. We fallback to
   // memalign.
   memory = memalign(kPageSize, size);
-#elif defined(FLETCH_TARGET_OS_WIN)
+#elif defined(DARTINO_TARGET_OS_WIN)
   memory = _aligned_malloc(size, kPageSize);
-#elif defined(FLETCH_TARGET_OS_LK) || defined(FLETCH_TARGET_OS_CMSIS)
+#elif defined(DARTINO_TARGET_OS_LK) || defined(DARTINO_TARGET_OS_CMSIS)
   size = Utils::RoundUp(size, PAGE_SIZE);
   memory = page_alloc(size >> PAGE_SIZE_SHIFT);
 #else
   if (posix_memalign(&memory, kPageSize, size) != 0) return NULL;
 #endif
   if (memory == NULL) return NULL;
 
   uword base = reinterpret_cast<uword>(memory);
   Chunk* chunk = new Chunk(owner, base, size);
 
@@ skipping 29 matching lines @@
   allocated_ -= chunk->size();
   delete chunk;
 }
 
 bool ObjectMemory::IsAddressInSpace(uword address, const Space* space) {
   PageTable* table = GetPageTable(address);
   return (table != NULL) ? table->Get((address >> 12) & 0x3ff) == space : false;
 }
 
 PageTable* ObjectMemory::GetPageTable(uword address) {
-#ifdef FLETCH32
+#ifdef DARTINO32
   return page_directory_.Get(address >> 22);
 #else
   PageDirectory* directory = page_directories_[address >> 35];
   if (directory == NULL) return NULL;
   return directory->Get((address >> 22) & 0x1fff);
 #endif
 }
 
 void ObjectMemory::SetPageTable(uword address, PageTable* table) {
-#ifdef FLETCH32
+#ifdef DARTINO32
   page_directory_.Set(address >> 22, table);
 #else
   int index = address >> 35;
   PageDirectory* directory = page_directories_[index];
   if (directory == NULL) {
     page_directories_[index] = directory = new PageDirectory();
     directory->Clear();
   }
   return directory->Set((address >> 22) & 0x1fff, table);
 #endif
@@ skipping 52 matching lines @@
               StaticClassStructures::one_word_filler_class();
         }
         current += Instance::kSize;
       } else {
         current += object->Size();
       }
     }
   }
 }
 
-}  // namespace fletch
+}  // namespace dartino