Revert "Debug: support breakpoints set in the middle of statement"

src/debug-debugger.js

 // Copyright 2012 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 53 matching lines @@
 // 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,
                                ScriptRegExp: 2 };
 
-// The different types of breakpoint position alignments.
-// Must match BreakPositionAlignment in debug.h.
-Debug.BreakPositionAlignment = {
-  Statement: 0,
-  BreakPosition: 1
-};
-
 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 = [];
 var debugger_flags = {
@@ skipping 160 matching lines @@
 // the break point is triggered and supposed to break execution.
 function IsBreakPointTriggered(break_id, break_point) {
   return break_point.isTriggered(MakeExecutionState(break_id));
 }
 
 
 // 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, opt_position_alignment) {
+                          opt_groupId) {
   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);
   } else {
     throw new Error("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;
   this.break_points_ = [];
 }
 
 
 //Creates a clone of script breakpoint that is linked to another script.
 ScriptBreakPoint.prototype.cloneForOtherScript = function (other_script) {
   var copy = new ScriptBreakPoint(Debug.ScriptBreakPointType.ScriptId,
-      other_script.id, this.line_, this.column_, this.groupId_,
-      this.position_alignment_);
+      other_script.id, this.line_, this.column_, this.groupId_);
   copy.number_ = next_break_point_number++;
   script_break_points.push(copy);
 
   copy.hit_count_ = this.hit_count_;
   copy.active_ = this.active_;
   copy.condition_ = this.condition_;
   copy.ignoreCount_ = this.ignoreCount_;
   return copy;
 };
 
@@ skipping 146 matching lines @@
   // Convert the line and column into an absolute position within the script.
   var position = Debug.findScriptSourcePosition(script, this.line(), column);
 
   // If the position is not found in the script (the script might be shorter
   // than it used to be) just ignore it.
   if (position === null) return;
 
   // Create a break point object and set the break point.
   break_point = MakeBreakPoint(position, this);
   break_point.setIgnoreCount(this.ignoreCount());
-  var actual_position = %SetScriptBreakPoint(script, position,
-                                             this.position_alignment_,
-                                             break_point);
+  var actual_position = %SetScriptBreakPoint(script, position, break_point);
   if (IS_UNDEFINED(actual_position)) {
     actual_position = position;
   }
   var actual_location = script.locationFromPosition(actual_position, true);
   break_point.actual_location = { line: actual_location.line,
                                   column: actual_location.column,
                                   script_id: script.id };
   this.break_points_.push(break_point);
   return break_point;
 };
@@ skipping 45 matching lines @@
     throw new Error('Parameters have wrong types.');
   }
   %SetDebugEventListener(listener, opt_data);
 };
 
 
 Debug.breakExecution = function(f) {
   %Break();
 };
 
-Debug.breakLocations = function(f, opt_position_aligment) {
+Debug.breakLocations = function(f) {
   if (!IS_FUNCTION(f)) throw new Error('Parameters have wrong types.');
-  var position_aligment = IS_UNDEFINED(opt_position_aligment)
-      ? Debug.BreakPositionAlignment.Statement : opt_position_aligment;
-  return %GetBreakLocations(f, position_aligment);
+  return %GetBreakLocations(f);
 };
 
 // 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.
 Debug.findScript = function(func_or_script_name) {
   if (IS_FUNCTION(func_or_script_name)) {
     return %FunctionGetScript(func_or_script_name);
@@ skipping 142 matching lines @@
     break_point.actual_location = { line: actual_location.line,
                                     column: actual_location.column,
                                     script_id: script.id };
     break_point.setCondition(opt_condition);
     return break_point.number();
   }
 };
 
 
 Debug.setBreakPointByScriptIdAndPosition = function(script_id, position,
-                                                    condition, enabled,
-                                                    opt_position_alignment)
+                                                    condition, enabled)
 {
   break_point = MakeBreakPoint(position);
   break_point.setCondition(condition);
   if (!enabled) {
     break_point.disable();
   }
   var scripts = this.scripts();
-  var position_alignment = IS_UNDEFINED(opt_position_alignment)
-      ? Debug.BreakPositionAlignment.Statement : opt_position_alignment;
   for (var i = 0; i < scripts.length; i++) {
     if (script_id == scripts[i].id) {
       break_point.actual_position = %SetScriptBreakPoint(scripts[i], position,
-          position_alignment, break_point);
+                                                         break_point);
       break;
     }
   }
   return break_point;
 };
 
 
 Debug.enableBreakPoint = function(break_point_number) {
   var break_point = this.findBreakPoint(break_point_number, false);
   // Only enable if the breakpoint hasn't been deleted:
@@ skipping 74 matching lines @@
     }
   }
   return script_break_point;
 };
 
 
 // Sets a breakpoint in a script identified through id or name at the
 // specified source line and column within that line.
 Debug.setScriptBreakPoint = function(type, script_id_or_name,
                                      opt_line, opt_column, opt_condition,
-                                     opt_groupId, opt_position_alignment) {
+                                     opt_groupId) {
   // Create script break point object.
   var script_break_point =
       new ScriptBreakPoint(type, script_id_or_name, opt_line, opt_column,
-                           opt_groupId, opt_position_alignment);
+                           opt_groupId);
 
   // Assign number to the new script break point and add it.
   script_break_point.number_ = next_break_point_number++;
   script_break_point.setCondition(opt_condition);
   script_break_points.push(script_break_point);
 
   // Run through all scripts to see if this script break point matches any
   // loaded scripts.
   var scripts = this.scripts();
   for (var i = 0; i < scripts.length; i++) {
     if (script_break_point.matchesScript(scripts[i])) {
       script_break_point.set(scripts[i]);
     }
   }
 
   return script_break_point.number();
 };
 
 
 Debug.setScriptBreakPointById = function(script_id,
                                          opt_line, opt_column,
-                                         opt_condition, opt_groupId,
-                                         opt_position_alignment) {
+                                         opt_condition, opt_groupId) {
   return this.setScriptBreakPoint(Debug.ScriptBreakPointType.ScriptId,
                                   script_id, opt_line, opt_column,
-                                  opt_condition, opt_groupId,
-                                  opt_position_alignment);
+                                  opt_condition, opt_groupId);
 };
 
 
 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);
 };
@@ skipping 63 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) {
+Debug.showBreakPoints = function(f, full) {
   if (!IS_FUNCTION(f)) throw new Error('Parameters have wrong types.');
   var source = full ? this.scriptSource(f) : this.source(f);
   var offset = full ? this.sourcePosition(f) : 0;
-  var locations = this.breakLocations(f, opt_position_alignment);
+  var locations = this.breakLocations(f);
   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;
     result += source.slice(prev_pos, pos);
     result += "[B" + i + "]";
     prev_pos = pos;
@@ skipping 1713 matching lines @@
 
     default:
       json = null;
   }
   return json;
 }
 
 Debug.TestApi = {
   CommandProcessorResolveValue: DebugCommandProcessor.resolveValue_
 };