&& death_type != KILLED_BY_WATER)

        && death_type != KILLED_BY_WATER)

            mpr(clua.error.c_str());

            mprf(MSGCH_WARN, "Lua error: %s", clua.error.c_str());

#ifndef CLUA_MAX_MEMORY_USE
#define CLUA_MAX_MEMORY_USE (6 * 1024)
#endif

    bool shutting_down;

    long memory_used;

#include "files.h"

#ifdef HASH_CONTAINERS
#   include <hash_map>
#   define CHMAP HASH_CONTAINER_NS::hash_map
#else
#   include <map>
#   define CHMAP std::map
#endif

#include <map>

static void *clua_allocator(void *ud, void *ptr, size_t osize, size_t nsize);

static int clua_panic(lua_State *);

    : error(), managed_vm(managed), throttle_unit_lines(10000),

    : error(), managed_vm(managed), shutting_down(false),
      throttle_unit_lines(10000),

      max_lua_call_depth(100), _state(NULL), sourced_files(), uniqindex(0L)

      max_lua_call_depth(100), memory_used(0),
      _state(NULL), sourced_files(), uniqindex(0L)

    shutting_down = true;

    _state = lua_open();

    _state = managed_vm? lua_newstate(clua_allocator, this) : luaL_newstate();

    lua_atpanic(_state, clua_panic);
    

typedef CHMAP<std::string, text_pattern> pattern_map;

typedef std::map<std::string, text_pattern> pattern_map;

    return pattern_cache[s];

    return (pattern_cache[s]);

// A panic function for the Lua interpreter, usually called when it
// runs out of memory when trying to load a file or a chunk of Lua from
// an unprotected Lua op. The only cases of unprotected Lua loads are
// loads of Lua code from .crawlrc, which is read at start of game.
//
// If there's an inordinately large .crawlrc (we're talking seriously
// massive here) that wants more memory than we're willing to give
// Lua, then the game will save and exit until the .crawlrc is fixed.
//
// Lua can also run out of memory during protected script execution,
// such as when running a macro or some other game hook, but in such
// cases the Lua interpreter will throw an exception instead of
// panicking.
//
static int clua_panic(lua_State *ls)
{
    if (crawl_state.need_save && !crawl_state.saving_game
        && !crawl_state.updating_scores)
    {
        save_game(true);
    }
    return (0);
}
static void *clua_allocator(void *ud, void *ptr, size_t osize, size_t nsize)
{
    CLua *cl = static_cast<CLua *>( ud );
    cl->memory_used += nsize - osize;
    if (nsize > osize && cl->memory_used >= CLUA_MAX_MEMORY_USE * 1024
           && cl->mixed_call_depth)
        return (NULL);
    
    if (!nsize)
    {
        free(ptr);
        return (NULL);
    }
    else
        return (realloc(ptr, nsize));
}

            simple_god_message( " says: Let disbelievers drown in blood!" );

            simple_god_message(
                " says: Drown the unbelievers in a sea of blood!");

#if defined(GCC)
#   define HASH_CONTAINER_NS __gnu_cxx
#   define HASH_CONTAINERS
#endif
// Uncomment to enable the Crawl Lua bindings. You can also set this in your
// makefile by adding -DCLUA_BINDINGS to the CFLAGS line (this is preferred to
// editing AppHdr.h directly).

// Uncomment to enable the Crawl Lua bindings. You can also set this
// in your makefile by adding -DCLUA_BINDINGS to the CFLAGS line (this
// is preferred to editing AppHdr.h directly).

// The maximum memory that the user-script Lua interpreter can
// allocate, in kilobytes. This limit is enforced to prevent
// badly-written or malicious user scripts from consuming too much
// memory.
//
#define CLUA_MAX_MEMORY_USE (2 * 1024)