def command(*commands, visible = True, internal = False, nargs = '*'):
    """Decorate a function to be the entry function of commands.

    Arguments:
        commands: Names of command that should trigger this function object.
        visible: This command is visible in tab completions.
        internal: The lexing rule is unchanged even if the parse_line() method
            is overloaded in the subclasses.
        nargs: Short for number of arguments. Similar to the nargs argument in
            the argparse module. Has the following valid values:
                    a non-negative integer
                    a list/set/tuple/range of non-negative integers
                    '*':        zero or more
                    '?':        zero or one
                    '+':        one or more
            The command method, whose interface is described below, will check
            the number of arguments. If it does not match this nargs argument,
            an error message will be printed to self.stderr and the shell is
            resumed.

    ----------------------------
    Interface of command methods:

        @command('foo', 'bar')
        def bar(self, args):
            '''The method invoked by 'foo' and 'bar' commands.

            Arguments:
                args: A list of strings. This list is obtianed via
                    shlex.split().
            '''
            pass
    """
    # Strict checking of the nargs argument.
    allowed_strs = {'*', '?', '+'}
    err_str = textwrap.dedent('''\
            command: '{}' is invalid, must be a non-negative integer, a
            list/set/tuple/range of non-negative integer, or one of {}
            '''.format(nargs, allowed_strs))
    if isinstance(nargs, str):
        if not nargs in allowed_strs:
            raise RuntimeError(err_str)
    elif isinstance(nargs, int):
        if nargs < 0:
            raise RuntimeError(err_str)
    else:
        nargs = list(nargs)
        for ele in nargs:
            if not isinstance(ele, int) or ele < 0:
                raise RuntimeError(err_str)

    def decorated_func(f):
        def inner_func(self, cmd, args):
            # Check the number of args according to nargs.
            n = len(args)
            if isinstance(nargs, str):
                if nargs == '*':
                    pass
                elif nargs == '?':
                    if n > 1:
                        self.error("{}: expect 0 or 1 argument, provided {}: {}\n".
                                format(cmd, n, args))
                        return
                elif nargs == '+':
                    if n == 0:
                        self.error("{}: expect 1 or more arguments, provided {}: {}\n".
                                format(cmd, n, args))
                        return
            elif isinstance(nargs, int):
                if n != nargs:
                        self.error("{}: expect {} arguments, provided {}: {}\n".
                                format(cmd, nargs, n, args))
                        return
            else:
                # nargs is already converted to a list.
                if not n in nargs:
                        self.error("{}: the number of arguments could be one of "
                                "{}, provided {}: {}\n".
                                format(cmd, nargs, n, args))
                        return
            return f(self, cmd, args)
        inner_func.__name__ = f.__name__
        inner_func.__doc__ = f.__doc__
        inner_func.__command__ = {
                'commands': list(commands),
                'visible': visible,
                'internal': internal,
        }
        # If f is deprecated, inner_func should also be deprecated. Do not use
        # the deprecated() function directly, as that adds duplicate warning
        # message.
        if isdeprecated(f):
            inner_func.__deprecated__ = True
        return inner_func
    return decorated_func