Debugger: load debugger builtins as normal native JS.

src/debug/debug.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+
+(function (global, utils) {
 "use strict";
 
+// ----------------------------------------------------------------------------
+// Imports
+
+var FrameMirror = global.FrameMirror;
+var GlobalArray = global.Array;
+var GlobalRegExp = global.RegExp;
+var IsNaN = global.isNaN;
+var JSONParse = global.JSON.parse;
+var JSONStringify = global.JSON.stringify;
+var LookupMirror = global.LookupMirror;
+var MakeMirror = global.MakeMirror;
+var MakeMirrorSerializer = global.MakeMirrorSerializer;
+var MathMin = global.Math.min;
+var Mirror = global.Mirror;
+var MirrorType;
+var ParseInt = global.parseInt;
+var ValueMirror = global.ValueMirror;
+
+utils.Import(function(from) {
+  MirrorType = from.MirrorType;
+});
+
+//----------------------------------------------------------------------------
+
 // Default number of frames to include in the response to backtrace request.
 var kDefaultBacktraceLength = 10;
 
 var Debug = {};
 
 // Regular expression to skip "crud" at the beginning of a source line which is
 // not really code. Currently the regular expression matches whitespace and
 // comments.
 var sourceLineBeginningSkip = /^(?:\s*(?:\/\*.*?\*\/)*)*/;
 
@@ skipping 179 matching lines @@
 BreakPoint.prototype.isTriggered = function(exec_state) {
   // Break point not active - not triggered.
   if (!this.active()) return false;
 
   // Check for conditional break point.
   if (this.condition()) {
     // If break point has condition try to evaluate it in the top frame.
     try {
       var mirror = exec_state.frame(0).evaluate(this.condition());
       // If no sensible mirror or non true value break point not triggered.
-      if (!(mirror instanceof ValueMirror) ||
-          !builtins.$toBoolean(mirror.value_)) {
+      if (!(mirror instanceof ValueMirror) || !$toBoolean(mirror.value_)) {
         return false;
       }
     } catch (e) {
       // Exception evaluating condition counts as not triggered.
       return false;
     }
   }
 
   // Update the hit count.
   this.hit_count_++;
@@ skipping 23 matching lines @@
 // script name or script id and the break point is represented as line and
 // column.
 function ScriptBreakPoint(type, script_id_or_name, opt_line, opt_column,
                           opt_groupId, opt_position_alignment) {
   this.type_ = type;
   if (type == Debug.ScriptBreakPointType.ScriptId) {
     this.script_id_ = script_id_or_name;
   } else if (type == Debug.ScriptBreakPointType.ScriptName) {
     this.script_name_ = script_id_or_name;
   } else if (type == Debug.ScriptBreakPointType.ScriptRegExp) {
-    this.script_regexp_object_ = new RegExp(script_id_or_name);
+    this.script_regexp_object_ = new GlobalRegExp(script_id_or_name);
   } else {
-    throw new Error("Unexpected breakpoint type " + type);
+    throw MakeError(kDebugger, "Unexpected breakpoint type " + type);
   }
   this.line_ = opt_line || 0;
   this.column_ = opt_column;
   this.groupId_ = opt_groupId;
   this.position_alignment_ = IS_UNDEFINED(opt_position_alignment)
       ? Debug.BreakPositionAlignment.Statement : opt_position_alignment;
   this.hit_count_ = 0;
   this.active_ = true;
   this.condition_ = null;
   this.ignoreCount_ = 0;
@@ skipping 126 matching lines @@
     // We might want to account columns here as well.
     if (!(script.line_offset <= this.line_  &&
           this.line_ < script.line_offset + script.lineCount())) {
       return false;
     }
     if (this.type_ == Debug.ScriptBreakPointType.ScriptName) {
       return this.script_name_ == script.nameOrSourceURL();
     } else if (this.type_ == Debug.ScriptBreakPointType.ScriptRegExp) {
       return this.script_regexp_object_.test(script.nameOrSourceURL());
     } else {
-      throw new Error("Unexpected breakpoint type " + this.type_);
+      throw MakeError(kDebugger, "Unexpected breakpoint type " + this.type_);
     }
   }
 };
 
 
 // Set the script break point in a script.
 ScriptBreakPoint.prototype.set = function (script) {
   var column = this.column();
   var line = this.line();
   // If the column is undefined the break is on the line. To help locate the
   // first piece of breakable code on the line try to find the column on the
   // line which contains some source.
   if (IS_UNDEFINED(column)) {
     var source_line = script.sourceLine(this.line());
 
     // Allocate array for caching the columns where the actual source starts.
     if (!script.sourceColumnStart_) {
-      script.sourceColumnStart_ = new Array(script.lineCount());
+      script.sourceColumnStart_ = new GlobalArray(script.lineCount());
     }
 
     // Fill cache if needed and get column where the actual source starts.
     if (IS_UNDEFINED(script.sourceColumnStart_[line])) {
       script.sourceColumnStart_[line] =
           source_line.match(sourceLineBeginningSkip)[0].length;
     }
     column = script.sourceColumnStart_[line];
   }
 
@@ skipping 58 matching lines @@
     if (script_break_points[i].matchesScript(script)) {
       result.push(script_break_points[i]);
     }
   }
   return result;
 }
 
 
 Debug.setListener = function(listener, opt_data) {
   if (!IS_FUNCTION(listener) && !IS_UNDEFINED(listener) && !IS_NULL(listener)) {
-    throw new Error('Parameters have wrong types.');
+    throw MakeTypeError(kDebuggerType);
   }
   %SetDebugEventListener(listener, opt_data);
 };
 
 
 Debug.breakLocations = function(f, opt_position_aligment) {
-  if (!IS_FUNCTION(f)) throw new Error('Parameters have wrong types.');
+  if (!IS_FUNCTION(f)) throw MakeTypeError(kDebuggerType);
   var position_aligment = IS_UNDEFINED(opt_position_aligment)
       ? Debug.BreakPositionAlignment.Statement : opt_position_aligment;
   return %GetBreakLocations(f, position_aligment);
 };
 
 // Returns a Script object. If the parameter is a function the return value
 // is the script in which the function is defined. If the parameter is a string
 // the return value is the script for which the script name has that string
 // value.  If it is a regexp and there is a unique script whose name matches
 // we return that, otherwise undefined.
@@ skipping 12 matching lines @@
       }
     }
     // Return the unique script matching the regexp.  If there are more
     // than one we don't return a value since there is no good way to
     // decide which one to return.  Returning a "random" one, say the
     // first, would introduce nondeterminism (or something close to it)
     // because the order is the heap iteration order.
     if (result_count == 1) {
       return last_result;
     } else {
-      return undefined;
+      return UNDEFINED;
     }
   } else {
     return %GetScript(func_or_script_name);
   }
 };
 
 // Returns the script source. If the parameter is a function the return value
 // is the script source for the script in which the function is defined. If the
 // parameter is a string the return value is the script for which the script
 // name has that string value.
 Debug.scriptSource = function(func_or_script_name) {
   return this.findScript(func_or_script_name).source;
 };
 
 
 Debug.source = function(f) {
-  if (!IS_FUNCTION(f)) throw new Error('Parameters have wrong types.');
+  if (!IS_FUNCTION(f)) throw MakeTypeError(kDebuggerType);
   return %FunctionGetSourceCode(f);
 };
 
 
 Debug.sourcePosition = function(f) {
-  if (!IS_FUNCTION(f)) throw new Error('Parameters have wrong types.');
+  if (!IS_FUNCTION(f)) throw MakeTypeError(kDebuggerType);
   return %FunctionGetScriptSourcePosition(f);
 };
 
 
 Debug.findFunctionSourceLocation = function(func, opt_line, opt_column) {
   var script = %FunctionGetScript(func);
   var script_offset = %FunctionGetScriptSourcePosition(func);
   return script.locationFromLine(opt_line, opt_column, script_offset);
 };
 
@@ skipping 33 matching lines @@
   }
   for (var i = 0; i < break_points.length; i++) {
     if (break_points[i].number() == break_point_number) {
       return [break_points[i].actual_location];
     }
   }
   return [];
 };
 
 Debug.setBreakPoint = function(func, opt_line, opt_column, opt_condition) {
-  if (!IS_FUNCTION(func)) throw new Error('Parameters have wrong types.');
+  if (!IS_FUNCTION(func)) throw MakeTypeError(kDebuggerType);
   // Break points in API functions are not supported.
   if (%FunctionIsAPIFunction(func)) {
-    throw new Error('Cannot set break point in native code.');
+    throw MakeError(kDebugger, 'Cannot set break point in native code.');
   }
   // Find source position relative to start of the function
   var break_position =
       this.findFunctionSourceLocation(func, opt_line, opt_column).position;
   var source_position = break_position - this.sourcePosition(func);
   // Find the script for the function.
   var script = %FunctionGetScript(func);
   // Break in builtin JavaScript code is not supported.
   if (script.type == Debug.ScriptType.Native) {
-    throw new Error('Cannot set break point in native code.');
+    throw MakeError(kDebugger, 'Cannot set break point in native code.');
   }
   // If the script for the function has a name convert this to a script break
   // point.
   if (script && script.id) {
     // Adjust the source position to be script relative.
     source_position += %FunctionGetScriptSourcePosition(func);
     // Find line and column for the position in the script and set a script
     // break point from that.
     var location = script.locationFromPosition(source_position, false);
     return this.setScriptBreakPointById(script.id,
@@ skipping 56 matching lines @@
 };
 
 
 Debug.changeBreakPointCondition = function(break_point_number, condition) {
   var break_point = this.findBreakPoint(break_point_number, false);
   break_point.setCondition(condition);
 };
 
 
 Debug.changeBreakPointIgnoreCount = function(break_point_number, ignoreCount) {
-  if (ignoreCount < 0) {
-    throw new Error('Invalid argument');
-  }
+  if (ignoreCount < 0) throw MakeError(kDebugger, 'Invalid argument');
   var break_point = this.findBreakPoint(break_point_number, false);
   break_point.setIgnoreCount(ignoreCount);
 };
 
 
 Debug.clearBreakPoint = function(break_point_number) {
   var break_point = this.findBreakPoint(break_point_number, true);
   if (break_point) {
     return %ClearBreakPoint(break_point);
   } else {
     break_point = this.findScriptBreakPoint(break_point_number, true);
-    if (!break_point) {
-      throw new Error('Invalid breakpoint');
-    }
+    if (!break_point) throw MakeError(kDebugger, 'Invalid breakpoint');
   }
 };
 
 
 Debug.clearAllBreakPoints = function() {
   for (var i = 0; i < break_points.length; i++) {
     var break_point = break_points[i];
     %ClearBreakPoint(break_point);
   }
   break_points = [];
@@ skipping 99 matching lines @@
 
 Debug.changeScriptBreakPointCondition = function(
     break_point_number, condition) {
   var script_break_point = this.findScriptBreakPoint(break_point_number, false);
   script_break_point.setCondition(condition);
 };
 
 
 Debug.changeScriptBreakPointIgnoreCount = function(
     break_point_number, ignoreCount) {
-  if (ignoreCount < 0) {
-    throw new Error('Invalid argument');
-  }
+  if (ignoreCount < 0) throw MakeError(kDebugger, 'Invalid argument');
   var script_break_point = this.findScriptBreakPoint(break_point_number, false);
   script_break_point.setIgnoreCount(ignoreCount);
 };
 
 
 Debug.scriptBreakPoints = function() {
   return script_break_points;
 };
 
 
@@ skipping 19 matching lines @@
 
 Debug.clearBreakOnUncaughtException = function() {
   return %ChangeBreakOnException(Debug.ExceptionBreak.Uncaught, false);
 };
 
 Debug.isBreakOnUncaughtException = function() {
   return !!%IsBreakOnException(Debug.ExceptionBreak.Uncaught);
 };
 
 Debug.showBreakPoints = function(f, full, opt_position_alignment) {
-  if (!IS_FUNCTION(f)) throw new Error('Parameters have wrong types.');
+  if (!IS_FUNCTION(f)) throw MakeError(kDebuggerType);
   var source = full ? this.scriptSource(f) : this.source(f);
   var offset = full ? this.sourcePosition(f) : 0;
   var locations = this.breakLocations(f, opt_position_alignment);
   if (!locations) return source;
   locations.sort(function(x, y) { return x - y; });
   var result = "";
   var prev_pos = 0;
   var pos;
   for (var i = 0; i < locations.length; i++) {
     pos = locations[i] - offset;
@@ skipping 26 matching lines @@
 }
 
 function ExecutionState(break_id) {
   this.break_id = break_id;
   this.selected_frame = 0;
 }
 
 ExecutionState.prototype.prepareStep = function(opt_action, opt_count,
     opt_callframe) {
   var action = Debug.StepAction.StepIn;
-  if (!IS_UNDEFINED(opt_action)) action = builtins.$toNumber(opt_action);
-  var count = opt_count ? builtins.$toNumber(opt_count) : 1;
+  if (!IS_UNDEFINED(opt_action)) action = $toNumber(opt_action);
+  var count = opt_count ? $toNumber(opt_count) : 1;
   var callFrameId = 0;
   if (!IS_UNDEFINED(opt_callframe)) {
     callFrameId = opt_callframe.details_.frameId();
   }
 
   return %PrepareStep(this.break_id, action, count, callFrameId);
 };
 
 ExecutionState.prototype.evaluateGlobal = function(source, disable_break,
     opt_additional_context) {
   return MakeMirror(%DebugEvaluateGlobal(this.break_id, source,
-                                         Boolean(disable_break),
+                                         $toBoolean(disable_break),
                                          opt_additional_context));
 };
 
 ExecutionState.prototype.frameCount = function() {
   return %GetFrameCount(this.break_id);
 };
 
 ExecutionState.prototype.threadCount = function() {
   return %GetThreadCount(this.break_id);
 };
 
 ExecutionState.prototype.frame = function(opt_index) {
   // If no index supplied return the selected frame.
   if (opt_index == null) opt_index = this.selected_frame;
   if (opt_index < 0 || opt_index >= this.frameCount()) {
-    throw new Error('Illegal frame index.');
+    throw MakeTypeError(kDebuggerFrame);
   }
   return new FrameMirror(this.break_id, opt_index);
 };
 
 ExecutionState.prototype.setSelectedFrame = function(index) {
-  var i = builtins.$toNumber(index);
-  if (i < 0 || i >= this.frameCount()) throw new Error('Illegal frame index.');
+  var i = $toNumber(index);
+  if (i < 0 || i >= this.frameCount()) {
+    throw MakeTypeError(kDebuggerFrame);
+  }
   this.selected_frame = i;
 };
 
 ExecutionState.prototype.selectedFrame = function() {
   return this.selected_frame;
 };
 
 ExecutionState.prototype.debugCommandProcessor = function(opt_is_running) {
   return new DebugCommandProcessor(this, opt_is_running);
 };
@@ skipping 66 matching lines @@
       var script_break_point = breakpoint.script_break_point();
       var number;
       if (script_break_point) {
         number = script_break_point.number();
       } else {
         number = breakpoint.number();
       }
       o.body.breakpoints.push(number);
     }
   }
-  return JSON.stringify(ObjectToProtocolObject_(o));
+  return JSONStringify(ObjectToProtocolObject_(o));
 };
 
 
 function MakeExceptionEvent(break_id, exception, uncaught, promise) {
   return new ExceptionEvent(break_id, exception, uncaught, promise);
 }
 
 
 function ExceptionEvent(break_id, exception, uncaught, promise) {
   this.exec_state_ = new ExecutionState(break_id);
@@ skipping 208 matching lines @@
     // response from the request.
     this.type = 'response';
     this.request_seq = request.seq;
     this.command = request.command;
   } else {
     // If message is not based on a request it is a dabugger generated event.
     this.type = 'event';
   }
   this.success = true;
   // Handler may set this field to control debugger state.
-  this.running = undefined;
+  this.running = UNDEFINED;
 }
 
 
 ProtocolMessage.prototype.setOption = function(name, value) {
   if (!this.options_) {
     this.options_ = {};
   }
   this.options_[name] = value;
 };
 
@@ skipping 25 matching lines @@
     json.success = this.success;
   } else {
     json.success = false;
   }
   if (this.body) {
     // Encode the body part.
     var bodyJson;
     var serializer = MakeMirrorSerializer(true, this.options_);
     if (this.body instanceof Mirror) {
       bodyJson = serializer.serializeValue(this.body);
-    } else if (this.body instanceof Array) {
+    } else if (this.body instanceof GlobalArray) {
       bodyJson = [];
       for (var i = 0; i < this.body.length; i++) {
         if (this.body[i] instanceof Mirror) {
           bodyJson.push(serializer.serializeValue(this.body[i]));
         } else {
           bodyJson.push(ObjectToProtocolObject_(this.body[i], serializer));
         }
       }
     } else {
       bodyJson = ObjectToProtocolObject_(this.body, serializer);
     }
     json.body = bodyJson;
     json.refs = serializer.serializeReferencedObjects();
   }
   if (this.message) {
     json.message = this.message;
   }
   if (this.error_details) {
     json.error_details = this.error_details;
   }
   json.running = this.running;
-  return JSON.stringify(json);
+  return JSONStringify(json);
 };
 
 
 DebugCommandProcessor.prototype.createResponse = function(request) {
   return new ProtocolMessage(request);
 };
 
 
 DebugCommandProcessor.prototype.processDebugJSONRequest = function(
     json_request) {
   var request;  // Current request.
   var response;  // Generated response.
   try {
     try {
       // Convert the JSON string to an object.
-      request = JSON.parse(json_request);
+      request = JSONParse(json_request);
 
       // Create an initial response.
       response = this.createResponse(request);
 
       if (!request.type) {
-        throw new Error('Type not specified');
+        throw MakeError(kDebugger, 'Type not specified');
       }
 
       if (request.type != 'request') {
-        throw new Error("Illegal type '" + request.type + "' in request");
+        throw MakeError(kDebugger,
+                        "Illegal type '" + request.type + "' in request");
       }
 
       if (!request.command) {
-        throw new Error('Command not specified');
+        throw MakeError(kDebugger, 'Command not specified');
       }
 
       if (request.arguments) {
         var args = request.arguments;
         // TODO(yurys): remove request.arguments.compactFormat check once
         // ChromeDevTools are switched to 'inlineRefs'
         if (args.inlineRefs || args.compactFormat) {
           response.setOption('inlineRefs', true);
         }
         if (!IS_UNDEFINED(args.maxStringLength)) {
           response.setOption('maxStringLength', args.maxStringLength);
         }
       }
 
       var key = request.command.toLowerCase();
       var handler = DebugCommandProcessor.prototype.dispatch_[key];
       if (IS_FUNCTION(handler)) {
         %_CallFunction(this, request, response, handler);
       } else {
-        throw new Error('Unknown command "' + request.command + '" in request');
+        throw MakeError(kDebugger,
+                        'Unknown command "' + request.command + '" in request');
       }
     } catch (e) {
       // If there is no response object created one (without command).
       if (!response) {
         response = this.createResponse();
       }
       response.success = false;
-      response.message = builtins.$toString(e);
+      response.message = $toString(e);
     }
 
     // Return the response as a JSON encoded string.
     try {
       if (!IS_UNDEFINED(response.running)) {
         // Response controls running state.
         this.running_ = response.running;
       }
       response.running = this.running_;
       return response.toJSONProtocol();
     } catch (e) {
       // Failed to generate response - return generic error.
       return '{"seq":' + response.seq + ',' +
               '"request_seq":' + request.seq + ',' +
               '"type":"response",' +
               '"success":false,' +
-              '"message":"Internal error: ' + builtins.$toString(e) + '"}';
+              '"message":"Internal error: ' + $toString(e) + '"}';
     }
   } catch (e) {
     // Failed in one of the catch blocks above - most generic error.
     return '{"seq":0,"type":"response","success":false,"message":"Internal error"}';
   }
 };
 
 
 DebugCommandProcessor.prototype.continueRequest_ = function(request, response) {
   // Check for arguments for continue.
   if (request.arguments) {
     var count = 1;
     var action = Debug.StepAction.StepIn;
 
     // Pull out arguments.
     var stepaction = request.arguments.stepaction;
     var stepcount = request.arguments.stepcount;
 
     // Get the stepcount argument if any.
     if (stepcount) {
-      count = builtins.$toNumber(stepcount);
+      count = $toNumber(stepcount);
       if (count < 0) {
-        throw new Error('Invalid stepcount argument "' + stepcount + '".');
+        throw MakeError(kDebugger,
+                        'Invalid stepcount argument "' + stepcount + '".');
       }
     }
 
     // Get the stepaction argument.
     if (stepaction) {
       if (stepaction == 'in') {
         action = Debug.StepAction.StepIn;
       } else if (stepaction == 'min') {
         action = Debug.StepAction.StepMin;
       } else if (stepaction == 'next') {
         action = Debug.StepAction.StepNext;
       } else if (stepaction == 'out') {
         action = Debug.StepAction.StepOut;
       } else {
-        throw new Error('Invalid stepaction argument "' + stepaction + '".');
+        throw MakeError(kDebugger,
+                        'Invalid stepaction argument "' + stepaction + '".');
       }
     }
 
     // Set up the VM for stepping.
     this.exec_state_.prepareStep(action, count);
   }
 
   // VM should be running after executing this request.
   response.running = true;
 };
@@ skipping 35 matching lines @@
     // Handle function break point.
     if (!IS_STRING(target)) {
       response.failed('Argument "target" is not a string value');
       return;
     }
     var f;
     try {
       // Find the function through a global evaluate.
       f = this.exec_state_.evaluateGlobal(target).value();
     } catch (e) {
-      response.failed('Error: "' + builtins.$toString(e) +
+      response.failed('Error: "' + $toString(e) +
                       '" evaluating "' + target + '"');
       return;
     }
     if (!IS_FUNCTION(f)) {
       response.failed('"' + target + '" does not evaluate to a function');
       return;
     }
 
     // Set function break point.
     break_point_number = Debug.setBreakPoint(f, line, column, condition);
   } else if (type == 'handle') {
     // Find the object pointed by the specified handle.
-    var handle = parseInt(target, 10);
+    var handle = ParseInt(target, 10);
     var mirror = LookupMirror(handle);
     if (!mirror) {
       return response.failed('Object #' + handle + '# not found');
     }
     if (!mirror.isFunction()) {
       return response.failed('Object #' + handle + '# is not a function');
     }
 
     // Set function break point.
     break_point_number = Debug.setBreakPoint(mirror.value(),
@@ skipping 33 matching lines @@
     if (break_point.type() == Debug.ScriptBreakPointType.ScriptId) {
       response.body.type = 'scriptId';
       response.body.script_id = break_point.script_id();
     } else if (break_point.type() == Debug.ScriptBreakPointType.ScriptName) {
       response.body.type = 'scriptName';
       response.body.script_name = break_point.script_name();
     } else if (break_point.type() == Debug.ScriptBreakPointType.ScriptRegExp) {
       response.body.type = 'scriptRegExp';
       response.body.script_regexp = break_point.script_regexp_object().source;
     } else {
-      throw new Error("Internal error: Unexpected breakpoint type: " +
-                      break_point.type());
+      throw MakeError(kDebugger,
+                      "Unexpected breakpoint type: " + break_point.type());
     }
     response.body.line = break_point.line();
     response.body.column = break_point.column();
     response.body.actual_locations = break_point.actual_locations();
   } else {
     response.body.type = 'function';
     response.body.actual_locations = [break_point.actual_location];
   }
 };
 
 
 DebugCommandProcessor.prototype.changeBreakPointRequest_ = function(
     request, response) {
   // Check for legal request.
   if (!request.arguments) {
     response.failed('Missing arguments');
     return;
   }
 
   // Pull out arguments.
-  var break_point = builtins.$toNumber(request.arguments.breakpoint);
+  var break_point = $toNumber(request.arguments.breakpoint);
   var enabled = request.arguments.enabled;
   var condition = request.arguments.condition;
   var ignoreCount = request.arguments.ignoreCount;
 
   // Check for legal arguments.
   if (!break_point) {
     response.failed('Missing argument "breakpoint"');
     return;
   }
 
@@ skipping 55 matching lines @@
 
 DebugCommandProcessor.prototype.clearBreakPointRequest_ = function(
     request, response) {
   // Check for legal request.
   if (!request.arguments) {
     response.failed('Missing arguments');
     return;
   }
 
   // Pull out arguments.
-  var break_point = builtins.$toNumber(request.arguments.breakpoint);
+  var break_point = $toNumber(request.arguments.breakpoint);
 
   // Check for legal arguments.
   if (!break_point) {
     response.failed('Missing argument "breakpoint"');
     return;
   }
 
   // Clear break point.
   Debug.clearBreakPoint(break_point);
 
@@ skipping 23 matching lines @@
     if (break_point.type() == Debug.ScriptBreakPointType.ScriptId) {
       description.type = 'scriptId';
       description.script_id = break_point.script_id();
     } else if (break_point.type() == Debug.ScriptBreakPointType.ScriptName) {
       description.type = 'scriptName';
       description.script_name = break_point.script_name();
     } else if (break_point.type() == Debug.ScriptBreakPointType.ScriptRegExp) {
       description.type = 'scriptRegExp';
       description.script_regexp = break_point.script_regexp_object().source;
     } else {
-      throw new Error("Internal error: Unexpected breakpoint type: " +
-                      break_point.type());
+      throw MakeError(kDebugger,
+                      "Unexpected breakpoint type: " + break_point.type());
     }
     array.push(description);
   }
 
   response.body = {
     breakpoints: array,
     breakOnExceptions: Debug.isBreakOnException(),
     breakOnUncaughtExceptions: Debug.isBreakOnUncaughtException()
   };
 };
@@ skipping 80 matching lines @@
       var tmp_index = total_frames - from_index;
       from_index = total_frames - to_index;
       to_index = tmp_index;
     }
     if (from_index < 0 || to_index < 0) {
       return response.failed('Invalid frame number');
     }
   }
 
   // Adjust the index.
-  to_index = Math.min(total_frames, to_index);
+  to_index = MathMin(total_frames, to_index);
 
   if (to_index <= from_index) {
     var error = 'Invalid frame range';
     return response.failed(error);
   }
 
   // Create the response body.
   var frames = [];
   for (var i = from_index; i < to_index; i++) {
     frames.push(this.exec_state_.frame(i));
@@ skipping 26 matching lines @@
 };
 
 
 DebugCommandProcessor.prototype.resolveFrameFromScopeDescription_ =
     function(scope_description) {
   // Get the frame for which the scope or scopes are requested.
   // With no frameNumber argument use the currently selected frame.
   if (scope_description && !IS_UNDEFINED(scope_description.frameNumber)) {
     var frame_index = scope_description.frameNumber;
     if (frame_index < 0 || this.exec_state_.frameCount() <= frame_index) {
-      throw new Error('Invalid frame number');
+      throw MakeTypeError(kDebuggerFrame);
     }
     return this.exec_state_.frame(frame_index);
   } else {
     return this.exec_state_.frame();
   }
 };
 
 
 // Gets scope host object from request. It is either a function
 // ('functionHandle' argument must be specified) or a stack frame
 // ('frameNumber' may be specified and the current frame is taken by default).
 DebugCommandProcessor.prototype.resolveScopeHolder_ =
     function(scope_description) {
   if (scope_description && "functionHandle" in scope_description) {
     if (!IS_NUMBER(scope_description.functionHandle)) {
-      throw new Error('Function handle must be a number');
+      throw MakeError(kDebugger, 'Function handle must be a number');
     }
     var function_mirror = LookupMirror(scope_description.functionHandle);
     if (!function_mirror) {
-      throw new Error('Failed to find function object by handle');
+      throw MakeError(kDebugger, 'Failed to find function object by handle');
     }
     if (!function_mirror.isFunction()) {
-      throw new Error('Value of non-function type is found by handle');
+      throw MakeError(kDebugger,
+                      'Value of non-function type is found by handle');
     }
     return function_mirror;
   } else {
     // No frames no scopes.
     if (this.exec_state_.frameCount() == 0) {
-      throw new Error('No scopes');
+      throw MakeError(kDebugger, 'No scopes');
     }
 
     // Get the frame for which the scopes are requested.
     var frame = this.resolveFrameFromScopeDescription_(scope_description);
     return frame;
   }
 }
 
 
 DebugCommandProcessor.prototype.scopesRequest_ = function(request, response) {
@@ skipping 14 matching lines @@
 };
 
 
 DebugCommandProcessor.prototype.scopeRequest_ = function(request, response) {
   // Get the frame or function for which the scope is requested.
   var scope_holder = this.resolveScopeHolder_(request.arguments);
 
   // With no scope argument just return top scope.
   var scope_index = 0;
   if (request.arguments && !IS_UNDEFINED(request.arguments.number)) {
-    scope_index = builtins.$toNumber(request.arguments.number);
+    scope_index = $toNumber(request.arguments.number);
     if (scope_index < 0 || scope_holder.scopeCount() <= scope_index) {
       return response.failed('Invalid scope number');
     }
   }
 
   response.body = scope_holder.scope(scope_index);
 };
 
 
 // Reads value from protocol description. Description may be in form of type
 // (for singletons), raw value (primitive types supported in JSON),
 // string value description plus type (for primitive values) or handle id.
 // Returns raw value or throws exception.
 DebugCommandProcessor.resolveValue_ = function(value_description) {
   if ("handle" in value_description) {
     var value_mirror = LookupMirror(value_description.handle);
     if (!value_mirror) {
-      throw new Error("Failed to resolve value by handle, ' #" +
-          value_description.handle + "# not found");
+      throw MakeError(kDebugger, "Failed to resolve value by handle, ' #" +
+                                 value_description.handle + "# not found");
     }
     return value_mirror.value();
   } else if ("stringDescription" in value_description) {
-    if (value_description.type == BOOLEAN_TYPE) {
-      return Boolean(value_description.stringDescription);
-    } else if (value_description.type == NUMBER_TYPE) {
-      return Number(value_description.stringDescription);
-    } if (value_description.type == STRING_TYPE) {
-      return String(value_description.stringDescription);
+    if (value_description.type == MirrorType.BOOLEAN_TYPE) {
+      return $toBoolean(value_description.stringDescription);
+    } else if (value_description.type == MirrorType.NUMBER_TYPE) {
+      return $toNumber(value_description.stringDescription);
+    } if (value_description.type == MirrorType.STRING_TYPE) {
+      return $toString(value_description.stringDescription);
     } else {
-      throw new Error("Unknown type");
+      throw MakeError(kDebugger, "Unknown type");
     }
   } else if ("value" in value_description) {
     return value_description.value;
-  } else if (value_description.type == UNDEFINED_TYPE) {
+  } else if (value_description.type == MirrorType.UNDEFINED_TYPE) {
     return UNDEFINED;
-  } else if (value_description.type == NULL_TYPE) {
+  } else if (value_description.type == MirrorType.NULL_TYPE) {
     return null;
   } else {
-    throw new Error("Failed to parse value description");
+    throw MakeError(kDebugger, "Failed to parse value description");
   }
 };
 
 
 DebugCommandProcessor.prototype.setVariableValueRequest_ =
     function(request, response) {
   if (!request.arguments) {
     response.failed('Missing arguments');
     return;
   }
 
   if (IS_UNDEFINED(request.arguments.name)) {
     response.failed('Missing variable name');
   }
   var variable_name = request.arguments.name;
 
   var scope_description = request.arguments.scope;
 
   // Get the frame or function for which the scope is requested.
   var scope_holder = this.resolveScopeHolder_(scope_description);
 
   if (IS_UNDEFINED(scope_description.number)) {
     response.failed('Missing scope number');
   }
-  var scope_index = builtins.$toNumber(scope_description.number);
+  var scope_index = $toNumber(scope_description.number);
 
   var scope = scope_holder.scope(scope_index);
 
   var new_value =
       DebugCommandProcessor.resolveValue_(request.arguments.newValue);
 
   scope.setVariableValue(variable_name, new_value);
 
   var new_value_mirror = MakeMirror(new_value);
 
@@ skipping 11 matching lines @@
   // Pull out arguments.
   var expression = request.arguments.expression;
   var frame = request.arguments.frame;
   var global = request.arguments.global;
   var disable_break = request.arguments.disable_break;
   var additional_context = request.arguments.additional_context;
 
   // The expression argument could be an integer so we convert it to a
   // string.
   try {
-    expression = String(expression);
+    expression = $toString(expression);
   } catch(e) {
     return response.failed('Failed to convert expression argument to string');
   }
 
   // Check for legal arguments.
   if (!IS_UNDEFINED(frame) && global) {
     return response.failed('Arguments "frame" and "global" are exclusive');
   }
 
   var additional_context_object;
   if (additional_context) {
     additional_context_object = {};
     for (var i = 0; i < additional_context.length; i++) {
       var mapping = additional_context[i];
 
       if (!IS_STRING(mapping.name)) {
         return response.failed("Context element #" + i +
             " doesn't contain name:string property");
       }
 
       var raw_value = DebugCommandProcessor.resolveValue_(mapping);
       additional_context_object[mapping.name] = raw_value;
     }
   }
 
   // Global evaluate.
   if (global) {
     // Evaluate in the native context.
     response.body = this.exec_state_.evaluateGlobal(
-        expression, Boolean(disable_break), additional_context_object);
+        expression, $toBoolean(disable_break), additional_context_object);
     return;
   }
 
   // Default value for disable_break is true.
   if (IS_UNDEFINED(disable_break)) {
     disable_break = true;
   }
 
   // No frames no evaluate in frame.
   if (this.exec_state_.frameCount() == 0) {
     return response.failed('No frames');
   }
 
   // Check whether a frame was specified.
   if (!IS_UNDEFINED(frame)) {
-    var frame_number = builtins.$toNumber(frame);
+    var frame_number = $toNumber(frame);
     if (frame_number < 0 || frame_number >= this.exec_state_.frameCount()) {
       return response.failed('Invalid frame "' + frame + '"');
     }
     // Evaluate in the specified frame.
     response.body = this.exec_state_.frame(frame_number).evaluate(
-        expression, Boolean(disable_break), additional_context_object);
+        expression, $toBoolean(disable_break), additional_context_object);
     return;
   } else {
     // Evaluate in the selected frame.
     response.body = this.exec_state_.frame().evaluate(
-        expression, Boolean(disable_break), additional_context_object);
+        expression, $toBoolean(disable_break), additional_context_object);
     return;
   }
 };
 
 
 DebugCommandProcessor.prototype.lookupRequest_ = function(request, response) {
   if (!request.arguments) {
     return response.failed('Missing arguments');
   }
 
   // Pull out arguments.
   var handles = request.arguments.handles;
 
   // Check for legal arguments.
   if (IS_UNDEFINED(handles)) {
     return response.failed('Argument "handles" missing');
   }
 
   // Set 'includeSource' option for script lookup.
   if (!IS_UNDEFINED(request.arguments.includeSource)) {
-    var includeSource = builtins.$toBoolean(request.arguments.includeSource);
+    var includeSource = $toBoolean(request.arguments.includeSource);
     response.setOption('includeSource', includeSource);
   }
 
   // Lookup handles.
   var mirrors = {};
   for (var i = 0; i < handles.length; i++) {
     var handle = handles[i];
     var mirror = LookupMirror(handle);
     if (!mirror) {
       return response.failed('Object #' + handle + '# not found');
@@ skipping 47 matching lines @@
 
   var from_line;
   var to_line;
   var frame = this.exec_state_.frame();
   if (request.arguments) {
     // Pull out arguments.
     from_line = request.arguments.fromLine;
     to_line = request.arguments.toLine;
 
     if (!IS_UNDEFINED(request.arguments.frame)) {
-      var frame_number = builtins.$toNumber(request.arguments.frame);
+      var frame_number = $toNumber(request.arguments.frame);
       if (frame_number < 0 || frame_number >= this.exec_state_.frameCount()) {
         return response.failed('Invalid frame "' + frame + '"');
       }
       frame = this.exec_state_.frame(frame_number);
     }
   }
 
   // Get the script selected.
   var script = frame.func().script();
   if (!script) {
@@ skipping 15 matching lines @@
 };
 
 
 DebugCommandProcessor.prototype.scriptsRequest_ = function(request, response) {
   var types = ScriptTypeFlag(Debug.ScriptType.Normal);
   var includeSource = false;
   var idsToInclude = null;
   if (request.arguments) {
     // Pull out arguments.
     if (!IS_UNDEFINED(request.arguments.types)) {
-      types = builtins.$toNumber(request.arguments.types);
-      if (isNaN(types) || types < 0) {
+      types = $toNumber(request.arguments.types);
+      if (IsNaN(types) || types < 0) {
         return response.failed('Invalid types "' +
                                request.arguments.types + '"');
       }
     }
 
     if (!IS_UNDEFINED(request.arguments.includeSource)) {
-      includeSource = builtins.$toBoolean(request.arguments.includeSource);
+      includeSource = $toBoolean(request.arguments.includeSource);
       response.setOption('includeSource', includeSource);
     }
 
     if (IS_ARRAY(request.arguments.ids)) {
       idsToInclude = {};
       var ids = request.arguments.ids;
       for (var i = 0; i < ids.length; i++) {
         idsToInclude[ids[i]] = true;
       }
     }
 
     var filterStr = null;
     var filterNum = null;
     if (!IS_UNDEFINED(request.arguments.filter)) {
-      var num = builtins.$toNumber(request.arguments.filter);
-      if (!isNaN(num)) {
+      var num = $toNumber(request.arguments.filter);
+      if (!IsNaN(num)) {
         filterNum = num;
       }
       filterStr = request.arguments.filter;
     }
   }
 
   // Collect all scripts in the heap.
   var scripts = %DebugGetLoadedScripts();
 
   response.body = [];
@@ skipping 72 matching lines @@
   for (var i = 0; i < scripts.length; i++) {
     if (scripts[i].id == script_id) {
       the_script = scripts[i];
     }
   }
   if (!the_script) {
     response.failed('Script not found');
     return;
   }
 
-  var change_log = new Array();
+  var change_log = new GlobalArray();
 
   if (!IS_STRING(request.arguments.new_source)) {
     throw "new_source argument expected";
   }
 
   var new_source = request.arguments.new_source;
 
   var result_description;
   try {
     result_description = Debug.LiveEdit.SetScriptSource(the_script,
@@ skipping 21 matching lines @@
   var frame = request.arguments.frame;
 
   // No frames to evaluate in frame.
   if (this.exec_state_.frameCount() == 0) {
     return response.failed('No frames');
   }
 
   var frame_mirror;
   // Check whether a frame was specified.
   if (!IS_UNDEFINED(frame)) {
-    var frame_number = builtins.$toNumber(frame);
+    var frame_number = $toNumber(frame);
     if (frame_number < 0 || frame_number >= this.exec_state_.frameCount()) {
       return response.failed('Invalid frame "' + frame + '"');
     }
     // Restart specified frame.
     frame_mirror = this.exec_state_.frame(frame_number);
   } else {
     // Restart selected frame.
     frame_mirror = this.exec_state_.frame();
   }
 
@@ skipping 173 matching lines @@
     case 'string':
     case 'number':
       json = value;
       break;
 
     default:
       json = null;
   }
   return json;
 }
+
+
+// -------------------------------------------------------------------
+// Exports
+
+utils.InstallConstants(global, [
+  "Debug", Debug,
+  "DebugCommandProcessor", DebugCommandProcessor,
+]);
+
+// Functions needed by the debugger runtime.
+utils.InstallFunctions(utils, DONT_ENUM, [
+  "MakeExecutionState", MakeExecutionState,
+  "MakeExceptionEvent", MakeExceptionEvent,
+  "MakeBreakEvent", MakeBreakEvent,
+  "MakeCompileEvent", MakeCompileEvent,
+  "MakePromiseEvent", MakePromiseEvent,
+  "MakeAsyncTaskEvent", MakeAsyncTaskEvent,
+  "IsBreakPointTriggered", IsBreakPointTriggered,
+  "UpdateScriptBreakPoints", UpdateScriptBreakPoints,
+]);
+
+// Export to liveedit.js
+utils.Export(function(to) {
+  to.GetScriptBreakPoints = GetScriptBreakPoints;
+});
+
+})