自学教程：C++ weechat_gettext函数代码示例

voidweechat_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);    }}

intweechat_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;}

voidweechat_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);}

voidweechat_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);}

voidweechat_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);}

voidweechat_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 VALUEweechat_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;}

intweechat_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;}

voidweechat_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);    }}

voidweechat_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;    }}

voidweechat_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);    }}

voidweechat_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);}

voidweechat_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);}

voidweechat_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);}

voidweechat_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);}

voidweechat_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);}

voidweechat_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);}

intweechat_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;}

intweechat_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)//.........这里部分代码省略.........

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;}

intweechat_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//.........这里部分代码省略.........

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//.........这里部分代码省略.........

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);    }//.........这里部分代码省略.........

intweechat_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;}

intweechat_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;    }//.........这里部分代码省略.........

intweechat_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));//.........这里部分代码省略.........