lib.h File Reference

Auto-completion. More...

#include <stdbool.h>
#include <stddef.h>
#include "compapi.h"
#include "data.h"

Include dependency graph for lib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	mutt_command_complete (struct CompletionData *cd, struct Buffer *buf, int pos, int numtabs)
	Complete a command name.
int	mutt_complete (struct CompletionData *cd, struct Buffer *buf)
	Attempt to complete a partial pathname.
int	mutt_label_complete (struct CompletionData *cd, struct Buffer *buf, int numtabs)
	Complete a label name.
bool	mutt_nm_query_complete (struct CompletionData *cd, struct Buffer *buf, int numtabs)
	Complete to the nearest notmuch tag.
bool	mutt_nm_tag_complete (struct CompletionData *cd, struct Buffer *buf, int numtabs)
	Complete to the nearest notmuch tag.
int	mutt_var_value_complete (struct CompletionData *cd, struct Buffer *buf, int pos)
	Complete a variable/value.
void	matches_ensure_morespace (struct CompletionData *cd, int new_size)
	Allocate more space for auto-completion.
bool	candidate (struct CompletionData *cd, char *user, const char *src, char *dest, size_t dlen)
	Helper function for completion.

Variables
const struct CompleteOps	CompleteCommandOps
	Auto-Completion of Commands.
const struct CompleteOps	CompleteLabelOps
	Auto-Completion of Labels.

Detailed Description

Auto-completion.

Authors

• Richard Russon
• Anna Figueiredo Gomes

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file lib.h.

Function Documentation

mutt_command_complete()

int mutt_command_complete	(	struct CompletionData *	cd,
		struct Buffer *	buf,
		int	pos,
		int	numtabs )

Complete a command name.

Parameters

cd	Completion Data
buf	Buffer for the result
pos	Cursor position in the buffer
numtabs	Number of times the user has hit 'tab'

Return values

1	Success, a match
0	Error, no match

Definition at line 111 of file helpers.c.

{
  char *pt = buf->data;
  int spaces; /* keep track of the number of leading spaces on the line */
 
  SKIPWS(pt);
  spaces = pt - buf->data;
 
  pt = buf->data + pos - spaces;
  while ((pt > buf->data) && !mutt_isspace(*pt))
    pt--;
 
  if (pt == buf->data) /* complete cmd */
  {
    /* first TAB. Collect all the matches */
    if (numtabs == 1)
    {
      cd->num_matched = 0;
      mutt_str_copy(cd->user_typed, pt, sizeof(cd->user_typed));
      memset(cd->match_list, 0, cd->match_list_len);
      memset(cd->completed, 0, sizeof(cd->completed));
 
      const struct Command **cp = NULL;
      ARRAY_FOREACH(cp, &NeoMutt->commands)
      {
        const struct Command *cmd = *cp;
 
        candidate(cd, cd->user_typed, cmd->name, cd->completed, sizeof(cd->completed));
      }
 
      matches_ensure_morespace(cd, cd->num_matched);
      cd->match_list[cd->num_matched++] = cd->user_typed;
 
      /* All matches are stored. Longest non-ambiguous string is ""
       * i.e. don't change 'buf'. Fake successful return this time */
      if (cd->user_typed[0] == '\0')
        return 1;
    }
 
    if ((cd->completed[0] == '\0') && (cd->user_typed[0] != '\0'))
      return 0;
 
    /* cd->num_matched will _always_ be at least 1 since the initial
     * user-typed string is always stored */
    if ((numtabs == 1) && (cd->num_matched == 2))
    {
      snprintf(cd->completed, sizeof(cd->completed), "%s", cd->match_list[0]);
    }
    else if ((numtabs > 1) && (cd->num_matched > 2))
    {
      /* cycle through all the matches */
      snprintf(cd->completed, sizeof(cd->completed), "%s",
               cd->match_list[(numtabs - 2) % cd->num_matched]);
    }
 
    /* return the completed command */
    buf_strcpy(buf, cd->completed);
  }
  else if (buf_startswith(buf, "set") || buf_startswith(buf, "unset") ||
           buf_startswith(buf, "reset") || buf_startswith(buf, "toggle"))
  { /* complete variables */
    static const char *const prefixes[] = { "no", "inv", "?", "&", 0 };
 
    pt++;
    /* loop through all the possible prefixes (no, inv, ...) */
    if (buf_startswith(buf, "set"))
    {
      for (int num = 0; prefixes[num]; num++)
      {
        if (mutt_str_startswith(pt, prefixes[num]))
        {
          pt += mutt_str_len(prefixes[num]);
          break;
        }
      }
    }
 
    /* first TAB. Collect all the matches */
    if (numtabs == 1)
    {
      cd->num_matched = 0;
      mutt_str_copy(cd->user_typed, pt, sizeof(cd->user_typed));
      memset(cd->match_list, 0, cd->match_list_len);
      memset(cd->completed, 0, sizeof(cd->completed));
 
      struct HashElemArray hea = get_elem_list(NeoMutt->sub->cs, GEL_ALL_CONFIG);
      struct HashElem **hep = NULL;
      ARRAY_FOREACH(hep, &hea)
      {
        candidate(cd, cd->user_typed, (*hep)->key.strkey, cd->completed,
                  sizeof(cd->completed));
      }
      ARRAY_FREE(&hea);
 
      matches_ensure_morespace(cd, cd->num_matched);
      cd->match_list[cd->num_matched++] = cd->user_typed;
 
      /* All matches are stored. Longest non-ambiguous string is ""
       * i.e. don't change 'buf'. Fake successful return this time */
      if (cd->user_typed[0] == '\0')
        return 1;
    }
 
    if ((cd->completed[0] == 0) && cd->user_typed[0])
      return 0;
 
    /* cd->num_matched will _always_ be at least 1 since the initial
     * user-typed string is always stored */
    if ((numtabs == 1) && (cd->num_matched == 2))
    {
      snprintf(cd->completed, sizeof(cd->completed), "%s", cd->match_list[0]);
    }
    else if ((numtabs > 1) && (cd->num_matched > 2))
    {
      /* cycle through all the matches */
      snprintf(cd->completed, sizeof(cd->completed), "%s",
               cd->match_list[(numtabs - 2) % cd->num_matched]);
    }
 
    strncpy(pt, cd->completed, buf->data + buf->dsize - pt - spaces);
    buf_fix_dptr(buf);
  }
  else if (buf_startswith(buf, "exec"))
  {
    const enum MenuType mtype = menu_get_current_type();
    const struct MenuFuncOp *funcs = km_get_table(mtype);
    if (!funcs && (mtype != MENU_PAGER))
      funcs = OpGeneric;
 
    pt++;
    /* first TAB. Collect all the matches */
    if (numtabs == 1)
    {
      cd->num_matched = 0;
      mutt_str_copy(cd->user_typed, pt, sizeof(cd->user_typed));
      memset(cd->match_list, 0, cd->match_list_len);
      memset(cd->completed, 0, sizeof(cd->completed));
      for (int num = 0; funcs[num].name; num++)
        candidate(cd, cd->user_typed, funcs[num].name, cd->completed, sizeof(cd->completed));
      /* try the generic menu */
      if ((mtype != MENU_PAGER) && (mtype != MENU_GENERIC))
      {
        funcs = OpGeneric;
        for (int num = 0; funcs[num].name; num++)
          candidate(cd, cd->user_typed, funcs[num].name, cd->completed,
                    sizeof(cd->completed));
      }
      matches_ensure_morespace(cd, cd->num_matched);
      cd->match_list[cd->num_matched++] = cd->user_typed;
 
      /* All matches are stored. Longest non-ambiguous string is ""
       * i.e. don't change 'buf'. Fake successful return this time */
      if (cd->user_typed[0] == '\0')
        return 1;
    }
 
    if ((cd->completed[0] == '\0') && (cd->user_typed[0] != '\0'))
      return 0;
 
    /* cd->num_matched will _always_ be at least 1 since the initial
     * user-typed string is always stored */
    if ((numtabs == 1) && (cd->num_matched == 2))
    {
      snprintf(cd->completed, sizeof(cd->completed), "%s", cd->match_list[0]);
    }
    else if ((numtabs > 1) && (cd->num_matched > 2))
    {
      /* cycle through all the matches */
      snprintf(cd->completed, sizeof(cd->completed), "%s",
               cd->match_list[(numtabs - 2) % cd->num_matched]);
    }
 
    strncpy(pt, cd->completed, buf->data + buf->dsize - pt - spaces);
    buf_fix_dptr(buf);
  }
  else
  {
    return 0;
  }
 
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_complete()

int mutt_complete	(	struct CompletionData *	cd,
		struct Buffer *	buf )

Attempt to complete a partial pathname.

Parameters

cd	Completion Data
buf	Buffer containing pathname

Return values

0	Ok
-1	No matches

Given a partial pathname, fill in as much of the rest of the path as is unique.

Definition at line 57 of file complete.c.

{
  const char *p = NULL;
  DIR *dir = NULL;
  struct dirent *de = NULL;
  int init = 0;
  size_t len;
  struct Buffer *dirpart = NULL;
  struct Buffer *exp_dirpart = NULL;
  struct Buffer *filepart = NULL;
  struct Buffer *tmp = NULL;
  struct Buffer *imap_path = NULL;
  int rc;
 
  mutt_debug(LL_DEBUG2, "completing %s\n", buf_string(buf));
 
  if (OptNews)
    return nntp_complete(buf);
 
  const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
  const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
 
  imap_path = buf_pool_get();
  /* we can use '/' as a delimiter, imap_complete rewrites it */
  char ch = buf_at(buf, 0);
  if ((ch == '=') || (ch == '+') || (ch == '!'))
  {
    if (ch == '!')
      p = NONULL(c_spool_file);
    else
      p = NONULL(c_folder);
 
    buf_concat_path(imap_path, p, buf_string(buf) + 1);
  }
  else
  {
    buf_copy(imap_path, buf);
  }
 
  if (imap_path_probe(buf_string(imap_path), NULL) == MUTT_IMAP)
  {
    rc = imap_complete(buf, buf_string(imap_path));
    buf_pool_release(&imap_path);
    return rc;
  }
 
  buf_pool_release(&imap_path);
 
  dirpart = buf_pool_get();
  exp_dirpart = buf_pool_get();
  filepart = buf_pool_get();
  tmp = buf_pool_get();
 
  ch = buf_at(buf, 0);
  if ((ch == '=') || (ch == '+') || (ch == '!'))
  {
    buf_addch(dirpart, ch);
    if (ch == '!')
      buf_strcpy(exp_dirpart, c_spool_file);
    else
      buf_strcpy(exp_dirpart, c_folder);
    p = strrchr(buf_string(buf), '/');
    if (p)
    {
      buf_concatn_path(tmp, buf_string(exp_dirpart), buf_len(exp_dirpart),
                       buf_string(buf) + 1, (size_t) (p - buf_string(buf) - 1));
      buf_copy(exp_dirpart, tmp);
      buf_substrcpy(dirpart, buf_string(buf), p + 1);
      buf_strcpy(filepart, p + 1);
    }
    else
    {
      buf_strcpy(filepart, buf_string(buf) + 1);
    }
    dir = mutt_file_opendir(buf_string(exp_dirpart), MUTT_OPENDIR_NONE);
  }
  else
  {
    p = strrchr(buf_string(buf), '/');
    if (p)
    {
      if (p == buf_string(buf)) /* absolute path */
      {
        p = buf_string(buf) + 1;
        buf_strcpy(dirpart, "/");
        buf_strcpy(filepart, p);
        dir = mutt_file_opendir(buf_string(dirpart), MUTT_OPENDIR_NONE);
      }
      else
      {
        buf_substrcpy(dirpart, buf_string(buf), p);
        buf_strcpy(filepart, p + 1);
        buf_copy(exp_dirpart, dirpart);
        buf_expand_path(exp_dirpart);
        dir = mutt_file_opendir(buf_string(exp_dirpart), MUTT_OPENDIR_NONE);
      }
    }
    else
    {
      /* no directory name, so assume current directory. */
      buf_strcpy(filepart, buf_string(buf));
      dir = mutt_file_opendir(".", MUTT_OPENDIR_NONE);
    }
  }
 
  if (!dir)
  {
    mutt_debug(LL_DEBUG1, "%s: %s (errno %d)\n", buf_string(exp_dirpart),
               strerror(errno), errno);
    goto cleanup;
  }
 
  /* special case to handle when there is no filepart yet.  find the first
   * file/directory which is not "." or ".." */
  len = buf_len(filepart);
  if (len == 0)
  {
    while ((de = readdir(dir)))
    {
      if (!mutt_str_equal(".", de->d_name) && !mutt_str_equal("..", de->d_name))
      {
        buf_strcpy(filepart, de->d_name);
        init++;
        break;
      }
    }
  }
 
  while ((de = readdir(dir)))
  {
    if (mutt_strn_equal(de->d_name, buf_string(filepart), len))
    {
      if (init)
      {
        char *cp = filepart->data;
 
        for (int i = 0; (*cp != '\0') && (de->d_name[i] != '\0'); i++, cp++)
        {
          if (*cp != de->d_name[i])
            break;
        }
        *cp = '\0';
        buf_fix_dptr(filepart);
      }
      else
      {
        struct stat st = { 0 };
 
        buf_strcpy(filepart, de->d_name);
 
        /* check to see if it is a directory */
        if (buf_is_empty(dirpart))
        {
          buf_reset(tmp);
        }
        else
        {
          buf_copy(tmp, exp_dirpart);
          buf_addch(tmp, '/');
        }
        buf_addstr(tmp, buf_string(filepart));
        if ((stat(buf_string(tmp), &st) != -1) && (st.st_mode & S_IFDIR))
          buf_addch(filepart, '/');
        init = 1;
      }
    }
  }
  closedir(dir);
 
  if (buf_is_empty(dirpart))
  {
    buf_copy(buf, filepart);
  }
  else
  {
    buf_copy(buf, dirpart);
    if (!mutt_str_equal("/", buf_string(dirpart)) &&
        (buf_string(dirpart)[0] != '=') && (buf_string(dirpart)[0] != '+'))
    {
      buf_addstr(buf, "/");
    }
    buf_addstr(buf, buf_string(filepart));
  }
 
cleanup:
  buf_pool_release(&dirpart);
  buf_pool_release(&exp_dirpart);
  buf_pool_release(&filepart);
  buf_pool_release(&tmp);
 
  return init ? 0 : -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_label_complete()

int mutt_label_complete	(	struct CompletionData *	cd,
		struct Buffer *	buf,
		int	numtabs )

Complete a label name.

Parameters

cd	Completion Data
buf	Buffer for the result
numtabs	Number of times the user has hit 'tab'

Return values

1	Success, a match
0	Error, no match

Definition at line 310 of file helpers.c.

{
  char *pt = buf->data;
 
  struct Mailbox *m_cur = get_current_mailbox();
  if (!m_cur || !m_cur->label_hash)
    return 0;
 
  SKIPWS(pt);
 
  /* first TAB. Collect all the matches */
  if (numtabs == 1)
  {
    struct HashElem *he = NULL;
    struct HashWalkState hws = { 0 };
 
    cd->num_matched = 0;
    mutt_str_copy(cd->user_typed, buf_string(buf), sizeof(cd->user_typed));
    memset(cd->match_list, 0, cd->match_list_len);
    memset(cd->completed, 0, sizeof(cd->completed));
    while ((he = mutt_hash_walk(m_cur->label_hash, &hws)))
      candidate(cd, cd->user_typed, he->key.strkey, cd->completed, sizeof(cd->completed));
    matches_ensure_morespace(cd, cd->num_matched);
    mutt_qsort_r(cd->match_list, cd->num_matched, sizeof(char *), label_sort, NULL);
    cd->match_list[cd->num_matched++] = cd->user_typed;
 
    /* All matches are stored. Longest non-ambiguous string is ""
     * i.e. don't change 'buf'. Fake successful return this time */
    if (cd->user_typed[0] == '\0')
      return 1;
  }
 
  if ((cd->completed[0] == '\0') && (cd->user_typed[0] != '\0'))
    return 0;
 
  /* cd->num_matched will _always_ be at least 1 since the initial
   * user-typed string is always stored */
  if ((numtabs == 1) && (cd->num_matched == 2))
  {
    snprintf(cd->completed, sizeof(cd->completed), "%s", cd->match_list[0]);
  }
  else if ((numtabs > 1) && (cd->num_matched > 2))
  {
    /* cycle through all the matches */
    snprintf(cd->completed, sizeof(cd->completed), "%s",
             cd->match_list[(numtabs - 2) % cd->num_matched]);
  }
 
  /* return the completed label */
  buf_strcpy(buf, cd->completed);
 
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_nm_query_complete()

bool mutt_nm_query_complete	(	struct CompletionData *	cd,
		struct Buffer *	buf,
		int	numtabs )

Complete to the nearest notmuch tag.

Parameters

cd	Completion Data
buf	Buffer for the result
numtabs	Number of times the user has hit 'tab'

Return values

true	Success, a match
false	Error, no match

Complete the last "tag:"-prefixed string.

Definition at line 101 of file complete.c.

{
  char *pt = buf->data;
  int spaces;
 
  SKIPWS(pt);
  spaces = pt - buf->data;
 
  pt = (char *) buf_rfind(buf, "tag:");
  if (pt)
  {
    pt += 4;
    if (numtabs == 1)
    {
      /* First TAB. Collect all the matches */
      complete_all_nm_tags(cd, pt);
 
      /* All matches are stored. Longest non-ambiguous string is ""
       * i.e. don't change 'buf'. Fake successful return this time.  */
      if (cd->user_typed[0] == '\0')
        return true;
    }
 
    if ((cd->completed[0] == '\0') && (cd->user_typed[0] != '\0'))
      return false;
 
    /* cd->num_matched will _always_ be at least 1 since the initial
     * user-typed string is always stored */
    if ((numtabs == 1) && (cd->num_matched == 2))
    {
      snprintf(cd->completed, sizeof(cd->completed), "%s", cd->match_list[0]);
    }
    else if ((numtabs > 1) && (cd->num_matched > 2))
    {
      /* cycle through all the matches */
      snprintf(cd->completed, sizeof(cd->completed), "%s",
               cd->match_list[(numtabs - 2) % cd->num_matched]);
    }
 
    /* return the completed query */
    strncpy(pt, cd->completed, buf->data + buf->dsize - pt - spaces);
  }
  else
  {
    return false;
  }
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_nm_tag_complete()

bool mutt_nm_tag_complete	(	struct CompletionData *	cd,
		struct Buffer *	buf,
		int	numtabs )

Complete to the nearest notmuch tag.

Parameters

cd	Completion Data
buf	Buffer for the result
numtabs	Number of times the user has hit 'tab'

Return values

true	Success, a match
false	Error, no match

Complete the nearest "+" or "-" -prefixed string previous to pos.

Definition at line 161 of file complete.c.

{
  if (!buf)
    return false;
 
  char *pt = buf->data;
 
  /* Only examine the last token */
  char *last_space = strrchr(buf->data, ' ');
  if (last_space)
    pt = (last_space + 1);
 
  /* Skip the +/- */
  if ((pt[0] == '+') || (pt[0] == '-'))
    pt++;
 
  if (numtabs == 1)
  {
    /* First TAB. Collect all the matches */
    complete_all_nm_tags(cd, pt);
 
    /* All matches are stored. Longest non-ambiguous string is ""
     * i.e. don't change 'buf'. Fake successful return this time.  */
    if (cd->user_typed[0] == '\0')
      return true;
  }
 
  if ((cd->completed[0] == '\0') && (cd->user_typed[0] != '\0'))
    return false;
 
  /* cd->num_matched will _always_ be at least 1 since the initial
   * user-typed string is always stored */
  if ((numtabs == 1) && (cd->num_matched == 2))
  {
    snprintf(cd->completed, sizeof(cd->completed), "%s", cd->match_list[0]);
  }
  else if ((numtabs > 1) && (cd->num_matched > 2))
  {
    /* cycle through all the matches */
    snprintf(cd->completed, sizeof(cd->completed), "%s",
             cd->match_list[(numtabs - 2) % cd->num_matched]);
  }
 
  /* return the completed query */
  strncpy(pt, cd->completed, buf->data + buf->dsize - pt);
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_var_value_complete()

int mutt_var_value_complete	(	struct CompletionData *	cd,
		struct Buffer *	buf,
		int	pos )

Complete a variable/value.

Parameters

cd	Completion Data
buf	Buffer for the result
pos	Cursor position in the buffer

Return values

1	Success
0	Failure

Definition at line 372 of file helpers.c.

{
  char *pt = buf->data;
 
  if (pt[0] == '\0')
    return 0;
 
  SKIPWS(pt);
  const int spaces = pt - buf->data;
 
  pt = buf->data + pos - spaces;
  while ((pt > buf->data) && !mutt_isspace(*pt))
    pt--;
  pt++;           /* move past the space */
  if (*pt == '=') /* abort if no var before the '=' */
    return 0;
 
  if (buf_startswith(buf, "set"))
  {
    char var[256] = { 0 };
    mutt_str_copy(var, pt, sizeof(var));
    /* ignore the trailing '=' when comparing */
    int vlen = mutt_str_len(var);
    if (vlen == 0)
      return 0;
 
    var[vlen - 1] = '\0';
 
    struct HashElem *he = cs_subset_lookup(NeoMutt->sub, var);
    if (!he)
      return 0; /* no such variable. */
 
    struct Buffer *value = buf_pool_get();
    struct Buffer *pretty = buf_pool_get();
    int rc = cs_subset_he_string_get(NeoMutt->sub, he, value);
    if (CSR_RESULT(rc) == CSR_SUCCESS)
    {
      pretty_var(value->data, pretty);
      snprintf(pt, buf->dsize - (pt - buf->data), "%s=%s", var, pretty->data);
      buf_pool_release(&value);
      buf_pool_release(&pretty);
      return 0;
    }
    buf_pool_release(&value);
    buf_pool_release(&pretty);
    return 1;
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

matches_ensure_morespace()

void matches_ensure_morespace	(	struct CompletionData *	cd,
		int	new_size )

Allocate more space for auto-completion.

Parameters

cd	Completion Data
new_size	Space required

Definition at line 53 of file helpers.c.

{
  if (new_size <= (cd->match_list_len - 2))
    return;
 
  new_size = ROUND_UP(new_size + 2, 512);
 
  MUTT_MEM_REALLOC(&cd->match_list, new_size, const char *);
  memset(&cd->match_list[cd->match_list_len], 0, new_size - cd->match_list_len);
 
  cd->match_list_len = new_size;
}

Here is the caller graph for this function:

candidate()

bool candidate	(	struct CompletionData *	cd,
		char *	user,
		const char *	src,
		char *	dest,
		size_t	dlen )

Helper function for completion.

Parameters

cd	Completion Data
user	User entered data for completion
src	Candidate for completion
dest	Completion result gets here
dlen	Length of dest buffer

Return values

true	If candidate string matches

Changes the dest buffer if necessary/possible to aid completion.

Definition at line 77 of file helpers.c.

{
  if (!dest || !user || !src)
    return false;
 
  if (strstr(src, user) != src)
    return false;
 
  matches_ensure_morespace(cd, cd->num_matched);
  cd->match_list[cd->num_matched++] = src;
  if (dest[0] == '\0')
  {
    mutt_str_copy(dest, src, dlen);
  }
  else
  {
    int l;
    for (l = 0; (src[l] != '\0') && (src[l] == dest[l]); l++)
      ; // do nothing
 
    dest[l] = '\0';
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

CompleteCommandOps

const struct CompleteOps CompleteCommandOps

extern

Auto-Completion of Commands.

Definition at line 476 of file helpers.c.

                                              {
  .complete = complete_command,
};

CompleteLabelOps

const struct CompleteOps CompleteLabelOps

extern

Auto-Completion of Labels.

Definition at line 483 of file helpers.c.

                                            {
  .complete = complete_label,
};