Rename fletch -> dartino

src/shared/utils.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_SHARED_UTILS_H_
 #define SRC_SHARED_UTILS_H_
 
 #include "src/shared/assert.h"
 #include "src/shared/atomic.h"
 #include "src/shared/globals.h"
 
-namespace fletch {
+namespace dartino {
 
 class Mutex;
 
 class PrintInterceptor {
  public:
   PrintInterceptor() : next_(NULL) {}
   virtual ~PrintInterceptor() {
     delete next_;
     next_ = NULL;
   }
@@ skipping 79 matching lines @@
   static bool IsInt8(word value) { return (-128 <= value) && (value < 128); }
 
   static bool IsUint8(word value) { return (0 <= value) && (value < 256); }
 
   static bool IsInt16(word value) {
     return (-32768 <= value) && (value < 32768);
   }
 
   static bool IsUint16(word value) { return (0 <= value) && (value < 65536); }
 
-#ifdef FLETCH64
+#ifdef DARTINO64
   static bool IsInt32(word value) {
     return (-(WORD_C(1) << 31) <= value) && (value < (WORD_C(1) << 31));
   }
 
   static bool IsUint32(word value) {
     return (0 <= value) && (value < (WORD_C(1) << 32));
   }
 #endif
 
   static bool SignedAddOverflow(word lhs, word rhs, word* val) {
-#if FLETCH_HAS_BUILTIN_SADDL_OVERFLOW
+#if DARTINO_HAS_BUILTIN_SADDL_OVERFLOW
     return __builtin_saddl_overflow(lhs, rhs, val);
 #else
     uword res = static_cast<uword>(lhs) + static_cast<uword>(rhs);
     *val = bit_cast<uword>(res);
     word bit = (res ^ lhs) & (res ^ rhs) & (UWORD_C(1) << (kBitsPerWord - 1));
     return bit != 0;
 #endif
   }
 
   static bool SignedSubOverflow(word lhs, word rhs, word* val) {
-#if FLETCH_HAS_BUILTIN_SSUBL_OVERFLOW
+#if DARTINO_HAS_BUILTIN_SSUBL_OVERFLOW
     return __builtin_ssubl_overflow(lhs, rhs, val);
 #else
     uword res = static_cast<uword>(lhs) - static_cast<uword>(rhs);
     *val = bit_cast<word>(res);
     uword bit = (res ^ lhs) & (res ^ ~rhs) & (UWORD_C(1) << (kBitsPerWord - 1));
     return bit != 0;
 #endif
   }
 
   static int HighestBit(int64 v) {
@@ skipping 28 matching lines @@
     // Flip bits if negative (-1 becomes 0).
     value ^= value >> 63;
     return (value == 0) ? 0 : (Utils::HighestBit(value) + 1);
   }
 
   static bool Signed64BitMulMightOverflow(int64 lhs, int64 rhs) {
     return (Utils::HighestBit(lhs) + Utils::HighestBit(rhs)) >= 62;
   }
 
   static bool SignedMulOverflow(word lhs, word rhs, word* val) {
-#if FLETCH_HAS_BUILTIN_SMULL_OVERFLOW
+#if DARTINO_HAS_BUILTIN_SMULL_OVERFLOW
     return __builtin_smull_overflow(lhs, rhs, val);
 #else
-#ifdef FLETCH64
+#ifdef DARTINO64
     if (Signed64BitMulMightOverflow(lhs, rhs)) return true;
     *val = lhs * rhs;
     return false;
 #else
     word res = lhs * rhs;
     bool overflow = (res != static_cast<int64>(lhs) * rhs);
     if (overflow) return true;
     *val = res;
     return false;
-#endif  // FLETCH64
-#endif  // FLETCH_HAS_BUILTIN_SMULL_OVERFLOW
+#endif  // DARTINO64
+#endif  // DARTINO_HAS_BUILTIN_SMULL_OVERFLOW
   }
 
   // Read a 32-bit integer from the buffer, as little endian.
   static inline int32 ReadInt32(uint8* buffer) {
     return reinterpret_cast<int32*>(buffer)[0];
   }
 
   // Write a 32-bit integer to the buffer, as little endian.
   static inline void WriteInt32(uint8* buffer, int32 value) {
     reinterpret_cast<int32*>(buffer)[0] = value;
@@ skipping 65 matching lines @@
 
   // Returns a uword with the bool field value encoded based on the
   // original value. Only the single bit corresponding to this bool
   // field will be changed.
   static uword update(bool value, uword original) {
     const uword mask = 1U << position;
     return value ? original | mask : original & ~mask;
   }
 };
 
-}  // namespace fletch
+}  // namespace dartino
 
 #endif  // SRC_SHARED_UTILS_H_