Draft for Issue 1418: Debug: extends setBreakpoint API to accept partial script name as a parameter

src/debug-debugger.js

 // Copyright 2006-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
@@ skipping 50 matching lines @@
                      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 script break point types.
 Debug.ScriptBreakPointType = { ScriptId: 0,
-                               ScriptName: 1 };
+                               ScriptName: 1,
+                               ScriptRegexp: 2 };

[Søren Thygesen Gjesse, 2011/06/06 09:03:43]

I guess that we do need an additional type here even thought he name matching
could be a regexp as well.

[Peter Rybin, 2011/06/16 11:02:20]

(I take it as "we do NOT need")

Actually on the client I'd like to distinguish these two type (I work with them
differently). Since V8 lists breakpoints back to client ("listbreakpoints"
request), this information should be somehow kept.

But we can drop new ScriptBreakPointType and create polymorphic
ScriptNameMatcher that will handle all this.

 
 function ScriptTypeFlag(type) {
   return (1 << type);
 }
 
 // Globals.
 var next_response_seq = 0;
 var next_break_point_number = 1;
 var break_points = [];
 var script_break_points = [];
@@ skipping 166 matching lines @@
 
 
 // Object representing a script break point. The script is referenced by its
 // 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) {
   this.type_ = type;
   if (type == Debug.ScriptBreakPointType.ScriptId) {
     this.script_id_ = script_id_or_name;
+  } else if (type == Debug.ScriptBreakPointType.ScriptRegexp) {
+    this.script_regexp_ = new RegExp(script_id_or_name);
   } else {  // type == Debug.ScriptBreakPointType.ScriptName
     this.script_name_ = script_id_or_name;
   }
   this.line_ = opt_line || 0;
   this.column_ = opt_column;
   this.groupId_ = opt_groupId;
   this.hit_count_ = 0;
   this.active_ = true;
   this.condition_ = null;
   this.ignoreCount_ = 0;
@@ skipping 34 matching lines @@
 ScriptBreakPoint.prototype.script_id = function() {
   return this.script_id_;
 };
 
 
 ScriptBreakPoint.prototype.script_name = function() {
   return this.script_name_;
 };
 
 
+ScriptBreakPoint.prototype.script_regexp = function() {
+  return this.script_regexp_;
+};
+
+
 ScriptBreakPoint.prototype.line = function() {
   return this.line_;
 };
 
 
 ScriptBreakPoint.prototype.column = function() {
   return this.column_;
 };
 
 
@@ skipping 55 matching lines @@
     this.break_points_[i].setIgnoreCount(ignoreCount);
   }
 };
 
 
 // Check whether a script matches this script break point. Currently this is
 // only based on script name.
 ScriptBreakPoint.prototype.matchesScript = function(script) {
   if (this.type_ == Debug.ScriptBreakPointType.ScriptId) {
     return this.script_id_ == script.id;
-  } else {  // this.type_ == Debug.ScriptBreakPointType.ScriptName
-    return this.script_name_ == script.nameOrSourceURL() &&
-           script.line_offset <= this.line_  &&
-           this.line_ < script.line_offset + script.lineCount();
+  } else {
+    if (!(script.line_offset <= this.line_  &&
+          this.line_ < script.line_offset + script.lineCount())) {
+      return false;
+    }
+    if (this.type_ == Debug.ScriptBreakPointType.ScriptRegexp) {
+      return this.script_regexp_.test(script.nameOrSourceURL());
+    } else {  // this.type_ == Debug.ScriptBreakPointType.ScriptName
+      return this.script_name_ == script.nameOrSourceURL();
+    }
   }
 };
 
 
 // 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
@@ skipping 391 matching lines @@
 
 Debug.setScriptBreakPointByName = function(script_name,
                                            opt_line, opt_column,
                                            opt_condition, opt_groupId) {
   return this.setScriptBreakPoint(Debug.ScriptBreakPointType.ScriptName,
                                   script_name, opt_line, opt_column,
                                   opt_condition, opt_groupId);
 }
 
 
+Debug.setScriptBreakPointByRegexp = function(script_regexp,
+                                             opt_line, opt_column,
+                                             opt_condition, opt_groupId) {
+  return this.setScriptBreakPoint(Debug.ScriptBreakPointType.ScriptRegexp,
+                                  script_regexp, opt_line, opt_column,
+                                  opt_condition, opt_groupId);
+}
+
+
 Debug.enableScriptBreakPoint = function(break_point_number) {
   var script_break_point = this.findScriptBreakPoint(break_point_number, false);
   script_break_point.enable();
 };
 
 
 Debug.disableScriptBreakPoint = function(break_point_number) {
   var script_break_point = this.findScriptBreakPoint(break_point_number, false);
   script_break_point.disable();
 };
@@ skipping 731 matching lines @@
   var condition = request.arguments.condition;
   var ignoreCount = request.arguments.ignoreCount;
   var groupId = request.arguments.groupId;
 
   // Check for legal arguments.
   if (!type || IS_UNDEFINED(target)) {
     response.failed('Missing argument "type" or "target"');
     return;
   }
   if (type != 'function' && type != 'handle' &&
-      type != 'script' && type != 'scriptId') {
+      type != 'script' && type != 'scriptId' && type != 'scriptRegexp') {
     response.failed('Illegal type "' + type + '"');
     return;
   }
 
   // Either function or script break point.
   var break_point_number;
   if (type == 'function') {
     // Handle function break point.
     if (!IS_STRING(target)) {
       response.failed('Argument "target" is not a string value');
@@ skipping 27 matching lines @@
     }
 
     // Set function break point.
     break_point_number = Debug.setBreakPoint(mirror.value(),
                                              line, column, condition);
   } else if (type == 'script') {
     // set script break point.
     break_point_number =
         Debug.setScriptBreakPointByName(target, line, column, condition,
                                         groupId);
+  } else if (type == 'scriptRegexp') { 

[Søren Thygesen Gjesse, 2011/06/06 09:03:43]

Can't we combine 'script' and 'scriptRegexp' here, and convert the name matching
to a regexp?

[Peter Rybin, 2011/06/16 11:02:20]

I'd like to keep exact name and regexp separate. It corresponds to two different
modes in my client. Of course I can analyze regexp source and detect that the
pattern is exact string, but I think it's too tricky.

+    break_point_number =
+        Debug.setScriptBreakPointByRegexp(target, line, column, condition,
+                                          groupId);
   } else {  // type == 'scriptId.
     break_point_number =
         Debug.setScriptBreakPointById(target, line, column, condition, groupId);
   }
 
   // Set additional break point properties.
   var break_point = Debug.findBreakPoint(break_point_number);
   if (ignoreCount) {
     Debug.changeBreakPointIgnoreCount(break_point_number, ignoreCount);
   }
   if (!enabled) {
     Debug.disableBreakPoint(break_point_number);
   }
 
   // Add the break point number to the response.
   response.body = { type: type,
                     breakpoint: break_point_number }
 
   // Add break point information to the response.
   if (break_point instanceof ScriptBreakPoint) {
     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.ScriptRegexp) {
+      response.body.type = 'scriptRegexp';
+      response.body.script_regexp = break_point.script_regexp().source();
     } else {
       response.body.type = 'scriptName';
       response.body.script_name = break_point.script_name();
     }
     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 112 matching lines @@
       hit_count: break_point.hit_count(),
       active: break_point.active(),
       condition: break_point.condition(),
       ignoreCount: break_point.ignoreCount(),
       actual_locations: break_point.actual_locations()
     }
 
     if (break_point.type() == Debug.ScriptBreakPointType.ScriptId) {
       description.type = 'scriptId';
       description.script_id = break_point.script_id();
+    } else if (break_point.type() == Debug.ScriptBreakPointType.ScriptRegexp) {
+      description.type = 'scriptRegexp';
+      description.script_name = break_point.script_regexp().source();
     } else {
       description.type = 'scriptName';
       description.script_name = break_point.script_name();
     }
     array.push(description);
   }
 
   response.body = {
     breakpoints: array,
     breakOnExceptions: Debug.isBreakOnException(),
@@ skipping 794 matching lines @@
     case 'string':
     case 'number':
       json = value;
       break
 
     default:
       json = null;
   }
   return json;
 }