Gammon Forum

extern "C" int luaCHSend(lua_State * L);

static const luaL_reg luaMudlib[] =
{
        {"send_to_char", luaCHSend},
        {NULL, NULL}
};

extern "C" int luaRegisterMudlib(lua_State * L)
{
        int i = 0;
        while (luaMudlib[i].name != NULL && luaMudlib[i].func != NULL)
        {
                lua_register(L, luaMudlib[i].name, luaMudlib[i].func);
                i++;
        }
        return RET_OK;
}

int luaOpen()
{
        // Create a new Lua state.
        g_luaState = luaL_newstate();
        if (!g_luaState)
        {
                log_lua("luaOpen: Failed to create lua_State!");
                return RET_ERR;
        }
        // Load standard libraries.
        luaL_openlibs(g_luaState);
        // Load mud library.
        lua_pushcfunction(g_luaState, luaRegisterMudlib);
        lua_call(g_luaState, 0, 0);
// None of these methods work?
//      luaRegisterMudlib(g_luaState);
//      luaL_register(g_luaState, "mud", luaMudlib);
        // Load mud interfaces.
//      luaRegisterCH(g_luaState);
//      luaRegisterRoom(g_luaState);
//      luaRegisterObj(g_luaState);

        lua_settop(g_luaState, 0);

        return RET_OK;
}

void lua_command(CHAR_DATA * ch, const char * command, const char * argument)
{
   char path[MAX_INPUT_LENGTH];
   char func[MAX_INPUT_LENGTH];
   int err;

   if (!g_luaState)
   {
      log_lua("lua_command: FATAL error: g_luaState == NULL!");
      return;
   }

   snprintf(path, MAX_INPUT_LENGTH, "%sdo_%s.lua", LUA_CMD_DIR, command);
   if ((err = luaL_loadfile(g_luaState, path)) != 0)
   {
      log_lua("lua_command: luaL_loadfile() error %d: %s", err, lua_tostring(g_luaState, -1));
      return;
   }

   snprintf(func, MAX_INPUT_LENGTH, "do_%s", command);
   lua_getglobal(g_luaState, func); // Get name of Lua func
   lua_pushlightuserdata(g_luaState, (void*)ch->GetId().Value()); // Push character ID
   lua_pushstring(g_luaState, argument); // Push argument
   if ((err = lua_pcall(g_luaState, 3, 0, 0)) != 0)
   {
      log_lua("lua_command: lua_pcall() error: %d: %s", err, lua_tostring(g_luaState, -1));
      return;
   }

   return;
}

extern "C" int luaCHSend(lua_State * L)
{
        CHAR_DATA * ch;
        const char * arg;
        char buf[MAX_STRING_LENGTH];
        uint64 id;
bug("luaCHSend"); // Just to see if we ever make it here, which we aren't...
        if (!L)
        {
                log_lua("luaCHSend: FATAL error: L == NULL");
                return 0;
        }

        if (lua_gettop(L) != 2)
        {
                log_lua("luaCHSend: Invalid number of arguments.");
                luaL_error(L, "luaCHSend: Invalid number of arguments.");
                return 0;
        }

        id = (uint64) lua_touserdata(L, -2);
        ch = char_map[id];
        if (ch == NULL)
        {
                log_lua("luaCHSend: NULL ch.");
                luaL_error(L, "luaCHSend: NULL ch.");
                return 0;
        }

        if (IS_NPC(ch))
                return 0;

        arg = lua_tostring(L, -1);
        if (arg == NULL)
        {
                log_lua("luaCHSend: NULL argument.");
                luaL_error(L, "luaCHSend: NULL argument.");
                return 0;
        }

        snprintf(buf, MAX_STRING_LENGTH, "%s\n\r", arg);

        send_to_char(buf, ch);

        return 0;
}

--- do_lua_test, function to test the lua implementation

function do_lua_test(ch, argument)
    --- NEITHER of these don't get called. At least one should be?
    mud.send(ch, "This is a test!")
    send(ch, "Another test!")
    return
end

static int RegisterLuaRoutines (lua_State *L)
  {

  lua_newtable (L);  /* environment */
  lua_replace (L, LUA_ENVIRONINDEX);

  /* this makes environment variable "character.state" by the pointer to our character */
  lua_settable(L, LUA_ENVIRONINDEX);

  /* register all mud.xxx routines */
  luaL_register (L, MUD_LIBRARY, mudlib);
  
  /* using interpret now
  RegisterLuaCommands (L);
  */

  luaopen_bits (L);     /* bit manipulation */

  return 0;
  
}  /* end of RegisterLuaRoutines */

void open_lua  ( CHAR_DATA * ch)
  {
  lua_State *L = luaL_newstate ();   /* opens Lua */
  ch->L = L;
  
  if (ch->L == NULL)
    {
    fprintf( stderr, "Cannot open Lua state\n");
    return;  /* catastrophic failure */
    }

  luaL_openlibs (L);    /* open all standard libraries */

  /* call as Lua function because we need the environment  */
  lua_pushcfunction(L, RegisterLuaRoutines);
  lua_pushstring(L, CHARACTER_STATE);  /* push address */
  lua_pushlightuserdata(L, (void *)ch);    /* push value */
  lua_call(L, 2, 0);
 
  /* run initialiation script */
  if (luaL_loadfile (L, LUA_STARTUP) ||
      CallLuaWithTraceBack (L, 0, 0))
      {
      const char * sError = lua_tostring(L, -1);
      
      fprintf( stderr, "Error loading Lua startup file:\n %s\n", 
              sError);
      
      if (IS_IMMORTAL(ch))
        {
        set_char_color( AT_YELLOW, ch );
        ch_printf (ch, "Error loading Lua startup file:\n %s\n", 
                  sError); 
        }  /* end of immortal */

      }

  lua_settop (L, 0);    /* get rid of stuff lying around */
        
  }  /* end of open_lua */

   if ((err = lua_pcall(g_luaState, 3, 0, 0)) != 0)

   if ((err = lua_pcall(g_luaState, 2, 0, 0)) != 0)

Lua: lua_command: lua_pcall() error: 2: attempt to call a nil value
   Path: ../lua/commands/do_lua_test.lua

   snprintf(func, MAX_INPUT_LENGTH, "do_%s", command);
   lua_getglobal(g_luaState, func);
   if (!lua_isfunction(g_luaState, -1))
   {
      lua_pop(g_luaState, -1);
      log_lua("lua_command: Function not found: %s", func);
      return;
   }

   if ((err = luaL_loadfile(g_luaState, path)) != 0)
   {
      log_lua("lua_command: luaL_loadfile() error %d: %s\n\r   Path: %s", err, lua_tostring(g_luaState, -1), path);
      return;
   }

   if ((err = luaL_dofile(g_luaState, path)) != 0)
   {
      log_lua("lua_command: luaL_dofile() error %d: %s\n\r   Path: %s", err, lua_tostring(g_luaState, -1), path);
      return;
   }

Lua: lua_command: lua_pcall() error: 2: ../lua/commands/do_lua_test.lua:5: attempt to call global 'send' (a nil value)
   Path: ../lua/commands/do_lua_test.lua

-- do_lua_test, function to test the lua implementation

function send(char, ...)
    send_to_char(char.id, table.concat {...} .. "\n\r")
   return
end -- send

function do_lua_test(ch, argument)
   if argument then
      send(ch, "&RYou typed: " .. argument)
   end
   send(ch, "&GYour name is " .. ch.name .. ", and you are a " .. ch.gender .. " " .. ch.race .. ".")
   och = get_char_world(ch, "tech")
   if och then
      send(ch, "&YWe found: " .. och.name)
   end
   ch:say("Testing")
   return
end -- do_lua_test

lua_test Some arg
You typed: Some arg
Your name is Kasji, and you are a male Noghri.
We found: a skittish verpine tech
You say, "Testing"

#include <stdio.h>
#include <string.h>
#include <time.h>
#include <setjmp.h>
#include "mud.h"
#include "lua.h"

extern lua_State * g_luaState;
extern jmp_buf g_luaEnv;
extern tPointerOwner<L_COROUTINE> coroutine_map;

DECLARE_LUA_FUN(luaPanic);

lua_coroutine::lua_coroutine(const char * type, uint64 id) : tObject<L_COROUTINE>(coroutine_map)
{
   clock_gettime(CLOCK_MONOTONIC, &(this->m_created));
   snprintf(this->m_owner_type, 10, "%s", type);
   this->m_owner_id = id;
   if (g_luaState)
   {
      this->m_L = lua_newthread(g_luaState);
      lua_atpanic(this->m_L, luaPanic);
   }
   else
      this->m_L = NULL;
   this->m_state = 0;
   this->m_started = FALSE;
   return;
}

lua_coroutine::~lua_coroutine()
{
}

int lua_coroutine::run(const char * funcname, int nargs)
{
   int jmp;

   jmp = setjmp(g_luaEnv);
   if (jmp == 1)
   {
      log_lua("Long jump successful.");
      return 0;
   }

   snprintf(this->m_func, 32, "%s", funcname);

   lua_getglobal(this->m_L, funcname);
   if (!lua_isfunction(this->m_L, -1))
   {
      log_lua("lua_coroutine::run: Function not found: %s", funcname);
//      lua_settop(g_luaState, 0);
      return 1;
   }
   if (nargs > 0)
      lua_insert(this->m_L, (-1 - nargs));

   this->m_state = lua_resume(this->m_L, nargs);
   this->m_started = TRUE;
   return this->m_state;
}

int lua_coroutine::resume()
{
   int jmp;

   if (this->m_started == FALSE || this->m_state != LUA_YIELD)
      return 0;

   jmp = setjmp(g_luaEnv);
   if (jmp == 1)
   {
      log_lua("Long jump successful.");
      return 0;
   }

   // If coroutine.yield returned any values, they need to be popped.
// while (lua_gettop(this->m_L) > (1 + this->m_nargs))
//    lua_pop(this->m_L, -1);

   this->m_state = lua_resume(this->m_L, 0);
   return this->m_state;
}

int lua_coroutine::status()
{
   if (this->m_L)
      this->m_state = lua_status(this->m_L);
   return this->m_state;
}

bool lua_coroutine::started()
{
   return this->m_started;
}

const timespec& lua_coroutine::created()
{
   return this->m_created;
}

uint64 lua_coroutine::owner_id()
{
   return this->m_owner_id;
}

const char * lua_coroutine::owner_type()
{
   return this->m_owner_type;
}

lua_State * lua_coroutine::L()
{
   return this->m_L;
}

const char * lua_coroutine::func()
{
   return this->m_func;
}

bool lua_coroutine::operator==(const lua_coroutine &rhs)
{
   return this->GetId().Value() == rhs.GetId().Value();
}

         {
            msg = lua_tostring(cor->L(), -1);
            log_lua("lua_updater::update(): %d: %s\n\r    Owner Type: %s  Owner ID: %llu", status, msg, cor->owner_type(), cor->owner_id());
         }
         it = this->killthread(it);
         continue;
      }
   }

   return;
}

L_COROUTINE * lua_updater::newthread(const char * type, uint64 id)
{
   L_COROUTINE * cor = new L_COROUTINE(type, id);
   this->m_coroutine_list.push_back(cor->GetId().Value());

   return cor;
}

void lua_updater::killthread(uint64 id)
{
   delete coroutine_map[id];
   this->m_coroutine_list.remove(id);
   return;
}

L_COR_IT lua_updater::killthread(L_COR_IT it)
{
   delete coroutine_map[(*it)];
   return this->m_coroutine_list.erase(it);
}

void lua_update()
{
   g_luaUpdater->update();

   return;
}

#0  0x00002b935acbd999 in ?? () from /usr/lib64/liblua-5.1.so
#1  0x00002b935acbd137 in ?? () from /usr/lib64/liblua-5.1.so
#2  0x00002b935acbd31a in lua_resume () from /usr/lib64/liblua-5.1.so
#3  0x000000000060faa0 in lua_coroutine::resume (this=0xd0ff800) at lua_coroutine.c:84
#4  0x0000000000619dfe in lua_updater::update (this=0xcf19740) at lua_update.c:37
#5  0x000000000061a093 in lua_update () at lua_update.c:84
#6  0x000000000060c0cc in update_handler () at update.c:2775
#7  0x00000000004d18bb in game_loop () at comm.c:580
#8  0x00000000004d0912 in main (argc=5, argv=0x7fff6861d488) at comm.c:252

function sleep(ch, seconds)
   local start = mud:time()

   while mud:time() - start < seconds do
      coroutine.yield()
   end
   return
end -- sleep