Set a breakpoint at the given function or operation name with a condition.

@param name
The function or operation name.
@param condition
Any condition for the breakpoint, or null.
@throws Exception
Problems parsing condition.
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");
		}
	}
191403
public static final void setServerName(String name)
    {
        if (tc.isDebugEnabled())
            Tr.debug(tc, "setServerName", name);

        // Store the server name.
        serverName = name;
    }
433770
public final <T> void addOption(String name, String description)
    {
        addOption(String.class, name, description, null);
    }
443770
public void setIfUnset(String name, String value) {
        if (get(name) == null) {
            set(name, value);
        }
    }
551367
public static void notNullOrEmpty(Object[] parameter, String name) throws IllegalArgumentException {
		if (parameter == null || parameter.length == 0) {
			throw new IllegalArgumentException(name + " parameter is empty.");
		}
	}
1127468
@Override
    public void setService(final String name, final FrameworkSupportService service){
        synchronized (services){
            if(null==services.get(name) && null!=service) {
                services.put(name, service);
            }else if(null==service) {
                services.remove(name);
            }
        }
    }
315085
public void setProperty(String name, String value)
    {
        if ((value == null) || (value.length() == 0))
        {
            _properties.remove(name);
        }
        else
        {
            _properties.setProperty(name, value);
        }
    }
1326195
public void setConditions(java.util.Collection<Condition> conditions) {
        if (conditions == null) {
            this.conditions = null;
            return;
        }

        this.conditions = new java.util.ArrayList<Condition>(conditions);
    }
49661
public void removeParameter(String name) {
		if(name == null) {
			throw new NullPointerException("parameter name is null ! ");
		}
		if(isModifiable == ModifiableRule.NotModifiable) {
			throw new IllegalStateException("it is forbidden to modify the parameters");
		}
		if(name.equalsIgnoreCase("tag") && (isModifiable == ModifiableRule.From || isModifiable == ModifiableRule.To)) {
			throw new IllegalStateException("it is forbidden to remove the tag parameter on To or From Header");
		}
		if(name.equalsIgnoreCase("branch") && isModifiable == ModifiableRule.Via) {
			throw new IllegalStateException("it is forbidden to set the branch parameter on the Via Header");
		}
		this.parameters.remove(name);
		if(header != null) {
			header.removeParameter(name);
		}
	}
277497
public void setAcl(String name, boolean acl) {
        String newName = name.toLowerCase();
        if (aclList.containsKey(newName)) {
            AccountACLValue value = aclList.get(newName);
            set(newName, value.canDeposit(), value.canWithdraw(), acl, value.canBalance(), value.isOwner());
        } else {
            set(newName, false, false, acl, false, false);
        }
    }
8935
public static void notNull(final Object arg, final String name) {
        if(arg == null) {
            throw new NullPointerException(String.format("%s should not be null.", name));
        }
    }
816138
public static void requireArgNotNull(@NotNull final String name, final Object value) throws ConstraintViolationException {
        // CHECKSTYLE:ON
        if (value == null) {
            throw new ConstraintViolationException("The argument '" + name + "' cannot be null");
        }
    }
1085683
public final void setError(IOException exception) throws IOException {
    Objects.requireNonNull(exception, "exception required");
    errorMessage = exception.getMessage();
    // StringWriter sw = new StringWriter();
    // exception.printStackTrace(new PrintWriter(sw));
    // errorMessage+="\n====\n"+sw.toString();
    errorStatus = true;
    throw exception;
  }
185450
public void badParam(String name, String value)
            throws ParseException {
        throw new ParseException("parameter " + name + " has bad value [[" +
                value + "]] in " + ruleStack, 0);
    }
1101868
public void setName(String name) {

        String oufqn = getOufqn();
        if (oufqn != null) {
            if (!oufqn.endsWith("/")) {
                oufqn += "/";
            }
        } else {
            oufqn = "/";
        }
        m_project.setName(oufqn + name);

    }
1147005
def set_break(
            self, filename, lineno=None, temporary=False, cond=None,
            funcname=None
    ):
        """"""
        log.info(
            'Setting break fn:%s lno:%s tmp:%s cond:%s fun:%s' %
            (filename, lineno, temporary, cond, funcname)
        )
        breakpoint = self.get_break(
            filename, lineno, temporary, cond, funcname
        )
        self.breakpoints.add(breakpoint)
        log.info('Breakpoint %r added' % breakpoint)
        return breakpoint
588153
public static void isPositive( long argument,
                                   String name ) {
        if (argument <= 0) {
            throw new IllegalArgumentException(CommonI18n.argumentMustBePositive.text(name, argument));
        }
    }