Rename fletch -> dartino

src/vm/object.h

 // 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.
 
 #ifndef SRC_VM_OBJECT_H_
 #define SRC_VM_OBJECT_H_
 
 #define _USE_MATH_DEFINES  // required for Windows
 #include <math.h>
 #include <string.h>
 
 #include "src/shared/assert.h"
 #include "src/shared/globals.h"
 #include "src/shared/random.h"
 #include "src/shared/list.h"
 #include "src/shared/utils.h"
 
 #include "src/vm/intrinsics.h"
 
-namespace fletch {
+namespace dartino {
 
 // This is an overview of the object class hierarchy:
 //
 //   Object
 //     Smi
 //     Failure
 //     HeapObject
 //       FreeListChunk
 //       OneWordFiller
 //       PromotedTrack
@@ skipping 414 matching lines @@
   static const int kSize = kValueOffset + sizeof(int64);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(LargeInteger);
 };
 
 // Heap allocated double.
 class Double : public HeapObject {
  public:
   // [value]: double value.
-  inline fletch_double value();
-  inline void set_value(fletch_double value);
+  inline dartino_double value();
+  inline void set_value(dartino_double value);
 
   // Casting.
   static inline Double* cast(Object* object);
 
   // Printing.
   void DoublePrint();
   void DoubleShortPrint();
 
   // Snapshotting.
   void DoubleWriteTo(SnapshotWriter* writer, Class* klass);
   void DoubleReadFrom(SnapshotReader* reader);
 
   // Sizing.
   static int AllocationSize() { return Utils::RoundUp(kSize, kPointerSize); }
 
   int DoubleSize() { return AllocationSize(); }
 
   PortableSize CalculatePortableSize() {
     return PortableSize(HeapObject::kSize / kPointerSize, 0, 1);
   }
 
   static const int kValueOffset = HeapObject::kSize;
-  static const int kSize = kValueOffset + sizeof(fletch_double);
+  static const int kSize = kValueOffset + sizeof(dartino_double);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Double);
 };
 
 // Heap allocated object that boxes a value.
 class Boxed : public HeapObject {
  public:
   inline Object* value();
   inline void set_value(Object* value);
@@ skipping 1718 matching lines @@
   *reinterpret_cast<int64*>(address() + kValueOffset) = value;
 }
 
 LargeInteger* LargeInteger::cast(Object* object) {
   ASSERT(object->IsLargeInteger());
   return reinterpret_cast<LargeInteger*>(object);
 }
 
 // Inlined Double functions.
 
-fletch_double Double::value() {
-  return *reinterpret_cast<fletch_double*>(address() + kValueOffset);
+dartino_double Double::value() {
+  return *reinterpret_cast<dartino_double*>(address() + kValueOffset);
 }
 
-void Double::set_value(fletch_double value) {
-  *reinterpret_cast<fletch_double*>(address() + kValueOffset) = value;
+void Double::set_value(dartino_double value) {
+  *reinterpret_cast<dartino_double*>(address() + kValueOffset) = value;
 }
 
 Double* Double::cast(Object* object) {
   ASSERT(object->IsDouble());
   return reinterpret_cast<Double*>(object);
 }
 
 // Inlined Boxed functions.
 
 Object* Boxed::value() { return at(kValueOffset); }
@@ skipping 127 matching lines @@
 inline bool Coroutine::has_caller() { return !at(kCallerOffset)->IsNull(); }
 
 inline Coroutine* Coroutine::caller() {
   return Coroutine::cast(at(kCallerOffset));
 }
 
 inline void Coroutine::set_caller(Coroutine* value) {
   at_put(kCallerOffset, value);
 }
 
-}  // namespace fletch
+}  // namespace dartino
 
 #endif  // SRC_VM_OBJECT_H_