Rename fletch -> dartino

pkg/dartino_compiler/lib/src/hub/hub_main.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 fletchc.hub_main;
+library dartino_compiler.hub_main;
 
 import 'dart:collection' show
     Queue;
 
 import 'dart:io' hide
     exitCode,
     stderr,
     stdin,
     stdout;
 
@@ skipping 110 matching lines @@
       int length = view.getUint32(offset, commandEndianness);
       offset += 4;
       argv.add(UTF8.decode(toUint8ListView(view, offset, length)));
       offset += length;
     }
     return argv;
   }
 }
 
 // Class for sending client commands from the hub (main isolate) to the
-// fletch c++ client.
+// dartino c++ client.
 class ClientCommandSender extends CommandSender {
   final Sink<List<int>> sink;
 
   ClientCommandSender(this.sink);
 
   void sendExitCode(int exitCode) {
     new CommandBuffer<ClientCommandCode>()
         ..addUint32(exitCode)
         ..sendOn(sink, ClientCommandCode.ExitCode);
   }
 
   void sendDataCommand(ClientCommandCode code, List<int> data) {
     new CommandBuffer<ClientCommandCode>()
         ..addUint32(data.length)
         ..addUint8List(data)
         ..sendOn(sink, code);
   }
 
   void sendClose() {
     throwInternalError("Client (C++) doesn't support ClientCommandCode.Close.");
   }
 
   void sendEventLoopStarted() {
     throwInternalError(
         "Client (C++) doesn't support ClientCommandCode.EventLoopStarted.");
   }
 }
 
 Future main(List<String> arguments) async {
-  // When running this program, -Dfletch.version must be provided on the Dart
+  // When running this program, -Ddartino.version must be provided on the Dart
   // VM command line.
-  assert(const String.fromEnvironment('fletch.version') != null);
+  assert(const String.fromEnvironment('dartino.version') != null);
 
   mainArguments.addAll(arguments);
   configFileUri = Uri.base.resolve(arguments.first);
   File configFile = new File.fromUri(configFileUri);
-  Directory tmpdir = Directory.systemTemp.createTempSync("fletch_client");
+  Directory tmpdir = Directory.systemTemp.createTempSync("dartino_client");
 
   File socketFile = new File("${tmpdir.path}/socket");
   try {
     socketFile.deleteSync();
   } on FileSystemException catch (e) {
     // Ignored. There's no way to check if a socket file exists.
   }
 
   ServerSocket server;
 
@@ skipping 143 matching lines @@
     }
     session.hasActiveWorkerTask = true;
     return session.worker.performTask(
         combineTasks(initializer, task), clientConnection, userSession: session)
         .whenComplete(() {
           session.hasActiveWorkerTask = false;
         });
   }
 }
 
-/// Handles communication with the Fletch C++ client.
+/// Handles communication with the Dartino C++ client.
 class ClientConnection {
-  /// Socket used for receiving and sending commands from/to the Fletch C++
+  /// Socket used for receiving and sending commands from/to the Dartino C++
   /// client.
   final Socket socket;
 
   /// Controller used to send commands to the from the ClientConnection to
   /// anyone listening on ClientConnection.commands (see [commands] below). The
   /// only listener as of now is the WorkerConnection which typically forwards
   /// the commands to the worker isolate.
   final StreamController<ClientCommand> controller =
       new StreamController<ClientCommand>();
 
   final ClientLogger log;
 
-  /// The commandSender is used to send commands back to the Fletch C++ client.
+  /// The commandSender is used to send commands back to the Dartino C++ client.
   ClientCommandSender commandSender;
 
   StreamSubscription<ClientCommand> subscription;
   Completer<Null> completer;
 
   Completer<List<String>> argumentsCompleter = new Completer<List<String>>();
 
   /// The analysed version of the request from the client.
   /// Updated by [parseArguments].
   AnalyzedSentence sentence;
 
-  /// Path to the fletch VM. Updated by [parseArguments].
-  String fletchVm;
+  /// Path to the dartino VM. Updated by [parseArguments].
+  String dartinoVm;
 
   ClientConnection(this.socket, this.log);
 
-  /// Stream of commands from the Fletch C++ client to the hub (main isolate).
+  /// Stream of commands from the Dartino C++ client to the hub (main isolate).
   /// The commands are typically forwarded to a worker isolate, see
   /// handleClientCommand.
   Stream<ClientCommand> get commands => controller.stream;
 
   /// Completes when [endSession] is called.
   Future<Null> get done => completer.future;
 
   /// Completes with the command-line arguments from the client.
   Future<List<String>> get arguments => argumentsCompleter.future;
 
   /// Start processing commands from the client.
   void start() {
     // Setup a command sender used to send responses from the hub (main isolate)
-    // back to the Fletch C++ client.
+    // back to the Dartino C++ client.
     commandSender = new ClientCommandSender(socket);
 
-    // Setup a listener for handling commands coming from the Fletch C++
+    // Setup a listener for handling commands coming from the Dartino C++
     // client.
     StreamTransformer<List<int>, ClientCommand> transformer =
         new ClientCommandTransformerBuilder().build();
     subscription = socket.transform(transformer).listen(null);
     subscription
         ..onData(handleClientCommand)
         ..onError(handleClientCommandError)
         ..onDone(handleClientCommandsDone);
     completer = new Completer<Null>();
   }
@@ skipping 22 matching lines @@
     // Cancel the subscription if an error occurred, this prevents
     // [handleCommandsDone] from being called and attempt to complete
     // [completer].
     subscription.cancel();
   }
 
   void handleClientCommandsDone() {
     completer.complete();
   }
 
-  // Send a command back to the Fletch C++ client.
+  // Send a command back to the Dartino C++ client.
   void sendCommandToClient(ClientCommand command) {
     switch (command.code) {
       case ClientCommandCode.Stdout:
         commandSender.sendStdoutBytes(command.data);
         break;
 
       case ClientCommandCode.Stderr:
         commandSender.sendStderrBytes(command.data);
         break;
 
@@ skipping 32 matching lines @@
       }
     }
     commandSender.sendExitCode(exitCode);
     endSession();
   }
 
   AnalyzedSentence parseArguments(List<String> arguments) {
     Options options = Options.parse(arguments);
     Sentence sentence =
         parseSentence(options.nonOptionArguments, includesProgramName: true);
-    // [programName] is the canonicalized absolute path to the fletch
+    // [programName] is the canonicalized absolute path to the dartino
     // executable (the C++ program).
     String programName = sentence.programName;
-    String fletchVm = "$programName-vm";
+    String dartinoVm = "$programName-vm";
     this.sentence = analyzeSentence(sentence, options);
-    this.fletchVm = fletchVm;
+    this.dartinoVm = dartinoVm;
     return this.sentence;
   }
 
   int reportErrorToClient(InputError error, StackTrace stackTrace) {
     bool isInternalError = error.kind == DiagnosticKind.internalError;
     if (isInternalError && !crashReportRequested) {
       printLineOnStderr(requestBugReportOnOtherCrashMessage);
       crashReportRequested = true;
     }
     printLineOnStderr(error.asDiagnostic().formatMessage());
@@ skipping 13 matching lines @@
   final ManagedIsolate isolate;
 
   /// A port used to send commands to the worker isolate.
   SendPort sendPort;
 
   /// A port used to read commands from the worker isolate.
   ReceivePort receivePort;
 
   /// workerCommands is an iterator over all the commands coming from the
   /// worker isolate. These are typically the outbound messages destined for
-  /// the Fletch C++ client.
+  /// the Dartino C++ client.
   /// It iterates over the data coming on the receivePort.
   StreamIterator<ClientCommand> workerCommands;
 
   /// When true, the worker can be shutdown by sending it a
   /// ClientCommandCode.Signal command.  Otherwise, it must be killed.
   bool eventLoopStarted = false;
 
   /// Subscription for errors from [isolate].
   StreamSubscription errorSubscription;
 
@@ skipping 17 matching lines @@
       // TODO(ahe): Add this assertion: assert(isolate.wasKilled);
       endSession();
       return;
     }
     ClientCommand command = workerCommands.current;
     assert(command.code == ClientCommandCode.SendPort);
     assert(command.data != null);
     sendPort = command.data;
   }
 
-  /// Attach to a fletch C++ client and forward commands to the worker isolate,
+  /// Attach to a dartino C++ client and forward commands to the worker isolate,
   /// and vice versa.  The returned future normally completes when the worker
   /// isolate sends ClientCommandCode.ClosePort, or if the isolate is killed due
   /// to ClientCommandCode.Signal arriving through client.commands.
   Future<int> attachClient(
       ClientConnection clientConnection,
       UserSession userSession) async {
 
     // Method for handling commands coming from the client. The commands are
     // typically forwarded to the worker isolate.
     handleCommandsFromClient(ClientCommand command) {
       if (command.code == ClientCommandCode.Signal && !eventLoopStarted) {
         if (userSession != null) {
           userSession.kill(clientConnection.printLineOnStderr);
         } else {
           isolate.kill();
         }
         receivePort.close();
       } else {
         sendPort.send([command.code.index, command.data]);
       }
     }
 
     // Method for handling commands coming back from the worker isolate.
-    // It typically forwards them to the Fletch C++ client via the
+    // It typically forwards them to the Dartino C++ client via the
     // clientConnection.
     Future<int> handleCommandsFromWorker(
         ClientConnection clientConnection) async {
       int exitCode = COMPILER_EXITCODE_CRASH;
       while (await workerCommands.moveNext()) {
         ClientCommand command = workerCommands.current;
         switch (command.code) {
           case ClientCommandCode.ClosePort:
             receivePort.close();
             break;
@@ skipping 29 matching lines @@
       }
       if (userSession != null) {
         userSession.kill(clientConnection.printLineOnStderr);
       } else {
         isolate.kill();
       }
       receivePort.close();
     });
     errorSubscription.resume();
 
-    // Start listening for commands coming from the Fletch C++ client (via
+    // Start listening for commands coming from the Dartino C++ client (via
     // clientConnection).
     // TODO(ahe): Add onDone event handler to detach the client.
     clientConnection.commands.listen(handleCommandsFromClient);
 
     // Start processing commands coming from the worker.
     int exitCode = await handleCommandsFromWorker(clientConnection);
 
     errorSubscription.pause();
     return exitCode;
   }
@@ skipping 32 matching lines @@
       log.error(error, stackTrace);
     }).then((_) {
       log.done();
     });
 
     // Indirectly send the task to be performed to the worker isolate via the
     // clientConnection.
     clientConnection.sendCommandToWorker(
         new ClientCommand(ClientCommandCode.PerformTask, task));
 
-    // Forward commands between the C++ fletch client [clientConnection], and the
+    // Forward commands between the C++ dartino client [clientConnection], and the

[Søren Gjesse, 2016/02/03 12:06:54]

Long line.

[ricow1, 2016/02/03 12:29:18]

Done.

     // worker isolate `this`.  Also, Intercept the signal command and
     // potentially kill the isolate (the isolate needs to tell if it is
     // interuptible or needs to be killed, an example of the latter is, if
     // compiler is running).
     int exitCode = await attachClient(clientConnection, userSession);
     // The verb (which was performed in the worker) is done.
     log.note("After attachClient (exitCode = $exitCode)");
 
     if (endSession) {
       // Return the isolate to the pool *before* shutting down the client. This
@@ skipping 152 matching lines @@
 
   void error(error, StackTrace stackTrace) {
     // TODO(ahe): Modify quit verb to report these errors.
     erroneousClients.add(this);
     note("Crash (${arguments.join(' ')}).\n"
          "${stringifyError(error, stackTrace)}");
   }
 
   String toString() => "$id";
 }