Commands with no do_* method fall to here.
177447
def default(self, line):
        '''  '''
        # Commands that fall through to this method are interpreted as FORTH,
        # and must be in upper case.
        if not line.isupper():
            print(self.style.error('Error: ', 'Unrecognized command.'))
            return

        if self.arm.is_connected():
            if self.wrapper:
                line = self.wrapper.wrap_input(line)
            self.arm.write(line)
            try:
                res = self.arm.read()
            except KeyboardInterrupt:
                # NOTE interrupts aren't recursively handled.
                self.arm.write('STOP')
                res = self.arm.read()
            if self.wrapper:
                res = self.wrapper.wrap_output(res)
            print(res)
        else:
            print(self.style.error('Error: ', 'Arm is not connected.'))
1359040
private Optional<RuntimeException> runCommands(String stage, List<String[]> commands) {
    if (commands == null) {
      return Optional.empty();
    }
    for (String[] command : commands) {
      try {
        LOG.info("{} command started: {}", stage, ProcessUtil.join(command));
        Process p = Runtime.getRuntime().exec(command, envp, dir);
        int exitCode = p.waitFor();

        String stdOut = ProcessUtil.getStdOut(p);
        String stdErr = ProcessUtil.getStdErr(p);
        if (!stdOut.isEmpty()) {
          LOG.info("STDOUT:\n" + stdOut);
        }
        if (!stdErr.isEmpty()) {
          LOG.info("STDERR:\n" + stdErr);
        }

        if (exitCode != 0) {
          return Optional.of(new IllegalArgumentException("Non-zero exit code: " + exitCode));
        }
      } catch (IOException e) {
        return Optional.of(new UncheckedIOException(e));
      } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return Optional.of(new RuntimeException(e));
      }
    }
    return Optional.empty();
  }
913076
def cli(ctx, cmd):
    """"""

    exit_code = util.call(cmd)
    ctx.exit(exit_code)
231179
def no_args(**kwargs):
    """"""
    from benchbuild.utils.cmd import uchroot as uchrt

    prefixes = CFG["container"]["prefixes"].value
    p_paths, p_libs = env(prefixes)
    uchrt = run.with_env_recursive(
        uchrt,
        LD_LIBRARY_PATH=path.list_to_path(p_libs),
        PATH=path.list_to_path(p_paths))

    return uchrt
171352
def do_shortcuts(self, _: argparse.Namespace) -> None:
        """"""
        result = "\n".join('%s: %s' % (sc[0], sc[1]) for sc in sorted(self.shortcuts))
        self.poutput("Shortcuts for other commands:\n{}\n".format(result))
1068769
def clean_library_commands
      aliases = @commands_hash.select {|k,v| @commands.include?(k) }.
        map {|k,v| v[:alias] }.compact
      @commands -= aliases
      @commands.uniq!
    end
1318519
def handle_one_command(self):
        """"""

        while True:
            yield from self.write_prompt()
            codeobj = yield from self.read_command()

            if codeobj is not None:
                yield from self.run_command(codeobj)
156651
def cli(ctx, all, top, nostyle, nowarn, warn, project_dir):
    """"""

    exit_code = SCons(project_dir).lint({
        'all': all,
        'top': top,
        'nostyle': nostyle,
        'nowarn': nowarn,
        'warn': warn
    })
    ctx.exit(exit_code)
15936
void markCommandDone(ExecutionResult executionResult, HystrixCommandKey commandKey, HystrixThreadPoolKey threadPoolKey, boolean executionStarted) {
        HystrixThreadEventStream.getInstance().executionDone(executionResult, commandKey, threadPoolKey);
        if (executionStarted) {
            concurrentExecutionCount.decrementAndGet();
        }
    }
785840
def p_command(p):
    """"""
    #print("COMMAND:", p[1], p[2], p[3])
    tests = p[2].get('tests')
    block = None
    if p[3] != ';': block = p[3]
    handler = sifter.handler.get('command', p[1])
    if handler is None:
        print("No handler registered for command '%s' on line %d" %
            (p[1], p.lineno(1)))
        raise SyntaxError
    p[0] = handler(arguments=p[2]['args'], tests=tests, block=block)
899783
def method_missing(method, *args, &block)
      method = method.to_sym
      if @modules.keys.include?(method)
        @modules[method]
      elsif available_modules.include?(method)
        @dummy_module
      else
        process_command method, *args
      end
    end
461057
def _do_main(self, commands):
        
        self._reset()
        self._init_schema_helper()
        self._run_prerequisites(commands)

        idl_ = idl.Idl(self.remote, self.schema_helper)
        seqno = idl_.change_seqno
        while True:
            self._idl_wait(idl_, seqno)

            seqno = idl_.change_seqno
            if self._do_vsctl(idl_, commands):
                break

            if self.txn:
                self.txn.abort()
                self.txn = None
            # TODO:XXX
            # ovsdb_symbol_table_destroy(symtab)

        idl_.close()
1126864
function(verbs, patterns, method) {
		//Force verbs to be an array.
		if (!verbs.each) verbs = [verbs];
		//Force pattern to be an array.
		if (!patterns.each) { patterns = [patterns]; }
		method = method || this['do_'+verbs[0]];
		if (!method) { return false; }
		//Force method to be a function and not a string.
		if (method.length) { method = this[method]; }
		this.commands.push ({
			'verbs'  : verbs,
			'syntax' : patterns,
			'handler': method
		});
	}
353468
def method_missing(name, *args, &block)
      if args.empty? && !block_given? && @arg_names.include?(name)
        @args[name]
      else
        super
      end
    end
205300
private void cleanup() {
    if (operation instanceof Command && log.isOpen()) {
      try {
        log.release(index);
      } catch (IllegalStateException e) {
      }
    }

    session.release();

    index = 0;
    session = null;
    instant = null;
    operation = null;

    pool.release(this);
  }
894979
function stopWithHelp(...msgs) {
  utils.header()
  utils.error(...msgs)
  commands.help.forCommand(commands.build)
  utils.die()
}
680920
def method_missing(name, *args, &reply_handler)
      unless @default_iface && has_iface?(@default_iface)
        # TODO: distinguish:
        # - di not specified
        # TODO
        # - di is specified but not found in introspection data
        raise NoMethodError, "undefined method `#{name}' for DBus interface `#{@default_iface}' on object `#{@path}'"
      end

      begin
        @interfaces[@default_iface].method(name).call(*args, &reply_handler)
      rescue NameError => e
        # interesting, foo.method("unknown")
        # raises NameError, not NoMethodError
        raise unless e.to_s =~ /undefined method `#{name}'/
        # BTW e.exception("...") would preserve the class.
        raise NoMethodError, "undefined method `#{name}' for DBus interface `#{@default_iface}' on object `#{@path}'"
      end
    end