Rename fletch -> dartino

lib/core/core_patch.dart

 // Copyright (c) 2015, 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.
 
 library dart.core_patch;
 
-import 'dart:fletch._system' as fletch;
-import 'dart:fletch._system' show patch;
+import 'dart:dartino._system' as dartino;
+import 'dart:dartino._system' show patch;
 import 'dart:collection' show LinkedHashMap, UnmodifiableMapView;
 
 part 'bigint.dart';
 part 'case.dart';
 part 'double.dart';
 part 'int.dart';
 part 'regexp.dart';
 part 'string.dart';
 
 @patch external bool identical(Object a, Object b);
 
 @patch int identityHashCode(Object object) {
   if (object is int) return object;
   return _identityHashCode(object);
 }
 
-@fletch.native external _identityHashCode(Object object);
+@dartino.native external _identityHashCode(Object object);
 
 @patch class Object {
   @patch String toString() => '[object Object]';
 
   @patch int get hashCode => _identityHashCode(this);
 
   @patch noSuchMethod(Invocation invocation) {
-    if (invocation is fletch.FletchInvocation) {
+    if (invocation is dartino.DartinoInvocation) {
       throw invocation.asNoSuchMethodError;
     }
     // TODO(ahe): Get rid of this call.
-    fletch.unresolved("<unknown>");
+    dartino.unresolved("<unknown>");
   }
 
   // The noSuchMethod helper is automatically called from the
   // trampoline and it is passed the selector. The arguments
   // to the original call are still present on the stack, so
   // it is possible to dig them out if need be.
   _noSuchMethod(receiver, receiverClass, receiverSelector) {
     // NOTE: The number and type of arguments here must be kept in sync with:
     //     src/vm/interpreter.cc:HandleEnterNoSuchMethod
-    return noSuchMethod(new fletch.FletchInvocation(
+    return noSuchMethod(new dartino.DartinoInvocation(
         receiver, receiverClass, receiverSelector));
   }
 
   // The noSuchMethod trampoline is automatically generated
   // by the compiler. It calls the noSuchMethod helper and
   // takes care off removing an arbitrary number of arguments
   // from the caller stack before it returns.
   external _noSuchMethodTrampoline();
 }
 
@@ skipping 123 matching lines @@
     }
     return '[object Object]';
   }
 
   @patch StackTrace get stackTrace {
     throw "getter stackTrace is unimplemented";
   }
 }
 
 @patch class Stopwatch {
-  @patch @fletch.native external static int _now();
+  @patch @dartino.native external static int _now();
 
   @patch static int _initTicker() {
-    _frequency = _fletchNative_frequency();
+    _frequency = _dartinoNative_frequency();
   }
 
-  @fletch.native external static int _fletchNative_frequency();
+  @dartino.native external static int _dartinoNative_frequency();
 }
 
 @patch class RegExp {
   @patch factory RegExp(String source, {bool multiLine: false,
                                         bool caseSensitive: true}) {
     return new _MiniExp(source, multiLine, caseSensitive);
   }
 }
 
 @patch class List {
   @patch factory List([int length]) {
-    return fletch.newList(length);
+    return dartino.newList(length);
   }
 
   @patch factory List.filled(int length, E fill) {
     // All error handling on the length parameter is done at the implementation
     // of new _List.
-    var result = fletch.newList(length);
+    var result = dartino.newList(length);
     if (fill != null) {
       for (int i = 0; i < length; i++) {
         result[i] = fill;
       }
     }
     return result;
   }
 
   @patch factory List.from(Iterable elements, {bool growable: true}) {
     // TODO(ajohnsen): elements.length can be slow if not a List. Consider
     // fast-path non-list & growable, and create internal helper for non-list &
     // non-growable.
     int length = elements.length;
     var list;
     if (growable) {
-      list = fletch.newList(null);
+      list = dartino.newList(null);
       list.length = length;
     } else {
-      list = fletch.newList(length);
+      list = dartino.newList(length);
     }
     if (elements is List) {
       for (int i = 0; i < length; i++) {
         list[i] = elements[i];
       }
     } else {
       int i = 0;
       elements.forEach((e) { list[i++] = e; });
     }
     return list;
@@ skipping 42 matching lines @@
           source.startsWith('+0x')) {
         if (onError != null) return onError(source);
         throw new FormatException("Can't parse string as integer", source);
       }
     } else {
       if (radix < 2 || radix > 36) throw new ArgumentError(radix);
     }
     return _parse(source, radix, onError);
   }
 
-  @fletch.native static int _parse(
+  @dartino.native static int _parse(
       String source,
       int radix,
       int onError(String source)) {
-    switch (fletch.nativeError) {
-      case fletch.wrongArgumentType:
+    switch (dartino.nativeError) {
+      case dartino.wrongArgumentType:
         throw new ArgumentError(source);
-      case fletch.indexOutOfBounds:
+      case dartino.indexOutOfBounds:
         if (onError != null) return onError(source);
         throw new FormatException("Can't parse string as integer", source);
     }
   }
 
   @patch factory int.fromEnvironment(
       String name,
       {int defaultValue}) => defaultValue;
 }
 
 @patch class double {
   @patch static double parse(String source, [double onError(String source)]) {
     return _parse(source.trim(), onError);
   }
 
-  @fletch.native static double _parse(
+  @dartino.native static double _parse(
       String source,
       double onError(String source)) {
-    switch (fletch.nativeError) {
-      case fletch.wrongArgumentType:
+    switch (dartino.nativeError) {
+      case dartino.wrongArgumentType:
         throw new ArgumentError(source);
-      case fletch.indexOutOfBounds:
+      case dartino.indexOutOfBounds:
         if (onError != null) return onError(source);
         throw new FormatException("Can't parse string as double", source);
     }
   }
 }
 
 @patch class DateTime {
   static const _MILLISECOND_INDEX = 0;
   static const _SECOND_INDEX = 1;
   static const _MINUTE_INDEX = 2;
@@ skipping 313 matching lines @@
   static int _timeZoneOffsetInSeconds(int millisecondsSinceEpoch) {
     int equivalentSeconds = _equivalentSeconds(millisecondsSinceEpoch);
     return _timeZoneOffset(equivalentSeconds);
   }
 
   static String _timeZoneName(int millisecondsSinceEpoch) {
     int equivalentSeconds = _equivalentSeconds(millisecondsSinceEpoch);
     return _timeZone(equivalentSeconds);
   }
 
-  @fletch.native external static int _getCurrentMs();
+  @dartino.native external static int _getCurrentMs();
 
-  @fletch.native external static String _timeZone(int clampedSecondsSinceEpoch);
+  @dartino.native external static String _timeZone(int clampedSecondsSinceEpoch);
 
-  @fletch.native external static int _timeZoneOffset(
+  @dartino.native external static int _timeZoneOffset(
       int clampedSecondsSinceEpoch);
 
-  @fletch.native external static int _localTimeZoneOffset();
+  @dartino.native external static int _localTimeZoneOffset();
 }
 
 @patch class Uri {
   @patch static Uri get base {
     return new Uri.file(_base());
   }
 
   @patch static bool get _isWindows => false;
 
-  @fletch.native static String _base() {
+  @dartino.native static String _base() {
     throw new RangeError("The Uri.base path is too large");
   }
 
   /// Encodes all characters in the string [text] except for those
   /// that appear in [canonicalTable], and returns the escaped string.
   @patch static String _uriEncode(
       List<int> canonicalTable,
       String text,
       Encoding encoding,
       bool spaceToPlus) {
@@ skipping 15 matching lines @@
       } else if (spaceToPlus && byte == _SPACE) {
         result.writeCharCode(_PLUS);
       } else {
         result.writeCharCode(_PERCENT);
         byteToHex(byte, result);
       }
     }
     return result.toString();
   }
 }