// What level is this stash or shop on.
    level_id level;
    coord_def pos;

    // Where's this thingummy of interest.
    level_pos pos;

    // The stash or shop in question.

    // The stash or shop in question. Both can be null if this is a feature.

    stash_search_result() : level(), player_distance(0), matches(0),

    stash_search_result() : pos(), player_distance(0), matches(0),

#include "overmap.h"

        res.pos.x = x;
        res.pos.y = y;

        // XXX pos.pos looks lame. Lameness is not solicited.
        res.pos.pos.x = x;
        res.pos.pos.y = y;

        res.pos.x = x;
        res.pos.y = y;

        res.pos.pos.x = x;
        res.pos.pos.y = y;

                res.level = clid;

                res.pos.id = clid;

            res.level = clid;

            res.pos.id = clid;

                "Search your stashes for what item [Enter for \"%s\"]?",

                "Search for what [Enter for \"%s\"]?",

                "Search your stashes for what item?");

                "Search for what?");

        mpr("That item is not present in any of your stashes.",

        mpr("Can't find anything matching that.",

    get_matching_features(search, results);

    {
        results[i].player_distance = level_distance(curr, results[i].level);
    }

        results[i].player_distance = level_distance(curr, results[i].pos.id);

            draw_title_suffix(" (x - examine stash)", false);

            draw_title_suffix(" (x - examine)", false);

            draw_title_suffix(" (x - go to stash; ? - examine stash)", false);

            draw_title_suffix(" (x - travel; ? - examine)", false);

    std::string title = "matching stash";

    std::string title = "match";

        std::string place = short_place_name(res.level);

        std::string place = short_place_name(res.pos.id);

                dotravel = res->shop->show_menu(short_place_name(res->level),

                dotravel = res->shop->show_menu(short_place_name(res->pos.id),

                dotravel = res->stash->show_menu(short_place_name(res->level),

                dotravel = res->stash->show_menu(short_place_name(res->pos.id),

                level_pos lp;
                lp.id  = res->level;
                lp.pos = res->pos;

                const level_pos lp = res->pos;

        level_pos lp;
        lp.id  = res->level;
        lp.pos = res->pos;

        const level_pos lp = res->pos;

#include "stash.h"
#include <vector>

void unnotice_altar();

void get_matching_features(
    const base_pattern &pattern, std::vector<stash_search_result> &results);

#include "direct.h"

std::map<branch_type, level_id> stair_level;
std::map<level_pos, shop_type> shops_present;
std::map<level_pos, god_type> altars_present;
std::map<level_pos, portal_type> portals_present;

typedef std::map<branch_type, level_id> stair_map_type;
typedef std::map<level_pos, shop_type> shop_map_type;
typedef std::map<level_pos, god_type> altar_map_type;
typedef std::map<level_pos, portal_type> portal_map_type;
stair_map_type stair_level;
shop_map_type shops_present;
altar_map_type altars_present;
portal_map_type portals_present;

}
static int portal_to_feature(portal_type p)
{
    switch ( p )
    {
    case PORTAL_LABYRINTH:
        return DNGN_ENTER_LABYRINTH;
    case PORTAL_HELL:
        return DNGN_ENTER_HELL;
    case PORTAL_ABYSS:
        return DNGN_ENTER_ABYSS;
    case PORTAL_PANDEMONIUM:
        return DNGN_ENTER_PANDEMONIUM;
    default:
        return DNGN_FLOOR;
    }

static altar_map_type get_notable_altars(const altar_map_type &altars)
{
    altar_map_type notable_altars;
    for ( altar_map_type::const_iterator na_iter = altars.begin();
          na_iter != altars.end(); ++na_iter )
    {
        if (na_iter->first.id.branch != BRANCH_ECUMENICAL_TEMPLE)
            notable_altars[na_iter->first] = na_iter->second;
    }
    return (notable_altars);
}
inline static std::string place_desc(const level_pos &pos)
{
    return "[" + pos.id.describe(false, true) + "] ";
}
inline static std::string altar_description(god_type god)
{
    return feature_description( altar_for_god(god) );
}
inline static std::string portal_description(portal_type portal)
{
    return feature_description( portal_to_feature(portal) );
}
static void get_matching_altars(
    const base_pattern &pattern, std::vector<stash_search_result> &results)
{
    for ( altar_map_type::const_iterator na_iter = altars_present.begin();
          na_iter != altars_present.end(); ++na_iter )
    {
        const std::string adesc =
            altar_description(na_iter->second);
        
        if (pattern.matches(place_desc(na_iter->first) + adesc))
        {
            stash_search_result sr;
            sr.pos   = na_iter->first;
            sr.match = adesc;
            results.push_back(sr);
        }
    }
}
static void get_matching_portals(
    const base_pattern &pattern, std::vector<stash_search_result> &results)
{
    for ( portal_map_type::const_iterator pl_iter = portals_present.begin();
          pl_iter != portals_present.end(); ++pl_iter )
    {
        const std::string desc =
            portal_description(pl_iter->second);
        
        if (pattern.matches(place_desc(pl_iter->first) + desc + " [portal]"))
        {
            stash_search_result sr;
            sr.pos   = pl_iter->first;
            sr.match = desc;
            results.push_back(sr);
        }
    }
}
void get_matching_features(
    const base_pattern &pattern, std::vector<stash_search_result> &results)
{
    if (!pattern.valid())
        return;
    get_matching_altars(pattern, results);
    get_matching_portals(pattern, results);
}

    // remove unworthy altars from the list we show the user. Yeah,
    // one more round of map iteration.
    const altar_map_type notable_altars = get_notable_altars(altars_present);

    if ( !altars_present.empty() )

    if ( !notable_altars.empty() )

        for ( ci_altar = altars_present.begin();
              ci_altar != altars_present.end();

        for ( ci_altar = notable_altars.begin();
              ci_altar != notable_altars.end();

    // no point in recording Temple altars
    if ( you.where_are_you == BRANCH_ECUMENICAL_TEMPLE )
        return;
    // portable; no point in recording
    if ( god == GOD_NEMELEX_XOBEH )
        return;

}
void unnotice_altar()
{
    const coord_def pos = { you.x_pos, you.y_pos };
    const level_pos curpos(level_id::get_current_level_id(), pos);
    // Hmm, what happens when erasing a nonexistent key directly?
    if (altars_present.find(curpos) != altars_present.end())
        altars_present.erase(curpos);

int altar_for_god( god_type god );

// returns 0 is grid is not an altar, else it returns the GOD_* type

// returns 0 if grid is not an altar, else it returns the GOD_* type

}
// returns DNGN_FLOOR for non-gods, otherwise returns the altar for
// the god.
int altar_for_god( god_type god )
{
    if (god == GOD_NO_GOD || god >= NUM_GODS)
        return (DNGN_FLOOR);  // Yeah, lame. Tell me about it.
    return (DNGN_ALTAR_ZIN + god - 1);

#include "overmap.h"

            unnotice_altar();

#include "overmap.h"

                seen_notable_thing(
                    DNGN_ALTAR_NEMELEX_XOBEH, you.x_pos, you.y_pos);

// The order of this enum must match the order of DNGN_ALTAR_FOO.

        return ("A gateway to hell.");

        return ("A gateway to Hell.");