case DNGN_ENTER_BAZAAR:
        case DNGN_EXIT_BAZAAR:

        case DNGN_ENTER_PORTAL_VAULT:
        case DNGN_EXIT_PORTAL_VAULT:

        case DNGN_ENTER_BAZAAR:
        case DNGN_EXIT_BAZAAR:

        case DNGN_ENTER_PORTAL_VAULT:
        case DNGN_EXIT_PORTAL_VAULT:

%token <i>      PRELUDE MAIN VALIDATE VETO NSUBST

%token <i>      PRELUDE MAIN VALIDATE VETO NSUBST WELCOME

                | welcome

                                     quote_lua_string($2).c_str()));
                }
                ;
welcome         : WELCOME STRING
                {
                    lc_map.main.add(
                        yylineno,
                        make_stringf("welcome(\"%s\")",

WELCOME:            { BEGIN(ARGUMENT); return WELCOME; }

    traversable_terrain[DNGN_ENTER_BAZAAR] =
    traversable_terrain[DNGN_EXIT_BAZAAR] =

    traversable_terrain[DNGN_ENTER_PORTAL_VAULT] =
    traversable_terrain[DNGN_EXIT_PORTAL_VAULT] =

    else if (branch == "Bzr")
        return (level_id(LEVEL_BAZAAR));

    else if (branch == "Port")
        return (level_id(LEVEL_PORTAL_VAULT));

    marshallString(th, you.level_type_name);

    you.level_type_name = unmarshallString(th);

    stashes.remove_level( level_id(LEVEL_BAZAAR) );

    stashes.remove_level( level_id(LEVEL_PORTAL_VAULT) );

    return (flies() == FL_FLY && travelling_light());

    // Only Kenku get perks for flying light.
    return (species == SP_KENKU && flies() == FL_FLY && travelling_light());

    const item_def *armour = you.slot_item(EQ_BODY_ARMOUR);
    if (armour && !is_light_armour(*armour))
        return (false);
    return (you.burden < carrying_capacity(BS_UNENCUMBERED) * 60 / 100);

    return (you.burden < carrying_capacity(BS_UNENCUMBERED) * 70 / 100);

                           LEVEL_BAZAAR, false ).c_str() );

                           LEVEL_PORTAL_VAULT, false ).c_str() );

    case DNGN_ENTER_BAZAAR:

    case DNGN_ENTER_PORTAL_VAULT:

    case DNGN_EXIT_BAZAAR:

    case DNGN_EXIT_PORTAL_VAULT:

    case DNGN_ENTER_BAZAAR:

    case DNGN_ENTER_PORTAL_VAULT:

    return (type == LEVEL_LABYRINTH || type == LEVEL_BAZAAR);

    return (type == LEVEL_LABYRINTH || type == LEVEL_PORTAL_VAULT);

    // Note the name ahead of time because the events may cause
    // markers to be discarded.
    const std::string newtype =
        env_property_at(you.pos(), MAT_ANY, "dst");
    

    you.level_type_name = newtype;    

    else if (stair_find == DNGN_ENTER_BAZAAR)

    else if (stair_find == DNGN_ENTER_PORTAL_VAULT)

        you.level_type = LEVEL_BAZAAR;

        you.level_type = LEVEL_PORTAL_VAULT;

        break;
    case LEVEL_BAZAAR:
        mpr("You enter an inter-dimensional bazaar!");

    if (you.level_type == LEVEL_BAZAAR)
        return "- a Bazaar";

    if (you.level_type == LEVEL_PORTAL_VAULT)
        return "- a Portal Chamber";

        case LEVEL_BAZAAR:
            return ( long_name ? "a Bazaar" : "Bzr" );

        case LEVEL_PORTAL_VAULT:
            return ( long_name ? "a Portal Chamber" : "Port" );

    if (selected >= 0 && selected <= (int) items.size())

    if (selected >= 0 && selected < (int) items.size())

    if (selected >= 0 && selected <= (int) items.size())

    if (selected >= 0 && selected < (int) items.size())

    MAT_FEATURE_NAME,

    virtual std::string describe() const = 0;
    

    virtual std::string debug_describe() const = 0;
    virtual std::string feature_description() const;
    virtual std::string property(const std::string &pname) const; 
   

    std::string describe() const;

    std::string debug_describe() const;

    std::string describe() const;
 

    std::string debug_describe() const;
    std::string feature_description() const;
    std::string property(const std::string &pname) const;
    

    bool callfn(const char *fn, bool warn_err = false) const;

    bool callfn(const char *fn, bool warn_err = false, int args = -1) const;
    std::string call_str_fn(const char *fn) const;

std::string env_property_at(const coord_def &c, map_marker_type,
                            const std::string &key);

}
std::string map_marker::feature_description() const
{
    return ("");
}
std::string map_marker::property(const std::string &pname) const
{
    return ("");

std::string map_feature_marker::describe() const

std::string map_feature_marker::debug_describe() const

bool map_lua_marker::callfn(const char *fn, bool warn_err) const

bool map_lua_marker::callfn(const char *fn, bool warn_err, int args) const

    const int top = lua_gettop(dlua);
    push_fn_args(fn);
    const bool res =
        dlua.callfn("dlua_marker_method", lua_gettop(dlua) - top, 1);

    if (args == -1)
    {
        const int top = lua_gettop(dlua);
        push_fn_args(fn);
        args = lua_gettop(dlua) - top;
    }
    const bool res = dlua.callfn("dlua_marker_method", args, 1);

std::string map_lua_marker::describe() const

std::string map_lua_marker::call_str_fn(const char *fn) const

    if (!callfn("describe"))
        return make_stringf("error: %s", dlua.error.c_str());

    if (!callfn(fn))
        return make_stringf("error (%s): %s", fn, dlua.error.c_str());
    std::string result;
    if (lua_isstring(dlua, -1))
        result = lua_tostring(dlua, -1);
    return (result);
}
std::string map_lua_marker::debug_describe() const
{
    return (call_str_fn("describe"));
}
std::string map_lua_marker::feature_description() const
{
    return (call_str_fn("feature_description"));
}

    std::string desc;

std::string map_lua_marker::property(const std::string &pname) const
{
    lua_stack_cleaner cln(dlua);
    push_fn_args("property");
    lua_pushstring(dlua, pname.c_str());
    if (!callfn("property", false, 4))
        return make_stringf("error (prop:%s): %s",
                            pname.c_str(), dlua.error.c_str());
    std::string result;

        desc = lua_tostring(dlua, -1);
    return desc;

        result = lua_tostring(dlua, -1);
    return (result);    

    strip_tag(raw, "lua:");

    strip_tag(raw, "lua:", true);

std::string env_property_at(const coord_def &c, map_marker_type type,
                            const std::string &key)
{
    std::pair<dgn_marker_map::const_iterator, dgn_marker_map::const_iterator>
        els = env.markers.equal_range(c);
    for (dgn_marker_map::const_iterator i = els.first; i != els.second; ++i)
    {
        const std::string prop = i->second->property(key);
        if (!prop.empty())
            return (prop);
    }
    return ("");
}

    std::vector<std::string> welcome_messages;

      map(), mons(), items(), keyspecs(), prelude("dlprelude"),
      main("dlmain"), validate("dlvalidate"), veto("dlveto"),
      index_only(false), cache_offset(0L)

      welcome_messages(), map(), mons(), items(), keyspecs(),
      prelude("dlprelude"), main("dlmain"), validate("dlvalidate"),
      veto("dlveto"), index_only(false), cache_offset(0L)

    welcome_messages.clear();

static int dgn_welcome(lua_State *ls)
{
    MAP(ls, 1, map);
    map->welcome_messages.push_back(luaL_checkstring(ls, 2));
    return (0);
}

    "", "", "", "", "", "", "", "enter_bazaar", "exit_bazaar", "", "",

    "", "", "", "", "", "", "", "enter_portal_vault", "exit_portal_vault",

    "altar_zin", "altar_shining_one", "altar_kikubaaqudgha",

    "", "", "altar_zin", "altar_shining_one", "altar_kikubaaqudgha",

    "permadry_fountain"    

    "permadry_fountain"

        feature_description(feat, NUM_TRAPS, false, dtype, need_stop);

        feature_description(feat, NUM_TRAPS, dtype, need_stop);
    lua_pushstring(ls, s.c_str());
    return (1);
}
static int dgn_feature_desc_at(lua_State *ls)
{
    const description_level_type dtype =
        lua_isnumber(ls, 3)?
        static_cast<description_level_type>(luaL_checkint(ls, 3)) :
        description_type_by_name(lua_tostring(ls, 3));
    const bool need_stop = lua_isboolean(ls, 4)? lua_toboolean(ls, 4) : false;
    const std::string s =
        feature_description(luaL_checkint(ls, 1), luaL_checkint(ls, 2),
                            dtype, need_stop);

    { "welcome", dgn_welcome },

    { "feature_desc_at", dgn_feature_desc_at },

    LPT_FUNCTION

    LPT_FUNCTION,
    LPT_NIL

    else if (lua_isnil(ls, 2))
        ptype = LPT_NIL;

    file_marshall(ls);

    if (ptype != LPT_NIL)
        file_marshall(ls);

    case LPT_NIL:
        lua_pushnil(ls);
        return (1);

    "D", "Lab", "Abyss", "Pan", "Bzr"

    "D", "Lab", "Abyss", "Pan", "Port"

    case LEVEL_BAZAAR:
        return ("bzr");

    case LEVEL_PORTAL_VAULT:
        return ("ptl");

    else if (stair_taken == DNGN_ENTER_BAZAAR)

    else if (stair_taken == DNGN_ENTER_PORTAL_VAULT)

    else if (stair_taken == DNGN_EXIT_BAZAAR)

    else if (stair_taken == DNGN_EXIT_PORTAL_VAULT)

        if (just_created_level)
            level_welcome_messages();
        

  std::string level_type_name;

    DNGN_ENTER_BAZAAR = 160,
    DNGN_EXIT_BAZAAR,

    DNGN_ENTER_PORTAL_VAULT = 160,
    DNGN_EXIT_PORTAL_VAULT,

    LEVEL_BAZAAR,

    LEVEL_PORTAL_VAULT,

void level_welcome_messages();

std::vector<vault_placement> level_vaults;

static std::vector<vault_placement> level_vaults;

void level_welcome_messages()
{
    for (int i = 0, size = level_vaults.size(); i < size; ++i)
    {
        const std::vector<std::string> &msgs =
            level_vaults[i].map.welcome_messages;
        for (int j = 0, msize = msgs.size(); j < msize; ++j)
            mpr(msgs[j].c_str());
    }
}

    if (you.level_type == LEVEL_LABYRINTH || you.level_type == LEVEL_BAZAAR

    if (you.level_type == LEVEL_LABYRINTH
        || you.level_type == LEVEL_PORTAL_VAULT

    if (level_type == LEVEL_BAZAAR)

    if (level_type == LEVEL_PORTAL_VAULT)

        bazaar_level(level_number);

        if (you.level_type_name == "bazaar")
            bazaar_level(level_number);
        else
        {
            // Need to find encompass vault with tag matching
            // level_type_name.
            ASSERT(false);
        }

                    grd[x][y] = DNGN_EXIT_BAZAAR;

                    grd[x][y] = DNGN_EXIT_PORTAL_VAULT;

            place_specific_stair(DNGN_ENTER_BAZAAR, "bzr_entry",

            place_specific_stair(DNGN_ENTER_PORTAL_VAULT,
                                 "bzr_entry",

                                    trap_type tr = NUM_TRAPS,
                                    bool temporary = false);

                                    trap_type tr = NUM_TRAPS);

                                bool temporary = false,

std::string feature_description(dungeon_feature_type grid,
                                trap_type trap,
                                bool temporary,
                                description_level_type dtype,
                                bool add_stop)

static std::string feature_do_grammar(description_level_type dtype,
                                      bool add_stop,
                                      bool force_article,
                                      std::string desc)

    std::string desc =
        raw_feature_description(grid, trap, temporary);

    if (dtype == DESC_PLAIN || (!grid_is_trap(grid) && isupper(desc[0])))

    if (dtype == DESC_PLAIN || (!force_article && isupper(desc[0])))

    }

    }    
}
std::string feature_description(dungeon_feature_type grid,
                                trap_type trap,
                                description_level_type dtype,
                                bool add_stop)
{
    std::string desc = raw_feature_description(grid, trap);
    return feature_do_grammar(dtype, add_stop, grid_is_trap(grid), desc);

                                    trap_type trap,
                                    bool temporary)

                                    trap_type trap)

        if (temporary)
            return ("slowly fading labyrinth entrance");
        else
            return ("labyrinth entrance");
    case DNGN_ENTER_BAZAAR:
        if (temporary)
            return ("gently fading gateway to a bazaar");
        else
            return ("gateway to a bazaar");
    case DNGN_EXIT_BAZAAR:
        return ("exit from the bazaar");

        return ("labyrinth entrance");

    case DNGN_EXIT_PORTAL_VAULT:
        return ("gate leading back to the Dungeon");

    }
}
static std::string marker_feature_description(const coord_def &p)
{
    std::vector<map_marker*> markers = env_get_markers(p);
    for (int i = 0, size = markers.size(); i < size; ++i)
    {
        const std::string desc = markers[i]->feature_description();
        if (!desc.empty())
            return (desc);

    return ("");

        return (feature_description(grid, trap_type_at_xy(mx, my), false,

        return (feature_description(grid, trap_type_at_xy(mx, my), 

    case DNGN_ENTER_PORTAL_VAULT:
        return (feature_do_grammar(
                    dtype, add_stop, false,
                    marker_feature_description(coord_def(mx, my))));

        return (feature_description(grid, NUM_TRAPS, false, dtype, add_stop));

        return (feature_description(grid, NUM_TRAPS, dtype, add_stop));

        std::string desc = mark->describe();

        std::string desc = mark->debug_describe();

    you.level_type = LEVEL_BAZAAR;

    you.level_type = LEVEL_PORTAL_VAULT;

    check_mapless(level_id(LEVEL_BAZAAR), mapless);

    check_mapless(level_id(LEVEL_PORTAL_VAULT), mapless);

dofile('clua/lm_pdesc.lua')
dofile('clua/lm_1way.lua')

dofile('clua/lm_1way.lua')

  return fn(marker, th)

  return fn({ }, marker, th)

function timed_marker(pars)
  return TimedMarker.new(pars)
end

TimedMarker = { }

TimedMarker = PortalDescriptor:new()

function TimedMarker._new()

function TimedMarker:_new()

  setmetatable(marker, TimedMarker)

  setmetatable(marker, self)
  self.__index = self

function TimedMarker.new(pars)

function TimedMarker:new(pars)

  local tmarker = TimedMarker._new()
  tmarker.dur   = dur * 10
  tmarker.fnum  = fnum
  tmarker.feat  = feat
  tmarker.msg   = pars.msg

  local tmarker     = self:_new()
  tmarker.dur       = dur * 10
  tmarker.fnum      = fnum
  tmarker.feat      = feat
  tmarker.msg       = pars.msg
  tmarker.disappear = pars.disappear
  if pars.props then
    tmarker.props = pars.props
  end

      crawl.mpr(dgn.feature_desc(dgn.grid(x, y), "The") .. 
                " disappears!")

      crawl.mpr( self.disappear or 
                 dgn.feature_desc_at(x, y, "The") .. " disappears!")

function TimedMarker.read(marker, th)
  local marker = TimedMarker._new()
  marker.dur = file.unmarshall_number(th)
  marker.fnum = file.unmarshall_number(th)
  marker.feat = file.unmarshall_string(th)
  marker.msg  = file.unmarshall_fn(th)(th)
  return marker

function TimedMarker:read(marker, th)
  PortalDescriptor.read(self, marker, th)
  self.dur = file.unmarshall_number(th)
  self.fnum = file.unmarshall_number(th)
  self.feat = file.unmarshall_string(th)
  self.disappear = file.unmarshall_meta(th)
  self.msg  = file.unmarshall_fn(th)(th)
  setmetatable(self, TimedMarker)
  return self 

  PortalDescriptor.write(self, marker, th)

  file.marshall_meta(th, self.disappear)

end
function timed_marker(pars)
  return TimedMarker:new(pars)

------------------------------------------------------------------------------
-- lm_desc.lua:
-- Portal descriptor markers.
------------------------------------------------------------------------------
PortalDescriptor = { }
PortalDescriptor.__index = PortalDescriptor
function PortalDescriptor:new(properties)
  local pd = { }
  setmetatable(pd, self)
  pd.props = properties
  return pd
end
function PortalDescriptor:write(marker, th)
  file.marshall(th, self.desc or '')
  lmark.marshall_table(th, self.props)
end
function PortalDescriptor:read(marker, th)
  self.desc  = file.unmarshall_string(th)
  self.props = lmark.unmarshall_table(th)
  setmetatable(self, PortalDescriptor)
  return self
end
function PortalDescriptor:feature_description(marker)
  return self.props.desc
end
function PortalDescriptor:property(marker, pname)
  return self.props and self.props[pname] or ''
end
function portal_desc(desc, props)
  return PortalDescriptor:new(desc, props)
end

OneWayStair = { }

OneWayStair = PortalDescriptor:new()

function OneWayStair.new()
  local ows = { }
  setmetatable(ows, OneWayStair)

function OneWayStair:new(props)
  local ows = PortalDescriptor.new(self, props)
  setmetatable(ows, self)

function OneWayStair.read(marker, th)
  return OneWayStair.new()

function OneWayStair:read(marker, th)
  PortalDescriptor.read(self, marker, th)
  setmetatable(self, OneWayStair)
  return self

function one_way_stair()
  return OneWayStair.new()

function one_way_stair(pars)
  return OneWayStair:new(pars)

    function check_expire_marker(e)
        e.messager = 
            bell_clock_msg { initmsg="You hear coins being counted." }
        if not crawl.one_chance_in(3) then
            e.marker( [[ O = lua: timed_marker {
                            low=1000, high=1500, msg=messager }
                      ]] )
        else
            e.marker("O = lua: one_way_stair()")
        end
    end

function bazaar_portal()
  local messager = bell_clock_msg { initmsg="You hear coins being counted." }
  if not crawl.one_chance_in(3) then
    local pdesc = 'flickering gateway to a bazaar'
    return timed_marker {
                  low=1000, high=1500, msg=messager,
                  disappear='The gate to the bazaar disappears!',
                  props = { desc=pdesc, dst='bazaar' }
              }
  else
    return one_way_stair { desc = 'gateway to a bazaar',
                           dst = 'bazaar' }
  end
end
function bazaar_message(e)
  e.welcome("You enter an inter-dimensional bazaar!")
end

: check_expire_marker(_G)

MARKER: O = lua:bazaar_portal()

: check_expire_marker(_G)

MARKER: O = lua:bazaar_portal()

: check_expire_marker(_G)

MARKER: O = lua:bazaar_portal()

: check_expire_marker(_G)

MARKER: O = lua:bazaar_portal()

# will be placed when entering the bazaar).

# will be placed when entering the bazaar). If there's no upstair, the player
# will arrive on a random square.

: bazaar_message(_G)

: bazaar_message(_G)

: bazaar_message(_G)

: bazaar_message(_G)