- (you_are_delayed()? 5 : 0));

            - (you_are_delayed()
               && !is_run_delay(current_delay_action())? 5 : 0));

    // In a macro delay, a stacked delay to tell Crawl to read and act on
    // one input command.
    DELAY_MACRO_PROCESS_KEY,

void clear_macro_process_key_delay();

}
void clear_macro_process_key_delay()
{
    if (current_delay_action() == DELAY_MACRO_PROCESS_KEY)
        _pop_delay();

    // If a Lua macro wanted Crawl to process a key normally, early exit.
    if (delay.type == DELAY_MACRO_PROCESS_KEY)
        return;

        start_delay(DELAY_MACRO, 1);

        if (!you_are_delayed())
            start_delay(DELAY_MACRO, 1);

    "interruptible", "uninterruptible"

    "macro_process_key", "interruptible", "uninterruptible"

-- Sends the characters in keys as keyboard input to crawl, then requests
-- that Crawl process one command.
function crawl.process_keys(keys, yield_value)
  if yield_value == nil then
    yield_value = true
  end
  crawl.sendkeys(keys)
  crawl.process_command()
  coroutine.yield(yield_value)
end

}
// Tell Crawl to process one command.
static int crawl_process_command(lua_State *ls)
{
    const bool will_process =
        current_delay_action() == DELAY_MACRO || !you_are_delayed();
    if (will_process)
    {
        // This should only be called from a macro delay, but run_macro
        // may not have started the macro delay; do so now.
        if (!you_are_delayed())
            start_delay(DELAY_MACRO, 1);
        start_delay(DELAY_MACRO_PROCESS_KEY, 1);
    }
    lua_pushboolean(ls, will_process);
    return (1);

    { "process_command", crawl_process_command },

    if (you_are_delayed())

    if (you_are_delayed() && current_delay_action() != DELAY_MACRO_PROCESS_KEY)

        clear_macro_process_key_delay();