When we hit a breakpoint in the debugger, show the source of current line.

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 "dart:math";
 
 import "ddbg/lib/commando.dart";
 
+class TargetScript {
+  // The text of a script.
+  String source = null;
+
+  // A mapping from line number to source text.
+  List<String> lineToSource = null;
+
+  // A mapping from token offset to line number.
+  Map<int,int> tokenToLine = null;
+}
+
+
 class TargetIsolate {
   int id;
   // The location of the last paused event.
   Map pausedLocation = null;
 
   TargetIsolate(this.id);
   bool get isPaused => pausedLocation != null;
+
+  Map<String, TargetScript> scripts = {};
 }
 
 Map<int, TargetIsolate> targetIsolates= new Map<int, TargetIsolate>();
 
 Map<int, Completer> outstandingCommands;
 
 Socket vmSock;
 String vmData;
 var cmdSubscription;
 Commando cmdo;
 var vmSubscription;
 int seqNum = 0;
 
 bool isDebugging = false;
+bool stepMode = false;
 Process targetProcess = null;
 bool suppressNextExitCode = false;
 
 final verbose = false;
 final printMessages = false;
 
 TargetIsolate currentIsolate;
 TargetIsolate mainIsolate;
 
 int debugPort = 5858;
@@ skipping 32 matching lines @@
   print("Current isolate must be paused");
   return false;
 }
 
 // These settings are allowed in the 'set' and 'show' debugger commands.
 var validSettings = ['vm', 'vmargs', 'script', 'args'];
 
 // The current values for all settings.
 var settings = new Map();
 
-// Generates a string of 'count' spaces.
-String _spaces(int count) {
-  return new List.filled(count, ' ').join('');
+String _leftJustify(text, int width) {
+  StringBuffer buffer = new StringBuffer();
+  buffer.write(text);
+  while (buffer.length < width) {
+    buffer.write(' ');
+  }
+  return buffer.toString();
 }
 
 // TODO(turnidge): Move all commands here.
 List<Command> commandList =
     [ new HelpCommand(),
       new QuitCommand(),
       new RunCommand(),
       new KillCommand(),
       new ConnectCommand(),
       new DisconnectCommand(),
@@ skipping 30 matching lines @@
 
 Usage:
   help
   help <command>
 """;
 
   Future run(List<String> args) {
     if (args.length == 1) {
       print("Debugger commands:\n");
       for (var command in commandList) {
-        const tabStop = 12;
-        var spaces = _spaces(max(1, (tabStop - command.name.length)));
-        print('  ${command.name}${spaces}${command.helpShort}');
+        print('  ${_leftJustify(command.name, 11)} ${command.helpShort}');
       }
 
       // TODO(turnidge): Convert all commands to use the Command class.
       print("""
   bt          Show backtrace
   r           Resume execution
   s           Single step
   so          Step over
   si          Step into
   sbp [<file>] <line> Set breakpoint
@@ skipping 351 matching lines @@
   var args = cmdLine.split(' ');
   if (args.length == 0) {
     return;
   }
   var command = args[0];
 
   var resume_commands =
       { 'r':'resume', 's':'stepOver', 'si':'stepInto', 'so':'stepOut'};
   if (resume_commands[command] != null) {
     if (!checkPaused()) return;
+    // TODO(turnidge): step mode isn't quite right yet.
+    stepMode = (command != 'r');
     var cmd = { "id": seqNum,
                 "command": resume_commands[command],
                 "params": { "isolateId" : currentIsolate.id } };
     sendCmd(cmd).then(showPromptAfter(handleResumedResponse));
   } else if (command == "bt") {
     var cmd = { "id": seqNum,
                 "command": "getStackTrace",
                 "params": { "isolateId" : currentIsolate.id } };
     sendCmd(cmd).then(showPromptAfter(handleStackTraceResponse));
   } else if (command == "ll") {
@@ skipping 377 matching lines @@
   Map result = response["result"];
   List callFrames = result["callFrames"];
   assert(callFrames != null);
   printStackTrace(callFrames);
 }
 
 
 void printStackFrame(frame_num, Map frame) {
   var fname = frame["functionName"];
   var loc = formatLocation(frame["location"]);
-  print("$frame_num  $fname ($loc)");
+  print("#${_leftJustify(frame_num,2)} $fname at $loc");
   List locals = frame["locals"];
   for (int i = 0; i < locals.length; i++) {
     printNamedObject(locals[i]);
   }
 }
 
 
 void printStackTrace(List frames) {
   for (int i = 0; i < frames.length; i++) {
     printStackFrame(i, frames[i]);
   }
 }
 
 
-void handlePausedEvent(msg) {
+Map<int, int> parseLineNumberTable(List<List<int>> table) {
+  Map tokenToLine = {};
+  for (var line in table) {
+    // Each entry begins with a line number...
+    var lineNumber = line[0];
+    for (var pos = 1; pos < line.length; pos += 2) {
+      // ...and is followed by (token offset, col number) pairs.
+      // We ignore the column numbers.
+      var tokenOffset = line[pos];
+      tokenToLine[tokenOffset] = lineNumber;
+    }
+  }
+  return tokenToLine;
+}
+
+
+Future<TargetScript> getTargetScript(Map location) {
+  var isolate = targetIsolates[currentIsolate.id];
+  var url = location['url'];
+  var script = isolate.scripts[url];
+  if (script != null) {
+    return new Future.value(script);
+  }
+
+  // Ask the vm for the source and line number table.
+  var sourceCmd = {
+    "id": seqNum++,
+    "command":  "getScriptSource",
+    "params": { "isolateId": currentIsolate.id,
+                "libraryId": location['libraryId'],
+                "url": url } };
+
+  var lineNumberCmd = {
+    "id": seqNum++,
+    "command":  "getLineNumberTable",
+    "params": { "isolateId": currentIsolate.id,
+                "libraryId": location['libraryId'],
+                "url": url } };
+
+  script = new TargetScript();
+  return Future.wait([

[hausner, 2013/12/05 23:57:53]

Your comments helped a lot to understand the control flow and nesting here, so
this is fine. 

OTOH, I'm still trying to experiment with making Futures programming readable.
Do you think this would be more readable:

Future sourceResponse = sendCmd(sourceCmd).then((response) ....);
Future lineResponse = sendCmd(lineNumberCmd).then((response) ...);

return Future.wait([sourceResponse, lineResponse]).then((_) {....};

[Bob Nystrom, 2013/12/06 00:08:09]

Drive-by!
It never gets completely readable, it just gets less unreadable. :)

The indentation you're using here doesn't follow the style guide and is probably
not that helpful. Taking Mattias' suggestion and going with how I usually see
this code styled would give you:

var sourceResponse = sendCmd(sourceCmd).then((response) {
  // Send the source command.
  var result = response["result"];
  script.source = result['text'];
  // Line numbers are 1-based so add a dummy for line 0.
  script.lineToSource = [''];
  script.lineToSource.addAll(script.source.split('\n'));
});

var lineResponse = sendCmd(lineNumberCmd).then((response) {
  // Send the line numbers command.
  var result = response["result"];
  script.tokenToLine = parseLineNumberTable(result['lines']);
});

return Future.wait([sourceResponse, lineResponse]).then((_) {
  // When both commands complete, cache the result.
  isolate.scripts[url] = script;
  return script;
});

[turnidge, 2013/12/06 17:19:43]

Done.

[turnidge, 2013/12/06 17:19:43]

Done.

+      // Send the source command
+      sendCmd(sourceCmd).then(
+          (Map response) {
+            Map result = response["result"];
+            script.source = result['text'];
+            // Line numbers are 1-based so add a dummy for line 0.
+            script.lineToSource = [''];
+            script.lineToSource.addAll(script.source.split('\n'));
+          }),
+      // Send the line numbers command
+      sendCmd(lineNumberCmd).then(
+          (Map response) {
+            Map result = response["result"];
+            script.tokenToLine = parseLineNumberTable(result['lines']);
+          })]).then((_) {
+              // When both commands complete, cache the result.
+              isolate.scripts[url] = script;
+              return script;
+            });
+}
+
+
+Future printLocation(String label, Map location) {
+  // Figure out the line number.
+  return getTargetScript(location).then(
+      (script) {
+        var lineNumber = script.tokenToLine[location['tokenOffset']];
+        var text = script.lineToSource[lineNumber];
+        if (label != null) {
+          var fileName = location['url'].split("/").last;
+          print("$label \n"
+                "    at $fileName:$lineNumber");
+        }
+        print("${_leftJustify(lineNumber, 8)}$text");
+      });
+}
+
+
+Future handlePausedEvent(msg) {
   assert(msg["params"] != null);
   var reason = msg["params"]["reason"];
   int isolateId = msg["params"]["isolateId"];
   assert(isolateId != null);
   var isolate = targetIsolates[isolateId];
   assert(isolate != null);
   assert(!isolate.isPaused);
   var location = msg["params"]["location"];;
   assert(location != null);
   isolate.pausedLocation = location;
   if (reason == "breakpoint") {
-    print("Isolate $isolateId paused on breakpoint");
-    print("location: ${formatLocation(location)}");
+    return printLocation((stepMode ? null : "Breakpoint"), location);

[hausner, 2013/12/05 23:57:53]

A cleaner way would be to add to the wire protocol whether the pause is due to
stepping or due to a breakpoint. I'll file a bug against myself to add that to
the protocol.

[turnidge, 2013/12/06 17:19:43]

That would be nice.  Also, it might be helpful to include the breakpoint id when
we hit a breakpoint.  That way it will be easier to say "Breakpoint #2" or
whatever when we stop.

   } else if (reason == "interrupted") {
-    print("Isolate $isolateId paused due to an interrupt");
-    print("location: ${formatLocation(location)}");
+    stepMode = false;
+    return printLocation("Interrupted", location);
   } else {
     assert(reason == "exception");
     var excObj = msg["params"]["exception"];
     print("Isolate $isolateId paused on exception");
     print(remoteObject(excObj));
+    return new Future.value();
   }
 }
 
 void handleIsolateEvent(msg) {
   Map params = msg["params"];
   assert(params != null);
   var isolateId = params["id"];
   var reason = params["reason"];
   if (reason == "created") {
     print("Isolate $isolateId has been created.");
@@ skipping 35 matching lines @@
   }
   var event = msg["event"];
   if (event == "isolate") {
     cmdo.hide();
     handleIsolateEvent(msg);
     cmdo.show();
     return;
   }
   if (event == "paused") {
     cmdo.hide();
-    handlePausedEvent(msg);
-    cmdo.show();
+    handlePausedEvent(msg).then((_) {
+        cmdo.show();
+      });
     return;
   }
   if (event == "breakpointResolved") {
     Map params = msg["params"];
     assert(params != null);
     var isolateId = params["isolateId"];
     var location = formatLocation(params["location"]);
     cmdo.hide();
-    print("BP ${params["breakpointId"]} resolved in isolate $isolateId"
+    print("Breakpoint ${params["breakpointId"]} resolved in isolate $isolateId"
           " at $location.");
     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"]}");
@@ skipping 235 matching lines @@
     cleanupFutures.add(future);
   }
 
   vmSubscription = null;
   vmSock = null;
   outstandingCommands = null;
   
   return Future.wait(cleanupFutures);
 }
 
+void debuggerError(error, StackTrace trace) {
+  print('\n--------\nExiting due to unexpected error:\n'
+        '  $error\n$trace\n');
+  debuggerQuit();
+}
+
 Future debuggerQuit() {
   // Kill target process, if any.
   if (targetProcess != null) {
     if (!targetProcess.kill()) {
       print('Unable to kill process ${targetProcess.pid}');
     }
   }
 
   // Restore terminal settings, close connections.
   return Future.wait([closeCommando(), closeVmSocket()]).then((_) {
@@ skipping 12 matching lines @@
     pos++;
   }
   if (pos < args.length) {
     settings['vmargs'] = args.getRange(0, pos).join(' ');
     settings['script'] = args[pos];
     settings['args'] = args.getRange(pos + 1, args.length).join(' ');
   }
 }
 
 void main(List<String> args) {
-  parseArgs(args);
+  // Setup a zone which will exit the debugger cleanly on any uncaught
+  // exception.
+  var zone =
+      Zone.ROOT.fork(
+          specification:new ZoneSpecification(
+              handleUncaughtError:
+              (self, parent, zone, error, trace) {
+                debuggerError(error, trace);
+              }));
 
-  cmdo = new Commando(completer: debuggerCommandCompleter);
-  cmdSubscription = cmdo.commands.listen(processCommand,
-                                         onError: processError,
-                                         onDone: processDone);
+  zone.run(() {
+      parseArgs(args);
+      cmdo = new Commando(completer: debuggerCommandCompleter);
+      cmdSubscription = cmdo.commands.listen(processCommand,
+                                             onError: processError,
+                                             onDone: processDone);
+    });
 }