lib.h File Reference

Auto-completion. More...

#include <stdbool.h>
#include <stdio.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, char *buf, size_t buflen, int pos, int numtabs)
	Complete a command name. More...
int	mutt_complete (struct CompletionData *cd, char *buf, size_t buflen)
	Attempt to complete a partial pathname. More...
int	mutt_label_complete (struct CompletionData *cd, char *buf, size_t buflen, int numtabs)
	Complete a label name. More...
bool	mutt_nm_query_complete (struct CompletionData *cd, char *buf, size_t buflen, int pos, int numtabs)
	Complete to the nearest notmuch tag. More...
bool	mutt_nm_tag_complete (struct CompletionData *cd, char *buf, size_t buflen, int numtabs)
	Complete to the nearest notmuch tag. More...
int	mutt_var_value_complete (struct CompletionData *cd, char *buf, size_t buflen, int pos)
	Complete a variable/value. More...

Detailed Description

Auto-completion.

Authors

• Richard Russon

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,
		char *	buf,
		size_t	buflen,
		int	pos,
		int	numtabs
	)

Complete a command name.

Parameters

cd	Completion Data
buf	Buffer for the result
buflen	Length of the buffer
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 164 of file helpers.c.

{
  char *pt = buf;
  int spaces; /* keep track of the number of leading spaces on the line */
 
  SKIPWS(buf);
  spaces = buf - pt;
 
  pt = buf + pos - spaces;
  while ((pt > buf) && !isspace((unsigned char) *pt))
    pt--;
 
  if (pt == buf) /* 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));
 
      struct Command *c = NULL;
      for (size_t num = 0, size = commands_array(&c); num < size; num++)
        candidate(cd, cd->user_typed, c[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]);
    }
 
    /* return the completed command */
    strncpy(buf, cd->completed, buflen - spaces);
  }
  else if (mutt_str_startswith(buf, "set") || mutt_str_startswith(buf, "unset") ||
           mutt_str_startswith(buf, "reset") || mutt_str_startswith(buf, "toggle"))
  { /* complete variables */
    static const char *const prefixes[] = { "no", "inv", "?", "&", 0 };
 
    pt++;
    /* loop through all the possible prefixes (no, inv, ...) */
    if (mutt_str_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 HashElem *he = NULL;
      struct HashElem **he_list = get_elem_list(NeoMutt->sub->cs);
      for (size_t i = 0; he_list[i]; i++)
      {
        he = he_list[i];
        const int type = DTYPE(he->type);
 
        if ((type == DT_SYNONYM) || (type & DT_DEPRECATED))
          continue;
 
        candidate(cd, cd->user_typed, he->key.strkey, cd->completed, sizeof(cd->completed));
      }
      FREE(&he_list);
 
      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 + buflen - pt - spaces);
  }
  else if (mutt_str_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 + buflen - pt - spaces);
  }
  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,
		char *	buf,
		size_t	buflen
	)

Attempt to complete a partial pathname.

Parameters

cd	Completion Data
buf	Buffer containing pathname
buflen	Length of buffer

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 58 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;
#ifdef USE_IMAP
  struct Buffer *imap_path = NULL;
  int rc;
#endif
 
  mutt_debug(LL_DEBUG2, "completing %s\n", buf);
 
#ifdef USE_NNTP
  if (OptNews)
    return nntp_complete(buf, buflen);
#endif
 
  const char *const c_spool_file = cs_subset_string(NeoMutt->sub, "spool_file");
  const char *const c_folder = cs_subset_string(NeoMutt->sub, "folder");
#ifdef USE_IMAP
  imap_path = buf_pool_get();
  /* we can use '/' as a delimiter, imap_complete rewrites it */
  if ((*buf == '=') || (*buf == '+') || (*buf == '!'))
  {
    if (*buf == '!')
      p = NONULL(c_spool_file);
    else
      p = NONULL(c_folder);
 
    buf_concat_path(imap_path, p, buf + 1);
  }
  else
  {
    buf_strcpy(imap_path, buf);
  }
 
  if (imap_path_probe(buf_string(imap_path), NULL) == MUTT_IMAP)
  {
    rc = imap_complete(buf, buflen, buf_string(imap_path));
    buf_pool_release(&imap_path);
    return rc;
  }
 
  buf_pool_release(&imap_path);
#endif
 
  dirpart = buf_pool_get();
  exp_dirpart = buf_pool_get();
  filepart = buf_pool_get();
  tmp = buf_pool_get();
 
  if ((*buf == '=') || (*buf == '+') || (*buf == '!'))
  {
    buf_addch(dirpart, *buf);
    if (*buf == '!')
      buf_strcpy(exp_dirpart, NONULL(c_spool_file));
    else
      buf_strcpy(exp_dirpart, NONULL(c_folder));
    p = strrchr(buf, '/');
    if (p)
    {
      buf_concatn_path(tmp, buf_string(exp_dirpart), buf_len(exp_dirpart),
                       buf + 1, (size_t) (p - buf - 1));
      buf_copy(exp_dirpart, tmp);
      buf_substrcpy(dirpart, buf, p + 1);
      buf_strcpy(filepart, p + 1);
    }
    else
    {
      buf_strcpy(filepart, buf + 1);
    }
    dir = mutt_file_opendir(buf_string(exp_dirpart), MUTT_OPENDIR_NONE);
  }
  else
  {
    p = strrchr(buf, '/');
    if (p)
    {
      if (p == buf) /* absolute path */
      {
        p = buf + 1;
        buf_strcpy(dirpart, "/");
        buf_strcpy(filepart, p);
        dir = mutt_file_opendir(buf_string(dirpart), MUTT_OPENDIR_NONE);
      }
      else
      {
        buf_substrcpy(dirpart, 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);
      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))
  {
    mutt_str_copy(buf, buf_string(filepart), buflen);
  }
  else
  {
    mutt_str_copy(buf, buf_string(dirpart), buflen);
    if (!mutt_str_equal("/", buf_string(dirpart)) &&
        (buf_string(dirpart)[0] != '=') && (buf_string(dirpart)[0] != '+'))
    {
      mutt_str_copy(buf + strlen(buf), "/", buflen - strlen(buf));
    }
    mutt_str_copy(buf + strlen(buf), buf_string(filepart), buflen - strlen(buf));
  }
 
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,
		char *	buf,
		size_t	buflen,
		int	numtabs
	)

Complete a label name.

Parameters

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

Return values

1	Success, a match
0	Error, no match

Definition at line 368 of file helpers.c.

{
  char *pt = buf;
  int spaces; /* keep track of the number of leading spaces on the line */
 
  struct Mailbox *m_cur = get_current_mailbox();
  if (!m_cur || !m_cur->label_hash)
    return 0;
 
  SKIPWS(buf);
  spaces = buf - 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, 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);
    qsort(cd->match_list, cd->num_matched, sizeof(char *), label_sort);
    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 */
  strncpy(buf, cd->completed, buflen - spaces);
 
  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,
		char *	buf,
		size_t	buflen,
		int	pos,
		int	numtabs
	)

Complete to the nearest notmuch tag.

Parameters

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

Return values

true	Success, a match
false	Error, no match

Complete the nearest "tag:"-prefixed string previous to pos.

Definition at line 437 of file helpers.c.

{
  char *pt = buf;
  int spaces;
 
  SKIPWS(buf);
  spaces = buf - pt;
 
  pt = (char *) mutt_strn_rfind((char *) buf, pos, "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 + buflen - 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,
		char *	buf,
		size_t	buflen,
		int	numtabs
	)

Complete to the nearest notmuch tag.

Parameters

cd	Completion Data
buf	Buffer for the result
buflen	Length of the buffer
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 501 of file helpers.c.

{
  if (!buf)
    return false;
 
  char *pt = buf;
 
  /* Only examine the last token */
  char *last_space = strrchr(buf, ' ');
  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 + buflen - 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,
		char *	buf,
		size_t	buflen,
		int	pos
	)

Complete a variable/value.

Parameters

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

Return values

1	Success
0	Failure

Definition at line 560 of file helpers.c.

{
  char *pt = buf;
 
  if (buf[0] == '\0')
    return 0;
 
  SKIPWS(buf);
  const int spaces = buf - pt;
 
  pt = buf + pos - spaces;
  while ((pt > buf) && !isspace((unsigned char) *pt))
    pt--;
  pt++;           /* move past the space */
  if (*pt == '=') /* abort if no var before the '=' */
    return 0;
 
  if (mutt_str_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_make(256);
    struct Buffer pretty = buf_make(256);
    int rc = cs_subset_he_string_get(NeoMutt->sub, he, &value);
    if (CSR_RESULT(rc) == CSR_SUCCESS)
    {
      pretty_var(value.data, &pretty);
      snprintf(pt, buflen - (pt - buf), "%s=%s", var, pretty.data);
      buf_dealloc(&value);
      buf_dealloc(&pretty);
      return 0;
    }
    buf_dealloc(&value);
    buf_dealloc(&pretty);
    return 1;
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: