Rename fletch -> dartino

lib/dartino/dartino.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.fletch;
+library dart.dartino;
 
-import 'dart:fletch._system' as fletch;
+import 'dart:dartino._system' as dartino;
 
 /// Fibers are lightweight co-operative multitask units of execution. They
 /// are scheduled on top of OS-level threads, but they are cheap to create
 /// and block.
 class Fiber {
 
   // We keep track of the top of the coroutine stack and
   // the list of other fibers that are waiting for this
   // fiber to exit.
   Coroutine _coroutine;
@@ skipping 15 matching lines @@
   static Fiber _idleFibers;
 
   Fiber._initial() {
     _previous = this;
     _next = this;
   }
 
   Fiber._forked(entry) {
     current;  // Force initialization of fiber sub-system.
     _coroutine = new Coroutine((ignore) {
-      fletch.runToEnd(entry);
+      dartino.runToEnd(entry);
     });
   }
 
   static Fiber get current {
     var current = _current;
     if (current != null) return current;
     return _current = new Fiber._initial();
   }
 
   static Fiber fork(entry) {
     Fiber fiber = new Fiber._forked(entry);
     _markReady(fiber);
     return fiber;
   }
 
   static void yield() {
     // Handle messages so that fibers that are blocked on receiving
     // messages can wake up.
     Process._handleMessages();
     _current._coroutine = Coroutine._coroutineCurrent();
     _schedule(_current._next);
   }
 
   static void exit([value]) {
     // If we never created a fiber, we can just go ahead and halt now.
-    if (_current == null) fletch.halt();
+    if (_current == null) dartino.halt();
 
     _current._exit(value);
   }
 
   join() {
     // If the fiber is already done, we just return the result.
     if (_isDone) return _result;
 
     // Add the current fiber to the list of fibers waiting
     // to join [this] fiber.
@@ skipping 72 matching lines @@
     if (exiting) {
       fiber._next = null;
       fiber._previous = null;
     } else {
       _idleFibers = _link(fiber, _idleFibers);
     }
 
     if (current != null) return current;
 
     // If we don't have any idle fibers, halt.
-    if (exiting && _idleFibers == null) fletch.halt();
+    if (exiting && _idleFibers == null) dartino.halt();
 
     while (true) {
       Process._handleMessages();
       // A call to _handleMessages can handle more messages than signaled, so
       // we can get a following false-positive wakeup. If no new _current is
       // set, simply yield again.
       current = _current;
       if (current != null) return current;
-      fletch.yield(fletch.InterruptKind.yield.index);
+      dartino.yield(dartino.InterruptKind.yield.index);
     }
   }
 
   static void _yieldTo(Fiber from, Fiber to) {
     from._coroutine = Coroutine._coroutineCurrent();
     _schedule(to);
   }
 
   // TODO(kasperl): This is temporary debugging support. We
   // should probably replace this support for passing in an
   // id of some sort when forking a fiber.
   static int _count = 0;
   int _index = _count++;
   toString() => "fiber:$_index";
 
   static void _schedule(Fiber to) {
     _current = to;
-    fletch.coroutineChange(to._coroutine, null);
+    dartino.coroutineChange(to._coroutine, null);
   }
 }
 
 class Coroutine {
 
   // TODO(kasperl): The VM has assumptions about the layout
   // of coroutine fields. We should validate that the code
   // agrees with those assumptions.
   var _stack;
   var _caller;
 
   Coroutine(entry) {
     _stack = _coroutineNewStack(this, entry);
   }
 
   bool get isSuspended => identical(_caller, null);
   bool get isRunning => !isSuspended && !isDone;
   bool get isDone => identical(_caller, this);
 
   call(argument) {
     if (!isSuspended) throw "Cannot call non-suspended coroutine";
     _caller = _coroutineCurrent();
-    var result = fletch.coroutineChange(this, argument);
+    var result = dartino.coroutineChange(this, argument);
 
     // If the called coroutine is done now, we clear the
     // stack reference in it so the memory can be reclaimed.
     if (isDone) {
       _stack = null;
     } else {
       _caller = null;
     }
     return result;
   }
 
   static yield(value) {
     Coroutine caller = _coroutineCurrent()._caller;
     if (caller == null) throw "Cannot yield outside coroutine";
-    return fletch.coroutineChange(caller, value);
+    return dartino.coroutineChange(caller, value);
   }
 
   _coroutineStart(entry) {
     // The first call to changeStack is actually skipped but we need
     // it to make sure the newly started coroutine is suspended in
     // exactly the same way as we do when yielding.
-    var argument = fletch.coroutineChange(0, 0);
+    var argument = dartino.coroutineChange(0, 0);
     var result = entry(argument);
 
     // Mark this coroutine as done and change back to the caller.
     Coroutine caller = _caller;
     _caller = this;
-    fletch.coroutineChange(caller, result);
+    dartino.coroutineChange(caller, result);
   }
 
-  @fletch.native external static _coroutineCurrent();
-  @fletch.native external static _coroutineNewStack(coroutine, entry);
+  @dartino.native external static _coroutineCurrent();
+  @dartino.native external static _coroutineNewStack(coroutine, entry);
 }
 
 class ProcessDeath {
   final Process process;
   final int _reason;
 
   ProcessDeath._(this.process, this._reason);
 
   DeathReason get reason => DeathReason.values[_reason];
 }
@@ skipping 12 matching lines @@
   final int _nativeProcessHandle;
 
   bool operator==(other) {
     return
         other is Process &&
         other._nativeProcessHandle == _nativeProcessHandle;
   }
 
   int get hashCode => _nativeProcessHandle.hashCode;
 
-  @fletch.native bool link() {
-    throw fletch.nativeError;
+  @dartino.native bool link() {
+    throw dartino.nativeError;
   }
 
-  @fletch.native void unlink() {
-    switch (fletch.nativeError) {
-      case fletch.wrongArgumentType:
+  @dartino.native void unlink() {
+    switch (dartino.nativeError) {
+      case dartino.wrongArgumentType:
         throw new StateError("Cannot unlink from parent process.");
       default:
-        throw fletch.nativeError;
+        throw dartino.nativeError;
     }
   }
 
-  @fletch.native bool monitor(Port port) {
-    switch (fletch.nativeError) {
-      case fletch.wrongArgumentType:
+  @dartino.native bool monitor(Port port) {
+    switch (dartino.nativeError) {
+      case dartino.wrongArgumentType:
         throw new StateError("The argument to monitor must be a Port object.");
       default:
-        throw fletch.nativeError;
+        throw dartino.nativeError;
     }
   }
 
-  @fletch.native void unmonitor(Port port) {
-    switch (fletch.nativeError) {
-      case fletch.wrongArgumentType:
+  @dartino.native void unmonitor(Port port) {
+    switch (dartino.nativeError) {
+      case dartino.wrongArgumentType:
         throw new StateError(
             "The argument to unmonitor must be a Port object.");
       default:
-        throw fletch.nativeError;
+        throw dartino.nativeError;
     }
   }
 
-  @fletch.native void kill() {
-    throw fletch.nativeError;
+  @dartino.native void kill() {
+    throw dartino.nativeError;
   }
 
   static Process spawn(Function fn, [argument]) {
     if (!isImmutable(fn)) {
       throw new ArgumentError(
           'The closure passed to Process.spawn() must be immutable.');
     }
 
     if (!isImmutable(argument)) {
       throw new ArgumentError(
@@ skipping 67 matching lines @@
 
   /**
    * Exit the current process. If a non-null [to] port is provided,
    * the process will send the provided [value] to the [to] port as
    * its final action.
    */
   static void exit({value, Port to}) {
     try {
       if (to != null) to._sendExit(value);
     } finally {
-      fletch.yield(fletch.InterruptKind.terminate.index);
+      dartino.yield(dartino.InterruptKind.terminate.index);
     }
   }
 
   // Low-level entry for spawned processes.
   static void _entry(fn, argument) {
     if (argument == null) {
-      fletch.runToEnd(fn);
+      dartino.runToEnd(fn);
     } else {
-      fletch.runToEnd(() => fn(argument));
+      dartino.runToEnd(() => fn(argument));
     }
   }
 
   // Low-level helper function for spawning.
-  @fletch.native static Process _spawn(Function entry,
+  @dartino.native static Process _spawn(Function entry,
                                        Function fn,
                                        argument,
                                        bool linkToChild,
                                        bool linkFromChild,
                                        Port monitor) {
     throw new ArgumentError();
   }
 
   static void _handleMessages() {
     Channel channel;
     while ((channel = _queueGetChannel()) != null) {
       var message = _queueGetMessage();
       if (message is ProcessDeath) {
         message = _queueSetupProcessDeath(message);
       }
       channel.send(message);
     }
   }
 
-  @fletch.native external static Process get current;
-  @fletch.native external static _queueGetMessage();
-  @fletch.native external static _queueSetupProcessDeath(ProcessDeath message);
-  @fletch.native external static Channel _queueGetChannel();
+  @dartino.native external static Process get current;
+  @dartino.native external static _queueGetMessage();
+  @dartino.native external static _queueSetupProcessDeath(ProcessDeath message);
+  @dartino.native external static Channel _queueGetChannel();
 }
 
 // Ports allow you to send messages to a channel. Ports are
 // are transferable and can be sent between processes.
 class Port {
   // A Smi stores the aligned pointer to the C++ port object.
   final int _port;
 
   factory Port(Channel channel) {
     return Port._create(channel);
   }
 
   // TODO(kasperl): Temporary debugging aid.
   int get id => _port;
 
   // Send a message to the channel. Not blocking.
-  @fletch.native void send(message) {
-    switch (fletch.nativeError) {
-      case fletch.wrongArgumentType:
+  @dartino.native void send(message) {
+    switch (dartino.nativeError) {
+      case dartino.wrongArgumentType:
         throw new ArgumentError();
-      case fletch.illegalState:
+      case dartino.illegalState:
         throw new StateError("Port is closed.");
       default:
-        throw fletch.nativeError;
+        throw dartino.nativeError;
     }
   }
 
-  @fletch.native void _sendExit(value) {
+  @dartino.native void _sendExit(value) {
     throw new StateError("Port is closed.");
   }
 
-  @fletch.native external static Port _create(Channel channel);
+  @dartino.native external static Port _create(Channel channel);
 }
 
 class Channel {
   Fiber _receiver;  // TODO(kasperl): Should this be a queue too?
 
   // TODO(kasperl): Maybe make this a bit smarter and store
   // the elements in a growable list? Consider allowing bounds
   // on the queue size.
   _ChannelEntry _head;
   _ChannelEntry _tail;
@@ skipping 58 matching lines @@
 
 class _ChannelEntry {
   final message;
   final Fiber sender;
   _ChannelEntry next;
   _ChannelEntry(this.message, this.sender);
 }
 
 bool isImmutable(Object object) => _isImmutable(object);
 
-@fletch.native external bool _isImmutable(String string);
+@dartino.native external bool _isImmutable(String string);
 
 /// Returns a channel that will receive a message in [milliseconds]
 /// milliseconds.
 // TODO(sigurdm): Move this function?
 Channel sleep(int milliseconds) {
   if (milliseconds is! int) throw new ArgumentError(milliseconds);
   Channel channel = new Channel();
   Port port = new Port(channel);
   _sleep(milliseconds, port);
   return channel;
 }
 
-@fletch.native external void _sleep(int milliseconds, Port port);
+@dartino.native external void _sleep(int milliseconds, Port port);