subst_spec(int torepl, bool fix, const glyph_replacements_t &repls);
    subst_spec() : foo(0), fix(false), frozen_value(0), repl() { }

    subst_spec(std::string torepl, bool fix, const glyph_replacements_t &repls);
    subst_spec(int count, bool fix, const glyph_replacements_t &repls);
    subst_spec() : key(""), count(-1), fix(false), frozen_value(0), repl() { }

    int key() const
    {
        return (foo);
    }

    int value();

    int value();

public:
    std::string key;
    // If this is part of an nsubst spec, how many to replace.
    // -1 corresponds to all (i.e. '*')
    int count;      

private:
    int foo;        // The thing to replace.
    bool fix;       // If true, the first replacement fixes the value.

    bool fix;

    nsubst_spec(int key, const std::vector<subst_spec> &specs);

    nsubst_spec(std::string key, const std::vector<subst_spec> &specs);

    int key;

    std::string key;

    colour_spec(int _key, bool _fix, const map_colour_list &clist)

    colour_spec(std::string _key, bool _fix, const map_colour_list &clist)

    int key;

    std::string key;

    fprop_spec(int _key, bool _fix, const map_fprop_list &flist)

    fprop_spec(std::string _key, bool _fix, const map_fprop_list &flist)

    int key;

    std::string key;

class map_tile_list : public std::vector<map_weighted_colour>

class map_tile_list : public std::vector<map_weighted_tile>

    int key;

    std::string key;

    map_marker_spec(int _key, const std::string &mark)

    map_marker_spec(std::string _key, const std::string &mark)

    map_marker_spec(int _key, const lua_datum &fn)

    map_marker_spec(std::string _key, const lua_datum &fn)

    std::vector<coord_def> find_glyph(const std::string &glyphs) const;

    // Parse the string and set the given entry.  If fix is true,
    // then whatever is selected for the first feature will be
    // permanently fixed.

    // Copy from the given mapspec.  If that entry is fixed,
    // it should be pre-selected prior to the copy.
    void copy_feat(keyed_mapspec &spec);
    void copy_mons(keyed_mapspec &spec);
    void copy_item(keyed_mapspec &spec);
    void copy_mask(keyed_mapspec &spec);

            const std::string &s, bool fixed));

            const std::string &s, bool fixed),
        void (keyed_mapspec::*copy_field)(keyed_mapspec &spec));

    std::string err = mapdef_split_key_item(s, &key, &sep, &arg);

    std::string err = mapdef_split_key_item(s, &key, &sep, &arg, -1);

    map_marker_spec spec(key[0], arg);

    map_marker_spec spec(key, arg);

    map_marker_spec spec(key[0], function);

    map_marker_spec spec(key, function);

    std::string err = mapdef_split_key_item(sub, &key, &sep, &substitute);

    std::string err = mapdef_split_key_item(sub, &key, &sep, &substitute, -1);

    colour_spec spec(key[0], sep == ':', colours);

    colour_spec spec(key, sep == ':', colours);

    std::string err = mapdef_split_key_item(sub, &key, &sep, &substitute);

    std::string err = mapdef_split_key_item(sub, &key, &sep, &substitute, -1);

    fprop_spec spec(key[0], sep == ':', fprops);

    fprop_spec spec(key, sep == ':', fprops);

    std::string err = mapdef_split_key_item(sub, &key, &sep, &substitute);

    std::string err = mapdef_split_key_item(sub, &key, &sep, &substitute, -1);

    subst_spec spec(key[0], sep == ':', repl);

    subst_spec spec(key, sep == ':', repl);

    const int keyval = key == "*"? -1 : atoi(key.c_str());
    if (!keyval)

    const int count = key == "*"? -1 : atoi(key.c_str());
    if (!count)

    spec = subst_spec(keyval, sep == ':', repl);

    spec = subst_spec(count, sep == ':', repl);

    std::string err = mapdef_split_key_item(s, &key, &sep, &arg);

    std::string err = mapdef_split_key_item(s, &key, &sep, &arg, -1);

    nsubst_spec spec(key[0], substs);

    nsubst_spec spec(key, substs);

    while ((pos = s.find(spec.key(), pos)) != std::string::npos)

    while ((pos = s.find_first_of(spec.key, pos)) != std::string::npos)

    ASSERT(!spec.key.empty());

        while ((pos = lines[y].find(spec.key, pos)) != std::string::npos)

        while ((pos = lines[y].find_first_of(spec.key, pos)) != std::string::npos)

        while ((pos = lines[y].find(spec.key, pos)) != std::string::npos)

        while ((pos = lines[y].find_first_of(spec.key, pos)) != std::string::npos)

        while ((pos = lines[y].find(spec.key, pos)) != std::string::npos)

        while ((pos = lines[y].find_first_of(spec.key, pos)) != std::string::npos)

        const int nsubsts = spec.specs[i].key();

        const int nsubsts = spec.specs[i].count;

std::vector<coord_def> map_lines::find_glyph(const std::string &glyphs) const
{
    std::vector<coord_def> points;
    for (int y = height() - 1; y >= 0; --y)
    {
        for (int x = width() - 1; x >= 0; --x)
        {
            const coord_def c(x, y);
            if (glyphs.find((*this)(c)) != std::string::npos)
                points.push_back(c);
        }
    }
    return (points);
}

    std::string (keyed_mapspec::*set_field)(const std::string &s, bool fixed))

    std::string (keyed_mapspec::*set_field)(const std::string &s, bool fixed),
    void (keyed_mapspec::*copy_field)(keyed_mapspec &spec))

    std::string err = mapdef_split_key_item(s, &key, &separator, &arg);

    std::string err = mapdef_split_key_item(s, &key, &separator, &arg, -1);

    keyed_mapspec &km = keyspecs[key[0]];
    km.key_glyph = key[0];
    return ((km.*set_field)(arg, separator == ':'));

    keyed_mapspec &kmbase = keyspecs[key[0]];
    kmbase.key_glyph = key[0];
    err = ((kmbase.*set_field)(arg, separator == ':'));
    if (!err.empty())
        return (err);
    size_t len = key.length();
    for (size_t i = 1; i < len; i++)
    {
        keyed_mapspec &km = keyspecs[key[i]];
        km.key_glyph = key[i];
        ((km.*copy_field)(kmbase));
    }
    return (err);

    return add_key_field(s, &keyed_mapspec::set_item);

    return add_key_field(s, &keyed_mapspec::set_item,
                         &keyed_mapspec::copy_item);

    return add_key_field(s, &keyed_mapspec::set_feat);

    return add_key_field(s, &keyed_mapspec::set_feat,
                         &keyed_mapspec::copy_feat);

    return add_key_field(s, &keyed_mapspec::set_mons);

    return add_key_field(s, &keyed_mapspec::set_mons,
                         &keyed_mapspec::copy_mons);

    return add_key_field(s, &keyed_mapspec::set_mask);

    return add_key_field(s, &keyed_mapspec::set_mask,
                         &keyed_mapspec::copy_mask);

    {

        pick_monster(slotmons);
    }

        {

            pick_item(sp);
        }

subst_spec::subst_spec(std::string _k, bool _f, const glyph_replacements_t &g)
    : key(_k), count(-1), fix(_f), frozen_value(0), repl(g)
{
}

subst_spec::subst_spec(int torepl, bool dofix, const glyph_replacements_t &g)
    : foo(torepl), fix(dofix), frozen_value(0), repl(g)

subst_spec::subst_spec(int _count, bool dofix, const glyph_replacements_t &g)
    : key(""), count(_count), fix(dofix), frozen_value(0), repl(g)

nsubst_spec::nsubst_spec(int _key, const std::vector<subst_spec> &_specs)

nsubst_spec::nsubst_spec(std::string _key, const std::vector<subst_spec> &_specs)

    // Fix this feature.
    if (fix)
        get_feat();

}
void keyed_mapspec::copy_feat(keyed_mapspec &spec)
{
    feat = spec.feat;

}
void keyed_mapspec::copy_mons(keyed_mapspec &spec)
{
    mons = spec.mons;
}
void keyed_mapspec::copy_item(keyed_mapspec &spec)
{
    item = spec.item;
}
void keyed_mapspec::copy_mask(keyed_mapspec &spec)
{
    map_mask = spec.map_mask;

KFEAT: A = any trap
KFEAT: C = any trap
KFEAT: E = any trap
KFEAT: H = any trap
KITEM: A = gold / nothing
KITEM: B = gold / nothing
KITEM: C = gold / nothing
KITEM: D = gold / nothing

KFEAT: ACEH = any trap
KITEM: ABCD = gold / nothing

KFEAT:   M = shallow_water
KFEAT:   N = shallow_water
KFEAT:   O = shallow_water
KFEAT:   Q = shallow_water

KFEAT:   MNOQ = shallow_water

FTILE:   1234+ABCDEabcde = floor_dirt

FTILE:   1234+ABCDEabcdem = floor_dirt

SUBST:   a=mx, b=mx, c=mx, d=mx, e=mx
SUBST:   A:mx, B:mx, C:mx, D:mx, E:mx

SUBST:   abcde = mx
SUBST:   ABCDE : mx

KMASK:  w = no_monster_gen
KMASK:  W = no_monster_gen

KMASK:  Ww = no_monster_gen

        map_smear({iterations=20, smear='x', onto='.W', boxy = true})

        map_smear({iterations=20, smear='x', onto='.W', boxy=true})

          destroyed, this floor tile will be used in place of the normal floor.
          Thus, it can be useful even for non-floor features.

          destroyed, this floor tile will be used in place of the normal
          floor. Thus, it can be useful even for non-floor features.

          For convenience, multiple glyphs can be specified together as a
          group, e.g. ".[{( = floor_orc".

Handling long lines
-------------------

Assigning multiple glyphs at once
---------------------------------

Declarations that modify glyphs allow multiple glyphs to be assigned
simultaneously as a convenience.  For example, the following declaration will
assign floor_orc as the tile to be used for all up stair cases and floor:

    FTILE: .[{( = floor_orc
This case is identical to the longer syntax:
    FTILE: . = floor_orc
    FTILE: [ = floor_orc
    FTILE: { = floor_orc
    FTILE: ( = floor_orc
Using : instead of = while assigning glyphs will assign the same value to all
glyphs.  In the following example, the glyphs A, B, and C will either all
contain gold or all contain nothing:
    KITEM: ABC : gold / nothing
Note: The number of items assigned in an NSUBST expression applies to the
entire group of glyphs being assigned.  For example:
    # Among all A, B, and C glyphs, make one a floor and the rest walls.
    NSUBST: ABC = 1:. / *:x
    # Make one A glyph floor, one B glyph floor, and one C glyph floor.
    # Make the rest of the A, B, and C glyphs walls.
    NSUBST: A = 1:. / *:x
    NSUBST: B = 1:. / *:x
    NSUBST: C = 1:. / *:x