#include "clua.h"

#include "luadgn.h"

%token <i>      NAME DEPTH ORIENT PLACE CHANCE FLAGS MONS ITEM
%token <i>      ROOT_DEPTH ENTRY_MSG EXIT_MSG
%token <i>      ROCK_COLOUR FLOOR_COLOUR
%token <i>      ENCOMPASS FLOAT 
%token <i>      NORTH EAST SOUTH WEST
%token <i>      NORTHEAST SOUTHEAST SOUTHWEST NORTHWEST
%token <i>      LEVEL END PVAULT PMINIVAULT MONSTERS ENDMONSTERS

%token <i>      NAME DEPTH ORIENT PLACE CHANCE MONS ITEM
%token <i>      PRELUDE MAIN

%token <i>      NO_HMIRROR NO_VMIRROR NO_ROTATE
%token <i>      PANDEMONIC 
%token <i>      DASH COMMA QUOTE OPAREN CPAREN COLON STAR NOT

%token <i>      DASH COMMA QUOTE OPAREN CPAREN

%type  <i>      orient_name flagname
%type  <range>  lev_range ext_range

%token <text>   IDENTIFIER

%token <text>   IDENTIFIER LUA_LINE

defdepth        : DEFAULT_DEPTH 
                  { lc_default_depths.clear(); }
                  default_depth_ranges

defdepth        : DEFAULT_DEPTH STRING
                {
                    dgn_reset_default_depth();
                    std::string err = dgn_set_default_depth($2);
                    if (!err.empty())
                        yyerror(make_stringf("Bad default-depth: %s (%s)",
                                $2, err.c_str()).c_str());
                }

                    if (lc_map.orient == MAP_FLOAT
                        || lc_map.is_minivault())
                    {
                        if (lc_map.map.width() > GXM - MAPGEN_BORDER * 2
                            || lc_map.map.height() > GYM - MAPGEN_BORDER * 2)
                        {
                            char buf[300];
                            snprintf(buf, sizeof buf, 
                                 "%s is too big: %dx%d - max %dx%d",
                                 lc_map.is_minivault()? "Minivault" : "Float",
                                 lc_map.map.width(), lc_map.map.height(),
                                 GXM - MAPGEN_BORDER * 2,
                                 GYM - MAPGEN_BORDER * 2);
                            yyerror(buf);
                        }
                    }
                    else
                    {
                        if (lc_map.map.width() > GXM
                            || lc_map.map.height() > GYM)
                        {
                            char buf[300];
                            snprintf(buf, sizeof buf, 
                                 "Map is too big: %dx%d - max %dx%d",
                                 lc_map.map.width(), lc_map.map.height(),
                                 GXM, GYM);
                            yyerror(buf);
                        }
                    }
                    if (lc_map.map.height() == 0)
                        yyerror("Must define map.");

                    std::string err = lc_map.validate();
                    if (!err.empty())
                        yyerror(err.c_str());

                | flags

                | main_lua
                | prelude_lua

main_lua        : MAIN main_lua_lines { }
main_lua_lines  : /* empty */ { }
                | main_lua_lines main_lua_line { }
                ;
main_lua_line   : LUA_LINE
                {
                    lc_map.main.add(yylineno, $1);
                }
prelude_lua     : PRELUDE prelude_lua_lines { }
prelude_lua_lines : /* empty */ { }
                | prelude_lua_lines prelude_lua_line { }
                ;
prelude_lua_line : LUA_LINE
                {
                    lc_map.prelude.add(yylineno, $1);
                }

                    std::string err = lc_map.add_key_feat($2);
                    if (!err.empty())
                        yyerror(
                            make_stringf("Bad arg to KFEAT: '%s' (%s)",
                                $2, err.c_str()).c_str());

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("kfeat(\"%s\")", 
                            quote_lua_string($2).c_str()));

                    std::string err = lc_map.add_key_mons($2);
                    if (!err.empty())
                        yyerror(
                            make_stringf("Bad arg to KMONS: '%s' (%s)",
                                $2, err.c_str()).c_str());

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("kmons(\"%s\")", 
                            quote_lua_string($2).c_str()));

                    std::string err = lc_map.add_key_item($2);
                    if (!err.empty())
                        yyerror(
                            make_stringf("Bad arg to KITEM: '%s' (%s)",
                                $2, err.c_str()).c_str());

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("kitem(\"%s\")", 
                            quote_lua_string($2).c_str()));

                    std::string err = lc_map.map.add_shuffle($1);
                    if (!err.empty())
                        yyerror(
                            make_stringf(
                                "Bad shuffle argument: '%s' (%s)",
                                $1, err.c_str() ).c_str() );

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("shuffle(\"%s\")", 
                            quote_lua_string($1).c_str()));

                | STRING tagstrings

                | tagstrings tagstring
                ;
tagstring       : STRING

                    lc_map.tags += " ";
                    lc_map.tags += $1;
                    lc_map.tags += " ";

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("tags(\"%s\")", 
                            quote_lua_string($1).c_str()));

                    std::string err = lc_map.map.add_subst($1);
                    if (!err.empty())
                        yyerror(
                            make_stringf(
                                "Bad SUBST argument: '%s' (%s)",
                                $1, err.c_str() ).c_str() );

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("subst(\"%s\")", 
                            quote_lua_string($1).c_str()));

                    std::string error = lc_map.items.add_item($1);
                    if (error.size())
                    {
                        char errbuf[300];
                        snprintf(errbuf, sizeof errbuf,
                            "Invalid item descriptor: '%s' (%s)",
                                $1, error.c_str());
                        yyerror(errbuf);
                    }
                    if (lc_map.items.size() > 8)
                        yyerror("Too many items specified (max 8)");

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("item(\"%s\")", 
                            quote_lua_string($1).c_str()));

                    std::string err = lc_map.mons.add_mons($1);
                    if (!err.empty())
                    {
                        char buf[300];
                        snprintf(buf, sizeof buf, 
                                 "bad monster spec '%s' (%s)",
                                 $1, err.c_str());
                        yyerror(buf);
                    }
                    if (lc_map.mons.size() > 7)
                        yyerror("Too many monsters specified (max 7)");

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("mons(\"%s\")", 
                            quote_lua_string($1).c_str()));

                    lc_map.place = $2;

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("place(\"%s\")", 
                            quote_lua_string($2).c_str()));

                | DEPTH extended_depth_ranges {}
                ;
default_depth_ranges : 
                ext_range
                {
                    lc_default_depths.push_back($1);
                }
                | default_depth_ranges COMMA ext_range
                {
                    lc_default_depths.push_back($3);
                }
                ;
extended_depth_ranges : 
                ext_range
                {
                    lc_map.add_depth($1);
                }
                | extended_depth_ranges COMMA ext_range
                {
                    lc_map.add_depth($3);
                }
                ;
ext_range       : lev_range     { $$ = $1; }
                | NOT lev_range { $$ = $2; $$.deny = true; }
                ;
lev_range       : IDENTIFIER
                {
                    $$ = set_range($1, 1, 100);
                }
                | IDENTIFIER COLON STAR
                {
                    $$ = set_range($1, 1, 100);
                }
                | IDENTIFIER COLON INTEGER DASH INTEGER
                {
                    $$ = set_range($1, $3, $5);
                }
                | IDENTIFIER COLON INTEGER

                | DEPTH STRING 

                    $$ = set_range($1, $3, $3);
                }
                | INTEGER DASH INTEGER
                {
                    $$ = set_range("Any", $1, $3);
                }
                | INTEGER
                {
                    $$ = set_range("Any", $1, $1);

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("depth(\"%s\")", 
                            quote_lua_string($2).c_str()));

                    lc_map.chance = $2;

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("chance(\"%d\")", $2));

                | ORIENT orient_name
                {
                    lc_map.orient = (map_section_type) $2;
                }
                ;
orient_name     : ENCOMPASS     { $$ = MAP_ENCOMPASS; }
                | NORTH         { $$ = MAP_NORTH; }
                | EAST          { $$ = MAP_EAST; }
                | SOUTH         { $$ = MAP_SOUTH; }
                | WEST          { $$ = MAP_WEST; }
                | NORTHEAST     { $$ = MAP_NORTHEAST; }
                | SOUTHEAST     { $$ = MAP_SOUTHEAST; }
                | SOUTHWEST     { $$ = MAP_SOUTHWEST; }
                | NORTHWEST     { $$ = MAP_NORTHWEST; }
                | FLOAT         { $$ = MAP_FLOAT; }
                ;
flags           : FLAGS flagnames {}
                ;
flagnames       : /* empty */
                | flagname flagnames

                | ORIENT STRING

                    switch ($1) {
                    case NO_HMIRROR:
                        lc_map.flags &= ~MAPF_MIRROR_HORIZONTAL;
                        break;
                    case NO_VMIRROR:
                        lc_map.flags &= ~MAPF_MIRROR_VERTICAL;
                        break;
                    case NO_ROTATE:
                        lc_map.flags &= ~MAPF_ROTATE;
                        break;
                    }

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("orient(\"%s\")", 
                                     quote_lua_string($2).c_str()));

flagname        : NO_HMIRROR    { $$ = NO_HMIRROR; }
                | NO_VMIRROR    { $$ = NO_VMIRROR; }
                | NO_ROTATE     { $$ = NO_ROTATE;  }
                ;

                    lc_map.map.add_line($1);

                    lc_map.main.add(
                        yylineno, 
                        make_stringf("map(\"%s\")", 
                                     quote_lua_string($1).c_str()));

static void settext()

static void settext(bool trim_right = false, int strip_trailing = 0)

    if ((yylval.text = strdup(yytext)))

    char *newstring = NULL;
    if ((yylval.text = newstring = strdup(yytext)))
    {

        char *s = NULL;
        if (trim_right)
        {
            s = newstring + strlen(newstring) - 1;
            while (isspace(*s) && s >= newstring)
                *s-- = 0;
        }
        if (strip_trailing)
        {
            if (!s)
                s = newstring + strlen(newstring) - 1;
            while (s >= newstring && --strip_trailing >= 0)
                *s-- = 0;
        }
    }

%x LUA

<LUA>\s*\}\}[ \t]*$     { BEGIN(INITIAL); }
<LUA>[^\r\n]+\}\}[ \t]*$ {
                            settext(true, 2);
                            BEGIN(INITIAL);
                            return LUA_LINE;
                        }
<LUA>[^\r\n]+           {
                            settext();
                            return LUA_LINE;
                        }
<LUA>\r?\n               ;

^\s*MAP                { BEGIN(MAPDEF); }

^\s*MAP             { BEGIN(MAPDEF); }

^prelude[ \t]*\{\{  { BEGIN(LUA); return PRELUDE; }      
^lua[ \t]*\{\{      { BEGIN(LUA); return MAIN; }
^[ \t]*\{\{         { BEGIN(LUA); return MAIN; }

default-depth:      return DEFAULT_DEPTH;
DEPTH:              return DEPTH;
ORIENT:             return ORIENT;

default-depth:      { BEGIN(ARGUMENT); return DEFAULT_DEPTH; }
DEPTH:              { BEGIN(ARGUMENT); return DEPTH; }
ORIENT:             { BEGIN(ARGUMENT); return ORIENT; }

FLAGS:              return FLAGS;

WEIGHT:             return CHANCE;
FLAGS:              { BEGIN(KEYWORDS); return TAGS; }

BRANCHDEF:          return BRANCH;
DEFAULT             return DEFAULT;
DESC:               return DESC;
BRANCH:             return BRANCH;
ROOT_DEPTH:         return ROOT_DEPTH;
FLOOR_COLOUR:       return FLOOR_COLOUR;
ROCK_COLOUR:        return ROCK_COLOUR;
LEVEL             return LEVEL;
END               return END;
PVAULT:             return PVAULT;
PMINIVAULT:         return PMINIVAULT;
ENTRY_MSG:          { BEGIN(ARGUMENT); return ENTRY_MSG; }
EXIT_MSG:           { BEGIN(ARGUMENT); return EXIT_MSG; }
MONSTERS          return MONSTERS;
ENDMONSTERS       return ENDMONSTERS;
pandemonic          return PANDEMONIC;
no_hmirror          return NO_HMIRROR;
no_vmirror          return NO_VMIRROR;
no_rotate           return NO_ROTATE;
encompass           return ENCOMPASS;
north               return NORTH;
south               return SOUTH;
east                return EAST;
west                return WEST;
northeast           return NORTHEAST;
northwest           return NORTHWEST;
southeast           return SOUTHEAST;
southwest           return SOUTHWEST;
float               return FLOAT;

:                   return COLON;
\*                  return STAR;
!                   return NOT;

    for (unsigned i = 0; i < 100; i++)

    for (unsigned i = 0; i < NUM_MUTATIONS; i++)

    for (i = 0; i < 100; i++)

    for (i = 0; i < NUM_MUTATIONS; i++)

    for (int i = 0; i < 100; i++)

    for (int i = 0; i < NUM_MUTATIONS; i++)

    map.reinit();
    map.run_lua(true);

    parse_maps( lc_desfile = datafile_path( "splev.des" ) );
    parse_maps( lc_desfile = datafile_path( "vaults.des" ) );
    parse_maps( lc_desfile = datafile_path( "entry.des" ) );
    parse_maps( lc_desfile = datafile_path( "ebranch.des" ) );

    static const char *map_files[] =
    {
        "entry.des", "splev.des", "vaults.des", "ebranch.des"
    };
    for (unsigned i = 0; i < ARRAYSIZE(map_files); ++i)
        parse_maps( lc_desfile = datafile_path( map_files[i] ) );

#include "luadgn.h"

enum map_flags
{
    MAPF_PANDEMONIUM_VAULT = 0x01,     // A pandemonium minivault.
    MAPF_MIRROR_VERTICAL   = 0x10,     // The map may be mirrored vertically
    MAPF_MIRROR_HORIZONTAL = 0x20,     // may be mirrored horizontally.
    MAPF_ROTATE            = 0x40      // may be rotated
};

    static level_range parse(std::string lr) throw (std::string);
    

    bool operator == (const level_range &lr) const;

private:
    static void parse_partial(level_range &lr, const std::string &s)
        throw (std::string);
    static void parse_depth_range(const std::string &s, int *low, int *high)
        throw (std::string);

    enum transform_type
    {
        TT_SHUFFLE,
        TT_SUBST
    };
    
public:

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

    transform_type type() const;
    std::string describe() const;

    bool operator == (const subst_spec &other) const;

    transform_type type() const;
    std::string describe() const;
    bool operator == (const shuffle_spec &other) const
    {
        return (shuffle == other.shuffle);
    }

    void remove_shuffle(const std::string &s);
    void remove_subst(const std::string &s);
    void clear_shuffles();
    void clear_substs();

    std::vector<std::string> &get_lines();
    std::vector<std::string> get_shuffle_strings() const;
    std::vector<std::string> get_subst_strings() const;

    void clear_transforms(map_transformer::transform_type);

    std::string set_mons(int slot, const std::string &s);

    std::string set_item(int index, const std::string &spec);

// Not providing a constructor to make life easy for C-style initialisation.

    int             chance;
    long            flags;

    int              chance;

    dlua_chunk      prelude, main;
private:
    // This map has been loaded from an index, and not fully realised.
    bool            index_only;
    long            cache_offset;

    map_def();

    void reinit();
    void set_file(const std::string &s);
    std::string run_lua(bool skip_main);
    void run_strip_prelude();
    void strip_lua();
    std::string validate();
    void add_prelude_line(int line,  const std::string &s);
    void add_main_line(int line, const std::string &s);

    std::vector<std::string> get_shuffle_strings() const;
    std::vector<std::string> get_subst_strings() const;
    

const char *map_section_name(int msect);

#include <iostream>

    if (shallowest == 1 && deepest >= branches[branch].depth)
        return ("");

    if (deepest >= branches[branch].depth)
        return (shallowest == 1? "" : make_stringf("%d-", shallowest));

level_range level_range::parse(std::string s) throw (std::string)
{
    level_range lr;
    trim_string(s);
    if (s[0] == '!')
    {
        lr.deny = true;
        s = trimmed_string(s.substr(1));
    }
    std::string::size_type cpos = s.find(':');
    if (cpos == std::string::npos)
        parse_partial(lr, s);
    else
    {
        std::string branch = trimmed_string(s.substr(0, cpos));
        std::string depth  = trimmed_string(s.substr(cpos + 1));
        parse_depth_range(depth, &lr.shallowest, &lr.deepest);
        lr.set(branch, lr.shallowest, lr.deepest);
    }
    return (lr);
}
void level_range::parse_partial(level_range &lr, const std::string &s)
    throw (std::string)
{
    if (isdigit(s[0]))
    {
        lr.branch = NUM_BRANCHES;
        parse_depth_range(s, &lr.shallowest, &lr.deepest);
    }
    else
        lr.set(s, 1, 100);
}
void level_range::parse_depth_range(const std::string &s, int *l, int *h)
    throw (std::string)
{
    if (s == "*")
    {
        *l = 1;
        *h = 100;
        return;
    }
    
    std::string::size_type hy = s.find('-');
    if (hy == std::string::npos)
    {
        *l = *h = atoi(s.c_str());
        if (!*l)
            throw std::string("Bad depth: ") + s;
    }
    else
    {
        *l = atoi(s.substr(0, hy).c_str());
        std::string tail = s.substr(hy + 1);
        if (tail.empty())
            *h = 100;
        else
            *h = atoi(tail.c_str());
        if (!*l || !*h || *l > *h)
            throw std::string("Bad depth: ") + s;
    }
}

}
bool level_range::operator == (const level_range &lr) const
{
    return (deny == lr.deny && shallowest == lr.shallowest
            && deepest == lr.deepest && branch == lr.branch);

{
    return (lines);
}
std::vector<std::string> &map_lines::get_lines()

void map_lines::remove_shuffle(const std::string &raw)
{
    std::string s = raw;
    const std::string err = check_shuffle(s);
    if (err.empty())
    {
        const shuffle_spec ss(s);
        for (int i = 0, size = transforms.size(); i < size; ++i)
        {
            if (transforms[i]->type() == map_transformer::TT_SHUFFLE)
            {
                const shuffle_spec *other =
                    dynamic_cast<shuffle_spec*>(transforms[i]);
                if (ss == *other)
                {
                    delete transforms[i];
                    transforms.erase( transforms.begin() + i );
                    return;
                }
            }
        }
    }
}
void map_lines::remove_subst(const std::string &raw)
{
    // Parsing subst specs is a pain, so we just let add_subst do the
    // work, then pop the subst off the end of the vector.
    if (add_subst(raw).empty())
    {
        map_transformer *sub = *transforms.rbegin();
        subst_spec spec = *dynamic_cast<subst_spec*>(sub);
        delete sub;
        transforms.pop_back();
        for (int i = 0, size = transforms.size(); i < size; ++i)
        {
            if (transforms[i]->type() == map_transformer::TT_SUBST)
            {
                subst_spec *cand = dynamic_cast<subst_spec*>(transforms[i]);
                if (spec == *cand)
                {
                    delete cand;
                    transforms.erase( transforms.begin() + i );
                    return;
                }
            }
        }
    }
}
void map_lines::clear_transforms(map_transformer::transform_type tt)
{
    if (transforms.empty())
        return;
    for (int i = transforms.size() - 1; i >= 0; --i)
        if (transforms[i]->type() == tt)
        {
            delete transforms[i];
            transforms.erase( transforms.begin() + i );
        }
}
void map_lines::clear_shuffles()
{
    clear_transforms(map_transformer::TT_SHUFFLE);
}
void map_lines::clear_substs()
{
    clear_transforms(map_transformer::TT_SUBST);    
}

}
std::vector<std::string> map_lines::get_shuffle_strings() const
{
    std::vector<std::string> shuffles;
    for (int i = 0, size = transforms.size(); i < size; ++i)
        if (transforms[i]->type() == map_transformer::TT_SHUFFLE)
            shuffles.push_back( transforms[i]->describe() );
    return (shuffles);
}
std::vector<std::string> map_lines::get_subst_strings() const
{
    std::vector<std::string> substs;
    for (int i = 0, size = transforms.size(); i < size; ++i)
        if (transforms[i]->type() == map_transformer::TT_SUBST)
            substs.push_back( transforms[i]->describe() );
    return (substs);

map_def::map_def()
    : name(), tags(), place(), depths(), orient(), chance(),
      map(), mons(), items(), keyspecs(), prelude(), main(),
      index_only(false), cache_offset(0L)
{
    init();
}

    orient = MAP_NONE;

    depths.clear();
    prelude.clear();
    main.clear();
    reinit();
}
void map_def::reinit()
{

    depths.clear();
    orient = MAP_NONE;

    // The map designer must explicitly disallow these if unwanted.
    flags = MAPF_MIRROR_VERTICAL | MAPF_MIRROR_HORIZONTAL
            | MAPF_ROTATE;

    // Clearing the map also zaps map transforms.

void map_def::set_file(const std::string &s)
{
    prelude.set_file(s);
    main.set_file(s);
}
void map_def::run_strip_prelude()
{
    run_lua(false);
    prelude.clear();
}
void map_def::strip_lua()
{
    prelude.clear();
    main.clear();
}
std::string map_def::run_lua(bool run_main)
{
    dlua.callfn("dgn_set_map", "m", this);
    int err = prelude.load(&dlua);
    if (err == -1000)
        lua_pushnil(dlua);
    else if (err)
        return (prelude.orig_error());
    if (!run_main)
        lua_pushnil(dlua);
    else
    {
        err = main.load(&dlua);
        if (err == -1000)
            lua_pushnil(dlua);
        else if (err)
            return (main.orig_error());
    }
    if (!dlua.callfn("dgn_run_map", 2, 0))
        return (dlua.error);
    
    // Clear the map setting.
    dlua.callfn("dgn_set_map", 0, 0);
    return (dlua.error);
}
std::string map_def::validate()
{
    std::string err = run_lua(true);
    if (!err.empty())
        return (err);
    
    if (orient == MAP_FLOAT || is_minivault())
    {
        if (map.width() > GXM - MAPGEN_BORDER * 2
            || map.height() > GYM - MAPGEN_BORDER * 2)
        {
            return make_stringf(
                     "%s is too big: %dx%d - max %dx%d",
                     is_minivault()? "Minivault" : "Float",
                     map.width(), map.height(),
                     GXM - MAPGEN_BORDER * 2,
                     GYM - MAPGEN_BORDER * 2);
        }
    }
    else
    {
        if (map.width() > GXM
            || map.height() > GYM)
        {
            return make_stringf(
                     "Map is too big: %dx%d - max %dx%d",
                     map.width(), map.height(),
                     GXM, GYM);
        }
    }
    if (map.height() == 0)
        return ("Must define map.");
    return ("");
}

    if (!(flags & MAPF_MIRROR_HORIZONTAL))

    if (has_tag("no_hmirror"))

    if (!(flags & MAPF_MIRROR_VERTICAL))

    if (has_tag("no_vmirror"))

    if (!(flags & MAPF_ROTATE))

    if (has_tag("no_rotate"))

}
std::vector<std::string> map_def::get_shuffle_strings() const
{
    return map.get_shuffle_strings();
}
std::vector<std::string> map_def::get_subst_strings() const
{
    return map.get_subst_strings();

    return (error);
}
std::string mons_list::set_mons(int index, const std::string &s)
{
    error.clear();
    if (index < 0)
        return (error = make_stringf("Index out of range: %d", index));
    
    mons_spec_slot slotmons = parse_mons_spec(s);
    if (!error.empty())
        return (error);

    if (index >= (int) mons.size())
    {
        mons.reserve(index + 1);
        mons.resize(index + 1, mons_spec_slot());
    }
    mons[index] = slotmons;

}
std::string item_list::set_item(int index, const std::string &spec)
{
    error.clear();
    if (index < 0)
        return (error = make_stringf("Index %d out of range", index));
    item_spec_slot sp = parse_item_spec(spec);
    if (error.empty())
    {
        if (index >= (int) items.size())
        {
            items.reserve(index + 1);
            items.resize(index + 1, item_spec_slot());
        }
        items.push_back(sp);
    }
    
    return (error);    

}
map_transformer::transform_type subst_spec::type() const
{
    return (TT_SUBST);
}
std::string subst_spec::describe() const
{
    std::string subst(1, foo);
    subst += std::string(" ") + (fix? ':' : '=');
    for (int i = 0, size = repl.size(); i < size; ++i)
    {
        const glyph_weighted_replacement_t &gly = repl[i];
        subst += " ";
        subst += static_cast<char>(gly.first);
        if (gly.second != 10)
            subst += make_stringf(":%d", gly.second);
    }
    return (subst);
}
bool subst_spec::operator == (const subst_spec &other) const
{
    if (foo != other.foo || fix != other.fix)
        return (false);
    if (repl.size() != other.repl.size())
        return (false);
    for (int i = 0, size = repl.size(); i < size; ++i)
    {
        if (repl[i] != other.repl[i])
            return (false);
    }
    return (true);

}
map_transformer::transform_type shuffle_spec::type() const
{
    return (TT_SHUFFLE);
}
std::string shuffle_spec::describe() const
{
    return (shuffle);

luadgn.o \

...

...

------------------------------------------------------------------------------
-- dungeon.lua:
-- Dungeoneering functions.
------------------------------------------------------------------------------
-- Given an object and a table (dgn), returns a table with functions
-- that translate into method calls on the object. This table is
-- suitable for setfenv() on a function that expects to directly
-- address a map object.
function dgn_map_meta_wrap(obj, tab)
   local meta = { }
   for fn, val in pairs(tab) do
      meta[fn] = function (...)
                    return val(obj, ...)
                 end
   end
   meta.wrapped_instance = obj
   local meta_meta = { __index = _G }
   setmetatable(meta, meta_meta)
   return meta
end
function dgn_set_map(map)
   g_dgn_curr_map = map
end
function dgn_run_map(prelude, main)
   if prelude or main then
      env = dgn_map_meta_wrap(g_dgn_curr_map, dgn)
      if prelude then
         setfenv(prelude, env)()
      end
      if main then
         setfenv(main, env)()
      end
      -- Return the environment in case we want to chain further
      -- calls.
      return env
   end
end

    CLua(bool managed);

    CLua(bool managed = true);

    int loadstring(const char *str, const char *context);

#define LUAWRAP(name, wrapexpr) \
    static int name(lua_State *ls) \
    {   \
        wrapexpr; \
        return (0); \
    }
#define PLUARET(type, val) \
        lua_push##type(ls, val); \
        return (1);
#define LUARET1(name, type, val) \
    static int name(lua_State *ls) \
    { \
        lua_push##type(ls, val); \
        return (1); \
    }

#define LUARET2(name, type, val1, val2)  \
    static int name(lua_State *ls) \
    { \
        lua_push##type(ls, val1); \
        lua_push##type(ls, val2); \
        return (2); \
    }
template <class T>
inline static T *util_get_userdata(lua_State *ls, int ndx)
{
    return (lua_islightuserdata(ls, ndx))?
            static_cast<T *>( lua_touserdata(ls, ndx) )
          : NULL;
}
template <class T>
inline static T *clua_get_userdata(lua_State *ls, const char *mt)
{
    return static_cast<T*>( luaL_checkudata( ls, 1, mt ) );
}
std::string quote_lua_string(const std::string &s);
#define MAP_METATABLE "dgn.mtmap"

#include "mapdef.h"

}
int CLua::loadstring(const char *s, const char *context)
{
    const int err = luaL_loadbuffer(state(), s, strlen(s), context);
    set_error(err, state());
    return err;

    int err = 0;
    if ((err = loadstring(s, context)))
        return (err);
    

    int err = luaL_loadbuffer(ls, s, strlen(s), context);
    if (err)
    {
        set_error(err, ls);
        return err;
    }

    int err = loadfile(ls, filename, trusted);

    int err = loadfile(ls, filename, trusted || !managed_vm);

static void push_map(lua_State *ls, map_def *map);

            break;
        case 'm':
            push_map(ls, va_arg(args, map_def *));

extern void lua_open_kills(lua_State *ls);
void lua_open_you(lua_State *ls);
void lua_open_item(lua_State *ls);
void lua_open_food(lua_State *ls);
void lua_open_crawl(lua_State *ls);
void lua_open_file(lua_State *ls);
void lua_open_options(lua_State *ls);
void lua_open_monsters(lua_State *ls);
void lua_open_globals(lua_State *ls);

extern void luaopen_kills(lua_State *ls);

void luaopen_you(lua_State *ls);
void luaopen_item(lua_State *ls);
void luaopen_food(lua_State *ls);
void luaopen_crawl(lua_State *ls);
void luaopen_file(lua_State *ls);
void luaopen_options(lua_State *ls);
void luaopen_monsters(lua_State *ls);
void luaopen_globals(lua_State *ls);

    lua_open_kills(_state);
    lua_open_you(_state);
    lua_open_item(_state);
    lua_open_food(_state);
    lua_open_crawl(_state);
    lua_open_file(_state);
    lua_open_options(_state);
    lua_open_monsters(_state);

    luaopen_kills(_state);
    luaopen_you(_state);
    luaopen_item(_state);
    luaopen_food(_state);
    luaopen_crawl(_state);
    luaopen_file(_state);
    luaopen_options(_state);
    luaopen_monsters(_state);

    lua_open_globals(_state);

    luaopen_globals(_state);

#define LUAWRAP(name, wrapexpr) \
    static int name(lua_State *ls) \
    {   \
        wrapexpr; \
        return (0); \
    }
#define LUARET1(name, type, val) \
    static int name(lua_State *ls) \
    { \
        lua_push##type(ls, val); \
        return (1); \
    }
#define LUARET2(name, type, val1, val2)  \
    static int name(lua_State *ls) \
    { \
        lua_push##type(ls, val1); \
        lua_push##type(ls, val2); \
        return (2); \
    }
template <class T> T *util_get_userdata(lua_State *ls, int ndx)
{
    return (lua_islightuserdata(ls, ndx))?
            static_cast<T *>( lua_touserdata(ls, ndx) )
          : NULL;
}
template <class T> T *clua_get_userdata(lua_State *ls, const char *mt)
{
    return static_cast<T*>( luaL_checkudata( ls, 1, mt ) );
}

void lua_open_you(lua_State *ls)

void luaopen_you(lua_State *ls)

void lua_open_item(lua_State *ls)

void luaopen_item(lua_State *ls)

void lua_open_food(lua_State *ls)

void luaopen_food(lua_State *ls)

void lua_open_crawl(lua_State *ls)

void luaopen_crawl(lua_State *ls)

void lua_open_file(lua_State *ls)

void luaopen_file(lua_State *ls)

void lua_open_options(lua_State *ls)

void luaopen_options(lua_State *ls)

void lua_open_monsters(lua_State *ls)

static void push_map(lua_State *ls, map_def *map)
{
    map_def **mapref = clua_new_userdata<map_def *>(ls, MAP_METATABLE);
    *mapref = map;
}
void luaopen_monsters(lua_State *ls)

void lua_open_globals(lua_State *ls)

void luaopen_globals(lua_State *ls)

std::string quote_lua_string(const std::string &s)
{
    return replace_all_of(replace_all_of(s, "\\", "\\\\"), "\"", "\\\"");
}

    for (int xy = 0; xy < 100; xy++)

    for (int xy = 0; xy < NUM_MUTATIONS; ++xy)

#include "luadgn.h"

    // set up the Lua interpreter for the dungeon builder.
    init_dungeon_lua();
    

void lua_open_kills(lua_State *ls)

void luaopen_kills(lua_State *ls)