Add support for command-line editing to ddbg.

tools/ddbg/bin/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 "../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(response);

[hausner, 2013/11/21 22:30:02]

Would help to have a type on the parameter. Is it Map?

[turnidge, 2013/11/22 19:59:59]

The actual handlers did not have types, so I was copying them.  Will go add
types to the response params below...

+
+HandlerType hidePrompt(void handler(response)) {
+  // Hide the command prompt immediately.
+  cmdo.hide();
+  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));
+    sendCmd(cmd).then(hidePrompt(handleGenericResponse));

[hausner, 2013/11/21 22:30:02]

I find it confusing that the "hidePrompt" function is a parameter to the closure
that is supposed to be executed when the future completes. It's difficult enough
to follow the control flow when futures are used. This makes it even harder I
think. Why not

cmdo.hide();
sendCmd(cmd).then(showPrompt(handleGenericResponse));

Or even put the cmdo.show() into the handleXXXX functions?

[turnidge, 2013/11/22 19:59:59]

Yeah, I didn't think this was exactly perfect either.

For now I went with your first suggestion -- cmdo.hide() explicitly.  I actually
renamed hidePrompt to "showPromptAfter" which reads a little better.

Longer term:

To make command completion work nicely, I would like to make command
dispatch/completion/help driven by data (basically a map from command to
dispatchers/handlers/completers/helpers).  Once this rewrite is done, I
anticipate that the hide/show will happen in just one place, which can be
well-documented.

   } else if (command == "bt") {
     var cmd = { "id": seqNum,
                 "command": "getStackTrace",
                 "params": { "isolateId" : isolate_id } };
-    sendCmd(cmd).then((result) => handleStackTraceResponse(result));
+    sendCmd(cmd).then(hidePrompt(handleStackTraceResponse));
   } else if (command == "ll") {
     var cmd = { "id": seqNum,
                 "command": "getLibraries",
                 "params": { "isolateId" : isolate_id } };
-    sendCmd(cmd).then((result) => handleGetLibraryResponse(result));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(handleGenericResponse));
   } else if (command == "li") {
     var cmd = { "id": seqNum, "command": "getIsolateIds" };
-    sendCmd(cmd).then((result) => handleGetIsolatesResponse(result));
+    sendCmd(cmd).then(hidePrompt(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));
+    sendCmd(cmd).then(hidePrompt(handleGenericResponse));
   } else if (command == "q") {
     quitShell();
   } else if (command == "h") {
     printHelp();
   } else {
     huh();
   }
 }
 
 
@@ skipping 119 matching lines @@
 }
 
 
 handleGetLineTableResponse(response) {
   Map result = response["result"];
   var info = result["lines"];
   print("Line info table:\n$info");
 }
 
 
-handleGetIsolatesResponse(response) {
+void handleGetIsolatesResponse(response) {

[hausner, 2013/11/21 22:30:02]

Remove the void annotation?

[turnidge, 2013/11/22 19:59:59]

I wanted it to be a match for HandlerType, above.

Also, it makes it consistent with e.g. handleGetLibraryResponse.

   Map result = response["result"];
   print("Isolates: ${result["isolateIds"]}");
 }
 
 
 void handleGetLibraryResponse(response) {
   Map result = response["result"];
   List libs = result["libraries"];
   print("Loaded libraries:");
   print(libs);
@@ skipping 83 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 happen.  For now
+        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);

[hausner, 2013/11/21 22:30:02]

Spaces around :

[turnidge, 2013/11/22 19:59:59]

Done.

   });
 }
 
-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();
   }
 }