get.c File Reference

Get a key from the user. More...

#include "config.h"
#include <ctype.h>
#include <limits.h>
#include <stdbool.h>
#include <string.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "config/lib.h"
#include "core/lib.h"
#include "gui/lib.h"
#include "get.h"
#include "menu/lib.h"
#include "globals.h"
#include "keymap.h"
#include "menu.h"
#include "module_data.h"
#include "notify.h"
#include "monitor.h"

Include dependency graph for get.c:

Go to the source code of this file.

Enumerations
enum	DokeyState { DKS_START = 1 , DKS_COUNTER , DKS_NEED_MORE }
	Internal state for km_dokey() More...

Functions
void	mutt_push_macro_repeated (char *macro, int count)
	Push a macro string into the input queue, optionally repeated.
void	mutt_flushinp (void)
	MacroEvents moved to KeyModuleData UngetKeyEvents moved to KeyModuleData.
struct KeyEvent *	array_pop (struct KeyEventArray *a)
	Remove an event from the array.
void	array_add (struct KeyEventArray *a, int ch, int op)
	Add an event to the end of the array.
void	array_to_endcond (struct KeyEventArray *a)
	Clear the array until an OP_END_COND.
void	mutt_unget_ch (int ch)
	Return a keystroke to the input buffer.
void	mutt_unget_op (int op)
	Return an operation to the input buffer.
void	mutt_push_macro_event (int ch, int op)
	Add the character/operation to the macro buffer.
void	mutt_flush_macro_to_endcond (void)
	Drop a macro from the input buffer.
static int	mutt_monitor_getch_timeout (int timeout_ms)
	Get a character and poll the filesystem monitor.
static struct KeyEvent	mutt_getch_timeout (GetChFlags flags, int timeout_ms)
	Read a character from the input buffer with timeout.
struct KeyEvent	mutt_getch (GetChFlags flags)
	Read a character from the input buffer.
void	km_error_key (const struct MenuDefinition *md)
	Handle an unbound key sequence.
void	generic_tokenize_push_string (char *s)
	Parse and queue a 'push' command.
KeyGatherFlags	gather_functions (const struct MenuDefinition *md, const keycode_t *keys, int key_len, struct KeymapMatchArray *kma)
	Find functions whose keybindings match.
static void	key_progress_notify (const struct MenuDefinition *md, int count, const keycode_t *keys, int key_len, GetChFlags flags)
	Send key matching progress notification.
struct KeyEvent	km_dokey (const struct MenuDefinition *md, GetChFlags flags)
	Determine what a keypress should do.

Variables
static const int	MaxKeyLoop = 64
	XXX.

Detailed Description

Get a key from the user.

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

Enumeration Type Documentation

DokeyState

enum DokeyState

Internal state for km_dokey()

Enumerator
DKS_START	Initial state, no input received yet.
DKS_COUNTER	Reading count prefix digits.
DKS_NEED_MORE	Prefix matches an exact and/or longer keybinding.

Definition at line 478 of file get.c.

{
  DKS_START = 1, 
  DKS_COUNTER,   
  DKS_NEED_MORE, 
};

Function Documentation

mutt_push_macro_repeated()

void mutt_push_macro_repeated	(	char *	macro,
		int	count )

Push a macro string into the input queue, optionally repeated.

Parameters

macro	Macro string to expand
count	Number of times to repeat (0 or 1 means once)

The repeat count is clamped to $macro_repeat_max to bound queue growth.

Definition at line 60 of file get.c.

{
  int repeat = (count > 0) ? count : 1;
 
  const short c_macro_repeat_max = cs_subset_number(NeoMutt->sub, "macro_repeat_max");
  if ((c_macro_repeat_max > 0) && (repeat > c_macro_repeat_max))
    repeat = c_macro_repeat_max;
 
  for (int i = 0; i < repeat; i++)
    generic_tokenize_push_string(macro);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_flushinp()

void mutt_flushinp

(

void

)

MacroEvents moved to KeyModuleData UngetKeyEvents moved to KeyModuleData.

Empty all the keyboard buffers

Definition at line 81 of file get.c.

{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  const size_t unget_count = ARRAY_SIZE(&mod_data->unget_key_events);
  const size_t macro_count = ARRAY_SIZE(&mod_data->macro_events);
  ARRAY_SHRINK(&mod_data->unget_key_events, ARRAY_SIZE(&mod_data->unget_key_events));
  ARRAY_SHRINK(&mod_data->macro_events, ARRAY_SIZE(&mod_data->macro_events));
 
  if ((unget_count + macro_count) > 0)
  {
    mutt_debug(LL_DEBUG1, "Flushed %zu queued key events (%zu unget, %zu macro)\n",
               unget_count + macro_count, unget_count, macro_count);
  }
  flushinp();
}

Here is the call graph for this function:

Here is the caller graph for this function:

array_pop()

struct KeyEvent * array_pop

(

struct KeyEventArray *

a

)

Remove an event from the array.

Parameters

a

Array

Return values

ptr

Event

Definition at line 102 of file get.c.

{
  if (ARRAY_EMPTY(a))
  {
    return NULL;
  }
 
  struct KeyEvent *event = ARRAY_LAST(a);
  ARRAY_SHRINK(a, 1);
  return event;
}

Here is the caller graph for this function:

array_add()

void array_add	(	struct KeyEventArray *	a,
		int	ch,
		int	op )

Add an event to the end of the array.

Parameters

a	Array
ch	Character
op	Operation, e.g. OP_DELETE

Definition at line 120 of file get.c.

{
  struct KeyEvent event = { ch, op, 0 };
  ARRAY_ADD(a, event);
}

Here is the caller graph for this function:

array_to_endcond()

void array_to_endcond

(

struct KeyEventArray *

a

)

Clear the array until an OP_END_COND.

Parameters

a

Array

Definition at line 130 of file get.c.

{
  while (!ARRAY_EMPTY(a))
  {
    if (array_pop(a)->op == OP_END_COND)
    {
      return;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_unget_ch()

void mutt_unget_ch

(

int

ch

)

Return a keystroke to the input buffer.

Parameters

ch

Key press

This puts events into the UngetKeyEvents buffer

Definition at line 147 of file get.c.

{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  array_add(&mod_data->unget_key_events, ch, OP_NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_unget_op()

void mutt_unget_op

(

int

op

)

Return an operation to the input buffer.

Parameters

op	Operation, e.g. OP_DELETE

This puts events into the UngetKeyEvents buffer

Definition at line 159 of file get.c.

{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  array_add(&mod_data->unget_key_events, 0, op);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_push_macro_event()

void mutt_push_macro_event	(	int	ch,
		int	op )

Add the character/operation to the macro buffer.

Parameters

ch	Character to add
op	Operation to add

Adds the ch/op to the macro buffer. This should be used for macros, push, and exec commands only.

Definition at line 173 of file get.c.

{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  array_add(&mod_data->macro_events, ch, op);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_flush_macro_to_endcond()

void mutt_flush_macro_to_endcond

(

void

)

Drop a macro from the input buffer.

All the macro text is deleted until an OP_END_COND command, or the buffer is empty.

Definition at line 185 of file get.c.

{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  array_to_endcond(&mod_data->macro_events);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_monitor_getch_timeout()

static int mutt_monitor_getch_timeout ( int timeout_ms )

static

Get a character and poll the filesystem monitor.

Parameters

timeout_ms

Timeout in milliseconds

Return values

num	Character pressed
ERR	Timeout

Definition at line 198 of file get.c.

{
  /* ncurses has its own internal buffer, so before we perform a poll,
   * we need to make sure there isn't a character waiting */
  timeout(0);
  int ch = getch();
  timeout(timeout_ms);
  if (ch == ERR)
  {
    if (mutt_monitor_poll() != 0)
      ch = ERR;
    else
      ch = getch();
  }
  return ch;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_getch_timeout()

static struct KeyEvent mutt_getch_timeout ( GetChFlags flags, int timeout_ms )

static

Read a character from the input buffer with timeout.

Parameters

flags	Flags, e.g. GETCH_IGNORE_MACRO
timeout_ms	Timeout in milliseconds

Return values

obj	KeyEvent to process

Definition at line 222 of file get.c.

{
  static const struct KeyEvent event_abort = { 0, OP_ABORT, 0 };
  static const struct KeyEvent event_repaint = { 0, OP_REPAINT, 0 };
  static const struct KeyEvent event_timeout = { 0, OP_TIMEOUT, 0 };
 
  if (!OptGui)
    return event_abort;
 
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
 
  struct KeyEvent *event_key = array_pop(&mod_data->unget_key_events);
  if (event_key)
    return *event_key;
 
  if (!(flags & GETCH_IGNORE_MACRO))
  {
    event_key = array_pop(&mod_data->macro_events);
    if (event_key)
      return *event_key;
  }
 
  int ch;
  SigInt = false;
  mutt_sig_allow_interrupt(true);
  timeout(timeout_ms);
#ifdef USE_INOTIFY
  ch = mutt_monitor_getch_timeout(timeout_ms);
#else
  ch = getch();
#endif
  mutt_sig_allow_interrupt(false);
 
  if (SigInt)
  {
    mutt_query_exit();
    return event_abort;
  }
 
  if (ch == KEY_RESIZE)
  {
    timeout(0);
    while ((ch = getch()) == KEY_RESIZE)
    {
      // do nothing
    }
  }
 
  if (ch == ERR)
  {
    if (!isatty(STDIN_FILENO)) // terminal was lost
      mutt_exit(1);
 
    if (SigWinch)
    {
      SigWinch = false;
      notify_send(NeoMutt->notify_resize, NT_RESIZE, 0, NULL);
      return event_repaint;
    }
 
    notify_send(NeoMutt->notify_timeout, NT_TIMEOUT, 0, NULL);
    return event_timeout;
  }
 
  if (ch == mod_data->abort_key)
    return event_abort;
 
  if (ch & 0x80)
  {
    const bool c_meta_key = cs_subset_bool(NeoMutt->sub, "meta_key");
    if (c_meta_key)
    {
      /* send ALT-x as ESC-x */
      ch &= ~0x80;
      mutt_unget_ch(ch);
      return (struct KeyEvent) { '\033', OP_NULL, 0 }; // Escape
    }
  }
 
  return (struct KeyEvent) { ch, OP_NULL, 0 };
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_getch()

struct KeyEvent mutt_getch

(

GetChFlags

flags

)

Read a character from the input buffer.

Parameters

flags

Flags, e.g. GETCH_IGNORE_MACRO

Return values

obj	KeyEvent to process

The priority for reading events is:

1. UngetKeyEvents buffer
2. MacroEvents buffer
3. Keyboard

This function can return:

• Abort { 0, OP_ABORT, 0 }
• Repaint { 0, OP_REPAINT, 0 }
• Timeout { 0, OP_TIMEOUT, 0 }

Definition at line 319 of file get.c.

{
  return mutt_getch_timeout(flags, 1000);
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_error_key()

void km_error_key

(

const struct MenuDefinition *

md

)

Handle an unbound key sequence.

Parameters

md	Menu Definition

Definition at line 328 of file get.c.

{
  if (!md)
    return;
 
  struct Keymap *key = km_find_func(md, OP_HELP);
  if (!key)
  {
    mutt_error(_("Key is not bound"));
    return;
  }
 
  struct Buffer *buf = buf_pool_get();
  keymap_expand_key(key, buf);
  mutt_error(_("Key is not bound.  Press '%s' for help."), buf_string(buf));
  buf_pool_release(&buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

generic_tokenize_push_string()

void generic_tokenize_push_string

(

char *

s

)

Parse and queue a 'push' command.

Parameters

s	String to push into the key queue

Parses s for <function> syntax and adds the whole sequence the macro buffer.

Definition at line 352 of file get.c.

{
  struct KeyModuleData *mod_data = neomutt_get_module_data(NeoMutt, MODULE_ID_KEY);
  char *pp = NULL;
  char *p = s + mutt_str_len(s) - 1;
  size_t l;
  int i, op = OP_NULL;
 
  while (p >= s)
  {
    /* if we see something like "<PageUp>", look to see if it is a real
     * function name and return the corresponding value */
    if (*p == '>')
    {
      for (pp = p - 1; pp >= s && *pp != '<'; pp--)
        ; // do nothing
 
      if (pp >= s)
      {
        i = parse_fkey(pp);
        if (i > 0)
        {
          mutt_push_macro_event(KEY_F(i), 0);
          p = pp - 1;
          continue;
        }
 
        l = p - pp + 1;
        for (i = 0; mod_data->key_names[i].name; i++)
        {
          if (mutt_istrn_equal(pp, mod_data->key_names[i].name, l))
            break;
        }
        if (mod_data->key_names[i].name)
        {
          /* found a match */
          mutt_push_macro_event(mod_data->key_names[i].value, 0);
          p = pp - 1;
          continue;
        }
 
        /* See if it is a valid command
         * skip the '<' and the '>' when comparing */
        struct Buffer *buf = buf_pool_get();
        buf_strcpy_n(buf, pp + 1, l - 2);
 
        for (enum MenuType j = 0; j < MENU_MAX; j++)
        {
          op = km_get_op_menu(j, buf_string(buf));
          if (op != OP_NULL)
            break;
        }
 
        buf_pool_release(&buf);
 
        if (op != OP_NULL)
        {
          mutt_push_macro_event(0, op);
          p = pp - 1;
          continue;
        }
      }
    }
    mutt_push_macro_event((unsigned char) *p--, 0); /* independent 8 bits chars */
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

gather_functions()

KeyGatherFlags gather_functions	(	const struct MenuDefinition *	md,
		const keycode_t *	keys,
		int	key_len,
		struct KeymapMatchArray *	kma )

Find functions whose keybindings match.

Parameters

[in]	md	Menu Definition of all valid functions
[in]	keys	User-entered key string to match
[in]	key_len	Length of key string
[out]	kma	Array for the results

Return values

flags

Results, e.g. KEY_GATHER_MATCH

Definition at line 427 of file get.c.

{
  if (!md || !keys || !kma)
    return 0;
 
  struct SubMenu **smp = NULL;
  KeyGatherFlags flags = KEY_GATHER_NO_MATCH;
 
  ARRAY_FOREACH(smp, &md->submenus)
  {
    struct Keymap *km = NULL;
 
    STAILQ_FOREACH(km, &(*smp)->keymaps, entries)
    {
      if (key_len > km->len)
        continue;
 
      bool match = true;
 
      for (int i = 0; i < key_len; i++)
      {
        if (keys[i] != km->keys[i])
        {
          match = false;
          break;
        }
      }
 
      if (match)
      {
        KeyGatherFlags fmatch = KEY_GATHER_NO_MATCH;
        if (km->len == key_len)
          fmatch = KEY_GATHER_MATCH;
        else
          fmatch = KEY_GATHER_LONGER;
 
        flags |= fmatch;
 
        struct KeymapMatch kmatch = { md->id, fmatch, km };
        ARRAY_ADD(kma, kmatch);
      }
    }
  }
 
  return flags;
}

Here is the caller graph for this function:

key_progress_notify()

static void key_progress_notify ( const struct MenuDefinition * md, int count, const keycode_t * keys, int key_len, GetChFlags flags )

static

Send key matching progress notification.

Parameters

md	Menu Definition
count	Parsed count prefix
keys	Entered keys
key_len	Number of entered keys
flags	Flags, e.g. GETCH_NO_FEEDBACK

Definition at line 493 of file get.c.

{
  if (flags & GETCH_NO_FEEDBACK)
    return;
 
  struct EventKeyProgress ev_k = { 0 };
  ev_k.md = md;
  ev_k.count = count;
  ev_k.key_len = MAX(0, MIN(key_len, KEY_SEQ_MAX_LEN));
 
  for (int i = 0; i < ev_k.key_len; i++)
  {
    ev_k.keys[i] = keys[i];
  }
 
  notify_send(NeoMutt->notify, NT_KEY, NT_KEY_PROGRESS, &ev_k);
}

Here is the call graph for this function:

Here is the caller graph for this function:

km_dokey()

struct KeyEvent km_dokey	(	const struct MenuDefinition *	md,
		GetChFlags	flags )

Determine what a keypress should do.

Parameters

md	Menu Definition
flags	Flags, e.g. GETCH_IGNORE_MACRO

Return values

ptr

Event

Definition at line 518 of file get.c.

{
  struct KeyEvent event = { 0, OP_NULL, 0 };
  enum DokeyState state = DKS_START;
  int count = 0;
  int count_digits = 0;
  int key_len = 0;
  struct Keymap *pending_exact = NULL;
  bool feedback_active = false;
  keycode_t keys[KEY_SEQ_MAX_LEN] = { 0 };
 
  const short c_key_timeout_idle = cs_subset_number(NeoMutt->sub, "key_timeout_idle");
  const short c_key_timeout_progress = cs_subset_number(NeoMutt->sub, "key_timeout_partial");
 
  if (!md)
    return event;
 
  for (int n = 0; n < MaxKeyLoop; n++)
  {
    const int timeout_ms = (state == DKS_START) ? c_key_timeout_idle : c_key_timeout_progress;
    event = mutt_getch_timeout(flags, timeout_ms);
 
    // abort, timeout, repaint
    if (event.op < OP_NULL)
    {
      if (event.op == OP_TIMEOUT)
      {
        if ((state == DKS_NEED_MORE) && pending_exact)
        {
          if (pending_exact->op != OP_MACRO)
          {
            key_progress_notify(md, count, keys, key_len, flags);
            key_progress_notify(md, 0, NULL, 0, flags);
            return (struct KeyEvent) { 0, pending_exact->op, count };
          }
 
          if (flags & GETCH_IGNORE_MACRO)
          {
            key_progress_notify(md, 0, NULL, 0, flags);
            return (struct KeyEvent) { 0, OP_NULL, 0 };
          }
 
          mutt_push_macro_repeated(pending_exact->macro, count_digits > 0 ? count : 0);
          state = DKS_START;
          count = 0;
          count_digits = 0;
          key_len = 0;
          pending_exact = NULL;
          memset(keys, 0, sizeof(keys));
          feedback_active = false;
          key_progress_notify(md, 0, NULL, 0, flags);
          continue;
        }
      }
 
      if (feedback_active || (state != DKS_START))
      {
        key_progress_notify(md, 0, NULL, 0, flags);
      }
      mutt_debug(LL_DEBUG3, "KEY: getch() %s\n", opcodes_get_name(event.op));
      return event;
    }
 
    // macro op pushed into queue (e.g. from `exec`)
    if (event.op > OP_NULL)
    {
      if (feedback_active || (state != DKS_START))
      {
        key_progress_notify(md, 0, NULL, 0, flags);
      }
      // Apply any count digits that arrived ahead of this op
      // (e.g. "5<next-entry>" inside a macro body),
      // preserving an explicit count already attached to the event.
      if ((event.count == 0) && (count_digits > 0))
        event.count = count;
      return event;
    }
 
    mutt_debug(LL_DEBUG3, "KEY: getch() '%c'\n", isprint(event.ch) ? event.ch : '?');
 
    // Check if digit keys have explicit bindings before using them as a counter
    if (!(flags & GETCH_NO_COUNTER) && (state != DKS_NEED_MORE) &&
        (event.ch >= '0') && (event.ch <= '9'))
    {
      keycode_t digit_key = event.ch;
      struct KeymapMatchArray digit_kma = ARRAY_HEAD_INITIALIZER;
      KeyGatherFlags digit_kgf = gather_functions(md, &digit_key, 1, &digit_kma);
      bool digit_bound = (digit_kgf & KEY_GATHER_MATCH);
      ARRAY_FREE(&digit_kma);
 
      if (!digit_bound)
      {
        if (count_digits >= KEY_COUNT_MAX_DIGITS)
        {
          key_progress_notify(md, count, keys, key_len, flags);
          key_progress_notify(md, 0, NULL, 0, flags);
          return (struct KeyEvent) { event.ch, OP_NULL, 0 };
        }
 
        const int digit = event.ch - '0';
        if ((count > (INT_MAX / 10)) ||
            ((count == (INT_MAX / 10)) && (digit > (INT_MAX % 10))))
        {
          key_progress_notify(md, count, keys, key_len, flags);
          key_progress_notify(md, 0, NULL, 0, flags);
          return (struct KeyEvent) { event.ch, OP_NULL, 0 };
        }
 
        count = (count * 10) + digit;
        count_digits++;
        state = DKS_COUNTER;
        feedback_active = true;
        key_progress_notify(md, count, keys, key_len, flags);
        continue;
      }
    }
 
    if (key_len >= KEY_SEQ_MAX_LEN)
    {
      key_progress_notify(md, count, keys, key_len, flags);
      key_progress_notify(md, 0, NULL, 0, flags);
      return (struct KeyEvent) { event.ch, OP_NULL, 0 };
    }
 
    keys[key_len] = event.ch;
    key_len++;
 
    struct KeymapMatchArray kma = ARRAY_HEAD_INITIALIZER;
    KeyGatherFlags kgf = gather_functions(md, keys, key_len, &kma);
 
    mutt_debug(LL_DEBUG3, "KEY: flags = %x\n", kgf);
 
    bool has_exact = false;
    bool has_longer = false;
    pending_exact = NULL;
 
    struct KeymapMatch *kmatch = NULL;
    ARRAY_FOREACH(kmatch, &kma)
    {
      if (kmatch->flags == KEY_GATHER_MATCH)
      {
        has_exact = true;
        if (!pending_exact)
          pending_exact = kmatch->keymap;
      }
      else if (kmatch->flags == KEY_GATHER_LONGER)
      {
        has_longer = true;
      }
    }
 
    if (!has_exact && !has_longer)
    {
      key_progress_notify(md, count, keys, key_len, flags);
      key_progress_notify(md, 0, NULL, 0, flags);
      mutt_debug(LL_DEBUG3, "KEY: FAIL1: ('%c', %s)\n",
                 isprint(event.ch) ? event.ch : '?', opcodes_get_name(event.op));
      ARRAY_FREE(&kma);
      return event;
    }
 
    if (has_exact && has_longer)
    {
      state = DKS_NEED_MORE;
      feedback_active = true;
      key_progress_notify(md, count, keys, key_len, flags);
      ARRAY_FREE(&kma);
      continue;
    }
 
    if (!has_exact && has_longer)
    {
      state = DKS_NEED_MORE;
      feedback_active = true;
      key_progress_notify(md, count, keys, key_len, flags);
      ARRAY_FREE(&kma);
      continue;
    }
 
    if (has_exact && pending_exact)
    {
      struct Keymap *map = pending_exact;
 
      if (map->op != OP_MACRO)
      {
        key_progress_notify(md, count, keys, key_len, flags);
        key_progress_notify(md, 0, NULL, 0, flags);
        mutt_debug(LL_DEBUG3, "KEY: SUCCESS: ('%c', %s)\n",
                   isprint(event.ch) ? event.ch : '?', opcodes_get_name(map->op));
        ARRAY_FREE(&kma);
        return (struct KeyEvent) { event.ch, map->op, count_digits > 0 ? count : 0 };
      }
 
      /* #GETCH_IGNORE_MACRO turns off processing the MacroEvents buffer
       * in mutt_getch().  Generating new macro events during that time would
       * result in undesired behavior once the option is turned off.
       *
       * Originally this returned -1, however that results in an unbuffered
       * username or password prompt being aborted.  Returning OP_NULL allows
       * mw_get_field() to display the keybinding pressed instead.
       *
       * It may be unexpected for a macro's keybinding to be returned,
       * but less so than aborting the prompt.  */
      if (flags & GETCH_IGNORE_MACRO)
      {
        key_progress_notify(md, 0, NULL, 0, flags);
        ARRAY_FREE(&kma);
        return (struct KeyEvent) { event.ch, OP_NULL, 0 };
      }
 
      mutt_push_macro_repeated(map->macro, count_digits > 0 ? count : 0);
      state = DKS_START;
      count = 0;
      count_digits = 0;
      key_len = 0;
      pending_exact = NULL;
      memset(keys, 0, sizeof(keys));
      feedback_active = false;
      key_progress_notify(md, 0, NULL, 0, flags);
      ARRAY_FREE(&kma);
      continue;
    }
 
    ARRAY_FREE(&kma);
  }
 
  key_progress_notify(md, 0, NULL, 0, flags);
  mutt_flushinp();
  mutt_error(_("Macro loop detected"));
  return (struct KeyEvent) { '\0', OP_ABORT, 0 };
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

MaxKeyLoop

const int MaxKeyLoop = 64

static

XXX.

Definition at line 51 of file get.c.