| global_lua  {} 

                    
                    if (lc_run_global_prelude && !lc_global_prelude.empty())
                    {
                        lc_global_prelude.set_file(lc_desfile);
                        lc_run_global_prelude = false;
                        if (lc_global_prelude.load_call(dlua, NULL))
                            yyerror( lc_global_prelude.orig_error().c_str() );
                    }

global_lua        : MAIN global_lua_lines { }
global_lua_lines  : /* empty */ { }
                | global_lua_lines global_lua_line { }
                ;
global_lua_line   : LUA_LINE
                {
                    lc_global_prelude.add(yylineno, $1);
                }

extern dlua_chunk map_file_prelude;

extern dlua_chunk lc_global_prelude;
extern bool lc_run_global_prelude;

dlua_chunk lc_file_prelude;

// All global preludes.
std::vector<dlua_chunk> global_preludes;
// Map-specific prelude.
dlua_chunk lc_global_prelude("global_prelude");

bool lc_run_global_prelude = true;

    lc_file_prelude.clear();

    lc_global_prelude.clear();

    lc_run_global_prelude = true;

#define DESCACHE_VER  1000

#define DESCACHE_VER  1001

    FILE *inf = fopen((base + ".idx").c_str(), "rb");

    // If there's a global prelude, load that first.
    FILE *inf = fopen((base + ".lux").c_str(), "rb");
    if (inf)
    {
        lc_global_prelude.read(inf);
        fclose(inf);
        global_preludes.push_back( lc_global_prelude );
    }
    
    inf = fopen((base + ".idx").c_str(), "rb");
    if (!inf)
        end(1, true, "Unable to read %s", (base + ".idx").c_str());

    const std::string luafile = filebase + ".lua";
    if (lc_file_prelude.empty())

    const std::string luafile = filebase + ".lux";
    if (lc_global_prelude.empty())

    FILE *outf = fopen(luafile.c_str(), "w");
    if (!outf)
        end(1, true, "Unable to open %s for writing", luafile.c_str());
    fprintf(outf, "%s", lc_file_prelude.lua_string().c_str());

    FILE *outf = fopen(luafile.c_str(), "wb");
    lc_global_prelude.write(outf);

    global_preludes.push_back( lc_global_prelude );

    for (int i = 0, size = global_preludes.size(); i < size; ++i)
    {
        dlua_chunk &chunk = global_preludes[i];
        if (!chunk.empty())
        {
            if (chunk.load_call(dlua, NULL))
                mprf(MSGCH_WARN, "Lua error: %s", chunk.orig_error().c_str());
        }
    }

// Lua chunks cannot exceed 512K. Which is plenty!
const int LUA_CHUNK_MAX_SIZE = 512 * 1024;
    

    writeString(outf, prelude.lua_string(), LUA_CHUNK_MAX_SIZE);
    writeString(outf, main.lua_string(), LUA_CHUNK_MAX_SIZE);

    prelude.write(outf);
    main.write(outf);

    prelude.set_chunk(readString(inf, LUA_CHUNK_MAX_SIZE));
    main.set_chunk(readString(inf, LUA_CHUNK_MAX_SIZE));

    prelude.read(inf);
    main.read(inf);

    writeString(outf, prelude.lua_string(), LUA_CHUNK_MAX_SIZE);

    prelude.write(outf);

    prelude.set_chunk(readString(inf, LUA_CHUNK_MAX_SIZE));

    prelude.read(inf);

    int err = prelude.load(&dlua);

    int err = prelude.load(dlua);

        err = main.load(&dlua);

        err = main.load(dlua);

// Lua chunks cannot exceed 512K. Which is plenty!
const int LUA_CHUNK_MAX_SIZE = 512 * 1024;

    std::string error;

    mutable std::string error;

    int load(CLua *interp);
    int load_call(CLua *interp, const char *function);

    int load(CLua &interp);
    int load_call(CLua &interp, const char *function);

    void write(FILE *) const;
    void read(FILE *);

#include "files.h"

}
void dlua_chunk::write(FILE *outf) const
{
    writeString(outf, chunk, LUA_CHUNK_MAX_SIZE);
    if (!chunk.empty())
    {
        writeString(outf, file);
        writeLong(outf, first);
    }
}
void dlua_chunk::read(FILE *inf)
{
    chunk = readString(inf, LUA_CHUNK_MAX_SIZE);
    if (!chunk.empty())
    {
        file  = readString(inf);
        first = readLong(inf);
    }

int dlua_chunk::load(CLua *interp)

int dlua_chunk::load(CLua &interp)

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

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

int dlua_chunk::load_call(CLua *interp, const char *fn)

int dlua_chunk::load_call(CLua &interp, const char *fn)

    return check_op(interp, interp->callfn(fn, 1, 0));

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

    rewrite_chunk_errors(error);

    
    lua_getglobal(ls, fn);
    if (!lua_isfunction(ls, -1))

    // If a function is not provided on the stack, get the named function.
    if (fn)

        lua_settop(ls, -nargs - 2);
        return (false);

        lua_getglobal(ls, fn);
        if (!lua_isfunction(ls, -1))
        {
            lua_settop(ls, -nargs - 2);
            return (false);
        }
        
        // Slide the function in front of its args and call it.
        if (nargs)
            lua_insert(ls, -nargs - 1);

    // Slide the function in front of its args and call it.
    if (nargs)
        lua_insert(ls, -nargs - 1);