if (is_feature(feature, x, y + 1))

                if (is_feature(feature, x, y))

                *move_x = coord.x - (start_x + curs_x);
                *move_y = coord.y - (start_y + curs_y);

                *move_x = coord.x - (start_x + curs_x - 1);
                *move_y = coord.y - (start_y + curs_y - 1);

        *move_x = firstx - (start_x + curs_x);
        *move_y = firsty - (start_y + curs_y);

        *move_x = firstx - (start_x + curs_x - 1);
        *move_y = firsty - (start_y + curs_y - 1);

    char keypress = 0;

    if (Options.show_more_prompt)
    {
        char keypress = 0;

    if (Options.tutorial_left)
        message_out(crawl_view.msgsz.y - 1,
                    LIGHTGREY,
                    "--more--                        "
                    "Press Ctrl-P to reread old messages",
                    2, false);
    else
        message_out(crawl_view.msgsz.y - 1,
                    LIGHTGREY, "--more--", 2, false);
    do
        keypress = getch();
    while (keypress != ' ' && keypress != '\r' && keypress != '\n');

        if (Options.tutorial_left)
            message_out(crawl_view.msgsz.y - 1,
                        LIGHTGREY,
                        "--more--                        "
                        "Press Ctrl-P to reread old messages",
                        2, false);
        else
            message_out(crawl_view.msgsz.y - 1,
                        LIGHTGREY, "--more--", 2, false);

        do
            keypress = getch();
        while (keypress != ' ' && keypress != '\r' && keypress != '\n');
    }

bool is_synthetic_key(int key);

#include <stdio.h>      // for snprintf
#include <ctype.h>      // for tolower

#include <cstdio>      // for snprintf
#include <cctype>      // for tolower
#include <cstdlib>

static int read_key_code(std::string s)
{
    if (s.empty())
        return (0);

    int base = 10;
    if (s[0] == 'x')
    {
        s = s.substr(1);
        base = 16;
    }
    else if (s[0] == '^')
    {
        // ^A = 1, etc.
        return (1 + toupper(s[1]) - 'A');
    }
    char *tail;
    return strtol(s.c_str(), &tail, base);
}

 * by the string. Most characters produce their own ASCII code. There
 * are two special cases: 

 * by the string. Most characters produce their own ASCII code. These
 * are the cases: 

 *   \{123} produces 123 (decimal) 

 *   \{123} produces 123 (decimal)
 *   \{^A}  produces 1 (Ctrl-A)
 *   \{x40} produces 64 (hexadecimal code)
 *   \{!more} or \{!m} disables -more- prompt until the end of the macro.

    
    for (std::string::iterator i = s.begin(); i != s.end(); i++) 

    bool more_reset = false;
    for (int i = 0, size = s.length(); i < size; ++i) 

        char c = *i;

        char c = s[i];

            if (c == '\\') {

            if (c == '\\')

            } else {

            else

            }

            if (c == '\\') {

            if (c == '\\')
            {

            } else if (c == '{') {

            }
            else if (c == '{')
            {

            if (c == '}') {
                v.push_back(num);
                state = 0;
            } else if (c >= '0' && c <= '9') {
                num = num * 10 + c - '0';
            } 
            // XXX Error handling

        {
            const std::string::size_type clb = s.find('}', i);
            if (clb == std::string::npos)
                break;
            const std::string arg = s.substr(i, clb - i);
            if (!more_reset && (arg == "!more" || arg == "!m"))
            {
                more_reset = true;
                v.push_back(KEY_MACRO_MORE_PROTECT);
            }
            else
            {
                const int key = read_key_code(arg);
                if (key)
                    v.push_back(key);
            }
            state = 0;
            i = clb;

        }

            char buff[10];

            if (*i == KEY_MACRO_MORE_PROTECT)
                s += "\\{!more}";
            else
            {
                char buff[20];
                snprintf( buff, sizeof(buff), "\\{%d}", *i );
                s += std::string( buff );
            }

            snprintf( buff, sizeof(buff), "\\{%d}", *i );
            s += std::string( buff );

static void macro_buf_add( keyseq actions ) 

static void macro_buf_add( const keyseq &actions, bool reverse = false ) 

    for (keyseq::iterator i = actions.begin(); i != actions.end(); i++)
        Buffer.push_back(*i);   

    keyseq act(actions.size());
    bool need_more_reset = false;
    for (keyseq::const_iterator i = actions.begin(); i != actions.end();
         ++i)
    {
        int key = *i;
        if (key == KEY_MACRO_MORE_PROTECT)
        {
            key = KEY_MACRO_DISABLE_MORE;
            need_more_reset = true;
        }
        act.push_back(key);
    }
    if (need_more_reset)
        act.push_back(KEY_MACRO_ENABLE_MORE);
    Buffer.insert( reverse? Buffer.begin() : Buffer.end(),
                   act.begin(), act.end() );

static void macro_buf_add_long( keyseq actions, macromap &keymap = Keymaps[KC_DEFAULT] ) 

static void macro_buf_add_long( keyseq actions,
                                macromap &keymap = Keymaps[KC_DEFAULT] ) 

            if (result.size() > 0) {

            if (result.size() > 0)
            {

        keyseq  result = Macros[tmp]; 

        const keyseq &result = Macros[tmp]; 

            // Add macro to front:
            for (keyseq::reverse_iterator k = result.rbegin(); k != result.rend(); k++)
                Buffer.push_front(*k);  

            macro_buf_add(result, true);

        Buffer.clear();

    {
        while (!Buffer.empty())
        {
            const int key = Buffer.front();
            Buffer.pop_front();
            if (key == KEY_MACRO_ENABLE_MORE)
                Options.show_more_prompt = true;
        }
    }

bool is_synthetic_key(int key)
{
    switch (key)
    {
    case KEY_MACRO_ENABLE_MORE:
    case KEY_MACRO_DISABLE_MORE:
    case KEY_MACRO_MORE_PROTECT:
        return (true);
    default:
        return (false);
    }
}

#include "macro.h"

        flush_input_buffer( FLUSH_ON_FAILURE );        

        flush_input_buffer( FLUSH_ON_FAILURE );

    show_more_prompt = true;

    bool        show_more_prompt;

    // Disable/enable -more- prompts.
    CMD_DISABLE_MORE,
    CMD_ENABLE_MORE,
    

// Synthetic keys:
#define KEY_MACRO_MORE_PROTECT -10
#define KEY_MACRO_DISABLE_MORE -1
#define KEY_MACRO_ENABLE_MORE  -2

        break;
    case CMD_DISABLE_MORE:
        Options.show_more_prompt = false;

    case CMD_ENABLE_MORE:
        Options.show_more_prompt = true;
        break;
        

    case KEY_MACRO_DISABLE_MORE: return CMD_DISABLE_MORE;
    case KEY_MACRO_ENABLE_MORE:  return CMD_ENABLE_MORE;

    mesclr();

    if (!is_synthetic_key(keyin))
        mesclr();