commands.c File Reference

Parse key binding commands. More...

#include "config.h"
#include <stdbool.h>
#include <string.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "commands.h"
#include "editor/lib.h"
#include "index/lib.h"
#include "menu/lib.h"
#include "pager/lib.h"
#include "parse/lib.h"
#include "dump.h"
#include "get.h"
#include "keymap.h"
#include "menu.h"
#include "module_data.h"
#include "notify.h"

Include dependency graph for commands.c:

Go to the source code of this file.

Data Structures
struct	ParseUnbind
	Parsed 'unbind' or 'unmacro' command. More...

Functions
enum CommandResult	parse_dump (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse 'bind' and 'macro' commands - Implements Command::parse() -.
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_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_bind (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'bind' command - Implements Command::parse() -.
void	set_default_bindings (const struct MenuDefinition *md)
	Set some safe default keybindings.
const char *	notify_binding_name (enum NotifyBinding ev)
	Get the name for a NotifyBinding.
bool	parse_unbind_args (const struct Command *cmd, struct Buffer *line, struct Buffer *err, struct ParseUnbind *args)
	Parse the 'unbind' and 'unmacro' commands.
bool	parse_unbind_exec (const struct Command *cmd, struct ParseUnbind *args, struct Buffer *err)
	Execute the 'unbind' or 'unmacro' command.
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() -.
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_exec (const struct Command *cmd, struct Buffer *line, const struct ParseContext *pc, struct ParseError *pe)
	Parse the 'exec' command - 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.c.

Function Documentation

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 116 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 176 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:

set_default_bindings()

void set_default_bindings

(

const struct MenuDefinition *

md

)

Set some safe default keybindings.

Parameters

md	Menu Definition to update

Definition at line 361 of file commands.c.

{
  bool success = false;
 
  const struct MenuDefinition *md_generic = generic_get_menu_definition();
  if (!md || (md == md_generic))
  {
    km_bind(md_generic, "<enter>", OP_GENERIC_SELECT_ENTRY, NULL, NULL, NULL);
    km_bind(md_generic, "<return>", OP_GENERIC_SELECT_ENTRY, NULL, NULL, NULL);
    km_bind(md_generic, ":", OP_ENTER_COMMAND, NULL, NULL, NULL);
    km_bind(md_generic, "?", OP_HELP, NULL, NULL, NULL);
    km_bind(md_generic, "q", OP_EXIT, NULL, NULL, NULL);
    success = true;
  }
 
  const struct MenuDefinition *md_index = index_get_menu_definition();
  if (!md || (md == md_index))
  {
    km_bind(md_index, "<enter>", OP_DISPLAY_MESSAGE, NULL, NULL, NULL);
    km_bind(md_index, "<return>", OP_DISPLAY_MESSAGE, NULL, NULL, NULL);
    km_bind(md_index, "q", OP_EXIT, NULL, NULL, NULL);
    success = true;
  }
 
  const struct MenuDefinition *md_editor = editor_get_menu_definition();
  if (!md || (md == md_editor))
  {
    km_bind(md_editor, "<backspace>", OP_EDITOR_BACKSPACE, NULL, NULL, NULL);
    km_bind(md_editor, "\177", OP_EDITOR_BACKSPACE, NULL, NULL, NULL);
    success = true;
  }
 
  const struct MenuDefinition *md_pager = pager_get_menu_definition();
  if (!md || (md == md_pager))
  {
    km_bind(md_pager, ":", OP_ENTER_COMMAND, NULL, NULL, NULL);
    km_bind(md_pager, "?", OP_HELP, NULL, NULL, NULL);
    km_bind(md_pager, "q", OP_EXIT, NULL, NULL, NULL);
    success = true;
  }
 
  if (success)
  {
    mutt_debug(LL_NOTIFY, "NT_BINDING_ADD set defaults\n");
    struct EventBinding ev_b = { md, NULL, OP_NULL };
    notify_send(NeoMutt->notify, NT_BINDING, NT_BINDING_ADD, &ev_b);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

notify_binding_name()

const char * notify_binding_name

(

enum NotifyBinding

ev

)

Get the name for a NotifyBinding.

Parameters

ev	Event type

Return values

str	Name of the NotifyBinding

Definition at line 415 of file commands.c.

{
  switch (ev)
  {
    case NT_BINDING_ADD:
      return "NT_BINDING_ADD";
    case NT_BINDING_DELETE:
      return "NT_BINDING_DELETE";
    case NT_MACRO_ADD:
      return "NT_MACRO_ADD";
    case NT_MACRO_DELETE:
      return "NT_MACRO_DELETE";
    default:
      return "UNKNOWN";
  }
}

Here is the caller graph for this function:

parse_unbind_args()

bool parse_unbind_args	(	const struct Command *	cmd,
		struct Buffer *	line,
		struct Buffer *	err,
		struct ParseUnbind *	args )

Parse the 'unbind' and 'unmacro' commands.

Parameters

[in]	cmd	Command being parsed
[in]	line	Text to parse
[out]	err	Buffer for error messages
[out]	args	Parsed args

Return values

true

Success

Command unbinds:

• all bindings in all menu-names
  • unbind *
• all bindings in one/many menu-names
  • unbind index *
  • unbind index
  • unbind index,pager *
  • unbind index,pager
• one binding in one/many/all menu-names
  • unbind index j
  • unbind index,pager j
  • unbind * j

The same applies to unmacro.

Definition at line 455 of file commands.c.

{
  if (!cmd || !line || !err || !args)
    return false;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return false;
  }
 
  struct Buffer *token = buf_pool_get();
  bool rc = false;
 
  parse_extract_token(token, line, TOKEN_NONE);
  if (mutt_str_equal(buf_string(token), "*"))
  {
    args->all_menus = true;
 
    if (MoreArgs(line))
    {
      // `unbind * key`
      // `unmacro * key`
      parse_extract_token(token, line, TOKEN_NONE);
      if (mutt_str_equal(buf_string(token), "*"))
        args->all_keys = true;
      else
        args->key = buf_strdup(token);
    }
    else
    {
      // `unbind *`
      // `unmacro *`
      args->all_keys = true;
      args->restore_defaults = (cmd->id == CMD_UNBIND);
    }
  }
  else
  {
    if (mutt_str_equal(buf_string(token), "*"))
    {
      args->all_menus = true;
    }
    else
    {
      parse_menu(&args->mda, buf_string(token), err);
      if (!buf_is_empty(err))
        goto done;
    }
 
    if (MoreArgs(line))
    {
      parse_extract_token(token, line, TOKEN_NONE);
      if (mutt_str_equal(buf_string(token), "*"))
      {
        // `unbind  menu *`
        // `unmacro menu *`
        args->all_keys = true;
      }
      else
      {
        // `unbind  menu key`
        // `unmacro menu key`
        args->key = buf_strdup(token);
      }
    }
    else
    {
      // `unbind  menu`
      // `unmacro menu`
      args->all_keys = true;
      args->restore_defaults = (cmd->id == CMD_UNBIND);
    }
  }
 
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    goto done;
  }
 
  rc = true;
 
done:
  buf_pool_release(&token);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

parse_unbind_exec()

bool parse_unbind_exec	(	const struct Command *	cmd,
		struct ParseUnbind *	args,
		struct Buffer *	err )

Execute the 'unbind' or 'unmacro' command.

Parameters

[in]	cmd	Command being executed
[in]	args	Parsed arguments
[out]	err	Buffer for error messages

Return values

true

Success

The user is trying to remove a binding or a macro. unbind only removes regular bindings; unmacro only removes macros.

Definition at line 554 of file commands.c.

{
  if (!cmd || !args || !err)
    return false;
 
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  keycode_t key_bytes[KEY_SEQ_MAX_LEN] = { 0 };
  int key_len = 0;
  if (args->key)
  {
    key_len = parse_keys(args->key, key_bytes, KEY_SEQ_MAX_LEN);
    if (key_len == 0)
      return false;
  }
 
  bool success = false;
  struct Buffer *keystr = buf_pool_get();
  enum NotifyBinding nb = (cmd->id == CMD_UNBIND) ? NT_BINDING_DELETE : NT_MACRO_DELETE;
  struct MenuDefinition **mdp = NULL;
  ARRAY_FOREACH(mdp, &mod_data->menu_defs)
  {
    struct MenuDefinition *md = *mdp;
    bool menu_success = false;
 
    if (!args->all_menus)
    {
      bool found = false;
      struct MenuDefinition **mdp2 = NULL;
      ARRAY_FOREACH(mdp2, &args->mda)
      {
        if ((*mdp2)->id == md->id)
        {
          found = true;
          break;
        }
      }
      if (!found)
        continue;
    }
 
    struct SubMenu **smp = ARRAY_GET(&md->submenus, 0);
    if (!smp || !*smp)
      continue;
 
    struct SubMenu *sm = *smp;
 
    struct Keymap *km = NULL;
    struct Keymap *km_tmp = NULL;
    STAILQ_FOREACH_SAFE(km, &sm->keymaps, entries, km_tmp)
    {
      bool match = args->all_keys || ((key_len == km->len) &&
                                      (memcmp(km->keys, key_bytes, km->len) == 0));
      if ((cmd->id == CMD_UNMACRO) && (km->op != OP_MACRO))
        match = false;
      if ((cmd->id == CMD_UNBIND) && (km->op == OP_MACRO))
        match = false;
 
      if (match)
      {
        STAILQ_REMOVE(&sm->keymaps, km, Keymap, entries);
        keymap_free(&km);
        success = true;
        menu_success = true;
 
        if (!args->all_keys && !args->all_menus)
        {
          buf_reset(keystr);
          keymap_expand_string(args->key, keystr);
          mutt_debug(LL_NOTIFY, "%s: %s %s\n", notify_binding_name(nb),
                     md->name, buf_string(keystr));
 
          struct EventBinding ev_b = { md, args->key, OP_NULL };
          notify_send(NeoMutt->notify, NT_BINDING, nb, &ev_b);
        }
      }
    }
 
    if (args->all_keys && !args->all_menus)
    {
      if (menu_success)
      {
        buf_reset(keystr);
        keymap_expand_string(args->key, keystr);
        mutt_debug(LL_NOTIFY, "%s: %s %s\n", notify_binding_name(nb), md->name,
                   buf_string(keystr));
 
        struct EventBinding ev_b = { md, args->key, OP_NULL };
        notify_send(NeoMutt->notify, NT_BINDING, nb, &ev_b);
      }
 
      if (args->restore_defaults)
        set_default_bindings(md);
    }
  }
 
  if (args->all_menus && args->all_keys)
  {
    if (success)
    {
      buf_reset(keystr);
      keymap_expand_string(args->key, keystr);
      mutt_debug(LL_NOTIFY, "%s: ALL %s\n", notify_binding_name(nb), buf_string(keystr));
 
      struct EventBinding ev_b = { NULL, args->key, OP_NULL };
      notify_send(NeoMutt->notify, NT_BINDING, nb, &ev_b);
    }
 
    if (args->restore_defaults)
      set_default_bindings(NULL);
  }
 
  buf_pool_release(&keystr);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function: