void
weechat_lua_reload_name (const char *name)
{
struct t_plugin_script *ptr_script;
char *filename;
ptr_script = plugin_script_search (weechat_lua_plugin, lua_scripts, name);
if (ptr_script)
{
filename = strdup (ptr_script->filename);
if (filename)
{
weechat_lua_unload (ptr_script);
if (!lua_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: script \"%s\" unloaded"),
LUA_PLUGIN_NAME, name);
}
weechat_lua_load (filename);
free (filename);
}
}
else
{
weechat_printf (NULL,
weechat_gettext ("%s%s: script \"%s\" not loaded"),
weechat_prefix ("error"), LUA_PLUGIN_NAME, name);
}
}
int
weechat_guile_load (const char *filename)
{
char *filename2, *ptr_base_name, *base_name;
SCM module;
if ((weechat_guile_plugin->debug >= 2) || !guile_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: loading script \"%s\""),
GUILE_PLUGIN_NAME, filename);
}
guile_current_script = NULL;
guile_registered_script = NULL;
guile_current_script_filename = filename;
filename2 = strdup (filename);
if (!filename2)
return 0;
ptr_base_name = basename (filename2);
base_name = strdup (ptr_base_name);
module = scm_c_define_module (base_name,
&weechat_guile_module_init_script, filename2);
free (filename2);
if (!guile_registered_script)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"register\" not "
"found (or failed) in file \"%s\""),
weechat_prefix ("error"), GUILE_PLUGIN_NAME, filename);
return 0;
}
weechat_guile_catch (scm_gc_protect_object, (void *)module);
guile_current_script = guile_registered_script;
/*
* set input/close callbacks for buffers created by this script
* (to restore callbacks after upgrade)
*/
plugin_script_set_buffer_callbacks (weechat_guile_plugin,
guile_scripts,
guile_current_script,
&weechat_guile_api_buffer_input_data_cb,
&weechat_guile_api_buffer_close_cb);
(void) weechat_hook_signal_send ("guile_script_loaded",
WEECHAT_HOOK_SIGNAL_STRING,
guile_current_script->filename);
return 1;
}
static PyObject *
weechat_python_output (PyObject *self, PyObject *args)
{
char *msg, *m, *p;
/* make C compiler happy */
(void) self;
msg = NULL;
if (!PyArg_ParseTuple (args, "s", &msg))
{
if (strlen(python_buffer_output) > 0)
{
weechat_printf (NULL,
weechat_gettext ("%s: stdout/stderr: %s%s"),
PYTHON_PLUGIN_NAME, python_buffer_output, "");
python_buffer_output[0] = '\0';
}
}
else
{
m = msg;
while ((p = strchr (m, '\n')) != NULL)
{
*p = '\0';
if (strlen (m) + strlen (python_buffer_output) > 0)
{
weechat_printf (NULL,
weechat_gettext ("%s: stdout/stderr: %s%s"),
PYTHON_PLUGIN_NAME, python_buffer_output, m);
}
*p = '\n';
python_buffer_output[0] = '\0';
m = ++p;
}
if (strlen(m) + strlen(python_buffer_output) > sizeof(python_buffer_output))
{
weechat_printf (NULL,
weechat_gettext ("%s: stdout/stderr: %s%s"),
PYTHON_PLUGIN_NAME, python_buffer_output, m);
python_buffer_output[0] = '\0';
}
else
strcat (python_buffer_output, m);
}
Py_INCREF(Py_None);
return Py_None;
}
void
weechat_guile_unload (struct t_plugin_script *script)
{
int *rc;
if ((weechat_guile_plugin->debug >= 1) || !guile_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: unloading script \"%s\""),
GUILE_PLUGIN_NAME, script->name);
}
if (script->shutdown_func && script->shutdown_func[0])
{
rc = (int *)weechat_guile_exec (script, WEECHAT_SCRIPT_EXEC_INT,
script->shutdown_func, NULL, NULL);
if (rc)
free (rc);
}
weechat_guile_catch (scm_gc_unprotect_object, script->interpreter);
if (guile_current_script == script)
guile_current_script = (guile_current_script->prev_script) ?
guile_current_script->prev_script : guile_current_script->next_script;
script_remove (weechat_guile_plugin, &guile_scripts, &last_guile_script,
script);
}
void
weechat_ruby_unload (struct t_plugin_script *script)
{
int *rc;
void *interpreter;
if ((weechat_ruby_plugin->debug >= 1) || !ruby_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: unloading script \"%s\""),
RUBY_PLUGIN_NAME, script->name);
}
if (script->shutdown_func && script->shutdown_func[0])
{
rc = (int *)weechat_ruby_exec (script,
WEECHAT_SCRIPT_EXEC_INT,
script->shutdown_func,
0, NULL);
if (rc)
free (rc);
}
interpreter = script->interpreter;
if (ruby_current_script == script)
ruby_current_script = (ruby_current_script->prev_script) ?
ruby_current_script->prev_script : ruby_current_script->next_script;
script_remove (weechat_ruby_plugin, &ruby_scripts, &last_ruby_script,
script);
if (interpreter)
rb_gc_unregister_address (interpreter);
}
void
weechat_perl_unload (struct t_plugin_script *script)
{
int *rc;
void *interpreter;
char *filename;
if ((weechat_perl_plugin->debug >= 2) || !perl_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: unloading script \"%s\""),
PERL_PLUGIN_NAME, script->name);
}
#ifdef MULTIPLICITY
PERL_SET_CONTEXT (script->interpreter);
#endif /* MULTIPLICITY */
if (script->shutdown_func && script->shutdown_func[0])
{
rc = (int *)weechat_perl_exec (script,
WEECHAT_SCRIPT_EXEC_INT,
script->shutdown_func,
NULL, NULL);
if (rc)
free (rc);
}
filename = strdup (script->filename);
interpreter = script->interpreter;
if (perl_current_script == script)
{
perl_current_script = (perl_current_script->prev_script) ?
perl_current_script->prev_script : perl_current_script->next_script;
}
plugin_script_remove (weechat_perl_plugin, &perl_scripts, &last_perl_script,
script);
#ifdef MULTIPLICITY
if (interpreter)
{
perl_destruct (interpreter);
perl_free (interpreter);
}
if (perl_current_script)
{
PERL_SET_CONTEXT (perl_current_script->interpreter);
}
#else
if (interpreter)
free (interpreter);
#endif /* MULTIPLICITY */
(void) weechat_hook_signal_send ("perl_script_unloaded",
WEECHAT_HOOK_SIGNAL_STRING, filename);
if (filename)
free (filename);
}
void
weechat_tcl_unload (struct t_plugin_script *script)
{
Tcl_Interp* interp;
int *rc;
if ((weechat_tcl_plugin->debug >= 1) || !tcl_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: unloading script \"%s\""),
TCL_PLUGIN_NAME, script->name);
}
if (script->shutdown_func && script->shutdown_func[0])
{
rc = (int *)weechat_tcl_exec (script,
WEECHAT_SCRIPT_EXEC_INT,
script->shutdown_func,
NULL, NULL);
if (rc)
free (rc);
}
interp = (Tcl_Interp*)script->interpreter;
if (tcl_current_script == script)
tcl_current_script = (tcl_current_script->prev_script) ?
tcl_current_script->prev_script : tcl_current_script->next_script;
script_remove (weechat_tcl_plugin, &tcl_scripts, &last_tcl_script, script);
Tcl_DeleteInterp(interp);
}
static VALUE
weechat_ruby_output (VALUE self, VALUE str)
{
if (ruby_hide_errors)
return Qnil;
char *msg, *p, *m;
/* make C compiler happy */
(void) self;
msg = strdup(StringValuePtr(str));
m = msg;
while ((p = strchr (m, '\n')) != NULL)
{
*p = '\0';
if (strlen (m) + strlen (ruby_buffer_output) > 0)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: stdout/stderr: %s%s"),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
ruby_buffer_output, m);
}
*p = '\n';
ruby_buffer_output[0] = '\0';
m = ++p;
}
if (strlen(m) + strlen(ruby_buffer_output) > sizeof(ruby_buffer_output))
{
weechat_printf (NULL,
weechat_gettext ("%s%s: stdout/stderr: %s%s"),
weechat_prefix ("error"), RUBY_PLUGIN_NAME,
ruby_buffer_output, m);
ruby_buffer_output[0] = '\0';
}
else
strcat (ruby_buffer_output, m);
if (msg)
free (msg);
return Qnil;
}
int
weechat_plugin_init (struct t_weechat_plugin *plugin, int argc, char *argv[])
{
struct t_plugin_script_init init;
#ifdef PERL_SYS_INIT3
int a;
char **perl_args_local;
char *perl_env[] = {};
a = perl_args_count;
perl_args_local = perl_args;
(void) perl_env;
PERL_SYS_INIT3 (&a, (char ***)&perl_args_local, (char ***)&perl_env);
#endif /* PERL_SYS_INIT3 */
weechat_perl_plugin = plugin;
#ifndef MULTIPLICITY
perl_main = perl_alloc ();
if (!perl_main)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to initialize %s"),
weechat_prefix ("error"), PERL_PLUGIN_NAME,
PERL_PLUGIN_NAME);
return WEECHAT_RC_ERROR;
}
perl_construct (perl_main);
perl_parse (perl_main, weechat_perl_api_init, perl_args_count,
perl_args, NULL);
#endif /* MULTIPLICITY */
init.callback_command = &weechat_perl_command_cb;
init.callback_completion = &weechat_perl_completion_cb;
init.callback_hdata = &weechat_perl_hdata_cb;
init.callback_infolist = &weechat_perl_infolist_cb;
init.callback_signal_debug_dump = &weechat_perl_signal_debug_dump_cb;
init.callback_signal_debug_libs = &weechat_perl_signal_debug_libs_cb;
init.callback_signal_script_action = &weechat_perl_signal_script_action_cb;
init.callback_load_file = &weechat_perl_load_cb;
perl_quiet = 1;
plugin_script_init (weechat_perl_plugin, argc, argv, &init);
perl_quiet = 0;
plugin_script_display_short_list (weechat_perl_plugin,
perl_scripts);
weechat_hook_signal ("quit",
&weechat_perl_signal_quit_upgrade_cb, NULL, NULL);
weechat_hook_signal ("upgrade",
&weechat_perl_signal_quit_upgrade_cb, NULL, NULL);
/* init OK */
return WEECHAT_RC_OK;
}
void
weechat_ruby_unload_name (const char *name)
{
struct t_plugin_script *ptr_script;
ptr_script = script_search (weechat_ruby_plugin, ruby_scripts, name);
if (ptr_script)
{
weechat_ruby_unload (ptr_script);
weechat_printf (NULL,
weechat_gettext ("%s: script \"%s\" unloaded"),
RUBY_PLUGIN_NAME, name);
}
else
{
weechat_printf (NULL,
weechat_gettext ("%s%s: script \"%s\" not loaded"),
weechat_prefix ("error"), RUBY_PLUGIN_NAME, name);
}
}
void
weechat_guile_stdout_flush ()
{
if (guile_stdout)
{
weechat_printf (NULL,
weechat_gettext ("%s: stdout/stderr: %s%s"),
GUILE_PLUGIN_NAME, guile_stdout, "");
free (guile_stdout);
guile_stdout = NULL;
}
}
void
weechat_python_unload_name (const char *name)
{
struct t_plugin_script *ptr_script;
ptr_script = plugin_script_search (weechat_python_plugin, python_scripts, name);
if (ptr_script)
{
weechat_python_unload (ptr_script);
if (!python_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: script \"%s\" unloaded"),
PYTHON_PLUGIN_NAME, name);
}
}
else
{
weechat_printf (NULL,
weechat_gettext ("%s%s: script \"%s\" not loaded"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, name);
}
}
void
weechat_python_unload (struct t_plugin_script *script)
{
int *rc;
void *interpreter;
char *filename;
if ((weechat_python_plugin->debug >= 2) || !python_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: unloading script \"%s\""),
PYTHON_PLUGIN_NAME, script->name);
}
if (script->shutdown_func && script->shutdown_func[0])
{
rc = (int *) weechat_python_exec (script, WEECHAT_SCRIPT_EXEC_INT,
script->shutdown_func, NULL, NULL);
if (rc)
free (rc);
}
filename = strdup (script->filename);
interpreter = script->interpreter;
if (python_current_script == script)
{
python_current_script = (python_current_script->prev_script) ?
python_current_script->prev_script : python_current_script->next_script;
}
plugin_script_remove (weechat_python_plugin, &python_scripts, &last_python_script,
script);
if (interpreter)
{
PyThreadState_Swap (interpreter);
Py_EndInterpreter (interpreter);
}
if (python_current_script)
PyThreadState_Swap (python_current_script->interpreter);
(void) weechat_hook_signal_send ("python_script_unloaded",
WEECHAT_HOOK_SIGNAL_STRING, filename);
if (filename)
free (filename);
}
void
weechat_lua_unload (struct t_plugin_script *script)
{
int *rc;
void *interpreter;
char *filename;
if ((weechat_lua_plugin->debug >= 2) || !lua_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: unloading script \"%s\""),
LUA_PLUGIN_NAME, script->name);
}
if (script->shutdown_func && script->shutdown_func[0])
{
rc = (int *)weechat_lua_exec (script,
WEECHAT_SCRIPT_EXEC_INT,
script->shutdown_func,
NULL, NULL);
if (rc)
free (rc);
}
filename = strdup (script->filename);
interpreter = script->interpreter;
if (lua_current_script == script)
lua_current_script = (lua_current_script->prev_script) ?
lua_current_script->prev_script : lua_current_script->next_script;
plugin_script_remove (weechat_lua_plugin, &lua_scripts, &last_lua_script, script);
if (interpreter)
lua_close (interpreter);
if (lua_current_script)
lua_current_interpreter = lua_current_script->interpreter;
(void) weechat_hook_signal_send ("lua_script_unloaded",
WEECHAT_HOOK_SIGNAL_STRING, filename);
if (filename)
free (filename);
}
void
weechat_guile_unload (struct t_plugin_script *script)
{
int *rc;
void *interpreter;
char *filename;
if ((weechat_guile_plugin->debug >= 2) || !guile_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: unloading script \"%s\""),
GUILE_PLUGIN_NAME, script->name);
}
if (script->shutdown_func && script->shutdown_func[0])
{
rc = (int *)weechat_guile_exec (script, WEECHAT_SCRIPT_EXEC_INT,
script->shutdown_func, NULL, NULL);
if (rc)
free (rc);
}
filename = strdup (script->filename);
interpreter = script->interpreter;
if (guile_current_script == script)
guile_current_script = (guile_current_script->prev_script) ?
guile_current_script->prev_script : guile_current_script->next_script;
plugin_script_remove (weechat_guile_plugin, &guile_scripts, &last_guile_script,
script);
if (interpreter)
weechat_guile_catch (scm_gc_unprotect_object, interpreter);
if (guile_current_script)
scm_set_current_module ((SCM)(guile_current_script->interpreter));
(void) weechat_hook_signal_send ("guile_script_unloaded",
WEECHAT_HOOK_SIGNAL_STRING, filename);
if (filename)
free (filename);
}
void
weechat_ruby_unload (struct t_plugin_script *script)
{
int *rc;
void *interpreter;
char *filename;
if ((weechat_ruby_plugin->debug >= 2) || !ruby_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: unloading script \"%s\""),
RUBY_PLUGIN_NAME, script->name);
}
if (script->shutdown_func && script->shutdown_func[0])
{
rc = (int *)weechat_ruby_exec (script,
WEECHAT_SCRIPT_EXEC_INT,
script->shutdown_func,
0, NULL);
if (rc)
free (rc);
}
filename = strdup (script->filename);
interpreter = script->interpreter;
if (ruby_current_script == script)
ruby_current_script = (ruby_current_script->prev_script) ?
ruby_current_script->prev_script : ruby_current_script->next_script;
plugin_script_remove (weechat_ruby_plugin, &ruby_scripts, &last_ruby_script,
script);
if (interpreter)
rb_gc_unregister_address (interpreter);
(void) weechat_hook_signal_send ("ruby_script_unloaded",
WEECHAT_HOOK_SIGNAL_STRING, filename);
if (filename)
free (filename);
}
void
weechat_js_unload (struct t_plugin_script *script)
{
int *rc;
char *filename;
void *interpreter;
if ((weechat_js_plugin->debug >= 2) || !js_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: unloading script \"%s\""),
JS_PLUGIN_NAME, script->name);
}
if (script->shutdown_func && script->shutdown_func[0])
{
rc = (int *)weechat_js_exec (script, WEECHAT_SCRIPT_EXEC_INT,
script->shutdown_func, NULL, NULL);
if (rc)
free (rc);
}
filename = strdup (script->filename);
interpreter = script->interpreter;
if (js_current_script == script)
{
js_current_script = (js_current_script->prev_script) ?
js_current_script->prev_script : js_current_script->next_script;
}
plugin_script_remove (weechat_js_plugin,
&js_scripts, &last_js_script, script);
if (interpreter)
delete((WeechatJsV8 *)interpreter);
(void) weechat_hook_signal_send ("javascript_script_unloaded",
WEECHAT_HOOK_SIGNAL_STRING, filename);
if (filename)
free (filename);
}
void
weechat_tcl_unload (struct t_plugin_script *script)
{
Tcl_Interp* interp;
int *rc;
char *filename;
if ((weechat_tcl_plugin->debug >= 2) || !tcl_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: unloading script \"%s\""),
TCL_PLUGIN_NAME, script->name);
}
if (script->shutdown_func && script->shutdown_func[0])
{
rc = (int *)weechat_tcl_exec (script,
WEECHAT_SCRIPT_EXEC_INT,
script->shutdown_func,
NULL, NULL);
if (rc)
free (rc);
}
filename = strdup (script->filename);
interp = (Tcl_Interp*)script->interpreter;
if (tcl_current_script == script)
tcl_current_script = (tcl_current_script->prev_script) ?
tcl_current_script->prev_script : tcl_current_script->next_script;
plugin_script_remove (weechat_tcl_plugin, &tcl_scripts, &last_tcl_script, script);
Tcl_DeleteInterp(interp);
weechat_hook_signal_send ("tcl_script_unloaded",
WEECHAT_HOOK_SIGNAL_STRING, filename);
if (filename)
free (filename);
}
int
weechat_plugin_end (struct t_weechat_plugin *plugin)
{
/* unload all scripts */
python_quiet = 1;
plugin_script_end (plugin, &python_scripts, &weechat_python_unload_all);
python_quiet = 0;
/* free python interpreter */
if (python_mainThreadState != NULL)
{
/* PyEval_AcquireLock (); */
PyThreadState_Swap (python_mainThreadState);
/* PyEval_ReleaseLock (); */
python_mainThreadState = NULL;
}
Py_Finalize ();
if (Py_IsInitialized () != 0)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to free interpreter"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME);
}
/* free some data */
if (python2_bin)
free (python2_bin);
if (python_action_install_list)
free (python_action_install_list);
if (python_action_remove_list)
free (python_action_remove_list);
if (python_action_autoload_list)
free (python_action_autoload_list);
return WEECHAT_RC_OK;
}
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;
}
void *
weechat_lua_exec (struct t_plugin_script *script, int ret_type,
const char *function,
const char *format, void **argv)
{
void *ret_value;
int argc, i, *ret_i;
lua_State *old_lua_current_interpreter;
struct t_plugin_script *old_lua_current_script;
old_lua_current_interpreter = lua_current_interpreter;
lua_current_interpreter = script->interpreter;
lua_getglobal (lua_current_interpreter, function);
old_lua_current_script = lua_current_script;
lua_current_script = script;
argc = 0;
if (format && format[0])
{
argc = strlen (format);
for (i = 0; i < argc; i++)
{
switch (format[i])
{
case 's': /* string */
lua_pushstring (lua_current_interpreter, (char *)argv[i]);
break;
case 'i': /* integer */
lua_pushnumber (lua_current_interpreter, *((int *)argv[i]));
break;
case 'h': /* hash */
weechat_lua_pushhashtable (lua_current_interpreter, (struct t_hashtable *)argv[i]);
break;
}
}
}
if (lua_pcall (lua_current_interpreter, argc, 1, 0) != 0)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to run function \"%s\""),
weechat_prefix ("error"), LUA_PLUGIN_NAME, function);
weechat_printf (NULL,
weechat_gettext ("%s%s: error: %s"),
weechat_prefix ("error"), LUA_PLUGIN_NAME,
lua_tostring (lua_current_interpreter, -1));
lua_current_script = old_lua_current_script;
lua_current_interpreter = old_lua_current_interpreter;
return NULL;
}
if (ret_type == WEECHAT_SCRIPT_EXEC_STRING)
ret_value = strdup ((char *) lua_tostring (lua_current_interpreter, -1));
else if (ret_type == WEECHAT_SCRIPT_EXEC_INT)
{
ret_i = malloc (sizeof (*ret_i));
if (ret_i)
*ret_i = lua_tonumber (lua_current_interpreter, -1);
ret_value = ret_i;
}
else if (ret_type == WEECHAT_SCRIPT_EXEC_HASHTABLE)
{
ret_value = weechat_lua_tohashtable (lua_current_interpreter, -1,
WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE);
}
else
{
WEECHAT_SCRIPT_MSG_WRONG_ARGS(LUA_CURRENT_SCRIPT_NAME, function);
lua_current_script = old_lua_current_script;
lua_current_interpreter = old_lua_current_interpreter;
return NULL;
}
lua_current_script = old_lua_current_script;
lua_current_interpreter = old_lua_current_interpreter;
return ret_value;
}
void *
weechat_js_exec (struct t_plugin_script *script,
int ret_type, const char *function,
const char *format, void **argv)
{
struct t_plugin_script *old_js_current_script;
WeechatJsV8 *js_v8;
void *ret_value;
v8::Handle<v8::Value> argv2[16], ret_js;
int i, argc, *ret_int;
ret_value = NULL;
old_js_current_script = js_current_script;
js_current_script = script;
js_v8 = (WeechatJsV8 *)(script->interpreter);
if (!js_v8->functionExists(function))
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to run function \"%s\""),
weechat_prefix ("error"), JS_PLUGIN_NAME, function);
goto end;
}
argc = 0;
if (format && format[0])
{
argc = strlen (format);
for (i = 0; i < argc; i++)
{
switch (format[i])
{
case 's': /* string */
argv2[i] = v8::String::New((const char *)argv[i]);
break;
case 'i': /* integer */
argv2[i] = v8::Integer::New(*((int *)argv[i]));
break;
case 'h': /* hash */
argv2[i] = weechat_js_hashtable_to_object (
(struct t_hashtable *)argv[i]);
break;
}
}
}
ret_js = js_v8->execFunction(function,
argc,
(argc > 0) ? argv2 : NULL);
if (!ret_js.IsEmpty())
{
if ((ret_type == WEECHAT_SCRIPT_EXEC_STRING) && (ret_js->IsString()))
{
v8::String::Utf8Value temp_str(ret_js);
ret_value = (*temp_str) ? strdup(*temp_str) : NULL;
}
else if ((ret_type == WEECHAT_SCRIPT_EXEC_INT) && (ret_js->IsInt32()))
{
ret_int = (int *)malloc (sizeof (*ret_int));
if (ret_int)
*ret_int = (int)(ret_js->IntegerValue());
ret_value = ret_int;
}
else if ((ret_type == WEECHAT_SCRIPT_EXEC_HASHTABLE)
&& (ret_js->IsObject()))
{
ret_value = (struct t_hashtable *)weechat_js_object_to_hashtable (
ret_js->ToObject(),
WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_STRING);
}
else
{
if (ret_type != WEECHAT_SCRIPT_EXEC_IGNORE)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"%s\" must "
"return a valid value"),
weechat_prefix ("error"), JS_PLUGIN_NAME,
function);
}
}
}
if ((ret_type != WEECHAT_SCRIPT_EXEC_IGNORE) && !ret_value)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: error in function \"%s\""),
weechat_prefix ("error"), JS_PLUGIN_NAME, function);
}
end:
js_current_script = old_js_current_script;
return ret_value;
}
int
weechat_python_load (const char *filename)
{
char *argv[] = { "__weechat_plugin__" , NULL };
#if PY_MAJOR_VERSION >= 3
wchar_t *wargv[] = { NULL, NULL };
#endif
FILE *fp;
PyObject *weechat_outputs, *python_path, *path;
const char *weechat_home;
char *str_home;
int len;
if ((fp = fopen (filename, "r")) == NULL)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: script \"%s\" not found"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, filename);
return 0;
}
if ((weechat_python_plugin->debug >= 2) || !python_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: loading script \"%s\""),
PYTHON_PLUGIN_NAME, filename);
}
python_current_script = NULL;
python_registered_script = NULL;
/* PyEval_AcquireLock (); */
python_current_interpreter = Py_NewInterpreter ();
#if PY_MAJOR_VERSION >= 3
/* python >= 3.x */
len = mbstowcs (NULL, argv[0], 0) + 1;
wargv[0] = malloc ((len + 1) * sizeof (wargv[0][0]));
if (wargv[0])
{
if (mbstowcs (wargv[0], argv[0], len) == (size_t)(-1))
{
free (wargv[0]);
wargv[0] = NULL;
}
PySys_SetArgv(1, wargv);
if (wargv[0])
free (wargv[0]);
}
#else
/* python <= 2.x */
PySys_SetArgv(1, argv);
#endif
if (!python_current_interpreter)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to create new "
"sub-interpreter"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME);
fclose (fp);
/* PyEval_ReleaseLock (); */
return 0;
}
PyThreadState_Swap (python_current_interpreter);
/* adding $weechat_dir/python in $PYTHONPATH */
python_path = PySys_GetObject ("path");
weechat_home = weechat_info_get ("weechat_dir", "");
if (weechat_home)
{
len = strlen (weechat_home) + 1 + strlen (PYTHON_PLUGIN_NAME) + 1;
str_home = malloc (len);
if (str_home)
{
snprintf (str_home, len, "%s/python", weechat_home);
#if PY_MAJOR_VERSION >= 3
/* python >= 3.x */
path = PyUnicode_FromString(str_home);
#else
/* python <= 2.x */
path = PyBytes_FromString (str_home);
#endif
if (path != NULL)
{
PyList_Insert (python_path, 0, path);
Py_DECREF (path);
}
free (str_home);
}
}
#if PY_MAJOR_VERSION >= 3
/* python >= 3.x */
weechat_outputs = PyModule_Create (&moduleDefOutputs);
#else
/* python <= 2.x */
weechat_outputs = Py_InitModule("weechatOutputs",
weechat_python_output_funcs);
#endif
if (!weechat_outputs)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to redirect stdout and "
"stderr"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME);
}
else
{
if (PySys_SetObject("stdout", weechat_outputs) == -1)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to redirect stdout"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME);
}
if (PySys_SetObject("stderr", weechat_outputs) == -1)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to redirect stderr"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME);
}
}
python_current_script_filename = filename;
if (PyRun_SimpleFile (fp, filename) != 0)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to parse file \"%s\""),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, filename);
fclose (fp);
if (PyErr_Occurred ())
PyErr_Print ();
/* if script was registered, remove it from list */
if (python_current_script != NULL)
{
plugin_script_remove (weechat_python_plugin,
&python_scripts, &last_python_script,
python_current_script);
}
Py_EndInterpreter (python_current_interpreter);
/* PyEval_ReleaseLock (); */
return 0;
}
if (PyErr_Occurred ())
PyErr_Print ();
fclose (fp);
if (!python_registered_script)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"register\" not "
"found (or failed) in file \"%s\""),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, filename);
if (PyErr_Occurred ())
PyErr_Print ();
Py_EndInterpreter (python_current_interpreter);
/* PyEval_ReleaseLock (); */
return 0;
}
python_current_script = python_registered_script;
/* PyEval_ReleaseThread (python_current_script->interpreter); */
/*
* set input/close callbacks for buffers created by this script
* (to restore callbacks after upgrade)
*/
plugin_script_set_buffer_callbacks (weechat_python_plugin,
python_scripts,
python_current_script,
&weechat_python_api_buffer_input_data_cb,
&weechat_python_api_buffer_close_cb);
(void) weechat_hook_signal_send ("python_script_loaded",
WEECHAT_HOOK_SIGNAL_STRING,
python_current_script->filename);
return 1;
}
void weechat_python_init_module_weechat ()
#endif
{
PyObject *weechat_module, *weechat_dict;
#if PY_MAJOR_VERSION >= 3
/* python >= 3.x */
weechat_module = PyModule_Create (&moduleDef);
#else
/* python <= 2.x */
weechat_module = Py_InitModule ("weechat", weechat_python_funcs);
#endif
if (!weechat_module)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to initialize WeeChat "
"module"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME);
#if PY_MAJOR_VERSION >= 3
return NULL;
#else
return;
#endif
}
/* define some constants */
weechat_dict = PyModule_GetDict(weechat_module);
PyDict_SetItemString(weechat_dict, "WEECHAT_RC_OK", PyLong_FromLong((long) WEECHAT_RC_OK));
PyDict_SetItemString(weechat_dict, "WEECHAT_RC_OK_EAT", PyLong_FromLong((long) WEECHAT_RC_OK_EAT));
PyDict_SetItemString(weechat_dict, "WEECHAT_RC_ERROR", PyLong_FromLong((long) WEECHAT_RC_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_READ_OK", PyLong_FromLong((long) WEECHAT_CONFIG_READ_OK));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_READ_MEMORY_ERROR", PyLong_FromLong((long) WEECHAT_CONFIG_READ_MEMORY_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_READ_FILE_NOT_FOUND", PyLong_FromLong((long) WEECHAT_CONFIG_READ_FILE_NOT_FOUND));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_WRITE_OK", PyLong_FromLong((long) WEECHAT_CONFIG_WRITE_OK));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_WRITE_ERROR", PyLong_FromLong((long) WEECHAT_CONFIG_WRITE_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_WRITE_MEMORY_ERROR", PyLong_FromLong((long) WEECHAT_CONFIG_WRITE_MEMORY_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_SET_OK_CHANGED", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_SET_OK_CHANGED));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_SET_ERROR", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_SET_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_UNSET_OK_RESET", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_UNSET_OK_RESET));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED));
PyDict_SetItemString(weechat_dict, "WEECHAT_CONFIG_OPTION_UNSET_ERROR", PyLong_FromLong((long) WEECHAT_CONFIG_OPTION_UNSET_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_LIST_POS_SORT", PyUnicode_FromString(WEECHAT_LIST_POS_SORT));
PyDict_SetItemString(weechat_dict, "WEECHAT_LIST_POS_BEGINNING", PyUnicode_FromString(WEECHAT_LIST_POS_BEGINNING));
PyDict_SetItemString(weechat_dict, "WEECHAT_LIST_POS_END", PyUnicode_FromString(WEECHAT_LIST_POS_END));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOTLIST_LOW", PyUnicode_FromString(WEECHAT_HOTLIST_LOW));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOTLIST_MESSAGE", PyUnicode_FromString(WEECHAT_HOTLIST_MESSAGE));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOTLIST_PRIVATE", PyUnicode_FromString(WEECHAT_HOTLIST_PRIVATE));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOTLIST_HIGHLIGHT", PyUnicode_FromString(WEECHAT_HOTLIST_HIGHLIGHT));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_PROCESS_RUNNING", PyLong_FromLong((long) WEECHAT_HOOK_PROCESS_RUNNING));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_PROCESS_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_PROCESS_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_OK", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_OK));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_ADDRESS_NOT_FOUND", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_ADDRESS_NOT_FOUND));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_IP_ADDRESS_NOT_FOUND", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_IP_ADDRESS_NOT_FOUND));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_CONNECTION_REFUSED", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_CONNECTION_REFUSED));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_PROXY_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_PROXY_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_LOCAL_HOSTNAME_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_LOCAL_HOSTNAME_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_GNUTLS_INIT_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_GNUTLS_INIT_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_GNUTLS_HANDSHAKE_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_GNUTLS_HANDSHAKE_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_MEMORY_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_MEMORY_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_TIMEOUT", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_TIMEOUT));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_CONNECT_SOCKET_ERROR", PyLong_FromLong((long) WEECHAT_HOOK_CONNECT_SOCKET_ERROR));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_SIGNAL_STRING", PyUnicode_FromString(WEECHAT_HOOK_SIGNAL_STRING));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_SIGNAL_INT", PyUnicode_FromString(WEECHAT_HOOK_SIGNAL_INT));
PyDict_SetItemString(weechat_dict, "WEECHAT_HOOK_SIGNAL_POINTER", PyUnicode_FromString(WEECHAT_HOOK_SIGNAL_POINTER));
#if PY_MAJOR_VERSION >= 3
return weechat_module;
#endif
}
struct t_plugin_script *
weechat_js_load (const char *filename, const char *code)
{
char *source;
/* make C compiler happy */
/* TODO: implement load of code in Javascript */
(void) code;
source = weechat_file_get_content (filename);
if (!source)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: script \"%s\" not found"),
weechat_prefix ("error"), JS_PLUGIN_NAME, filename);
return NULL;
}
if ((weechat_js_plugin->debug >= 2) || !js_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: loading script \"%s\""),
JS_PLUGIN_NAME, filename);
}
js_current_script = NULL;
js_registered_script = NULL;
js_current_interpreter = new WeechatJsV8();
if (!js_current_interpreter)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to create new "
"sub-interpreter"),
weechat_prefix ("error"), JS_PLUGIN_NAME);
free (source);
return NULL;
}
/* load libs */
js_current_interpreter->loadLibs();
js_current_script_filename = filename;
if (!js_current_interpreter->load(source))
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to load file \"%s\""),
weechat_prefix ("error"), JS_PLUGIN_NAME);
delete js_current_interpreter;
free (source);
/* if script was registered, remove it from list */
if (js_current_script)
{
plugin_script_remove (weechat_js_plugin,
&js_scripts, &last_js_script,
js_current_script);
js_current_script = NULL;
}
return NULL;
}
free (source);
if (!js_current_interpreter->execScript())
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to execute file "
"\"%s\""),
weechat_prefix ("error"), JS_PLUGIN_NAME, filename);
delete js_current_interpreter;
/* if script was registered, remove it from list */
if (js_current_script)
{
plugin_script_remove (weechat_js_plugin,
&js_scripts, &last_js_script,
js_current_script);
js_current_script = NULL;
}
return NULL;
}
if (!js_registered_script)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"register\" not "
"found (or failed) in file \"%s\""),
weechat_prefix ("error"), JS_PLUGIN_NAME, filename);
delete js_current_interpreter;
return NULL;
}
js_current_script = js_registered_script;
/*
* set input/close callbacks for buffers created by this script
* (to restore callbacks after upgrade)
*/
plugin_script_set_buffer_callbacks (weechat_js_plugin,
js_scripts,
js_current_script,
&weechat_js_api_buffer_input_data_cb,
&weechat_js_api_buffer_close_cb);
weechat_hook_signal_send ("javascript_script_loaded",
WEECHAT_HOOK_SIGNAL_STRING,
js_current_script->filename);
return js_current_script;
}
void *
weechat_python_exec (struct t_plugin_script *script,
int ret_type, const char *function,
char *format, void **argv)
{
struct t_plugin_script *old_python_current_script;
PyThreadState *old_interpreter;
PyObject *evMain, *evDict, *evFunc, *rc;
void *argv2[16], *ret_value;
int i, argc, *ret_int;
ret_value = NULL;
/* PyEval_AcquireLock (); */
old_python_current_script = python_current_script;
python_current_script = script;
old_interpreter = NULL;
if (script->interpreter)
{
old_interpreter = PyThreadState_Swap (NULL);
PyThreadState_Swap (script->interpreter);
}
evMain = PyImport_AddModule ((char *) "__main__");
evDict = PyModule_GetDict (evMain);
evFunc = PyDict_GetItemString (evDict, function);
if ( !(evFunc && PyCallable_Check (evFunc)) )
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to run function \"%s\""),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, function);
/* PyEval_ReleaseThread (python_current_script->interpreter); */
goto end;
}
if (argv && argv[0])
{
argc = strlen (format);
for (i = 0; i < 16; i++)
{
argv2[i] = (i < argc) ? argv[i] : NULL;
}
rc = PyObject_CallFunction (evFunc, format,
argv2[0], argv2[1],
argv2[2], argv2[3],
argv2[4], argv2[5],
argv2[6], argv2[7],
argv2[8], argv2[9],
argv2[10], argv2[11],
argv2[12], argv2[13],
argv2[14], argv2[15]);
}
else
{
rc = PyObject_CallFunction (evFunc, NULL);
}
/*
* ugly hack : rc = NULL while 'return weechat.WEECHAT_RC_OK ....
* because of '#define WEECHAT_RC_OK 0'
*/
if (rc == NULL)
rc = PyLong_FromLong ((long)0);
if (PyErr_Occurred())
{
PyErr_Print ();
Py_XDECREF(rc);
}
else if ((ret_type == WEECHAT_SCRIPT_EXEC_STRING) && (PyUnicode_Check (rc)))
{
ret_value = weechat_python_unicode_to_string (rc);
Py_XDECREF(rc);
}
else if ((ret_type == WEECHAT_SCRIPT_EXEC_STRING) && (PyBytes_Check (rc)))
{
if (PyBytes_AsString (rc))
ret_value = strdup (PyBytes_AsString (rc));
else
ret_value = NULL;
Py_XDECREF(rc);
}
else if ((ret_type == WEECHAT_SCRIPT_EXEC_INT) && (PY_INTEGER_CHECK(rc)))
{
ret_int = malloc (sizeof (*ret_int));
if (ret_int)
*ret_int = (int) PyLong_AsLong (rc);
ret_value = ret_int;
Py_XDECREF(rc);
}
else if (ret_type == WEECHAT_SCRIPT_EXEC_HASHTABLE)
{
ret_value = weechat_python_dict_to_hashtable (rc,
WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_STRING);
Py_XDECREF(rc);
}
else
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"%s\" must return "
"a valid value"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, function);
}
if (!ret_value)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: error in function \"%s\""),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME, function);
}
/* PyEval_ReleaseThread (python_current_script->interpreter); */
end:
python_current_script = old_python_current_script;
if (old_interpreter)
PyThreadState_Swap (old_interpreter);
return ret_value;
}
int
weechat_plugin_init (struct t_weechat_plugin *plugin, int argc, char *argv[])
{
struct t_plugin_script_init init;
weechat_python_plugin = plugin;
/*
* hook info to get path to python 2.x interpreter
* (some scripts using hook_process need that)
*/
weechat_python_set_python2_bin ();
weechat_hook_info ("python2_bin",
N_("path to python 2.x interpreter"),
NULL,
&weechat_python_info_cb, NULL);
/* init stdout/stderr buffer */
python_buffer_output[0] = '\0';
PyImport_AppendInittab("weechat",
&weechat_python_init_module_weechat);
Py_Initialize ();
if (Py_IsInitialized () == 0)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to launch global "
"interpreter"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME);
return WEECHAT_RC_ERROR;
}
/* PyEval_InitThreads(); */
/* python_mainThreadState = PyThreadState_Swap(NULL); */
python_mainThreadState = PyEval_SaveThread();
/* PyEval_ReleaseLock (); */
if (!python_mainThreadState)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to get current "
"interpreter state"),
weechat_prefix ("error"), PYTHON_PLUGIN_NAME);
return WEECHAT_RC_ERROR;
}
init.callback_command = &weechat_python_command_cb;
init.callback_completion = &weechat_python_completion_cb;
init.callback_hdata = &weechat_python_hdata_cb;
init.callback_infolist = &weechat_python_infolist_cb;
init.callback_signal_debug_dump = &weechat_python_signal_debug_dump_cb;
init.callback_signal_debug_libs = &weechat_python_signal_debug_libs_cb;
init.callback_signal_buffer_closed = &weechat_python_signal_buffer_closed_cb;
init.callback_signal_script_action = &weechat_python_signal_script_action_cb;
init.callback_load_file = &weechat_python_load_cb;
python_quiet = 1;
plugin_script_init (weechat_python_plugin, argc, argv, &init);
python_quiet = 0;
plugin_script_display_short_list (weechat_python_plugin,
python_scripts);
/* init OK */
return WEECHAT_RC_OK;
}
int
weechat_perl_load (const char *filename)
{
struct t_plugin_script temp_script;
struct stat buf;
char *perl_code;
int length;
#ifndef MULTIPLICITY
char pkgname[64];
#endif /* MULTIPLICITY */
temp_script.filename = NULL;
temp_script.interpreter = NULL;
temp_script.name = NULL;
temp_script.author = NULL;
temp_script.version = NULL;
temp_script.license = NULL;
temp_script.description = NULL;
temp_script.shutdown_func = NULL;
temp_script.charset = NULL;
if (stat (filename, &buf) != 0)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: script \"%s\" not found"),
weechat_prefix ("error"), PERL_PLUGIN_NAME, filename);
return 0;
}
if ((weechat_perl_plugin->debug >= 2) || !perl_quiet)
{
weechat_printf (NULL,
weechat_gettext ("%s: loading script \"%s\""),
PERL_PLUGIN_NAME, filename);
}
perl_current_script = NULL;
perl_current_script_filename = filename;
perl_registered_script = NULL;
#ifdef MULTIPLICITY
perl_current_interpreter = perl_alloc();
if (!perl_current_interpreter)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to create new "
"sub-interpreter"),
weechat_prefix ("error"), PERL_PLUGIN_NAME);
return 0;
}
PERL_SET_CONTEXT (perl_current_interpreter);
perl_construct (perl_current_interpreter);
temp_script.interpreter = (PerlInterpreter *) perl_current_interpreter;
perl_parse (perl_current_interpreter, weechat_perl_api_init,
perl_args_count, perl_args, NULL);
length = strlen (perl_weechat_code) - 2 + strlen (filename) + 1;
perl_code = malloc (length);
if (!perl_code)
return 0;
snprintf (perl_code, length, perl_weechat_code, filename);
#else
snprintf (pkgname, sizeof (pkgname), "%s%d", PKG_NAME_PREFIX, perl_num);
perl_num++;
length = strlen (perl_weechat_code) - 4 + strlen (pkgname) + strlen (filename) + 1;
perl_code = malloc (length);
if (!perl_code)
return 0;
snprintf (perl_code, length, perl_weechat_code, pkgname, filename);
#endif /* MULTIPLICITY */
eval_pv (perl_code, TRUE);
free (perl_code);
if (SvTRUE (ERRSV))
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unable to parse file "
"\"%s\""),
weechat_prefix ("error"), PERL_PLUGIN_NAME,
filename);
weechat_printf (NULL,
weechat_gettext ("%s%s: error: %s"),
weechat_prefix ("error"), PERL_PLUGIN_NAME,
SvPV_nolen(ERRSV));
#ifdef MULTIPLICITY
perl_destruct (perl_current_interpreter);
perl_free (perl_current_interpreter);
#endif /* MULTIPLICITY */
if (perl_current_script && (perl_current_script != &temp_script))
{
plugin_script_remove (weechat_perl_plugin,
&perl_scripts, &last_perl_script,
perl_current_script);
perl_current_script = NULL;
}
return 0;
}
if (!perl_registered_script)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"register\" not "
"found (or failed) in file \"%s\""),
weechat_prefix ("error"), PERL_PLUGIN_NAME, filename);
#ifdef MULTIPLICITY
perl_destruct (perl_current_interpreter);
perl_free (perl_current_interpreter);
#endif /* MULTIPLICITY */
return 0;
}
perl_current_script = perl_registered_script;
#ifndef MULTIPLICITY
perl_current_script->interpreter = strdup (pkgname);
#endif /* MULTIPLICITY */
/*
* set input/close callbacks for buffers created by this script
* (to restore callbacks after upgrade)
*/
plugin_script_set_buffer_callbacks (weechat_perl_plugin,
perl_scripts,
perl_current_script,
&weechat_perl_api_buffer_input_data_cb,
&weechat_perl_api_buffer_close_cb);
(void) weechat_hook_signal_send ("perl_script_loaded",
WEECHAT_HOOK_SIGNAL_STRING,
perl_current_script->filename);
return 1;
}
int
weechat_lua_command_cb (void *data, struct t_gui_buffer *buffer,
int argc, char **argv, char **argv_eol)
{
char *ptr_name, *path_script;
/* make C compiler happy */
(void) data;
(void) buffer;
if (argc == 1)
{
plugin_script_display_list (weechat_lua_plugin, lua_scripts,
NULL, 0);
}
else if (argc == 2)
{
if (weechat_strcasecmp (argv[1], "list") == 0)
{
plugin_script_display_list (weechat_lua_plugin, lua_scripts,
NULL, 0);
}
else if (weechat_strcasecmp (argv[1], "listfull") == 0)
{
plugin_script_display_list (weechat_lua_plugin, lua_scripts,
NULL, 1);
}
else if (weechat_strcasecmp (argv[1], "autoload") == 0)
{
plugin_script_auto_load (weechat_lua_plugin, &weechat_lua_load_cb);
}
else if (weechat_strcasecmp (argv[1], "reload") == 0)
{
weechat_lua_unload_all ();
plugin_script_auto_load (weechat_lua_plugin, &weechat_lua_load_cb);
}
else if (weechat_strcasecmp (argv[1], "unload") == 0)
{
weechat_lua_unload_all ();
}
}
else
{
if (weechat_strcasecmp (argv[1], "list") == 0)
{
plugin_script_display_list (weechat_lua_plugin, lua_scripts,
argv_eol[2], 0);
}
else if (weechat_strcasecmp (argv[1], "listfull") == 0)
{
plugin_script_display_list (weechat_lua_plugin, lua_scripts,
argv_eol[2], 1);
}
else if ((weechat_strcasecmp (argv[1], "load") == 0)
|| (weechat_strcasecmp (argv[1], "reload") == 0)
|| (weechat_strcasecmp (argv[1], "unload") == 0))
{
ptr_name = argv_eol[2];
if (strncmp (ptr_name, "-q ", 3) == 0)
{
lua_quiet = 1;
ptr_name += 3;
while (ptr_name[0] == ' ')
{
ptr_name++;
}
}
if (weechat_strcasecmp (argv[1], "load") == 0)
{
/* load Lua script */
path_script = plugin_script_search_path (weechat_lua_plugin,
ptr_name);
weechat_lua_load ((path_script) ? path_script : ptr_name);
if (path_script)
free (path_script);
}
else if (weechat_strcasecmp (argv[1], "reload") == 0)
{
/* reload one Lua script */
weechat_lua_reload_name (ptr_name);
}
else if (weechat_strcasecmp (argv[1], "unload") == 0)
{
/* unload Lua script */
weechat_lua_unload_name (ptr_name);
}
lua_quiet = 0;
}
else
{
weechat_printf (NULL,
weechat_gettext ("%s%s: unknown option for "
"command \"%s\""),
weechat_prefix ("error"), LUA_PLUGIN_NAME, "lua");
}
}
return WEECHAT_RC_OK;
}
void *
weechat_perl_exec (struct t_plugin_script *script,
int ret_type, const char *function,
const char *format, void **argv)
{
char *func;
unsigned int count;
void *ret_value;
int *ret_i, mem_err, length, i, argc;
SV *ret_s;
HV *hash;
struct t_plugin_script *old_perl_current_script;
#ifdef MULTIPLICITY
void *old_context;
#endif /* MULTIPLICITY */
old_perl_current_script = perl_current_script;
perl_current_script = script;
#ifdef MULTIPLICITY
(void) length;
func = (char *) function;
old_context = PERL_GET_CONTEXT;
if (script->interpreter)
PERL_SET_CONTEXT (script->interpreter);
#else
length = strlen ((script->interpreter) ? script->interpreter : perl_main) +
strlen (function) + 3;
func = (char *) malloc (length);
if (!func)
return NULL;
snprintf (func, length, "%s::%s",
(char *) ((script->interpreter) ? script->interpreter : perl_main),
function);
#endif /* MULTIPLICITY */
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
if (format && format[0])
{
argc = strlen (format);
for (i = 0; i < argc; i++)
{
switch (format[i])
{
case 's': /* string */
XPUSHs(sv_2mortal(newSVpv((char *)argv[i], 0)));
break;
case 'i': /* integer */
XPUSHs(sv_2mortal(newSViv(*((int *)argv[i]))));
break;
case 'h': /* hash */
hash = weechat_perl_hashtable_to_hash (argv[i]);
XPUSHs(sv_2mortal(newRV_inc((SV *)hash)));
break;
}
}
}
PUTBACK;
count = call_pv (func, G_EVAL | G_SCALAR);
ret_value = NULL;
mem_err = 1;
SPAGAIN;
if (SvTRUE (ERRSV))
{
weechat_printf (NULL,
weechat_gettext ("%s%s: error: %s"),
weechat_prefix ("error"), PERL_PLUGIN_NAME,
SvPV_nolen (ERRSV));
(void) POPs; /* poping the 'undef' */
mem_err = 0;
}
else
{
if (count != 1)
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"%s\" must "
"return one valid value (%d)"),
weechat_prefix ("error"), PERL_PLUGIN_NAME,
function, count);
mem_err = 0;
}
else
{
if (ret_type == WEECHAT_SCRIPT_EXEC_STRING)
{
ret_s = newSVsv(POPs);
ret_value = strdup (SvPV_nolen (ret_s));
SvREFCNT_dec (ret_s);
}
else if (ret_type == WEECHAT_SCRIPT_EXEC_INT)
{
ret_i = malloc (sizeof (*ret_i));
if (ret_i)
*ret_i = POPi;
ret_value = ret_i;
}
else if (ret_type == WEECHAT_SCRIPT_EXEC_HASHTABLE)
{
ret_value = weechat_perl_hash_to_hashtable (POPs,
WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_STRING);
}
else
{
weechat_printf (NULL,
weechat_gettext ("%s%s: function \"%s\" is "
"internally misused"),
weechat_prefix ("error"), PERL_PLUGIN_NAME,
function);
mem_err = 0;
}
}
}
PUTBACK;
FREETMPS;
LEAVE;
perl_current_script = old_perl_current_script;
#ifdef MULTIPLICITY
PERL_SET_CONTEXT (old_context);
#else
free (func);
#endif /* MULTIPLICITY */
if (!ret_value && (mem_err == 1))
{
weechat_printf (NULL,
weechat_gettext ("%s%s: not enough memory in function "
"\"%s\""),
weechat_prefix ("error"), PERL_PLUGIN_NAME, function);
return NULL;
}
return ret_value;
}
