static int lxc_cb_lua(char *word[], char *word_eol[], void *userdata)
{
lua_State *L = lxc_new_state();
if (word[2][0] == '\0') {
xchat_printf(ph, "LUA: Usage: /LUA LUA_CODE... execute LUA_CODE");
return XCHAT_EAT_ALL;
}
if (luaL_loadbuffer(L, word_eol[2], strlen(word_eol[2]), "/LUA")) {
xchat_printf(ph, "LUA: error loading line %s", lua_tostring(L, -1));
lua_pop(L, 1);
}
#define LXC_HOOK_DISABLE "xchat.hook_command = nil\n" \
"xchat.hook_server = nil\n" \
"xchat.hook_print = nil\n" \
"xchat.hook_timer = nil\n"
#if defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM >= 501)
(void)luaL_dostring(L, LXC_HOOK_DISABLE);
#else
lua_dostring(L, LXC_HOOK_DISABLE);
#endif
if (lua_pcall(L, 0, 0, 0)) {
xchat_printf(ph, "LUA: error executing line %s", lua_tostring(L, -1));
lua_pop(L, 1);
}
lua_close(L);
return XCHAT_EAT_ALL;
}
static void internaldostring() {
if (lua_getparam(2) != LUA_NOOBJECT)
lua_error("invalid 2nd argument (probably obsolete code)");
if (lua_dostring(luaL_check_string(1)) == 0)
if (luaA_passresults() == 0)
lua_pushuserdata(0); // at least one result to signal no errors
}
/*
** Internal function: do a string
*/
void lua_internaldostring (void)
{
lua_Object obj = lua_getparam (1);
if (lua_isstring(obj) && !lua_dostring(lua_getstring(obj)))
lua_pushnumber(1);
else
lua_pushnil();
}
void ScriptManager::executeString(const Common::UString &code) {
assert(_luaState && _regNestingLevel == 0);
const int execResult = lua_dostring(_luaState, code.c_str());
if (execResult != 0) {
throw Common::Exception("Failed to execute Lua code: %s", code.c_str());
}
}
static void io_debug (void)
{
while (1) {
char buffer[250];
fprintf(stderr, "lua_debug> ");
if (fgets(buffer, sizeof(buffer), stdin) == 0) return;
if (strcmp(buffer, "cont\n") == 0) return;
lua_dostring(buffer);
}
}
static void manual_input (void)
{
if (isatty(fileno(stdin)))
{
char buffer[250];
while (gets(buffer) != 0)
lua_dostring(buffer);
}
else
lua_dofile(NULL); /* executes stdin as a file */
}
static void manual_input (void)
{
if (isatty(0))
{
char buffer[250];
while (fgets(buffer, sizeof(buffer), stdin) != 0)
lua_dostring(buffer);
}
else
lua_dofile(NULL); /* executes stdin as a file */
}
static int io_debug (lua_State *L) {
for (;;) {
char buffer[250];
fprintf(stderr, "lua_debug> ");
if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
strcmp(buffer, "cont\n") == 0)
return 0;
lua_dostring(L, buffer);
lua_settop(L, 0); /* remove eventual returns */
}
}
int InitScripting(DISZ80 *d)
{
char buf[256];
int err;
if (d->ls == NULL)
{
d->ls = lua_open(0);
if (d->ls == NULL)
return DERR_OUTOFMEM;
lua_baselibopen(d->ls);
lua_strlibopen(d->ls);
lua_pushuserdata(d->ls, d);
lua_setglobal(d->ls, "DISZ80STRUC");
lua_register(d->ls, LUA_ERRORMESSAGE, LuaErrorHandler);
/* Register the dZ80 support functions */
lua_register(d->ls, "d_RegTrap", d_RegTrap);
lua_register(d->ls, "d_AddComment", d_AddComment);
lua_register(d->ls, "d_AddToDis", d_AddToDis);
lua_register(d->ls, "d_AddToDisTab", d_AddToDisTab);
lua_register(d->ls, "d_GetByte", d_GetByte);
lua_register(d->ls, "d_LookByte", d_LookByte);
lua_register(d->ls, "d_DB", d_DB);
lua_register(d->ls, "d_FlushLine", d_FlushLine);
lua_register(d->ls, "d_IsCodeByte", d_IsCodeByte);
lua_register(d->ls, "d_GetPC", d_GetPC);
lua_register(d->ls, "d_LookByteAddr", d_LookByteAddr);
lua_register(d->ls, "d_GetPass", d_GetPass);
lua_register(d->ls, "d_Message", d_Message);
/* Register the general support functions */
lua_register(d->ls, "hex", d_FromHex);
/* Set up the trap registration functions */
sprintf(buf,
"__dz80_pre={}\n"
"__dz80_post={}\n"
"function d_PreTrap(op, fn) __dz80_pre[op]=fn d_RegTrap(op, %d) end\n"
"function d_PostTrap(op, fn) __dz80_post[op]=fn d_RegTrap(op, %d) end\n",
D_SCRIPT_PRE, D_SCRIPT_POST);
err = lua_dostring(d->ls, buf);
if (err)
return DERR_SCRIPTERROR;
}
return DERR_NONE;
}
int cboxlua_open (void)
{
lua_register("iupCreateCbox",CreateCbox);
return lua_dostring("IUPCBOX = {parent = IUPCANVAS}\n"
"function IUPCBOX:CreateIUPelement (obj)\n"
" return iupCreateCbox (obj, getn(obj))\n"
"end\n"
"function iupcbox (o)\n"
" return IUPCBOX:Constructor (o)\n"
"end\n"
"iup.cbox = iupcbox\n");
}
/* a really simple way of calling lua from C
just give it a lua state & a string to execute
Unfortunately lua keeps changing its API's.
In lua 5.0.X it's lua_dostring()
In lua 5.1.X it's luaL_dostring()
so we have a few extra compiles
*/
int dostring(lua_State *L, char* str) {
int ok;
#if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501))
ok=luaL_dostring(L,str); /* looks like this is lua 5.1.X or later, good */
#else
ok=lua_dostring(L,str); /* might be lua 5.0.x, using lua_dostring */
#endif
if (ok!=0)
printf("[C] ERROR in dostring: %s\n",lua_tostring(L,-1));
return ok;
}
int main()
{
config::open();
luaSDL_initialize(config::L);
lua_dofile(config::L, "property.lua"); // migrate this into config::open().
lua_dofile(config::L, "init.lua");
lua_register(config::L, "fc", float_compare_lua);
lua_register(config::L, "fasi", float_as_int_lua);
// Show initial test var values.
printf( "test_cfloat = %f, test_cvar = %s\n",
(float) test_cfloat,
(const char*) test_cvar );
// Change the values, and show the results.
test_cfloat = 100.5f;
test_cvar = "newfilename.jpg";
printf( "test_cfloat = %f, test_cvar = %s\n", (float) test_cfloat, (const char*) test_cvar );
// Interpreter loop, to fiddle with cfloats & cvars...
for (;;) {
// Get a command line.
char buffer[1000];
printf( "> " );
fgets( buffer, 1000, stdin );
if ( strstr( buffer, "quit" ) ) {
break;
}
// Execute it.
lua_dostring( config::L, buffer );
}
// Show ending var values.
printf( "test_cfloat = %f, test_cvar = %s, test_cvalue = %s\n", (float) test_cfloat, (const char*) cvar("test_cvar"), (const char*) c10 );
printf("actorprefs.jumpheight = %f, actorprefs.runspeed = %f, actorprefs.color = %s",
(float) actorprefs::jumpheight,
(float) actorprefs::runspeed,
(const char*) actorprefs::color
);
return 0;
}
void LuaNetworkClient::ProcessPackets()
{
if (!m_socket.IsValid())
return;
EnterCriticalSection( &m_socketAccessCS );
while (m_socket.IsReadDataWaiting())
{
SimpleString command;
if (ReadString(m_socket, command))
{
lua_dostring(m_state, command);
}
}
LeaveCriticalSection( &m_socketAccessCS );
}
double CPromptBox::ParseDouble()
{
// parse the contents of the edit box and return a double;
CString tolua;
int i,k;
double x=0;
tolua="return " + instring;
i=lua_gettop(lua);
lua_dostring(lua,tolua);
k=lua_gettop(lua);
if (i!=k){
tolua=lua_tostring(lua,-1);
if (tolua.GetLength()==0) AfxMessageBox("Input does not evaluate to a numerical value");
else x=lua_todouble(lua,-1);
}
return x;
}
void CLuaConsoleDlg::OnBnClickedEvaluate()
{
if (bLinehook!=FALSE) return;
CString LuaCmd;
UpdateData();
ToOutput(inbuffer+"\r\n");
LuaCmd=inbuffer;
inbuffer="";
UpdateData(FALSE);
bLinehook=NormalLua;
CStatusBar *StatBar=(CStatusBar *)((CFrameWnd *)GetTopLevelFrame())->GetMessageBar();
StatBar->SetPaneText(0,"EXECUTING LUASCRIPT -- HIT <ESC> TO ABORT",TRUE);
int lua_error_code=lua_dostring(lua,LuaCmd);
if(lua_error_code!=FALSE){
// if (lua_error_code==LUA_ERRRUN)
// AfxMessageBox("Run Error");
// if (lua_error_code==LUA_ERRSYNTAX)
// AfxMessageBox("Syntax Error");
if (lua_error_code==LUA_ERRMEM)
AfxMessageBox("Lua memory Error");
if (lua_error_code==LUA_ERRERR)
AfxMessageBox("User error error");
if (lua_error_code==LUA_ERRFILE)
AfxMessageBox("File Error");
inbuffer=LuaCmd;
UpdateData(FALSE);
}
bLinehook=FALSE;
inbufferctrl.SetFocus();
StatBar->SetPaneText(0,"Ready",TRUE);
if(lua_byebye==TRUE){
ASSERT(AfxGetMainWnd() != NULL);
AfxGetMainWnd()->PostMessage(WM_CLOSE);
}
}
/*
** Python prototype: "lua_state <-- lua_open([stack_size])"
** opens a Lua State and returns it to Python
** accepts an optional parameter informing the size of the stack Lua should use
** (measured in number of elements)
*/
static PyObject *Py_lua_open(PyObject *self, PyObject *args) {
lua_State *L;
int stack_size = 0;
PyObject *result = NULL;
if (PyArg_ParseTuple(args, "|i:lua_open", &stack_size)) {
L = lua_open(stack_size);
lua_baselibopen(L);
lua_iolibopen(L);
lua_strlibopen(L);
lua_mathlibopen(L);
lua_dblibopen(L);
lua_register(L, "_LuaPy_callPythonFunction", Lua_callPythonFunction);
lua_register(L, "_LuaPy_setErrorMessage", Lua_setErrorMessage);
lua_dostring(L, LUA_init_state);
result = Py_BuildValue("i", L);
}
return result;
}
static int read_number (lua_State *L, FILE *f) {
// double d;
// if (fscanf(f, "%lf", &d) == 1) {
// lua_pushnumber(L, d);
// return 1;
// }
// else return 0; /* read fails */
//}
char v[256],s[256];
int i,k;
if (fscanf(f,"%s",v)>0){
sprintf(s,"return %s",v);
i=lua_gettop(L);
lua_dostring(L,s);
k=lua_gettop(L);
return (k-i);
}
else return 0; /* read fails */
}
/*
** Python prototype: "<tuple|value> <-- lua(lua_code)"
** executes the Lua "dostring" function, returning all return values to Python.
** The Lua return values can be of the type "number", "string", "userdata" or
** "python_function" only (the others are not yet implemented).
** If only 1 value is returned from Lua, it is passed as a single value to
** Python, but if Lua returns 0 or more than 1 values, a tuple is passed to
** Python.
*/
static PyObject *Py_lua(PyObject *self, PyObject *args) {
lua_State *L;
char *lua_code;
int lua_return_code;
int nreturns;
PyObject *result;
if (PyArg_ParseTuple(args, "is:lua", &L, &lua_code)) {
lua_return_code = lua_dostring(L, lua_code);
/* treat errors that Lua can't give its own message */
if (lua_return_code == LUA_ERRMEM) {
PyErr_NoMemory();
return NULL;
} else if (lua_return_code == LUA_ERRERR) {
PyErr_SetString(PyExc_Exception, "LuaPy: error in the user-defined Lua error function!");
return NULL;
} else if (lua_return_code != 0) {
/* Lua error ocurred. Set error condition in Python */
/* (Lua has already told Python what happened -- via 'Lua_setErrorMessage') */
return NULL;
}
nreturns = lua_gettop(L);
result = pyTryValue(luaStack_to_pythonTuple(L, 1, nreturns));
/* remove Lua return values from the stack */
lua_pop(L, nreturns);
} else {
return NULL;
}
/* watch out the 'LuaPy_Python_error_ocurred' condition, which can change due to */
/* the execution of 'lua_dostring' */
if (LuaPy_Python_error_ocurred == False) {
return result;
} else {
return NULL;
}
}
bool kgmLuaScript::load(kgmString s)
{
if (!resources)
return false;
kgmString ls = "scripts/";
ls += (s + ".lua");
kgmString script;
kgmMemory<u8> content;
if (!resources->getFile(ls, content))
return false;
script = (const s8*) content.data();
if(lua_dostring(handler, script.data()))
return false;
return true;
}
int main (int argc, char *argv[])
{
int i;
int result = 0;
iolib_open ();
strlib_open ();
mathlib_open ();
lua_register("argv", lua_getargv);
if (argc < 2)
{
char buffer[250];
while (gets(buffer) != 0)
result = lua_dostring(buffer);
}
else
{
for (i=1; i<argc; i++)
{
if (strcmp(argv[i], "--") == 0)
{
lua_argc = argc-i-1;
lua_argv = argv+i;
break;
}
}
for (i=1; i<argc; i++)
{
if (strcmp(argv[i], "--") == 0)
break;
else
result = lua_dofile (argv[i]);
}
}
return result;
}
extern int lua_dostring(const char* str) {
return lua_dostring(gL, str);
}
int
weechat_lua_load (const char *filename)
{
FILE *fp;
char *weechat_lua_code = {
"weechat_outputs = {\n"
" write = function (self, str)\n"
" weechat.print(\"\", \"lua: stdout/stderr: \" .. str)\n"
" end\n"
"}\n"
"io.stdout = weechat_outputs\n"
"io.stderr = weechat_outputs\n"
};
if ((fp = fopen (filename, "r")) == NULL)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: script \"%s\" not found"),
weechat_prefix ("error"), LUA_PLUGIN_NAME, filename);
return 0;
}
if ((weechat_lua_plugin->debug >= 2) || !lua_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: loading script \"%s\""),
LUA_PLUGIN_NAME, filename);
}
lua_current_script = NULL;
lua_registered_script = NULL;
lua_current_interpreter = luaL_newstate();
if (lua_current_interpreter == NULL)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to create new "
"sub-interpreter"),
weechat_prefix ("error"), LUA_PLUGIN_NAME);
fclose (fp);
return 0;
}
#ifdef LUA_VERSION_NUM /* LUA_VERSION_NUM is defined only in lua >= 5.1.0 */
luaL_openlibs (lua_current_interpreter);
#else
luaopen_base (lua_current_interpreter);
luaopen_string (lua_current_interpreter);
luaopen_table (lua_current_interpreter);
luaopen_math (lua_current_interpreter);
luaopen_io (lua_current_interpreter);
luaopen_debug (lua_current_interpreter);
#endif
weechat_lua_register_lib (lua_current_interpreter, "weechat", weechat_lua_api_funcs);
#ifdef LUA_VERSION_NUM
if (luaL_dostring (lua_current_interpreter, weechat_lua_code) != 0)
#else
if (lua_dostring (lua_current_interpreter, weechat_lua_code) != 0)
#endif
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to redirect stdout "
"and stderr"),
weechat_prefix ("error"), LUA_PLUGIN_NAME);
}
lua_current_script_filename = filename;
if (luaL_loadfile (lua_current_interpreter, filename) != 0)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to load file \"%s\""),
weechat_prefix ("error"), LUA_PLUGIN_NAME, filename);
weechat_printf (NULL,
weechat_gettext ("%s%s: error: %s"),
weechat_prefix ("error"), LUA_PLUGIN_NAME,
lua_tostring (lua_current_interpreter, -1));
lua_close (lua_current_interpreter);
fclose (fp);
return 0;
}
if (lua_pcall (lua_current_interpreter, 0, 0, 0) != 0)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to execute file "
"\"%s\""),
weechat_prefix ("error"), LUA_PLUGIN_NAME, filename);
weechat_printf (NULL,
weechat_gettext ("%s%s: error: %s"),
weechat_prefix ("error"), LUA_PLUGIN_NAME,
lua_tostring (lua_current_interpreter, -1));
lua_close (lua_current_interpreter);
fclose (fp);
/* if script was registered, remove it from list */
if (lua_current_script)
{
plugin_script_remove (weechat_lua_plugin, &lua_scripts, &last_lua_script,
lua_current_script);
}
return 0;
}
fclose (fp);
if (!lua_registered_script)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"register\" not "
"found (or failed) in file \"%s\""),
weechat_prefix ("error"), LUA_PLUGIN_NAME, filename);
lua_close (lua_current_interpreter);
return 0;
}
lua_current_script = lua_registered_script;
lua_current_script->interpreter = (lua_State *) lua_current_interpreter;
/*
* set input/close callbacks for buffers created by this script
* (to restore callbacks after upgrade)
*/
plugin_script_set_buffer_callbacks (weechat_lua_plugin,
lua_scripts,
lua_current_script,
&weechat_lua_api_buffer_input_data_cb,
&weechat_lua_api_buffer_close_cb);
weechat_hook_signal_send ("lua_script_loaded", WEECHAT_HOOK_SIGNAL_STRING,
lua_current_script->filename);
return 1;
}
bool kgmLuaRun(kgmString str){
if(lua_dostring(lua_main, str.data()))
return false;
return true;
}
static int luaopen_xchat(lua_State *L)
{
int i;
/*
* wrappers for xchat.printf() and xchat.commandf()
* ... xchat.strip
*/
#define LXC_WRAPPERS "function xchat.printf(...)\n" \
" xchat.print(string.format(unpack(arg)))\n" \
"end\n" \
"function xchat.commandf(...)\n" \
" xchat.command(string.format(unpack(arg)))\n" \
"end\n" \
"function xchat.strip(str, flags)\n" \
" if flags == nil then\n" \
" flags = xchat.STRIP_ALL\n" \
" end\n" \
" local bits = xchat.bits(flags)\n" \
" if bits[1] then\n" \
" str = string.gsub(\n" \
" string.gsub(str, \"\\3%d%d?,%d%d?\", \"\"),\n" \
" \"\\3%d%d?\", \"\")\n" \
" end\n" \
" if bits[2] then\n" \
" -- bold, beep, reset, reverse, underline\n" \
" str = string.gsub(str,\n" \
" \"[\\2\\7\\15\\22\\31]\", \"\")\n" \
" end\n" \
" return str\n" \
"end\n"
#if defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM >= 501)
luaL_register(L, "xchat", lxc_functions);
(void)luaL_dostring(L, LXC_WRAPPERS);
#else
luaL_openlib(L, "xchat", lxc_functions, 0);
lua_dostring(L, LXC_WRAPPERS);
#endif
luaL_newmetatable(L, "xchat");
lua_pushliteral(L, "__index");
lua_newtable(L);
lua_pushstring(L, "ARCH");
#ifdef _WIN32
lua_pushstring(L, "Windows");
#else
lua_pushstring(L, "Unix");
#endif
lua_settable(L, -3); /* add to table __index */
for (i=0; lxc_consts[i].name; i++) {
lua_pushstring(L, lxc_consts[i].name);
lua_pushnumber(L, lxc_consts[i].value);
lua_settable(L, -3); /* add to table __index */
}
lua_settable(L, -3); /* add to metatable */
lua_pushliteral(L, "__newindex");
lua_pushcfunction(L, lxc__newindex);
lua_settable(L, -3);
/*
lua_pushliteral(L, "__metatable");
lua_pushstring(L, "nothing to see here, move along");
lua_settable(L, -3);
*/
lua_setmetatable(L, -2);
lua_pop(L, 1);
return 1;
}
int scripting_Run(const char *command) {
/* fprintf(stderr, "[command] %s\n", command); */
return lua_dostring(L, command);
}
