Revert r6180 as it caused test failures

src/d8.js

 // Copyright 2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 92 matching lines @@
                     Local: 1,
                     With: 2,
                     Closure: 3,
                     Catch: 4 };
 
 
 // Current debug state.
 const kNoFrame = -1;
 Debug.State = {
   currentFrame: kNoFrame,
-  displaySourceStartLine: -1,
-  displaySourceEndLine: -1,
   currentSourceLine: -1
 }
 var trace_compile = false;  // Tracing all compile events?
-var trace_debug_json = false; // Tracing all debug json packets?
-var last_cmd_line = '';
-var repeat_cmd_line = '';
-var is_running = true;
-
-// Copied from debug-delay.js.  This is needed below:
-function ScriptTypeFlag(type) {
-  return (1 << type);
-}
 
 
 // Process a debugger JSON message into a display text and a running status.
 // This function returns an object with properties "text" and "running" holding
 // this information.
 function DebugMessageDetails(message) {
-  if (trace_debug_json) {
-    print("received: '" + message + "'");
-  }
   // Convert the JSON string to an object.
   var response = new ProtocolPackage(message);
-  is_running = response.running();
 
   if (response.type() == 'event') {
     return DebugEventDetails(response);
   } else {
     return DebugResponseDetails(response);
   }
 }
 
 function DebugEventDetails(response) {
   details = {text:'', running:false}
@@ skipping 20 matching lines @@
       } else {
         result += 'break';
       }
       result += ' in ';
       result += body.invocationText;
       result += ', ';
       result += SourceInfo(body);
       result += '\n';
       result += SourceUnderline(body.sourceLineText, body.sourceColumn);
       Debug.State.currentSourceLine = body.sourceLine;
-      Debug.State.displaySourceStartLine = -1;
-      Debug.State.displaySourceEndLine = -1;
       Debug.State.currentFrame = 0;
       details.text = result;
       break;
 
     case 'exception':
       if (body.uncaught) {
         result += 'Uncaught: ';
       } else {
         result += 'Exception: ';
       }
       result += '"';
       result += body.exception.text;
       result += '"';
       if (body.sourceLine >= 0) {
         result += ', ';
         result += SourceInfo(body);
         result += '\n';
         result += SourceUnderline(body.sourceLineText, body.sourceColumn);
         Debug.State.currentSourceLine = body.sourceLine;
-        Debug.State.displaySourceStartLine = -1;
-        Debug.State.displaySourceEndLine = -1;
         Debug.State.currentFrame = 0;
       } else {
         result += ' (empty stack)';
         Debug.State.currentSourceLine = -1;
-        Debug.State.displaySourceStartLine = -1;
-        Debug.State.displaySourceEndLine = -1;
         Debug.State.currentFrame = kNoFrame;
       }
       details.text = result;
       break;
 
     case 'afterCompile':
       if (trace_compile) {
         result = 'Source ' + body.script.name + ' compiled:\n'
         var source = body.script.source;
         if (!(source[source.length - 1] == '\n')) {
           result += source;
         } else {
           result += source.substring(0, source.length - 1);
         }
       }
       details.text = result;
       break;
 
-    case 'scriptCollected':
-      details.text = result;
-      break;
-
     default:
       details.text = 'Unknown debug event ' + response.event();
   }
 
   return details;
 };
 
 
 function SourceInfo(body) {
   var result = '';
@@ skipping 32 matching lines @@
   }
   underline += '^';
 
   // Return the source line text with the underline beneath.
   return source_text + '\n' + underline;
 };
 
 
 // Converts a text command to a JSON request.
 function DebugCommandToJSONRequest(cmd_line) {
-  var result = new DebugRequest(cmd_line).JSONRequest();
-  if (trace_debug_json && result) {
-    print("sending: '" + result + "'");
-  }
-  return result;
+  return new DebugRequest(cmd_line).JSONRequest();
 };
 
 
 function DebugRequest(cmd_line) {
   // If the very first character is a { assume that a JSON request have been
   // entered as a command. Converting that to a JSON request is trivial.
   if (cmd_line && cmd_line.length > 0 && cmd_line.charAt(0) == '{') {
     this.request_ = cmd_line;
     return;
   }
 
-  // Check for a simple carriage return to repeat the last command:
-  var is_repeating = false;
-  if (cmd_line == '\n') {
-    if (is_running) {
-      cmd_line = 'break'; // Not in debugger mode, break with a frame request.
-    } else {
-      cmd_line = repeat_cmd_line; // use command to repeat.
-      is_repeating = true;
-    }
-  }
-  if (!is_running) { // Only save the command if in debugger mode.
-    repeat_cmd_line = cmd_line;   // save last command.
-  }
-
   // Trim string for leading and trailing whitespace.
   cmd_line = cmd_line.replace(/^\s+|\s+$/g, '');
 
   // Find the command.
   var pos = cmd_line.indexOf(' ');
   var cmd;
   var args;
   if (pos == -1) {
     cmd = cmd_line;
     args = '';
   } else {
     cmd = cmd_line.slice(0, pos);
     args = cmd_line.slice(pos).replace(/^\s+|\s+$/g, '');
   }
 
-  if ((cmd === undefined) || !cmd) {
-    this.request_ = void 0;
-    return;
-  }
-
-  last_cmd = cmd;
-
   // Switch on command.
   switch (cmd) {
     case 'continue':
     case 'c':
       this.request_ = this.continueCommandToJSONRequest_(args);
       break;
 
     case 'step':
     case 's':
-      this.request_ = this.stepCommandToJSONRequest_(args, 'in');
-      break;
-
-    case 'stepi':
-    case 'si':
-      this.request_ = this.stepCommandToJSONRequest_(args, 'min');
-      break;
-
-    case 'next':
-    case 'n':
-      this.request_ = this.stepCommandToJSONRequest_(args, 'next');
-      break;
-
-    case 'finish':
-    case 'fin':
-      this.request_ = this.stepCommandToJSONRequest_(args, 'out');
+      this.request_ = this.stepCommandToJSONRequest_(args);
       break;
 
     case 'backtrace':
     case 'bt':
       this.request_ = this.backtraceCommandToJSONRequest_(args);
       break;
 
     case 'frame':
     case 'f':
       this.request_ = this.frameCommandToJSONRequest_(args);
       break;
 
     case 'scopes':
       this.request_ = this.scopesCommandToJSONRequest_(args);
       break;
 
     case 'scope':
       this.request_ = this.scopeCommandToJSONRequest_(args);
       break;
 
-    case 'disconnect':
-    case 'exit':
-    case 'quit':
-      this.request_ = this.disconnectCommandToJSONRequest_(args);
-      break;
-
-    case 'up':
-      this.request_ =
-          this.frameCommandToJSONRequest_('' +
-                                          (Debug.State.currentFrame + 1));
-      break;
-      
-    case 'down':
-    case 'do':
-      this.request_ =
-          this.frameCommandToJSONRequest_('' +
-                                          (Debug.State.currentFrame - 1));
-      break;
-      
-    case 'set':
     case 'print':
     case 'p':
       this.request_ = this.printCommandToJSONRequest_(args);
       break;
 
     case 'dir':
       this.request_ = this.dirCommandToJSONRequest_(args);
       break;
 
     case 'references':
       this.request_ = this.referencesCommandToJSONRequest_(args);
       break;
 
     case 'instances':
       this.request_ = this.instancesCommandToJSONRequest_(args);
       break;
 
-    case 'list':
-    case 'l':
-      this.request_ = this.listCommandToJSONRequest_(args);
-      break;
     case 'source':
       this.request_ = this.sourceCommandToJSONRequest_(args);
       break;
 
     case 'scripts':
-    case 'script':
-    case 'scr':
       this.request_ = this.scriptsCommandToJSONRequest_(args);
       break;
 
     case 'break':
     case 'b':
       this.request_ = this.breakCommandToJSONRequest_(args);
       break;
 
     case 'breakpoints':
     case 'bb':
       this.request_ = this.breakpointsCommandToJSONRequest_(args);
       break;
 
     case 'clear':
-    case 'delete':
-    case 'd':
       this.request_ = this.clearCommandToJSONRequest_(args);
       break;
 
     case 'threads':
       this.request_ = this.threadsCommandToJSONRequest_(args);
       break;
 
-    case 'cond':
-      this.request_ = this.changeBreakpointCommandToJSONRequest_(args, 'cond');
-      break;
-
-    case 'enable':
-    case 'en':
-      this.request_ =
-          this.changeBreakpointCommandToJSONRequest_(args, 'enable');
-      break;
-
-    case 'disable':
-    case 'dis':
-      this.request_ =
-          this.changeBreakpointCommandToJSONRequest_(args, 'disable');
-      break;
-
-    case 'ignore':
-      this.request_ =
-          this.changeBreakpointCommandToJSONRequest_(args, 'ignore');
-      break;
-
-    case 'info':
-    case 'inf':
-      this.request_ = this.infoCommandToJSONRequest_(args);
-      break;
-
-    case 'flags':
-      this.request_ = this.v8FlagsToJSONRequest_(args);
-      break;
-
-    case 'gc':
-      this.request_ = this.gcToJSONRequest_(args);
-      break;
-
     case 'trace':
-    case 'tr':
       // Return undefined to indicate command handled internally (no JSON).
       this.request_ = void 0;
       this.traceCommand_(args);
       break;
 
     case 'help':
     case '?':
       this.helpCommand_(args);
       // Return undefined to indicate command handled internally (no JSON).
       this.request_ = void 0;
       break;
 
     default:
       throw new Error('Unknown command "' + cmd + '"');
   }
+
+  last_cmd = cmd;
 }
 
 DebugRequest.prototype.JSONRequest = function() {
   return this.request_;
 }
 
 
 function RequestPacket(command) {
   this.seq = 0;
   this.type = 'request';
@@ skipping 73 matching lines @@
 
 
 // Create a JSON request for the continue command.
 DebugRequest.prototype.continueCommandToJSONRequest_ = function(args) {
   var request = this.createRequest('continue');
   return request.toJSONProtocol();
 };
 
 
 // Create a JSON request for the step command.
-DebugRequest.prototype.stepCommandToJSONRequest_ = function(args, type) {
+DebugRequest.prototype.stepCommandToJSONRequest_ = function(args) {
   // Requesting a step is through the continue command with additional
   // arguments.
   var request = this.createRequest('continue');
   request.arguments = {};
 
   // Process arguments if any.
-
-  // Only process args if the command is 'step' which is indicated by type being
-  // set to 'in'.  For all other commands, ignore the args.
   if (args && args.length > 0) {
-    args = args.split(/\s+/g);
+    args = args.split(/\s*[ ]+\s*/g);
 
     if (args.length > 2) {
       throw new Error('Invalid step arguments.');
     }
 
     if (args.length > 0) {
-      // Check if we have a gdb stype step command.  If so, the 1st arg would
-      // be the step count.  If it's not a number, then assume that we're
-      // parsing for the legacy v8 step command.
-      var stepcount = Number(args[0]);
-      if (stepcount == Number.NaN) {
-        // No step count at arg 1.  Process as legacy d8 step command:
-        if (args.length == 2) {
-          var stepcount = parseInt(args[1]);
-          if (isNaN(stepcount) || stepcount <= 0) {
-            throw new Error('Invalid step count argument "' + args[0] + '".');
-          }
-          request.arguments.stepcount = stepcount;
+      // Get step count argument if any.
+      if (args.length == 2) {
+        var stepcount = parseInt(args[1]);
+        if (isNaN(stepcount) || stepcount <= 0) {
+          throw new Error('Invalid step count argument "' + args[0] + '".');
         }
+        request.arguments.stepcount = stepcount;
+      }
 
-        // Get the step action.
-        switch (args[0]) {
-          case 'in':
-          case 'i':
-            request.arguments.stepaction = 'in';
-            break;
+      // Get the step action.
+      switch (args[0]) {
+        case 'in':
+        case 'i':
+          request.arguments.stepaction = 'in';
+          break;
 
-          case 'min':
-          case 'm':
-            request.arguments.stepaction = 'min';
-            break;
+        case 'min':
+        case 'm':
+          request.arguments.stepaction = 'min';
+          break;
 
-          case 'next':
-          case 'n':
-            request.arguments.stepaction = 'next';
-            break;
+        case 'next':
+        case 'n':
+          request.arguments.stepaction = 'next';
+          break;
 
-          case 'out':
-          case 'o':
-            request.arguments.stepaction = 'out';
-            break;
+        case 'out':
+        case 'o':
+          request.arguments.stepaction = 'out';
+          break;
 
-          default:
-            throw new Error('Invalid step argument "' + args[0] + '".');
-        }
-
-      } else {
-        // gdb style step commands:
-        request.arguments.stepaction = type;
-        request.arguments.stepcount = stepcount;
+        default:
+          throw new Error('Invalid step argument "' + args[0] + '".');
       }
     }
   } else {
-    // Default is step of the specified type.
-    request.arguments.stepaction = type;
+    // Default is step next.
+    request.arguments.stepaction = 'next';
   }
 
   return request.toJSONProtocol();
 };
 
 
 // Create a JSON request for the backtrace command.
 DebugRequest.prototype.backtraceCommandToJSONRequest_ = function(args) {
   // Build a backtrace request from the text command.
   var request = this.createRequest('backtrace');
@@ skipping 110 matching lines @@
   // Build an evaluate request from the text command.
   if (args.length == 0) {
     throw new Error('Missing object id.');
   }
 
   // Build a references request.
   return this.makeReferencesJSONRequest_(args, 'constructedBy');
 };
 
 
-// Create a JSON request for the list command.
-DebugRequest.prototype.listCommandToJSONRequest_ = function(args) {
-
-  // Default is ten lines starting five lines before the current location.
-  if (Debug.State.displaySourceEndLine == -1) {
-    // If we list forwards, we will start listing after the last source end
-    // line.  Set it to start from 5 lines before the current location.
-    Debug.State.displaySourceEndLine = Debug.State.currentSourceLine - 5;
-    // If we list backwards, we will start listing backwards from the last
-    // source start line.  Set it to start from 1 lines before the current
-    // location.
-    Debug.State.displaySourceStartLine = Debug.State.currentSourceLine + 1;
-  }
-
-  var from = Debug.State.displaySourceEndLine + 1;
-  var lines = 10;
-
-  // Parse the arguments.
-  args = args.split(/\s*,\s*/g);
-  if (args == '') {
-  } else if ((args.length == 1) && (args[0] == '-')) {
-    from = Debug.State.displaySourceStartLine - lines;
-  } else if (args.length == 2) {
-    from = parseInt(args[0]);
-    lines = parseInt(args[1]) - from + 1; // inclusive of the ending line.
-  } else {
-    throw new Error('Invalid list arguments.');
-  }
-  Debug.State.displaySourceStartLine = from;
-  Debug.State.displaySourceEndLine = from + lines - 1;
-  var sourceArgs = '' + from + ' ' + lines;
-  return this.sourceCommandToJSONRequest_(sourceArgs);
-};
-
-
 // Create a JSON request for the source command.
 DebugRequest.prototype.sourceCommandToJSONRequest_ = function(args) {
   // Build a evaluate request from the text command.
   var request = this.createRequest('source');
 
   // Default is ten lines starting five lines before the current location.
   var from = Debug.State.currentSourceLine - 5;
   var lines = 10;
 
   // Parse the arguments.
@@ skipping 41 matching lines @@
         break;
 
       case 'all':
         request.arguments.types =
             ScriptTypeFlag(Debug.ScriptType.Normal) |
             ScriptTypeFlag(Debug.ScriptType.Native) |
             ScriptTypeFlag(Debug.ScriptType.Extension);
         break;
 
       default:
-        // If the arg is not one of the know one aboves, then it must be a
-        // filter used for filtering the results:
-        request.arguments.filter = args[0];
-        break;
+        throw new Error('Invalid argument "' + args[0] + '".');
     }
   }
 
   return request.toJSONProtocol();
 };
 
 
 // Create a JSON request for the break command.
 DebugRequest.prototype.breakCommandToJSONRequest_ = function(args) {
   // Build a evaluate request from the text command.
   // Process arguments if any.
   if (args && args.length > 0) {
     var target = args;
     var type = 'function';
     var line;
     var column;
     var condition;
     var pos;
 
     var request = this.createRequest('setbreakpoint');
 
-    // Break the args into target spec and condition if appropriate.
-
     // Check for breakpoint condition.
     pos = args.indexOf(' ');
     if (pos > 0) {
       target = args.substring(0, pos);
       condition = args.substring(pos + 1, args.length);
     }
 
     // Check for script breakpoint (name:line[:column]). If no ':' in break
     // specification it is considered a function break point.
     pos = target.indexOf(':');
@@ skipping 50 matching lines @@
     request.arguments = {};
     request.arguments.breakpoint = parseInt(args);
   } else {
     throw new Error('Invalid break arguments.');
   }
 
   return request.toJSONProtocol();
 };
 
 
-// Create a JSON request for the change breakpoint command.
-DebugRequest.prototype.changeBreakpointCommandToJSONRequest_ =
-    function(args, command) {
-
-  var request;
-
-  // Check for exception breaks first:
-  //   en[able] exc[eptions] [all|unc[aught]]
-  //   en[able] [all|unc[aught]] exc[eptions]
-  //   dis[able] exc[eptions] [all|unc[aught]]
-  //   dis[able] [all|unc[aught]] exc[eptions]
-  if ((command == 'enable' || command == 'disable') &&
-      args && args.length > 1) {
-    var nextPos = args.indexOf(' ');
-    var arg1 = (nextPos > 0) ? args.substring(0, nextPos) : args;
-    var excType = null;
-
-    // Check for:
-    //   en[able] exc[eptions] [all|unc[aught]]
-    //   dis[able] exc[eptions] [all|unc[aught]]
-    if (arg1 == 'exc' || arg1 == 'exception' || arg1 == 'exceptions') {
-
-      var arg2 = (nextPos > 0) ?
-          args.substring(nextPos + 1, args.length) : 'all';
-      if (!arg2) {
-        arg2 = 'all'; // if unspecified, set for all.
-      } if (arg2 == 'unc') { // check for short cut.
-        arg2 = 'uncaught';
-      }
-      excType = arg2;
-      
-    // Check for:
-    //   en[able] [all|unc[aught]] exc[eptions]
-    //   dis[able] [all|unc[aught]] exc[eptions]
-    } else if (arg1 == 'all' || arg1 == 'unc' || arg1 == 'uncaught') {
-
-      var arg2 = (nextPos > 0) ?
-          args.substring(nextPos + 1, args.length) : null;
-      if (arg2 == 'exc' || arg1 == 'exception' || arg1 == 'exceptions') {
-        excType = arg1;
-        if (excType == 'unc') {
-          excType = 'uncaught';
-        }
-      }
-    }
-
-    // If we matched one of the command formats, then excType will be non-null:
-    if (excType) {
-      // Build a evaluate request from the text command.
-      request = this.createRequest('setexceptionbreak');
-
-      request.arguments = {};
-      request.arguments.type = excType;
-      request.arguments.enabled = (command == 'enable');
-
-      return request.toJSONProtocol();
-    }
-  }
-
-  // Build a evaluate request from the text command.
-  request = this.createRequest('changebreakpoint');
-
-  // Process arguments if any.
-  if (args && args.length > 0) {
-    request.arguments = {};
-    var pos = args.indexOf(' ');
-    var breakpointArg = args;
-    var otherArgs;
-    if (pos > 0) {
-      breakpointArg = args.substring(0, pos);
-      otherArgs = args.substring(pos + 1, args.length);
-    }
-
-    request.arguments.breakpoint = parseInt(breakpointArg);
-
-    switch(command) {
-      case 'cond':
-        request.arguments.condition = otherArgs ? otherArgs : null;
-        break;
-      case 'enable':
-        request.arguments.enabled = true;
-        break;
-      case 'disable':
-        request.arguments.enabled = false;
-        break;
-      case 'ignore':
-        request.arguments.ignoreCount = parseInt(otherArgs);
-        break;
-      default:
-        throw new Error('Invalid arguments.');  
-        }
-  } else {
-    throw new Error('Invalid arguments.');
-  }
-
-  return request.toJSONProtocol();
-};
-
-
-// Create a JSON request for the disconnect command.
-DebugRequest.prototype.disconnectCommandToJSONRequest_ = function(args) {
-  var request;
-  request = this.createRequest('disconnect');
-  return request.toJSONProtocol();
-};
-
-
-// Create a JSON request for the info command.
-DebugRequest.prototype.infoCommandToJSONRequest_ = function(args) {
-  var request;
-  if (args && (args == 'break' || args == 'br')) {
-    // Build a evaluate request from the text command.
-    request = this.createRequest('listbreakpoints');
-        last_cmd = 'info break';
-  } else if (args && (args == 'locals' || args == 'lo')) {
-    // Build a evaluate request from the text command.
-        request = this.createRequest('frame');
-        last_cmd = 'info locals';
-  } else if (args && (args == 'args' || args == 'ar')) {
-    // Build a evaluate request from the text command.
-        request = this.createRequest('frame');
-        last_cmd = 'info args';
-  } else {
-    throw new Error('Invalid info arguments.');
-  }
-
-  return request.toJSONProtocol();
-};
-
-
-DebugRequest.prototype.v8FlagsToJSONRequest_ = function(args) {
-  var request;
-  request = this.createRequest('v8flags');
-  request.arguments = {};
-  request.arguments.flags = args;
-  return request.toJSONProtocol();
-};
-
-
-DebugRequest.prototype.gcToJSONRequest_ = function(args) {
-  var request;
-  if (!args) {
-    args = 'all';
-  }
-  var args = args.split(/\s+/g);
-  var cmd = args[0];
-
-  switch(cmd) {
-    case 'all':
-    case 'quick':
-    case 'full':
-    case 'young':
-    case 'old':
-    case 'compact':
-    case 'sweep':
-    case 'scavenge': {
-      if (cmd == 'young') { cmd = 'quick'; }
-      else if (cmd == 'old') { cmd = 'full'; }
-
-      request = this.createRequest('gc');
-      request.arguments = {};
-      request.arguments.type = cmd;
-      break;
-    }
-      // Else fall thru to the default case below to report the error.
-    default:
-      throw new Error('Missing arguments after ' + cmd + '.');
-  }
-  return request.toJSONProtocol();
-};
-
-
 // Create a JSON request for the threads command.
 DebugRequest.prototype.threadsCommandToJSONRequest_ = function(args) {
   // Build a threads request from the text command.
   var request = this.createRequest('threads');
   return request.toJSONProtocol();
 };
 
 
 // Handle the trace command.
 DebugRequest.prototype.traceCommand_ = function(args) {
   // Process arguments.
   if (args && args.length > 0) {
     if (args == 'compile') {
       trace_compile = !trace_compile;
       print('Tracing of compiled scripts ' + (trace_compile ? 'on' : 'off'));
-    } else if (args === 'debug json' || args === 'json' || args === 'packets') {
-      trace_debug_json = !trace_debug_json;
-      print('Tracing of debug json packets ' +
-            (trace_debug_json ? 'on' : 'off'));
     } else {
       throw new Error('Invalid trace arguments.');
     }
   } else {
     throw new Error('Invalid trace arguments.');
   }
 }
 
 // Handle the help command.
 DebugRequest.prototype.helpCommand_ = function(args) {
   // Help os quite simple.
   if (args && args.length > 0) {
     print('warning: arguments to \'help\' are ignored');
   }
 
-  print('Note: <> denotes symbollic values to be replaced with real values.');
-  print('Note: [] denotes optional parts of commands, or optional options / arguments.');
-  print('      e.g. d[elete] - you get the same command if you type d or delete.');
-  print('');
-  print('[break] - break as soon as possible');
-  print('b[reak] location [condition]');
-  print('        - break on named function: location is a function name');
-  print('        - break on function: location is #<id>#');
-  print('        - break on script position: location is name:line[:column]');
-  print('');
-  print('clear <breakpoint #>       - deletes the specified user defined breakpoint');
-  print('d[elete]  <breakpoint #>   - deletes the specified user defined breakpoint');
-  print('dis[able] <breakpoint #>   - disables the specified user defined breakpoint');
-  print('dis[able] exc[eptions] [[all] | unc[aught]]');
-  print('                           - disables breaking on exceptions');
-  print('en[able]  <breakpoint #>   - enables the specified user defined breakpoint');
-  print('en[able]  exc[eptions] [[all] | unc[aught]]');
-  print('                           - enables breaking on exceptions');
-  print('');
-  print('b[ack]t[race] [n] | [-n] | [from to]');
-  print('                           - prints the stack back trace');
-  print('f[rame]                    - prints info about the current frame context');
-  print('f[rame] <frame #>          - set context to specified frame #');
+  print('break');
+  print('break location [condition]');
+  print('  break on named function: location is a function name');
+  print('  break on function: location is #<id>#');
+  print('  break on script position: location is name:line[:column]');
+  print('clear <breakpoint #>');
+  print('backtrace [n] | [-n] | [from to]');
+  print('frame <frame #>');
   print('scopes');
   print('scope <scope #>');
-  print('');
-  print('up                         - set context to caller of current frame');
-  print('do[wn]                     - set context to callee of current frame');
-  print('inf[o] br[eak]             - prints info about breakpoints in use');
-  print('inf[o] ar[gs]              - prints info about arguments of the current function');
-  print('inf[o] lo[cals]            - prints info about locals in the current function');
-  print('inf[o] liveobjectlist|lol  - same as \'lol info\'');
-  print('');
   print('step [in | next | out| min [step count]]');
-  print('c[ontinue]                 - continue executing after a breakpoint');
-  print('s[tep]   [<N>]             - step into the next N callees (default N is 1)');
-  print('s[tep]i  [<N>]             - step into the next N callees (default N is 1)');
-  print('n[ext]   [<N>]             - step over the next N callees (default N is 1)');
-  print('fin[ish] [<N>]             - step out of N frames (default N is 1)');
-  print('');
-  print('p[rint] <expression>       - prints the result of the specified expression');
-  print('dir <expression>           - prints the object structure of the result');
-  print('set <var> = <expression>   - executes the specified statement');
-  print('');
-  print('l[ist]                     - list the source code around for the current pc');
-  print('l[ist] [- | <start>,<end>] - list the specified range of source code');
+  print('print <expression>');
+  print('dir <expression>');
   print('source [from line [num lines]]');
-  print('scr[ipts] [native|extensions|all]');
-  print('scr[ipts] [<filter text>]  - list scripts with the specified text in its description');
-  print('');
-  print('gc                         - runs the garbage collector');
-  print('');
+  print('scripts');
+  print('continue');
   print('trace compile');
-  // hidden command: trace debug json - toggles tracing of debug json packets
-  print('');
-  print('disconnect|exit|quit       - disconnects and quits the debugger');
-  print('help                       - prints this help information');
+  print('help');
 }
 
 
 function formatHandleReference_(value) {
   if (value.handle() >= 0) {
     return '#' + value.handle() + '#';
   } else {
     return '#Transient#';
   }
 }
@@ skipping 61 matching lines @@
     case Debug.ScopeType.Closure:
       result += 'Closure';
       break;
     default:
       result += 'UNKNOWN';
   }
   return result;
 }
 
 
-function refObjectToString_(protocolPackage, handle) {
-  var value = protocolPackage.lookup(handle);
-  var result = '';
-  if (value.isString()) {
-    result = '"' + value.value() + '"';
-  } else if (value.isPrimitive()) {
-    result = value.valueString();
-  } else if (value.isObject()) {
-    result += formatObject_(value, true);
-  }
-  return result;
-}
-
-
-// Rounds number 'num' to 'length' decimal places.
-function roundNumber(num, length) {
-  var factor = Math.pow(10, length);
-  return Math.round(num * factor) / factor;
-}
-
-
 // Convert a JSON response to text for display in a text based debugger.
 function DebugResponseDetails(response) {
   details = {text:'', running:false}
 
   try {
     if (!response.success()) {
       details.text = response.message();
       return details;
     }
 
@@ skipping 12 matching lines @@
         result += body.breakpoint;
         details.text = result;
         break;
 
       case 'clearbreakpoint':
         result = 'cleared breakpoint #';
         result += body.breakpoint;
         details.text = result;
         break;
 
-      case 'changebreakpoint':
-        result = 'successfully changed breakpoint';
-        details.text = result;
-        break;
-
       case 'listbreakpoints':
         result = 'breakpoints: (' + body.breakpoints.length + ')';
         for (var i = 0; i < body.breakpoints.length; i++) {
           var breakpoint = body.breakpoints[i];
           result += '\n id=' + breakpoint.number;
           result += ' type=' + breakpoint.type;
           if (breakpoint.script_id) {
               result += ' script_id=' + breakpoint.script_id;
           }
           if (breakpoint.script_name) {
               result += ' script_name=' + breakpoint.script_name;
           }
-          result += ' line=' + (breakpoint.line + 1);
+          result += ' line=' + breakpoint.line;
           if (breakpoint.column != null) {
-            result += ' column=' + (breakpoint.column + 1);
+            result += ' column=' + breakpoint.column;
           }
           if (breakpoint.groupId) {
             result += ' groupId=' + breakpoint.groupId;
           }
           if (breakpoint.ignoreCount) {
               result += ' ignoreCount=' + breakpoint.ignoreCount;
           }
           if (breakpoint.active === false) {
             result += ' inactive';
           }
           if (breakpoint.condition) {
             result += ' condition=' + breakpoint.condition;
           }
           result += ' hit_count=' + breakpoint.hit_count;
         }
-        if (body.breakpoints.length === 0) {
-          result = "No user defined breakpoints\n";
-        } else {
-          result += '\n';
-        }
-        if (body.breakOnExceptions) {
-          result += '* breaking on ALL exceptions is enabled\n';
-        } else if (body.breakOnUncaughtExceptions) {
-          result += '* breaking on UNCAUGHT exceptions is enabled\n';
-        } else {
-          result += '* all exception breakpoints are disabled\n';            
-        }
-        details.text = result;
-        break;
-
-      case 'setexceptionbreak':
-        result = 'Break on ' + body.type + ' exceptions: ';
-        result += body.enabled ? 'enabled' : 'disabled';
         details.text = result;
         break;
 
       case 'backtrace':
         if (body.totalFrames == 0) {
           result = '(empty stack)';
         } else {
           var result = 'Frames #' + body.fromFrame + ' to #' +
               (body.toFrame - 1) + ' of ' + body.totalFrames + '\n';
           for (i = 0; i < body.frames.length; i++) {
             if (i != 0) result += '\n';
             result += body.frames[i].text;
           }
         }
         details.text = result;
         break;
 
       case 'frame':
-        if (last_cmd === 'info locals') {
-          var locals = body.locals;
-          if (locals.length === 0) {
-            result = 'No locals';
-          } else {
-            for (var i = 0; i < locals.length; i++) {
-              var local = locals[i];
-              result += local.name + ' = ';
-              result += refObjectToString_(response, local.value.ref);
-              result += '\n';
-            }
-          }
-        } else if (last_cmd === 'info args') {
-          var args = body.arguments;
-          if (args.length === 0) {
-            result = 'No arguments';
-          } else {
-            for (var i = 0; i < args.length; i++) {
-              var arg = args[i];
-              result += arg.name + ' = ';
-              result += refObjectToString_(response, arg.value.ref);
-              result += '\n';
-            }
-          }
-        } else {
-          result = SourceUnderline(body.sourceLineText,
-                                   body.column);
-          Debug.State.currentSourceLine = body.line;
-          Debug.State.currentFrame = body.index;
-          Debug.State.displaySourceStartLine = -1;
-          Debug.State.displaySourceEndLine = -1;
-        }
-        details.text = result;
+        details.text = SourceUnderline(body.sourceLineText,
+                                       body.column);
+        Debug.State.currentSourceLine = body.line;
+        Debug.State.currentFrame = body.index;
         break;
 
       case 'scopes':
         if (body.totalScopes == 0) {
           result = '(no scopes)';
         } else {
           result = 'Scopes #' + body.fromScope + ' to #' +
                    (body.toScope - 1) + ' of ' + body.totalScopes + '\n';
           for (i = 0; i < body.scopes.length; i++) {
             if (i != 0) {
@@ skipping 98 matching lines @@
           if (i != 0) result += '\n';
           if (body[i].id) {
             result += body[i].id;
           } else {
             result += '[no id]';
           }
           result += ', ';
           if (body[i].name) {
             result += body[i].name;
           } else {
-            if (body[i].compilationType == Debug.ScriptCompilationType.Eval
-                && body[i].evalFromScript
-                ) {
+            if (body[i].compilationType == Debug.ScriptCompilationType.Eval) {
               result += 'eval from ';
               var script_value = response.lookup(body[i].evalFromScript.ref);
               result += ' ' + script_value.field('name');
               result += ':' + (body[i].evalFromLocation.line + 1);
               result += ':' + body[i].evalFromLocation.column;
             } else if (body[i].compilationType ==
                        Debug.ScriptCompilationType.JSON) {
               result += 'JSON ';
             } else {  // body[i].compilation == Debug.ScriptCompilationType.Host
               result += '[unnamed] ';
             }
           }
           result += ' (lines: ';
           result += body[i].lineCount;
           result += ', length: ';
           result += body[i].sourceLength;
           if (body[i].type == Debug.ScriptType.Native) {
             result += ', native';
           } else if (body[i].type == Debug.ScriptType.Extension) {
             result += ', extension';
           }
           result += '), [';
           var sourceStart = body[i].sourceStart;
           if (sourceStart.length > 40) {
             sourceStart = sourceStart.substring(0, 37) + '...';
           }
           result += sourceStart;
           result += ']';
         }
-        if (body.length == 0) {
-          result = "no matching scripts found";
-        }
         details.text = result;
         break;
 
       case 'threads':
         var result = 'Active V8 threads: ' + body.totalThreads + '\n';
         body.threads.sort(function(a, b) { return a.id - b.id; });
         for (i = 0; i < body.threads.length; i++) {
           result += body.threads[i].current ? '*' : ' ';
           result += ' ';
           result += body.threads[i].id;
           result += '\n';
         }
         details.text = result;
         break;
 
       case 'continue':
         details.text = "(running)";
         break;
 
-      case 'v8flags':
-        details.text = "flags set";
-        break;
-
-      case 'gc':
-        details.text = "GC " + body.before + " => " + body.after;
-        if (body.after > (1024*1024)) {
-          details.text +=
-              " (" + roundNumber(body.before/(1024*1024), 1) + "M => " +
-                     roundNumber(body.after/(1024*1024), 1) + "M)";
-        } else if (body.after > 1024) {
-          details.text +=
-              " (" + roundNumber(body.before/1024, 1) + "K => " +
-                     roundNumber(body.after/1024, 1) + "K)";
-        }
-        break;
-
       default:
         details.text =
             'Response for unknown command \'' + response.command() + '\'' +
             ' (' + response.raw_json() + ')';
     }
   } catch (e) {
     details.text = 'Error: "' + e + '" formatting response';
   }
 
   return details;
@@ skipping 266 matching lines @@
 
 /**
  * Check is the value is a string.
  * @return {boolean} true if the value is a string
  */
 ProtocolValue.prototype.value = function() {
   return this.value_.value;
 }
 
 
-ProtocolValue.prototype.valueString = function() {
-  return this.value_.text;
-}
-
-
 function ProtocolReference(handle) {
   this.handle_ = handle;
 }
 
 
 ProtocolReference.prototype.handle = function() {
   return this.handle_;
 }
 
 
@@ skipping 126 matching lines @@
   var content = [];
   for (var key in object) {
     // Only consider string keys.
     if (typeof key == 'string') {
       var property_value = object[key];
 
       // Format the value based on its type.
       var property_value_json;
       switch (typeof property_value) {
         case 'object':
-          if (property_value === null) {
-            property_value_json = 'null';
-          } else if (typeof property_value.toJSONProtocol == 'function') {
+          if (typeof property_value.toJSONProtocol == 'function') {
             property_value_json = property_value.toJSONProtocol(true)
           } else if (property_value.constructor.name == 'Array'){
             property_value_json = SimpleArrayToJSON_(property_value);
           } else {
             property_value_json = SimpleObjectToJSON_(property_value);
           }
           break;
 
         case 'boolean':
           property_value_json = BooleanToJSON_(property_value);
@@ skipping 47 matching lines @@
       json += NumberToJSON_(elem);
     } else if (typeof(elem) === 'string')  {
       json += StringToJSON_(elem);
     } else {
       json += elem;
     }
   }
   json += ']';
   return json;
 }