Handle the --nice argument.
422138
private void handleArgNice(final Deque<String> args) {
        final String value = args.pop();
        if (value == null) {
            throw new BuildException("You must supply a niceness value (1-10) after the --nice option");
        }
        try {
            threadPriority = Integer.decode(value);
        } catch (final NumberFormatException e) {
            throw new BuildException("Unrecognized niceness value: " + value);
        }

        if (threadPriority < Thread.MIN_PRIORITY || threadPriority > Thread.MAX_PRIORITY) {
            throw new BuildException("Niceness value is out of the range 1-10");
        }
    }
693345
def _ValidateArguments(arg_dict, type_check_dict):
  """"""
  messages = []
  for arg_name, arg_value in arg_dict.items():
    if arg_name in type_check_dict:
      type_check = type_check_dict[arg_name]
      res = _ValidateValue(arg_value, type_check)
      if not res:
        message = ("Invalid value '%s' for argument %s. Expected %s" %
                   (arg_value, arg_name, _FormatTypeCheck(type_check)))
        messages.append(message)
  return messages
458512
function assertArguments(options, argnames) {
  if (!argnames) return;
  if (!options) throw new TypeError('missing arguments: ' + argnames);
  argnames.forEach(function (argname) {
    if (!options.hasOwnProperty(argname)) {
      throw new TypeError('missing argument: ' + argname);
    }
  });
}
453477
def positive(value, argument='argument'):
    
    value = _get_integer(value)
    if value < 1:
        error = ('Invalid {arg}: {value}. {arg} must be a positive '
                 'integer'.format(arg=argument, value=value))
        raise ValueError(error)
    return value
38912
def _add_two_argument_command(self, command, arg1, arg2):
        """"""
        self.lines.append("{} {} {}".format(command, arg1, arg2))
757704
def make_arg(key, annotation=None):
    """"""
    arg = ast.arg(key, annotation)
    arg.lineno, arg.col_offset = 0, 0
    return arg
197957
function Args() {
    if (argv._.length >= 1) {
        try {
            // Attempt to parse 1st argument as JSON string
            _.extend(this, JSON.parse(argv._[0]));
        } catch (err) {
            // Pass, we must be in the console so don't worry about it
        }
    }
}
785740
def ok(*args)
      options = Utils.extract_options!(args)
      args.each { |message| say message, options.merge(color: :green) }
    end
884626
def equal_args(*args, **kwargs):
  """"""
  key = args
  if kwargs:
    key += _kwargs_separator + tuple(sorted(kwargs.items()))
  return key
741593
def ok(self, *args, cb=None):
        """"""
        self.clear_widgets()
        if cb:
            cb()
        self.idx += 1
        self.advance_dialog()
26115
def _attach_arguments(self):
        """"""
        for arg in self.arguments:
            self.parser.add_argument(*arg[0], **arg[1])
451596
function prepareArgument(match, name) {
		var result = {
				type:  match ? match[1] : false,
				name:  match ? match[2] : name
			};

		if (match) {
			if (match[4] === '@') {
				result.reference = match[5];
			}
			else if (match[3] === '=') {
				result.value = cast(result.type, match[5]);
			}
		}

		return result;
	}
719869
def add_arg(self,arg, prepend=False):
        """"""

        self.args = [arg_.strip() for arg_ in self.args if arg_.strip()]

        if arg.title() not in self.args:
            if prepend:
                self.args = [arg.title()] + self.args
            else:
                self.args.append(arg.title())
1157623
function invalidArgument(it, at, expected, actual) {
    throw new TypeError (
      it
      + ' expects its '
      + ordinal[at]
      + ' argument to '
      + expected
      + '\n  Actual: '
      + show (actual)
    );
  }
786907
function ( parent, child ) {
		parent.then( function ( arg ) {
			child.resolve( arg );
		}, function ( e ) {
			child.reject( e );
		});
	}
941812
private void processArgument() {
        final StringBuilder argumentBuilder = new StringBuilder();
        while (templateReader.hasNextCharacter()) {
            final char argumentCharacter = templateReader.nextCharacter();
            if (argumentCharacter == syntax.getArgumentClosing()) {
                final String argument = argumentBuilder.toString().trim(); // Getting actual argument name.
                if (Strings.startsWith(argument, syntax.getEquationMarker())) {
                    // Starts with an equation sign. Evaluating.
                    final String equation = LmlUtilities.stripMarker(argument);
                    templateReader.append(newEquation().getResult(equation), equation + " equation");
                } else if (Strings.startsWith(argument, syntax.getConditionMarker())) {
                    // Condition/ternary operator. Evaluating.
                    processConditionArgument(argument, argumentBuilder);
                } else { // Regular argument. Looking for value mapped to the selected key.
                    templateReader.append(Nullables.toString(data.getArgument(argument)), argument + " argument");
                }
                return;
            }
            argumentBuilder.append(argumentCharacter);
        }
    }
1166967
function handleIncomingMessage(data) {
		var message;
		reader.parse(data, initPending);
		initPending = false;
		while (!reader.isEmpty()) {
			message = reader.pop();
			// console.log("IN MESSAGE: " + inspect(message));
			handlers[message.verb](message);
		}
	}