32

While running the complete command on my gnome-terminal, it shows some commands.What are they? And what is the use of complete command?

$ complete
complete -F _minimal 
complete -F _filedir_xspec oodraw
complete -F _filedir_xspec elinks
complete -F _filedir_xspec freeamp
complete -F _longopt split
complete -F _longopt sed
complete -F _longopt ld
complete -F _longopt grep
complete -F _service /etc/init.d/vboxweb-service
complete -F _service /etc/init.d/vboxballoonctrl-service
complete -F _service /etc/init.d/rc
complete -F _service /etc/init.d/nmbd
complete -F _service /etc/init.d/halt
complete -j -P '"%' -S '"' jobs
complete -d pushd

List goes long, so i posted some of the them.

6
  • 2
    I tried 'man complete' command but it displays nothing. Apr 4, 2014 at 7:39
  • 6
    try help complete Apr 4, 2014 at 7:45
  • 4
    Holy carp I've been using Bash for decades and did not know there is a help command for builtins. I have always searched the massive 'man bash' output, while cursing. May 28, 2020 at 21:11
  • use man bash then search for 'completing'. I'll post the readout in an answer below. It can be used to adjust the tab completion functions of Bash.
    – alchemy
    Dec 6, 2022 at 1:54
  • there is much more under 'Programmable Completion' in man bash
    – alchemy
    Dec 6, 2022 at 2:16

4 Answers 4

33

complete is a bash builtin function. So there is not a binary on the system. It handles how commands will be completed when pressing tab.

Example: if you type:

user@host:~$ pidof <tab><tab>

...a list is appearing with all possible values for this command. In this case it means all running processes. See the output of the complete function:

user@host:~$ complete | grep pidof
complete -F _pgrep pidof

This means that the function _pgrep (-F) is executed when tabbing the command pidof. The definition of this function is in /etc/bash_completion.d/procps.

Another example: if you type:

user@host:~$ cd /usr/<tab><tab>
bin/     games/   include/ lib/     lib32/   local/   sbin/    share/   src/

...you see the list of folders you can cd to under /usr/. Which function is executed? greping the complete function (as above) tells us it's the funtction _cd in /etc/bash_completion.

Do it yourself: You have a program/script called /bin/myprog and you want that if you execute it as follows

user@host:~$ myprog /home/user/<tab><tab>

...it should only list folders, not files. So extend your bash completion with the following command:

user@host:~$ complete -F _cd myprog

That's it. You can also write own functions to complete custom things, for example complete only specific files or numbers or lists of static values...

1
  • 1
    So that's how git's command line completion seems so much smarter than most program's...
    – AShelly
    Apr 4, 2014 at 11:06
12

complete is a bash command used to perform the auto-complete action when the user hit the TAB key in a terminal.

Calling just complete will list all the functions registered for auto-completion of commands or services options.

From the bash man pages:

complete: complete [-abcdefgjksuv] [-pr] [-DE] [-o option] [-A action] [-G globpat]
          [-W wordlist]  [-F function] [-C command] [-X filterpat] [-P prefix]
          [-S suffix] [name ...]
    Specify how arguments are to be completed by Readline.

    For each NAME, specify how arguments are to be completed.  If no options
    are supplied, existing completion specifications are printed in a way that
    allows them to be reused as input.

    Options:
      -p    print existing completion specifications in a reusable format
      -r    remove a completion specification for each NAME, or, if no
        NAMEs are supplied, all completion specifications
      -D    apply the completions and actions as the default for commands
        without any specific completion defined
      -E    apply the completions and actions to "empty" commands --
        completion attempted on a blank line

    When completion is attempted, the actions are applied in the order the
    uppercase-letter options are listed above.  The -D option takes
    precedence over -E.

    Exit Status:
    Returns success unless an invalid option is supplied or an error occurs.

Check /usr/share/bash-completion/bash_completion to see the default completions that come with bash.

Visit http://www.linuxjournal.com/content/more-using-bash-complete-command for a full tutorial about this command.

1
  • you can see the help complete documentation is missing documentation on -F -A -G... everything
    – ZJR
    May 21, 2023 at 13:26
1

(Also see: https://www.reddit.com/r/bash/comments/qyr8sj/understanding_c_command_for_completions/ https://echorand.me/posts/linux_shell_autocompletion/)

From man bash search 'Completing':

Completing
       complete (TAB)
              Attempt to perform completion on the text before point.  Bash attempts comple-
              tion treating the text as a variable (if the text begins with $), username (if
              the text begins with ~), hostname (if the text begins with @), or command (in-
              cluding aliases and functions) in turn.  If none of these  produces  a  match,
              filename completion is attempted.
       possible-completions (M-?)
              List the possible completions of the text before point.
       insert-completions (M-*)
              Insert all completions of the text before point that would have been generated
              by possible-completions.
       menu-complete
              Similar to complete, but replaces the word to be completed with a single match
              from  the  list  of possible completions.  Repeated execution of menu-complete
              steps through the list of possible completions, inserting each match in  turn.
              At  the  end of the list of completions, the bell is rung (subject to the set-
              ting of bell-style) and the original text is restored.  An argument of n moves
              n positions forward in the list of matches; a negative argument may be used to
              move backward through the list.  This command is intended to be bound to  TAB,
              but is unbound by default.
       menu-complete-backward
              Identical  to  menu-complete,  but moves backward through the list of possible
              completions, as if menu-complete had been given  a  negative  argument.   This
              command is unbound by default.
       delete-char-or-list
              Deletes  the  character under the cursor if not at the beginning or end of the
              line (like delete-char).  If at the end of the line,  behaves  identically  to
              possible-completions.  This command is unbound by default.
       complete-filename (M-/)
              Attempt filename completion on the text before point.
       possible-filename-completions (C-x /)
              List the possible completions of the text before point, treating it as a file-
              name.
       complete-username (M-~)
              Attempt completion on the text before point, treating it as a username.
       possible-username-completions (C-x ~)
              List the possible completions of the text before point, treating it as a user-
              name.
       complete-variable (M-$)
              Attempt completion on the text before point, treating it as a shell variable.
       possible-variable-completions (C-x $)
              List the possible completions of the text before point, treating it as a shell
              variable.
       complete-hostname (M-@)
              Attempt completion on the text before point, treating it as a hostname.
       possible-hostname-completions (C-x @)
              List the possible completions of the text before point, treating it as a host-
              name.
       complete-command (M-!)
          Attempt  completion  on  the text before point, treating it as a command name.
          Command completion attempts to match the text against aliases, reserved words,
          shell functions, shell builtins, and finally executable filenames, in that or-
          der.
       possible-command-completions (C-x !)
          List the possible completions of the text before point, treating it as a  com-
          mand name.
       dynamic-complete-history (M-TAB)
          Attempt  completion on the text before point, comparing the text against lines
          from the history list for possible completion matches.
       dabbrev-expand
          Attempt menu completion on the text before point, comparing the  text  against
          lines from the history list for possible completion matches.
       complete-into-braces (M-{)
          Perform  filename  completion  and insert the list of possible completions en-
          closed within braces so the list is available to the shell (see  Brace  Expan-
          sion above).

search 'Programmable Completion':

Programmable Completion
       When word completion is attempted for an argument to a command for which a completion
       specification  (a  compspec)  has  been defined using the complete builtin (see SHELL
       BUILTIN COMMANDS below), the programmable completion facilities are invoked.

       First, the command name is identified.  If the command word is the empty string (com-
       pletion  attempted  at the beginning of an empty line), any compspec defined with the
       -E option to complete is used.  If a compspec has been defined for that command,  the
       compspec  is  used to generate the list of possible completions for the word.  If the
       command word is a full pathname, a compspec for the full  pathname  is  searched  for
       first.   If  no compspec is found for the full pathname, an attempt is made to find a
       compspec for the portion following the final slash.  If those searches do not  result
       in a compspec, any compspec defined with the -D option to complete is used as the de-
       fault.  If there is no default compspec, bash attempts alias expansion on the command
       word as a final resort, and attempts to find a compspec for the command word from any
       successful expansion.

       Once a compspec has been found, it is used to generate the list  of  matching  words.
       If a compspec is not found, the default bash completion as described above under Com-
       pleting is performed.

       First, the actions specified by the compspec are used.  Only matches which  are  pre-
       fixed by the word being completed are returned.  When the -f or -d option is used for
       filename or directory name completion, the shell variable FIGNORE is used  to  filter
       the matches.

       Any completions specified by a pathname expansion pattern to the -G option are gener-
       ated next.  The words generated by the pattern need not match  the  word  being  com-
       pleted.   The  GLOBIGNORE  shell  variable is not used to filter the matches, but the
       FIGNORE variable is used.

       Next, the string specified as the argument to  the  -W  option  is  considered.   The
       string is first split using the characters in the IFS special variable as delimiters.
       Shell quoting is honored.  Each word is then expanded using  brace  expansion,  tilde
       expansion, parameter and variable expansion, command substitution, and arithmetic ex-
       pansion, as described above under EXPANSION.  The results are split using  the  rules
       described  above  under  Word  Splitting.   The  results of the expansion are prefix-
       matched against the word being completed, and the matching words become the  possible
       completions.

       After these matches have been generated, any shell function or command specified with
       the -F and -C options is invoked.  When the  command  or  function  is  invoked,  the
       COMP_LINE,  COMP_POINT,  COMP_KEY, and COMP_TYPE variables are assigned values as de-
       scribed above under Shell Variables.  If a  shell  function  is  being  invoked,  the
       COMP_WORDS  and  COMP_CWORD  variables are also set.  When the function or command is
       invoked, the first argument ($1) is the name of the command whose arguments are being
       completed,  the second argument ($2) is the word being completed, and the third argu-
       ment ($3) is the word preceding the word being completed on the current command line.
       No  filtering  of  the generated completions against the word being completed is per-
       formed; the function or command has complete freedom in generating the matches.

       Any function specified with -F is invoked first.  The function may  use  any  of  the
       shell  facilities,  including  the  compgen  builtin described below, to generate the
       matches.  It must put the possible completions in the COMPREPLY array  variable,  one
       per array element.

       Next,  any  command specified with the -C option is invoked in an environment equiva-
       lent to command substitution.  It should print a list of completions, one  per  line,
       to the standard output.  Backslash may be used to escape a newline, if necessary.

       After all of the possible completions are generated, any filter specified with the -X
       option is applied to the list.  The filter is a pattern as used for  pathname  expan-
       sion;  a  &  in the pattern is replaced with the text of the word being completed.  A
       literal & may be escaped with a backslash; the backslash is removed before attempting
       a  match.   Any completion that matches the pattern will be removed from the list.  A
       leading ! negates the pattern; in this case any completion not matching  the  pattern
       will  be removed.  If the nocasematch shell option is enabled, the match is performed
       without regard to the case of alphabetic characters.

       Finally, any prefix and suffix specified with the -P and -S options are added to each
       member  of the completion list, and the result is returned to the readline completion
       code as the list of possible completions.

       If the previously-applied actions do not generate any matches, and  the  -o  dirnames
       option was supplied to complete when the compspec was defined, directory name comple-
       tion is attempted.

       If the -o plusdirs option was supplied to complete when the compspec was defined, di-
       rectory  name completion is attempted and any matches are added to the results of the
       other actions.

       By default, if a compspec is found, whatever it generates is returned to the  comple-
       tion  code as the full set of possible completions.  The default bash completions are
       not attempted, and the readline default of filename completion is disabled.   If  the
       -o  bashdefault  option  was  supplied to complete when the compspec was defined, the
       bash default completions are attempted if the compspec generates no matches.  If  the
       -o  default option was supplied to complete when the compspec was defined, readline's
       default completion will be performed if the compspec (and, if attempted, the  default
       bash completions) generate no matches.

       When a compspec indicates that directory name completion is desired, the programmable
       completion functions force readline to append a slash to completed  names  which  are
       symbolic  links to directories, subject to the value of the mark-directories readline
       variable, regardless of the setting of the mark-symlinked-directories readline  vari-
       able.

       There  is  some  support  for dynamically modifying completions.  This is most useful
       when used in combination with a default completion specified with complete -D.   It's
       possible for shell functions executed as completion handlers to indicate that comple-
       tion should be retried by returning an exit status of 124.  If a shell  function  re-
       turns  124,  and changes the compspec associated with the command on which completion
       is being attempted (supplied as the first argument when the  function  is  executed),
       programmable  completion  restarts  from the beginning, with an attempt to find a new
       compspec for that command.  This allows a set of completions to be built  dynamically
       as completion is attempted, rather than being loaded all at once.

       For instance, assuming that there is a library of compspecs, each kept in a file cor-
       responding to the name of the command,  the  following  default  completion  function
       would load completions dynamically:

       _completion_loader()
       {
            . "/etc/bash_completion.d/$1.sh" >/dev/null 2>&1 && return 124
       }
       complete -D -F _completion_loader -o bashdefault -o default
1

So. All answers here are good, but also somewhat incomplete. (pun intended)
I felt the need for a recap, and here it is.

1. Where to find bash documentation

First of all let's target bash documentation. In general.

You can get documentation on bash from:

  • the bash man page,
  • the inline help,
  • the info manual.

The bash man page sucks. It always did. It is on purpose. It's very superficial. By design.

The inline help can be obtained by typing help <command> on the command line. It's good if you don't remember syntaxes. It's very incomplete nonetheless. For comparison, on windows, you can pretty much learn everything about cmd.exe from the inline help. Not so much with bash.

The info manual is where the real dough at. You call it with info bash from the command line. You search it by typing /<query> it has chapters and navigation, but the bash manual is not neatly divided with a chapter for every command as it should be, and you have instead to rely on hitting /<name-of-the-command> again and again until you get to the right point. It is tedious.

Also, you might not have the info reader installed, the info documentation in general, or bash info documentation in particular. Why? Package managers act in mysterious ways and it's not up to us mere users to question their logic (unless we want to end up making another distro in the process).

If you don't have the info documentation installed, a call to info bash will instead show you its less-than-ideal manpage. Sigh. But on debian/ubuntu/kali you should just need to apt install bash-doc to install it, so there's that.

The good news is the bash manual is also always available on the gnu website:
https://www.gnu.org/software/bash/manual/

And there you can browse it.
The relevant documentation about complete, compgen, and compopt is here:
https://www.gnu.org/software/bash/manual/html_node/Programmable-Completion-Builtins.html

2. How to dig into how complete is used on Ubuntu

As you noticed by doing a complete -p ubuntu predefines a lot of completions. This is not typical of every distro. Many don't bother, the rest have a package to install to get that going.

As you probably also noticed most of those completions are -F completions, that is: they defer the handling of the completion to a bash function. How do you get the code for that function? Through another builtin, called declare.

declare    # shows all declare variables, functions, everything.
declare -f # shows all declared functions and their code.
declare -F # shows ONLY declared function NAMES

Where are the completions stored and loaded from? Most of them come from /usr/share/bash-completion/completions and are installed by the bash-completion package.

There is also a /etc/bash_completion file that simply sources the file /usr/share/bash-completion/bash_completion and the directory /etc/bash_completion.d/ where packages can add their own custom completions for their own custom command (e.g. git does that).

Now you should have enough data to go explore completions on your own, without being overwhelmed with frustration.

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .