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 175 matching lines @@
       processArgs.addAll(settings['vmargs'].split(' '));
     }
     processArgs.add(settings['script']);
     if (settings['args'] != null) {
       processArgs.addAll(settings['args'].split(' '));
     }
     String vm = settings['vm'];
 
     isDebugging = true;
     cmdo.hide();
-    return Process.start(vm, processArgs).then((Process process) {
+    return Process.start(vm, processArgs).then((process) {
         print("Started process ${process.pid} '$vm ${processArgs.join(' ')}'");
         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) {
@@ skipping 155 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 } };
+
+  // Send the source command
+  var sourceResponse = sendCmd(sourceCmd).then((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
+  var lineNumberResponse = sendCmd(lineNumberCmd).then((response) {
+      Map result = response["result"];
+      script.tokenToLine = parseLineNumberTable(result['lines']);
+    });
+
+  script = new TargetScript();
+  return Future.wait([sourceResponse, lineNumberResponse]).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);
   } 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(self, parent, zone, 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: debuggerError));
 
-  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);
+    });
 }