add legacy subdir for mods with 5.1 edition of mod_lua, change languages/mod_lua…

add legacy subdir for mods with 5.1 edition of mod_lua, change languages/mod_lua to legacy/languages/mod_lua in modules.conf to use older lua mod

build/swigall.sh

@@ -3,6 +3,11 @@ make swigclean
 make lua_wrap
 cd ../../../..
 
+cd src/mod/legacy/languages/mod_lua
+make swigclean
+make lua_wrap
+cd ../../../..
+
 cd src/mod/languages/mod_perl
 make swigclean
 make mod_perl_wrap.cpp

configure.in

@@ -1159,6 +1159,7 @@ AC_CONFIG_FILES([Makefile
 		src/mod/asr_tts/mod_unimrcp/Makefile
 		src/mod/languages/mod_java/Makefile
 		src/mod/languages/mod_lua/Makefile
+		src/mod/legacy/languages/mod_lua/Makefile
 		src/mod/languages/mod_python/Makefile
 		src/mod/languages/mod_spidermonkey/Makefile
 		src/mod/event_handlers/mod_erlang_event/Makefile

src/mod/legacy/languages/mod_lua/Makefile.am

+VERBOSE=1
+include $(top_srcdir)/build/modmake.rulesam
+
+MODNAME=mod_lua
+
+LIBLUA_A=lua/liblua.a
+
+AM_CFLAGS += $(CFLAGS) -D_GNU_SOURCE
+mod_LTLIBRARIES = mod_lua.la
+mod_lua_la_SOURCES = mod_lua.cpp freeswitch_lua.cpp mod_lua_wrap.cpp
+mod_lua_la_CXXFLAGS = -Ilua $(AM_CPPFLAGS)
+mod_lua_la_LIBADD = $(switch_builddir)/libfreeswitch.la 
+mod_lua_la_LDFLAGS = -avoid-version -module -no-undefined -shared -lm $(AM_LDFLAGS) $(LIBLUA_A) $(SOLINK)
+
+BUILT_SOURCES = $(LIBLUA_A)
+$(mod_lua_la_SOURCES) : $(BUILT_SOURCES)
+
+$(LIBLUA_A):
+	cd lua && $(MAKE) CC="$(CC)" AR="$(AR) rcu" CFLAGS="$(AM_CFLAGS) -DLUA_USE_LINUX -w" liblua.a
+
+reswig: swigclean lua_wrap
+
+luaclean:
+	cd lua && $(MAKE) clean
+
+allclean: clean luaclean
+
+swigclean: clean
+	rm -f mod_lua_wrap.*
+
+lua_wrap: mod_lua_extra.c
+	swig -lua -c++ -I../../../../src/include -oh mod_lua_wrap.h -o mod_lua_wrap.cpp freeswitch.i
+	echo "#include \"mod_lua_extra.c\"" >> mod_lua_wrap.cpp
+	patch -s -p0 -i hack.diff
+

src/mod/legacy/languages/mod_lua/freeswitch.i

+%module freeswitch
+%include ../../../../swig_common.i
+//%include "cstring.i"
+
+/** 
+ * tell swig to treat these variables as mutable so they
+ * can be used to return values.
+ * See http://www.swig.org/Doc1.3/Library.html
+ */
+//%cstring_bounded_mutable(char *dtmf_buf, 128);
+//%cstring_bounded_mutable(char *terminator, 8);
+
+
+/** insert the following includes into generated code so it compiles */
+%{
+#include "switch.h"
+#include "switch_cpp.h"
+#include "freeswitch_lua.h"
+%}
+
+
+/* Lua function typemap */
+%typemap(in, checkfn = "lua_isfunction") SWIGLUA_FN {
+  $1.L = L;
+  $1.idx = $input;
+}
+
+%typemap(default) SWIGLUA_FN {
+  SWIGLUA_FN default_swiglua_fn = { 0 };
+  $1 = default_swiglua_fn;
+}
+
+
+%ignore SwitchToMempool;   
+%newobject EventConsumer::pop;
+%newobject Session;
+%newobject CoreSession;
+%newobject Event;
+%newobject Stream;
+%newobject Dbh;
+
+/**
+ * tell swig to grok everything defined in these header files and
+ * build all sorts of c wrappers and lua shadows of the c wrappers.
+ */
+%include switch_swigable_cpp.h
+
+
+namespace LUA {
+class Session : public CoreSession {
+ private:
+	virtual void do_hangup_hook();
+	lua_State *getLUA();
+	lua_State *L;
+	int hh;
+	int mark;
+ public:
+    Session();
+    Session(char *uuid, CoreSession *a_leg = NULL);
+    Session(switch_core_session_t *session);
+    ~Session();        
+	virtual void destroy(const char *err = NULL);
+	
+	virtual bool begin_allow_threads();
+	virtual bool end_allow_threads();
+	virtual void check_hangup_hook();
+
+	virtual switch_status_t run_dtmf_callback(void *input, switch_input_type_t itype);
+	void unsetInputCallback(void);
+	void setInputCallback(char *cbfunc, char *funcargs = NULL);
+	void setHangupHook(char *func, char *arg = NULL);
+	bool ready();
+	int originate(CoreSession *a_leg_session, char *dest, int timeout);
+	
+	char *cb_function;
+	char *cb_arg;
+	char *hangup_func_str;
+	char *hangup_func_arg;
+	void setLUA(lua_State *state);
+
+};
+
+class Dbh {
+  private:
+    switch_cache_db_handle_t *dbh;
+    bool m_connected;
+    static int query_callback(void *pArg, int argc, char **argv, char **cargv);
+  public:
+    Dbh(char *dsn, char *user = NULL, char *pass = NULL);
+    ~Dbh();
+    bool release();
+    bool connected();
+    bool test_reactive(char *test_sql, char *drop_sql = NULL, char *reactive_sql = NULL);
+    bool query(char *sql, SWIGLUA_FN lua_fun);
+    int affected_rows();
+    int load_extension(const char *extension);
+};
+
+}
+

src/mod/legacy/languages/mod_lua/freeswitch_lua.cpp

+
+#include <switch.h>
+#include "freeswitch_lua.h"
+using namespace LUA;
+
+extern "C" {
+	int docall(lua_State * L, int narg, int nresults, int perror);
+};
+
+Session::Session():CoreSession()
+{
+	cb_function = cb_arg = hangup_func_str = hangup_func_arg = NULL;
+	hh = mark = 0;
+}
+
+Session::Session(char *nuuid, CoreSession *a_leg):CoreSession(nuuid, a_leg)
+{
+	cb_function = cb_arg = hangup_func_str = hangup_func_arg = NULL;
+	hh = mark = 0;
+}
+
+Session::Session(switch_core_session_t *new_session):CoreSession(new_session)
+{
+	cb_function = cb_arg = hangup_func_str = hangup_func_arg = NULL;
+	hh = mark = 0;
+}
+static switch_status_t lua_hanguphook(switch_core_session_t *session_hungup);
+
+
+void Session::destroy(const char *err)
+{
+	
+	if (!allocated) {
+		return;
+	}
+
+	if (session) {
+		if (!channel) {
+			channel = switch_core_session_get_channel(session);
+		}
+		switch_channel_set_private(channel, "CoreSession", NULL);
+		switch_core_event_hook_remove_state_change(session, lua_hanguphook);
+	}
+
+	switch_safe_free(hangup_func_str);
+	switch_safe_free(hangup_func_arg);
+	switch_safe_free(cb_function);
+	switch_safe_free(cb_arg);
+
+	CoreSession::destroy();
+
+
+	if (!zstr(err)) {
+		lua_pushstring(L, err);
+		lua_error(L);
+	}
+
+}
+
+
+Session::~Session()
+{
+	destroy();
+}
+
+bool Session::begin_allow_threads()
+{
+	do_hangup_hook();
+	return true;
+}
+
+bool Session::end_allow_threads()
+{
+	do_hangup_hook();
+	return true;
+}
+
+void Session::setLUA(lua_State * state)
+{
+	L = state;
+
+	if (session && allocated && uuid) {
+		lua_setglobal(L, uuid);
+		lua_getfield(L, LUA_GLOBALSINDEX, uuid);
+	}
+
+}
+
+int Session::originate(CoreSession *a_leg_session, char *dest, int timeout)
+{
+	int x = CoreSession::originate(a_leg_session, dest, timeout);
+
+	if (x) {
+		setLUA(L);
+	}
+
+	return x;
+}
+
+lua_State *Session::getLUA()
+{
+	if (!L) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Doh!\n");
+	}
+	return L;
+}
+
+
+bool Session::ready()
+{
+	bool r;
+
+	if (!session) {
+		return false;
+	}
+	sanity_check(false);
+	r = switch_channel_ready(channel) != 0;
+	do_hangup_hook();
+
+	return r;
+}
+
+void Session::check_hangup_hook()
+{
+	if (hangup_func_str && (hook_state == CS_HANGUP || hook_state == CS_ROUTING)) {
+		hh++;
+	}
+}
+
+void Session::do_hangup_hook()
+{
+	if (hh && !mark) {
+		int arg_count = 2;
+		mark++;
+
+		if (!getLUA()) {
+			return;
+		}
+
+		lua_getfield(L, LUA_GLOBALSINDEX, (char *) hangup_func_str);
+		lua_getfield(L, LUA_GLOBALSINDEX, uuid);
+
+		lua_pushstring(L, hook_state == CS_HANGUP ? "hangup" : "transfer");
+
+		if (hangup_func_arg) {
+			lua_getfield(L, LUA_GLOBALSINDEX, (char *) hangup_func_arg);
+			arg_count++;
+		}
+
+		docall(L, arg_count, 1, 1);
+
+		const char *err = lua_tostring(L, -1);
+		
+		switch_channel_set_variable(channel, "lua_hangup_hook_return_val", err);
+
+		if (!zstr(err)) {
+
+			if (!strcasecmp(err, "exit") || !strcasecmp(err, "die")) {
+				lua_error(L);
+			} else {
+				lua_pop(L, 1);
+			}
+		} else {
+			lua_pop(L, 1);
+		}
+
+
+		if (channel) {
+			switch_channel_set_private(channel, "CoreSession", NULL);
+		}
+
+		if (session) {
+			switch_core_event_hook_remove_state_change(session, lua_hanguphook);
+		}
+		switch_safe_free(hangup_func_str);
+
+	}
+}
+
+static switch_status_t lua_hanguphook(switch_core_session_t *session_hungup)
+{
+	switch_channel_t *channel = switch_core_session_get_channel(session_hungup);
+	Session *coresession = NULL;
+	switch_channel_state_t state = switch_channel_get_state(channel);
+
+	if (session_hungup) {
+
+		channel = switch_core_session_get_channel(session_hungup);
+
+		if (channel) {
+			void *vs = switch_channel_get_private(channel, "CoreSession");
+			if (vs) {
+				coresession = (Session *) vs;
+			}
+		}
+		
+		if (!(coresession && coresession->hook_state)) {
+			return SWITCH_STATUS_FALSE;
+		}
+
+		if (coresession && coresession->allocated && (state == CS_HANGUP || state == CS_ROUTING) && coresession->hook_state != state) {
+			coresession->hook_state = state;
+			coresession->check_hangup_hook();
+			switch_core_event_hook_remove_state_change(session_hungup, lua_hanguphook);
+		}
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+
+void Session::setHangupHook(char *func, char *arg)
+{
+
+	sanity_check_noreturn;
+
+	switch_safe_free(hangup_func_str);
+	switch_safe_free(hangup_func_arg);
+
+	if (func) {
+		hangup_func_str = strdup(func);
+		if (!zstr(arg)) {
+			hangup_func_arg = strdup(arg);
+		}
+		switch_channel_set_private(channel, "CoreSession", this);
+		hook_state = switch_channel_get_state(channel);
+		switch_core_event_hook_add_state_change(session, lua_hanguphook);
+	}
+}
+
+void Session::unsetInputCallback(void)
+{
+	sanity_check_noreturn;
+	switch_safe_free(cb_function);
+	switch_safe_free(cb_arg);
+	args.input_callback = NULL;
+	ap = NULL;
+}
+
+void Session::setInputCallback(char *cbfunc, char *funcargs)
+{
+
+	sanity_check_noreturn;
+
+	switch_safe_free(cb_function);
+	if (cbfunc) {
+		cb_function = strdup(cbfunc);
+	}
+
+	switch_safe_free(cb_arg);
+	if (funcargs) {
+		cb_arg = strdup(funcargs);
+	}
+
+	args.buf = this;
+	switch_channel_set_private(channel, "CoreSession", this);
+
+	args.input_callback = dtmf_callback;
+	ap = &args;
+}
+
+switch_status_t Session::run_dtmf_callback(void *input, switch_input_type_t itype)
+{
+	const char *ret;
+
+	if (!getLUA()) {
+		return SWITCH_STATUS_FALSE;;
+	}
+
+	switch (itype) {
+	case SWITCH_INPUT_TYPE_DTMF:
+		{
+			switch_dtmf_t *dtmf = (switch_dtmf_t *) input;
+			char str[3] = "";
+			int arg_count = 3;
+
+			lua_getfield(L, LUA_GLOBALSINDEX, (char *) cb_function);
+			lua_getfield(L, LUA_GLOBALSINDEX, uuid);
+
+			lua_pushstring(L, "dtmf");
+
+			lua_newtable(L);
+			lua_pushstring(L, "digit");
+			str[0] = dtmf->digit;
+			lua_pushstring(L, str);
+			lua_rawset(L, -3);
+
+			lua_pushstring(L, "duration");
+			lua_pushnumber(L, dtmf->duration);
+			lua_rawset(L, -3);
+
+			if (!zstr(cb_arg)) {
+				lua_getfield(L, LUA_GLOBALSINDEX, (char *) cb_arg);
+				arg_count++;
+			}
+
+			docall(L, arg_count, 1, 1);
+
+			ret = lua_tostring(L, -1);
+			lua_pop(L, 1);
+
+			return process_callback_result((char *) ret);
+		}
+		break;
+	case SWITCH_INPUT_TYPE_EVENT:
+		{
+			switch_event_t *event = (switch_event_t *) input;
+			int arg_count = 3;
+
+
+			lua_getfield(L, LUA_GLOBALSINDEX, (char *) cb_function);
+			lua_getfield(L, LUA_GLOBALSINDEX, uuid);
+			lua_pushstring(L, "event");
+			mod_lua_conjure_event(L, event, "__Input_Event__", 1);
+			lua_getfield(L, LUA_GLOBALSINDEX, "__Input_Event__");
+
+			if (!zstr(cb_arg)) {
+				lua_getfield(L, LUA_GLOBALSINDEX, (char *) cb_arg);
+				arg_count++;
+			}
+
+			docall(L, arg_count, 1, 1);
+			ret = lua_tostring(L, -1);
+			lua_pop(L, 1);
+
+			return process_callback_result((char *) ret);
+		}
+		break;
+	}
+
+	return SWITCH_STATUS_SUCCESS;
+}
+
+
+Dbh::Dbh(char *dsn, char *user, char *pass)
+{
+	dbh = NULL;
+	char *tmp = NULL;
+	
+	if (!zstr(user) || !zstr(pass)) {
+		tmp = switch_mprintf("%s%s%s%s%s", dsn, 
+							 zstr(user) ? "" : ":",
+							 zstr(user) ? "" : user,
+							 zstr(pass) ? "" : ":",
+							 zstr(pass) ? "" : pass
+							 );
+		
+		dsn = tmp;
+	}
+
+	if (switch_cache_db_get_db_handle_dsn(&dbh, dsn) == SWITCH_STATUS_SUCCESS) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "DBH handle %p Connected.\n", (void *) dbh);
+	} else {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Connection failed.  DBH NOT Connected.\n");
+	}
+
+	switch_safe_free(tmp);
+	
+}
+
+Dbh::~Dbh()
+{
+	if (dbh) release();
+}
+
+bool Dbh::release()
+{
+  if (dbh) {
+	  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "DBH handle %p released.\n", (void *) dbh);
+	  switch_cache_db_release_db_handle(&dbh);
+	  return true;
+  }
+
+  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DBH NOT Connected.\n");
+  return false;
+}
+
+bool Dbh::connected()
+{
+	return dbh ? true : false;
+}
+
+bool Dbh::test_reactive(char *test_sql, char *drop_sql, char *reactive_sql)
+{
+  if (dbh) {
+    if (switch_cache_db_test_reactive(dbh, test_sql, drop_sql, reactive_sql) == SWITCH_TRUE) {
+      return true;
+    }
+  }
+
+  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DBH NOT Connected.\n");
+  return false;
+}
+
+int Dbh::query_callback(void *pArg, int argc, char **argv, char **cargv)
+{
+  SWIGLUA_FN *lua_fun = (SWIGLUA_FN *)pArg;
+	int ret = 0;
+
+  lua_pushvalue(lua_fun->L, lua_fun->idx); /* get the lua callback function onto the stack */
+
+  lua_newtable(lua_fun->L); /* push a row (table) */
+
+  for (int i = 0; i < argc; i++) {
+    lua_pushstring(lua_fun->L, switch_str_nil(cargv[i]));
+    lua_pushstring(lua_fun->L, switch_str_nil(argv[i]));
+    lua_settable(lua_fun->L, -3);
+  }
+
+	docall(lua_fun->L, 1, 1, 1);
+	ret = lua_tonumber(lua_fun->L, -1);
+	lua_pop(lua_fun->L, 1);
+
+	if (ret != 0) {
+		return 1;
+	}
+
+  return 0; /* 0 to continue with next row */
+}
+
+bool Dbh::query(char *sql, SWIGLUA_FN lua_fun)
+{
+  if (dbh) {
+    if (lua_fun.L) {
+      if (switch_cache_db_execute_sql_callback(dbh, sql, query_callback, &lua_fun, NULL) == SWITCH_STATUS_SUCCESS) {
+        return true;
+      }
+    } else { /* if no lua_fun arg is passed from Lua, an empty initialized struct will be sent - see freeswitch.i */
+      if (switch_cache_db_execute_sql(dbh, sql, NULL) == SWITCH_STATUS_SUCCESS) {
+        return true;
+      }
+    }
+  }
+
+  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DBH NOT Connected.\n");
+  return false;
+}
+
+int Dbh::affected_rows()
+{
+  if (dbh) {
+    return switch_cache_db_affected_rows(dbh);
+  }
+
+  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DBH NOT Connected.\n");
+  return 0;
+}
+
+int Dbh::load_extension(const char *extension)
+{
+  if (dbh) {
+    return switch_cache_db_load_extension(dbh, extension);
+  }
+
+  switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "DBH NOT Connected.\n");
+  return 0;
+}

src/mod/legacy/languages/mod_lua/freeswitch_lua.h

+#ifndef FREESWITCH_LUA_H
+#define FREESWITCH_LUA_H
+
+extern "C" {
+#include "lua.h"
+#include <lauxlib.h>
+#include <lualib.h>
+#include "mod_lua_extra.h"
+}
+#include <switch_cpp.h>
+
+
+typedef struct{
+  lua_State* L;
+  int idx;
+}SWIGLUA_FN;
+
+#define SWIGLUA_FN_GET(fn) {lua_pushvalue(fn.L,fn.idx);}
+
+
+namespace LUA {
+	class Session:public CoreSession {
+	  private:
+		virtual void do_hangup_hook();
+		lua_State *getLUA();
+		lua_State *L;
+		int hh;
+		int mark;
+	  public:
+		    Session();
+		    Session(char *uuid, CoreSession * a_leg = NULL);
+		     Session(switch_core_session_t *session);
+		                     ~Session();
+		                      SWITCH_MOD_DECLARE(virtual void) destroy(const char *err = NULL);
+
+		virtual bool begin_allow_threads();
+		virtual bool end_allow_threads();
+		virtual void check_hangup_hook();
+
+		virtual switch_status_t run_dtmf_callback(void *input, switch_input_type_t itype);
+		void unsetInputCallback(void);
+		void setInputCallback(char *cbfunc, char *funcargs = NULL);
+		void setHangupHook(char *func, char *arg = NULL);
+		bool ready();
+		int originate(CoreSession * a_leg_session, char *dest, int timeout);
+
+		char *cb_function;
+		char *cb_arg;
+		char *hangup_func_str;
+		char *hangup_func_arg;
+		void setLUA(lua_State * state);
+
+	};
+
+  class Dbh {
+    protected:
+      switch_cache_db_handle_t *dbh;
+      bool m_connected;
+      static int query_callback(void *pArg, int argc, char **argv, char **cargv);
+    public:
+      Dbh(char *dsn, char *user = NULL, char *pass = NULL);
+      ~Dbh();
+      bool release();
+      bool connected();
+      bool test_reactive(char *test_sql, char *drop_sql = NULL, char *reactive_sql = NULL);
+      bool query(char *sql, SWIGLUA_FN lua_fun);
+      int affected_rows();
+      int load_extension(const char *extension);
+  };
+}
+#endif

src/mod/legacy/languages/mod_lua/hack.diff

+--- mod_lua_wrap.cpp.orig	2010-09-05 16:39:26.000000000 +0200
++++ mod_lua_wrap.cpp	2010-09-05 16:39:44.000000000 +0200
+@@ -4913,7 +4913,7 @@
+   
+   result = (LUA::Session *)new LUA::Session();
+   SWIG_arg=0;
+-  SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Session,1); SWIG_arg++; 
++  SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Session,1); SWIG_arg++; result->setLUA(L);
+   return SWIG_arg;
+   
+ fail:
+@@ -4934,7 +4934,7 @@
+   arg2=(CoreSession *)SWIG_MustGetPtr(L,2,SWIGTYPE_p_CoreSession,0,2,"new_Session");
+   result = (LUA::Session *)new LUA::Session(arg1,arg2);
+   SWIG_arg=0;
+-  SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Session,1); SWIG_arg++; 
++  SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Session,1); SWIG_arg++; result->setLUA(L);
+   return SWIG_arg;
+   
+ fail:
+@@ -4952,7 +4952,7 @@
+   arg1 = (char*)lua_tostring(L, 1);
+   result = (LUA::Session *)new LUA::Session(arg1);
+   SWIG_arg=0;
+-  SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Session,1); SWIG_arg++; 
++  SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Session,1); SWIG_arg++; result->setLUA(L);
+   return SWIG_arg;
+   
+ fail:
+@@ -4970,7 +4970,7 @@
+   arg1=(switch_core_session_t *)SWIG_MustGetPtr(L,1,SWIGTYPE_p_switch_core_session_t,0,1,"new_Session");
+   result = (LUA::Session *)new LUA::Session(arg1);
+   SWIG_arg=0;
+-  SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Session,1); SWIG_arg++; 
++  SWIG_NewPointerObj(L,result,SWIGTYPE_p_LUA__Session,1); SWIG_arg++; result->setLUA(L);
+   return SWIG_arg;
+   
+ fail:

src/mod/legacy/languages/mod_lua/lua/Makefile

+# makefile for building Lua
+# see ../INSTALL for installation instructions
+# see ../Makefile and luaconf.h for further customization
+
+# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
+
+# Your platform. See PLATS for possible values.
+PLAT= none
+
+CC= gcc
+CFLAGS= -O2 -Wall $(MYCFLAGS)
+AR= ar rcu
+RANLIB= ranlib
+RM= rm -f
+LIBS= -lm $(MYLIBS)
+
+MYCFLAGS=
+MYLDFLAGS=
+MYLIBS=
+
+# == END OF USER SETTINGS. NO NEED TO CHANGE ANYTHING BELOW THIS LINE =========
+
+PLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris
+
+LUA_A=	liblua.a
+CORE_O=	lapi.o lcode.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o \
+	lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o  \
+	lundump.o lvm.o lzio.o
+LIB_O=	lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o \
+	lstrlib.o loadlib.o linit.o
+
+LUA_T=	lua
+LUA_O=	lua.o
+
+LUAC_T=	luac
+LUAC_O=	luac.o print.o
+
+ALL_O= $(CORE_O) $(LIB_O) $(LUA_O) $(LUAC_O)
+ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
+ALL_A= $(LUA_A)
+
+default: $(PLAT)
+
+all:	$(ALL_T)
+
+o:	$(ALL_O)
+
+a:	$(ALL_A)
+
+$(LUA_A): $(CORE_O) $(LIB_O)
+	$(AR) $@ $?
+	$(RANLIB) $@
+
+$(LUA_T): $(LUA_O) $(LUA_A)
+	$(CC) -o $@ $(MYLDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
+
+$(LUAC_T): $(LUAC_O) $(LUA_A)
+	$(CC) -o $@ $(MYLDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
+
+clean:
+	$(RM) $(ALL_T) $(ALL_O)
+
+depend:
+	@$(CC) $(CFLAGS) -MM l*.c print.c
+
+echo:
+	@echo "PLAT = $(PLAT)"
+	@echo "CC = $(CC)"
+	@echo "CFLAGS = $(CFLAGS)"
+	@echo "AR = $(AR)"
+	@echo "RANLIB = $(RANLIB)"
+	@echo "RM = $(RM)"
+	@echo "MYCFLAGS = $(MYCFLAGS)"
+	@echo "MYLDFLAGS = $(MYLDFLAGS)"
+	@echo "MYLIBS = $(MYLIBS)"
+
+# convenience targets for popular platforms
+
+none:
+	@echo "Please choose a platform:"
+	@echo "   $(PLATS)"
+
+aix:
+	$(MAKE) all CC="xlc" CFLAGS="-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl" MYLDFLAGS="-brtl -bexpall"
+
+ansi:
+	$(MAKE) all MYCFLAGS=-DLUA_ANSI
+
+bsd:
+	$(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-Wl,-E"
+
+freebsd:
+	$(MAKE) all MYCFLAGS="-DLUA_USE_LINUX" MYLIBS="-Wl,-E -lreadline"
+
+generic:
+	$(MAKE) all MYCFLAGS=
+
+linux:
+	$(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-Wl,-E -ldl -lreadline -lhistory -lncurses"
+
+macosx:
+	$(MAKE) all MYCFLAGS=-DLUA_USE_LINUX MYLIBS="-lreadline"
+# use this on Mac OS X 10.3-
+#	$(MAKE) all MYCFLAGS=-DLUA_USE_MACOSX
+
+mingw:
+	$(MAKE) "LUA_A=lua51.dll" "LUA_T=lua.exe" \
+	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
+	"MYCFLAGS=-DLUA_BUILD_AS_DLL" "MYLIBS=" "MYLDFLAGS=-s" lua.exe
+	$(MAKE) "LUAC_T=luac.exe" luac.exe
+
+posix:
+	$(MAKE) all MYCFLAGS=-DLUA_USE_POSIX
+
+solaris:
+	$(MAKE) all MYCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" MYLIBS="-ldl"
+
+# list targets that do not create files (but not all makes understand .PHONY)
+.PHONY: all $(PLATS) default o a clean depend echo none
+
+# DO NOT DELETE
+
+lapi.o: lapi.c lua.h luaconf.h lapi.h lobject.h llimits.h ldebug.h \
+  lstate.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h \
+  lundump.h lvm.h
+lauxlib.o: lauxlib.c lua.h luaconf.h lauxlib.h
+lbaselib.o: lbaselib.c lua.h luaconf.h lauxlib.h lualib.h
+lcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
+  lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lgc.h \
+  ltable.h
+ldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h
+ldebug.o: ldebug.c lua.h luaconf.h lapi.h lobject.h llimits.h lcode.h \
+  llex.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \
+  lfunc.h lstring.h lgc.h ltable.h lvm.h
+ldo.o: ldo.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
+  lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lparser.h lstring.h \
+  ltable.h lundump.h lvm.h
+ldump.o: ldump.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \
+  lzio.h lmem.h lundump.h
+lfunc.o: lfunc.c lua.h luaconf.h lfunc.h lobject.h llimits.h lgc.h lmem.h \
+  lstate.h ltm.h lzio.h
+lgc.o: lgc.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
+  lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h
+linit.o: linit.c lua.h luaconf.h lualib.h lauxlib.h
+liolib.o: liolib.c lua.h luaconf.h lauxlib.h lualib.h
+llex.o: llex.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h ltm.h \
+  lzio.h lmem.h llex.h lparser.h lstring.h lgc.h ltable.h
+lmathlib.o: lmathlib.c lua.h luaconf.h lauxlib.h lualib.h
+lmem.o: lmem.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
+  ltm.h lzio.h lmem.h ldo.h
+loadlib.o: loadlib.c lua.h luaconf.h lauxlib.h lualib.h
+lobject.o: lobject.c lua.h luaconf.h ldo.h lobject.h llimits.h lstate.h \
+  ltm.h lzio.h lmem.h lstring.h lgc.h lvm.h
+lopcodes.o: lopcodes.c lopcodes.h llimits.h lua.h luaconf.h
+loslib.o: loslib.c lua.h luaconf.h lauxlib.h lualib.h
+lparser.o: lparser.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
+  lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h \
+  lfunc.h lstring.h lgc.h ltable.h
+lstate.o: lstate.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
+  ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h llex.h lstring.h ltable.h
+lstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \
+  ltm.h lzio.h lstring.h lgc.h
+lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h
+ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
+  ltm.h lzio.h lmem.h ldo.h lgc.h ltable.h
+ltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h
+ltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \
+  lmem.h lstring.h lgc.h ltable.h
+lua.o: lua.c lua.h luaconf.h lauxlib.h lualib.h
+luac.o: luac.c lua.h luaconf.h lauxlib.h ldo.h lobject.h llimits.h \
+  lstate.h ltm.h lzio.h lmem.h lfunc.h lopcodes.h lstring.h lgc.h \
+  lundump.h
+lundump.o: lundump.c lua.h luaconf.h ldebug.h lstate.h lobject.h \
+  llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h lundump.h
+lvm.o: lvm.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
+  lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h lvm.h
+lzio.o: lzio.c lua.h luaconf.h llimits.h lmem.h lstate.h lobject.h ltm.h \
+  lzio.h
+print.o: print.c ldebug.h lstate.h lua.h luaconf.h lobject.h llimits.h \
+  ltm.h lzio.h lmem.h lopcodes.h lundump.h
+
+# (end of Makefile)

src/mod/legacy/languages/mod_lua/lua/lapi.h

+/*
+** $Id: lapi.h,v 2.2.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions from Lua API
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lapi_h
+#define lapi_h
+
+
+#include "lobject.h"
+
+
+LUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o);
+
+#endif

src/mod/legacy/languages/mod_lua/lua/lauxlib.h

+/*
+** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+
+#if defined(LUA_COMPAT_GETN)
+LUALIB_API int (luaL_getn) (lua_State *L, int t);
+LUALIB_API void (luaL_setn) (lua_State *L, int t, int n);
+#else
+#define luaL_getn(L,i)          ((int)lua_objlen(L, i))
+#define luaL_setn(L,i,j)        ((void)0)  /* no op! */
+#endif
+
+#if defined(LUA_COMPAT_OPENLIB)
+#define luaI_openlib	luaL_openlib
+#endif
+
+
+/* extra error code for `luaL_load' */
+#define LUA_ERRFILE     (LUA_ERRERR+1)
+
+
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+
+
+
+LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname,
+                                const luaL_Reg *l, int nup);
+LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
+                                const luaL_Reg *l);
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname);
+LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
+                                                          size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
+                                          const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
+                                          lua_Integer def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
+
+LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
+                                   const char *const lst[]);
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename);
+LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz,
+                                  const char *name);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate) (void);
+
+
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
+                                                  const char *r);
+
+LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,
+                                         const char *fname, int szhint);
+
+
+
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define luaL_argcheck(L, cond,numarg,extramsg)	\
+		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+
+#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+
+
+typedef struct luaL_Buffer {
+  char *p;			/* current position in buffer */
+  int lvl;  /* number of strings in the stack (level) */
+  lua_State *L;
+  char buffer[LUAL_BUFFERSIZE];
+} luaL_Buffer;
+
+#define luaL_addchar(B,c) \
+  ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
+   (*(B)->p++ = (char)(c)))
+
+/* compatibility only */
+#define luaL_putchar(B,c)	luaL_addchar(B,c)
+
+#define luaL_addsize(B,n)	((B)->p += (n))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+
+
+/* }====================================================== */
+
+
+/* compatibility with ref system */
+
+/* pre-defined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \
+      (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))
+
+#define lua_unref(L,ref)        luaL_unref(L, LUA_REGISTRYINDEX, (ref))
+
+#define lua_getref(L,ref)       lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))
+
+
+#define luaL_reg	luaL_Reg
+
+#endif
+
+

src/mod/legacy/languages/mod_lua/lua/lcode.h

+/*
+** $Id: lcode.h,v 1.48.1.1 2007/12/27 13:02:25 roberto Exp $
+** Code generator for Lua
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lcode_h
+#define lcode_h
+
+#include "llex.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lparser.h"
+
+
+/*
+** Marks the end of a patch list. It is an invalid value both as an absolute
+** address, and as a list link (would link an element to itself).
+*/
+#define NO_JUMP (-1)
+
+
+/*
+** grep "ORDER OPR" if you change these enums
+*/
+typedef enum BinOpr {
+  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
+  OPR_CONCAT,
+  OPR_NE, OPR_EQ,
+  OPR_LT, OPR_LE, OPR_GT, OPR_GE,
+  OPR_AND, OPR_OR,
+  OPR_NOBINOPR
+} BinOpr;
+
+
+typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
+
+
+#define getcode(fs,e)	((fs)->f->code[(e)->u.s.info])
+
+#define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
+
+#define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
+
+LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
+LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
+LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
+LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
+LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
+LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
+LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
+LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
+LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
+LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
+LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
+LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
+LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
+LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
+LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
+LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
+LUAI_FUNC int luaK_jump (FuncState *fs);
+LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
+LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
+LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
+LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
+LUAI_FUNC int luaK_getlabel (FuncState *fs);
+LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);
+LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
+LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);
+LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
+
+
+#endif