Sets whether execution should break when a function is entered.
335396
public void setBreakOnEnter(boolean value) {
        dim.setBreakOnEnter(value);
        debugGui.getMenubar().getBreakOnEnter().setSelected(value);
    }
951287
private Status executeFail(Stmt.Fail stmt, CallStack frame, EnclosingScope scope) {
		throw new AssertionError("Runtime fault occurred");
	}
258620
def _onFunction( self, name, line, pos, absPosition,
                           keywordLine, keywordPos,
                           colonLine, colonPos, level ):
        "  "
        self.__flushLevel( level )
        self.objectsStack.append( Function( name, line, pos, absPosition,
                                            keywordLine, keywordPos,
                                            colonLine, colonPos ) )
        return
1298774
def _set(self):
        """"""
        self.__event.set()
        if self._complete_func:
            self.__run_completion_func(self._complete_func, self.id_)
1356865
def callable_check(func, arg_count=1, arg_value=None, allow_none=False):
        """"""
        if func is None:
            if not allow_none:
                raise ValueError('callable cannot be None')
        elif not arg_checker(func, *[arg_value for _ in range(arg_count)]):
            raise ValueError('callable %s invalid (for %d arguments)' % (func, arg_count))
391580
def on_set(self, key, value):
    """"""
    if self._on_set is not None:
      self._on_set(key, value)
656525
def try_and_error(*funcs):
    """"""
    def validate(value):
        exc = None
        for func in funcs:
            try:
                return func(value)
            except (ValueError, TypeError) as e:
                exc = e
        raise exc
    return validate
753740
def _onFunction(self, name, line, pos, absPosition,
                    keywordLine, keywordPos,
                    colonLine, colonPos, level,
                    isAsync, returnAnnotation):
        """"""
        self.__flushLevel(level)
        f = Function(name, line, pos, absPosition, keywordLine, keywordPos,
                     colonLine, colonPos, isAsync, returnAnnotation)
        if self.__lastDecorators is not None:
            f.decorators = self.__lastDecorators
            self.__lastDecorators = None
        self.objectsStack.append(f)
674718
def _handle_break(self, node, scope, ctxt, stream):
        
        self._dlog("handling break")
        raise errors.InterpBreak()
312428
def should_break_here(self, frame):
        """"""
        # Next line commented out for performance
        #_logger.b_debug("should_break_here(filename=%s, lineno=%s) with breaks=%s",
        #                frame.f_code.co_filename,
        #                frame.f_lineno,
        #                IKBreakpoint.breakpoints_by_number)
        
        c_file_name = self.canonic(frame.f_code.co_filename)
        if not c_file_name in IKBreakpoint.breakpoints_files:
            return False
        bp = IKBreakpoint.lookup_effective_breakpoint(c_file_name, 
                                                      frame.f_lineno, 
                                                      frame)
        return True if bp else False
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");
		}
	}
1189294
def ok(no_exit, func, *args, **kwargs):
    """"""
    ret = func(*args, **kwargs)
    if no_exit or ret >= 0:
        return ret
    reason = errmsg[abs(ret)]
    error('{0}() returned {1} ({2})'.format(func.__name__, ret, reason))
298061
def handle_user_input
      while true
        begin
          break if !wait_for_prompt
          input = $stdin.gets.chomp!
          execute_action(input, true)
        rescue SignalException => e
          return false
        end
      end
      wait
    end
1168920
function(func, arr, opts) {
		var dfrd = $.Deferred(),
			abortFlg = false,
			parms = Object.assign({
				interval : 0,
				numPerOnce : 1
			}, opts || {}),
			resArr = [],
			vars =[],
			curVars = [],
			exec,
			tm;
		
		dfrd._abort = function(resolve) {
			tm && clearTimeout(tm);
			vars = [];
			abortFlg = true;
			if (dfrd.state() === 'pending') {
				dfrd[resolve? 'resolve' : 'reject'](resArr);
			}
		};
		
		dfrd.fail(function() {
			dfrd._abort();
		}).always(function() {
			dfrd._abort = function() {};
		});

		if (typeof func === 'function' && Array.isArray(arr)) {
			vars = arr.concat();
			exec = function() {
				var i, len, res;
				if (abortFlg) {
					return;
				}
				curVars = vars.splice(0, parms.numPerOnce);
				len = curVars.length;
				for (i = 0; i < len; i++) {
					if (abortFlg) {
						break;
					}
					res = func(curVars[i]);
					(res !== null) && resArr.push(res);
				}
				if (abortFlg) {
					return;
				}
				if (vars.length) {
					tm = setTimeout(exec, parms.interval);
				} else {
					dfrd.resolve(resArr);
				}
			};
			if (vars.length) {
				tm = setTimeout(exec, 0);
			} else {
				dfrd.resolve(resArr);
			}
		} else {
			dfrd.reject();
		}
		return dfrd;
	}
1027608
function (f) {
    var self = this;

    if (typeof f !== 'function')
      throw new Error("onInvalidate requires a function");

    if (self.invalidated) {
      Deps.nonreactive(function () {
        callWithNoYieldsAllowed(f, self);
      });
    } else {
      self._onInvalidateCallbacks.push(f);
    }
  }
32115
function handleExit (canCancel, signal, code) {
	var i = 0,
		sub;

	while ((sub = subs[i++])) {
		if (sub[0].call(sub[1], canCancel, signal, code) === false && canCancel) {
			return;
		}
	}

	if (canCancel) {
		process.exit(code);
	}
}
852782
public void setBreakOnReturn(boolean value) {
        dim.setBreakOnReturn(value);
        debugGui.getMenubar().getBreakOnReturn().setSelected(value);
    }