commands.h File Reference

Parse key binding commands. More...

#include "core/lib.h"

Include dependency graph for commands.h:

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

Go to the source code of this file.

Functions
enum CommandResult	km_bind (struct MenuDefinition *md, const char *key_str, int op, char *macro, char *desc, struct Buffer *err)
	Set up a key binding.
char *	parse_keymap (const struct Command *cmd, struct MenuDefinitionArray *mda, struct Buffer *line, struct Buffer *err)
	Parse a user-config key binding.
void	parse_menu (struct MenuDefinitionArray *menus, const char *s, struct Buffer *err)
	Parse menu-names into an array.
enum CommandResult	parse_bind (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'bind' command - Implements Command::parse() -.
enum CommandResult	parse_exec (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'exec' command - Implements Command::parse() -.
enum CommandResult	parse_macro (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'macro' command - Implements Command::parse() -.
enum CommandResult	parse_push (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'push' command - Implements Command::parse() -.
enum CommandResult	parse_unbind (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'unbind' and 'unmacro' commands - Implements Command::parse() -.

Detailed Description

Parse key binding commands.

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 commands.h.

Function Documentation

km_bind()

enum CommandResult km_bind	(	struct MenuDefinition *	md,
		const char *	key_str,
		int	op,
		char *	macro,
		char *	desc,
		struct Buffer *	err )

Set up a key binding.

Parameters

md	Menu Definition
key_str	Key string
op	Operation, e.g. OP_DELETE
macro	Macro string
desc	Description of macro (OPTIONAL)
err	Buffer for error message

Return values

CommandResult

Result e.g. MUTT_CMD_SUCCESS

Insert a key sequence into the specified map. The map is sorted by ASCII value (lowest to highest)

Definition at line 52 of file menu.c.

{
  if (!md || ARRAY_EMPTY(&md->submenus))
    return MUTT_CMD_ERROR;
 
  enum CommandResult rc = MUTT_CMD_SUCCESS;
  struct Keymap *last = NULL;
  struct Keymap *np = NULL;
  struct Keymap *compare = NULL;
  keycode_t buf[KEY_SEQ_MAX_LEN] = { 0 };
  size_t pos = 0;
  size_t lastpos = 0;
 
  struct SubMenu *sm = *ARRAY_FIRST(&md->submenus);
  struct KeymapList *kml = &sm->keymaps;
 
  size_t len = parse_keys(key_str, buf, KEY_SEQ_MAX_LEN);
 
  struct Keymap *map = keymap_alloc(len, buf);
  map->op = op;
  map->macro = mutt_str_dup(macro);
  map->desc = mutt_str_dup(desc);
 
  /* find position to place new keymap */
  STAILQ_FOREACH(np, kml, entries)
  {
    compare = keymap_compare(map, np, &pos);
 
    if (compare == map) /* map's keycode is bigger */
    {
      last = np;
      lastpos = pos;
      if (pos > np->eq)
        pos = np->eq;
    }
    else if (compare == np) /* np's keycode is bigger, found insert location */
    {
      map->eq = pos;
      break;
    }
    else /* equal keycodes */
    {
      if (np->len < len)
      {
        // Prefix-compatible binding, continue looking for insertion point.
        last = np;
        lastpos = np->len;
        if (pos > np->eq)
          pos = np->eq;
        continue;
      }
      else if (np->len > len)
      {
        // Prefix-compatible binding, insert before the longer sequence.
        map->eq = len;
        break;
      }
 
      // Exact same key sequence: replace existing mapping.
      map->eq = np->eq;
      STAILQ_REMOVE(kml, np, Keymap, entries);
      keymap_free(&np);
      break;
    }
  }
 
  if (last) /* if queue has at least one entry */
  {
    if (STAILQ_NEXT(last, entries))
      STAILQ_INSERT_AFTER(kml, last, map, entries);
    else /* last entry in the queue */
      STAILQ_INSERT_TAIL(kml, map, entries);
    last->eq = lastpos;
  }
  else /* queue is empty, so insert from head */
  {
    STAILQ_INSERT_HEAD(kml, map, entries);
  }
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_keymap()

char * parse_keymap	(	const struct Command *	cmd,
		struct MenuDefinitionArray *	mda,
		struct Buffer *	line,
		struct Buffer *	err )

Parse a user-config key binding.

Parameters

cmd	Command being processed
mda	Array for results
line	Buffer containing config string
err	Buffer for error messages

Return values

ptr	Key string for the binding

Expects to see: <menu-string>,<menu-string>,... <key-string>

Note

Caller needs to free the returned string

Definition at line 115 of file commands.c.

{
  struct Buffer *token = buf_pool_get();
  char *q = NULL;
  char *result = NULL;
 
  /* menu name */
  parse_extract_token(token, line, TOKEN_NONE);
  char *p = token->data;
  if (MoreArgs(line))
  {
    while (true)
    {
      q = strchr(p, ',');
      if (q)
        *q = '\0';
 
      struct MenuDefinition *md = menu_find_by_name(p);
      if (!md)
      {
        buf_printf(err, _("%s: no such menu"), p);
        goto done;
      }
      ARRAY_ADD(mda, md);
      if (q)
        p = q + 1;
      else
        break;
    }
    /* key sequence */
    parse_extract_token(token, line, TOKEN_NONE);
 
    if (buf_at(token, 0) == '\0')
    {
      buf_printf(err, _("%s: null key sequence"), cmd->name);
    }
    else if (MoreArgs(line))
    {
      result = buf_strdup(token);
      goto done;
    }
  }
  else
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
  }
done:
  buf_pool_release(&token);
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_menu()

void parse_menu	(	struct MenuDefinitionArray *	menus,
		const char *	s,
		struct Buffer *	err )

Parse menu-names into an array.

Parameters

menus	Array for results
s	String containing menu-names
err	Buffer for error messages

Expects to see: <menu-string>[,<menu-string>]

Definition at line 175 of file commands.c.

{
  char *menu_names_dup = mutt_str_dup(s);
  char *marker = menu_names_dup;
  char *menu_name = NULL;
 
  while ((menu_name = mutt_str_sep(&marker, ",")))
  {
    struct MenuDefinition *md = menu_find_by_name(menu_name);
    if (!md)
    {
      buf_printf(err, _("%s: no such menu"), menu_name);
      break;
    }
    else
    {
      ARRAY_ADD(menus, md);
    }
  }
 
  FREE(&menu_names_dup);
}

Here is the call graph for this function:

Here is the caller graph for this function: