*  File:       sqldbm.c

 *  File:       sqldbm.cc

 *  
 *  Modified for Crawl Reference by $Author: dshaligram $ on $Date: 2007-06-26T17:43:23.491102Z $

#endif

#endif // USE_SQLITE_DBM

const int MAP_CACHE_VERSION = 1003;

#define DESCACHE_VER  1002

    return (ver == DESCACHE_VER);

    return (ver == MAP_CACHE_VERSION);

    writeLong(outf, DESCACHE_VER);

    writeLong(outf, MAP_CACHE_VERSION);

    writeLong(outf, DESCACHE_VER);

    writeLong(outf, MAP_CACHE_VERSION);

    writeShort(outf, 0x1eaf);   // Level indicator.

    writeShort(outf, MAP_CACHE_VERSION);   // Level indicator.

    if (readShort(inf) != 0x1eaf || readString(inf) != name)

    if (readShort(inf) != MAP_CACHE_VERSION || readString(inf) != name)

    std::string compiled;

    enum chunk_t
    {
        CT_EMPTY,
        CT_SOURCE,
        CT_COMPILED
    };
    

    int check_op(CLua *, int);

    int check_op(CLua &, int);

    void release_compiled_chunk();

#include "stuff.h"
#include <sstream>

    : file(), chunk(), context(_context), first(-1), last(-1), error()

    : file(), chunk(), compiled(), context(_context), first(-1),
      last(-1), error()

    writeString(outf, chunk, LUA_CHUNK_MAX_SIZE);
    if (!chunk.empty())

    if (compiled.empty() && chunk.empty())

        writeString(outf, file);
        writeLong(outf, first);

        writeByte(outf, CT_EMPTY);
        return;
    }
    
    if (!compiled.empty())
    {
        writeByte(outf, CT_COMPILED);
        writeString(outf, compiled, LUA_CHUNK_MAX_SIZE);

    else
    {
        writeByte(outf, CT_SOURCE);
        writeString(outf, chunk, LUA_CHUNK_MAX_SIZE);
    }
        
    writeString(outf, file);
    writeLong(outf, first);

    chunk = readString(inf, LUA_CHUNK_MAX_SIZE);
    if (!chunk.empty())

    clear();
    chunk_t type = static_cast<chunk_t>(readByte(inf));
    switch (type)

        file  = readString(inf);
        first = readLong(inf);

    case CT_EMPTY:
        return;
    case CT_SOURCE:
        chunk = readString(inf, LUA_CHUNK_MAX_SIZE);
        break;
    case CT_COMPILED:
        compiled = readString(inf, LUA_CHUNK_MAX_SIZE);
        break;

    file  = readString(inf);
    first = readLong(inf);

    compiled.clear();

int dlua_chunk::check_op(CLua *interp, int err)

int dlua_chunk::check_op(CLua &interp, int err)

    error = interp->error;

    error = interp.error;

static int dlua_compiled_chunk_writer(lua_State *ls, const void *p,
                                      size_t sz, void *ud)
{
    std::ostringstream &out = *static_cast<std::ostringstream*>(ud);
    out.write((const char *) p, sz);
    return (0);
}

    if (trimmed_string(chunk).empty())

    if (!compiled.empty())
        return check_op( interp,
                         interp.loadbuffer(compiled.c_str(), compiled.length(),
                                           context.c_str()) );
    if (empty())
    {
        chunk.clear();

    return check_op(&interp,
                    interp.loadstring(chunk.c_str(), context.c_str()));

    }
    
    int err = check_op( interp,
                        interp.loadstring(chunk.c_str(), context.c_str()) );
    if (err)
        return (err);
    std::ostringstream out;
    err = lua_dump(interp, dlua_compiled_chunk_writer, &out);
    if (err)
    {
        const char *e = lua_tostring(interp, -1);
        error = e? e : "Unknown error compiling chunk";
        lua_pop(interp, 2);
    }
    compiled = out.str();
    chunk.clear();
    return (err);

    return check_op(&interp, !interp.callfn(fn, fn? 1 : 0, 0));

    return check_op(interp, !interp.callfn(fn, fn? 1 : 0, 0));

static int dgn_grid(lua_State *ls)
{
    const int x = luaL_checkint(ls, 1), y = luaL_checkint(ls, 2);
    if (!map_bounds(x, y))
        luaL_error(ls,
                   make_stringf("(%d,%d) is out of bounds (%d-%d,%d-%d)",
                                x, y,
                                X_BOUND_1, X_BOUND_2,
                                Y_BOUND_1, Y_BOUND_2).c_str());
    if (lua_isnumber(ls, 3))
        grd[x][y] = static_cast<dungeon_feature_type>(luaL_checkint(ls, 3));
    PLUARET(number, grd[x][y]);
}

    { "grid", dgn_grid },

            char *buf = new char[length + 1];

            char *buf = new char[length];

            buf[length] = 0;
            const std::string s = buf;

            const std::string s(buf, length);

    int loadbuffer(const char *buf, size_t size, const char *context);

#include "travel.h"

int CLua::loadstring(const char *s, const char *context)

int CLua::loadbuffer(const char *buf, size_t size, const char *context)

    const int err = luaL_loadbuffer(state(), s, strlen(s), context);

    const int err = luaL_loadbuffer(state(), buf, size, context);

int CLua::loadstring(const char *s, const char *context)
{
    return loadbuffer(s, strlen(s), context);
}

LUARET1(you_where, string, level_id::current().describe().c_str())

    { "where", you_where },