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.

// How crappy is it that I have to implement completely basic stuff

// like this myself?  Answer: very.

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 void 0;

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

  }

  return result;

}

// Global object holding debugger related constants and state.

const 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 };

// Current debug state.

const kNoFrame = -1;

Debug.State = {

  currentFrame: kNoFrame,

  currentSourceLine: -1

}

var trace_compile = false;  // Tracing all compile events?

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

  // Convert the JSON string to an object.

  var response = new ProtocolPackage(message);

  if (response.type() == 'event') {

    return DebugEventDetails(response);

  } else {

    return DebugResponseDetails(response);

  }

}

function DebugEventDetails(response) {

  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.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.currentFrame = 0;

      } else {

        result += ' (empty stack)';

        Debug.State.currentSourceLine = -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;

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

  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;

  }

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

  }

  // Switch on command.

  switch (cmd) {

    case 'continue':

    case 'c':

      this.request_ = this.continueCommandToJSONRequest_(args);

      break;

    case 'step':

    case 's':

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

      this.request_ = this.sourceCommandToJSONRequest_(args);

      break;

    case 'scripts':

      this.request_ = this.scriptsCommandToJSONRequest_(args);

      break;

    case 'break':

    case 'b':

      this.request_ = this.breakCommandToJSONRequest_(args);

      break;

    case 'clear':

      this.request_ = this.clearCommandToJSONRequest_(args);

      break;

    case 'threads':

      this.request_ = this.threadsCommandToJSONRequest_(args);

      break;

    case 'trace':

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

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

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

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

  if (handle_match) {

    // Build a lookup request.

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

    request.arguments = {};

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

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

  // Requesting a step is through the continue command with additional

  // arguments.

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

  request.arguments = {};

  // Process arguments if any.

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

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

    if (args.length > 2) {

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

    }

    if (args.length > 0) {

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

        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 {

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

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

  if (args.length == 2) {

    request.arguments = {};

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

    }

    request.arguments.fromFrame = fromFrame;

    request.arguments.toFrame = toFrame + 1;

  }

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

        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.

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

  // Process arguments if any.

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

    var target = args;

    var condition;

    var pos = args.indexOf(' ');

    if (pos > 0) {

      target = args.substring(0, pos);

      condition = args.substring(pos + 1, args.length);

    }

    request.arguments = {};

    request.arguments.type = 'function';

    request.arguments.target = target;

    request.arguments.condition = condition;

  } else {

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

  }

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

      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('break location [condition]');

  print('clear <breakpoint #>');

  print('backtrace [from frame #] [to frame #]]');

  print('frame <frame #>');

  print('step [in | next | out| min [step count]]');

  print('print <expression>');

  print('source [from line [num lines]]');

  print('scripts');

  print('continue');

  print('trace compile');

  print('help');

}

function formatHandleReference_(value) {

  return '#' + value.handle() + '#';

}

function formatObject_(value, include_properties) {

  var result = '';

  result += formatHandleReference_(value);

  result += ', type: object'

  result += ', constructor ';

  var ctor = value.constructorFunctionValue();

  result += formatHandleReference_(ctor);

  result += ', __proto__ ';

  var proto = value.protoObjectValue();

  result += formatHandleReference_(proto);

  result += ', ';

  result += value.propertyCount();

  result +=  ' properties.';

  if (include_properties) {

    result +=  '\n';

    for (var i = 0; i < value.propertyCount(); i++) {

      result += '  ';

      result += value.propertyName(i);

      result += ': ';

      var property_value = value.propertyValue(i);

      if (property_value && property_value.type()) {

        result += property_value.type();

      } else {

        result += '<no type>';

      }

      result += ' ';

      result += formatHandleReference_(property_value);

      result += '\n';

    }

  }

  return result;

}

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

    }

    // Get the running state.

    details.running = response.running();

    var body = response.body();

    var result = '';

    switch (response.command()) {

      case 'setbreakpoint':

        result = 'set breakpoint #';

        result += body.breakpoint;

        details.text = result;

        break;

      case 'clearbreakpoint':

        result = 'cleared breakpoint #';

        result += body.breakpoint;

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

        details.text = SourceUnderline(body.sourceLineText,

                                       body.column);

        Debug.State.currentSourceLine = body.line;

        Debug.State.currentFrame = body.index;

        break;

      case 'evaluate':

      case 'lookup':

        if (last_cmd == 'p' || last_cmd == 'print') {

          result = body.text;

        } else {

          var value = response.bodyValue();

          if (value.isObject()) {

            result += formatObject_(value, true);

          } else {

            result += 'type: ';

            result += value.type();

            if (!value.isUndefined() && !value.isNull()) {

              result += ', ';

              if (value.isString()) {

                result += '"';

              }

              result += value.value();

              if (value.isString()) {

                result += '"';

              }

            }

            result += '\n';

          }

        }

        details.text = result;

        break;

      case 'references':

        var count = body.length;

        result += 'found ' + count + ' objects';

        result += '\n';

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

          var value = response.bodyValue(i);

          result += formatObject_(value, false);

          result += '\n';

        }

        details.text = result;

        break;

      case 'source':

        // Get the source from the response.

        var source = body.source;

        var from_line = body.fromLine + 1;

        var lines = source.split('\n');

        var maxdigits = 1 + Math.floor(log10(from_line + lines.length));

        if (maxdigits < 3) {

          maxdigits = 3;

        }

        var result = '';

        for (var num = 0; num < lines.length; num++) {

          // Check if there's an extra newline at the end.

          if (num == (lines.length - 1) && lines[num].length == 0) {

            break;

          }

          var current_line = from_line + num;

          spacer = maxdigits - (1 + Math.floor(log10(current_line)));

          if (current_line == Debug.State.currentSourceLine + 1) {

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

              result += '>';

            }

            result += '  ';

          } else {

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

              result += ' ';

            }

            result += current_line + ': ';

          }

          result += lines[num];

          result += '\n';

        }

        details.text = result;

        break;

      case 'scripts':

        var result = '';

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

          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 {

            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 += ']';

        }

        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;

      default:

        details.text =

            'Response for unknown command \'' + response.command + '\'' +

            ' (' + json_response + ')';

    }

  } catch (e) {

    details.text = 'Error: "' + e + '" formatting response';

  }

  return details;

};

/**

 * Protocol packages send from the debugger.

 * @param {string} json - raw protocol packet as JSON string.

 * @constructor

 */

function ProtocolPackage(json) {

  this.packet_ = eval('(' + json + ')');

  this.refs_ = [];

  if (this.packet_.refs) {

    for (var i = 0; i < this.packet_.refs.length; i++) {

      this.refs_[this.packet_.refs[i].handle] = this.packet_.refs[i];

    }

  }

}

/**

 * Get the packet type.

 * @return {String} the packet type

 */

ProtocolPackage.prototype.type = function() {

  return this.packet_.type;

}

/**

 * Get the packet event.

 * @return {Object} the packet event

 */

ProtocolPackage.prototype.event = function() {

  return this.packet_.event;

}

/**

 * Get the packet request sequence.

 * @return {number} the packet request sequence

 */

ProtocolPackage.prototype.requestSeq = function() {

  return this.packet_.request_seq;

}

/**

 * Get the packet request sequence.

 * @return {number} the packet request sequence

 */

ProtocolPackage.prototype.running = function() {

  return this.packet_.running ? true : false;

}

ProtocolPackage.prototype.success = function() {

  return this.packet_.success ? true : false;

}

ProtocolPackage.prototype.message = function() {

  return this.packet_.message;

}

ProtocolPackage.prototype.command = function() {

  return this.packet_.command;

}

ProtocolPackage.prototype.body = function() {

  return this.packet_.body;

}

ProtocolPackage.prototype.bodyValue = function(index) {

  if (index) {

    return new ProtocolValue(this.packet_.body[index], this);

  } else {

    return new ProtocolValue(this.packet_.body, this);

  }

}

ProtocolPackage.prototype.body = function() {

  return this.packet_.body;

}

ProtocolPackage.prototype.lookup = function(handle) {

  var value = this.refs_[handle];

  if (value) {

    return new ProtocolValue(value, this);

  } else {

    return new ProtocolReference(handle);

  }

}

function ProtocolValue(value, packet) {

  this.value_ = value;

  this.packet_ = packet;

}

/**

 * Get the value type.

 * @return {String} the value type

 */

ProtocolValue.prototype.type = function() {

  return this.value_.type;

}

/**

 * Check is the value is a primitive value.

 * @return {boolean} true if the value is primitive

 */

ProtocolValue.prototype.isPrimitive = function() {

  return this.isUndefined() || this.isNull() || this.isBoolean() ||

         this.isNumber() || this.isString();

}

/**

 * Get the object handle.

 * @return {number} the value handle

 */

ProtocolValue.prototype.handle = function() {

  return this.value_.handle;

}

/**

 * Check is the value is undefined.

 * @return {boolean} true if the value is undefined

 */

ProtocolValue.prototype.isUndefined = function() {

  return this.value_.type == 'undefined';

}

/**

 * Check is the value is null.

 * @return {boolean} true if the value is null

 */

ProtocolValue.prototype.isNull = function() {

  return this.value_.type == 'null';

}

/**

 * Check is the value is a boolean.

 * @return {boolean} true if the value is a boolean

 */

ProtocolValue.prototype.isBoolean = function() {

  return this.value_.type == 'boolean';

}

/**

 * Check is the value is a number.

 * @return {boolean} true if the value is a number

 */

ProtocolValue.prototype.isNumber = function() {

  return this.value_.type == 'number';

}

/**

 * Check is the value is a string.

 * @return {boolean} true if the value is a string

 */

ProtocolValue.prototype.isString = function() {

  return this.value_.type == 'string';

}

/**

 * Check is the value is an object.

 * @return {boolean} true if the value is an object

 */

ProtocolValue.prototype.isObject = function() {

  return this.value_.type == 'object' || this.value_.type == 'function' ||

         this.value_.type == 'error' || this.value_.type == 'regexp';

}

/**

 * Get the constructor function

 * @return {ProtocolValue} constructor function

 */

ProtocolValue.prototype.constructorFunctionValue = function() {

  var ctor = this.value_.constructorFunction;

  return this.packet_.lookup(ctor.ref);

}

/**

 * Get the __proto__ value

 * @return {ProtocolValue} __proto__ value

 */

ProtocolValue.prototype.protoObjectValue = function() {

  var proto = this.value_.protoObject;

  return this.packet_.lookup(proto.ref);

}

/**

 * Get the number og properties.

 * @return {number} the number of properties

 */

ProtocolValue.prototype.propertyCount = function() {

  return this.value_.properties ? this.value_.properties.length : 0;

}

/**

 * Get the specified property name.

 * @return {string} property name

 */

ProtocolValue.prototype.propertyName = function(index) {

  var property = this.value_.properties[index];

  return property.name;

}