INSTALLDIR   := /usr/games

INSTALLDIR   := /usr/games/crawl

# SAVEDIR := /usr/games/crawl-saves/
# DATADIR := /usr/games/crawl-data/

# SAVEDIR := /usr/games/crawl/saves/
# DATADIR := /usr/games/crawl/data/

	$(COPY) $(GAME) ${INSTALLDIR}

	$(COPY) $(GAME) $(INSTALLDIR)

	mkdir -p $(DATADIR)/dat

	mkdir -p $(DATADIR)/dat/clua

	cp dat/clua/*.lua $(DATADIR)/dat/clua

	ln -s $(INSTALLDIR)/$(GAME) /usr/local/bin/

		mkdir $(INSTALLDIR)\dat\clua 2>null || echo "">nul

		copy /y dat\clua\*.lua $(INSTALLDIR)\dat\clua

std::string datafile_path(const std::string &basename,

std::string datafile_path(std::string basename,

std::string datafile_path(const std::string &basename,

std::string datafile_path(std::string basename,

#if FILE_SEPARATOR != '/'
    basename = replace_all_of(basename, "/", std::string(1, FILE_SEPARATOR));
#endif
    

        std::string("..")+FILE_SEPARATOR+std::string("docs")+FILE_SEPARATOR,

        std::string("..") + FILE_SEPARATOR + "docs" + FILE_SEPARATOR,

------------------------------------------------------------------
-- macro.lua:
-- Crawl macro framework for Lua.
--
-- Macros are called as Lua coroutines. If the macro yields false, the
-- coroutine is discarded (assuming an error). If the macro yields
-- true, Crawl will start a macro delay for the macro and call the
-- coroutine again next turn. If the macro just returns, the coroutine
-- is assumed to be done.
--
-- Why coroutines: Macros may need to perform actions that take
-- multiple turns, which requires control to return to Crawl to
-- perform world updates between actions. Coroutines are the simplest
-- way to pass control back and forth without losing the macro's
-- state.
------------------------------------------------------------------
function c_macro(fn)
   if fn == nil then
      if c_macro_coroutine ~= nil then
         local coret, mret
         coret, mret = coroutine.resume(c_macro_coroutine)
         if not coret or not mret then
            c_macro_coroutine = nil
            c_macro_name      = nil
         end
         if not coret and mret then
            error(mret)
         end
         return (coret and mret)
      end
      return false
   end
   if _G[fn] == nil or type(_G[fn]) ~= 'function' then
      return false
   end
   c_macro_name = fn
   c_macro_coroutine = coroutine.create(_G[fn]) 
   return c_macro() 
end

    int execfile(const char *filename);

    int execfile(const char *filename, bool trusted = false);

    static int loadfile(lua_State *ls, const char *file);
    static bool is_path_safe(const char *file);

    static int loadfile(lua_State *ls, const char *file, bool trusted = false);
    static bool is_path_safe(std::string file, bool trusted = false);

bool CLua::is_path_safe(const char *s)

bool CLua::is_path_safe(std::string s, bool trusted)

    return (!strstr(s, "..") && shell_safe(s));

    lowercase(s);
    return (s.find("..") == std::string::npos && shell_safe(s.c_str())
            && (trusted || s.find("clua") == std::string::npos));

int CLua::loadfile(lua_State *ls, const char *filename)

int CLua::loadfile(lua_State *ls, const char *filename, bool trusted)

    if (!is_path_safe(filename))

    if (!is_path_safe(filename, trusted))

int CLua::execfile(const char *filename)

int CLua::execfile(const char *filename, bool trusted)

    int err = loadfile(ls, filename);

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

    static const char *c_macro =
        "function c_macro(fn)"
        "    if fn == nil then"
        "        if c_macro_coroutine ~= nil then"
        "            local coret, mret"
        "            coret, mret = coroutine.resume(c_macro_coroutine)"
        "            if not coret or not mret then"
        "                c_macro_coroutine = nil"
        "                c_macro_name      = nil"
        "            end"
        "            if not coret and mret then"
        "                error(mret)"
        "            end"
        "            return (coret and mret)"
        "        end"
        "        return false"
        "    end"
        "    if _G[fn] == nil or type(_G[fn]) ~= 'function' then"
        "        return false"
        "    end"
        "    c_macro_name = fn"
        "    c_macro_coroutine = coroutine.create(_G[fn]) "
        "    return c_macro() "
        "end";
    execstring(c_macro, "base");

    execfile("clua/macro.lua", true);