Rename fletch -> dartino

src/vm/natives.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/natives.h"
 
 #include <errno.h>
 #include <math.h>
 #include <stdlib.h>
 
 #include "src/shared/bytecodes.h"
 #include "src/shared/flags.h"
 #include "src/shared/names.h"
 #include "src/shared/selectors.h"
 #include "src/shared/platform.h"
 
 #include "src/vm/event_handler.h"
 #include "src/vm/interpreter.h"
 #include "src/vm/native_interpreter.h"
 #include "src/vm/port.h"
 #include "src/vm/process.h"
 #include "src/vm/scheduler.h"
 #include "src/vm/session.h"
 
 #include "third_party/double-conversion/src/double-conversion.h"
 
-namespace fletch {
+namespace dartino {
 
 static const char kDoubleExponentChar = 'e';
 static const char* kDoubleInfinitySymbol = "Infinity";
 static const char* kDoubleNaNSymbol = "NaN";
 
 static Object* ToBool(Process* process, bool value) {
   Program* program = process->program();
   return value ? program->true_object() : program->false_object();
 }
 
@@ skipping 476 matching lines @@
 BEGIN_NATIVE(DoubleNegate) {
   Double* x = Double::cast(arguments[0]);
   return process->NewDouble(-x->value());
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleAdd) {
   Double* x = Double::cast(arguments[0]);
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double y_value = Double::cast(y)->value();
   return process->NewDouble(x->value() + y_value);
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleSub) {
   Double* x = Double::cast(arguments[0]);
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double y_value = Double::cast(y)->value();
   return process->NewDouble(x->value() - y_value);
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleMul) {
   Double* x = Double::cast(arguments[0]);
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double y_value = Double::cast(y)->value();
   return process->NewDouble(x->value() * y_value);
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleMod) {
   Double* x = Double::cast(arguments[0]);
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double y_value = Double::cast(y)->value();
   return process->NewDouble(fmod(x->value(), y_value));
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleDiv) {
   Double* x = Double::cast(arguments[0]);
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double y_value = Double::cast(y)->value();
   return process->NewDouble(x->value() / y_value);
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleTruncDiv) {
   Double* x = Double::cast(arguments[0]);
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double y_value = Double::cast(y)->value();
   if (y_value == 0) return Failure::index_out_of_bounds();
   return process->NewInteger(static_cast<int64>(x->value() / y_value));
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleEqual) {
   Double* x = Double::cast(arguments[0]);
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double y_value = Double::cast(y)->value();
   return ToBool(process, x->value() == y_value);
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleLess) {
   Double* x = Double::cast(arguments[0]);
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double y_value = Double::cast(y)->value();
   return ToBool(process, x->value() < y_value);
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleLessEqual) {
   Double* x = Double::cast(arguments[0]);
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double y_value = Double::cast(y)->value();
   return ToBool(process, x->value() <= y_value);
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleGreater) {
   Double* x = Double::cast(arguments[0]);
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double y_value = Double::cast(y)->value();
   return ToBool(process, x->value() > y_value);
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleGreaterEqual) {
   Double* x = Double::cast(arguments[0]);
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double y_value = Double::cast(y)->value();
   return ToBool(process, x->value() >= y_value);
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleIsNaN) {
-  fletch_double d = Double::cast(arguments[0])->value();
+  dartino_double d = Double::cast(arguments[0])->value();
   return ToBool(process, isnan(static_cast<double>(d)));
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoubleIsNegative) {
   // TODO(ajohnsen): Okay to always use double version?
   double d = static_cast<double>(Double::cast(arguments[0])->value());
   return ToBool(process, (signbit(d) != 0) && !isnan(d));
 }
 END_NATIVE()
@@ skipping 211 matching lines @@
   // The string is trimmed, so we must accept the full string.
   if (consumed != length) return Failure::index_out_of_bounds();
   return process->NewDouble(result);
 }
 END_NATIVE()
 
 #define DOUBLE_MATH_NATIVE(name, method)                       \
   BEGIN_NATIVE(name) {                                         \
     Object* x = arguments[0];                                  \
     if (!x->IsDouble()) return Failure::wrong_argument_type(); \
-    fletch_double d = Double::cast(x)->value();                \
+    dartino_double d = Double::cast(x)->value();                \
     return process->NewDouble(method(d));                      \
   }                                                            \
   END_NATIVE()
 
 DOUBLE_MATH_NATIVE(DoubleSin, sin)
 DOUBLE_MATH_NATIVE(DoubleCos, cos)
 DOUBLE_MATH_NATIVE(DoubleTan, tan)
 DOUBLE_MATH_NATIVE(DoubleAcos, acos)
 DOUBLE_MATH_NATIVE(DoubleAsin, asin)
 DOUBLE_MATH_NATIVE(DoubleAtan, atan)
 DOUBLE_MATH_NATIVE(DoubleSqrt, sqrt)
 DOUBLE_MATH_NATIVE(DoubleExp, exp)
 DOUBLE_MATH_NATIVE(DoubleLog, log)
 
 BEGIN_NATIVE(DoubleAtan2) {
   Object* x = arguments[0];
   if (!x->IsDouble()) return Failure::wrong_argument_type();
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double x_value = Double::cast(x)->value();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double x_value = Double::cast(x)->value();
+  dartino_double y_value = Double::cast(y)->value();
   return process->NewDouble(atan2(x_value, y_value));
 }
 END_NATIVE()
 
 BEGIN_NATIVE(DoublePow) {
   Object* x = arguments[0];
   if (!x->IsDouble()) return Failure::wrong_argument_type();
   Object* y = arguments[1];
   if (!y->IsDouble()) return Failure::wrong_argument_type();
-  fletch_double x_value = Double::cast(x)->value();
-  fletch_double y_value = Double::cast(y)->value();
+  dartino_double x_value = Double::cast(x)->value();
+  dartino_double y_value = Double::cast(y)->value();
   return process->NewDouble(pow(x_value, y_value));
 }
 END_NATIVE()
 
 BEGIN_NATIVE(ListNew) {
   Object* x = arguments[0];
   if (!x->IsSmi()) return Failure::wrong_argument_type();
   int length = Smi::cast(arguments[0])->value();
   if (length < 0) return Failure::index_out_of_bounds();
   return process->NewArray(length);
@@ skipping 229 matching lines @@
 
 BEGIN_NATIVE(IdentityHashCode) {
   Object* object = arguments[0];
   if (object->IsOneByteString()) {
     return Smi::FromWord(OneByteString::cast(object)->Hash());
   } else if (object->IsTwoByteString()) {
     return Smi::FromWord(TwoByteString::cast(object)->Hash());
   } else if (object->IsSmi() || object->IsLargeInteger()) {
     return object;
   } else if (object->IsDouble()) {
-    fletch_double value = Double::cast(object)->value();
+    dartino_double value = Double::cast(object)->value();
     return process->ToInteger(static_cast<int64>(value));
   } else {
     return Instance::cast(object)->LazyIdentityHashCode(process->random());
   }
 }
 END_NATIVE()
 
 char* AsForeignString(Object* object) {
   if (object->IsOneByteString()) {
     return OneByteString::cast(object)->ToCString();
@@ skipping 367 matching lines @@
 
 BEGIN_NATIVE(EventHandlerSleep) {
   int64 timeout =
       AsForeignInt64(arguments[0]) + Platform::GetMicroseconds() / 1000;
   Port* port = Port::FromDartObject(arguments[1]);
   EventHandler::GlobalInstance()->ScheduleTimeout(timeout, port);
   return process->program()->null_object();
 }
 END_NATIVE()
 
-}  // namespace fletch
+}  // namespace dartino