Set/Edit conditional breakpoint
170013
def set_or_edit_conditional_breakpoint(self):
        """"""
        editorstack = self.get_current_editorstack()
        if editorstack is not None:
            self.switch_to_plugin()
            editorstack.set_or_edit_conditional_breakpoint()
427816
public void breakpointManagerEnablementChanged(boolean enabled)
	{
		IBreakpoint[] breakpoints = getBreakpointManager().getBreakpoints(target.getModelIdentifier());

		final IDbgpSession[] sessions = getSessions();
		for (int i = 0; i < breakpoints.length; ++i)
		{
			try
			{
				final IBreakpoint breakpoint = breakpoints[i];
				if (breakpoint instanceof IVdmBreakpoint)
				{
					for (int j = 0; j < sessions.length; ++j)
					{
						changeBreakpoint(sessions[j], (IVdmBreakpoint) breakpoint);
					}
				}
			} catch (Exception e)
			{
				VdmDebugPlugin.log(e);
			}
		}
	}
1214281
public void setBreakPoint(int line) {
        if (sourceInfo.breakableLine(line)) {
            boolean changed = sourceInfo.breakpoint(line, true);
            if (changed) {
                fileHeader.repaint();
            }
        }
    }
26225
def make_breakpoint(self, event_type, *args, **kwargs):
        
        bp = BP(*args, **kwargs)
        self.add_breakpoint(event_type, bp)
        return bp
73219
function saveBreakHold() {
    if (editor.binding && editor.holding) {
      generator.clientUpdateFragmentText(editor.binding, editor.$edit.val(), true);
      editor.holding = false;
    }
  }
340626
function(width) {

			var foundBrkpt = false;

			// look for existing breakpoint based on width
			for (var i = 0; i < mediaBreakpoints.length; i++) {

				// if registered breakpoint found, break out of loop
				if (width >= mediaBreakpoints[i]['enter'] && width <= mediaBreakpoints[i]['exit']) {
					foundBrkpt = true;

					break;
				}
			}

			// if breakpoint is found and it's not the current one
			if (foundBrkpt && curr !== mediaBreakpoints[i]['label']) {
				prev = curr;
				curr = mediaBreakpoints[i]['label'];

				// run the loop
				cycleThrough();

			// or if no breakpoint applies
			} else if (!foundBrkpt && curr !== '') {
				curr = '';

				// run the loop
				cycleThrough();
			}

		}
506398
function neoDebug (prefix, options)
{
	var copy = {};
	if (options)
	{
		for (var i in options)
			copy[i] = options[i];
	}

	copy.prefix = prefix;

	var index = String(_options.push(copy) - 1);
	_prevTimes.push(0);
	updateDebugFunction(index);
	function debug ()
	{
		var f = _functions[index];
		if (f !== disabled)
			f(arguments);
	}

	debug.update = function (options)
	{
		if (!options)
			return;

		var orig = _options[index];
		for (var i in options)
			orig[i] = options[i];

		updateDebugFunction(index);
	};

	return debug;
}
507481
private void setBreakpoint(String name, String condition) throws Exception
	{
		LexTokenReader ltr = new LexTokenReader(name, Dialect.VDM_SL);
		LexToken token = ltr.nextToken();
		ltr.close();

		Value v = null;

		if (token.is(VDMToken.IDENTIFIER))
		{
			LexIdentifierToken id = (LexIdentifierToken) token;
			LexNameToken lnt = new LexNameToken(interpreter.getDefaultName(), id);
			v = interpreter.findGlobal(lnt);
		} else if (token.is(VDMToken.NAME))
		{
			v = interpreter.findGlobal((LexNameToken) token);
		}

		if (v instanceof FunctionValue)
		{
			FunctionValue fv = (FunctionValue) v;
			PExp exp = fv.body;
			interpreter.clearBreakpoint(BreakpointManager.getBreakpoint(exp).number);
			Breakpoint bp = interpreter.setBreakpoint(exp, condition);
			println("Created " + bp);
			println(interpreter.getSourceLine(bp.location));
		} else if (v instanceof OperationValue)
		{
			OperationValue ov = (OperationValue) v;
			PStm stmt = ov.body;
			interpreter.clearBreakpoint(BreakpointManager.getBreakpoint(stmt).number);
			Breakpoint bp = interpreter.setBreakpoint(stmt, condition);
			println("Created " + bp);
			println(interpreter.getSourceLine(bp.location));
		} else if (v == null)
		{
			println(name + " is not visible or not found");
		} else
		{
			println(name + " is not a function or operation");
		}
	}
173433
def set_debug(self, status):
        """"""
        if status:
            self.logger.setLevel('DEBUG')
        else:
            self.logger.setLevel('INFO')
714267
def setBreakpoints( self, breakpoints ):
        
        self.clearBreakpoints()
        for breakpoint in breakpoints:
            self.addBreakpoint(breakpoint)
820136
function setToolMode(mode, changeEvent, toolName, options) {
  _trackGlobalToolModeChange(mode, toolName, options);
  store.state.enabledElements.forEach(element => {
    setToolModeForElement(mode, changeEvent, element, toolName, options);
  });
}
475963
function findExistingBreakpoint(state, generatedLocation) {
  const breakpoints = getBreakpointsList(state);

  return breakpoints.find(bp => {
    return (
      bp.generatedLocation.sourceUrl == generatedLocation.sourceUrl &&
      bp.generatedLocation.line == generatedLocation.line &&
      bp.generatedLocation.column == generatedLocation.column
    );
  });
}
1009708
function() {
    this.setColour(Blockly.Blocks.logic.HUE);
    this.appendDummyInput()
        .appendField(Blockly.Msg.CONTROLS_IF_ELSE_TITLE_ELSE);
    this.setPreviousStatement(true);
    this.setTooltip(Blockly.Msg.CONTROLS_IF_ELSE_TOOLTIP);
    this.contextMenu = false;
  }
845152
function fixupCompilerOptions(options, diagnostics) {
        // Lazily create this value to fix module loading errors.
        commandLineOptionsStringToEnum = commandLineOptionsStringToEnum || ts.filter(ts.optionDeclarations, function (o) {
            return typeof o.type === "object" && !ts.forEachProperty(o.type, function (v) { return typeof v !== "number"; });
        });
        options = ts.clone(options);
        var _loop_3 = function(opt) {
            if (!ts.hasProperty(options, opt.name)) {
                return "continue";
            }
            var value = options[opt.name];
            // Value should be a key of opt.type
            if (typeof value === "string") {
                // If value is not a string, this will fail
                options[opt.name] = ts.parseCustomTypeOption(opt, value, diagnostics);
            }
            else {
                if (!ts.forEachProperty(opt.type, function (v) { return v === value; })) {
                    // Supplied value isn't a valid enum value.
                    diagnostics.push(ts.createCompilerDiagnosticForInvalidCustomType(opt));
                }
            }
        };
        for (var _i = 0, commandLineOptionsStringToEnum_1 = commandLineOptionsStringToEnum; _i < commandLineOptionsStringToEnum_1.length; _i++) {
            var opt = commandLineOptionsStringToEnum_1[_i];
            _loop_3(opt);
        }
        return options;
    }
1314502
def breakpoint(args):
    
    from jcvi.utils.iter import pairwise

    p = OptionParser(breakpoint.__doc__)
    p.add_option("--diff", default=.1, type="float",
                 help="Maximum ratio of differences allowed [default: %default]")
    opts, args = p.parse_args(args)

    if len(args) != 1:
        sys.exit(not p.print_help())

    mstmap, = args
    diff = opts.diff
    data = MSTMap(mstmap)

    # Remove singleton markers (avoid double cross-over)
    good = []
    nsingletons = 0
    for i in xrange(1, len(data) - 1):
        a = data[i]
        left_label, left_rr = check_markers(data[i - 1], a, diff)
        right_label, right_rr = check_markers(a, data[i + 1], diff)

        if left_label == BREAK and right_label == BREAK:
            nsingletons += 1
            continue

        good.append(a)

    logging.debug("A total of {0} singleton markers removed.".format(nsingletons))

    for a, b in pairwise(good):
        label, rr = check_markers(a, b, diff)
        if label == BREAK:
            print("\t".join(str(x) for x in rr))
805830
def update_active_breakpoint_flag(cls):
        
        cls.any_active_breakpoint=any([bp.enabled for bp in cls.breakpoints_by_number if bp])
396096
def set_breakpoint(self, file_name, line_number, condition=None, enabled=True):
        
        c_file_name = self.canonic(file_name)
        import linecache
        line = linecache.getline(c_file_name, line_number)
        if not line:
            return "Line %s:%d does not exist." % (c_file_name, line_number), None
        bp = IKBreakpoint(c_file_name, line_number, condition, enabled)
        if self.pending_stop or IKBreakpoint.any_active_breakpoint:
            self.enable_tracing()
        else:
            self.disable_tracing()
        return None, bp.number