commands.c

Go to the documentation of this file.

 
#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"

struct ParseUnbind
{
  struct MenuDefinitionArray mda; 
  bool all_menus;                 
  bool all_keys;                  
  bool restore_defaults;          
  const char *key;                
};

enum CommandResult parse_dump(const struct Command *cmd, struct Buffer *line,
                              const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
 
  struct Buffer *token = buf_pool_get();
  const struct MenuDefinition *md = NULL;
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  if (MoreArgs(line))
  {
    parse_extract_token(token, line, TOKEN_NONE);
 
    if (MoreArgs(line))
    {
      /* More arguments potentially means the user is using the
       * ::command_t :bind command thus we delegate the task. */
      goto done;
    }
 
    if (!mutt_str_equal(buf_string(token), "all"))
    {
      md = menu_find_by_name(buf_string(token));
      if (!md)
      {
        // L10N: '%s' is the (misspelled) name of the menu, e.g. 'index' or 'pager'
        buf_printf(err, _("%s: no such menu"), buf_string(token));
        goto done;
      }
    }
  }
 
  dump_bind_macro(cmd, md, token, err);
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

char *parse_keymap(const struct Command *cmd, struct MenuDefinitionArray *mda,
                   struct Buffer *line, struct Buffer *err)
{
  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;
}

void parse_menu(struct MenuDefinitionArray *menus, const char *s, struct Buffer *err)
{
  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);
}

enum CommandResult parse_push(const struct Command *cmd, struct Buffer *line,
                              const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  parse_extract_token(token, line, TOKEN_CONDENSE);
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    goto done;
  }
 
  generic_tokenize_push_string(token->data);
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}

enum CommandResult parse_bind(const struct Command *cmd, struct Buffer *line,
                              const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
 
  if (StartupComplete)
  {
    // Save and restore the offset in `line` because parse_dump() might change it
    char *dptr = line->dptr;
    if (parse_dump(cmd, line, pc, pe) == MUTT_CMD_SUCCESS)
    {
      return MUTT_CMD_SUCCESS;
    }
    if (!buf_is_empty(err))
    {
      return MUTT_CMD_ERROR;
    }
    line->dptr = dptr;
  }
 
  struct Buffer *token = buf_pool_get();
  struct Buffer *keystr = NULL;
 
  struct MenuDefinitionArray mda = ARRAY_HEAD_INITIALIZER;
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  char *key = parse_keymap(cmd, &mda, line, err);
  if (!key)
    goto done;
 
  /* function to execute */
  parse_extract_token(token, line, TOKEN_NONE);
  if (MoreArgs(line))
  {
    buf_printf(err, _("%s: too many arguments"), cmd->name);
    goto done;
  }
 
  rc = MUTT_CMD_SUCCESS;
 
  if (mutt_istr_equal("noop", buf_string(token)))
  {
    keystr = buf_pool_get();
    struct MenuDefinition **mdp = NULL;
    ARRAY_FOREACH(mdp, &mda)
    {
      struct MenuDefinition *md = *mdp;
 
      km_bind(md, key, OP_NULL, NULL, NULL, NULL); /* the 'unbind' command */
 
      buf_reset(keystr);
      keymap_expand_string(key, keystr);
      mutt_debug(LL_NOTIFY, "NT_BINDING_DELETE: %s %s\n", md->name, buf_string(keystr));
 
      int op = km_get_op_menu(md->id, buf_string(token));
 
      struct EventBinding ev_b = { md, key, op };
      notify_send(NeoMutt->notify, NT_BINDING, NT_BINDING_DELETE, &ev_b);
    }
  }
  else
  {
    keystr = buf_pool_get();
    struct MenuDefinition **mdp = NULL;
    ARRAY_FOREACH(mdp, &mda)
    {
      struct MenuDefinition *md = *mdp;
 
      int op = OP_NULL;
      struct SubMenu **ptr = NULL;
      ARRAY_FOREACH(ptr, &md->submenus)
      {
        struct SubMenu *sm = *ptr;
        const struct MenuFuncOp *mfo = NULL;
        for (int j = 0; sm->functions[j].name; j++)
        {
          mfo = &sm->functions[j];
          if (mutt_str_equal(buf_string(token), mfo->name))
          {
            op = mfo->op;
            break;
          }
        }
        if (op != OP_NULL)
          break;
      }
 
      if (op == OP_NULL)
      {
        buf_printf(err, _("%s: no such function: %s"), cmd->name, buf_string(token));
        rc = MUTT_CMD_ERROR;
        goto done;
      }
 
      rc = km_bind(md, key, op, NULL, NULL, err);
      if (rc == MUTT_CMD_SUCCESS)
      {
        buf_reset(keystr);
        keymap_expand_string(key, keystr);
        mutt_debug(LL_NOTIFY, "NT_BINDING_NEW: %s %s\n", md->name, buf_string(keystr));
 
        struct EventBinding ev_b = { md, key, op };
        notify_send(NeoMutt->notify, NT_BINDING, NT_BINDING_ADD, &ev_b);
      }
    }
  }
 
done:
  FREE(&key);
  ARRAY_FREE(&mda);
  buf_pool_release(&keystr);
  buf_pool_release(&token);
  return rc;
}

void set_default_bindings(const struct MenuDefinition *md)
{
  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);
  }
}

const char *notify_binding_name(enum NotifyBinding ev)
{
  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";
  }
}

bool parse_unbind_args(const struct Command *cmd, struct Buffer *line,
                       struct Buffer *err, struct ParseUnbind *args)
{
  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;
}

bool parse_unbind_exec(const struct Command *cmd, struct ParseUnbind *args, struct Buffer *err)
{
  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;
}

enum CommandResult parse_unbind(const struct Command *cmd, struct Buffer *line,
                                const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
 
  struct ParseUnbind args = { 0 };
  enum CommandResult rc = MUTT_CMD_WARNING;
 
  if (!parse_unbind_args(cmd, line, err, &args))
    goto done;
 
  rc = MUTT_CMD_ERROR;
  if (parse_unbind_exec(cmd, &args, err))
    rc = MUTT_CMD_SUCCESS;
 
done:
  ARRAY_FREE(&args.mda);
  FREE(&args.key);
  return rc;
}

enum CommandResult parse_macro(const struct Command *cmd, struct Buffer *line,
                               const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
 
  if (StartupComplete)
  {
    // Save and restore the offset in `line` because parse_dump() might change it
    char *dptr = line->dptr;
    if (parse_dump(cmd, line, pc, pe) == MUTT_CMD_SUCCESS)
    {
      return MUTT_CMD_SUCCESS;
    }
    if (!buf_is_empty(err))
    {
      return MUTT_CMD_ERROR;
    }
    line->dptr = dptr;
  }
 
  struct MenuDefinitionArray mda = ARRAY_HEAD_INITIALIZER;
  struct Buffer *token = buf_pool_get();
  struct Buffer *keystr = NULL;
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  char *key = parse_keymap(cmd, &mda, line, err);
  if (!key)
    goto done;
 
  parse_extract_token(token, line, TOKEN_CONDENSE);
  /* make sure the macro sequence is not an empty string */
  if (buf_at(token, 0) == '\0')
  {
    buf_strcpy(err, _("macro: empty key sequence"));
  }
  else
  {
    if (MoreArgs(line))
    {
      char *seq = mutt_str_dup(buf_string(token));
      parse_extract_token(token, line, TOKEN_CONDENSE);
 
      if (MoreArgs(line))
      {
        buf_printf(err, _("%s: too many arguments"), cmd->name);
      }
      else
      {
        keystr = buf_pool_get();
        struct MenuDefinition **mdp = NULL;
        ARRAY_FOREACH(mdp, &mda)
        {
          struct MenuDefinition *md = *mdp;
 
          rc = km_bind(md, key, OP_MACRO, seq, token->data, NULL);
          if (rc == MUTT_CMD_SUCCESS)
          {
            buf_reset(keystr);
            keymap_expand_string(key, keystr);
            mutt_debug(LL_NOTIFY, "NT_MACRO_NEW: %s %s\n", md->name, buf_string(keystr));
 
            struct EventBinding ev_b = { md, key, OP_MACRO };
            notify_send(NeoMutt->notify, NT_BINDING, NT_MACRO_ADD, &ev_b);
            continue;
          }
        }
      }
 
      FREE(&seq);
    }
    else
    {
      keystr = buf_pool_get();
      struct MenuDefinition **mdp = NULL;
      ARRAY_FOREACH(mdp, &mda)
      {
        struct MenuDefinition *md = *mdp;
 
        rc = km_bind(md, key, OP_MACRO, token->data, NULL, NULL);
        if (rc == MUTT_CMD_SUCCESS)
        {
          buf_reset(keystr);
          keymap_expand_string(key, keystr);
          mutt_debug(LL_NOTIFY, "NT_MACRO_NEW: %s %s\n", md->name, buf_string(keystr));
 
          struct EventBinding ev_b = { md, key, OP_MACRO };
          notify_send(NeoMutt->notify, NT_BINDING, NT_MACRO_ADD, &ev_b);
          continue;
        }
      }
    }
  }
 
done:
  FREE(&key);
  ARRAY_FREE(&mda);
  buf_pool_release(&keystr);
  buf_pool_release(&token);
  return rc;
}

enum CommandResult parse_exec(const struct Command *cmd, struct Buffer *line,
                              const struct ParseContext *pc, struct ParseError *pe)
{
  struct Buffer *err = pe->message;
 
  if (!MoreArgs(line))
  {
    buf_printf(err, _("%s: too few arguments"), cmd->name);
    return MUTT_CMD_WARNING;
  }
 
  struct Buffer *token = buf_pool_get();
  enum CommandResult rc = MUTT_CMD_ERROR;
 
  int ops[128] = { 0 };
  int nops = 0;
  char *function = NULL;
 
  do
  {
    parse_extract_token(token, line, TOKEN_NONE);
    function = token->data;
 
    const enum MenuType mtype = menu_get_current_type();
    ops[nops] = km_get_op_menu(mtype, function);
    if (ops[nops] == OP_NULL)
    {
      mutt_flushinp();
      mutt_error(_("%s: no such function"), function);
      goto done;
    }
    nops++;
  } while (MoreArgs(line) && nops < countof(ops));
 
  while (nops)
    mutt_push_macro_event(0, ops[--nops]);
 
  rc = MUTT_CMD_SUCCESS;
 
done:
  buf_pool_release(&token);
  return rc;
}