text: // 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.
  
  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 };
  
  
  // 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 };
  
  
  // 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 'scopes':
        this.request_ = this.scopesCommandToJSONRequest_(args);
        break;
        
      case 'scope':
        this.request_ = this.scopeCommandToJSONRequest_(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) {
    // Global varaible used to store whether a handle was requested.
    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) {
    // 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');
    
    // 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 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 type = 'function';
      var line;
      var column;
      var condition;
      var pos;
  
      // 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) {
        type = 'script';
        var tmp = target.substring(pos + 1, target.length);
        target = target.substring(0, pos);
        
        // 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 {
      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('  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('step [in | next | out| min [step count]]');
    print('print <expression>');
    print('dir <expression>');
    print('source [from line [num lines]]');
    print('scripts');
    print('continue');
    print('trace compile');
    print('help');
  }
  
  
  function formatHandleReference_(value) {
    if (value.handle() >= 0) {
      return '#' + value.handle() + '#';
    } else {
      return '#Transient#';
    }
  }
  
  
  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 instanceof ProtocolReference) {
          result += '<no type>';
        } else {
          if (property_value && property_value.type()) {
            result += property_value.type();
          } else {
            result += '<no type>';
          }
        }
        result += ' ';
        result += formatHandleReference_(property_value);
        result += '\n';
      }
    }
    return result;
  }
  
  
  function formatScope_(scope) {
    var result = '';
    var index = scope.index;
    result += '#' + (index <= 9 ? '0' : '') + index;
    result += ' ';
    switch (scope.type) {
      case Debug.ScopeType.Global:
        result += 'Global, ';
        result += '#' + scope.object.ref + '#';
        break;
      case Debug.ScopeType.Local:
        result += 'Local';
        break;
      case Debug.ScopeType.With:
        result += 'With, ';
        result += '#' + scope.object.ref + '#';
        break;
      case Debug.ScopeType.Catch:
        result += 'Catch, ';
        result += '#' + scope.object.ref + '#';
        break;
      case Debug.ScopeType.Closure:
        result += 'Closure';
        break;
      default:
        result += 'UNKNOWN';
    }
    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 '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) {
                result += '\n';
              }
              result += formatScope_(body.scopes[i]);
            }
          }
          details.text = result;
          break;
  
        case 'scope':
          result += formatScope_(body);
          result += '\n';
          var scope_object_value = response.lookup(body.object.ref);
          result += formatObject_(scope_object_value, true);
          details.text = result;
          break;
        
        case 'evaluate':
        case 'lookup':
          if (last_cmd == 'p' || last_cmd == 'print') {
            result = body.text;
          } else {
            var value;
            if (lookup_handle) {
              value = response.bodyValue(lookup_handle);
            } else {
              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 {
              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 += ']';
          }
          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_ = JSON.parse(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 != null) {
      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;
  }
  
  
  /**
   * Get a metadata field from a protocol value. 
   * @return {Object} the metadata field value
   */
  ProtocolValue.prototype.field = function(name) {
    return this.value_[name];
  }
  
  
  /**
   * 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;
  }
  
  
  /**
   * Return index for the property name.
   * @param name The property name to look for
   * @return {number} index for the property name
   */
  ProtocolValue.prototype.propertyIndex = function(name) {
    for (var i = 0; i < this.propertyCount(); i++) {
      if (this.value_.properties[i].name == name) {
        return i;
      }
    }
    return null;
  }
  
  
  /**
   * Get the specified property value.
   * @return {ProtocolValue} property value
   */
  ProtocolValue.prototype.propertyValue = function(index) {
    var property = this.value_.properties[index];
    return this.packet_.lookup(property.ref);
  }
  
  
  /**
   * Check is the value is a string.
   * @return {boolean} true if the value is a string
   */
  ProtocolValue.prototype.value = function() {
    return this.value_.value;
  }
  
  
  function ProtocolReference(handle) {
    this.handle_ = handle;
  }
  
  
  ProtocolReference.prototype.handle = function() {
    return this.handle_;
  }
  
  
  function MakeJSONPair_(name, value) {
    return '"' + name + '":' + value;
  }
  
  
  function ArrayToJSONObject_(content) {
    return '{' + content.join(',') + '}';
  }
  
  
  function ArrayToJSONArray_(content) {
    return '[' + content.join(',') + ']';
  }
  
  
  function BooleanToJSON_(value) {
    return String(value); 
  }
  
  
  function NumberToJSON_(value) {
    return String(value); 
  }
  
  
  // Mapping of some control characters to avoid the \uXXXX syntax for most
  // commonly used control cahracters.
  const ctrlCharMap_ = {
    '\b': '\\b',
    '\t': '\\t',
    '\n': '\\n',
    '\f': '\\f',
    '\r': '\\r',
    '"' : '\\"',
    '\\': '\\\\'
  };
  
  
  // Regular expression testing for ", \ and control characters (0x00 - 0x1F).
  const ctrlCharTest_ = new RegExp('["\\\\\x00-\x1F]');
  
  
  // Regular expression matching ", \ and control characters (0x00 - 0x1F)
  // globally.
  const ctrlCharMatch_ = new RegExp('["\\\\\x00-\x1F]', 'g');
  
  
  /**
   * Convert a String to its JSON representation (see http://www.json.org/). To
   * avoid depending on the String object this method calls the functions in
   * string.js directly and not through the value.
   * @param {String} value The String value to format as JSON
   * @return {string} JSON formatted String value
   */
  function StringToJSON_(value) {
    // Check for" , \ and control characters (0x00 - 0x1F). No need to call
    // RegExpTest as ctrlchar is constructed using RegExp.
    if (ctrlCharTest_.test(value)) {
      // Replace ", \ and control characters (0x00 - 0x1F).
      return '"' +
        value.replace(ctrlCharMatch_, function (char) {
          // Use charmap if possible.
          var mapped = ctrlCharMap_[char];
          if (mapped) return mapped;
          mapped = char.charCodeAt();
          // Convert control character to unicode escape sequence.
          return '\\u00' +
            '0' + // TODO %NumberToRadixString(Math.floor(mapped / 16), 16) +
            '0' // TODO %NumberToRadixString(mapped % 16, 16);
        })
      + '"';
    }
  
    // Simple string with no special characters.
    return '"' + value + '"';
  }
  
  
  /**
   * Convert a Date to ISO 8601 format. To avoid depending on the Date object
   * this method calls the functions in date.js directly and not through the
   * value.
   * @param {Date} value The Date value to format as JSON
   * @return {string} JSON formatted Date value
   */
  function DateToISO8601_(value) {
    function f(n) {
      return n < 10 ? '0' + n : n;
    }
    function g(n) {
      return n < 10 ? '00' + n : n < 100 ? '0' + n : n;
    }
    return builtins.GetUTCFullYearFrom(value)         + '-' +
            f(builtins.GetUTCMonthFrom(value) + 1)    + '-' +
            f(builtins.GetUTCDateFrom(value))         + 'T' +
            f(builtins.GetUTCHoursFrom(value))        + ':' +
            f(builtins.GetUTCMinutesFrom(value))      + ':' +
            f(builtins.GetUTCSecondsFrom(value))      + '.' +
            g(builtins.GetUTCMillisecondsFrom(value)) + 'Z';
  }
  
  
  /**
   * Convert a Date to ISO 8601 format. To avoid depending on the Date object
   * this method calls the functions in date.js directly and not through the
   * value.
   * @param {Date} value The Date value to format as JSON
   * @return {string} JSON formatted Date value
   */
  function DateToJSON_(value) {
    return '"' + DateToISO8601_(value) + '"';
  }
  
  
  /**
   * Convert an Object to its JSON representation (see http://www.json.org/).
   * This implementation simply runs through all string property names and adds
   * each property to the JSON representation for some predefined types. For type
   * "object" the function calls itself recursively unless the object has the
   * function property "toJSONProtocol" in which case that is used. This is not
   * a general implementation but sufficient for the debugger. Note that circular
   * structures will cause infinite recursion.
   * @param {Object} object The object to format as JSON
   * @return {string} JSON formatted object value
   */
  function SimpleObjectToJSON_(object) {
    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 (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);
            break;
  
          case 'number':
            property_value_json = NumberToJSON_(property_value);
            break;
  
          case 'string':
            property_value_json = StringToJSON_(property_value);
            break;
  
          default:
            property_value_json = null;
        }
  
        // Add the property if relevant.
        if (property_value_json) {
          content.push(StringToJSON_(key) + ':' + property_value_json);
        }
      }
    }
  
    // Make JSON object representation.
    return '{' + content.join(',') + '}';
  }
  
  
  /**
   * Convert an array to its JSON representation. This is a VERY simple
   * implementation just to support what is needed for the debugger.
   * @param {Array} arrya The array to format as JSON
   * @return {string} JSON formatted array value
   */
  function SimpleArrayToJSON_(array) {
    // Make JSON array representation.
    var json = '[';
    for (var i = 0; i < array.length; i++) {
      if (i != 0) {
        json += ',';
      }
      var elem = array[i];
      if (elem.toJSONProtocol) {
        json += elem.toJSONProtocol(true)
      } else if (typeof(elem) === 'object')  {
        json += SimpleObjectToJSON_(elem);
      } else if (typeof(elem) === 'boolean')  {
        json += BooleanToJSON_(elem);
      } else if (typeof(elem) === 'number')  {
        json += NumberToJSON_(elem);
      } else if (typeof(elem) === 'string')  {
        json += StringToJSON_(elem);
      } else {
        json += elem;
      }
    }
    json += ']';
    return json;
  }
  