helpers.c File Reference

Auto-completion helpers. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "lib.h"
#include "editor/lib.h"
#include "index/lib.h"
#include "key/lib.h"
#include "menu/lib.h"
#include "compapi.h"
#include "data.h"

Include dependency graph for helpers.c:

Go to the source code of this file.

Functions
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.
int	mutt_command_complete (struct CompletionData *cd, struct Buffer *buf, int pos, int numtabs, void *cdata)
	Complete a command name.
static int	label_sort (const void *a, const void *b, void *sdata)
	Compare two label strings - Implements sort_t -.
int	mutt_label_complete (struct CompletionData *cd, struct Buffer *buf, int numtabs)
	Complete a label name.
int	mutt_var_value_complete (struct CompletionData *cd, struct Buffer *buf, int pos)
	Complete a variable/value.
enum FunctionRetval	complete_command (struct EnterWindowData *wdata, int op)
	Complete a NeoMutt Command - Implements CompleteOps::complete() -.
enum FunctionRetval	complete_label (struct EnterWindowData *wdata, int op)
	Complete a label - Implements CompleteOps::complete() -.

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

Detailed Description

Auto-completion helpers.

Authors

• Richard Russon
• Anna Figueiredo Gomes
• Dennis Schön

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 helpers.c.

Function Documentation

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:

mutt_command_complete()

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

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'
cdata	Completion private data

Return values

1	Success, a match
0	Error, no match

Definition at line 112 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"))
  {
    enum MenuType mtype = MENU_GENERIC;
    if (cdata)
    {
      struct FileCompletionData *fcd = cdata;
      struct MuttWindow *win = fcd->win;
      if (win && win->wdata)
      {
        struct Menu *menu = win->wdata;
        mtype = menu->type;
      }
    }
    else
    {
      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_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 326 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_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 388 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:

Variable Documentation

CompleteCommandOps

const struct CompleteOps CompleteCommandOps

Initial value:

= {
  .complete = complete_command,
}

Auto-Completion of Commands.

Definition at line 492 of file helpers.c.

                                              {
  .complete = complete_command,
};

CompleteLabelOps

const struct CompleteOps CompleteLabelOps

Initial value:

= {
  .complete = complete_label,
}

Auto-Completion of Labels.

Definition at line 499 of file helpers.c.

                                            {
  .complete = complete_label,
};