Rename fletch -> dartino

src/shared/globals.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_GLOBALS_H_
 #define SRC_SHARED_GLOBALS_H_
 
 #ifndef __STDC_FORMAT_MACROS
 #define __STDC_FORMAT_MACROS
 #endif
 
 #ifndef __STDC_LIMIT_MACROS
 #define __STDC_LIMIT_MACROS
 #endif
 
 #include <inttypes.h>
 #include <limits.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <string.h>
 
 // Types for native machine words. Guaranteed to be able to hold
 // pointers and integers.
-#if defined(FLETCH64) && defined(FLETCH_TARGET_OS_WIN)
+#if defined(DARTINO64) && defined(DARTINO_TARGET_OS_WIN)
 typedef long long word;            // NOLINT
 typedef unsigned long long uword;  // NOLINT
 #define WORD_C(n) n##LL
 #define UWORD_C(n) n##LL
 #else
 typedef long word;            // NOLINT
 typedef unsigned long uword;  // NOLINT
 #define WORD_C(n) n##L
 #define UWORD_C(n) n##UL
 #endif
 
 // Introduce integer types with specific bit widths.
 typedef signed char int8;
 typedef short int16;  // NOLINT
 typedef int int32;
 
 typedef unsigned char uint8;
 typedef unsigned short uint16;  // NOLINT
 typedef unsigned int uint32;
 
 // On Windows platforms, long is always 32 bit.
-#if defined(FLETCH64) && !defined(FLETCH_TARGET_OS_WIN)
+#if defined(DARTINO64) && !defined(DARTINO_TARGET_OS_WIN)
 typedef long int64;            // NOLINT
 typedef unsigned long uint64;  // NOLINT
 #else
 typedef long long int int64;        // NOLINT
 typedef long long unsigned uint64;  // NOLINT
 #endif
 
-#ifdef FLETCH_TARGET_OS_LK
-typedef float fletch_double;
-typedef uint32 fletch_double_as_uint;
+#ifdef DARTINO_TARGET_OS_LK
+typedef float dartino_double;
+typedef uint32 dartino_double_as_uint;
 #else
-typedef double fletch_double;
-typedef uint64 fletch_double_as_uint;
+typedef double dartino_double;
+typedef uint64 dartino_double_as_uint;
 #endif
 
 // Byte sizes.
 const int kWordSize = sizeof(word);
 const int kDoubleSize = sizeof(double);  // NOLINT
 const int kPointerSize = sizeof(void*);  // NOLINT
 
-#ifdef FLETCH64
+#ifdef DARTINO64
 const int kPointerSizeLog2 = 3;
 const int kAlternativePointerSize = 4;
 #else
 const int kPointerSizeLog2 = 2;
 const int kAlternativePointerSize = 8;
 #endif
 
 // Bit sizes.
 const int kBitsPerByte = 8;
 const int kBitsPerByteLog2 = 3;
@@ skipping 74 matching lines @@
   // here means your D and S have different sizes.
   char VerifySizesAreEqual[sizeof(D) == sizeof(S) ? 1 : -1];
   USE(VerifySizesAreEqual);
 
   D destination;
   memcpy(&destination, &source, sizeof(destination));
   return destination;
 }
 
 #ifdef __has_builtin
-#define FLETCH_HAS_BUILTIN_SADDL_OVERFLOW \
+#define DARTINO_HAS_BUILTIN_SADDL_OVERFLOW \
   (__has_builtin(__builtin_saddl_overflow))
-#define FLETCH_HAS_BUILTIN_SSUBL_OVERFLOW \
+#define DARTINO_HAS_BUILTIN_SSUBL_OVERFLOW \
   (__has_builtin(__builtin_ssubl_overflow))
-#define FLETCH_HAS_BUILTIN_SMULL_OVERFLOW \
+#define DARTINO_HAS_BUILTIN_SMULL_OVERFLOW \
   (__has_builtin(__builtin_smull_overflow))
 #endif
 
 #ifdef TEMP_FAILURE_RETRY
 #undef TEMP_FAILURE_RETRY
 #endif
 // The definition below is copied from Linux and adapted to avoid lint
 // errors (type long int changed to intptr_t and do/while split on
 // separate lines with body in {}s) and to also block signals.
 #define TEMP_FAILURE_RETRY(expression)               \
   ({                                                 \
     intptr_t __result;                               \
     do {                                             \
       __result = (expression);                       \
     } while ((__result == -1L) && (errno == EINTR)); \
     __result;                                        \
   })
 
 #define VOID_TEMP_FAILURE_RETRY(expression) \
   (static_cast<void>(TEMP_FAILURE_RETRY(expression)))
 
 #endif  // SRC_SHARED_GLOBALS_H_