Add support for command-line editing to ddbg.

tools/ddbg.dart

 // Copyright (c) 2012, the Dart 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 file.
 
 // Simple interactive debugger shell that connects to the Dart VM's debugger
 // connection port.
 
 import "dart:convert";
 import "dart:io";
 import "dart:async";
 
+import "ddbg/lib/commando.dart";
+
 
 Map<int, Completer> outstandingCommands;
 
 Socket vmSock;
 String vmData;
-var stdinSubscription;
+Commando cmdo;
 var vmSubscription;
 int seqNum = 0;
 int isolate_id = -1;
 
+Process targetProcess;
+
 final verbose = false;
 final printMessages = false;
 
 // The location of the last paused event.
 Map pausedLocation = null;
 
 
 void printHelp() {
   print("""
   q   Quit debugger shell
@@ skipping 21 matching lines @@
   li List ids of all isolates in the VM
   i <id> Interrupt execution of given isolate id
   h   Print help
 """);
 }
 
 
 void quitShell() {
   vmSubscription.cancel();
   vmSock.close();
-  stdinSubscription.cancel();
+  cmdo.done();
 }
 
 
 Future sendCmd(Map<String, dynamic> cmd) {
   var completer = new Completer();
   int id = cmd["id"];
   outstandingCommands[id] = completer;
   if (verbose) {
     print("sending: '${JSON.encode(cmd)}'");
   }
   vmSock.write(JSON.encode(cmd));
   return completer.future;
 }
 
+
+typedef void HandlerType(Map response);
+
+HandlerType showPromptAfter(void handler(Map response)) {
+  // Hide the command prompt immediately.
+  return (response) {
+    handler(response);
+    cmdo.show();
+  };
+}
+
+
 void processCommand(String cmdLine) {
   
   void huh() {
     print("'$cmdLine' not understood, try h for help");
   }
 
   seqNum++;
+  cmdLine = cmdLine.trim();
   var args = cmdLine.split(' ');
   if (args.length == 0) {
     return;
   }
   var command = args[0];
   var simple_commands =
       { 'r':'resume', 's':'stepOver', 'si':'stepInto', 'so':'stepOut'};
   if (simple_commands[command] != null) {
     var cmd = { "id": seqNum,
                 "command": simple_commands[command],
                 "params": { "isolateId" : isolate_id } };
-    sendCmd(cmd).then((result) => handleGenericResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGenericResponse));
   } else if (command == "bt") {
     var cmd = { "id": seqNum,
                 "command": "getStackTrace",
                 "params": { "isolateId" : isolate_id } };
-    sendCmd(cmd).then((result) => handleStackTraceResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleStackTraceResponse));
   } else if (command == "ll") {
     var cmd = { "id": seqNum,
                 "command": "getLibraries",
                 "params": { "isolateId" : isolate_id } };
-    sendCmd(cmd).then((result) => handleGetLibraryResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGetLibraryResponse));
   } else if (command == "sbp" && args.length >= 2) {
     var url, line;
     if (args.length == 2 && pausedLocation != null) {
       url = pausedLocation["url"];
       assert(url != null);
       line = int.parse(args[1]);
     } else {
       url = args[1];
       line = int.parse(args[2]);
     }
     var cmd = { "id": seqNum,
                 "command": "setBreakpoint",
                 "params": { "isolateId" : isolate_id,
                             "url": url,
                             "line": line }};
-    sendCmd(cmd).then((result) => handleSetBpResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleSetBpResponse));
   } else if (command == "rbp" && args.length == 2) {
     var cmd = { "id": seqNum,
                 "command": "removeBreakpoint",
                 "params": { "isolateId" : isolate_id,
                             "breakpointId": int.parse(args[1]) } };
-    sendCmd(cmd).then((result) => handleGenericResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGenericResponse));
   } else if (command == "ls" && args.length == 2) {
     var cmd = { "id": seqNum,
                 "command": "getScriptURLs",
                 "params": { "isolateId" : isolate_id,
                             "libraryId": int.parse(args[1]) } };
-    sendCmd(cmd).then((result) => handleGetScriptsResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGetScriptsResponse));
   } else if (command == "eval" && args.length > 3) {
     var expr = args.getRange(3, args.length).join(" ");
     var target = args[1];
     if (target == "obj") {
       target = "objectId";
     } else if (target == "cls") {
       target = "classId";
     } else if (target == "lib") {
       target = "libraryId";
     } else {
       huh();
       return;
     }
     var cmd = { "id": seqNum,
                 "command": "evaluateExpr",
                 "params": { "isolateId": isolate_id,
                             target: int.parse(args[2]),
                             "expression": expr } };
-    sendCmd(cmd).then((result) => handleEvalResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleEvalResponse));
   } else if (command == "po" && args.length == 2) {
     var cmd = { "id": seqNum,
                 "command": "getObjectProperties",
                 "params": { "isolateId" : isolate_id,
                             "objectId": int.parse(args[1]) } };
-    sendCmd(cmd).then((result) => handleGetObjPropsResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGetObjPropsResponse));
   } else if (command == "pl" && args.length >= 3) {
-     var cmd;
-     if (args.length == 3) {
-       cmd = { "id": seqNum,
-               "command": "getListElements",
-               "params": { "isolateId" : isolate_id,
-                           "objectId": int.parse(args[1]),
-                           "index": int.parse(args[2]) } };
+    var cmd;
+    if (args.length == 3) {
+      cmd = { "id": seqNum,
+              "command": "getListElements",
+              "params": { "isolateId" : isolate_id,
+                          "objectId": int.parse(args[1]),
+                          "index": int.parse(args[2]) } };
     } else {
-       cmd = { "id": seqNum,
-               "command": "getListElements",
-               "params": { "isolateId" : isolate_id,
-                           "objectId": int.parse(args[1]),
-                           "index": int.parse(args[2]),
-                           "length": int.parse(args[3]) } };
+      cmd = { "id": seqNum,
+              "command": "getListElements",
+              "params": { "isolateId" : isolate_id,
+                          "objectId": int.parse(args[1]),
+                          "index": int.parse(args[2]),
+                          "length": int.parse(args[3]) } };
     }
-    sendCmd(cmd).then((result) => handleGetListResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGetListResponse));
   } else if (command == "pc" && args.length == 2) {
     var cmd = { "id": seqNum,
                 "command": "getClassProperties",
                 "params": { "isolateId" : isolate_id,
                             "classId": int.parse(args[1]) } };
-    sendCmd(cmd).then((result) => handleGetClassPropsResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGetClassPropsResponse));
   } else if (command == "plib" && args.length == 2) {
     var cmd = { "id": seqNum,
                 "command": "getLibraryProperties",
                 "params": {"isolateId" : isolate_id,
                            "libraryId": int.parse(args[1]) } };
-    sendCmd(cmd).then((result) => handleGetLibraryPropsResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGetLibraryPropsResponse));
   } else if (command == "slib" && args.length == 3) {
     var cmd = { "id": seqNum,
                 "command": "setLibraryProperties",
                 "params": {"isolateId" : isolate_id,
                            "libraryId": int.parse(args[1]),
                            "debuggingEnabled": args[2] } };
-    sendCmd(cmd).then((result) => handleSetLibraryPropsResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleSetLibraryPropsResponse));
   } else if (command == "pg" && args.length == 2) {
     var cmd = { "id": seqNum,
                 "command": "getGlobalVariables",
                 "params": { "isolateId" : isolate_id,
                             "libraryId": int.parse(args[1]) } };
-    sendCmd(cmd).then((result) => handleGetGlobalVarsResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGetGlobalVarsResponse));
   } else if (command == "gs" && args.length == 3) {
     var cmd = { "id": seqNum,
                 "command":  "getScriptSource",
                 "params": { "isolateId" : isolate_id,
                             "libraryId": int.parse(args[1]),
                             "url": args[2] } };
-    sendCmd(cmd).then((result) => handleGetSourceResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGetSourceResponse));
   } else if (command == "tok" && args.length == 3) {
     var cmd = { "id": seqNum,
                 "command":  "getLineNumberTable",
                 "params": { "isolateId" : isolate_id,
                             "libraryId": int.parse(args[1]),
                             "url": args[2] } };
-    sendCmd(cmd).then((result) => handleGetLineTableResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGetLineTableResponse));
   } else if (command == "epi" && args.length == 2) {
     var cmd = { "id": seqNum,
                 "command":  "setPauseOnException",
                 "params": { "isolateId" : isolate_id,
                             "exceptions": args[1] } };
-    sendCmd(cmd).then((result) => handleGenericResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGenericResponse));
   } else if (command == "li") {
     var cmd = { "id": seqNum, "command": "getIsolateIds" };
-    sendCmd(cmd).then((result) => handleGetIsolatesResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGetIsolatesResponse));
   } else if (command == "i" && args.length == 2) {
     var cmd = { "id": seqNum,
                 "command": "interrupt",
                 "params": { "isolateId": int.parse(args[1]) } };
-    sendCmd(cmd).then((result) => handleGenericResponse(result));
+    cmdo.hide();
+    sendCmd(cmd).then(showPromptAfter(handleGenericResponse));
   } else if (command == "q") {
     quitShell();
   } else if (command == "h") {
     printHelp();
   } else {
     huh();
   }
 }
 
 
@@ skipping 22 matching lines @@
 }
 
 
 printNamedObject(obj) {
   var name = obj["name"];
   var value = obj["value"];
   print("  $name = ${remoteObject(value)}");
 }
 
 
-handleGetObjPropsResponse(response) {
+handleGetObjPropsResponse(Map response) {
   Map props = response["result"];
   int class_id = props["classId"];
   if (class_id == -1) {
     print("  null");
     return;
   }
   List fields = props["fields"];
   print("  class id: $class_id");
   for (int i = 0; i < fields.length; i++) {
     printNamedObject(fields[i]);
   }
 }
 
-handleGetListResponse(response) {
+handleGetListResponse(Map response) {
   Map result = response["result"];
   if (result["elements"] != null) {
     // List slice.
     var index = result["index"];
     var length = result["length"];
     List elements = result["elements"];
     assert(length == elements.length);
     for (int i = 0; i < length; i++) {
       var kind = elements[i]["kind"];
       var text = elements[i]["text"];
       print("  ${index + i}: ($kind) $text");
     }
   } else {
     // One element, a remote object.
     print(result);
     print("  ${remoteObject(result)}");
   }
 }
 
 
-handleGetClassPropsResponse(response) {
+handleGetClassPropsResponse(Map response) {
   Map props = response["result"];
   assert(props["name"] != null);
   int libId = props["libraryId"];
   assert(libId != null);
   print("  class ${props["name"]} (library id: $libId)");
   List fields = props["fields"];
   if (fields.length > 0) {
     print("  static fields:");
     for (int i = 0; i < fields.length; i++) {
       printNamedObject(fields[i]);
     }
   }
 }
 
 
-handleGetLibraryPropsResponse(response) {
+handleGetLibraryPropsResponse(Map response) {
   Map props = response["result"];
   assert(props["url"] != null);
   print("  library url: ${props["url"]}");
   assert(props["debuggingEnabled"] != null);
   print("  debugging enabled: ${props["debuggingEnabled"]}");
   List imports = props["imports"];
   assert(imports != null);
   if (imports.length > 0) {
     print("  imports:");
     for (int i = 0; i < imports.length; i++) {
       print("    id ${imports[i]["libraryId"]} prefix ${imports[i]["prefix"]}");
     }
   }
   List globals = props["globals"];
   assert(globals != null);
   if (globals.length > 0) {
     print("  global variables:");
     for (int i = 0; i < globals.length; i++) {
       printNamedObject(globals[i]);
     }
   }
 }
 
 
-handleSetLibraryPropsResponse(response) {
+handleSetLibraryPropsResponse(Map response) {
   Map props = response["result"];
   assert(props["debuggingEnabled"] != null);
   print("  debugging enabled: ${props["debuggingEnabled"]}");
 }
 
 
-handleGetGlobalVarsResponse(response) {
+handleGetGlobalVarsResponse(Map response) {
   List globals = response["result"]["globals"];
   for (int i = 0; i < globals.length; i++) {
     printNamedObject(globals[i]);
   }
 }
 
 
-handleGetSourceResponse(response) {
+handleGetSourceResponse(Map response) {
   Map result = response["result"];
   String source = result["text"];
   print("Source text:\n$source\n--------");
 }
 
 
-handleGetLineTableResponse(response) {
+handleGetLineTableResponse(Map response) {
   Map result = response["result"];
   var info = result["lines"];
   print("Line info table:\n$info");
 }
 
 
-handleGetIsolatesResponse(response) {
+void handleGetIsolatesResponse(Map response) {
   Map result = response["result"];
   print("Isolates: ${result["isolateIds"]}");
 }
 
 
-void handleGetLibraryResponse(response) {
+void handleGetLibraryResponse(Map response) {
   Map result = response["result"];
   List libs = result["libraries"];
   print("Loaded libraries:");
   print(libs);
   for (int i = 0; i < libs.length; i++) {
     print("  ${libs[i]["id"]} ${libs[i]["url"]}");
   }
 }
 
 
-void handleGetScriptsResponse(response) {
+void handleGetScriptsResponse(Map response) {
   Map result = response["result"];
   List urls = result["urls"];
   print("Loaded scripts:");
   for (int i = 0; i < urls.length; i++) {
     print("  $i ${urls[i]}");
   }
 }
 
 
-void handleEvalResponse(response) {
+void handleEvalResponse(Map response) {
   Map result = response["result"];
   print(remoteObject(result));
 }
 
 
-void handleSetBpResponse(response) {
+void handleSetBpResponse(Map response) {
   Map result = response["result"];
   var id = result["breakpointId"];
   assert(id != null);
   print("Set BP $id");
 }
 
 
-void handleGenericResponse(response) {
+void handleGenericResponse(Map response) {
   if (response["error"] != null) {
     print("Error: ${response["error"]}");
   }
 }
 
 
-void handleStackTraceResponse(response) {
+void handleStackTraceResponse(Map response) {
   Map result = response["result"];
   List callFrames = result["callFrames"];
   assert(callFrames != null);
   printStackTrace(callFrames);
 }
 
 
 void printStackFrame(frame_num, Map frame) {
   var fname = frame["functionName"];
   var libId = frame["location"]["libraryId"];
@@ skipping 35 matching lines @@
 }
 
 
 void processVmMessage(String jsonString) {
   var msg = JSON.decode(jsonString);
   if (msg == null) {
     return;
   }
   var event = msg["event"];
   if (event == "paused") {
+    cmdo.hide();
     handlePausedEvent(msg);
+    cmdo.show();
     return;
   }
   if (event == "breakpointResolved") {
     Map params = msg["params"];
     assert(params != null);
+    cmdo.hide();
     print("BP ${params["breakpointId"]} resolved and "
           "set at line ${params["line"]}.");
+    cmdo.show();
     return;
   }
   if (event == "isolate") {
     Map params = msg["params"];
     assert(params != null);
+    cmdo.hide();
     print("Isolate ${params["id"]} has been ${params["reason"]}.");
+    cmdo.show();
     return;
   }
   if (msg["id"] != null) {
     var id = msg["id"];
     if (outstandingCommands.containsKey(id)) {
+      var completer = outstandingCommands.remove(id);
       if (msg["error"] != null) {
         print("VM says: ${msg["error"]}");
+        // TODO(turnidge): Rework how hide/show happens.  For now we
+        // show here explicitly.
+        cmdo.show();
       } else {
-        var completer = outstandingCommands[id];
         completer.complete(msg);
       }
-      outstandingCommands.remove(id);
     }
   }
 }
 
 bool haveGarbageVmData() {
   if (vmData == null || vmData.length == 0) return false;
   var i = 0, char = " ";
   while (i < vmData.length) {
     char = vmData[i];
     if (char != " " && char != "\n" && char != "\r" && char != "\t") break;
@@ skipping 84 matching lines @@
       nesting--;
       if (nesting == 0) return index;
     } else if (char == '"') {
       // Strings can contain braces. Skip their content.
       index = skipString(index);
     }
   }
   return 0;
 }
 
+List<String> debuggerCommandCompleter(List<String> commandParts) {
+  List<String> completions = new List<String>();
+
+  // TODO(turnidge): Have a global command table and use it to for
+  // help messages, command completion, and command dispatching.  For now
+  // we hardcode the list here.
+  //
+  // TODO(turnidge): Implement completion for arguments as well.
+  List<String> allCommands = ['q', 'bt', 'r', 's', 'so', 'si', 'sbp', 'rbp',
+                              'po', 'eval', 'pl', 'pc', 'll', 'plib', 'slib',
+                              'pg', 'ls', 'gs', 'tok', 'epi', 'li', 'i', 'h'];
+
+  // Completion of first word in the command.
+  if (commandParts.length == 1) {
+    String prefix = commandParts.last;
+    for (String command in allCommands) {
+      if (command.startsWith(prefix)) {
+        completions.add(command);
+      }
+    } 
+  }
+
+  return completions;
+}
 
 void debuggerMain() {
   outstandingCommands = new Map<int, Completer>();
   Socket.connect("127.0.0.1", 5858).then((s) {
     vmSock = s;
     vmSock.setOption(SocketOption.TCP_NODELAY, true);
     var stringStream = vmSock.transform(UTF8.decoder);
     vmSubscription = stringStream.listen(
         (String data) {
           processVmData(data);
         },
         onDone: () {
           print("VM debugger connection closed");
           quitShell();
         },
         onError: (err) {
           print("Error in debug connection: $err");
           // TODO(floitsch): do we want to print the stack trace?
           quitShell();
         });
-    stdinSubscription = stdin.transform(UTF8.decoder)
-                             .transform(new LineSplitter())
-                             .listen((String line) => processCommand(line));
+    cmdo = new Commando(stdin, stdout, processCommand,
+                        completer : debuggerCommandCompleter);
   });
 }
 
-void main(List<String> arguments) {
-  if (arguments.length > 0) {
-    arguments = <String>['--debug', '--verbose_debug']..addAll(arguments);
-    Process.start(Platform.executable, arguments).then((Process process) {
-      process.stdin.close();
-      process.exitCode.then((int exitCode) {
-        print('${arguments.join(" ")} exited with $exitCode');
-      });
+void main(List<String> args) {
+  if (args.length > 0) {
+    if (verbose) {
+      args = <String>['--debug', '--verbose_debug']..addAll(args);
+    } else {
+      args = <String>['--debug']..addAll(args);
+    }
+    Process.start(Platform.executable, args).then((Process process) {
+        targetProcess = process;
+        process.stdin.close();
+
+        // TODO(turnidge): For now we only show full lines of output
+        // from the debugged process.  Should show each character.
+        process.stdout
+            .transform(UTF8.decoder)
+            .transform(new LineSplitter())
+            .listen((String line) {
+                // Hide/show command prompt across asynchronous output.
+                if (cmdo != null) {
+                  cmdo.hide();
+                }
+                print("$line");
+                if (cmdo != null) {
+                  cmdo.show();
+                }
+              });
+
+        process.exitCode.then((int exitCode) {
+            if (exitCode == 0) {
+              print('Program exited normally.');
+            } else {
+              print('Program exited with code $exitCode.');
+            }
+          });
+
       debuggerMain();
     });
   } else {
     debuggerMain();
   }
 }