CSE2410 Fall 2014 Bounce

// 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

//       with the distribution.

//     * Neither the name of Google Inc. nor the names of its

//       contributors may be used to endorse or promote products derived

//       from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

"use strict";

String.prototype.startsWith = function (str) {

  if (str.length > this.length) {

    return false;

  }

  return this.substr(0, str.length) == str;

};

function log10(num) {

  return Math.log(num)/Math.log(10);

}

function ToInspectableObject(obj) {

  if (!obj && typeof obj === 'object') {

    return UNDEFINED;

  } else {

    return Object(obj);

  }

}

function GetCompletions(global, last, full) {

  var full_tokens = full.split();

  full = full_tokens.pop();

  var parts = full.split('.');

  parts.pop();

  var current = global;

  for (var i = 0; i < parts.length; i++) {

    var part = parts[i];

    var next = current[part];

    if (!next) {

      return [];

    }

    current = next;

  }

  var result = [];

  current = ToInspectableObject(current);

  while (typeof current !== 'undefined') {

    var mirror = new $debug.ObjectMirror(current);

    var properties = mirror.properties();

    for (var i = 0; i < properties.length; i++) {

      var name = properties[i].name();

      if (typeof name === 'string' && name.startsWith(last)) {

        result.push(name);

      }

    }

    current = ToInspectableObject(Object.getPrototypeOf(current));

  }

  return result;

}

// Global object holding debugger related constants and state.

var Debug = {};

// Debug events which can occour in the V8 JavaScript engine. These originate

// from the API include file v8-debug.h.

Debug.DebugEvent = { Break: 1,

                     Exception: 2,

                     NewFunction: 3,

                     BeforeCompile: 4,

                     AfterCompile: 5 };

// The different types of scripts matching enum ScriptType in objects.h.

Debug.ScriptType = { Native: 0,

                     Extension: 1,

                     Normal: 2 };

// The different types of script compilations matching enum

// Script::CompilationType in objects.h.

Debug.ScriptCompilationType = { Host: 0,

                                Eval: 1,

                                JSON: 2 };

// The different types of scopes matching constants runtime.cc.

Debug.ScopeType = { Global: 0,

                    Local: 1,

                    With: 2,

                    Closure: 3,

                    Catch: 4,

                    Block: 5 };

// Current debug state.

var 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 = '';

var repeat_cmd_line = '';

var is_running = true;

// Global variable used to store whether a handle was requested.

var lookup_handle = null;

// 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) {

  var details = {text:'', running:false};

  // Get the running state.

  details.running = response.running();

  var body = response.body();

  var result = '';

  switch (response.event()) {

    case 'break':

      if (body.breakpoints) {

        result += 'breakpoint';

        if (body.breakpoints.length > 1) {

          result += 's';

        }

        result += ' #';

        for (var i = 0; i < body.breakpoints.length; i++) {

          if (i > 0) {

            result += ', #';

          }

          result += body.breakpoints[i];

        }

      } 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 = '';

  if (body.script) {

    if (body.script.name) {

      result += body.script.name;

    } else {

      result += '[unnamed]';

    }

  }

  result += ' line ';

  result += body.sourceLine + 1;

  result += ' column ';

  result += body.sourceColumn + 1;

  return result;

}

function SourceUnderline(source_text, position) {

  if (!source_text) {

    return;

  }

  // Create an underline with a caret pointing to the source position. If the

  // source contains a tab character the underline will have a tab character in

  // the same place otherwise the underline will have a space character.

  var underline = '';

  for (var i = 0; i < position; i++) {

    if (source_text[i] == '\t') {

      underline += '\t';

    } else {

      underline += ' ';

    }

  }

  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;

}

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_ = UNDEFINED;

    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');

      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_ = UNDEFINED;

      this.traceCommand_(args);

      break;

    case 'help':

    case '?':

      this.helpCommand_(args);

      // Return undefined to indicate command handled internally (no JSON).

      this.request_ = UNDEFINED;

      break;

    default:

      throw new Error('Unknown command "' + cmd + '"');

  }

}

DebugRequest.prototype.JSONRequest = function() {

  return this.request_;

};

function RequestPacket(command) {

  this.seq = 0;

  this.type = 'request';

  this.command = command;

}

RequestPacket.prototype.toJSONProtocol = function() {

  // Encode the protocol header.

  var json = '{';

  json += '"seq":' + this.seq;

  json += ',"type":"' + this.type + '"';

  if (this.command) {

    json += ',"command":' + StringToJSON_(this.command);

  }

  if (this.arguments) {

    json += ',"arguments":';

    // Encode the arguments part.

    if (this.arguments.toJSONProtocol) {

      json += this.arguments.toJSONProtocol();

    } else {

      json += SimpleObjectToJSON_(this.arguments);

    }

  }

  json += '}';

  return json;

};

DebugRequest.prototype.createRequest = function(command) {

  return new RequestPacket(command);

};

// Create a JSON request for the evaluation command.

DebugRequest.prototype.makeEvaluateJSONRequest_ = function(expression) {

  lookup_handle = null;

  // Check if the expression is a handle id in the form #<handle>#.

  var handle_match = expression.match(/^#([0-9]*)#$/);

  if (handle_match) {

    // Remember the handle requested in a global variable.

    lookup_handle = parseInt(handle_match[1]);

    // Build a lookup request.

    var request = this.createRequest('lookup');

    request.arguments = {};

    request.arguments.handles = [ lookup_handle ];

    return request.toJSONProtocol();

  } else {

    // Build an evaluate request.

    var request = this.createRequest('evaluate');

    request.arguments = {};

    request.arguments.expression = expression;

    // Request a global evaluation if there is no current frame.

    if (Debug.State.currentFrame == kNoFrame) {

      request.arguments.global = true;

    }

    return request.toJSONProtocol();

  }

};

// Create a JSON request for the references/instances command.

DebugRequest.prototype.makeReferencesJSONRequest_ = function(handle, type) {

  // Build a references request.

  var handle_match = handle.match(/^#([0-9]*)#$/);

  if (handle_match) {

    var request = this.createRequest('references');

    request.arguments = {};

    request.arguments.type = type;

    request.arguments.handle = parseInt(handle_match[1]);

    return request.toJSONProtocol();

  } else {

    throw new Error('Invalid object id.');

  }

};

// 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) {

  // 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);

    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 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 'next':

          case 'n':

            request.arguments.stepaction = 'next';

            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;

      }

    }

  } else {

    // Default is step of the specified type.

    request.arguments.stepaction = type;

  }

  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');

  // Default is to show top 10 frames.

  request.arguments = {};

  request.arguments.fromFrame = 0;

  request.arguments.toFrame = 10;

  args = args.split(/\s*[ ]+\s*/g);

  if (args.length == 1 && args[0].length > 0) {

    var frameCount = parseInt(args[0]);

    if (frameCount > 0) {

      // Show top frames.

      request.arguments.fromFrame = 0;

      request.arguments.toFrame = frameCount;

    } else {

      // Show bottom frames.

      request.arguments.fromFrame = 0;

      request.arguments.toFrame = -frameCount;

      request.arguments.bottom = true;

    }

  } else if (args.length == 2) {

    var fromFrame = parseInt(args[0]);

    var toFrame = parseInt(args[1]);

    if (isNaN(fromFrame) || fromFrame < 0) {

      throw new Error('Invalid start frame argument "' + args[0] + '".');

    }

    if (isNaN(toFrame) || toFrame < 0) {

      throw new Error('Invalid end frame argument "' + args[1] + '".');

    }

    if (fromFrame > toFrame) {

      throw new Error('Invalid arguments start frame cannot be larger ' +

                      'than end frame.');

    }

    // Show frame range.

    request.arguments.fromFrame = fromFrame;

    request.arguments.toFrame = toFrame + 1;

  } else if (args.length > 2) {

    throw new Error('Invalid backtrace arguments.');

  }

  return request.toJSONProtocol();

};

// Create a JSON request for the frame command.

DebugRequest.prototype.frameCommandToJSONRequest_ = function(args) {

  // Build a frame request from the text command.

  var request = this.createRequest('frame');

  args = args.split(/\s*[ ]+\s*/g);

  if (args.length > 0 && args[0].length > 0) {

    request.arguments = {};

    request.arguments.number = args[0];

  }

  return request.toJSONProtocol();

};

// Create a JSON request for the scopes command.

DebugRequest.prototype.scopesCommandToJSONRequest_ = function(args) {

  // Build a scopes request from the text command.

  var request = this.createRequest('scopes');

  return request.toJSONProtocol();

};

// Create a JSON request for the scope command.

DebugRequest.prototype.scopeCommandToJSONRequest_ = function(args) {

  // Build a scope request from the text command.

  var request = this.createRequest('scope');

  args = args.split(/\s*[ ]+\s*/g);

  if (args.length > 0 && args[0].length > 0) {

    request.arguments = {};

    request.arguments.number = args[0];

  }

  return request.toJSONProtocol();

};

// Create a JSON request for the print command.

DebugRequest.prototype.printCommandToJSONRequest_ = function(args) {

  // Build an evaluate request from the text command.

  if (args.length == 0) {

    throw new Error('Missing expression.');

  }

  return this.makeEvaluateJSONRequest_(args);

};

// Create a JSON request for the dir command.

DebugRequest.prototype.dirCommandToJSONRequest_ = function(args) {

  // Build an evaluate request from the text command.

  if (args.length == 0) {

    throw new Error('Missing expression.');

  }

  return this.makeEvaluateJSONRequest_(args);

};

// Create a JSON request for the references command.

DebugRequest.prototype.referencesCommandToJSONRequest_ = function(args) {

  // Build an evaluate request from the text command.

  if (args.length == 0) {

    throw new Error('Missing object id.');

  }

  return this.makeReferencesJSONRequest_(args, 'referencedBy');

};

// Create a JSON request for the instances command.

DebugRequest.prototype.instancesCommandToJSONRequest_ = function(args) {

  // 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.

  args = args.split(/\s*[ ]+\s*/g);

  if (args.length > 1 && args[0].length > 0 && args[1].length > 0) {

    from = parseInt(args[0]) - 1;

    lines = parseInt(args[1]);

  } else if (args.length > 0 && args[0].length > 0) {

    from = parseInt(args[0]) - 1;

  }

  if (from < 0) from = 0;

  if (lines < 0) lines = 10;

  // Request source arround current source location.

  request.arguments = {};

  request.arguments.fromLine = from;

  request.arguments.toLine = from + lines;

  return request.toJSONProtocol();

};

// Create a JSON request for the scripts command.

DebugRequest.prototype.scriptsCommandToJSONRequest_ = function(args) {

  // Build a evaluate request from the text command.

  var request = this.createRequest('scripts');

  // Process arguments if any.

  if (args && args.length > 0) {

    args = args.split(/\s*[ ]+\s*/g);

    if (args.length > 1) {

      throw new Error('Invalid scripts arguments.');

    }

    request.arguments = {};

    switch (args[0]) {

      case 'natives':

        request.arguments.types = ScriptTypeFlag(Debug.ScriptType.Native);

        break;

      case 'extensions':

        request.arguments.types = ScriptTypeFlag(Debug.ScriptType.Extension);

        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;

    }

  }

  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(':');

    if (pos > 0) {

      var tmp = target.substring(pos + 1, target.length);

      target = target.substring(0, pos);

      if (target[0] == '/' && target[target.length - 1] == '/') {

        type = 'scriptRegExp';

        target = target.substring(1, target.length - 1);

      } else {

        type = 'script';

      }

      // Check for both line and column.

      pos = tmp.indexOf(':');

      if (pos > 0) {

        column = parseInt(tmp.substring(pos + 1, tmp.length)) - 1;

        line = parseInt(tmp.substring(0, pos)) - 1;

      } else {

        line = parseInt(tmp) - 1;

      }

    } else if (target[0] == '#' && target[target.length - 1] == '#') {

      type = 'handle';

      target = target.substring(1, target.length - 1);

    } else {

      type = 'function';

    }

    request.arguments = {};

    request.arguments.type = type;

    request.arguments.target = target;

    request.arguments.line = line;

    request.arguments.column = column;

    request.arguments.condition = condition;

  } else {

    var request = this.createRequest('suspend');

  }

  return request.toJSONProtocol();

};

DebugRequest.prototype.breakpointsCommandToJSONRequest_ = function(args) {

  if (args && args.length > 0) {

    throw new Error('Unexpected arguments.');

  }

  var request = this.createRequest('listbreakpoints');

  return request.toJSONProtocol();

};

// Create a JSON request for the clear command.

DebugRequest.prototype.clearCommandToJSONRequest_ = function(args) {

  // Build a evaluate request from the text command.

  var request = this.createRequest('clearbreakpoint');

  // Process arguments if any.

  if (args && args.length > 0) {

    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.

      } else 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'; }