summaryrefslogtreecommitdiff
path: root/src/plugins/ruby
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins/ruby')
-rw-r--r--src/plugins/ruby/CMakeLists.txt30
-rw-r--r--src/plugins/ruby/Makefile.am33
-rw-r--r--src/plugins/ruby/weechat-ruby-api.c6867
-rw-r--r--src/plugins/ruby/weechat-ruby-api.h31
-rw-r--r--src/plugins/ruby/weechat-ruby.c1112
-rw-r--r--src/plugins/ruby/weechat-ruby.h45
6 files changed, 8118 insertions, 0 deletions
diff --git a/src/plugins/ruby/CMakeLists.txt b/src/plugins/ruby/CMakeLists.txt
new file mode 100644
index 000000000..5f2aa86ee
--- /dev/null
+++ b/src/plugins/ruby/CMakeLists.txt
@@ -0,0 +1,30 @@
+#
+# Copyright (C) 2003-2012 Sebastien Helleu <flashcode@flashtux.org>
+#
+# This file is part of WeeChat, the extensible chat client.
+#
+# WeeChat is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# WeeChat is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with WeeChat. If not, see <http://www.gnu.org/licenses/>.
+#
+
+ADD_LIBRARY(ruby MODULE weechat-ruby.c weechat-ruby.h weechat-ruby-api.c
+weechat-ruby-api.h)
+
+SET_TARGET_PROPERTIES(ruby PROPERTIES PREFIX "")
+
+IF(RUBY_FOUND)
+ INCLUDE_DIRECTORIES(${RUBY_INCLUDE_PATH} ${RUBY_ARCH})
+ TARGET_LINK_LIBRARIES(ruby ${RUBY_LIBRARY} weechat_plugins_scripts)
+ENDIF(RUBY_FOUND)
+
+INSTALL(TARGETS ruby LIBRARY DESTINATION ${LIBDIR}/plugins)
diff --git a/src/plugins/ruby/Makefile.am b/src/plugins/ruby/Makefile.am
new file mode 100644
index 000000000..dedb40944
--- /dev/null
+++ b/src/plugins/ruby/Makefile.am
@@ -0,0 +1,33 @@
+#
+# Copyright (C) 2003-2012 Sebastien Helleu <flashcode@flashtux.org>
+#
+# This file is part of WeeChat, the extensible chat client.
+#
+# WeeChat is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# WeeChat is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with WeeChat. If not, see <http://www.gnu.org/licenses/>.
+#
+
+INCLUDES = -DLOCALEDIR=\"$(datadir)/locale\" $(RUBY_CFLAGS)
+
+libdir = ${weechat_libdir}/plugins
+
+lib_LTLIBRARIES = ruby.la
+
+ruby_la_SOURCES = weechat-ruby.c \
+ weechat-ruby.h \
+ weechat-ruby-api.c \
+ weechat-ruby-api.h
+ruby_la_LDFLAGS = -module
+ruby_la_LIBADD = ../lib_weechat_plugins_scripts.la $(RUBY_LFLAGS)
+
+EXTRA_DIST = CMakeLists.txt
diff --git a/src/plugins/ruby/weechat-ruby-api.c b/src/plugins/ruby/weechat-ruby-api.c
new file mode 100644
index 000000000..f2ea2bba8
--- /dev/null
+++ b/src/plugins/ruby/weechat-ruby-api.c
@@ -0,0 +1,6867 @@
+/*
+ * Copyright (C) 2003-2012 Sebastien Helleu <flashcode@flashtux.org>
+ * Copyright (C) 2005-2007 Emmanuel Bouthenot <kolter@openics.org>
+ *
+ * This file is part of WeeChat, the extensible chat client.
+ *
+ * WeeChat is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * WeeChat is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with WeeChat. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * weechat-ruby-api.c: ruby API functions
+ */
+
+#undef _
+
+#include <ruby.h>
+#include <time.h>
+
+#include "../weechat-plugin.h"
+#include "../plugin-script.h"
+#include "../plugin-script-api.h"
+#include "../plugin-script-callback.h"
+#include "weechat-ruby.h"
+
+
+#define API_FUNC(__init, __name, __ret) \
+ char *ruby_function_name = __name; \
+ (void) class; \
+ if (__init \
+ && (!ruby_current_script || !ruby_current_script->name)) \
+ { \
+ WEECHAT_SCRIPT_MSG_NOT_INIT(RUBY_CURRENT_SCRIPT_NAME, \
+ ruby_function_name); \
+ __ret; \
+ }
+#define API_WRONG_ARGS(__ret) \
+ { \
+ WEECHAT_SCRIPT_MSG_WRONG_ARGS(RUBY_CURRENT_SCRIPT_NAME, \
+ ruby_function_name); \
+ __ret; \
+ }
+#define API_PTR2STR(__pointer) \
+ plugin_script_ptr2str (__pointer)
+#define API_STR2PTR(__string) \
+ plugin_script_str2ptr (weechat_ruby_plugin, \
+ RUBY_CURRENT_SCRIPT_NAME, \
+ ruby_function_name, __string)
+#define API_RETURN_OK return INT2FIX (1);
+#define API_RETURN_ERROR return INT2FIX (0);
+#define API_RETURN_EMPTY return Qnil;
+#define API_RETURN_STRING(__string) \
+ if (__string) \
+ return rb_str_new2 (__string); \
+ return rb_str_new2 ("")
+#define API_RETURN_STRING_FREE(__string) \
+ if (__string) \
+ { \
+ return_value = rb_str_new2 (__string); \
+ free (__string); \
+ return return_value; \
+ } \
+ return rb_str_new2 ("")
+#define API_RETURN_INT(__int) \
+ return INT2FIX (__int);
+#define API_RETURN_LONG(__long) \
+ return LONG2FIX (__long);
+
+#define API_DEF_FUNC(__name, __argc) \
+ rb_define_module_function (ruby_mWeechat, #__name, \
+ &weechat_ruby_api_##__name, __argc);
+
+
+/*
+ * weechat_ruby_api_register: startup function for all WeeChat Ruby scripts
+ */
+
+static VALUE
+weechat_ruby_api_register (VALUE class, VALUE name, VALUE author,
+ VALUE version, VALUE license, VALUE description,
+ VALUE shutdown_func, VALUE charset)
+{
+ char *c_name, *c_author, *c_version, *c_license, *c_description;
+ char *c_shutdown_func, *c_charset;
+
+ API_FUNC(0, "register", API_RETURN_ERROR);
+ if (ruby_registered_script)
+ {
+ /* script already registered */
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: script \"%s\" already "
+ "registered (register ignored)"),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME,
+ ruby_registered_script->name);
+ API_RETURN_ERROR;
+ }
+ ruby_current_script = NULL;
+ ruby_registered_script = NULL;
+ if (NIL_P (name) || NIL_P (author) || NIL_P (version)
+ || NIL_P (license) || NIL_P (description) || NIL_P (shutdown_func)
+ || NIL_P (charset))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (name, T_STRING);
+ Check_Type (author, T_STRING);
+ Check_Type (version, T_STRING);
+ Check_Type (license, T_STRING);
+ Check_Type (description, T_STRING);
+ Check_Type (shutdown_func, T_STRING);
+ Check_Type (charset, T_STRING);
+
+ c_name = StringValuePtr (name);
+ c_author = StringValuePtr (author);
+ c_version = StringValuePtr (version);
+ c_license = StringValuePtr (license);
+ c_description = StringValuePtr (description);
+ c_shutdown_func = StringValuePtr (shutdown_func);
+ c_charset = StringValuePtr (charset);
+
+ if (plugin_script_search (weechat_ruby_plugin, ruby_scripts, c_name))
+ {
+ /* another script already exists with same name */
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: unable to register script "
+ "\"%s\" (another script already "
+ "exists with this name)"),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME, c_name);
+ API_RETURN_ERROR;
+ }
+
+ /* register script */
+ ruby_current_script = plugin_script_add (weechat_ruby_plugin,
+ &ruby_scripts, &last_ruby_script,
+ (ruby_current_script_filename) ?
+ ruby_current_script_filename : "",
+ c_name, c_author, c_version, c_license,
+ c_description, c_shutdown_func,
+ c_charset);
+
+ if (ruby_current_script)
+ {
+ ruby_registered_script = ruby_current_script;
+ if ((weechat_ruby_plugin->debug >= 2) || !ruby_quiet)
+ {
+ weechat_printf (NULL,
+ weechat_gettext ("%s: registered script \"%s\", "
+ "version %s (%s)"),
+ RUBY_PLUGIN_NAME, c_name, c_version, c_description);
+ }
+ }
+ else
+ {
+ API_RETURN_ERROR;
+ }
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_plugin_get_name: get name of plugin (return "core" for
+ * WeeChat core)
+ */
+
+static VALUE
+weechat_ruby_api_plugin_get_name (VALUE class, VALUE plugin)
+{
+ char *c_plugin;
+ const char *result;
+
+ API_FUNC(1, "plugin_get_name", API_RETURN_EMPTY);
+ if (NIL_P (plugin))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (plugin, T_STRING);
+
+ c_plugin = StringValuePtr (plugin);
+
+ result = weechat_plugin_get_name (API_STR2PTR(c_plugin));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_charset_set: set script charset
+ */
+
+static VALUE
+weechat_ruby_api_charset_set (VALUE class, VALUE charset)
+{
+ char *c_charset;
+
+ API_FUNC(1, "charset_set", API_RETURN_ERROR);
+ if (NIL_P (charset))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (charset, T_STRING);
+
+ c_charset = StringValuePtr (charset);
+
+ plugin_script_api_charset_set (ruby_current_script, c_charset);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_iconv_to_internal: convert string to internal WeeChat charset
+ */
+
+static VALUE
+weechat_ruby_api_iconv_to_internal (VALUE class, VALUE charset, VALUE string)
+{
+ char *c_charset, *c_string, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "iconv_to_internal", API_RETURN_EMPTY);
+ if (NIL_P (charset) || NIL_P (string))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (charset, T_STRING);
+ Check_Type (string, T_STRING);
+
+ c_charset = StringValuePtr (charset);
+ c_string = StringValuePtr (string);
+
+ result = weechat_iconv_to_internal (c_charset, c_string);
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_iconv_from_internal: convert string from WeeChat internal
+ * charset to another one
+ */
+
+static VALUE
+weechat_ruby_api_iconv_from_internal (VALUE class, VALUE charset, VALUE string)
+{
+ char *c_charset, *c_string, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "iconv_from_internal", API_RETURN_EMPTY);
+ if (NIL_P (charset) || NIL_P (string))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (charset, T_STRING);
+ Check_Type (string, T_STRING);
+
+ c_charset = StringValuePtr (charset);
+ c_string = StringValuePtr (string);
+
+ result = weechat_iconv_from_internal (c_charset, c_string);
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_gettext: get translated string
+ */
+
+static VALUE
+weechat_ruby_api_gettext (VALUE class, VALUE string)
+{
+ char *c_string;
+ const char *result;
+
+ API_FUNC(1, "gettext", API_RETURN_EMPTY);
+ if (NIL_P (string))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (string, T_STRING);
+
+ c_string = StringValuePtr (string);
+
+ result = weechat_gettext (c_string);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_ngettext: get translated string with plural form
+ */
+
+static VALUE
+weechat_ruby_api_ngettext (VALUE class, VALUE single, VALUE plural,
+ VALUE count)
+{
+ char *c_single, *c_plural;
+ const char *result;
+ int c_count;
+
+ API_FUNC(1, "ngettext", API_RETURN_EMPTY);
+ if (NIL_P (single) || NIL_P (plural) || NIL_P (count))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (single, T_STRING);
+ Check_Type (plural, T_STRING);
+ Check_Type (count, T_FIXNUM);
+
+ c_single = StringValuePtr (single);
+ c_plural = StringValuePtr (plural);
+ c_count = FIX2INT (count);
+
+ result = weechat_ngettext (c_single, c_plural, c_count);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_string_match: return 1 if string matches a mask
+ * mask can begin or end with "*", no other "*"
+ * are allowed inside mask
+ */
+
+static VALUE
+weechat_ruby_api_string_match (VALUE class, VALUE string, VALUE mask,
+ VALUE case_sensitive)
+{
+ char *c_string, *c_mask;
+ int c_case_sensitive, value;
+
+ API_FUNC(1, "string_match", API_RETURN_INT(0));
+ if (NIL_P (string) || NIL_P (mask) || NIL_P (case_sensitive))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (string, T_STRING);
+ Check_Type (mask, T_STRING);
+ Check_Type (case_sensitive, T_FIXNUM);
+
+ c_string = StringValuePtr (string);
+ c_mask = StringValuePtr (mask);
+ c_case_sensitive = FIX2INT (case_sensitive);
+
+ value = weechat_string_match (c_string, c_mask, c_case_sensitive);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_string_has_highlight: return 1 if string contains a
+ * highlight (using list of words to
+ * highlight)
+ * return 0 if no highlight is found in
+ * string
+ */
+
+static VALUE
+weechat_ruby_api_string_has_highlight (VALUE class, VALUE string,
+ VALUE highlight_words)
+{
+ char *c_string, *c_highlight_words;
+ int value;
+
+ API_FUNC(1, "string_has_highlight", API_RETURN_INT(0));
+ if (NIL_P (string) || NIL_P (highlight_words))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (string, T_STRING);
+ Check_Type (highlight_words, T_STRING);
+
+ c_string = StringValuePtr (string);
+ c_highlight_words = StringValuePtr (highlight_words);
+
+ value = weechat_string_has_highlight (c_string, c_highlight_words);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_string_has_highlight_regex: return 1 if string contains a
+ * highlight (using regular
+ * expression)
+ * return 0 if no highlight is
+ * found in string
+ */
+
+static VALUE
+weechat_ruby_api_string_has_highlight_regex (VALUE class, VALUE string,
+ VALUE regex)
+{
+ char *c_string, *c_regex;
+ int value;
+
+ API_FUNC(1, "string_has_highlight_regex", API_RETURN_INT(0));
+ if (NIL_P (string) || NIL_P (regex))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (string, T_STRING);
+ Check_Type (regex, T_STRING);
+
+ c_string = StringValuePtr (string);
+ c_regex = StringValuePtr (regex);
+
+ value = weechat_string_has_highlight_regex (c_string, c_regex);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_string_mask_to_regex: convert a mask (string with only
+ * "*" as wildcard) to a regex, paying
+ * attention to special chars in a
+ * regex
+ */
+
+static VALUE
+weechat_ruby_api_string_mask_to_regex (VALUE class, VALUE mask)
+{
+ char *c_mask, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "string_mask_to_regex", API_RETURN_EMPTY);
+ if (NIL_P (mask))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (mask, T_STRING);
+
+ c_mask = StringValuePtr (mask);
+
+ result = weechat_string_mask_to_regex (c_mask);
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_string_remove_color: remove WeeChat color codes from string
+ */
+
+static VALUE
+weechat_ruby_api_string_remove_color (VALUE class, VALUE string,
+ VALUE replacement)
+{
+ char *c_string, *c_replacement, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "string_remove_color", API_RETURN_EMPTY);
+ if (NIL_P (string) || NIL_P (replacement))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (string, T_STRING);
+ Check_Type (replacement, T_STRING);
+
+ c_string = StringValuePtr (string);
+ c_replacement = StringValuePtr (replacement);
+
+ result = weechat_string_remove_color (c_string, c_replacement);
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_string_is_command_char: check if first char of string is a
+ * command char
+ */
+
+static VALUE
+weechat_ruby_api_string_is_command_char (VALUE class, VALUE string)
+{
+ char *c_string;
+ int value;
+
+ API_FUNC(1, "string_is_command_char", API_RETURN_INT(0));
+ if (NIL_P (string))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (string, T_STRING);
+
+ c_string = StringValuePtr (string);
+
+ value = weechat_string_is_command_char (c_string);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_string_input_for_buffer: return string with input text
+ * for buffer or empty string if
+ * it's a command
+ */
+
+static VALUE
+weechat_ruby_api_string_input_for_buffer (VALUE class, VALUE string)
+{
+ char *c_string;
+ const char *result;
+
+ API_FUNC(1, "string_input_for_buffer", API_RETURN_EMPTY);
+ if (NIL_P (string))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (string, T_STRING);
+
+ c_string = StringValuePtr (string);
+
+ result = weechat_string_input_for_buffer (c_string);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_mkdir_home: create a directory in WeeChat home
+ */
+
+static VALUE
+weechat_ruby_api_mkdir_home (VALUE class, VALUE directory, VALUE mode)
+{
+ char *c_directory;
+ int c_mode;
+
+ API_FUNC(1, "mkdir_home", API_RETURN_ERROR);
+ if (NIL_P (directory) || NIL_P (mode))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (directory, T_STRING);
+ Check_Type (mode, T_FIXNUM);
+
+ c_directory = StringValuePtr (directory);
+ c_mode = FIX2INT (mode);
+
+ if (weechat_mkdir_home (c_directory, c_mode))
+ API_RETURN_OK;
+
+ API_RETURN_ERROR;
+}
+
+/*
+ * weechat_ruby_api_mkdir: create a directory
+ */
+
+static VALUE
+weechat_ruby_api_mkdir (VALUE class, VALUE directory, VALUE mode)
+{
+ char *c_directory;
+ int c_mode;
+
+ API_FUNC(1, "mkdir", API_RETURN_ERROR);
+ if (NIL_P (directory) || NIL_P (mode))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (directory, T_STRING);
+ Check_Type (mode, T_FIXNUM);
+
+ c_directory = StringValuePtr (directory);
+ c_mode = FIX2INT (mode);
+
+ if (weechat_mkdir (c_directory, c_mode))
+ API_RETURN_OK;
+
+ API_RETURN_ERROR;
+}
+
+/*
+ * weechat_ruby_api_mkdir_parents: create a directory and make parent
+ * directories as needed
+ */
+
+static VALUE
+weechat_ruby_api_mkdir_parents (VALUE class, VALUE directory, VALUE mode)
+{
+ char *c_directory;
+ int c_mode;
+
+ API_FUNC(1, "mkdir_parents", API_RETURN_ERROR);
+ if (NIL_P (directory) || NIL_P (mode))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (directory, T_STRING);
+ Check_Type (mode, T_FIXNUM);
+
+ c_directory = StringValuePtr (directory);
+ c_mode = FIX2INT (mode);
+
+ if (weechat_mkdir_parents (c_directory, c_mode))
+ API_RETURN_OK;
+
+ API_RETURN_ERROR;
+}
+
+/*
+ * weechat_ruby_api_list_new: create a new list
+ */
+
+static VALUE
+weechat_ruby_api_list_new (VALUE class)
+{
+ char *result;
+
+ API_FUNC(1, "list_new", API_RETURN_EMPTY);
+
+ result = API_PTR2STR(weechat_list_new ());
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_list_add: add a string to list
+ */
+
+static VALUE
+weechat_ruby_api_list_add (VALUE class, VALUE weelist, VALUE data, VALUE where,
+ VALUE user_data)
+{
+ char *c_weelist, *c_data, *c_where, *c_user_data, *result;
+
+ API_FUNC(1, "list_add", API_RETURN_EMPTY);
+ if (NIL_P (weelist) || NIL_P (data) || NIL_P (where) || NIL_P (user_data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (weelist, T_STRING);
+ Check_Type (data, T_STRING);
+ Check_Type (where, T_STRING);
+ Check_Type (user_data, T_STRING);
+
+ c_weelist = StringValuePtr (weelist);
+ c_data = StringValuePtr (data);
+ c_where = StringValuePtr (where);
+ c_user_data = StringValuePtr (user_data);
+
+ result = API_PTR2STR(weechat_list_add (API_STR2PTR(c_weelist),
+ c_data,
+ c_where,
+ API_STR2PTR(c_user_data)));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_list_search: search a string in list
+ */
+
+static VALUE
+weechat_ruby_api_list_search (VALUE class, VALUE weelist, VALUE data)
+{
+ char *c_weelist, *c_data, *result;
+
+ API_FUNC(1, "list_search", API_RETURN_EMPTY);
+ if (NIL_P (weelist) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (weelist, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_weelist = StringValuePtr (weelist);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(weechat_list_search (API_STR2PTR(c_weelist),
+ c_data));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_list_search_pos: search position of a string in list
+ */
+
+static VALUE
+weechat_ruby_api_list_search_pos (VALUE class, VALUE weelist, VALUE data)
+{
+ char *c_weelist, *c_data;
+ int pos;
+
+ API_FUNC(1, "list_search_pos", API_RETURN_INT(-1));
+ if (NIL_P (weelist) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_INT(-1));
+
+ Check_Type (weelist, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_weelist = StringValuePtr (weelist);
+ c_data = StringValuePtr (data);
+
+ pos = weechat_list_search_pos (API_STR2PTR(c_weelist), c_data);
+
+ API_RETURN_INT(pos);
+}
+
+/*
+ * weechat_ruby_api_list_casesearch: search a string in list (ignore case)
+ */
+
+static VALUE
+weechat_ruby_api_list_casesearch (VALUE class, VALUE weelist, VALUE data)
+{
+ char *c_weelist, *c_data, *result;
+
+ API_FUNC(1, "list_casesearch", API_RETURN_EMPTY);
+ if (NIL_P (weelist) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (weelist, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_weelist = StringValuePtr (weelist);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(weechat_list_casesearch (API_STR2PTR(c_weelist),
+ c_data));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_list_casesearch_pos: search position of a string in list
+ * (ignore case)
+ */
+
+static VALUE
+weechat_ruby_api_list_casesearch_pos (VALUE class, VALUE weelist, VALUE data)
+{
+ char *c_weelist, *c_data;
+ int pos;
+
+ API_FUNC(1, "list_casesearch_pos", API_RETURN_INT(-1));
+ if (NIL_P (weelist) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_INT(-1));
+
+ Check_Type (weelist, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_weelist = StringValuePtr (weelist);
+ c_data = StringValuePtr (data);
+
+ pos = weechat_list_casesearch_pos (API_STR2PTR(c_weelist), c_data);
+
+ API_RETURN_INT(pos);
+}
+
+/*
+ * weechat_ruby_api_list_get: get item by position
+ */
+
+static VALUE
+weechat_ruby_api_list_get (VALUE class, VALUE weelist, VALUE position)
+{
+ char *c_weelist, *result;
+ int c_position;
+
+ API_FUNC(1, "list_get", API_RETURN_EMPTY);
+ if (NIL_P (weelist) || NIL_P (position))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (weelist, T_STRING);
+ Check_Type (position, T_FIXNUM);
+
+ c_weelist = StringValuePtr (weelist);
+ c_position = FIX2INT (position);
+
+ result = API_PTR2STR(weechat_list_get (API_STR2PTR(c_weelist),
+ c_position));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_list_set: set new value for item
+ */
+
+static VALUE
+weechat_ruby_api_list_set (VALUE class, VALUE item, VALUE new_value)
+{
+ char *c_item, *c_new_value;
+
+ API_FUNC(1, "list_set", API_RETURN_ERROR);
+ if (NIL_P (item) || NIL_P (new_value))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (item, T_STRING);
+ Check_Type (new_value, T_STRING);
+
+ c_item = StringValuePtr (item);
+ c_new_value = StringValuePtr (new_value);
+
+ weechat_list_set (API_STR2PTR(c_item),
+ c_new_value);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_list_next: get next item
+ */
+
+static VALUE
+weechat_ruby_api_list_next (VALUE class, VALUE item)
+{
+ char *c_item, *result;
+
+ API_FUNC(1, "list_next", API_RETURN_EMPTY);
+ if (NIL_P (item))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (item, T_STRING);
+
+ c_item = StringValuePtr (item);
+
+ result = API_PTR2STR(weechat_list_next (API_STR2PTR(c_item)));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_list_prev: get previous item
+ */
+
+static VALUE
+weechat_ruby_api_list_prev (VALUE class, VALUE item)
+{
+ char *c_item, *result;
+
+ API_FUNC(1, "list_prev", API_RETURN_EMPTY);
+ if (NIL_P (item))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (item, T_STRING);
+
+ c_item = StringValuePtr (item);
+
+ result = API_PTR2STR(weechat_list_prev (API_STR2PTR(c_item)));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_list_string: get string value of item
+ */
+
+static VALUE
+weechat_ruby_api_list_string (VALUE class, VALUE item)
+{
+ char *c_item;
+ const char *result;
+
+ API_FUNC(1, "list_string", API_RETURN_EMPTY);
+ if (NIL_P (item))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (item, T_STRING);
+
+ c_item = StringValuePtr (item);
+
+ result = weechat_list_string (API_STR2PTR(c_item));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_list_size: get number of elements in list
+ */
+
+static VALUE
+weechat_ruby_api_list_size (VALUE class, VALUE weelist)
+{
+ char *c_weelist;
+ int size;
+
+ API_FUNC(1, "list_size", API_RETURN_INT(0));
+ if (NIL_P (weelist))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (weelist, T_STRING);
+
+ c_weelist = StringValuePtr (weelist);
+
+ size = weechat_list_size (API_STR2PTR(c_weelist));
+
+ API_RETURN_INT(size);
+}
+
+/*
+ * weechat_ruby_api_list_remove: remove item from list
+ */
+
+static VALUE
+weechat_ruby_api_list_remove (VALUE class, VALUE weelist, VALUE item)
+{
+ char *c_weelist, *c_item;
+
+ API_FUNC(1, "list_remove", API_RETURN_ERROR);
+ if (NIL_P (weelist) || NIL_P (item))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (weelist, T_STRING);
+ Check_Type (item, T_STRING);
+
+ c_weelist = StringValuePtr (weelist);
+ c_item = StringValuePtr (item);
+
+ weechat_list_remove (API_STR2PTR(c_weelist),
+ API_STR2PTR(c_item));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_list_remove_all: remove all items from list
+ */
+
+static VALUE
+weechat_ruby_api_list_remove_all (VALUE class, VALUE weelist)
+{
+ char *c_weelist;
+
+ API_FUNC(1, "list_remove_all", API_RETURN_ERROR);
+ if (NIL_P (weelist))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (weelist, T_STRING);
+
+ c_weelist = StringValuePtr (weelist);
+
+ weechat_list_remove_all (API_STR2PTR(c_weelist));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_list_free: free list
+ */
+
+static VALUE
+weechat_ruby_api_list_free (VALUE class, VALUE weelist)
+{
+ char *c_weelist;
+
+ API_FUNC(1, "list_free", API_RETURN_ERROR);
+ if (NIL_P (weelist))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (weelist, T_STRING);
+
+ c_weelist = StringValuePtr (weelist);
+
+ weechat_list_free (API_STR2PTR(c_weelist));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_config_reload_cb: callback for config reload
+ */
+
+int
+weechat_ruby_api_config_reload_cb (void *data,
+ struct t_config_file *config_file)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[2];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(config_file);
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "ss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_CONFIG_READ_FILE_NOT_FOUND;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+
+ return ret;
+ }
+
+ return WEECHAT_CONFIG_READ_FILE_NOT_FOUND;
+}
+
+/*
+ * weechat_ruby_api_config_new: create a new configuration file
+ */
+
+static VALUE
+weechat_ruby_api_config_new (VALUE class, VALUE name, VALUE function,
+ VALUE data)
+{
+ char *c_name, *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "config_new", API_RETURN_EMPTY);
+ if (NIL_P (name) || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (name, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_name = StringValuePtr (name);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_config_new (weechat_ruby_plugin,
+ ruby_current_script,
+ c_name,
+ &weechat_ruby_api_config_reload_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_config_read_cb: callback for reading option in section
+ */
+
+int
+weechat_ruby_api_config_read_cb (void *data,
+ struct t_config_file *config_file,
+ struct t_config_section *section,
+ const char *option_name, const char *value)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[5];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(config_file);
+ func_argv[2] = API_PTR2STR(section);
+ func_argv[3] = (option_name) ? (char *)option_name : empty_arg;
+ func_argv[4] = (value) ? (char *)value : empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "sssss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_CONFIG_OPTION_SET_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+ if (func_argv[2])
+ free (func_argv[2]);
+
+ return ret;
+ }
+
+ return WEECHAT_CONFIG_OPTION_SET_ERROR;
+}
+
+/*
+ * weechat_ruby_api_config_section_write_cb: callback for writing section
+ */
+
+int
+weechat_ruby_api_config_section_write_cb (void *data,
+ struct t_config_file *config_file,
+ const char *section_name)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[3];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(config_file);
+ func_argv[2] = (section_name) ? (char *)section_name : empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "sss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_CONFIG_WRITE_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+
+ return ret;
+ }
+
+ return WEECHAT_CONFIG_WRITE_ERROR;
+}
+
+/*
+ * weechat_ruby_api_config_section_write_default_cb: callback for writing
+ * default values for section
+ */
+
+int
+weechat_ruby_api_config_section_write_default_cb (void *data,
+ struct t_config_file *config_file,
+ const char *section_name)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[3];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(config_file);
+ func_argv[2] = (section_name) ? (char *)section_name : empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "sss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_CONFIG_WRITE_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+
+ return ret;
+ }
+
+ return WEECHAT_CONFIG_WRITE_ERROR;
+}
+
+/*
+ * weechat_ruby_api_config_section_create_option_cb: callback to create an option
+ */
+
+int
+weechat_ruby_api_config_section_create_option_cb (void *data,
+ struct t_config_file *config_file,
+ struct t_config_section *section,
+ const char *option_name,
+ const char *value)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[5];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(config_file);
+ func_argv[2] = API_PTR2STR(section);
+ func_argv[3] = (option_name) ? (char *)option_name : empty_arg;
+ func_argv[4] = (value) ? (char *)value : empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "sssss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_CONFIG_OPTION_SET_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+ if (func_argv[2])
+ free (func_argv[2]);
+
+ return ret;
+ }
+
+ return WEECHAT_CONFIG_OPTION_SET_ERROR;
+}
+
+/*
+ * weechat_ruby_api_config_section_delete_option_cb: callback to delete an option
+ */
+
+int
+weechat_ruby_api_config_section_delete_option_cb (void *data,
+ struct t_config_file *config_file,
+ struct t_config_section *section,
+ struct t_config_option *option)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[4];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(config_file);
+ func_argv[2] = API_PTR2STR(section);
+ func_argv[3] = API_PTR2STR(option);
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "ssss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_CONFIG_OPTION_UNSET_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+ if (func_argv[2])
+ free (func_argv[2]);
+ if (func_argv[3])
+ free (func_argv[3]);
+
+ return ret;
+ }
+
+ return WEECHAT_CONFIG_OPTION_UNSET_ERROR;
+}
+
+/*
+ * weechat_ruby_api_config_new_section: create a new section in configuration file
+ */
+
+static VALUE
+weechat_ruby_api_config_new_section (VALUE class, VALUE config_file,
+ VALUE name, VALUE user_can_add_options,
+ VALUE user_can_delete_options,
+ VALUE function_read,
+ VALUE data_read,
+ VALUE function_write,
+ VALUE data_write,
+ VALUE function_write_default,
+ VALUE data_write_default,
+ VALUE function_create_option,
+ VALUE data_create_option,
+ VALUE function_delete_option,
+ VALUE data_delete_option)
+{
+ char *c_config_file, *c_name, *c_function_read, *c_data_read;
+ char *c_function_write, *c_data_write, *c_function_write_default;
+ char *c_data_write_default, *c_function_create_option;
+ char *c_data_create_option, *c_function_delete_option;
+ char *c_data_delete_option, *result;
+ int c_user_can_add_options, c_user_can_delete_options;
+ VALUE return_value;
+
+ API_FUNC(1, "config_new_section", API_RETURN_EMPTY);
+ if (NIL_P (config_file) || NIL_P (name) || NIL_P (user_can_add_options)
+ || NIL_P (user_can_delete_options) || NIL_P (function_read)
+ || NIL_P (data_read) || NIL_P (function_write) || NIL_P (data_write)
+ || NIL_P (function_write_default) || NIL_P (data_write_default)
+ || NIL_P (function_create_option) || NIL_P (data_create_option)
+ || NIL_P (function_delete_option) || NIL_P (data_delete_option))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (config_file, T_STRING);
+ Check_Type (name, T_STRING);
+ Check_Type (user_can_add_options, T_FIXNUM);
+ Check_Type (user_can_delete_options, T_FIXNUM);
+ Check_Type (function_read, T_STRING);
+ Check_Type (data_read, T_STRING);
+ Check_Type (function_write, T_STRING);
+ Check_Type (data_write, T_STRING);
+ Check_Type (function_write_default, T_STRING);
+ Check_Type (data_write_default, T_STRING);
+ Check_Type (function_create_option, T_STRING);
+ Check_Type (data_create_option, T_STRING);
+ Check_Type (function_delete_option, T_STRING);
+ Check_Type (data_delete_option, T_STRING);
+
+ c_config_file = StringValuePtr (config_file);
+ c_name = StringValuePtr (name);
+ c_user_can_add_options = FIX2INT (user_can_add_options);
+ c_user_can_delete_options = FIX2INT (user_can_delete_options);
+ c_function_read = StringValuePtr (function_read);
+ c_data_read = StringValuePtr (data_read);
+ c_function_write = StringValuePtr (function_write);
+ c_data_write = StringValuePtr (data_write);
+ c_function_write_default = StringValuePtr (function_write_default);
+ c_data_write_default = StringValuePtr (data_write_default);
+ c_function_create_option = StringValuePtr (function_create_option);
+ c_data_create_option = StringValuePtr (data_create_option);
+ c_function_delete_option = StringValuePtr (function_delete_option);
+ c_data_delete_option = StringValuePtr (data_delete_option);
+
+ result = API_PTR2STR(plugin_script_api_config_new_section (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_config_file),
+ c_name,
+ c_user_can_add_options,
+ c_user_can_delete_options,
+ &weechat_ruby_api_config_read_cb,
+ c_function_read,
+ c_data_read,
+ &weechat_ruby_api_config_section_write_cb,
+ c_function_write,
+ c_data_write,
+ &weechat_ruby_api_config_section_write_default_cb,
+ c_function_write_default,
+ c_data_write_default,
+ &weechat_ruby_api_config_section_create_option_cb,
+ c_function_create_option,
+ c_data_create_option,
+ &weechat_ruby_api_config_section_delete_option_cb,
+ c_function_delete_option,
+ c_data_delete_option));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_config_search_section: search section in configuration file
+ */
+
+static VALUE
+weechat_ruby_api_config_search_section (VALUE class, VALUE config_file,
+ VALUE section_name)
+{
+ char *c_config_file, *c_section_name, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "config_search_section", API_RETURN_EMPTY);
+ if (NIL_P (config_file) || NIL_P (section_name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (config_file, T_STRING);
+ Check_Type (section_name, T_STRING);
+
+ c_config_file = StringValuePtr (config_file);
+ c_section_name = StringValuePtr (section_name);
+
+ result = API_PTR2STR(weechat_config_search_section (API_STR2PTR(c_config_file),
+ c_section_name));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_config_option_check_value_cb: callback for checking new
+ * value for option
+ */
+
+int
+weechat_ruby_api_config_option_check_value_cb (void *data,
+ struct t_config_option *option,
+ const char *value)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[3];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(option);
+ func_argv[2] = (value) ? (char *)value : empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "sss", func_argv);
+
+ if (!rc)
+ ret = 0;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+
+ return ret;
+ }
+
+ return 0;
+}
+
+/*
+ * weechat_ruby_api_config_option_change_cb: callback for option changed
+ */
+
+void
+weechat_ruby_api_config_option_change_cb (void *data,
+ struct t_config_option *option)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[2];
+ char empty_arg[1] = { '\0' };
+ int *rc;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(option);
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "ss", func_argv);
+
+ if (func_argv[1])
+ free (func_argv[1]);
+
+ if (rc)
+ free (rc);
+ }
+}
+
+/*
+ * weechat_ruby_api_config_option_delete_cb: callback when option is deleted
+ */
+
+void
+weechat_ruby_api_config_option_delete_cb (void *data,
+ struct t_config_option *option)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[2];
+ char empty_arg[1] = { '\0' };
+ int *rc;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(option);
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "ss", func_argv);
+
+ if (func_argv[1])
+ free (func_argv[1]);
+
+ if (rc)
+ free (rc);
+ }
+}
+
+/*
+ * weechat_ruby_api_config_new_option: create a new option in section
+ */
+
+static VALUE
+weechat_ruby_api_config_new_option (VALUE class, VALUE config_file,
+ VALUE section, VALUE name, VALUE type,
+ VALUE description, VALUE string_values,
+ VALUE min, VALUE max, VALUE default_value,
+ VALUE value, VALUE null_value_allowed,
+ VALUE function_check_value,
+ VALUE data_check_value,
+ VALUE function_change,
+ VALUE data_change,
+ VALUE function_delete,
+ VALUE data_delete)
+{
+ char *c_config_file, *c_section, *c_name, *c_type, *c_description;
+ char *c_string_values, *c_default_value, *c_value;
+ char *c_function_check_value, *c_data_check_value, *c_function_change;
+ char *c_data_change, *c_function_delete, *c_data_delete, *result;
+ int c_min, c_max, c_null_value_allowed;
+ VALUE return_value;
+
+ API_FUNC(1, "config_new_option", API_RETURN_EMPTY);
+ if (NIL_P (config_file) || NIL_P (section) || NIL_P (name) || NIL_P (type)
+ || NIL_P (description) || NIL_P (string_values) || NIL_P (min)
+ || NIL_P (max) || NIL_P (default_value) || NIL_P (value)
+ || NIL_P (null_value_allowed) || NIL_P (function_check_value)
+ || NIL_P (data_check_value) || NIL_P (function_change)
+ || NIL_P (data_change) || NIL_P (function_delete)
+ || NIL_P (data_delete))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (config_file, T_STRING);
+ Check_Type (section, T_STRING);
+ Check_Type (name, T_STRING);
+ Check_Type (type, T_STRING);
+ Check_Type (description, T_STRING);
+ Check_Type (string_values, T_STRING);
+ Check_Type (min, T_FIXNUM);
+ Check_Type (max, T_FIXNUM);
+ Check_Type (default_value, T_STRING);
+ Check_Type (value, T_STRING);
+ Check_Type (null_value_allowed, T_FIXNUM);
+ Check_Type (function_check_value, T_STRING);
+ Check_Type (data_check_value, T_STRING);
+ Check_Type (function_change, T_STRING);
+ Check_Type (data_change, T_STRING);
+ Check_Type (function_delete, T_STRING);
+ Check_Type (data_delete, T_STRING);
+
+ c_config_file = StringValuePtr (config_file);
+ c_section = StringValuePtr (section);
+ c_name = StringValuePtr (name);
+ c_type = StringValuePtr (type);
+ c_description = StringValuePtr (description);
+ c_string_values = StringValuePtr (string_values);
+ c_min = FIX2INT (min);
+ c_max = FIX2INT (max);
+ c_default_value = StringValuePtr (default_value);
+ c_value = StringValuePtr (value);
+ c_null_value_allowed = FIX2INT (null_value_allowed);
+ c_function_check_value = StringValuePtr (function_check_value);
+ c_data_check_value = StringValuePtr (data_check_value);
+ c_function_change = StringValuePtr (function_change);
+ c_data_change = StringValuePtr (data_change);
+ c_function_delete = StringValuePtr (function_delete);
+ c_data_delete = StringValuePtr (data_delete);
+
+ result = API_PTR2STR(plugin_script_api_config_new_option (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_config_file),
+ API_STR2PTR(c_section),
+ c_name,
+ c_type,
+ c_description,
+ c_string_values,
+ c_min,
+ c_max,
+ c_default_value,
+ c_value,
+ c_null_value_allowed,
+ &weechat_ruby_api_config_option_check_value_cb,
+ c_function_check_value,
+ c_data_check_value,
+ &weechat_ruby_api_config_option_change_cb,
+ c_function_change,
+ c_data_change,
+ &weechat_ruby_api_config_option_delete_cb,
+ c_function_delete,
+ c_data_delete));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_config_search_option: search option in configuration file or section
+ */
+
+static VALUE
+weechat_ruby_api_config_search_option (VALUE class, VALUE config_file,
+ VALUE section, VALUE option_name)
+{
+ char *c_config_file, *c_section, *c_option_name, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "config_search_option", API_RETURN_EMPTY);
+ if (NIL_P (config_file) || NIL_P (section) || NIL_P (option_name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (config_file, T_STRING);
+ Check_Type (section, T_STRING);
+ Check_Type (option_name, T_STRING);
+
+ c_config_file = StringValuePtr (config_file);
+ c_section = StringValuePtr (section);
+ c_option_name = StringValuePtr (option_name);
+
+ result = API_PTR2STR(weechat_config_search_option (API_STR2PTR(c_config_file),
+ API_STR2PTR(c_section),
+ c_option_name));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_config_string_to_boolean: return boolean value of a string
+ */
+
+static VALUE
+weechat_ruby_api_config_string_to_boolean (VALUE class, VALUE text)
+{
+ char *c_text;
+ int value;
+
+ API_FUNC(1, "config_string_to_boolean", API_RETURN_INT(0));
+ if (NIL_P (text))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (text, T_STRING);
+
+ c_text = StringValuePtr (text);
+
+ value = weechat_config_string_to_boolean (c_text);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_config_option_reset: reset option with default value
+ */
+
+static VALUE
+weechat_ruby_api_config_option_reset (VALUE class, VALUE option,
+ VALUE run_callback)
+{
+ char *c_option;
+ int c_run_callback, rc;
+
+ API_FUNC(1, "config_option_reset", API_RETURN_INT(0));
+ if (NIL_P (option) || NIL_P (run_callback))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (option, T_STRING);
+ Check_Type (run_callback, T_FIXNUM);
+
+ c_option = StringValuePtr (option);
+ c_run_callback = FIX2INT (run_callback);
+
+ rc = weechat_config_option_reset (API_STR2PTR(c_option),
+ c_run_callback);
+
+ API_RETURN_INT(rc);
+}
+
+/*
+ * weechat_ruby_api_config_option_set: set new value for option
+ */
+
+static VALUE
+weechat_ruby_api_config_option_set (VALUE class, VALUE option, VALUE new_value,
+ VALUE run_callback)
+{
+ char *c_option, *c_new_value;
+ int c_run_callback, rc;
+
+ API_FUNC(1, "config_option_set", API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));
+ if (NIL_P (option) || NIL_P (new_value) || NIL_P (run_callback))
+ API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));
+
+ Check_Type (option, T_STRING);
+ Check_Type (new_value, T_STRING);
+ Check_Type (run_callback, T_FIXNUM);
+
+ c_option = StringValuePtr (option);
+ c_new_value = StringValuePtr (new_value);
+ c_run_callback = FIX2INT (run_callback);
+
+ rc = weechat_config_option_set (API_STR2PTR(c_option),
+ c_new_value,
+ c_run_callback);
+
+ API_RETURN_INT(rc);
+}
+
+/*
+ * weechat_ruby_api_config_option_set_null: set null (undefined) value for
+ * option
+ */
+
+static VALUE
+weechat_ruby_api_config_option_set_null (VALUE class, VALUE option,
+ VALUE run_callback)
+{
+ char *c_option;
+ int c_run_callback, rc;
+
+ API_FUNC(1, "config_option_set_null", API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));
+ if (NIL_P (option) || NIL_P (run_callback))
+ API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));
+
+ Check_Type (option, T_STRING);
+ Check_Type (run_callback, T_FIXNUM);
+
+ c_option = StringValuePtr (option);
+ c_run_callback = FIX2INT (run_callback);
+
+ rc = weechat_config_option_set_null (API_STR2PTR(c_option),
+ c_run_callback);
+
+ API_RETURN_INT(rc);
+}
+
+/*
+ * weechat_ruby_api_config_option_unset: unset an option
+ */
+
+static VALUE
+weechat_ruby_api_config_option_unset (VALUE class, VALUE option)
+{
+ char *c_option;
+ int rc;
+
+ API_FUNC(1, "config_option_unset", API_RETURN_INT(WEECHAT_CONFIG_OPTION_UNSET_ERROR));
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_OPTION_UNSET_ERROR));
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ rc = weechat_config_option_unset (API_STR2PTR(c_option));
+
+ API_RETURN_INT(rc);
+}
+
+/*
+ * weechat_ruby_api_config_option_rename: rename an option
+ */
+
+static VALUE
+weechat_ruby_api_config_option_rename (VALUE class, VALUE option,
+ VALUE new_name)
+{
+ char *c_option, *c_new_name;
+
+ API_FUNC(1, "config_option_rename", API_RETURN_ERROR);
+ if (NIL_P (option) || NIL_P (new_name))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (option, T_STRING);
+ Check_Type (new_name, T_STRING);
+
+ c_option = StringValuePtr (option);
+ c_new_name = StringValuePtr (new_name);
+
+ weechat_config_option_rename (API_STR2PTR(c_option),
+ c_new_name);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_config_option_is_null: return 1 if value of option is null
+ */
+
+static VALUE
+weechat_ruby_api_config_option_is_null (VALUE class, VALUE option)
+{
+ char *c_option;
+ int value;
+
+ API_FUNC(1, "config_option_is_null", API_RETURN_INT(1));
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_INT(1));
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ value = weechat_config_option_is_null (API_STR2PTR(c_option));
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_config_option_default_is_null: return 1 if value of option is null
+ */
+
+static VALUE
+weechat_ruby_api_config_option_default_is_null (VALUE class, VALUE option)
+{
+ char *c_option;
+ int value;
+
+ API_FUNC(1, "config_option_default_is_null", API_RETURN_INT(1));
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_INT(1));
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ value = weechat_config_option_default_is_null (API_STR2PTR(c_option));
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_config_boolean: return boolean value of option
+ */
+
+static VALUE
+weechat_ruby_api_config_boolean (VALUE class, VALUE option)
+{
+ char *c_option;
+ int value;
+
+ API_FUNC(1, "config_boolean", API_RETURN_INT(0));
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ value = weechat_config_boolean (API_STR2PTR(c_option));
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_config_boolean_default: return default boolean value of option
+ */
+
+static VALUE
+weechat_ruby_api_config_boolean_default (VALUE class, VALUE option)
+{
+ char *c_option;
+ int value;
+
+ API_FUNC(1, "config_boolean_default", API_RETURN_INT(0));
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ value = weechat_config_boolean_default (API_STR2PTR(c_option));
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_config_integer: return integer value of option
+ */
+
+static VALUE
+weechat_ruby_api_config_integer (VALUE class, VALUE option)
+{
+ char *c_option;
+ int value;
+
+ API_FUNC(1, "config_integer", API_RETURN_INT(0));
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ value = weechat_config_integer (API_STR2PTR(c_option));
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_config_integer_default: return default integer value of option
+ */
+
+static VALUE
+weechat_ruby_api_config_integer_default (VALUE class, VALUE option)
+{
+ char *c_option;
+ int value;
+
+ API_FUNC(1, "config_integer_default", API_RETURN_INT(0));
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ value = weechat_config_integer_default (API_STR2PTR(c_option));
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_config_string: return string value of option
+ */
+
+static VALUE
+weechat_ruby_api_config_string (VALUE class, VALUE option)
+{
+ char *c_option;
+ const char *result;
+
+ API_FUNC(1, "config_string", API_RETURN_EMPTY);
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ result = weechat_config_string (API_STR2PTR(c_option));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_config_string_default: return default string value of option
+ */
+
+static VALUE
+weechat_ruby_api_config_string_default (VALUE class, VALUE option)
+{
+ char *c_option;
+ const char *result;
+
+ API_FUNC(1, "config_string_default", API_RETURN_EMPTY);
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ result = weechat_config_string_default (API_STR2PTR(c_option));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_config_color: return color value of option
+ */
+
+static VALUE
+weechat_ruby_api_config_color (VALUE class, VALUE option)
+{
+ char *c_option;
+ const char *result;
+
+ API_FUNC(1, "config_color", API_RETURN_INT(0));
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ result = weechat_config_color (API_STR2PTR(c_option));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_config_color_default: return default color value of option
+ */
+
+static VALUE
+weechat_ruby_api_config_color_default (VALUE class, VALUE option)
+{
+ char *c_option;
+ const char *result;
+
+ API_FUNC(1, "config_color_default", API_RETURN_INT(0));
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ result = weechat_config_color_default (API_STR2PTR(c_option));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_config_write_option: write an option in configuration file
+ */
+
+static VALUE
+weechat_ruby_api_config_write_option (VALUE class, VALUE config_file,
+ VALUE option)
+{
+ char *c_config_file, *c_option;
+
+ API_FUNC(1, "config_write_option", API_RETURN_ERROR);
+ if (NIL_P (config_file) || NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (config_file, T_STRING);
+ Check_Type (option, T_STRING);
+
+ c_config_file = StringValuePtr (config_file);
+ c_option = StringValuePtr (option);
+
+ weechat_config_write_option (API_STR2PTR(c_config_file),
+ API_STR2PTR(c_option));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_config_write_line: write a line in configuration file
+ */
+
+static VALUE
+weechat_ruby_api_config_write_line (VALUE class, VALUE config_file,
+ VALUE option_name, VALUE value)
+{
+ char *c_config_file, *c_option_name, *c_value;
+
+ API_FUNC(1, "config_write_line", API_RETURN_ERROR);
+ if (NIL_P (config_file) || NIL_P (option_name) || NIL_P (value))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (config_file, T_STRING);
+ Check_Type (option_name, T_STRING);
+ Check_Type (value, T_STRING);
+
+ c_config_file = StringValuePtr (config_file);
+ c_option_name = StringValuePtr (option_name);
+ c_value = StringValuePtr (value);
+
+ weechat_config_write_line (API_STR2PTR(c_config_file),
+ c_option_name,
+ "%s",
+ c_value);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_config_write: write configuration file
+ */
+
+static VALUE
+weechat_ruby_api_config_write (VALUE class, VALUE config_file)
+{
+ char *c_config_file;
+ int rc;
+
+ API_FUNC(1, "config_write", API_RETURN_INT(-1));
+ if (NIL_P (config_file))
+ API_WRONG_ARGS(API_RETURN_INT(-1));
+
+ Check_Type (config_file, T_STRING);
+
+ c_config_file = StringValuePtr (config_file);
+
+ rc = weechat_config_write (API_STR2PTR(c_config_file));
+
+ API_RETURN_INT(rc);
+}
+
+/*
+ * weechat_ruby_api_config_read: read configuration file
+ */
+
+static VALUE
+weechat_ruby_api_config_read (VALUE class, VALUE config_file)
+{
+ char *c_config_file;
+ int rc;
+
+ API_FUNC(1, "config_read", API_RETURN_INT(-1));
+ if (NIL_P (config_file))
+ API_WRONG_ARGS(API_RETURN_INT(-1));
+
+ Check_Type (config_file, T_STRING);
+
+ c_config_file = StringValuePtr (config_file);
+
+ rc = weechat_config_read (API_STR2PTR(c_config_file));
+
+ API_RETURN_INT(rc);
+}
+
+/*
+ * weechat_ruby_api_config_reload: reload configuration file
+ */
+
+static VALUE
+weechat_ruby_api_config_reload (VALUE class, VALUE config_file)
+{
+ char *c_config_file;
+ int rc;
+
+ API_FUNC(1, "config_reload", API_RETURN_INT(-1));
+ if (NIL_P (config_file))
+ API_WRONG_ARGS(API_RETURN_INT(-1));
+
+ Check_Type (config_file, T_STRING);
+
+ c_config_file = StringValuePtr (config_file);
+
+ rc = weechat_config_reload (API_STR2PTR(c_config_file));
+
+ API_RETURN_INT(rc);
+}
+
+/*
+ * weechat_ruby_api_config_option_free: free an option in configuration file
+ */
+
+static VALUE
+weechat_ruby_api_config_option_free (VALUE class, VALUE option)
+{
+ char *c_option;
+
+ API_FUNC(1, "config_option_free", API_RETURN_ERROR);
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ plugin_script_api_config_option_free (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_option));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_config_section_free_options: free all options of a section
+ * in configuration file
+ */
+
+static VALUE
+weechat_ruby_api_config_section_free_options (VALUE class, VALUE section)
+{
+ char *c_section;
+
+ API_FUNC(1, "config_section_free_options", API_RETURN_ERROR);
+ if (NIL_P (section))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (section, T_STRING);
+
+ c_section = StringValuePtr (section);
+
+ plugin_script_api_config_section_free_options (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_section));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_config_section_free: free section in configuration file
+ */
+
+static VALUE
+weechat_ruby_api_config_section_free (VALUE class, VALUE section)
+{
+ char *c_section;
+
+ API_FUNC(1, "config_section_free", API_RETURN_ERROR);
+ if (NIL_P (section))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (section, T_STRING);
+
+ c_section = StringValuePtr (section);
+
+ plugin_script_api_config_section_free (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_section));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_config_free: free configuration file
+ */
+
+static VALUE
+weechat_ruby_api_config_free (VALUE class, VALUE config_file)
+{
+ char *c_config_file;
+
+ API_FUNC(1, "config_free", API_RETURN_ERROR);
+ if (NIL_P (config_file))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (config_file, T_STRING);
+
+ c_config_file = StringValuePtr (config_file);
+
+ plugin_script_api_config_free (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_config_file));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_config_get: get config option
+ */
+
+static VALUE
+weechat_ruby_api_config_get (VALUE class, VALUE option)
+{
+ char *c_option, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "config_get", API_RETURN_EMPTY);
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ result = API_PTR2STR(weechat_config_get (c_option));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_config_get_plugin: get value of a plugin option
+ */
+
+static VALUE
+weechat_ruby_api_config_get_plugin (VALUE class, VALUE option)
+{
+ char *c_option;
+ const char *result;
+
+ API_FUNC(1, "config_get_plugin", API_RETURN_EMPTY);
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ result = plugin_script_api_config_get_plugin (weechat_ruby_plugin,
+ ruby_current_script,
+ c_option);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_config_is_set_plugin: check if a plugin option is set
+ */
+
+static VALUE
+weechat_ruby_api_config_is_set_plugin (VALUE class, VALUE option)
+{
+ char *c_option;
+ int rc;
+
+ API_FUNC(1, "config_is_set_plugin", API_RETURN_INT(0));
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ rc = plugin_script_api_config_is_set_plugin (weechat_ruby_plugin,
+ ruby_current_script,
+ c_option);
+
+ API_RETURN_INT(rc);
+}
+
+/*
+ * weechat_ruby_api_config_set_plugin: set value of a plugin option
+ */
+
+static VALUE
+weechat_ruby_api_config_set_plugin (VALUE class, VALUE option, VALUE value)
+{
+ char *c_option, *c_value;
+ int rc;
+
+ API_FUNC(1, "config_set_plugin", API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));
+ if (NIL_P (option) || NIL_P (value))
+ API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));
+
+ Check_Type (option, T_STRING);
+ Check_Type (value, T_STRING);
+
+ c_option = StringValuePtr (option);
+ c_value = StringValuePtr (value);
+
+ rc = plugin_script_api_config_set_plugin (weechat_ruby_plugin,
+ ruby_current_script,
+ c_option,
+ c_value);
+
+ API_RETURN_INT(rc);
+}
+
+/*
+ * weechat_ruby_api_config_set_desc_plugin: set description of a plugin option
+ */
+
+static VALUE
+weechat_ruby_api_config_set_desc_plugin (VALUE class, VALUE option,
+ VALUE description)
+{
+ char *c_option, *c_description;
+
+ API_FUNC(1, "config_set_desc_plugin", API_RETURN_ERROR);
+ if (NIL_P (option) || NIL_P (description))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (option, T_STRING);
+ Check_Type (description, T_STRING);
+
+ c_option = StringValuePtr (option);
+ c_description = StringValuePtr (description);
+
+ plugin_script_api_config_set_desc_plugin (weechat_ruby_plugin,
+ ruby_current_script,
+ c_option,
+ c_description);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_config_unset_plugin: unset plugin option
+ */
+
+static VALUE
+weechat_ruby_api_config_unset_plugin (VALUE class, VALUE option)
+{
+ char *c_option;
+ int rc;
+
+ API_FUNC(1, "config_unset_plugin", API_RETURN_INT(WEECHAT_CONFIG_OPTION_UNSET_ERROR));
+ if (NIL_P (option))
+ API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_OPTION_UNSET_ERROR));
+
+ Check_Type (option, T_STRING);
+
+ c_option = StringValuePtr (option);
+
+ rc = plugin_script_api_config_unset_plugin (weechat_ruby_plugin,
+ ruby_current_script,
+ c_option);
+
+ API_RETURN_INT(rc);
+}
+
+/*
+ * weechat_ruby_api_key_bind: bind key(s)
+ */
+
+static VALUE
+weechat_ruby_api_key_bind (VALUE class, VALUE context, VALUE keys)
+{
+ char *c_context;
+ struct t_hashtable *c_keys;
+ int num_keys;
+
+ API_FUNC(1, "key_bind", API_RETURN_INT(0));
+ if (NIL_P (context) || NIL_P (keys))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (context, T_STRING);
+ Check_Type (keys, T_HASH);
+
+ c_context = StringValuePtr (context);
+ c_keys = weechat_ruby_hash_to_hashtable (keys,
+ WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE);
+
+ num_keys = weechat_key_bind (c_context, c_keys);
+
+ if (c_keys)
+ weechat_hashtable_free (c_keys);
+
+ API_RETURN_INT(num_keys);
+}
+
+/*
+ * weechat_ruby_api_key_unbind: unbind key(s)
+ */
+
+static VALUE
+weechat_ruby_api_key_unbind (VALUE class, VALUE context, VALUE key)
+{
+ char *c_context, *c_key;
+ int num_keys;
+
+ API_FUNC(1, "key_unbind", API_RETURN_INT(0));
+ if (NIL_P (context) || NIL_P (key))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (context, T_STRING);
+ Check_Type (key, T_STRING);
+
+ c_context = StringValuePtr (context);
+ c_key = StringValuePtr (key);
+
+ num_keys = weechat_key_unbind (c_context, c_key);
+
+ API_RETURN_INT(num_keys);
+}
+
+/*
+ * weechat_ruby_api_prefix: get a prefix, used for display
+ */
+
+static VALUE
+weechat_ruby_api_prefix (VALUE class, VALUE prefix)
+{
+ char *c_prefix;
+ const char *result;
+
+ API_FUNC(0, "prefix", API_RETURN_EMPTY);
+ if (NIL_P (prefix))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (prefix, T_STRING);
+
+ c_prefix = StringValuePtr (prefix);
+
+ result = weechat_prefix (c_prefix);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_color: get a color code, used for display
+ */
+
+static VALUE
+weechat_ruby_api_color (VALUE class, VALUE color)
+{
+ char *c_color;
+ const char *result;
+
+ API_FUNC(0, "color", API_RETURN_EMPTY);
+ if (NIL_P (color))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (color, T_STRING);
+
+ c_color = StringValuePtr (color);
+
+ result = weechat_color (c_color);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_print: print message in a buffer
+ */
+
+static VALUE
+weechat_ruby_api_print (VALUE class, VALUE buffer, VALUE message)
+{
+ char *c_buffer, *c_message;
+
+ API_FUNC(0, "print", API_RETURN_ERROR);
+ if (NIL_P (buffer) || NIL_P (message))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (message, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_message = StringValuePtr (message);
+
+ plugin_script_api_printf (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_buffer),
+ "%s", c_message);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_print_date_tags: print message in a buffer with optional
+ * date and tags
+ */
+
+static VALUE
+weechat_ruby_api_print_date_tags (VALUE class, VALUE buffer, VALUE date,
+ VALUE tags, VALUE message)
+{
+ char *c_buffer, *c_tags, *c_message;
+ int c_date;
+
+ API_FUNC(1, "print_date_tags", API_RETURN_ERROR);
+ if (NIL_P (buffer) || NIL_P (date) || NIL_P (tags) || NIL_P (message))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (date, T_FIXNUM);
+ Check_Type (tags, T_STRING);
+ Check_Type (message, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_date = FIX2INT (date);
+ c_tags = StringValuePtr (tags);
+ c_message = StringValuePtr (message);
+
+ plugin_script_api_printf_date_tags (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_buffer),
+ c_date,
+ c_tags,
+ "%s", c_message);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_print_y: print message in a buffer with free content
+ */
+
+static VALUE
+weechat_ruby_api_print_y (VALUE class, VALUE buffer, VALUE y, VALUE message)
+{
+ char *c_buffer, *c_message;
+ int c_y;
+
+ API_FUNC(1, "print_y", API_RETURN_ERROR);
+ if (NIL_P (buffer) || NIL_P (y) || NIL_P (message))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (y, T_FIXNUM);
+ Check_Type (message, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_y = FIX2INT (y);
+ c_message = StringValuePtr (message);
+
+ plugin_script_api_printf_y (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_buffer),
+ c_y,
+ "%s", c_message);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_log_print: print message in WeeChat log file
+ */
+
+static VALUE
+weechat_ruby_api_log_print (VALUE class, VALUE message)
+{
+ char *c_message;
+
+ API_FUNC(1, "log_print", API_RETURN_ERROR);
+ if (NIL_P (message))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (message, T_STRING);
+
+ c_message = StringValuePtr (message);
+
+ plugin_script_api_log_printf (weechat_ruby_plugin,
+ ruby_current_script,
+ "%s", c_message);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_hook_command_cb: callback for command hooked
+ */
+
+int
+weechat_ruby_api_hook_command_cb (void *data, struct t_gui_buffer *buffer,
+ int argc, char **argv, char **argv_eol)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[3];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ /* make C compiler happy */
+ (void) argv;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(buffer);
+ func_argv[2] = (argc > 1) ? argv_eol[1] : empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "sss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_hook_command: hook a command
+ */
+
+static VALUE
+weechat_ruby_api_hook_command (VALUE class, VALUE command, VALUE description,
+ VALUE args, VALUE args_description,
+ VALUE completion, VALUE function, VALUE data)
+{
+ char *c_command, *c_description, *c_args, *c_args_description;
+ char *c_completion, *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_command", API_RETURN_EMPTY);
+ if (NIL_P (command) || NIL_P (description) || NIL_P (args)
+ || NIL_P (args_description) || NIL_P (completion) || NIL_P (function)
+ || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (command, T_STRING);
+ Check_Type (description, T_STRING);
+ Check_Type (args, T_STRING);
+ Check_Type (args_description, T_STRING);
+ Check_Type (completion, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_command = StringValuePtr (command);
+ c_description = StringValuePtr (description);
+ c_args = StringValuePtr (args);
+ c_args_description = StringValuePtr (args_description);
+ c_completion = StringValuePtr (completion);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_command (weechat_ruby_plugin,
+ ruby_current_script,
+ c_command,
+ c_description,
+ c_args,
+ c_args_description,
+ c_completion,
+ &weechat_ruby_api_hook_command_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_command_run_cb: callback for command_run hooked
+ */
+
+int
+weechat_ruby_api_hook_command_run_cb (void *data, struct t_gui_buffer *buffer,
+ const char *command)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[3];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(buffer);
+ func_argv[2] = (command) ? (char *)command : empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "sss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_hook_command_run: hook a command_run
+ */
+
+static VALUE
+weechat_ruby_api_hook_command_run (VALUE class, VALUE command, VALUE function,
+ VALUE data)
+{
+ char *c_command, *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_command_run", API_RETURN_EMPTY);
+ if (NIL_P (command) || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (command, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_command = StringValuePtr (command);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_command_run (weechat_ruby_plugin,
+ ruby_current_script,
+ c_command,
+ &weechat_ruby_api_hook_command_run_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_timer_cb: callback for timer hooked
+ */
+
+int
+weechat_ruby_api_hook_timer_cb (void *data, int remaining_calls)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[2];
+ char str_remaining_calls[32], empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ snprintf (str_remaining_calls, sizeof (str_remaining_calls),
+ "%d", remaining_calls);
+
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = str_remaining_calls;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "ss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_hook_timer: hook a timer
+ */
+
+static VALUE
+weechat_ruby_api_hook_timer (VALUE class, VALUE interval, VALUE align_second,
+ VALUE max_calls, VALUE function, VALUE data)
+{
+ int c_interval, c_align_second, c_max_calls;
+ char *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_timer", API_RETURN_EMPTY);
+ if (NIL_P (interval) || NIL_P (align_second) || NIL_P (max_calls)
+ || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (interval, T_FIXNUM);
+ Check_Type (align_second, T_FIXNUM);
+ Check_Type (max_calls, T_FIXNUM);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_interval = FIX2INT (interval);
+ c_align_second = FIX2INT (align_second);
+ c_max_calls = FIX2INT (max_calls);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_timer (weechat_ruby_plugin,
+ ruby_current_script,
+ c_interval,
+ c_align_second,
+ c_max_calls,
+ &weechat_ruby_api_hook_timer_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_fd_cb: callback for fd hooked
+ */
+
+int
+weechat_ruby_api_hook_fd_cb (void *data, int fd)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[2];
+ char str_fd[32], empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ snprintf (str_fd, sizeof (str_fd), "%d", fd);
+
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = str_fd;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "ss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_hook_fd: hook a fd
+ */
+
+static VALUE
+weechat_ruby_api_hook_fd (VALUE class, VALUE fd, VALUE read, VALUE write,
+ VALUE exception, VALUE function, VALUE data)
+{
+ int c_fd, c_read, c_write, c_exception;
+ char *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_fd", API_RETURN_EMPTY);
+ if (NIL_P (fd) || NIL_P (read) || NIL_P (write) || NIL_P (exception)
+ || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (fd, T_FIXNUM);
+ Check_Type (read, T_FIXNUM);
+ Check_Type (write, T_FIXNUM);
+ Check_Type (exception, T_FIXNUM);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_fd = FIX2INT (fd);
+ c_read = FIX2INT (read);
+ c_write = FIX2INT (write);
+ c_exception = FIX2INT (exception);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_fd (weechat_ruby_plugin,
+ ruby_current_script,
+ c_fd,
+ c_read,
+ c_write,
+ c_exception,
+ &weechat_ruby_api_hook_fd_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_process_cb: callback for process hooked
+ */
+
+int
+weechat_ruby_api_hook_process_cb (void *data,
+ const char *command, int return_code,
+ const char *out, const char *err)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[5];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = (command) ? (char *)command : empty_arg;
+ func_argv[2] = &return_code;
+ func_argv[3] = (out) ? (char *)out : empty_arg;
+ func_argv[4] = (err) ? (char *)err : empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "ssiss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_hook_process: hook a process
+ */
+
+static VALUE
+weechat_ruby_api_hook_process (VALUE class, VALUE command, VALUE timeout,
+ VALUE function, VALUE data)
+{
+ char *c_command, *c_function, *c_data, *result;
+ int c_timeout;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_process", API_RETURN_EMPTY);
+ if (NIL_P (command) || NIL_P (timeout) || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (command, T_STRING);
+ Check_Type (timeout, T_FIXNUM);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_command = StringValuePtr (command);
+ c_timeout = FIX2INT (timeout);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_process (weechat_ruby_plugin,
+ ruby_current_script,
+ c_command,
+ c_timeout,
+ &weechat_ruby_api_hook_process_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_process_hashtable: hook a process with options in
+ * a hashtable
+ */
+
+static VALUE
+weechat_ruby_api_hook_process_hashtable (VALUE class, VALUE command,
+ VALUE options, VALUE timeout,
+ VALUE function, VALUE data)
+{
+ char *c_command, *c_function, *c_data, *result;
+ struct t_hashtable *c_options;
+ int c_timeout;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_process_hashtable", API_RETURN_EMPTY);
+ if (NIL_P (command) || NIL_P (options) || NIL_P (timeout)
+ || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (command, T_STRING);
+ Check_Type (options, T_HASH);
+ Check_Type (timeout, T_FIXNUM);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_command = StringValuePtr (command);
+ c_options = weechat_ruby_hash_to_hashtable (options,
+ WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE);
+ c_timeout = FIX2INT (timeout);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_process_hashtable (weechat_ruby_plugin,
+ ruby_current_script,
+ c_command,
+ c_options,
+ c_timeout,
+ &weechat_ruby_api_hook_process_cb,
+ c_function,
+ c_data));
+
+ if (c_options)
+ weechat_hashtable_free (c_options);
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_connect_cb: callback for connect hooked
+ */
+
+int
+weechat_ruby_api_hook_connect_cb (void *data, int status, int gnutls_rc,
+ const char *error, const char *ip_address)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[5];
+ char str_status[32], str_gnutls_rc[32];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ snprintf (str_status, sizeof (str_status), "%d", status);
+ snprintf (str_gnutls_rc, sizeof (str_gnutls_rc), "%d", gnutls_rc);
+
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = str_status;
+ func_argv[2] = str_gnutls_rc;
+ func_argv[3] = (ip_address) ? (char *)ip_address : empty_arg;
+ func_argv[4] = (error) ? (char *)error : empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "sssss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_hook_connect: hook a connection
+ */
+
+static VALUE
+weechat_ruby_api_hook_connect (VALUE class, VALUE proxy, VALUE address,
+ VALUE port, VALUE sock, VALUE ipv6,
+ VALUE local_hostname, VALUE function,
+ VALUE data)
+{
+ char *c_proxy, *c_address, *c_local_hostname, *c_function, *c_data, *result;
+ int c_port, c_sock, c_ipv6;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_connect", API_RETURN_EMPTY);
+ if (NIL_P (proxy) || NIL_P (address) || NIL_P (port) || NIL_P (sock)
+ || NIL_P (ipv6) || NIL_P (local_hostname) || NIL_P (function)
+ || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (proxy, T_STRING);
+ Check_Type (address, T_STRING);
+ Check_Type (port, T_FIXNUM);
+ Check_Type (sock, T_FIXNUM);
+ Check_Type (ipv6, T_FIXNUM);
+ Check_Type (local_hostname, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_proxy = StringValuePtr (proxy);
+ c_address = StringValuePtr (address);
+ c_port = FIX2INT (port);
+ c_sock = FIX2INT (sock);
+ c_ipv6 = FIX2INT (ipv6);
+ c_local_hostname = StringValuePtr (local_hostname);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_connect (weechat_ruby_plugin,
+ ruby_current_script,
+ c_proxy,
+ c_address,
+ c_port,
+ c_sock,
+ c_ipv6,
+ NULL, /* gnutls session */
+ NULL, /* gnutls callback */
+ 0, /* gnutls DH key size */
+ NULL, /* gnutls priorities */
+ c_local_hostname,
+ &weechat_ruby_api_hook_connect_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_print_cb: callback for print hooked
+ */
+
+int
+weechat_ruby_api_hook_print_cb (void *data, struct t_gui_buffer *buffer,
+ time_t date,
+ int tags_count, const char **tags,
+ int displayed, int highlight,
+ const char *prefix, const char *message)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[8];
+ char empty_arg[1] = { '\0' };
+ static char timebuffer[64];
+ int *rc, ret;
+
+ /* make C compiler happy */
+ (void) tags_count;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ snprintf (timebuffer, sizeof (timebuffer) - 1, "%ld", (long int)date);
+
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(buffer);
+ func_argv[2] = timebuffer;
+ func_argv[3] = weechat_string_build_with_split_string (tags, ",");
+ if (!func_argv[3])
+ func_argv[3] = strdup ("");
+ func_argv[4] = (displayed) ? strdup ("1") : strdup ("0");
+ func_argv[5] = (highlight) ? strdup ("1") : strdup ("0");
+ func_argv[6] = (prefix) ? (char *)prefix : empty_arg;
+ func_argv[7] = (message) ? (char *)message : empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "ssssssss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+ if (func_argv[3])
+ free (func_argv[3]);
+ if (func_argv[4])
+ free (func_argv[4]);
+ if (func_argv[5])
+ free (func_argv[5]);
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_hook_print: hook a print
+ */
+
+static VALUE
+weechat_ruby_api_hook_print (VALUE class, VALUE buffer, VALUE tags,
+ VALUE message, VALUE strip_colors, VALUE function,
+ VALUE data)
+{
+ char *c_buffer, *c_tags, *c_message, *c_function, *c_data, *result;
+ int c_strip_colors;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_print", API_RETURN_EMPTY);
+ if (NIL_P (buffer) || NIL_P (tags) || NIL_P (message)
+ || NIL_P (strip_colors) || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (tags, T_STRING);
+ Check_Type (message, T_STRING);
+ Check_Type (strip_colors, T_FIXNUM);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_tags = StringValuePtr (tags);
+ c_message = StringValuePtr (message);
+ c_strip_colors = FIX2INT (strip_colors);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_print (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_buffer),
+ c_tags,
+ c_message,
+ c_strip_colors,
+ &weechat_ruby_api_hook_print_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_signal_cb: callback for signal hooked
+ */
+
+int
+weechat_ruby_api_hook_signal_cb (void *data, const char *signal, const char *type_data,
+ void *signal_data)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[3];
+ char empty_arg[1] = { '\0' };
+ static char value_str[64];
+ int *rc, ret, free_needed;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = (signal) ? (char *)signal : empty_arg;
+ free_needed = 0;
+ if (strcmp (type_data, WEECHAT_HOOK_SIGNAL_STRING) == 0)
+ {
+ func_argv[2] = (signal_data) ? (char *)signal_data : empty_arg;
+ }
+ else if (strcmp (type_data, WEECHAT_HOOK_SIGNAL_INT) == 0)
+ {
+ snprintf (value_str, sizeof (value_str) - 1,
+ "%d", *((int *)signal_data));
+ func_argv[2] = value_str;
+ }
+ else if (strcmp (type_data, WEECHAT_HOOK_SIGNAL_POINTER) == 0)
+ {
+ func_argv[2] = API_PTR2STR(signal_data);
+ free_needed = 1;
+ }
+ else
+ func_argv[2] = empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "sss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (free_needed && func_argv[2])
+ free (func_argv[2]);
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_hook_signal: hook a signal
+ */
+
+static VALUE
+weechat_ruby_api_hook_signal (VALUE class, VALUE signal, VALUE function,
+ VALUE data)
+{
+ char *c_signal, *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_signal", API_RETURN_EMPTY);
+ if (NIL_P (signal) || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (signal, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_signal = StringValuePtr (signal);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_signal (weechat_ruby_plugin,
+ ruby_current_script,
+ c_signal,
+ &weechat_ruby_api_hook_signal_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_signal_send: send a signal
+ */
+
+static VALUE
+weechat_ruby_api_hook_signal_send (VALUE class, VALUE signal, VALUE type_data,
+ VALUE signal_data)
+{
+ char *c_signal, *c_type_data, *c_signal_data;
+ int number;
+
+ API_FUNC(1, "hook_signal_send", API_RETURN_ERROR);
+ if (NIL_P (signal) || NIL_P (type_data) || NIL_P (signal_data))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (signal, T_STRING);
+ Check_Type (type_data, T_STRING);
+
+ c_signal = StringValuePtr (signal);
+ c_type_data = StringValuePtr (type_data);
+
+ if (strcmp (c_type_data, WEECHAT_HOOK_SIGNAL_STRING) == 0)
+ {
+ Check_Type (signal_data, T_STRING);
+ c_signal_data = StringValuePtr (signal_data);
+ weechat_hook_signal_send (c_signal, c_type_data, c_signal_data);
+ API_RETURN_OK;
+ }
+ else if (strcmp (c_type_data, WEECHAT_HOOK_SIGNAL_INT) == 0)
+ {
+ Check_Type (signal_data, T_FIXNUM);
+ number = FIX2INT (signal_data);
+ weechat_hook_signal_send (c_signal, c_type_data, &number);
+ API_RETURN_OK;
+ }
+ else if (strcmp (c_type_data, WEECHAT_HOOK_SIGNAL_POINTER) == 0)
+ {
+ Check_Type (signal_data, T_STRING);
+ c_signal_data = StringValuePtr (signal_data);
+ weechat_hook_signal_send (c_signal, c_type_data,
+ API_STR2PTR(c_signal_data));
+ API_RETURN_OK;
+ }
+
+ API_RETURN_ERROR;
+}
+
+/*
+ * weechat_ruby_api_hook_hsignal_cb: callback for hsignal hooked
+ */
+
+int
+weechat_ruby_api_hook_hsignal_cb (void *data, const char *signal,
+ struct t_hashtable *hashtable)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[3];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = (signal) ? (char *)signal : empty_arg;
+ func_argv[2] = hashtable;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "ssh", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_hook_hsignal: hook a hsignal
+ */
+
+static VALUE
+weechat_ruby_api_hook_hsignal (VALUE class, VALUE signal, VALUE function,
+ VALUE data)
+{
+ char *c_signal, *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_hsignal", API_RETURN_EMPTY);
+ if (NIL_P (signal) || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (signal, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_signal = StringValuePtr (signal);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_hsignal (weechat_ruby_plugin,
+ ruby_current_script,
+ c_signal,
+ &weechat_ruby_api_hook_hsignal_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_hsignal_send: send a hsignal
+ */
+
+static VALUE
+weechat_ruby_api_hook_hsignal_send (VALUE class, VALUE signal, VALUE hashtable)
+{
+ char *c_signal;
+ struct t_hashtable *c_hashtable;
+
+ API_FUNC(1, "hook_hsignal_send", API_RETURN_ERROR);
+ if (NIL_P (signal) || NIL_P (hashtable))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (signal, T_STRING);
+ Check_Type (hashtable, T_HASH);
+
+ c_signal = StringValuePtr (signal);
+ c_hashtable = weechat_ruby_hash_to_hashtable (hashtable,
+ WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE);
+
+ weechat_hook_hsignal_send (c_signal, c_hashtable);
+
+ if (c_hashtable)
+ weechat_hashtable_free (c_hashtable);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_hook_config_cb: callback for config option hooked
+ */
+
+int
+weechat_ruby_api_hook_config_cb (void *data, const char *option, const char *value)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[3];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = (option) ? (char *)option : empty_arg;
+ func_argv[2] = (value) ? (char *)value : empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "sss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_hook_config: hook a config option
+ */
+
+static VALUE
+weechat_ruby_api_hook_config (VALUE class, VALUE option, VALUE function,
+ VALUE data)
+{
+ char *c_option, *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_config", API_RETURN_EMPTY);
+ if (NIL_P (option) || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (option, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_option = StringValuePtr (option);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_config (weechat_ruby_plugin,
+ ruby_current_script,
+ c_option,
+ &weechat_ruby_api_hook_config_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_completion_cb: callback for completion hooked
+ */
+
+int
+weechat_ruby_api_hook_completion_cb (void *data, const char *completion_item,
+ struct t_gui_buffer *buffer,
+ struct t_gui_completion *completion)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[4];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = (completion_item) ? (char *)completion_item : empty_arg;
+ func_argv[2] = API_PTR2STR(buffer);
+ func_argv[3] = API_PTR2STR(completion);
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "ssss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[2])
+ free (func_argv[2]);
+ if (func_argv[3])
+ free (func_argv[3]);
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_hook_completion: hook a completion
+ */
+
+static VALUE
+weechat_ruby_api_hook_completion (VALUE class, VALUE completion,
+ VALUE description, VALUE function,
+ VALUE data)
+{
+ char *c_completion, *c_description, *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_completion", API_RETURN_EMPTY);
+ if (NIL_P (completion) || NIL_P (description) || NIL_P (function)
+ || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (completion, T_STRING);
+ Check_Type (description, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_completion = StringValuePtr (completion);
+ c_description = StringValuePtr (description);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_completion (weechat_ruby_plugin,
+ ruby_current_script,
+ c_completion,
+ c_description,
+ &weechat_ruby_api_hook_completion_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_completion_list_add: add a word to list for a completion
+ */
+
+static VALUE
+weechat_ruby_api_hook_completion_list_add (VALUE class, VALUE completion,
+ VALUE word, VALUE nick_completion,
+ VALUE where)
+{
+ char *c_completion, *c_word, *c_where;
+ int c_nick_completion;
+
+ API_FUNC(1, "hook_completion_list_add", API_RETURN_ERROR);
+ if (NIL_P (completion) || NIL_P (word) || NIL_P (nick_completion)
+ || NIL_P (where))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (completion, T_STRING);
+ Check_Type (word, T_STRING);
+ Check_Type (nick_completion, T_FIXNUM);
+ Check_Type (where, T_STRING);
+
+ c_completion = StringValuePtr (completion);
+ c_word = StringValuePtr (word);
+ c_nick_completion = FIX2INT (nick_completion);
+ c_where = StringValuePtr (where);
+
+ weechat_hook_completion_list_add (API_STR2PTR(c_completion),
+ c_word,
+ c_nick_completion,
+ c_where);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_hook_modifier_cb: callback for modifier hooked
+ */
+
+char *
+weechat_ruby_api_hook_modifier_cb (void *data, const char *modifier,
+ const char *modifier_data, const char *string)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[4];
+ char empty_arg[1] = { '\0' };
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = (modifier) ? (char *)modifier : empty_arg;
+ func_argv[2] = (modifier_data) ? (char *)modifier_data : empty_arg;
+ func_argv[3] = (string) ? (char *)string : empty_arg;
+
+ return (char *)weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_STRING,
+ script_callback->function,
+ "ssss", func_argv);
+ }
+
+ return NULL;
+}
+
+/*
+ * weechat_ruby_api_hook_modifier: hook a modifier
+ */
+
+static VALUE
+weechat_ruby_api_hook_modifier (VALUE class, VALUE modifier, VALUE function,
+ VALUE data)
+{
+ char *c_modifier, *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_modifier", API_RETURN_EMPTY);
+ if (NIL_P (modifier) || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (modifier, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_modifier = StringValuePtr (modifier);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_modifier (weechat_ruby_plugin,
+ ruby_current_script,
+ c_modifier,
+ &weechat_ruby_api_hook_modifier_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_modifier_exec: execute a modifier hook
+ */
+
+static VALUE
+weechat_ruby_api_hook_modifier_exec (VALUE class, VALUE modifier,
+ VALUE modifier_data, VALUE string)
+{
+ char *c_modifier, *c_modifier_data, *c_string, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_modifier_exec", API_RETURN_EMPTY);
+ if (NIL_P (modifier) || NIL_P (modifier_data) || NIL_P (string))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (modifier, T_STRING);
+ Check_Type (modifier_data, T_STRING);
+ Check_Type (string, T_STRING);
+
+ c_modifier = StringValuePtr (modifier);
+ c_modifier_data = StringValuePtr (modifier_data);
+ c_string = StringValuePtr (string);
+
+ result = weechat_hook_modifier_exec (c_modifier, c_modifier_data, c_string);
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_info_cb: callback for info hooked
+ */
+
+const char *
+weechat_ruby_api_hook_info_cb (void *data, const char *info_name,
+ const char *arguments)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[3];
+ char empty_arg[1] = { '\0' };
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = (info_name) ? (char *)info_name : empty_arg;
+ func_argv[2] = (arguments) ? (char *)arguments : empty_arg;
+
+ return (const char *)weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_STRING,
+ script_callback->function,
+ "sss", func_argv);
+ }
+
+ return NULL;
+}
+
+/*
+ * weechat_ruby_api_hook_info: hook an info
+ */
+
+static VALUE
+weechat_ruby_api_hook_info (VALUE class, VALUE info_name, VALUE description,
+ VALUE args_description, VALUE function, VALUE data)
+{
+ char *c_info_name, *c_description, *c_args_description, *c_function;
+ char *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_info", API_RETURN_EMPTY);
+ if (NIL_P (info_name) || NIL_P (description) || NIL_P (args_description)
+ || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (info_name, T_STRING);
+ Check_Type (description, T_STRING);
+ Check_Type (args_description, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_info_name = StringValuePtr (info_name);
+ c_description = StringValuePtr (description);
+ c_args_description = StringValuePtr (args_description);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_info (weechat_ruby_plugin,
+ ruby_current_script,
+ c_info_name,
+ c_description,
+ c_args_description,
+ &weechat_ruby_api_hook_info_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_info_hashtable_cb: callback for info_hashtable hooked
+ */
+
+struct t_hashtable *
+weechat_ruby_api_hook_info_hashtable_cb (void *data, const char *info_name,
+ struct t_hashtable *hashtable)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[3];
+ char empty_arg[1] = { '\0' };
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = (info_name) ? (char *)info_name : empty_arg;
+ func_argv[2] = hashtable;
+
+ return (struct t_hashtable *)weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_HASHTABLE,
+ script_callback->function,
+ "ssh", func_argv);
+ }
+
+ return NULL;
+}
+
+/*
+ * weechat_ruby_api_hook_info_hashtable: hook an info_hashtable
+ */
+
+static VALUE
+weechat_ruby_api_hook_info_hashtable (VALUE class, VALUE info_name,
+ VALUE description,
+ VALUE args_description,
+ VALUE output_description,
+ VALUE function, VALUE data)
+{
+ char *c_info_name, *c_description, *c_args_description;
+ char *c_output_description, *c_function;
+ char *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_info_hashtable", API_RETURN_EMPTY);
+ if (NIL_P (info_name) || NIL_P (description) || NIL_P (args_description)
+ || NIL_P (output_description) || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (info_name, T_STRING);
+ Check_Type (description, T_STRING);
+ Check_Type (args_description, T_STRING);
+ Check_Type (output_description, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_info_name = StringValuePtr (info_name);
+ c_description = StringValuePtr (description);
+ c_args_description = StringValuePtr (args_description);
+ c_output_description = StringValuePtr (output_description);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_info_hashtable (weechat_ruby_plugin,
+ ruby_current_script,
+ c_info_name,
+ c_description,
+ c_args_description,
+ c_output_description,
+ &weechat_ruby_api_hook_info_hashtable_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_infolist_cb: callback for infolist hooked
+ */
+
+struct t_infolist *
+weechat_ruby_api_hook_infolist_cb (void *data, const char *infolist_name,
+ void *pointer, const char *arguments)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[4];
+ char empty_arg[1] = { '\0' };
+ struct t_infolist *result;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = (infolist_name) ? (char *)infolist_name : empty_arg;
+ func_argv[2] = API_PTR2STR(pointer);
+ func_argv[3] = (arguments) ? (char *)arguments : empty_arg;
+
+ result = (struct t_infolist *)weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_STRING,
+ script_callback->function,
+ "ssss", func_argv);
+
+ if (func_argv[2])
+ free (func_argv[2]);
+
+ return result;
+ }
+
+ return NULL;
+}
+
+/*
+ * weechat_ruby_api_hook_infolist: hook an infolist
+ */
+
+static VALUE
+weechat_ruby_api_hook_infolist (VALUE class, VALUE infolist_name,
+ VALUE description, VALUE pointer_description,
+ VALUE args_description, VALUE function,
+ VALUE data)
+{
+ char *c_infolist_name, *c_description, *c_pointer_description;
+ char *c_args_description, *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_infolist", API_RETURN_EMPTY);
+ if (NIL_P (infolist_name) || NIL_P (description)
+ || NIL_P (pointer_description) || NIL_P (args_description)
+ || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (infolist_name, T_STRING);
+ Check_Type (description, T_STRING);
+ Check_Type (pointer_description, T_STRING);
+ Check_Type (args_description, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_infolist_name = StringValuePtr (infolist_name);
+ c_description = StringValuePtr (description);
+ c_pointer_description = StringValuePtr (pointer_description);
+ c_args_description = StringValuePtr (args_description);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_infolist (weechat_ruby_plugin,
+ ruby_current_script,
+ c_infolist_name,
+ c_description,
+ c_pointer_description,
+ c_args_description,
+ &weechat_ruby_api_hook_infolist_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hook_focus_cb: callback for focus hooked
+ */
+
+struct t_hashtable *
+weechat_ruby_api_hook_focus_cb (void *data, struct t_hashtable *info)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[2];
+ char empty_arg[1] = { '\0' };
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = info;
+
+ return (struct t_hashtable *)weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_HASHTABLE,
+ script_callback->function,
+ "sh", func_argv);
+ }
+
+ return NULL;
+}
+
+/*
+ * weechat_ruby_api_hook_focus: hook a focus
+ */
+
+static VALUE
+weechat_ruby_api_hook_focus (VALUE class, VALUE area, VALUE function,
+ VALUE data)
+{
+ char *c_area, *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hook_focus", API_RETURN_EMPTY);
+ if (NIL_P (area) || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (area, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_area = StringValuePtr (area);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_hook_focus (weechat_ruby_plugin,
+ ruby_current_script,
+ c_area,
+ &weechat_ruby_api_hook_focus_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_unhook: unhook something
+ */
+
+static VALUE
+weechat_ruby_api_unhook (VALUE class, VALUE hook)
+{
+ char *c_hook;
+
+ API_FUNC(1, "unhook", API_RETURN_ERROR);
+ if (NIL_P (hook))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (hook, T_STRING);
+
+ c_hook = StringValuePtr (hook);
+
+ plugin_script_api_unhook (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_hook));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_unhook_all: unhook all for script
+ */
+
+static VALUE
+weechat_ruby_api_unhook_all (VALUE class)
+{
+ API_FUNC(1, "unhook_all", API_RETURN_ERROR);
+
+ plugin_script_api_unhook_all (weechat_ruby_plugin, ruby_current_script);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_buffer_input_data_cb: callback for input data in a buffer
+ */
+
+int
+weechat_ruby_api_buffer_input_data_cb (void *data, struct t_gui_buffer *buffer,
+ const char *input_data)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[3];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(buffer);
+ func_argv[2] = (input_data) ? (char *)input_data : empty_arg;
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "sss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_buffer_close_cb: callback for closed buffer
+ */
+
+int
+weechat_ruby_api_buffer_close_cb (void *data, struct t_gui_buffer *buffer)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[2];
+ char empty_arg[1] = { '\0' };
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(buffer);
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "ss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_buffer_new: create a new buffer
+ */
+
+static VALUE
+weechat_ruby_api_buffer_new (VALUE class, VALUE name, VALUE function_input,
+ VALUE data_input, VALUE function_close,
+ VALUE data_close)
+{
+ char *c_name, *c_function_input, *c_data_input, *c_function_close;
+ char *c_data_close, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "buffer_new", API_RETURN_EMPTY);
+ if (NIL_P (name) || NIL_P (function_input) || NIL_P (data_input)
+ || NIL_P (function_close) || NIL_P (data_close))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (name, T_STRING);
+ Check_Type (function_input, T_STRING);
+ Check_Type (data_input, T_STRING);
+ Check_Type (function_close, T_STRING);
+ Check_Type (data_close, T_STRING);
+
+ c_name = StringValuePtr (name);
+ c_function_input = StringValuePtr (function_input);
+ c_data_input = StringValuePtr (data_input);
+ c_function_close = StringValuePtr (function_close);
+ c_data_close = StringValuePtr (data_close);
+
+ result = API_PTR2STR(plugin_script_api_buffer_new (weechat_ruby_plugin,
+ ruby_current_script,
+ c_name,
+ &weechat_ruby_api_buffer_input_data_cb,
+ c_function_input,
+ c_data_input,
+ &weechat_ruby_api_buffer_close_cb,
+ c_function_close,
+ c_data_close));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_buffer_search: search a buffer
+ */
+
+static VALUE
+weechat_ruby_api_buffer_search (VALUE class, VALUE plugin, VALUE name)
+{
+ char *c_plugin, *c_name, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "buffer_search", API_RETURN_EMPTY);
+ if (NIL_P (plugin) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (plugin, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_plugin = StringValuePtr (plugin);
+ c_name = StringValuePtr (name);
+
+ result = API_PTR2STR(weechat_buffer_search (c_plugin, c_name));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_buffer_search_main: search main buffer (WeeChat core buffer)
+ */
+
+static VALUE
+weechat_ruby_api_buffer_search_main (VALUE class)
+{
+ char *result;
+ VALUE return_value;
+
+ API_FUNC(1, "buffer_search_main", API_RETURN_EMPTY);
+
+ result = API_PTR2STR(weechat_buffer_search_main ());
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_current_buffer: get current buffer
+ */
+
+static VALUE
+weechat_ruby_api_current_buffer (VALUE class)
+{
+ char *result;
+ VALUE return_value;
+
+ API_FUNC(1, "current_buffer", API_RETURN_EMPTY);
+
+ result = API_PTR2STR(weechat_current_buffer ());
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_buffer_clear: clear a buffer
+ */
+
+static VALUE
+weechat_ruby_api_buffer_clear (VALUE class, VALUE buffer)
+{
+ char *c_buffer;
+
+ API_FUNC(1, "buffer_clear", API_RETURN_ERROR);
+ if (NIL_P (buffer))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+
+ weechat_buffer_clear (API_STR2PTR(c_buffer));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_buffer_close: close a buffer
+ */
+
+static VALUE
+weechat_ruby_api_buffer_close (VALUE class, VALUE buffer)
+{
+ char *c_buffer;
+
+ API_FUNC(1, "buffer_close", API_RETURN_ERROR);
+ if (NIL_P (buffer))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+
+ plugin_script_api_buffer_close (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_buffer));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_buffer_merge: merge a buffer to another buffer
+ */
+
+static VALUE
+weechat_ruby_api_buffer_merge (VALUE class, VALUE buffer, VALUE target_buffer)
+{
+ char *c_buffer, *c_target_buffer;
+
+ API_FUNC(1, "buffer_merge", API_RETURN_ERROR);
+ if (NIL_P (buffer) || NIL_P (target_buffer))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (target_buffer, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_target_buffer = StringValuePtr (target_buffer);
+
+ weechat_buffer_merge (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_target_buffer));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_buffer_unmerge: unmerge a buffer from a group of merged
+ * buffers
+ */
+
+static VALUE
+weechat_ruby_api_buffer_unmerge (VALUE class, VALUE buffer, VALUE number)
+{
+ char *c_buffer;
+ int c_number;
+
+ API_FUNC(1, "buffer_unmerge", API_RETURN_ERROR);
+ if (NIL_P (buffer) || NIL_P (number))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (number, T_FIXNUM);
+
+ c_buffer = StringValuePtr (buffer);
+ c_number = FIX2INT (number);
+
+ weechat_buffer_unmerge (API_STR2PTR(c_buffer), c_number);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_buffer_get_integer: get a buffer property as integer
+ */
+
+static VALUE
+weechat_ruby_api_buffer_get_integer (VALUE class, VALUE buffer, VALUE property)
+{
+ char *c_buffer, *c_property;
+ int value;
+
+ API_FUNC(1, "buffer_get_integer", API_RETURN_INT(-1));
+ if (NIL_P (buffer) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_INT(-1));
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_property = StringValuePtr (property);
+
+ value = weechat_buffer_get_integer (API_STR2PTR(c_buffer),
+ c_property);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_buffer_get_string: get a buffer property as string
+ */
+
+static VALUE
+weechat_ruby_api_buffer_get_string (VALUE class, VALUE buffer, VALUE property)
+{
+ char *c_buffer, *c_property;
+ const char *result;
+
+ API_FUNC(1, "buffer_get_string", API_RETURN_EMPTY);
+ if (NIL_P (buffer) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_property = StringValuePtr (property);
+
+ result = weechat_buffer_get_string (API_STR2PTR(c_buffer),
+ c_property);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_buffer_get_pointer: get a buffer property as pointer
+ */
+
+static VALUE
+weechat_ruby_api_buffer_get_pointer (VALUE class, VALUE buffer, VALUE property)
+{
+ char *c_buffer, *c_property, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "buffer_get_pointer", API_RETURN_EMPTY);
+ if (NIL_P (buffer) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_property = StringValuePtr (property);
+
+ result = API_PTR2STR(weechat_buffer_get_pointer (API_STR2PTR(c_buffer),
+ c_property));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_buffer_set: set a buffer property
+ */
+
+static VALUE
+weechat_ruby_api_buffer_set (VALUE class, VALUE buffer, VALUE property,
+ VALUE value)
+{
+ char *c_buffer, *c_property, *c_value;
+
+ API_FUNC(1, "buffer_set", API_RETURN_ERROR);
+ if (NIL_P (buffer) || NIL_P (property) || NIL_P (value))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (property, T_STRING);
+ Check_Type (value, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_property = StringValuePtr (property);
+ c_value = StringValuePtr (value);
+
+ weechat_buffer_set (API_STR2PTR(c_buffer),
+ c_property,
+ c_value);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_buffer_string_replace_local_var: replace local variables ($var) in a string,
+ * using value of local variables
+ */
+
+static VALUE
+weechat_ruby_api_buffer_string_replace_local_var (VALUE class, VALUE buffer, VALUE string)
+{
+ char *c_buffer, *c_string, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "buffer_string_replace_local_var", API_RETURN_ERROR);
+ if (NIL_P (buffer) || NIL_P (string))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (string, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_string = StringValuePtr (string);
+
+ result = weechat_buffer_string_replace_local_var (API_STR2PTR(c_buffer), c_string);
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_buffer_match_list: return 1 if buffer matches list of buffers
+ */
+
+static VALUE
+weechat_ruby_api_buffer_match_list (VALUE class, VALUE buffer, VALUE string)
+{
+ char *c_buffer, *c_string;
+ int value;
+
+ API_FUNC(1, "buffer_match_list", API_RETURN_INT(0));
+ if (NIL_P (buffer) || NIL_P (string))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (string, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_string = StringValuePtr (string);
+
+ value = weechat_buffer_match_list (API_STR2PTR(c_buffer),
+ c_string);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_current_window: get current window
+ */
+
+static VALUE
+weechat_ruby_api_current_window (VALUE class)
+{
+ char *result;
+ VALUE return_value;
+
+ API_FUNC(1, "current_window", API_RETURN_EMPTY);
+
+ result = API_PTR2STR(weechat_current_window ());
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_window_search_with_buffer: search a window with buffer
+ * pointer
+ */
+
+static VALUE
+weechat_ruby_api_window_search_with_buffer (VALUE class, VALUE buffer)
+{
+ char *c_buffer, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "window_search_with_buffer", API_RETURN_EMPTY);
+ if (NIL_P (buffer))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (buffer, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+
+ result = API_PTR2STR(weechat_window_search_with_buffer (API_STR2PTR(c_buffer)));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_window_get_integer: get a window property as integer
+ */
+
+static VALUE
+weechat_ruby_api_window_get_integer (VALUE class, VALUE window, VALUE property)
+{
+ char *c_window, *c_property;
+ int value;
+
+ API_FUNC(1, "window_get_integer", API_RETURN_INT(-1));
+ if (NIL_P (window) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_INT(-1));
+
+ Check_Type (window, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_window = StringValuePtr (window);
+ c_property = StringValuePtr (property);
+
+ value = weechat_window_get_integer (API_STR2PTR(c_window),
+ c_property);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_window_get_string: get a window property as string
+ */
+
+static VALUE
+weechat_ruby_api_window_get_string (VALUE class, VALUE window, VALUE property)
+{
+ char *c_window, *c_property;
+ const char *result;
+
+ API_FUNC(1, "window_get_string", API_RETURN_EMPTY);
+ if (NIL_P (window) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (window, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_window = StringValuePtr (window);
+ c_property = StringValuePtr (property);
+
+ result = weechat_window_get_string (API_STR2PTR(c_window),
+ c_property);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_window_get_pointer: get a window property as pointer
+ */
+
+static VALUE
+weechat_ruby_api_window_get_pointer (VALUE class, VALUE window, VALUE property)
+{
+ char *c_window, *c_property, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "window_get_pointer", API_RETURN_EMPTY);
+ if (NIL_P (window) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (window, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_window = StringValuePtr (window);
+ c_property = StringValuePtr (property);
+
+ result = API_PTR2STR(weechat_window_get_pointer (API_STR2PTR(c_window),
+ c_property));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_window_set_title: set window title
+ */
+
+static VALUE
+weechat_ruby_api_window_set_title (VALUE class, VALUE title)
+{
+ char *c_title;
+
+ API_FUNC(1, "window_set_title", API_RETURN_ERROR);
+ if (NIL_P (title))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (title, T_STRING);
+
+ c_title = StringValuePtr (title);
+
+ weechat_window_set_title (c_title);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_nicklist_add_group: add a group in nicklist
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_add_group (VALUE class, VALUE buffer,
+ VALUE parent_group, VALUE name,
+ VALUE color, VALUE visible)
+{
+ char *c_buffer, *c_parent_group, *c_name, *c_color, *result;
+ int c_visible;
+ VALUE return_value;
+
+ API_FUNC(1, "nicklist_add_group", API_RETURN_EMPTY);
+ if (NIL_P (buffer) || NIL_P (parent_group) || NIL_P (name) || NIL_P (color)
+ || NIL_P (visible))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (parent_group, T_STRING);
+ Check_Type (name, T_STRING);
+ Check_Type (color, T_STRING);
+ Check_Type (visible, T_FIXNUM);
+
+ c_buffer = StringValuePtr (buffer);
+ c_parent_group = StringValuePtr (parent_group);
+ c_name = StringValuePtr (name);
+ c_color = StringValuePtr (color);
+ c_visible = FIX2INT (visible);
+
+ result = API_PTR2STR(weechat_nicklist_add_group (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_parent_group),
+ c_name,
+ c_color,
+ c_visible));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_nicklist_search_group: search a group in nicklist
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_search_group (VALUE class, VALUE buffer,
+ VALUE from_group, VALUE name)
+{
+ char *c_buffer, *c_from_group, *c_name, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "nicklist_search_group", API_RETURN_EMPTY);
+ if (NIL_P (buffer) || NIL_P (from_group) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (from_group, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_from_group = StringValuePtr (from_group);
+ c_name = StringValuePtr (name);
+
+ result = API_PTR2STR(weechat_nicklist_search_group (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_from_group),
+ c_name));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_nicklist_add_nick: add a nick in nicklist
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_add_nick (VALUE class, VALUE buffer, VALUE group,
+ VALUE name, VALUE color, VALUE prefix,
+ VALUE prefix_color, VALUE visible)
+{
+ char *c_buffer, *c_group, *c_name, *c_color, *c_prefix, *c_prefix_color;
+ char *result;
+ int c_visible;
+ VALUE return_value;
+
+ API_FUNC(1, "nicklist_add_nick", API_RETURN_EMPTY);
+ if (NIL_P (buffer) || NIL_P (group) || NIL_P (name) || NIL_P (color)
+ || NIL_P (prefix) || NIL_P (prefix_color) || NIL_P (visible))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (group, T_STRING);
+ Check_Type (name, T_STRING);
+ Check_Type (color, T_STRING);
+ Check_Type (prefix, T_STRING);
+ Check_Type (prefix_color, T_STRING);
+ Check_Type (visible, T_FIXNUM);
+
+ c_buffer = StringValuePtr (buffer);
+ c_group = StringValuePtr (group);
+ c_name = StringValuePtr (name);
+ c_color = StringValuePtr (color);
+ c_prefix = StringValuePtr (prefix);
+ c_prefix_color = StringValuePtr (prefix_color);
+ c_visible = FIX2INT (visible);
+
+ result = API_PTR2STR(weechat_nicklist_add_nick (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_group),
+ c_name,
+ c_color,
+ c_prefix,
+ c_prefix_color,
+ c_visible));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_nicklist_search_nick: search a nick in nicklist
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_search_nick (VALUE class, VALUE buffer,
+ VALUE from_group, VALUE name)
+{
+ char *c_buffer, *c_from_group, *c_name, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "nicklist_search_nick", API_RETURN_EMPTY);
+ if (NIL_P (buffer) || NIL_P (from_group) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (from_group, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_from_group = StringValuePtr (from_group);
+ c_name = StringValuePtr (name);
+
+ result = API_PTR2STR(weechat_nicklist_search_nick (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_from_group),
+ c_name));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_nicklist_remove_group: remove a group from nicklist
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_remove_group (VALUE class, VALUE buffer, VALUE group)
+{
+ char *c_buffer, *c_group;
+
+ API_FUNC(1, "nicklist_remove_group", API_RETURN_ERROR);
+ if (NIL_P (buffer) || NIL_P (group))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (group, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_group = StringValuePtr (group);
+
+ weechat_nicklist_remove_group (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_group));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_nicklist_remove_nick: remove a nick from nicklist
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_remove_nick (VALUE class, VALUE buffer, VALUE nick)
+{
+ char *c_buffer, *c_nick;
+
+ API_FUNC(1, "nicklist_remove_nick", API_RETURN_ERROR);
+ if (NIL_P (buffer) || NIL_P (nick))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (nick, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_nick = StringValuePtr (nick);
+
+ weechat_nicklist_remove_nick (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_nick));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_nicklist_remove_all: remove all groups/nicks from nicklist
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_remove_all (VALUE class, VALUE buffer)
+{
+ char *c_buffer;
+
+ API_FUNC(1, "nicklist_remove_all", API_RETURN_ERROR);
+ if (NIL_P (buffer))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+
+ weechat_nicklist_remove_all (API_STR2PTR(c_buffer));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_nicklist_group_get_integer: get a group property as integer
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_group_get_integer (VALUE class, VALUE buffer,
+ VALUE group, VALUE property)
+{
+ char *c_buffer, *c_group, *c_property;
+ int value;
+
+ API_FUNC(1, "nicklist_group_get_integer", API_RETURN_INT(-1));
+ if (NIL_P (buffer) || NIL_P (group) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_INT(-1));
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (group, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_group = StringValuePtr (group);
+ c_property = StringValuePtr (property);
+
+ value = weechat_nicklist_group_get_integer (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_group),
+ c_property);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_nicklist_group_get_string: get a group property as string
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_group_get_string (VALUE class, VALUE buffer,
+ VALUE group, VALUE property)
+{
+ char *c_buffer, *c_group, *c_property;
+ const char *result;
+
+ API_FUNC(1, "nicklist_group_get_string", API_RETURN_EMPTY);
+ if (NIL_P (buffer) || NIL_P (group) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (group, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_group = StringValuePtr (group);
+ c_property = StringValuePtr (property);
+
+ result = weechat_nicklist_group_get_string (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_group),
+ c_property);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_nicklist_group_get_pointer: get a group property as pointer
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_group_get_pointer (VALUE class, VALUE buffer,
+ VALUE group, VALUE property)
+{
+ char *c_buffer, *c_group, *c_property, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "nicklist_group_get_pointer", API_RETURN_EMPTY);
+ if (NIL_P (buffer) || NIL_P (group) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (group, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_group = StringValuePtr (group);
+ c_property = StringValuePtr (property);
+
+ result = API_PTR2STR(weechat_nicklist_group_get_pointer (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_group),
+ c_property));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_nicklist_group_set: set a group property
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_group_set (VALUE class, VALUE buffer, VALUE group,
+ VALUE property, VALUE value)
+{
+ char *c_buffer, *c_group, *c_property, *c_value;
+
+ API_FUNC(1, "nicklist_group_set", API_RETURN_ERROR);
+ if (NIL_P (buffer) || NIL_P (group) || NIL_P (property) || NIL_P (value))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (group, T_STRING);
+ Check_Type (property, T_STRING);
+ Check_Type (value, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_group = StringValuePtr (group);
+ c_property = StringValuePtr (property);
+ c_value = StringValuePtr (value);
+
+ weechat_nicklist_group_set (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_group),
+ c_property,
+ c_value);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_nicklist_nick_get_integer: get a nick property as integer
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_nick_get_integer (VALUE class, VALUE buffer,
+ VALUE nick, VALUE property)
+{
+ char *c_buffer, *c_nick, *c_property;
+ int value;
+
+ API_FUNC(1, "nicklist_nick_get_integer", API_RETURN_INT(-1));
+ if (NIL_P (buffer) || NIL_P (nick) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_INT(-1));
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (nick, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_nick = StringValuePtr (nick);
+ c_property = StringValuePtr (property);
+
+ value = weechat_nicklist_nick_get_integer (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_nick),
+ c_property);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_nicklist_nick_get_string: get a nick property as string
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_nick_get_string (VALUE class, VALUE buffer,
+ VALUE nick, VALUE property)
+{
+ char *c_buffer, *c_nick, *c_property;
+ const char *result;
+
+ API_FUNC(1, "nicklist_nick_get_string", API_RETURN_EMPTY);
+ if (NIL_P (buffer) || NIL_P (nick) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (nick, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_nick = StringValuePtr (nick);
+ c_property = StringValuePtr (property);
+
+ result = weechat_nicklist_nick_get_string (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_nick),
+ c_property);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_nicklist_nick_get_pointer: get a nick property as pointer
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_nick_get_pointer (VALUE class, VALUE buffer,
+ VALUE nick, VALUE property)
+{
+ char *c_buffer, *c_nick, *c_property, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "nicklist_nick_get_pointer", API_RETURN_EMPTY);
+ if (NIL_P (buffer) || NIL_P (nick) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (nick, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_nick = StringValuePtr (nick);
+ c_property = StringValuePtr (property);
+
+ result = API_PTR2STR(weechat_nicklist_nick_get_pointer (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_nick),
+ c_property));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_nicklist_nick_set: set a nick property
+ */
+
+static VALUE
+weechat_ruby_api_nicklist_nick_set (VALUE class, VALUE buffer, VALUE nick,
+ VALUE property, VALUE value)
+{
+ char *c_buffer, *c_nick, *c_property, *c_value;
+
+ API_FUNC(1, "nicklist_nick_set", API_RETURN_ERROR);
+ if (NIL_P (buffer) || NIL_P (nick) || NIL_P (property) || NIL_P (value))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (nick, T_STRING);
+ Check_Type (property, T_STRING);
+ Check_Type (value, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_nick = StringValuePtr (nick);
+ c_property = StringValuePtr (property);
+ c_value = StringValuePtr (value);
+
+ weechat_nicklist_nick_set (API_STR2PTR(c_buffer),
+ API_STR2PTR(c_nick),
+ c_property,
+ c_value);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_bar_item_search: search a bar item
+ */
+
+static VALUE
+weechat_ruby_api_bar_item_search (VALUE class, VALUE name)
+{
+ char *c_name, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "bar_item_search", API_RETURN_EMPTY);
+ if (NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (name, T_STRING);
+
+ c_name = StringValuePtr (name);
+
+ result = API_PTR2STR(weechat_bar_item_search (c_name));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_bar_item_build_cb: callback for building bar item
+ */
+
+char *
+weechat_ruby_api_bar_item_build_cb (void *data, struct t_gui_bar_item *item,
+ struct t_gui_window *window)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[3];
+ char empty_arg[1] = { '\0' }, *ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(item);
+ func_argv[2] = API_PTR2STR(window);
+
+ ret = (char *)weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_STRING,
+ script_callback->function,
+ "sss", func_argv);
+
+ if (func_argv[1])
+ free (func_argv[1]);
+ if (func_argv[2])
+ free (func_argv[2]);
+
+ return ret;
+ }
+
+ return NULL;
+}
+
+/*
+ * weechat_ruby_api_bar_item_new: add a new bar item
+ */
+
+static VALUE
+weechat_ruby_api_bar_item_new (VALUE class, VALUE name, VALUE function,
+ VALUE data)
+{
+ char *c_name, *c_function, *c_data, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "bar_item_new", API_RETURN_EMPTY);
+ if (NIL_P (name) || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (name, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_name = StringValuePtr (name);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ result = API_PTR2STR(plugin_script_api_bar_item_new (weechat_ruby_plugin,
+ ruby_current_script,
+ c_name,
+ &weechat_ruby_api_bar_item_build_cb,
+ c_function,
+ c_data));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_bar_item_update: update a bar item on screen
+ */
+
+static VALUE
+weechat_ruby_api_bar_item_update (VALUE class, VALUE name)
+{
+ char *c_name;
+
+ API_FUNC(1, "bar_item_update", API_RETURN_ERROR);
+ if (NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (name, T_STRING);
+
+ c_name = StringValuePtr (name);
+
+ weechat_bar_item_update (c_name);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_bar_item_remove: remove a bar item
+ */
+
+static VALUE
+weechat_ruby_api_bar_item_remove (VALUE class, VALUE item)
+{
+ char *c_item;
+
+ API_FUNC(1, "bar_item_remove", API_RETURN_ERROR);
+ if (NIL_P (item))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (item, T_STRING);
+
+ c_item = StringValuePtr (item);
+
+ plugin_script_api_bar_item_remove (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_item));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_bar_search: search a bar
+ */
+
+static VALUE
+weechat_ruby_api_bar_search (VALUE class, VALUE name)
+{
+ char *c_name, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "bar_search", API_RETURN_EMPTY);
+ if (NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (name, T_STRING);
+
+ c_name = StringValuePtr (name);
+
+ result = API_PTR2STR(weechat_bar_search (c_name));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_bar_new: add a new bar
+ */
+
+static VALUE
+weechat_ruby_api_bar_new (VALUE class, VALUE name, VALUE hidden,
+ VALUE priority, VALUE type, VALUE conditions,
+ VALUE position, VALUE filling_top_bottom,
+ VALUE filling_left_right, VALUE size,
+ VALUE size_max, VALUE color_fg, VALUE color_delim,
+ VALUE color_bg, VALUE separator, VALUE items)
+{
+ char *c_name, *c_hidden, *c_priority, *c_type, *c_conditions, *c_position;
+ char *c_filling_top_bottom, *c_filling_left_right, *c_size, *c_size_max;
+ char *c_color_fg, *c_color_delim, *c_color_bg, *c_separator, *c_items;
+ char *result;
+ VALUE return_value;
+
+ API_FUNC(1, "bar_new", API_RETURN_EMPTY);
+ if (NIL_P (name) || NIL_P (hidden) || NIL_P (priority) || NIL_P (type)
+ || NIL_P (conditions) || NIL_P (position) || NIL_P (filling_top_bottom)
+ || NIL_P (filling_left_right) || NIL_P (size) || NIL_P (size_max)
+ || NIL_P (color_fg) || NIL_P (color_delim) || NIL_P (color_bg)
+ || NIL_P (separator) || NIL_P (items))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (name, T_STRING);
+ Check_Type (hidden, T_STRING);
+ Check_Type (priority, T_STRING);
+ Check_Type (type, T_STRING);
+ Check_Type (conditions, T_STRING);
+ Check_Type (position, T_STRING);
+ Check_Type (filling_top_bottom, T_STRING);
+ Check_Type (filling_left_right, T_STRING);
+ Check_Type (size, T_STRING);
+ Check_Type (size_max, T_STRING);
+ Check_Type (color_fg, T_STRING);
+ Check_Type (color_delim, T_STRING);
+ Check_Type (color_bg, T_STRING);
+ Check_Type (separator, T_STRING);
+ Check_Type (items, T_STRING);
+
+ c_name = StringValuePtr (name);
+ c_hidden = StringValuePtr (hidden);
+ c_priority = StringValuePtr (priority);
+ c_type = StringValuePtr (type);
+ c_conditions = StringValuePtr (conditions);
+ c_position = StringValuePtr (position);
+ c_filling_top_bottom = StringValuePtr (filling_top_bottom);
+ c_filling_left_right = StringValuePtr (filling_left_right);
+ c_size = StringValuePtr (size);
+ c_size_max = StringValuePtr (size_max);
+ c_color_fg = StringValuePtr (color_fg);
+ c_color_delim = StringValuePtr (color_delim);
+ c_color_bg = StringValuePtr (color_bg);
+ c_separator = StringValuePtr (separator);
+ c_items = StringValuePtr (items);
+
+ result = API_PTR2STR(weechat_bar_new (c_name,
+ c_hidden,
+ c_priority,
+ c_type,
+ c_conditions,
+ c_position,
+ c_filling_top_bottom,
+ c_filling_left_right,
+ c_size,
+ c_size_max,
+ c_color_fg,
+ c_color_delim,
+ c_color_bg,
+ c_separator,
+ c_items));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_bar_set: set a bar property
+ */
+
+static VALUE
+weechat_ruby_api_bar_set (VALUE class, VALUE bar, VALUE property, VALUE value)
+{
+ char *c_bar, *c_property, *c_value;
+
+ API_FUNC(1, "bar_set", API_RETURN_ERROR);
+ if (NIL_P (bar) || NIL_P (property) || NIL_P (value))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (bar, T_STRING);
+ Check_Type (property, T_STRING);
+ Check_Type (value, T_STRING);
+
+ c_bar = StringValuePtr (bar);
+ c_property = StringValuePtr (property);
+ c_value = StringValuePtr (value);
+
+ weechat_bar_set (API_STR2PTR(c_bar),
+ c_property,
+ c_value);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_bar_update: update a bar on screen
+ */
+
+static VALUE
+weechat_ruby_api_bar_update (VALUE class, VALUE name)
+{
+ char *c_name;
+
+ API_FUNC(1, "bar_update", API_RETURN_ERROR);
+ if (NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (name, T_STRING);
+
+ c_name = StringValuePtr (name);
+
+ weechat_bar_update (c_name);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_bar_remove: remove a bar
+ */
+
+static VALUE
+weechat_ruby_api_bar_remove (VALUE class, VALUE bar)
+{
+ char *c_bar;
+
+ API_FUNC(1, "bar_remove", API_RETURN_ERROR);
+ if (NIL_P (bar))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (bar, T_STRING);
+
+ c_bar = StringValuePtr (bar);
+
+ weechat_bar_remove (API_STR2PTR(c_bar));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_command: send command to server
+ */
+
+static VALUE
+weechat_ruby_api_command (VALUE class, VALUE buffer, VALUE command)
+{
+ char *c_buffer, *c_command;
+
+ API_FUNC(1, "command", API_RETURN_ERROR);
+ if (NIL_P (buffer) || NIL_P (command))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (buffer, T_STRING);
+ Check_Type (command, T_STRING);
+
+ c_buffer = StringValuePtr (buffer);
+ c_command = StringValuePtr (command);
+
+ plugin_script_api_command (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_buffer),
+ c_command);
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_info_get: get info (as string)
+ */
+
+static VALUE
+weechat_ruby_api_info_get (VALUE class, VALUE info_name, VALUE arguments)
+{
+ char *c_info_name, *c_arguments;
+ const char *result;
+
+ API_FUNC(1, "info_get", API_RETURN_EMPTY);
+ if (NIL_P (info_name) || NIL_P (arguments))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (info_name, T_STRING);
+ Check_Type (arguments, T_STRING);
+
+ c_info_name = StringValuePtr (info_name);
+ c_arguments = StringValuePtr (arguments);
+
+ result = weechat_info_get (c_info_name, c_arguments);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_info_get_hashtable: get info (as hashtable)
+ */
+
+static VALUE
+weechat_ruby_api_info_get_hashtable (VALUE class, VALUE info_name,
+ VALUE hash)
+{
+ char *c_info_name;
+ struct t_hashtable *c_hashtable, *result_hashtable;
+ VALUE result_hash;
+
+ API_FUNC(1, "info_get_hashtable", API_RETURN_EMPTY);
+ if (NIL_P (info_name) || NIL_P (hash))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (info_name, T_STRING);
+ Check_Type (hash, T_HASH);
+
+ c_info_name = StringValuePtr (info_name);
+ c_hashtable = weechat_ruby_hash_to_hashtable (hash,
+ WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE);
+
+ result_hashtable = weechat_info_get_hashtable (c_info_name, c_hashtable);
+ result_hash = weechat_ruby_hashtable_to_hash (result_hashtable);
+
+ if (c_hashtable)
+ weechat_hashtable_free (c_hashtable);
+ if (result_hashtable)
+ weechat_hashtable_free (result_hashtable);
+
+ return result_hash;
+}
+
+/*
+ * weechat_ruby_api_infolist_new: create new infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_new (VALUE class)
+{
+ char *result;
+ VALUE return_value;
+
+ API_FUNC(1, "infolist_new", API_RETURN_EMPTY);
+
+ result = API_PTR2STR(weechat_infolist_new ());
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_infolist_new_item: create new item in infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_new_item (VALUE class, VALUE infolist)
+{
+ char *c_infolist, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "infolist_new_item", API_RETURN_EMPTY);
+ if (NIL_P (infolist))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (infolist, T_STRING);
+
+ c_infolist = StringValuePtr (infolist);
+
+ result = API_PTR2STR(weechat_infolist_new_item (API_STR2PTR(c_infolist)));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_infolist_new_var_integer: create new integer variable in
+ * infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_new_var_integer (VALUE class, VALUE infolist,
+ VALUE name, VALUE value)
+{
+ char *c_infolist, *c_name, *result;
+ int c_value;
+ VALUE return_value;
+
+ API_FUNC(1, "infolist_new_var_integer", API_RETURN_EMPTY);
+ if (NIL_P (infolist) || NIL_P (name) || NIL_P (value))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (infolist, T_STRING);
+ Check_Type (name, T_STRING);
+ Check_Type (value, T_FIXNUM);
+
+ c_infolist = StringValuePtr (infolist);
+ c_name = StringValuePtr (name);
+ c_value = FIX2INT (value);
+
+ result = API_PTR2STR(weechat_infolist_new_var_integer (API_STR2PTR(c_infolist),
+ c_name,
+ c_value));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_infolist_new_var_string: create new string variable in
+ * infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_new_var_string (VALUE class, VALUE infolist,
+ VALUE name, VALUE value)
+{
+ char *c_infolist, *c_name, *c_value, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "infolist_new_var_string", API_RETURN_EMPTY);
+ if (NIL_P (infolist) || NIL_P (name) || NIL_P (value))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (infolist, T_STRING);
+ Check_Type (name, T_STRING);
+ Check_Type (value, T_STRING);
+
+ c_infolist = StringValuePtr (infolist);
+ c_name = StringValuePtr (name);
+ c_value = StringValuePtr (value);
+
+ result = API_PTR2STR(weechat_infolist_new_var_string (API_STR2PTR(c_infolist),
+ c_name,
+ c_value));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_infolist_new_var_pointer: create new pointer variable in
+ * infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_new_var_pointer (VALUE class, VALUE infolist,
+ VALUE name, VALUE value)
+{
+ char *c_infolist, *c_name, *c_value, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "infolist_new_var_pointer", API_RETURN_EMPTY);
+ if (NIL_P (infolist) || NIL_P (name) || NIL_P (value))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (infolist, T_STRING);
+ Check_Type (name, T_STRING);
+ Check_Type (value, T_STRING);
+
+ c_infolist = StringValuePtr (infolist);
+ c_name = StringValuePtr (name);
+ c_value = StringValuePtr (value);
+
+ result = API_PTR2STR(weechat_infolist_new_var_pointer (API_STR2PTR(c_infolist),
+ c_name,
+ API_STR2PTR(c_value)));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_infolist_new_var_time: create new time variable in infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_new_var_time (VALUE class, VALUE infolist,
+ VALUE name, VALUE value)
+{
+ char *c_infolist, *c_name, *result;
+ int c_value;
+ VALUE return_value;
+
+ API_FUNC(1, "infolist_new_var_time", API_RETURN_EMPTY);
+ if (NIL_P (infolist) || NIL_P (name) || NIL_P (value))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (infolist, T_STRING);
+ Check_Type (name, T_STRING);
+ Check_Type (value, T_FIXNUM);
+
+ c_infolist = StringValuePtr (infolist);
+ c_name = StringValuePtr (name);
+ c_value = FIX2INT (value);
+
+ result = API_PTR2STR(weechat_infolist_new_var_time (API_STR2PTR(c_infolist),
+ c_name,
+ c_value));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_infolist_get: get list with infos
+ */
+
+static VALUE
+weechat_ruby_api_infolist_get (VALUE class, VALUE name, VALUE pointer,
+ VALUE arguments)
+{
+ char *c_name, *c_pointer, *c_arguments, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "infolist_get", API_RETURN_EMPTY);
+ if (NIL_P (name) || NIL_P (pointer) || NIL_P (arguments))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (name, T_STRING);
+ Check_Type (pointer, T_STRING);
+ Check_Type (arguments, T_STRING);
+
+ c_name = StringValuePtr (name);
+ c_pointer = StringValuePtr (pointer);
+ c_arguments = StringValuePtr (arguments);
+
+ result = API_PTR2STR(weechat_infolist_get (c_name,
+ API_STR2PTR(c_pointer),
+ c_arguments));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_infolist_next: move item pointer to next item in infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_next (VALUE class, VALUE infolist)
+{
+ char *c_infolist;
+ int value;
+
+ API_FUNC(1, "infolist_next", API_RETURN_INT(0));
+ if (NIL_P (infolist))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (infolist, T_STRING);
+
+ c_infolist = StringValuePtr (infolist);
+
+ value = weechat_infolist_next (API_STR2PTR(c_infolist));
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_infolist_prev: move item pointer to previous item in infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_prev (VALUE class, VALUE infolist)
+{
+ char *c_infolist;
+ int value;
+
+ API_FUNC(1, "infolist_prev", API_RETURN_INT(0));
+ if (NIL_P (infolist))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (infolist, T_STRING);
+
+ c_infolist = StringValuePtr (infolist);
+
+ value = weechat_infolist_prev (API_STR2PTR(c_infolist));
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_infolist_reset_item_cursor: reset pointer to current item
+ * in infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_reset_item_cursor (VALUE class, VALUE infolist)
+{
+ char *c_infolist;
+
+ API_FUNC(1, "infolist_reset_item_cursor", API_RETURN_ERROR);
+ if (NIL_P (infolist))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (infolist, T_STRING);
+
+ c_infolist = StringValuePtr (infolist);
+
+ weechat_infolist_reset_item_cursor (API_STR2PTR(c_infolist));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_infolist_fields: get list of fields for current item of infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_fields (VALUE class, VALUE infolist)
+{
+ char *c_infolist;
+ const char *result;
+
+ API_FUNC(1, "infolist_fields", API_RETURN_EMPTY);
+ if (NIL_P (infolist))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (infolist, T_STRING);
+
+ c_infolist = StringValuePtr (infolist);
+
+ result = weechat_infolist_fields (API_STR2PTR(c_infolist));
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_infolist_integer: get integer value of a variable in infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_integer (VALUE class, VALUE infolist, VALUE variable)
+{
+ char *c_infolist, *c_variable;
+ int value;
+
+ API_FUNC(1, "infolist_integer", API_RETURN_INT(0));
+ if (NIL_P (infolist) || NIL_P (variable))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (infolist, T_STRING);
+ Check_Type (variable, T_STRING);
+
+ c_infolist = StringValuePtr (infolist);
+ c_variable = StringValuePtr (variable);
+
+ value = weechat_infolist_integer (API_STR2PTR(c_infolist), c_variable);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_infolist_string: get string value of a variable in infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_string (VALUE class, VALUE infolist, VALUE variable)
+{
+ char *c_infolist, *c_variable;
+ const char *result;
+
+ API_FUNC(1, "infolist_string", API_RETURN_EMPTY);
+ if (NIL_P (infolist) || NIL_P (variable))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (infolist, T_STRING);
+ Check_Type (variable, T_STRING);
+
+ c_infolist = StringValuePtr (infolist);
+ c_variable = StringValuePtr (variable);
+
+ result = weechat_infolist_string (API_STR2PTR(c_infolist), c_variable);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_infolist_pointer: get pointer value of a variable in infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_pointer (VALUE class, VALUE infolist, VALUE variable)
+{
+ char *c_infolist, *c_variable, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "infolist_pointer", API_RETURN_EMPTY);
+ if (NIL_P (infolist) || NIL_P (variable))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (infolist, T_STRING);
+ Check_Type (variable, T_STRING);
+
+ c_infolist = StringValuePtr (infolist);
+ c_variable = StringValuePtr (variable);
+
+ result = API_PTR2STR(weechat_infolist_pointer (API_STR2PTR(c_infolist), c_variable));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_infolist_time: get time value of a variable in infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_time (VALUE class, VALUE infolist, VALUE variable)
+{
+ char *c_infolist, *c_variable, timebuffer[64], *result;
+ time_t time;
+ struct tm *date_tmp;
+ VALUE return_value;
+
+ API_FUNC(1, "infolist_time", API_RETURN_EMPTY);
+ if (NIL_P (infolist) || NIL_P (variable))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (infolist, T_STRING);
+ Check_Type (variable, T_STRING);
+
+ c_infolist = StringValuePtr (infolist);
+ c_variable = StringValuePtr (variable);
+
+ timebuffer[0] = '\0';
+ time = weechat_infolist_time (API_STR2PTR(c_infolist), c_variable);
+ date_tmp = localtime (&time);
+ if (date_tmp)
+ strftime (timebuffer, sizeof (timebuffer), "%F %T", date_tmp);
+ result = strdup (timebuffer);
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_infolist_free: free infolist
+ */
+
+static VALUE
+weechat_ruby_api_infolist_free (VALUE class, VALUE infolist)
+{
+ char *c_infolist;
+
+ API_FUNC(1, "infolist_free", API_RETURN_ERROR);
+ if (NIL_P (infolist))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (infolist, T_STRING);
+
+ c_infolist = StringValuePtr (infolist);
+
+ weechat_infolist_free (API_STR2PTR(c_infolist));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_hdata_get: get hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_get (VALUE class, VALUE name)
+{
+ char *c_name, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hdata_get", API_RETURN_EMPTY);
+ if (NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (name, T_STRING);
+
+ c_name = StringValuePtr (name);
+
+ result = API_PTR2STR(weechat_hdata_get (c_name));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hdata_get_var_offset: get offset of variable in hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_get_var_offset (VALUE class, VALUE hdata, VALUE name)
+{
+ char *c_hdata, *c_name;
+ int value;
+
+ API_FUNC(1, "hdata_get_var_offset", API_RETURN_INT(0));
+ if (NIL_P (hdata) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_name = StringValuePtr (name);
+
+ value = weechat_hdata_get_var_offset (API_STR2PTR(c_hdata), c_name);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_hdata_get_var_type_string: get type of variable as string
+ * in hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_get_var_type_string (VALUE class, VALUE hdata,
+ VALUE name)
+{
+ char *c_hdata, *c_name;
+ const char *result;
+
+ API_FUNC(1, "hdata_get_var_type_string", API_RETURN_EMPTY);
+ if (NIL_P (hdata) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_name = StringValuePtr (name);
+
+ result = weechat_hdata_get_var_type_string (API_STR2PTR(c_hdata), c_name);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_hdata_get_var_array_size: get array size for variable in hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_get_var_array_size (VALUE class, VALUE hdata, VALUE pointer,
+ VALUE name)
+{
+ char *c_hdata, *c_pointer, *c_name;
+ int value;
+
+ API_FUNC(1, "hdata_get_var_array_size", API_RETURN_INT(-1));
+ if (NIL_P (hdata) || NIL_P (pointer) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_INT(-1));
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (pointer, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_pointer = StringValuePtr (pointer);
+ c_name = StringValuePtr (name);
+
+ value = weechat_hdata_get_var_array_size (API_STR2PTR(c_hdata),
+ API_STR2PTR(c_pointer),
+ c_name);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_hdata_get_var_array_size_string: get array size for variable
+ * in hdata (as string)
+ */
+
+static VALUE
+weechat_ruby_api_hdata_get_var_array_size_string (VALUE class, VALUE hdata,
+ VALUE pointer, VALUE name)
+{
+ char *c_hdata, *c_pointer, *c_name;
+ const char *result;
+
+ API_FUNC(1, "hdata_get_var_array_size_string", API_RETURN_EMPTY);
+ if (NIL_P (hdata) || NIL_P (pointer) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (pointer, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_pointer = StringValuePtr (pointer);
+ c_name = StringValuePtr (name);
+
+ result = weechat_hdata_get_var_array_size_string (API_STR2PTR(c_hdata),
+ API_STR2PTR(c_pointer),
+ c_name);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_hdata_get_var_hdata: get hdata for variable in hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_get_var_hdata (VALUE class, VALUE hdata, VALUE name)
+{
+ char *c_hdata, *c_name;
+ const char *result;
+
+ API_FUNC(1, "hdata_get_var_hdata", API_RETURN_EMPTY);
+ if (NIL_P (hdata) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_name = StringValuePtr (name);
+
+ result = weechat_hdata_get_var_hdata (API_STR2PTR(c_hdata), c_name);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_hdata_get_list: get list pointer in hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_get_list (VALUE class, VALUE hdata, VALUE name)
+{
+ char *c_hdata, *c_name, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hdata_get_list", API_RETURN_EMPTY);
+ if (NIL_P (hdata) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_name = StringValuePtr (name);
+
+ result = API_PTR2STR(weechat_hdata_get_list (API_STR2PTR(c_hdata),
+ c_name));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hdata_check_pointer: check pointer with hdata/list
+ */
+
+static VALUE
+weechat_ruby_api_hdata_check_pointer (VALUE class, VALUE hdata, VALUE list,
+ VALUE pointer)
+{
+ char *c_hdata, *c_list, *c_pointer;
+ int value;
+
+ API_FUNC(1, "hdata_check_pointer", API_RETURN_INT(0));
+ if (NIL_P (hdata) || NIL_P (list) || NIL_P (pointer))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (list, T_STRING);
+ Check_Type (pointer, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_list = StringValuePtr (list);
+ c_pointer = StringValuePtr (pointer);
+
+ value = weechat_hdata_check_pointer (API_STR2PTR(c_hdata),
+ API_STR2PTR(c_list),
+ API_STR2PTR(c_pointer));
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_hdata_move: move pointer to another element in list
+ */
+
+static VALUE
+weechat_ruby_api_hdata_move (VALUE class, VALUE hdata, VALUE pointer,
+ VALUE count)
+{
+ char *c_hdata, *c_pointer, *result;
+ int c_count;
+ VALUE return_value;
+
+ API_FUNC(1, "hdata_move", API_RETURN_EMPTY);
+ if (NIL_P (hdata) || NIL_P (pointer) || NIL_P (count))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (pointer, T_STRING);
+ Check_Type (count, T_FIXNUM);
+
+ c_hdata = StringValuePtr (hdata);
+ c_pointer = StringValuePtr (pointer);
+ c_count = FIX2INT (count);
+
+ result = weechat_hdata_move (API_STR2PTR(c_hdata),
+ API_STR2PTR(c_pointer),
+ c_count);
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hdata_char: get char value of a variable in structure using
+ * hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_char (VALUE class, VALUE hdata, VALUE pointer,
+ VALUE name)
+{
+ char *c_hdata, *c_pointer, *c_name;
+ int value;
+
+ API_FUNC(1, "hdata_char", API_RETURN_INT(0));
+ if (NIL_P (hdata) || NIL_P (pointer) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (pointer, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_pointer = StringValuePtr (pointer);
+ c_name = StringValuePtr (name);
+
+ value = (int)weechat_hdata_char (API_STR2PTR(c_hdata),
+ API_STR2PTR(c_pointer),
+ c_name);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_hdata_integer: get integer value of a variable in structure
+ * using hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_integer (VALUE class, VALUE hdata, VALUE pointer,
+ VALUE name)
+{
+ char *c_hdata, *c_pointer, *c_name;
+ int value;
+
+ API_FUNC(1, "hdata_integer", API_RETURN_INT(0));
+ if (NIL_P (hdata) || NIL_P (pointer) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (pointer, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_pointer = StringValuePtr (pointer);
+ c_name = StringValuePtr (name);
+
+ value = weechat_hdata_integer (API_STR2PTR(c_hdata),
+ API_STR2PTR(c_pointer),
+ c_name);
+
+ API_RETURN_INT(value);
+}
+
+/*
+ * weechat_ruby_api_hdata_long: get long value of a variable in structure using
+ * hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_long (VALUE class, VALUE hdata, VALUE pointer,
+ VALUE name)
+{
+ char *c_hdata, *c_pointer, *c_name;
+ long value;
+
+ API_FUNC(1, "hdata_long", API_RETURN_LONG(0));
+ if (NIL_P (hdata) || NIL_P (pointer) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_LONG(0));
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (pointer, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_pointer = StringValuePtr (pointer);
+ c_name = StringValuePtr (name);
+
+ value = weechat_hdata_long (API_STR2PTR(c_hdata),
+ API_STR2PTR(c_pointer),
+ c_name);
+
+ API_RETURN_LONG(value);
+}
+
+/*
+ * weechat_ruby_api_hdata_string: get string value of a variable in structure
+ * using hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_string (VALUE class, VALUE hdata, VALUE pointer,
+ VALUE name)
+{
+ char *c_hdata, *c_pointer, *c_name;
+ const char *result;
+
+ API_FUNC(1, "hdata_string", API_RETURN_EMPTY);
+ if (NIL_P (hdata) || NIL_P (pointer) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (pointer, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_pointer = StringValuePtr (pointer);
+ c_name = StringValuePtr (name);
+
+ result = weechat_hdata_string (API_STR2PTR(c_hdata),
+ API_STR2PTR(c_pointer),
+ c_name);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_hdata_pointer: get pointer value of a variable in structure
+ * using hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_pointer (VALUE class, VALUE hdata, VALUE pointer,
+ VALUE name)
+{
+ char *c_hdata, *c_pointer, *c_name, *result;
+ VALUE return_value;
+
+ API_FUNC(1, "hdata_pointer", API_RETURN_EMPTY);
+ if (NIL_P (hdata) || NIL_P (pointer) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (pointer, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_pointer = StringValuePtr (pointer);
+ c_name = StringValuePtr (name);
+
+ result = API_PTR2STR(weechat_hdata_pointer (API_STR2PTR(c_hdata),
+ API_STR2PTR(c_pointer),
+ c_name));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hdata_time: get time value of a variable in structure using
+ * hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_time (VALUE class, VALUE hdata, VALUE pointer,
+ VALUE name)
+{
+ char *c_hdata, *c_pointer, *c_name, timebuffer[64], *result;
+ time_t time;
+ struct tm *date_tmp;
+ VALUE return_value;
+
+ API_FUNC(1, "hdata_time", API_RETURN_EMPTY);
+ if (NIL_P (hdata) || NIL_P (pointer) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (pointer, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_pointer = StringValuePtr (pointer);
+ c_name = StringValuePtr (name);
+
+ timebuffer[0] = '\0';
+ time = weechat_hdata_time (API_STR2PTR(c_hdata),
+ API_STR2PTR(c_pointer),
+ c_name);
+ date_tmp = localtime (&time);
+ if (date_tmp)
+ strftime (timebuffer, sizeof (timebuffer), "%F %T", date_tmp);
+ result = strdup (timebuffer);
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_hdata_hashtable: get hashtable value of a variable in
+ * structure using hdata
+ */
+
+static VALUE
+weechat_ruby_api_hdata_hashtable (VALUE class, VALUE hdata, VALUE pointer,
+ VALUE name)
+{
+ char *c_hdata, *c_pointer, *c_name;
+ VALUE result_hash;
+
+ API_FUNC(1, "hdata_hashtable", API_RETURN_EMPTY);
+ if (NIL_P (hdata) || NIL_P (pointer) || NIL_P (name))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (pointer, T_STRING);
+ Check_Type (name, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_pointer = StringValuePtr (pointer);
+ c_name = StringValuePtr (name);
+
+ result_hash = weechat_ruby_hashtable_to_hash (
+ weechat_hdata_hashtable (API_STR2PTR(c_hdata),
+ API_STR2PTR(c_pointer),
+ c_name));
+
+ return result_hash;
+}
+
+/*
+ * weechat_ruby_api_hdata_get_string: get hdata property as string
+ */
+
+static VALUE
+weechat_ruby_api_hdata_get_string (VALUE class, VALUE hdata, VALUE property)
+{
+ char *c_hdata, *c_property;
+ const char *result;
+
+ API_FUNC(1, "hdata_get_string", API_RETURN_EMPTY);
+ if (NIL_P (hdata) || NIL_P (property))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (hdata, T_STRING);
+ Check_Type (property, T_STRING);
+
+ c_hdata = StringValuePtr (hdata);
+ c_property = StringValuePtr (property);
+
+ result = weechat_hdata_get_var_type_string (API_STR2PTR(c_hdata),
+ c_property);
+
+ API_RETURN_STRING(result);
+}
+
+/*
+ * weechat_ruby_api_upgrade_new: create an upgrade file
+ */
+
+static VALUE
+weechat_ruby_api_upgrade_new (VALUE class, VALUE filename, VALUE write)
+{
+ char *c_filename, *result;
+ int c_write;
+ VALUE return_value;
+
+ API_FUNC(1, "upgrade_new", API_RETURN_EMPTY);
+ if (NIL_P (filename) || NIL_P (write))
+ API_WRONG_ARGS(API_RETURN_EMPTY);
+
+ Check_Type (filename, T_STRING);
+ Check_Type (write, T_FIXNUM);
+
+ c_filename = StringValuePtr (filename);
+ c_write = FIX2INT (write);
+
+ result = API_PTR2STR(weechat_upgrade_new (c_filename,
+ c_write));
+
+ API_RETURN_STRING_FREE(result);
+}
+
+/*
+ * weechat_ruby_api_upgrade_write_object: write object in upgrade file
+ */
+
+static VALUE
+weechat_ruby_api_upgrade_write_object (VALUE class, VALUE upgrade_file,
+ VALUE object_id, VALUE infolist)
+{
+ char *c_upgrade_file, *c_infolist;
+ int c_object_id, rc;
+
+ API_FUNC(1, "upgrade_write_object", API_RETURN_INT(0));
+ if (NIL_P (upgrade_file) || NIL_P (object_id) || NIL_P (infolist))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (upgrade_file, T_STRING);
+ Check_Type (object_id, T_FIXNUM);
+ Check_Type (infolist, T_STRING);
+
+ c_upgrade_file = StringValuePtr (upgrade_file);
+ c_object_id = FIX2INT (object_id);
+ c_infolist = StringValuePtr (infolist);
+
+ rc = weechat_upgrade_write_object (API_STR2PTR(c_upgrade_file),
+ c_object_id,
+ API_STR2PTR(c_infolist));
+
+ API_RETURN_INT(rc);
+}
+
+/*
+ * weechat_ruby_api_upgrade_read_cb: callback for reading object in upgrade file
+ */
+
+int
+weechat_ruby_api_upgrade_read_cb (void *data,
+ struct t_upgrade_file *upgrade_file,
+ int object_id,
+ struct t_infolist *infolist)
+{
+ struct t_script_callback *script_callback;
+ void *func_argv[4];
+ char empty_arg[1] = { '\0' }, str_object_id[32];
+ int *rc, ret;
+
+ script_callback = (struct t_script_callback *)data;
+
+ if (script_callback && script_callback->function && script_callback->function[0])
+ {
+ snprintf (str_object_id, sizeof (str_object_id), "%d", object_id);
+
+ func_argv[0] = (script_callback->data) ? script_callback->data : empty_arg;
+ func_argv[1] = API_PTR2STR(upgrade_file);
+ func_argv[2] = str_object_id;
+ func_argv[3] = API_PTR2STR(infolist);
+
+ rc = (int *) weechat_ruby_exec (script_callback->script,
+ WEECHAT_SCRIPT_EXEC_INT,
+ script_callback->function,
+ "ssss", func_argv);
+
+ if (!rc)
+ ret = WEECHAT_RC_ERROR;
+ else
+ {
+ ret = *rc;
+ free (rc);
+ }
+ if (func_argv[1])
+ free (func_argv[1]);
+ if (func_argv[3])
+ free (func_argv[3]);
+
+ return ret;
+ }
+
+ return WEECHAT_RC_ERROR;
+}
+
+/*
+ * weechat_ruby_api_upgrade_read: read upgrade file
+ */
+
+static VALUE
+weechat_ruby_api_upgrade_read (VALUE class, VALUE upgrade_file,
+ VALUE function, VALUE data)
+{
+ char *c_upgrade_file, *c_function, *c_data;
+ int rc;
+
+ API_FUNC(1, "upgrade_read", API_RETURN_INT(0));
+ if (NIL_P (upgrade_file) || NIL_P (function) || NIL_P (data))
+ API_WRONG_ARGS(API_RETURN_INT(0));
+
+ Check_Type (upgrade_file, T_STRING);
+ Check_Type (function, T_STRING);
+ Check_Type (data, T_STRING);
+
+ c_upgrade_file = StringValuePtr (upgrade_file);
+ c_function = StringValuePtr (function);
+ c_data = StringValuePtr (data);
+
+ rc = plugin_script_api_upgrade_read (weechat_ruby_plugin,
+ ruby_current_script,
+ API_STR2PTR(c_upgrade_file),
+ &weechat_ruby_api_upgrade_read_cb,
+ c_function,
+ c_data);
+
+ API_RETURN_INT(rc);
+}
+
+/*
+ * weechat_ruby_api_upgrade_close: close upgrade file
+ */
+
+static VALUE
+weechat_ruby_api_upgrade_close (VALUE class, VALUE upgrade_file)
+{
+ char *c_upgrade_file;
+
+ API_FUNC(1, "upgrade_close", API_RETURN_ERROR);
+ if (NIL_P (upgrade_file))
+ API_WRONG_ARGS(API_RETURN_ERROR);
+
+ Check_Type (upgrade_file, T_STRING);
+
+ c_upgrade_file = StringValuePtr (upgrade_file);
+
+ weechat_upgrade_close (API_STR2PTR(c_upgrade_file));
+
+ API_RETURN_OK;
+}
+
+/*
+ * weechat_ruby_api_init: init Ruby API: add variables and functions
+ */
+
+void
+weechat_ruby_api_init (VALUE ruby_mWeechat)
+{
+ rb_define_const(ruby_mWeechat, "WEECHAT_RC_OK", INT2NUM(WEECHAT_RC_OK));
+ rb_define_const(ruby_mWeechat, "WEECHAT_RC_OK_EAT", INT2NUM(WEECHAT_RC_OK_EAT));
+ rb_define_const(ruby_mWeechat, "WEECHAT_RC_ERROR", INT2NUM(WEECHAT_RC_ERROR));
+
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_READ_OK", INT2NUM(WEECHAT_CONFIG_READ_OK));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_READ_MEMORY_ERROR", INT2NUM(WEECHAT_CONFIG_READ_MEMORY_ERROR));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_READ_FILE_NOT_FOUND", INT2NUM(WEECHAT_CONFIG_READ_FILE_NOT_FOUND));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_WRITE_OK", INT2NUM(WEECHAT_CONFIG_WRITE_OK));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_WRITE_ERROR", INT2NUM(WEECHAT_CONFIG_WRITE_ERROR));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_WRITE_MEMORY_ERROR", INT2NUM(WEECHAT_CONFIG_WRITE_MEMORY_ERROR));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_OPTION_SET_OK_CHANGED", INT2NUM(WEECHAT_CONFIG_OPTION_SET_OK_CHANGED));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE", INT2NUM(WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_OPTION_SET_ERROR", INT2NUM(WEECHAT_CONFIG_OPTION_SET_ERROR));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND", INT2NUM(WEECHAT_CONFIG_OPTION_SET_OPTION_NOT_FOUND));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET", INT2NUM(WEECHAT_CONFIG_OPTION_UNSET_OK_NO_RESET));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_OPTION_UNSET_OK_RESET", INT2NUM(WEECHAT_CONFIG_OPTION_UNSET_OK_RESET));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED", INT2NUM(WEECHAT_CONFIG_OPTION_UNSET_OK_REMOVED));
+ rb_define_const(ruby_mWeechat, "WEECHAT_CONFIG_OPTION_UNSET_ERROR", INT2NUM(WEECHAT_CONFIG_OPTION_UNSET_ERROR));
+
+ rb_define_const(ruby_mWeechat, "WEECHAT_LIST_POS_SORT", rb_str_new2(WEECHAT_LIST_POS_SORT));
+ rb_define_const(ruby_mWeechat, "WEECHAT_LIST_POS_BEGINNING", rb_str_new2(WEECHAT_LIST_POS_BEGINNING));
+ rb_define_const(ruby_mWeechat, "WEECHAT_LIST_POS_END", rb_str_new2(WEECHAT_LIST_POS_END));
+
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOTLIST_LOW", rb_str_new2(WEECHAT_HOTLIST_LOW));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOTLIST_MESSAGE", rb_str_new2(WEECHAT_HOTLIST_MESSAGE));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOTLIST_PRIVATE", rb_str_new2(WEECHAT_HOTLIST_PRIVATE));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOTLIST_HIGHLIGHT", rb_str_new2(WEECHAT_HOTLIST_HIGHLIGHT));
+
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_PROCESS_RUNNING", INT2NUM(WEECHAT_HOOK_PROCESS_RUNNING));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_PROCESS_ERROR", INT2NUM(WEECHAT_HOOK_PROCESS_ERROR));
+
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_CONNECT_OK", INT2NUM(WEECHAT_HOOK_CONNECT_OK));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_CONNECT_ADDRESS_NOT_FOUND", INT2NUM(WEECHAT_HOOK_CONNECT_ADDRESS_NOT_FOUND));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_CONNECT_IP_ADDRESS_NOT_FOUND", INT2NUM(WEECHAT_HOOK_CONNECT_IP_ADDRESS_NOT_FOUND));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_CONNECT_CONNECTION_REFUSED", INT2NUM(WEECHAT_HOOK_CONNECT_CONNECTION_REFUSED));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_CONNECT_PROXY_ERROR", INT2NUM(WEECHAT_HOOK_CONNECT_PROXY_ERROR));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_CONNECT_LOCAL_HOSTNAME_ERROR", INT2NUM(WEECHAT_HOOK_CONNECT_LOCAL_HOSTNAME_ERROR));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_CONNECT_GNUTLS_INIT_ERROR", INT2NUM(WEECHAT_HOOK_CONNECT_GNUTLS_INIT_ERROR));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_CONNECT_GNUTLS_HANDSHAKE_ERROR", INT2NUM(WEECHAT_HOOK_CONNECT_GNUTLS_HANDSHAKE_ERROR));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_CONNECT_MEMORY_ERROR", INT2NUM(WEECHAT_HOOK_CONNECT_MEMORY_ERROR));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_CONNECT_TIMEOUT", INT2NUM(WEECHAT_HOOK_CONNECT_TIMEOUT));
+
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_SIGNAL_STRING", rb_str_new2(WEECHAT_HOOK_SIGNAL_STRING));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_SIGNAL_INT", rb_str_new2(WEECHAT_HOOK_SIGNAL_INT));
+ rb_define_const(ruby_mWeechat, "WEECHAT_HOOK_SIGNAL_POINTER", rb_str_new2(WEECHAT_HOOK_SIGNAL_POINTER));
+
+ API_DEF_FUNC(register, 7);
+ API_DEF_FUNC(plugin_get_name, 1);
+ API_DEF_FUNC(charset_set, 1);
+ API_DEF_FUNC(iconv_to_internal, 2);
+ API_DEF_FUNC(iconv_from_internal, 2);
+ API_DEF_FUNC(gettext, 1);
+ API_DEF_FUNC(ngettext, 3);
+ API_DEF_FUNC(string_match, 3);
+ API_DEF_FUNC(string_has_highlight, 2);
+ API_DEF_FUNC(string_has_highlight_regex, 2);
+ API_DEF_FUNC(string_mask_to_regex, 1);
+ API_DEF_FUNC(string_remove_color, 2);
+ API_DEF_FUNC(string_is_command_char, 1);
+ API_DEF_FUNC(string_input_for_buffer, 1);
+ API_DEF_FUNC(mkdir_home, 2);
+ API_DEF_FUNC(mkdir, 2);
+ API_DEF_FUNC(mkdir_parents, 2);
+ API_DEF_FUNC(list_new, 0);
+ API_DEF_FUNC(list_add, 4);
+ API_DEF_FUNC(list_search, 2);
+ API_DEF_FUNC(list_search_pos, 2);
+ API_DEF_FUNC(list_casesearch, 2);
+ API_DEF_FUNC(list_casesearch_pos, 2);
+ API_DEF_FUNC(list_get, 2);
+ API_DEF_FUNC(list_set, 2);
+ API_DEF_FUNC(list_next, 1);
+ API_DEF_FUNC(list_prev, 1);
+ API_DEF_FUNC(list_string, 1);
+ API_DEF_FUNC(list_size, 1);
+ API_DEF_FUNC(list_remove, 2);
+ API_DEF_FUNC(list_remove_all, 1);
+ API_DEF_FUNC(list_free, 1);
+ API_DEF_FUNC(config_new, 3);
+ API_DEF_FUNC(config_new_section, 14);
+ API_DEF_FUNC(config_search_section, 2);
+ API_DEF_FUNC(config_new_option, 17);
+ API_DEF_FUNC(config_search_option, 3);
+ API_DEF_FUNC(config_string_to_boolean, 1);
+ API_DEF_FUNC(config_option_reset, 2);
+ API_DEF_FUNC(config_option_set, 3);
+ API_DEF_FUNC(config_option_set_null, 2);
+ API_DEF_FUNC(config_option_unset, 1);
+ API_DEF_FUNC(config_option_rename, 2);
+ API_DEF_FUNC(config_option_is_null, 1);
+ API_DEF_FUNC(config_option_default_is_null, 1);
+ API_DEF_FUNC(config_boolean, 1);
+ API_DEF_FUNC(config_boolean_default, 1);
+ API_DEF_FUNC(config_integer, 1);
+ API_DEF_FUNC(config_integer_default, 1);
+ API_DEF_FUNC(config_string, 1);
+ API_DEF_FUNC(config_string_default, 1);
+ API_DEF_FUNC(config_color, 1);
+ API_DEF_FUNC(config_color_default, 1);
+ API_DEF_FUNC(config_write_option, 2);
+ API_DEF_FUNC(config_write_line, 3);
+ API_DEF_FUNC(config_write, 1);
+ API_DEF_FUNC(config_read, 1);
+ API_DEF_FUNC(config_reload, 1);
+ API_DEF_FUNC(config_option_free, 1);
+ API_DEF_FUNC(config_section_free_options, 1);
+ API_DEF_FUNC(config_section_free, 1);
+ API_DEF_FUNC(config_free, 1);
+ API_DEF_FUNC(config_get, 1);
+ API_DEF_FUNC(config_get_plugin, 1);
+ API_DEF_FUNC(config_is_set_plugin, 1);
+ API_DEF_FUNC(config_set_plugin, 2);
+ API_DEF_FUNC(config_set_desc_plugin, 2);
+ API_DEF_FUNC(config_unset_plugin, 1);
+ API_DEF_FUNC(key_bind, 2);
+ API_DEF_FUNC(key_unbind, 2);
+ API_DEF_FUNC(prefix, 1);
+ API_DEF_FUNC(color, 1);
+ API_DEF_FUNC(print, 2);
+ API_DEF_FUNC(print_date_tags, 4);
+ API_DEF_FUNC(print_y, 3);
+ API_DEF_FUNC(log_print, 1);
+ API_DEF_FUNC(hook_command, 7);
+ API_DEF_FUNC(hook_command_run, 3);
+ API_DEF_FUNC(hook_timer, 5);
+ API_DEF_FUNC(hook_fd, 6);
+ API_DEF_FUNC(hook_process, 4);
+ API_DEF_FUNC(hook_process_hashtable, 5);
+ API_DEF_FUNC(hook_connect, 8);
+ API_DEF_FUNC(hook_print, 6);
+ API_DEF_FUNC(hook_signal, 3);
+ API_DEF_FUNC(hook_signal_send, 3);
+ API_DEF_FUNC(hook_hsignal, 3);
+ API_DEF_FUNC(hook_hsignal_send, 2);
+ API_DEF_FUNC(hook_config, 3);
+ API_DEF_FUNC(hook_completion, 4);
+ API_DEF_FUNC(hook_completion_list_add, 4);
+ API_DEF_FUNC(hook_modifier, 3);
+ API_DEF_FUNC(hook_modifier_exec, 3);
+ API_DEF_FUNC(hook_info, 5);
+ API_DEF_FUNC(hook_info_hashtable, 6);
+ API_DEF_FUNC(hook_infolist, 6);
+ API_DEF_FUNC(hook_focus, 3);
+ API_DEF_FUNC(unhook, 1);
+ API_DEF_FUNC(unhook_all, 0);
+ API_DEF_FUNC(buffer_new, 5);
+ API_DEF_FUNC(buffer_search, 2);
+ API_DEF_FUNC(buffer_search_main, 0);
+ API_DEF_FUNC(current_buffer, 0);
+ API_DEF_FUNC(buffer_clear, 1);
+ API_DEF_FUNC(buffer_close, 1);
+ API_DEF_FUNC(buffer_merge, 2);
+ API_DEF_FUNC(buffer_unmerge, 2);
+ API_DEF_FUNC(buffer_get_integer, 2);
+ API_DEF_FUNC(buffer_get_string, 2);
+ API_DEF_FUNC(buffer_get_pointer, 2);
+ API_DEF_FUNC(buffer_set, 3);
+ API_DEF_FUNC(buffer_string_replace_local_var, 2);
+ API_DEF_FUNC(buffer_match_list, 2);
+ API_DEF_FUNC(current_window, 0);
+ API_DEF_FUNC(window_search_with_buffer, 1);
+ API_DEF_FUNC(window_get_integer, 2);
+ API_DEF_FUNC(window_get_string, 2);
+ API_DEF_FUNC(window_get_pointer, 2);
+ API_DEF_FUNC(window_set_title, 1);
+ API_DEF_FUNC(nicklist_add_group, 5);
+ API_DEF_FUNC(nicklist_search_group, 3);
+ API_DEF_FUNC(nicklist_add_nick, 7);
+ API_DEF_FUNC(nicklist_search_nick, 3);
+ API_DEF_FUNC(nicklist_remove_group, 2);
+ API_DEF_FUNC(nicklist_remove_nick, 2);
+ API_DEF_FUNC(nicklist_remove_all, 1);
+ API_DEF_FUNC(nicklist_group_get_integer, 3);
+ API_DEF_FUNC(nicklist_group_get_string, 3);
+ API_DEF_FUNC(nicklist_group_get_pointer, 3);
+ API_DEF_FUNC(nicklist_group_set, 4);
+ API_DEF_FUNC(nicklist_nick_get_integer, 3);
+ API_DEF_FUNC(nicklist_nick_get_string, 3);
+ API_DEF_FUNC(nicklist_nick_get_pointer, 3);
+ API_DEF_FUNC(nicklist_nick_set, 4);
+ API_DEF_FUNC(bar_item_search, 1);
+ API_DEF_FUNC(bar_item_new, 3);
+ API_DEF_FUNC(bar_item_update, 1);
+ API_DEF_FUNC(bar_item_remove, 1);
+ API_DEF_FUNC(bar_search, 1);
+ API_DEF_FUNC(bar_new, 15);
+ API_DEF_FUNC(bar_set, 3);
+ API_DEF_FUNC(bar_update, 1);
+ API_DEF_FUNC(bar_remove, 1);
+ API_DEF_FUNC(command, 2);
+ API_DEF_FUNC(info_get, 2);
+ API_DEF_FUNC(info_get_hashtable, 2);
+ API_DEF_FUNC(infolist_new, 0);
+ API_DEF_FUNC(infolist_new_item, 1);
+ API_DEF_FUNC(infolist_new_var_integer, 3);
+ API_DEF_FUNC(infolist_new_var_string, 3);
+ API_DEF_FUNC(infolist_new_var_pointer, 3);
+ API_DEF_FUNC(infolist_new_var_time, 3);
+ API_DEF_FUNC(infolist_get, 3);
+ API_DEF_FUNC(infolist_next, 1);
+ API_DEF_FUNC(infolist_prev, 1);
+ API_DEF_FUNC(infolist_reset_item_cursor, 1);
+ API_DEF_FUNC(infolist_fields, 1);
+ API_DEF_FUNC(infolist_integer, 2);
+ API_DEF_FUNC(infolist_string, 2);
+ API_DEF_FUNC(infolist_pointer, 2);
+ API_DEF_FUNC(infolist_time, 2);
+ API_DEF_FUNC(infolist_free, 1);
+ API_DEF_FUNC(hdata_get, 1);
+ API_DEF_FUNC(hdata_get_var_offset, 2);
+ API_DEF_FUNC(hdata_get_var_type_string, 2);
+ API_DEF_FUNC(hdata_get_var_array_size, 3);
+ API_DEF_FUNC(hdata_get_var_array_size_string, 3);
+ API_DEF_FUNC(hdata_get_var_hdata, 2);
+ API_DEF_FUNC(hdata_get_list, 2);
+ API_DEF_FUNC(hdata_check_pointer, 3);
+ API_DEF_FUNC(hdata_move, 3);
+ API_DEF_FUNC(hdata_char, 3);
+ API_DEF_FUNC(hdata_integer, 3);
+ API_DEF_FUNC(hdata_long, 3);
+ API_DEF_FUNC(hdata_string, 3);
+ API_DEF_FUNC(hdata_pointer, 3);
+ API_DEF_FUNC(hdata_time, 3);
+ API_DEF_FUNC(hdata_hashtable, 3);
+ API_DEF_FUNC(hdata_get_string, 2);
+ API_DEF_FUNC(upgrade_new, 2);
+ API_DEF_FUNC(upgrade_write_object, 3);
+ API_DEF_FUNC(upgrade_read, 3);
+ API_DEF_FUNC(upgrade_close, 1);
+}
diff --git a/src/plugins/ruby/weechat-ruby-api.h b/src/plugins/ruby/weechat-ruby-api.h
new file mode 100644
index 000000000..708bf518f
--- /dev/null
+++ b/src/plugins/ruby/weechat-ruby-api.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2003-2012 Sebastien Helleu <flashcode@flashtux.org>
+ * Copyright (C) 2005-2007 Emmanuel Bouthenot <kolter@openics.org>
+ *
+ * This file is part of WeeChat, the extensible chat client.
+ *
+ * WeeChat is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * WeeChat is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with WeeChat. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __WEECHAT_RUBY_API_H
+#define __WEECHAT_RUBY_API_H 1
+
+extern int weechat_ruby_api_buffer_input_data_cb (void *data,
+ struct t_gui_buffer *buffer,
+ const char *input_data);
+extern int weechat_ruby_api_buffer_close_cb (void *data,
+ struct t_gui_buffer *buffer);
+extern void weechat_ruby_api_init (VALUE ruby_mWeechat);
+
+#endif /* __WEECHAT_RUBY_API_H */
diff --git a/src/plugins/ruby/weechat-ruby.c b/src/plugins/ruby/weechat-ruby.c
new file mode 100644
index 000000000..37074646a
--- /dev/null
+++ b/src/plugins/ruby/weechat-ruby.c
@@ -0,0 +1,1112 @@
+/*
+ * Copyright (C) 2003-2012 Sebastien Helleu <flashcode@flashtux.org>
+ * Copyright (C) 2005-2007 Emmanuel Bouthenot <kolter@openics.org>
+ *
+ * This file is part of WeeChat, the extensible chat client.
+ *
+ * WeeChat is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * WeeChat is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with WeeChat. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * weechat-ruby.c: ruby plugin for WeeChat
+ */
+
+#undef _
+
+#include <ruby.h>
+#if defined(RUBY_VERSION) && RUBY_VERSION >=19
+#include <ruby/encoding.h>
+#endif
+
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include "../weechat-plugin.h"
+#include "../plugin-script.h"
+#include "weechat-ruby.h"
+#include "weechat-ruby-api.h"
+
+#ifndef StringValuePtr
+#define StringValuePtr(s) STR2CSTR(s)
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(s) RARRAY(s)->len
+#endif
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(s) RARRAY(s)->ptr
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) RSTRING(s)->len
+#endif
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) RSTRING(s)->ptr
+#endif
+
+
+WEECHAT_PLUGIN_NAME(RUBY_PLUGIN_NAME);
+WEECHAT_PLUGIN_DESCRIPTION(N_("Support of ruby scripts"));
+WEECHAT_PLUGIN_AUTHOR("Sebastien Helleu <flashcode@flashtux.org>");
+WEECHAT_PLUGIN_VERSION(WEECHAT_VERSION);
+WEECHAT_PLUGIN_LICENSE(WEECHAT_LICENSE);
+
+struct t_weechat_plugin *weechat_ruby_plugin = NULL;
+
+int ruby_quiet = 0;
+int ruby_hide_errors = 0;
+struct t_plugin_script *ruby_scripts = NULL;
+struct t_plugin_script *last_ruby_script = NULL;
+struct t_plugin_script *ruby_current_script = NULL;
+struct t_plugin_script *ruby_registered_script = NULL;
+const char *ruby_current_script_filename = NULL;
+
+/*
+ * string used to execute action "install":
+ * when signal "ruby_install_script" is received, name of string
+ * is added to this string, to be installed later by a timer (when nothing is
+ * running in script)
+ */
+char *ruby_action_install_list = NULL;
+
+/*
+ * string used to execute action "remove":
+ * when signal "ruby_remove_script" is received, name of string
+ * is added to this string, to be removed later by a timer (when nothing is
+ * running in script)
+ */
+char *ruby_action_remove_list = NULL;
+
+VALUE ruby_mWeechat, ruby_mWeechatOutputs;
+
+#define MOD_NAME_PREFIX "WeechatRubyModule"
+int ruby_num = 0;
+
+char ruby_buffer_output[128];
+
+typedef struct protect_call_arg {
+ VALUE recv;
+ ID mid;
+ int argc;
+ VALUE *argv;
+} protect_call_arg_t;
+
+
+/*
+ * weechat_ruby_hashtable_map_cb: callback called for each key/value in a
+ * hashtable
+ */
+
+void
+weechat_ruby_hashtable_map_cb (void *data,
+ struct t_hashtable *hashtable,
+ const char *key,
+ const char *value)
+{
+ VALUE *hash;
+
+ /* make C compiler happy */
+ (void) hashtable;
+
+ hash = (VALUE *)data;
+
+ rb_hash_aset (hash[0], rb_str_new2 (key), rb_str_new2 (value));
+}
+
+/*
+ * weechat_ruby_hashtable_to_hash: get ruby hash with a WeeChat hashtable
+ */
+
+VALUE
+weechat_ruby_hashtable_to_hash (struct t_hashtable *hashtable)
+{
+ VALUE hash;
+
+ hash = rb_hash_new ();
+ if (NIL_P (hash))
+ return Qnil;
+
+ weechat_hashtable_map_string (hashtable,
+ &weechat_ruby_hashtable_map_cb,
+ &hash);
+
+ return hash;
+}
+
+int
+weechat_ruby_hash_foreach_cb (VALUE key, VALUE value, void *arg)
+{
+ struct t_hashtable *hashtable;
+
+ hashtable = (struct t_hashtable *)arg;
+ if ((TYPE(key) == T_STRING) && (TYPE(value) == T_STRING))
+ {
+ weechat_hashtable_set (hashtable, StringValuePtr(key),
+ StringValuePtr(value));
+ }
+ return 0;
+}
+
+/*
+ * weechat_ruby_hash_to_hashtable: get WeeChat hashtable with ruby hashtable
+ * Hashtable returned has type string for
+ * both keys and values
+ * Note: hashtable has to be released after use
+ * with call to weechat_hashtable_free()
+ */
+
+struct t_hashtable *
+weechat_ruby_hash_to_hashtable (VALUE hash, int hashtable_size)
+{
+ struct t_hashtable *hashtable;
+
+ hashtable = weechat_hashtable_new (hashtable_size,
+ WEECHAT_HASHTABLE_STRING,
+ WEECHAT_HASHTABLE_STRING,
+ NULL,
+ NULL);
+ if (!hashtable)
+ return NULL;
+
+ rb_hash_foreach (hash, &weechat_ruby_hash_foreach_cb,
+ (unsigned long)hashtable);
+
+ return hashtable;
+}
+
+/*
+ * protect_funcall0 : used to protect a function call
+ */
+
+static VALUE
+protect_funcall0 (VALUE arg)
+{
+ return rb_funcall2 (((protect_call_arg_t *)arg)->recv,
+ ((protect_call_arg_t *)arg)->mid,
+ ((protect_call_arg_t *)arg)->argc,
+ ((protect_call_arg_t *)arg)->argv);
+}
+
+/*
+ * rb_protect_funcall: function call in protect mode
+ */
+
+VALUE
+rb_protect_funcall (VALUE recv, ID mid, int *state, int argc, VALUE *argv)
+{
+ struct protect_call_arg arg;
+
+ arg.recv = recv;
+ arg.mid = mid;
+ arg.argc = argc;
+ arg.argv = argv;
+ return rb_protect (protect_funcall0, (VALUE) &arg, state);
+}
+
+/*
+ * weechat_ruby_print_exception: display ruby exception
+ */
+
+int
+weechat_ruby_print_exception (VALUE err)
+{
+ VALUE backtrace, tmp1, tmp2, tmp3;
+ int i;
+ int ruby_error;
+ char* line;
+ char* cline;
+ char* err_msg;
+ char* err_class;
+
+ backtrace = rb_protect_funcall (err, rb_intern("backtrace"),
+ &ruby_error, 0, NULL);
+
+ tmp1 = rb_protect_funcall(err, rb_intern("message"), &ruby_error, 0, NULL);
+ err_msg = StringValueCStr(tmp1);
+
+ tmp2 = rb_protect_funcall(rb_protect_funcall(err, rb_intern("class"),
+ &ruby_error, 0, NULL),
+ rb_intern("name"), &ruby_error, 0, NULL);
+ err_class = StringValuePtr(tmp2);
+
+ if (strcmp (err_class, "SyntaxError") == 0)
+ {
+ tmp3 = rb_inspect(err);
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: error: %s"),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME,
+ StringValuePtr(tmp3));
+ }
+ else
+ {
+ for (i = 0; i < RARRAY_LEN(backtrace); i++)
+ {
+ line = StringValuePtr(RARRAY_PTR(backtrace)[i]);
+ cline = NULL;
+ if (i == 0)
+ {
+ cline = (char *)calloc (strlen (line) + 2 + strlen (err_msg) +
+ 3 + strlen (err_class) + 1,
+ sizeof (char));
+ if (cline)
+ {
+ strcat (cline, line);
+ strcat (cline, ": ");
+ strcat (cline, err_msg);
+ strcat (cline, " (");
+ strcat (cline, err_class);
+ strcat (cline, ")");
+ }
+ }
+ else
+ {
+ cline = (char *)calloc(strlen (line) + strlen (" from ") + 1,
+ sizeof (char));
+ if (cline)
+ {
+ strcat (cline, " from ");
+ strcat (cline, line);
+ }
+ }
+ if (cline)
+ {
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: error: %s"),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME,
+ cline);
+ }
+
+ if (cline)
+ free (cline);
+ }
+ }
+
+ return 0;
+}
+
+/*
+ * weechat_ruby_exec: execute a ruby function
+ */
+
+void *
+weechat_ruby_exec (struct t_plugin_script *script,
+ int ret_type, const char *function,
+ const char *format, void **argv)
+{
+ VALUE rc, err;
+ int ruby_error, i, argc, *ret_i;
+ VALUE argv2[16];
+ void *ret_value;
+ struct t_plugin_script *old_ruby_current_script;
+
+ old_ruby_current_script = ruby_current_script;
+ ruby_current_script = script;
+
+ argc = 0;
+ if (format && format[0])
+ {
+ argc = strlen (format);
+ for (i = 0; i < argc; i++)
+ {
+ switch (format[i])
+ {
+ case 's': /* string */
+ argv2[i] = rb_str_new2 ((char *)argv[i]);
+ break;
+ case 'i': /* integer */
+ argv2[i] = INT2FIX (*((int *)argv[i]));
+ break;
+ case 'h': /* hash */
+ argv2[i] = weechat_ruby_hashtable_to_hash (argv[i]);
+ break;
+ }
+ }
+ }
+
+ if (argc > 0)
+ {
+ rc = rb_protect_funcall ((VALUE) script->interpreter,
+ rb_intern(function),
+ &ruby_error, argc, argv2);
+ }
+ else
+ {
+ rc = rb_protect_funcall ((VALUE) script->interpreter,
+ rb_intern(function),
+ &ruby_error, 0, NULL);
+ }
+
+ if (ruby_error)
+ {
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: unable to run function \"%s\""),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME, function);
+
+ err = rb_gv_get("$!");
+ weechat_ruby_print_exception(err);
+
+ return NULL;
+ }
+
+ if ((TYPE(rc) == T_STRING) && (ret_type == WEECHAT_SCRIPT_EXEC_STRING))
+ {
+ if (StringValuePtr (rc))
+ ret_value = strdup (StringValuePtr (rc));
+ else
+ ret_value = NULL;
+ }
+ else if ((TYPE(rc) == T_FIXNUM) && (ret_type == WEECHAT_SCRIPT_EXEC_INT))
+ {
+ ret_i = malloc (sizeof (*ret_i));
+ if (ret_i)
+ *ret_i = NUM2INT(rc);
+ ret_value = ret_i;
+ }
+ else if (ret_type == WEECHAT_SCRIPT_EXEC_HASHTABLE)
+ {
+ ret_value = weechat_ruby_hash_to_hashtable (rc,
+ WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE);
+ }
+ else
+ {
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: function \"%s\" must return a "
+ "valid value"),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME, function);
+ ruby_current_script = old_ruby_current_script;
+ return WEECHAT_RC_OK;
+ }
+
+ if (ret_value == NULL)
+ {
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: not enough memory in function "
+ "\"%s\""),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME, function);
+ ruby_current_script = old_ruby_current_script;
+ return NULL;
+ }
+
+ ruby_current_script = old_ruby_current_script;
+
+ return ret_value;
+}
+
+/*
+ * weechat_ruby_output: redirection for stdout and stderr
+ */
+
+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;
+}
+
+/*
+ * weechat_ruby_output_flush: just for compatibility
+ */
+
+static VALUE
+weechat_ruby_output_flush (VALUE self)
+{
+ /* make C compiler happy */
+ (void) self;
+
+ return Qnil;
+}
+
+/*
+ * weechat_ruby_load: load a Ruby script
+ */
+
+int
+weechat_ruby_load (const char *filename)
+{
+ char modname[64];
+ VALUE curModule, ruby_retcode, err, argv[1];
+ int ruby_error;
+ struct stat buf;
+
+ if (stat (filename, &buf) != 0)
+ {
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: script \"%s\" not found"),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename);
+ return 0;
+ }
+
+ if ((weechat_ruby_plugin->debug >= 2) || !ruby_quiet)
+ {
+ weechat_printf (NULL,
+ weechat_gettext ("%s: loading script \"%s\""),
+ RUBY_PLUGIN_NAME, filename);
+ }
+
+ ruby_current_script = NULL;
+ ruby_registered_script = NULL;
+
+ snprintf (modname, sizeof(modname), "%s%d", MOD_NAME_PREFIX, ruby_num);
+ ruby_num++;
+
+ curModule = rb_define_module(modname);
+
+ ruby_current_script_filename = filename;
+
+ argv[0] = rb_str_new2 (filename);
+ ruby_retcode = rb_protect_funcall (curModule, rb_intern("load_eval_file"),
+ &ruby_error, 1, argv);
+
+ if (ruby_retcode == Qnil)
+ {
+ err = rb_gv_get("$!");
+ weechat_ruby_print_exception(err);
+ return 0;
+ }
+
+ if (NUM2INT(ruby_retcode) != 0)
+ {
+ switch (NUM2INT(ruby_retcode))
+ {
+ case 1:
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: unable to read file "
+ "\"%s\""),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME,
+ filename);
+ break;
+ case 2:
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: error while loading "
+ "file \"%s\""),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME,
+ filename);
+ break;
+ case 3:
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: function "
+ "\"weechat_init\" is missing "
+ "in file \"%s\""),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME,
+ filename);
+ break;
+ }
+
+ if (NUM2INT(ruby_retcode) == 1 || NUM2INT(ruby_retcode) == 2)
+ {
+ weechat_ruby_print_exception(rb_iv_get(curModule, "@load_eval_file_error"));
+ }
+
+ return 0;
+ }
+
+ (void) rb_protect_funcall (curModule, rb_intern("weechat_init"),
+ &ruby_error, 0, NULL);
+
+ if (ruby_error)
+ {
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: unable to eval function "
+ "\"weechat_init\" in file \"%s\""),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename);
+
+ err = rb_gv_get("$!");
+ weechat_ruby_print_exception(err);
+
+ if (ruby_current_script != NULL)
+ {
+ plugin_script_remove (weechat_ruby_plugin,
+ &ruby_scripts, &last_ruby_script,
+ ruby_current_script);
+ }
+
+ return 0;
+ }
+
+ if (!ruby_registered_script)
+ {
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: function \"register\" not "
+ "found (or failed) in file \"%s\""),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME, filename);
+ return 0;
+ }
+ ruby_current_script = ruby_registered_script;
+
+ ruby_current_script->interpreter = (VALUE *) curModule;
+ rb_gc_register_address (ruby_current_script->interpreter);
+
+ /*
+ * set input/close callbacks for buffers created by this script
+ * (to restore callbacks after upgrade)
+ */
+ plugin_script_set_buffer_callbacks (weechat_ruby_plugin,
+ ruby_scripts,
+ ruby_current_script,
+ &weechat_ruby_api_buffer_input_data_cb,
+ &weechat_ruby_api_buffer_close_cb);
+
+ return 1;
+}
+
+/*
+ * weechat_ruby_load_cb: callback for weechat_script_auto_load() function
+ */
+
+void
+weechat_ruby_load_cb (void *data, const char *filename)
+{
+ /* make C compiler happy */
+ (void) data;
+
+ weechat_ruby_load (filename);
+}
+
+/*
+ * weechat_ruby_unload: unload a Ruby script
+ */
+
+void
+weechat_ruby_unload (struct t_plugin_script *script)
+{
+ int *rc;
+ void *interpreter;
+
+ 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);
+ }
+
+ 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);
+}
+
+/*
+ * weechat_ruby_unload_name: unload a Ruby script by name
+ */
+
+void
+weechat_ruby_unload_name (const char *name)
+{
+ struct t_plugin_script *ptr_script;
+
+ ptr_script = plugin_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);
+ }
+}
+
+/*
+ * weechat_ruby_reload_name: reload a Ruby script by name
+ */
+
+void
+weechat_ruby_reload_name (const char *name)
+{
+ struct t_plugin_script *ptr_script;
+ char *filename;
+
+ ptr_script = plugin_script_search (weechat_ruby_plugin, ruby_scripts, name);
+ if (ptr_script)
+ {
+ filename = strdup (ptr_script->filename);
+ if (filename)
+ {
+ weechat_ruby_unload (ptr_script);
+ weechat_printf (NULL,
+ weechat_gettext ("%s: script \"%s\" unloaded"),
+ RUBY_PLUGIN_NAME, name);
+ weechat_ruby_load (filename);
+ free (filename);
+ }
+ }
+ else
+ {
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: script \"%s\" not loaded"),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME, name);
+ }
+}
+
+/*
+ * weechat_ruby_unload_all: unload all Ruby scripts
+ */
+
+void
+weechat_ruby_unload_all ()
+{
+ while (ruby_scripts)
+ {
+ weechat_ruby_unload (ruby_scripts);
+ }
+}
+
+/*
+ * weechat_ruby_command_cb: callback for "/ruby" command
+ */
+
+int
+weechat_ruby_command_cb (void *data, struct t_gui_buffer *buffer,
+ int argc, char **argv, char **argv_eol)
+{
+ char *path_script;
+
+ /* make C compiler happy */
+ (void) data;
+ (void) buffer;
+
+ if (argc == 1)
+ {
+ plugin_script_display_list (weechat_ruby_plugin, ruby_scripts,
+ NULL, 0);
+ }
+ else if (argc == 2)
+ {
+ if (weechat_strcasecmp (argv[1], "list") == 0)
+ {
+ plugin_script_display_list (weechat_ruby_plugin, ruby_scripts,
+ NULL, 0);
+ }
+ else if (weechat_strcasecmp (argv[1], "listfull") == 0)
+ {
+ plugin_script_display_list (weechat_ruby_plugin, ruby_scripts,
+ NULL, 1);
+ }
+ else if (weechat_strcasecmp (argv[1], "autoload") == 0)
+ {
+ plugin_script_auto_load (weechat_ruby_plugin, &weechat_ruby_load_cb);
+ }
+ else if (weechat_strcasecmp (argv[1], "reload") == 0)
+ {
+ weechat_ruby_unload_all ();
+ plugin_script_auto_load (weechat_ruby_plugin, &weechat_ruby_load_cb);
+ }
+ else if (weechat_strcasecmp (argv[1], "unload") == 0)
+ {
+ weechat_ruby_unload_all ();
+ }
+ }
+ else
+ {
+ if (weechat_strcasecmp (argv[1], "list") == 0)
+ {
+ plugin_script_display_list (weechat_ruby_plugin, ruby_scripts,
+ argv_eol[2], 0);
+ }
+ else if (weechat_strcasecmp (argv[1], "listfull") == 0)
+ {
+ plugin_script_display_list (weechat_ruby_plugin, ruby_scripts,
+ argv_eol[2], 1);
+ }
+ else if (weechat_strcasecmp (argv[1], "load") == 0)
+ {
+ /* load Ruby script */
+ path_script = plugin_script_search_path (weechat_ruby_plugin,
+ argv_eol[2]);
+ weechat_ruby_load ((path_script) ? path_script : argv_eol[2]);
+ if (path_script)
+ free (path_script);
+ }
+ else if (weechat_strcasecmp (argv[1], "reload") == 0)
+ {
+ /* reload one Ruby script */
+ weechat_ruby_reload_name (argv_eol[2]);
+ }
+ else if (weechat_strcasecmp (argv[1], "unload") == 0)
+ {
+ /* unload Ruby script */
+ weechat_ruby_unload_name (argv_eol[2]);
+ }
+ else
+ {
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: unknown option for "
+ "command \"%s\""),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME, "ruby");
+ }
+ }
+
+ return WEECHAT_RC_OK;
+}
+
+/*
+ * weechat_ruby_completion_cb: callback for script completion
+ */
+
+int
+weechat_ruby_completion_cb (void *data, const char *completion_item,
+ struct t_gui_buffer *buffer,
+ struct t_gui_completion *completion)
+{
+ /* make C compiler happy */
+ (void) data;
+ (void) completion_item;
+ (void) buffer;
+
+ plugin_script_completion (weechat_ruby_plugin, completion, ruby_scripts);
+
+ return WEECHAT_RC_OK;
+}
+
+/*
+ * weechat_ruby_infolist_cb: callback for infolist
+ */
+
+struct t_infolist *
+weechat_ruby_infolist_cb (void *data, const char *infolist_name,
+ void *pointer, const char *arguments)
+{
+ /* make C compiler happy */
+ (void) data;
+
+ if (!infolist_name || !infolist_name[0])
+ return NULL;
+
+ if (weechat_strcasecmp (infolist_name, "ruby_script") == 0)
+ {
+ return plugin_script_infolist_list_scripts (weechat_ruby_plugin,
+ ruby_scripts, pointer,
+ arguments);
+ }
+
+ return NULL;
+}
+
+/*
+ * weechat_ruby_signal_debug_dump_cb: dump Ruby plugin data in WeeChat log file
+ */
+
+int
+weechat_ruby_signal_debug_dump_cb (void *data, const char *signal,
+ const char *type_data, void *signal_data)
+{
+ /* make C compiler happy */
+ (void) data;
+ (void) signal;
+ (void) type_data;
+
+ if (!signal_data
+ || (weechat_strcasecmp ((char *)signal_data, RUBY_PLUGIN_NAME) == 0))
+ {
+ plugin_script_print_log (weechat_ruby_plugin, ruby_scripts);
+ }
+
+ return WEECHAT_RC_OK;
+}
+
+/*
+ * weechat_ruby_signal_buffer_closed_cb: callback called when a buffer is closed
+ */
+
+int
+weechat_ruby_signal_buffer_closed_cb (void *data, const char *signal,
+ const char *type_data, void *signal_data)
+{
+ /* make C compiler happy */
+ (void) data;
+ (void) signal;
+ (void) type_data;
+
+ if (signal_data)
+ plugin_script_remove_buffer_callbacks (ruby_scripts, signal_data);
+
+ return WEECHAT_RC_OK;
+}
+
+/*
+ * weechat_ruby_timer_action_cb: timer for executing actions
+ */
+
+int
+weechat_ruby_timer_action_cb (void *data, int remaining_calls)
+{
+ /* make C compiler happy */
+ (void) remaining_calls;
+
+ if (data)
+ {
+ if (data == &ruby_action_install_list)
+ {
+ plugin_script_action_install (weechat_ruby_plugin,
+ ruby_scripts,
+ &weechat_ruby_unload,
+ &weechat_ruby_load,
+ &ruby_action_install_list);
+ }
+ else if (data == &ruby_action_remove_list)
+ {
+ plugin_script_action_remove (weechat_ruby_plugin,
+ ruby_scripts,
+ &weechat_ruby_unload,
+ &ruby_action_remove_list);
+ }
+ }
+
+ return WEECHAT_RC_OK;
+}
+
+/*
+ * weechat_ruby_signal_script_action_cb: callback called when a script action
+ * is asked (install/remove a script)
+ */
+
+int
+weechat_ruby_signal_script_action_cb (void *data, const char *signal,
+ const char *type_data,
+ void *signal_data)
+{
+ /* make C compiler happy */
+ (void) data;
+
+ if (strcmp (type_data, WEECHAT_HOOK_SIGNAL_STRING) == 0)
+ {
+ if (strcmp (signal, "ruby_script_install") == 0)
+ {
+ plugin_script_action_add (&ruby_action_install_list,
+ (const char *)signal_data);
+ weechat_hook_timer (1, 0, 1,
+ &weechat_ruby_timer_action_cb,
+ &ruby_action_install_list);
+ }
+ else if (strcmp (signal, "ruby_script_remove") == 0)
+ {
+ plugin_script_action_add (&ruby_action_remove_list,
+ (const char *)signal_data);
+ weechat_hook_timer (1, 0, 1,
+ &weechat_ruby_timer_action_cb,
+ &ruby_action_remove_list);
+ }
+ }
+
+ return WEECHAT_RC_OK;
+}
+
+/*
+ * weechat_plugin_init: initialize Ruby plugin
+ */
+
+int
+weechat_plugin_init (struct t_weechat_plugin *plugin, int argc, char *argv[])
+{
+ struct t_plugin_script_init init;
+ int ruby_error;
+ char *weechat_ruby_code =
+ {
+ "$stdout = WeechatOutputs\n"
+ "$stderr = WeechatOutputs\n"
+ "begin"
+ " if RUBY_VERSION.split('.')[1] == '9'\n"
+ " require 'enc/encdb.so'\n"
+ " require 'enc/trans/transdb.so'\n"
+ "\n"
+ " require 'thread'\n"
+ " class ::Mutex\n"
+ " def synchronize(*args)\n"
+ " yield\n"
+ " end\n"
+ " end\n"
+ " require 'rubygems'\n"
+ " else\n"
+ " require 'rubygems'\n"
+ " end\n"
+ "rescue LoadError\n"
+ "end\n"
+ "\n"
+ "class Module\n"
+ "\n"
+ " def load_eval_file (file)\n"
+ " lines = ''\n"
+ " begin\n"
+ " lines = File.read(file)\n"
+ " rescue => e\n"
+ " return 1\n"
+ " end\n"
+ "\n"
+ " begin\n"
+ " module_eval(lines)\n"
+ " rescue Exception => e\n"
+ " @load_eval_file_error = e\n"
+ " return 2\n"
+ " end\n"
+ "\n"
+ " has_init = false\n"
+ "\n"
+ " instance_methods.each do |meth|\n"
+ " if meth.to_s == 'weechat_init'\n"
+ " has_init = true\n"
+ " end\n"
+ " module_eval('module_function :' + meth.to_s)\n"
+ " end\n"
+ "\n"
+ " unless has_init\n"
+ " return 3\n"
+ " end\n"
+ "\n"
+ " return 0\n"
+ " end\n"
+ "end\n"
+ };
+
+ weechat_ruby_plugin = plugin;
+
+ ruby_error = 0;
+
+ /* init stdout/stderr buffer */
+ ruby_buffer_output[0] = '\0';
+
+#if defined(RUBY_VERSION) && RUBY_VERSION >= 19
+ RUBY_INIT_STACK;
+#endif
+
+ ruby_hide_errors = 1;
+ ruby_init ();
+ ruby_init_loadpath ();
+ ruby_script ("__weechat_plugin__");
+
+ ruby_mWeechat = rb_define_module("Weechat");
+ weechat_ruby_api_init (ruby_mWeechat);
+
+ /* redirect stdin and stdout */
+ ruby_mWeechatOutputs = rb_define_module("WeechatOutputs");
+ rb_define_singleton_method(ruby_mWeechatOutputs, "write",
+ weechat_ruby_output, 1);
+ rb_define_singleton_method(ruby_mWeechatOutputs, "puts",
+ weechat_ruby_output, 1);
+ rb_define_singleton_method(ruby_mWeechatOutputs, "p",
+ weechat_ruby_output, 1);
+ rb_define_singleton_method(ruby_mWeechatOutputs, "flush",
+ weechat_ruby_output_flush, 0);
+ ruby_hide_errors = 0;
+
+ rb_eval_string_protect(weechat_ruby_code, &ruby_error);
+ if (ruby_error)
+ {
+ weechat_printf (NULL,
+ weechat_gettext ("%s%s: unable to eval WeeChat ruby "
+ "internal code"),
+ weechat_prefix ("error"), RUBY_PLUGIN_NAME);
+ VALUE err = rb_gv_get("$!");
+ weechat_ruby_print_exception(err);
+ return WEECHAT_RC_ERROR;
+ }
+
+ init.callback_command = &weechat_ruby_command_cb;
+ init.callback_completion = &weechat_ruby_completion_cb;
+ init.callback_infolist = &weechat_ruby_infolist_cb;
+ init.callback_signal_debug_dump = &weechat_ruby_signal_debug_dump_cb;
+ init.callback_signal_buffer_closed = &weechat_ruby_signal_buffer_closed_cb;
+ init.callback_signal_script_action = &weechat_ruby_signal_script_action_cb;
+ init.callback_load_file = &weechat_ruby_load_cb;
+
+ ruby_quiet = 1;
+ plugin_script_init (weechat_ruby_plugin, argc, argv, &init);
+ ruby_quiet = 0;
+
+ plugin_script_display_short_list (weechat_ruby_plugin,
+ ruby_scripts);
+
+ /* init ok */
+ return WEECHAT_RC_OK;
+}
+
+/*
+ * weechat_plugin_end: shutdown Ruby interface
+ */
+
+int
+weechat_plugin_end (struct t_weechat_plugin *plugin)
+{
+ /* unload all scripts */
+ ruby_quiet = 1;
+ plugin_script_end (plugin, &ruby_scripts, &weechat_ruby_unload_all);
+ ruby_quiet = 0;
+
+ /*
+ * Do not cleanup Ruby because this causes a crash when plugin is reloaded
+ * again. This causes a memory leak, but I don't know better solution to
+ * this problem :(
+ */
+ /*ruby_cleanup (0);*/
+
+ return WEECHAT_RC_OK;
+}
diff --git a/src/plugins/ruby/weechat-ruby.h b/src/plugins/ruby/weechat-ruby.h
new file mode 100644
index 000000000..cf3e7a1b2
--- /dev/null
+++ b/src/plugins/ruby/weechat-ruby.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2003-2012 Sebastien Helleu <flashcode@flashtux.org>
+ * Copyright (C) 2005-2007 Emmanuel Bouthenot <kolter@openics.org>
+ *
+ * This file is part of WeeChat, the extensible chat client.
+ *
+ * WeeChat is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * WeeChat is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with WeeChat. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __WEECHAT_RUBY_H
+#define __WEECHAT_RUBY_H 1
+
+#define weechat_plugin weechat_ruby_plugin
+#define RUBY_PLUGIN_NAME "ruby"
+
+#define RUBY_CURRENT_SCRIPT_NAME ((ruby_current_script) ? ruby_current_script->name : "-")
+
+extern struct t_weechat_plugin *weechat_ruby_plugin;
+
+extern int ruby_quiet;
+extern struct t_plugin_script *ruby_scripts;
+extern struct t_plugin_script *last_ruby_script;
+extern struct t_plugin_script *ruby_current_script;
+extern struct t_plugin_script *ruby_registered_script;
+extern const char *ruby_current_script_filename;
+
+extern VALUE weechat_ruby_hashtable_to_hash (struct t_hashtable *hashtable);
+extern struct t_hashtable *weechat_ruby_hash_to_hashtable (VALUE dict,
+ int hashtable_size);
+void *weechat_ruby_exec (struct t_plugin_script *script,
+ int ret_type, const char *function,
+ const char *format, void **argv);
+
+#endif /* __WEECHAT_RUBY_H */