if (value) {

Debug.setBreakOnException();

} else {

Debug.clearBreakOnException();

}

if (value) {

Debug.setBreakOnUncaughtException();

} else {

Debug.clearBreakOnUncaughtException();

}

var break_point = new BreakPoint(source_position, opt_line, opt_column, opt_script_break_point);

break_points.push(break_point);

return break_point;

this.source_position_ = source_position;

this.source_line_ = opt_line;

this.source_column_ = opt_column;

if (opt_script_break_point) {

this.script_break_point_ = opt_script_break_point;

} else {

this.number_ = next_break_point_number++;

}

this.hit_count_ = 0;

this.active_ = true;

this.condition_ = null;

this.ignoreCount_ = 0;

if (this.script_break_point()) {

return this.script_break_point().active();

}

return this.active_;

if (this.script_break_point() && this.script_break_point().condition()) {

return this.script_break_point().condition();

}

return this.condition_;

// 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) || !%ToBoolean(mirror.value_)) {

return false;

}

} catch (e) {

// Exception evaluating condition counts as not triggered.

return false;

}

}

// Update the hit count.

this.hit_count_++;

if (this.script_break_point_) {

this.script_break_point_.hit_count_++;

}

// If the break point has an ignore count it is not triggered.

if (this.ignoreCount_ > 0) {

this.ignoreCount_--;

return false;

}

// Break point triggered.

return true;

opt_groupId) {

this.type_ = type;

if (type == Debug.ScriptBreakPointType.ScriptId) {

this.script_id_ = 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;

this.break_points_ = [];

var copy = new ScriptBreakPoint(Debug.ScriptBreakPointType.ScriptId,

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;

var locations = [];

for (var i = 0; i < this.break_points_.length; i++) {

locations.push(this.break_points_[i].actual_location);

}

return locations;

this.ignoreCount_ = ignoreCount;

// Set ignore count on all break points created from this script break point.

for (var i = 0; i < this.break_points_.length; i++) {

this.break_points_[i].setIgnoreCount(ignoreCount);

}

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();

}

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());

}

// 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];

}

// 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.line(), this.column(), this);

break_point.setIgnoreCount(this.ignoreCount());

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 };

this.break_points_.push(break_point);

return break_point;

var remaining_break_points = [];

for (var i = 0; i < break_points.length; i++) {

if (break_points[i].script_break_point() &&

break_points[i].script_break_point() === this) {

%ClearBreakPoint(break_points[i]);

} else {

remaining_break_points.push(break_points[i]);

}

}

break_points = remaining_break_points;

this.break_points_ = [];

for (var i = 0; i < script_break_points.length; i++) {

if (script_break_points[i].type() == Debug.ScriptBreakPointType.ScriptName &&

script_break_points[i].matchesScript(script)) {

script_break_points[i].set(script);

}

}

var result = [];

for (var i = 0; i < script_break_points.length; i++) {

if (script_break_points[i].matchesScript(script)) {

result.push(script_break_points[i]);

}

}

return result;

if (!IS_FUNCTION(listener) && !IS_UNDEFINED(listener) && !IS_NULL(listener)) {

throw new Error('Parameters have wrong types.');

}

%SetDebugEventListener(listener, opt_data);

if (IS_FUNCTION(func_or_script_name)) {

return %FunctionGetScript(func_or_script_name);

} else if (IS_REGEXP(func_or_script_name)) {

var scripts = Debug.scripts();

var last_result = null;

var result_count = 0;

for (var i in scripts) {

var script = scripts[i];

if (func_or_script_name.test(script.name)) {

last_result = script;

result_count++;

}

}

// 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;

}

} else {

return %GetScript(func_or_script_name);

}

var script = %FunctionGetScript(func);

var script_offset = %FunctionGetScriptSourcePosition(func);

return script.locationFromLine(opt_line, opt_column, script_offset);

var break_point;

for (var i = 0; i < break_points.length; i++) {

if (break_points[i].number() == break_point_number) {

break_point = break_points[i];

// Remove the break point from the list if requested.

if (remove) {

break_points.splice(i, 1);

}

break;

}

}

if (break_point) {

return break_point;

} else {

return this.findScriptBreakPoint(break_point_number, remove);

}

for (var i = 0; i < script_break_points.length; i++) {

if (script_break_points[i].number() == break_point_number) {

return script_break_points[i].actual_locations();

}

}

for (var i = 0; i < break_points.length; i++) {

if (break_points[i].number() == break_point_number) {

return [break_points[i].actual_location];

}

}

return [];

if (!IS_FUNCTION(func)) throw new Error('Parameters have wrong types.');

// Break points in API functions are not supported.

if (%FunctionIsAPIFunction(func)) {

throw new Error('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.');

}

// 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,

location.line, location.column,

opt_condition);

} else {

// Set a break point directly on the function.

var break_point = MakeBreakPoint(source_position, opt_line, opt_column);

var actual_position =

%SetFunctionBreakPoint(func, source_position, break_point);

actual_position += this.sourcePosition(func);

var actual_location = script.locationFromPosition(actual_position, true);

break_point.actual_location = { line: actual_location.line,

column: actual_location.column };

break_point.setCondition(opt_condition);

return break_point.number();

}

if (ignoreCount < 0) {

throw new Error('Invalid argument');

}

var break_point = this.findBreakPoint(break_point_number, false);

break_point.setIgnoreCount(ignoreCount);

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');

}

}

for (var i = 0; i < break_points.length; i++) {

break_point = break_points[i];

%ClearBreakPoint(break_point);

}

break_points = [];

var script_break_point;

for (var i = 0; i < script_break_points.length; i++) {

if (script_break_points[i].number() == break_point_number) {

script_break_point = script_break_points[i];

// Remove the break point from the list if requested.

if (remove) {

script_break_point.clear();

script_break_points.splice(i,1);

}

break;

}

}

return script_break_point;

opt_line, opt_column, opt_condition,

opt_groupId) {

// Create script break point object.

var script_break_point =

new ScriptBreakPoint(type, script_id_or_name, opt_line, opt_column,

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();

opt_line, opt_column,

opt_condition, opt_groupId) {

return this.setScriptBreakPoint(Debug.ScriptBreakPointType.ScriptId,

script_id, opt_line, opt_column,

opt_condition, opt_groupId);

opt_line, opt_column,

opt_condition, opt_groupId) {

return this.setScriptBreakPoint(Debug.ScriptBreakPointType.ScriptName,

script_name, opt_line, opt_column,

opt_condition, opt_groupId);

if (ignoreCount < 0) {

throw new Error('Invalid argument');

}

var script_break_point = this.findScriptBreakPoint(break_point_number, false);

script_break_point.setIgnoreCount(ignoreCount);

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);

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;

}

pos = source.length;

result += source.substring(prev_pos, pos);

return result;