crawl-ref/source/dlua.cc

   1 /*
   2  *  File:       dlua.cc
   3  *  Summary:    Dungeon-builder Lua interface.
   4  *  Created by: dshaligram on Sat Jun 23 20:02:09 2007 UTC
   5  */
   6
   7 #include "AppHdr.h"
   8
   9 #include <sstream>
  10
  11 #include "dlua.h"
  12 #include "l_libs.h"
  13 #include "libutil.h"
  14 #include "tags.h"
  15
  16 static int dlua_compiled_chunk_writer(lua_State *ls, const void *p,
  17                                       size_t sz, void *ud)
  18 {
  19     std::ostringstream &out = *static_cast<std::ostringstream*>(ud);
  20     out.write(static_cast<const char *>(p), sz);
  21     return (0);
  22 }
  23
  24 ///////////////////////////////////////////////////////////////////////////
  25 // dlua_chunk
  26
  27 dlua_chunk::dlua_chunk(const std::string &_context)
  28     : file(), chunk(), compiled(), context(_context), first(-1),
  29       last(-1), error()
  30 {
  31     clear();
  32 }
  33
  34 // Initialises a chunk from the function on the top of stack.
  35 // This function must not be a closure, i.e. must not have any upvalues.
  36 dlua_chunk::dlua_chunk(lua_State *ls)
  37     : file(), chunk(), compiled(), context(), first(-1), last(-1), error()
  38 {
  39     clear();
  40
  41     lua_stack_cleaner cln(ls);
  42     std::ostringstream out;
  43     const int err = lua_dump(ls, dlua_compiled_chunk_writer, &out);
  44     if (err)
  45     {
  46         const char *e = lua_tostring(ls, -1);
  47         error = e? e : "Unknown error compiling chunk";
  48     }
  49     compiled = out.str();
  50 }
  51
  52 dlua_chunk dlua_chunk::precompiled(const std::string &_chunk)
  53 {
  54     dlua_chunk dchunk;
  55     dchunk.compiled = _chunk;
  56     return (dchunk);
  57 }
  58
  59 std::string dlua_chunk::describe(const std::string &name) const
  60 {
  61     if (chunk.empty())
  62         return "";
  63     return make_stringf("function %s()\n%s\nend\n",
  64                         name.c_str(), chunk.c_str());
  65 }
  66
  67 void dlua_chunk::write(writer& outf) const
  68 {
  69     if (empty())
  70     {
  71         marshallByte(outf, CT_EMPTY);
  72         return;
  73     }
  74
  75     if (!compiled.empty())
  76     {
  77         marshallByte(outf, CT_COMPILED);
  78         marshallString4(outf, compiled);
  79     }
  80     else
  81     {
  82         marshallByte(outf, CT_SOURCE);
  83         marshallString4(outf, chunk);
  84     }
  85
  86     marshallString4(outf, file);
  87     marshallInt(outf, first);
  88 }
  89
  90 void dlua_chunk::read(reader& inf)
  91 {
  92     clear();
  93     chunk_t type = static_cast<chunk_t>(unmarshallByte(inf));
  94     switch (type)
  95     {
  96     case CT_EMPTY:
  97         return;
  98     case CT_SOURCE:
  99         unmarshallString4(inf, chunk);
 100         break;
 101     case CT_COMPILED:
 102         unmarshallString4(inf, compiled);
 103         break;
 104     }
 105     unmarshallString4(inf, file);
 106     first = unmarshallInt(inf);
 107 }
 108
 109 void dlua_chunk::clear()
 110 {
 111     file.clear();
 112     chunk.clear();
 113     first = last = -1;
 114     error.clear();
 115     compiled.clear();
 116 }
 117
 118 void dlua_chunk::set_file(const std::string &s)
 119 {
 120     file = s;
 121 }
 122
 123 void dlua_chunk::add(int line, const std::string &s)
 124 {
 125     if (first == -1)
 126         first = line;
 127
 128     if (line != last && last != -1)
 129         while (last++ < line)
 130             chunk += '\n';
 131
 132     chunk += " ";
 133     chunk += s;
 134     last = line;
 135 }
 136
 137 void dlua_chunk::set_chunk(const std::string &s)
 138 {
 139     chunk = s;
 140 }
 141
 142 int dlua_chunk::check_op(CLua &interp, int err)
 143 {
 144     error = interp.error;
 145     return (err);
 146 }
 147
 148 int dlua_chunk::load(CLua &interp)
 149 {
 150     if (!compiled.empty())
 151         return check_op(interp,
 152                          interp.loadbuffer(compiled.c_str(), compiled.length(),
 153                                            context.c_str()));
 154
 155     if (empty())
 156     {
 157         chunk.clear();
 158         return (E_CHUNK_LOAD_FAILURE);
 159     }
 160
 161     int err = check_op(interp,
 162                         interp.loadstring(chunk.c_str(), context.c_str()));
 163     if (err)
 164         return (err);
 165     std::ostringstream out;
 166     err = lua_dump(interp, dlua_compiled_chunk_writer, &out);
 167     if (err)
 168     {
 169         const char *e = lua_tostring(interp, -1);
 170         error = e? e : "Unknown error compiling chunk";
 171         lua_pop(interp, 2);
 172     }
 173     compiled = out.str();
 174     return (err);
 175 }
 176
 177 int dlua_chunk::run(CLua &interp)
 178 {
 179     int err = load(interp);
 180     if (err)
 181         return (err);
 182     // callfn returns true on success, but we want to return 0 on success.
 183     return (check_op(interp, !interp.callfn(NULL, 0, 0)));
 184 }
 185
 186 int dlua_chunk::load_call(CLua &interp, const char *fn)
 187 {
 188     int err = load(interp);
 189     if (err == E_CHUNK_LOAD_FAILURE)
 190         return (0);
 191     if (err)
 192         return (err);
 193
 194     return check_op(interp, !interp.callfn(fn, fn? 1 : 0, 0));
 195 }
 196
 197 std::string dlua_chunk::orig_error() const
 198 {
 199     rewrite_chunk_errors(error);
 200     return (error);
 201 }
 202
 203 bool dlua_chunk::empty() const
 204 {
 205     return compiled.empty() && trimmed_string(chunk).empty();
 206 }
 207
 208 bool dlua_chunk::rewrite_chunk_errors(std::string &s) const
 209 {
 210     const std::string contextm = "[string \"" + context + "\"]:";
 211     std::string::size_type dlwhere = s.find(contextm);
 212
 213     if (dlwhere == std::string::npos)
 214         return (false);
 215
 216     if (!dlwhere)
 217     {
 218         s = rewrite_chunk_prefix(s);
 219         return (true);
 220     }
 221
 222     // Our chunk is mentioned, go back through and rewrite lines.
 223     std::vector<std::string> lines = split_string("\n", s);
 224     std::string newmsg = lines[0];
 225     bool wrote_prefix = false;
 226     for (int i = 2, size = lines.size() - 1; i < size; ++i)
 227     {
 228         const std::string &st = lines[i];
 229         if (st.find(context) != std::string::npos)
 230         {
 231             if (!wrote_prefix)
 232             {
 233                 newmsg = get_chunk_prefix(st) + ": " + newmsg;
 234                 wrote_prefix = true;
 235             }
 236             else
 237                 newmsg += "\n" + rewrite_chunk_prefix(st);
 238         }
 239     }
 240     s = newmsg;
 241     return (true);
 242 }
 243
 244 std::string dlua_chunk::rewrite_chunk_prefix(const std::string &line,
 245                                              bool skip_body) const
 246 {
 247     std::string s = line;
 248     const std::string contextm = "[string \"" + context + "\"]:";
 249     const std::string::size_type ps = s.find(contextm);
 250     if (ps == std::string::npos)
 251         return (s);
 252
 253     const std::string::size_type lns = ps + contextm.length();
 254     std::string::size_type pe = s.find(':', ps + contextm.length());
 255     if (pe != std::string::npos)
 256     {
 257         const std::string line_num = s.substr(lns, pe - lns);
 258         const int lnum = atoi(line_num.c_str());
 259         const std::string newlnum = make_stringf("%d", lnum + first - 1);
 260         s = s.substr(0, lns) + newlnum + s.substr(pe);
 261         pe = lns + newlnum.length();
 262     }
 263
 264     return s.substr(0, ps) + (file.empty()? context : file) + ":"
 265         + (skip_body? s.substr(lns, pe - lns)
 266                     : s.substr(lns));
 267 }
 268
 269 std::string dlua_chunk::get_chunk_prefix(const std::string &sorig) const
 270 {
 271     return rewrite_chunk_prefix(sorig, true);
 272 }
 273
 274 static void _dlua_register_constants(CLua &lua)
 275 {
 276     lua_pushstring(lua, CORPSE_NEVER_DECAYS);
 277     lua.setglobal("CORPSE_NEVER_DECAYS");
 278 }
 279
 280 void init_dungeon_lua()
 281 {
 282     lua_stack_cleaner clean(dlua);
 283
 284     dluaopen_colour(dlua);
 285     dluaopen_crawl(dlua);
 286     dluaopen_file(dlua);
 287     dluaopen_mapgrd(dlua);
 288     dluaopen_monsters(dlua);
 289     dluaopen_you(dlua);
 290     dluaopen_dgn(dlua);
 291
 292     luaL_openlib(dlua, "feat", feat_dlib, 0);
 293     luaL_openlib(dlua, "spells", spells_dlib, 0);
 294     luaL_openlib(dlua, "debug", debug_dlib, 0);
 295     luaL_openlib(dlua, "los", los_dlib, 0);
 296
 297     dlua.execfile("clua/dungeon.lua", true, true);
 298     dlua.execfile("clua/luamark.lua", true, true);
 299     dlua.execfile("clua/mapinit.lua", true, true);
 300
 301     lua_getglobal(dlua, "dgn_run_map");
 302     luaopen_debug(dlua);
 303     luaL_newmetatable(dlua, MAP_METATABLE);
 304
 305     luaopen_dgnevent(dlua);
 306     luaopen_mapmarker(dlua);
 307     luaopen_ray(dlua);
 308
 309     register_itemlist(dlua);
 310     register_monslist(dlua);
 311
 312     _dlua_register_constants(dlua);
 313 }