Move family of MakeError functions to C++

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 MakeError;
-var MakeTypeError;
 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) {
-  MakeError = from.MakeError;
-  MakeTypeError = from.MakeTypeError;
   MirrorType = from.MirrorType;
 });
 
 //----------------------------------------------------------------------------
 
 // Default number of frames to include in the response to backtrace request.
 var kDefaultBacktraceLength = 10;
 
 var Debug = {};
 
@@ skipping 199 matching lines @@
 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 GlobalRegExp(script_id_or_name);
   } else {
-    throw MakeError(kDebugger, "Unexpected breakpoint type " + type);
+    throw %make_error(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.active_ = true;
   this.condition_ = null;
   this.break_points_ = [];
 }
@@ skipping 102 matching lines @@
     // We might want to account columns here as well.
     if (!(script.line_offset <= this.line_  &&
           this.line_ < script.line_offset + %ScriptLineCount(script))) {
       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 MakeError(kDebugger, "Unexpected breakpoint type " + this.type_);
+      throw %make_error(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
@@ skipping 75 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 MakeTypeError(kDebuggerType);
+    throw %make_type_error(kDebuggerType);
   }
   %SetDebugEventListener(listener, opt_data);
 };
 
 
 // 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 29 matching lines @@
 // 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 MakeTypeError(kDebuggerType);
+  if (!IS_FUNCTION(f)) throw %make_type_error(kDebuggerType);
   return %FunctionGetSourceCode(f);
 };
 
 
 Debug.sourcePosition = function(f) {
-  if (!IS_FUNCTION(f)) throw MakeTypeError(kDebuggerType);
+  if (!IS_FUNCTION(f)) throw %make_type_error(kDebuggerType);
   return %FunctionGetScriptSourcePosition(f);
 };
 
 
 Debug.findFunctionSourceLocation = function(func, opt_line, opt_column) {
   var script = %FunctionGetScript(func);
   var script_offset = %FunctionGetScriptSourcePosition(func);
   return %ScriptLocationFromLine(script, 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 MakeTypeError(kDebuggerType);
+  if (!IS_FUNCTION(func)) throw %make_type_error(kDebuggerType);
   // Break points in API functions are not supported.
   if (%FunctionIsAPIFunction(func)) {
-    throw MakeError(kDebugger, 'Cannot set break point in native code.');
+    throw %make_error(kDebugger, 'Cannot set break point in native code.');
   }
   // Find source position.
   var source_position =
       this.findFunctionSourceLocation(func, opt_line, opt_column).position;
   // 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 MakeError(kDebugger, 'Cannot set break point in native code.');
+    throw %make_error(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) {
     // 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,
                                         location.line, location.column,
                                         opt_condition);
@@ skipping 55 matching lines @@
   break_point.setCondition(condition);
 };
 
 
 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 MakeError(kDebugger, 'Invalid breakpoint');
+    if (!break_point) throw %make_error(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 131 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 MakeError(kDebuggerType);
+  if (!IS_FUNCTION(f)) throw %make_error(kDebuggerType);
   var source = full ? this.scriptSource(f) : this.source(f);
   var offset = full ? 0 : this.sourcePosition(f);
   var position_alignment = IS_UNDEFINED(opt_position_alignment)
       ? Debug.BreakPositionAlignment.Statement : opt_position_alignment;
   var locations = %GetBreakLocations(f, position_alignment);
   if (!locations) return source;
   locations.sort(function(x, y) { return x - y; });
   var result = "";
   var prev_pos = 0;
   var pos;
@@ skipping 53 matching lines @@
   this.selected_frame = 0;
 }
 
 ExecutionState.prototype.prepareStep = function(action) {
   if (action === Debug.StepAction.StepIn ||
       action === Debug.StepAction.StepOut ||
       action === Debug.StepAction.StepNext ||
       action === Debug.StepAction.StepFrame) {
     return %PrepareStep(this.break_id, action);
   }
-  throw MakeTypeError(kDebuggerType);
+  throw %make_type_error(kDebuggerType);
 };
 
 ExecutionState.prototype.evaluateGlobal = function(source, disable_break,
     opt_additional_context) {
   return MakeMirror(%DebugEvaluateGlobal(this.break_id, source,
                                          TO_BOOLEAN(disable_break),
                                          opt_additional_context));
 };
 
 ExecutionState.prototype.frameCount = function() {
   return %GetFrameCount(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 MakeTypeError(kDebuggerFrame);
+    throw %make_type_error(kDebuggerFrame);
   }
   return new FrameMirror(this.break_id, opt_index);
 };
 
 ExecutionState.prototype.setSelectedFrame = function(index) {
   var i = TO_NUMBER(index);
   if (i < 0 || i >= this.frameCount()) {
-    throw MakeTypeError(kDebuggerFrame);
+    throw %make_type_error(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 353 matching lines @@
   var response;  // Generated response.
   try {
     try {
       // Convert the JSON string to an object.
       request = JSONParse(json_request);
 
       // Create an initial response.
       response = this.createResponse(request);
 
       if (!request.type) {
-        throw MakeError(kDebugger, 'Type not specified');
+        throw %make_error(kDebugger, 'Type not specified');
       }
 
       if (request.type != 'request') {
-        throw MakeError(kDebugger,
+        throw %make_error(kDebugger,
                         "Illegal type '" + request.type + "' in request");
       }
 
       if (!request.command) {
-        throw MakeError(kDebugger, 'Command not specified');
+        throw %make_error(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)) {
         %_Call(handler, this, request, response);
       } else {
-        throw MakeError(kDebugger,
+        throw %make_error(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 = TO_STRING(e);
     }
@@ skipping 31 matching lines @@
 
     // Get the stepaction argument.
     if (stepaction) {
       if (stepaction == 'in') {
         action = Debug.StepAction.StepIn;
       } else if (stepaction == 'next') {
         action = Debug.StepAction.StepNext;
       } else if (stepaction == 'out') {
         action = Debug.StepAction.StepOut;
       } else {
-        throw MakeError(kDebugger,
+        throw %make_error(kDebugger,
                         'Invalid stepaction argument "' + stepaction + '".');
       }
     }
 
     // Set up the VM for stepping.
     this.exec_state_.prepareStep(action);
   }
 
   // VM should be running after executing this request.
   response.running = true;
@@ skipping 99 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 MakeError(kDebugger,
+      throw %make_error(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];
   }
 };
@@ skipping 113 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 MakeError(kDebugger,
+      throw %make_error(kDebugger,
                       "Unexpected breakpoint type: " + break_point.type());
     }
     array.push(description);
   }
 
   response.body = {
     breakpoints: array,
     breakOnExceptions: Debug.isBreakOnException(),
     breakOnUncaughtExceptions: Debug.isBreakOnUncaughtException()
   };
@@ skipping 128 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 MakeTypeError(kDebuggerFrame);
+      throw %make_type_error(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 MakeError(kDebugger, 'Function handle must be a number');
+      throw %make_error(kDebugger, 'Function handle must be a number');
     }
     var function_mirror = LookupMirror(scope_description.functionHandle);
     if (!function_mirror) {
-      throw MakeError(kDebugger, 'Failed to find function object by handle');
+      throw %make_error(kDebugger, 'Failed to find function object by handle');
     }
     if (!function_mirror.isFunction()) {
-      throw MakeError(kDebugger,
+      throw %make_error(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 MakeError(kDebugger, 'No scopes');
+      throw %make_error(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 32 matching lines @@
 
 
 // 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 MakeError(kDebugger, "Failed to resolve value by handle, ' #" +
+      throw %make_error(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 == MirrorType.BOOLEAN_TYPE) {
       return TO_BOOLEAN(value_description.stringDescription);
     } else if (value_description.type == MirrorType.NUMBER_TYPE) {
       return TO_NUMBER(value_description.stringDescription);
     } if (value_description.type == MirrorType.STRING_TYPE) {
       return TO_STRING(value_description.stringDescription);
     } else {
-      throw MakeError(kDebugger, "Unknown type");
+      throw %make_error(kDebugger, "Unknown type");
     }
   } else if ("value" in value_description) {
     return value_description.value;
   } else if (value_description.type == MirrorType.UNDEFINED_TYPE) {
     return UNDEFINED;
   } else if (value_description.type == MirrorType.NULL_TYPE) {
     return null;
   } else {
-    throw MakeError(kDebugger, "Failed to parse value description");
+    throw %make_error(kDebugger, "Failed to parse value description");
   }
 };
 
 
 DebugCommandProcessor.prototype.setVariableValueRequest_ =
     function(request, response) {
   if (!request.arguments) {
     response.failed('Missing arguments');
     return;
   }
@@ skipping 587 matching lines @@
   "IsBreakPointTriggered", IsBreakPointTriggered,
   "UpdateScriptBreakPoints", UpdateScriptBreakPoints,
 ]);
 
 // Export to liveedit.js
 utils.Export(function(to) {
   to.GetScriptBreakPoints = GetScriptBreakPoints;
 });
 
 })