diff options
author | Adam Saponara <as@php.net> | 2017-09-03 12:17:26 +0200 |
---|---|---|
committer | Sébastien Helleu <flashcode@flashtux.org> | 2017-09-03 15:33:16 +0200 |
commit | d032ee2159cdc9909af566602a174de6766cf002 (patch) | |
tree | 1844fecd355f29c1d042a0e921ba88fe5dac5fa8 /src/plugins/php/weechat-php-api.c | |
parent | 8c046d9be913a3ee1b990d0f45d2c44338086e3a (diff) | |
download | weechat-d032ee2159cdc9909af566602a174de6766cf002.zip |
php: new php plugin
This plugin requires PHP >= 7.0.
Diffstat (limited to 'src/plugins/php/weechat-php-api.c')
-rw-r--r-- | src/plugins/php/weechat-php-api.c | 4287 |
1 files changed, 4287 insertions, 0 deletions
diff --git a/src/plugins/php/weechat-php-api.c b/src/plugins/php/weechat-php-api.c new file mode 100644 index 000000000..d7caf14f2 --- /dev/null +++ b/src/plugins/php/weechat-php-api.c @@ -0,0 +1,4287 @@ +/* + * weechat-php-api.c - PHP API functions + * + * Copyright (C) 2006-2017 Adam Saponara <as@php.net> + * + * 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/>. + */ + +#include <sapi/embed/php_embed.h> +#include <php.h> +#include <php_ini.h> +#include <ext/standard/info.h> + +#include "../weechat-plugin.h" +#include "../plugin-script.h" +#include "../plugin-script-api.h" +#include "weechat-php.h" + + +#define API_FUNC_INIT(__name) \ + char *php_function_name = #__name; \ + (void)php_function_name + +#define API_PTR2STR(__pointer) \ + plugin_script_ptr2str (__pointer) + +#define API_STR2PTR(__string) \ + plugin_script_str2ptr (weechat_php_plugin, \ + PHP_CURRENT_SCRIPT_NAME, \ + php_function_name, __string) + +#define SAFE_RETURN_STRING(__c) \ + RETURN_STRING((__c) ? (__c) : "") + +#define weechat_php_get_function_name(__zfunc, __str) \ + char *(__str); \ + do { \ + if (!zend_is_callable (__zfunc, 0, NULL)) \ + { \ + php_error_docref (NULL, E_WARNING, "Expected callable"); \ + RETURN_FALSE; \ + } \ + (__str) = weechat_php_func_map_add (__zfunc); \ + } while (0) + +static char weechat_php_empty_arg[1] = { '\0' }; + +PHP_FUNCTION(weechat_register) +{ + API_FUNC_INIT(weechat_register); + zend_string *name; + zend_string *author; + zend_string *version; + zend_string *license; + zend_string *description; + zval *shutdown_func; + char *shutdown_func_name; + zend_string *charset; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SSSSSzS", + &name, &author, &version, &license, &description, + &shutdown_func, &charset) == FAILURE) + { + return; + } + + if (php_registered_script) + { + /* script already registered */ + weechat_printf (NULL, + weechat_gettext ("%s%s: script \"%s\" already " + "registered (register ignored)"), + weechat_prefix ("error"), PHP_PLUGIN_NAME, + php_registered_script->name); + RETURN_FALSE; + } + + php_current_script = NULL; + php_registered_script = NULL; + + if (plugin_script_search (weechat_php_plugin, php_scripts, ZSTR_VAL(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"), PHP_PLUGIN_NAME, + ZSTR_VAL(name)); + RETURN_FALSE; + } + + /* resolve shutdown func */ + shutdown_func_name = NULL; + if (zend_is_callable (shutdown_func, 0, NULL)) + { + weechat_php_get_function_name(shutdown_func, shutdown_func_name_tmp); + shutdown_func_name = shutdown_func_name_tmp; + } + + /* register script */ + php_current_script = plugin_script_add (weechat_php_plugin, + &php_scripts, &last_php_script, + (php_current_script_filename) ? + php_current_script_filename : "", + ZSTR_VAL(name), + ZSTR_VAL(author), + ZSTR_VAL(version), + ZSTR_VAL(license), + ZSTR_VAL(description), + shutdown_func_name, + ZSTR_VAL(charset)); + if (php_current_script) + { + php_registered_script = php_current_script; + if ((weechat_php_plugin->debug >= 2) || !php_quiet) + { + weechat_printf (NULL, + weechat_gettext ("%s: registered script \"%s\", " + "version %s (%s)"), + PHP_PLUGIN_NAME, ZSTR_VAL(name), ZSTR_VAL(version), + ZSTR_VAL(description)); + } + } + else + { + RETURN_FALSE; + } + + RETURN_TRUE; +} + +static void weechat_php_cb(const void *pointer, void *data, void **func_argv, const char *func_types, int func_type, void *rc) +{ + struct t_plugin_script *script; + const char *ptr_function, *ptr_data; + void *ret; + + script = (struct t_plugin_script *)pointer; + plugin_script_get_function_and_data (data, &ptr_function, &ptr_data); + + func_argv[0] = ptr_data ? (char *)ptr_data : weechat_php_empty_arg; + + if (!ptr_function || !ptr_function[0]) + { + goto weechat_php_cb_err; + } + + ret = weechat_php_exec (script, func_type, ptr_function, + func_types, func_argv); + + if (!ret) + { + goto weechat_php_cb_err; + } + + if (func_type == WEECHAT_SCRIPT_EXEC_INT) + { + *((int *)rc) = *((int *)ret); + free(ret); + } + else if (func_type == WEECHAT_SCRIPT_EXEC_HASHTABLE) + { + *((struct t_hashtable **)rc) = (struct t_hashtable *)ret; + } + else + { + *((char **)rc) = (char *)ret; + } + return; + +weechat_php_cb_err: + if (func_type == WEECHAT_SCRIPT_EXEC_INT) + { + *((int *)rc) = WEECHAT_RC_ERROR; + } + else if (func_type == WEECHAT_SCRIPT_EXEC_HASHTABLE) + { + *((struct t_hashtable **)rc) = NULL; + } + else + { + *((char **)rc) = NULL; + } +} + +static char *weechat_php_bar_item_new_build_callback(const void *pointer, void *data, struct t_gui_bar_item *item, struct t_gui_window *window, struct t_gui_buffer *buffer, struct t_hashtable *extra_info) +{ + char *rc; + void *func_argv[5]; + func_argv[1] = API_PTR2STR(item); + func_argv[2] = API_PTR2STR(window); + func_argv[3] = API_PTR2STR(buffer); + func_argv[4] = extra_info; + weechat_php_cb(pointer, data, func_argv, "ssssh", WEECHAT_SCRIPT_EXEC_STRING, &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 rc; +} + +int weechat_php_buffer_new_input_callback(const void *pointer, void *data, struct t_gui_buffer *buffer, const char *input_data) +{ + int rc; + void *func_argv[3]; + func_argv[1] = API_PTR2STR(buffer); + func_argv[2] = input_data ? (char *)input_data : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "sss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); + return rc; +} + +int weechat_php_buffer_new_close_callback(const void *pointer, void *data, struct t_gui_buffer *buffer) +{ + int rc; + void *func_argv[2]; + func_argv[1] = API_PTR2STR(buffer); + weechat_php_cb(pointer, data, func_argv, "ss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); + return rc; +} + +static int weechat_php_config_new_callback_reload(const void *pointer, void *data, struct t_config_file *config_file) +{ + int rc; + void *func_argv[2]; + func_argv[1] = API_PTR2STR(config_file); + weechat_php_cb(pointer, data, func_argv, "ss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); + return rc; +} + +static int weechat_php_config_new_option_callback_check_value(const void *pointer, void *data, struct t_config_option *option, const char *value) +{ + int rc; + void *func_argv[3]; + func_argv[1] = API_PTR2STR(option); + func_argv[2] = value ? (char *)value : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "sss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); + return rc; +} + +static void weechat_php_config_new_option_callback_change(const void *pointer, void *data, struct t_config_option *option) +{ + int *rc; + void *func_argv[2]; + func_argv[1] = API_PTR2STR(option); + weechat_php_cb(pointer, data, func_argv, "ss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); +} + +static void weechat_php_config_new_option_callback_delete(const void *pointer, void *data, struct t_config_option *option) +{ + int rc; + void *func_argv[2]; + func_argv[1] = API_PTR2STR(option); + weechat_php_cb(pointer, data, func_argv, "ss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); +} + +static int weechat_php_config_new_section_callback_read(const void *pointer, void *data, struct t_config_file *config_file, struct t_config_section *section, const char *option_name, const char *value) +{ + int rc; + void *func_argv[5]; + func_argv[1] = API_PTR2STR(config_file); + func_argv[2] = API_PTR2STR(section); + func_argv[3] = option_name ? (char *)option_name : weechat_php_empty_arg; + func_argv[4] = value ? (char *)value : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "sssss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); + if (func_argv[2]) + free (func_argv[2]); + return rc; +} + +static int weechat_php_config_new_section_callback_write(const void *pointer, void *data, struct t_config_file *config_file, const char *section_name) +{ + int rc; + void *func_argv[3]; + func_argv[1] = API_PTR2STR(config_file); + func_argv[2] = section_name ? (char *)section_name : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "sss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); + return rc; +} + +static int weechat_php_config_new_section_callback_write_default(const void *pointer, void *data, struct t_config_file *config_file, const char *section_name) +{ + int rc; + void *func_argv[3]; + func_argv[1] = API_PTR2STR(config_file); + func_argv[2] = section_name ? (char *)section_name : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "sss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); + return rc; +} + +static int weechat_php_config_new_section_callback_create_option(const void *pointer, void *data, struct t_config_file *config_file, struct t_config_section *section, const char *option_name, const char *value) +{ + int rc; + void *func_argv[5]; + func_argv[1] = API_PTR2STR(config_file); + func_argv[2] = API_PTR2STR(section); + func_argv[3] = option_name ? (char *)option_name : weechat_php_empty_arg; + func_argv[4] = value ? (char *)value : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "sssss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); + if (func_argv[2]) + free (func_argv[2]); + return rc; +} + +static int weechat_php_config_new_section_callback_delete_option(const void *pointer, void *data, struct t_config_file *config_file, struct t_config_section *section, struct t_config_option *option) +{ + int rc; + void *func_argv[4]; + func_argv[1] = API_PTR2STR(config_file); + func_argv[2] = API_PTR2STR(section); + func_argv[3] = API_PTR2STR(option); + weechat_php_cb(pointer, data, func_argv, "ssss", WEECHAT_SCRIPT_EXEC_INT, &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 rc; +} + +static int weechat_php_hook_command_callback(const void *pointer, void *data, struct t_gui_buffer *buffer, int argc, char **argv, char **argv_eol) +{ + int rc; + void *func_argv[4]; + int i; + int *argi; + struct t_hashtable *args; + + (void)argv_eol; + + args = weechat_hashtable_new (argc, WEECHAT_HASHTABLE_INTEGER, WEECHAT_HASHTABLE_STRING, NULL, NULL); + argi = malloc(sizeof(int) * argc); + + for (i = 0; i < argc; i++) + { + *(argi + i) = i; + weechat_hashtable_set (args, argi+i, argv[i]); + } + + func_argv[1] = API_PTR2STR(buffer); + func_argv[2] = &argc; + func_argv[3] = args; + weechat_php_cb(pointer, data, func_argv, "ssih", WEECHAT_SCRIPT_EXEC_INT, &rc); + free (argi); + weechat_hashtable_free (args); + if (func_argv[1]) + free (func_argv[1]); + return rc; +} + +static int weechat_php_hook_command_run_callback(const void *pointer, void *data, struct t_gui_buffer *buffer, const char *command) +{ + int rc; + void *func_argv[3]; + func_argv[1] = API_PTR2STR(buffer); + func_argv[2] = command ? (char *)command : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "sss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); + return rc; +} + +static int weechat_php_hook_completion_callback(const void *pointer, void *data, const char *completion_item, struct t_gui_buffer *buffer, struct t_gui_completion *completion) +{ + int rc; + void *func_argv[4]; + func_argv[1] = completion_item ? (char *)completion_item : weechat_php_empty_arg; + func_argv[2] = API_PTR2STR(buffer); + func_argv[3] = API_PTR2STR(completion); + weechat_php_cb(pointer, data, func_argv, "ssss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[2]) + free (func_argv[2]); + if (func_argv[3]) + free (func_argv[3]); + return rc; +} + +static int weechat_php_hook_config_callback(const void *pointer, void *data, const char *option, const char *value) +{ + int rc; + void *func_argv[3]; + func_argv[1] = option ? (char *)option : weechat_php_empty_arg; + func_argv[2] = value ? (char *)value : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "sss", WEECHAT_SCRIPT_EXEC_INT, &rc); + return rc; +} + +static int weechat_php_hook_connect_callback(const void *pointer, void *data, int status, int gnutls_rc, int sock, const char *error, const char *ip_address) +{ + int rc; + void *func_argv[6]; + func_argv[1] = &status; + func_argv[2] = &gnutls_rc; + func_argv[3] = &sock; + func_argv[4] = error ? (char *)error : weechat_php_empty_arg; + func_argv[5] = ip_address ? (char *)ip_address : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "siiiss", WEECHAT_SCRIPT_EXEC_INT, &rc); + return rc; +} + +static int weechat_php_hook_fd_callback(const void *pointer, void *data, int fd) +{ + int rc; + void *func_argv[2]; + func_argv[1] = &fd; + weechat_php_cb(pointer, data, func_argv, "si", WEECHAT_SCRIPT_EXEC_INT, &rc); + return rc; +} + +static int weechat_php_hook_hsignal_callback(const void *pointer, void *data, const char *signal, struct t_hashtable *hashtable) +{ + int rc; + void *func_argv[3]; + func_argv[1] = signal ? (char *)signal : weechat_php_empty_arg; + func_argv[2] = hashtable; + weechat_php_cb(pointer, data, func_argv, "ssh", WEECHAT_SCRIPT_EXEC_INT, &rc); + return rc; +} + +static const char *weechat_php_hook_info_callback(const void *pointer, void *data, const char *info_name, const char *arguments) +{ + char *rc; + void *func_argv[3]; + func_argv[1] = info_name ? (char *)info_name : weechat_php_empty_arg; + func_argv[2] = arguments ? (char *)arguments : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "sss", WEECHAT_SCRIPT_EXEC_STRING, &rc); + return rc; +} + +static char *weechat_php_hook_modifier_callback(const void *pointer, void *data, const char *modifier, const char *modifier_data, const char *string) +{ + char *rc; + void *func_argv[4]; + func_argv[1] = modifier ? (char *)modifier : weechat_php_empty_arg; + func_argv[2] = modifier_data ? (char *)modifier_data : weechat_php_empty_arg; + func_argv[3] = string ? (char *)string : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "ssss", WEECHAT_SCRIPT_EXEC_STRING, &rc); + return rc; +} + +static int weechat_php_hook_print_callback(const void *pointer, 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) +{ + int rc; + void *func_argv[9]; + func_argv[1] = API_PTR2STR(buffer); + func_argv[2] = &date; + func_argv[3] = &tags_count; + func_argv[4] = tags ? (char *)tags : weechat_php_empty_arg; + func_argv[5] = &displayed; + func_argv[6] = &highlight; + func_argv[7] = prefix ? (char *)prefix : weechat_php_empty_arg; + func_argv[8] = message ? (char *)message : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "ssiisiiss", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); + return rc; +} + +static int weechat_php_hook_process_callback(const void *pointer, void *data, const char *command, int return_code, const char *out, const char *err) +{ + int rc; + void *func_argv[5]; + func_argv[1] = command ? (char *)command : weechat_php_empty_arg; + func_argv[2] = &return_code; + func_argv[3] = out ? (char *)out : weechat_php_empty_arg; + func_argv[4] = err ? (char *)err : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "ssiss", WEECHAT_SCRIPT_EXEC_INT, &rc); + return rc; +} + +static int weechat_php_hook_process_hashtable_callback(const void *pointer, void *data, const char *command, int return_code, const char *out, const char *err) +{ + int rc; + void *func_argv[5]; + func_argv[1] = command ? (char *)command : weechat_php_empty_arg; + func_argv[2] = &return_code; + func_argv[3] = out ? (char *)out : weechat_php_empty_arg; + func_argv[4] = err ? (char *)err : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "ssiss", WEECHAT_SCRIPT_EXEC_INT, &rc); + return rc; +} + +static int weechat_php_hook_signal_callback(const void *pointer, void *data, const char *signal, const char *type_data, void *signal_data) +{ + int rc; + void *func_argv[4]; + func_argv[1] = signal ? (char *)signal : weechat_php_empty_arg; + func_argv[2] = type_data ? (char *)type_data : weechat_php_empty_arg; + func_argv[3] = signal_data ? (char *)signal_data : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "ssss", WEECHAT_SCRIPT_EXEC_INT, &rc); + return rc; +} + +static int weechat_php_hook_timer_callback(const void *pointer, void *data, int remaining_calls) +{ + int rc; + void *func_argv[2]; + func_argv[1] = &remaining_calls; + weechat_php_cb(pointer, data, func_argv, "si", WEECHAT_SCRIPT_EXEC_INT, &rc); + return rc; +} + +static int weechat_php_upgrade_new_callback_read(const void *pointer, void *data, struct t_upgrade_file *upgrade_file, int object_id, struct t_infolist *infolist) +{ + int rc; + void *func_argv[4]; + func_argv[1] = API_PTR2STR(upgrade_file); + func_argv[2] = &object_id; + func_argv[3] = API_PTR2STR(infolist); + weechat_php_cb(pointer, data, func_argv, "ssis", WEECHAT_SCRIPT_EXEC_INT, &rc); + if (func_argv[1]) + free (func_argv[1]); + if (func_argv[3]) + free (func_argv[3]); + return rc; +} + +struct t_hashtable * weechat_php_api_hook_focus_callback(const void *pointer, void *data, struct t_hashtable *info) +{ + struct t_hashtable *rc; + void *func_argv[2]; + func_argv[1] = info; + weechat_php_cb(pointer, data, func_argv, "sh", WEECHAT_SCRIPT_EXEC_HASHTABLE, &rc); + return rc; +} + +struct t_hashtable * weechat_php_api_hook_info_hashtable_callback(const void *pointer, void *data, const char *info_name, struct t_hashtable *hashtable) +{ + struct t_hashtable *rc; + void *func_argv[3]; + func_argv[1] = (info_name) ? (char *)info_name : weechat_php_empty_arg; + func_argv[2] = hashtable; + weechat_php_cb(pointer, data, func_argv, "ssh", WEECHAT_SCRIPT_EXEC_HASHTABLE, &rc); + return rc; +} + +struct t_infolist * weechat_php_api_hook_infolist_callback (const void *pointer, void *data, const char *info_name, void *obj_pointer, const char *arguments) +{ + struct t_infolist *rc; + void *func_argv[4]; + func_argv[1] = (info_name) ? (char *)info_name : weechat_php_empty_arg; + func_argv[2] = API_PTR2STR(obj_pointer); + func_argv[3] = (arguments) ? (char *)arguments : weechat_php_empty_arg; + weechat_php_cb(pointer, data, func_argv, "ssss", WEECHAT_SCRIPT_EXEC_STRING, &rc); + if (func_argv[2]) + free (func_argv[2]); + return rc; +} + + +PHP_FUNCTION(weechat_bar_item_remove) +{ + API_FUNC_INIT(weechat_bar_item_remove); + zend_string *z_item; + struct t_gui_bar_item *item; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_item) == FAILURE) + { + return; + } + item = (struct t_gui_bar_item *)API_STR2PTR(ZSTR_VAL(z_item)); + weechat_bar_item_remove (item); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_bar_item_search) +{ + API_FUNC_INIT(weechat_bar_item_search); + zend_string *z_name; + struct t_gui_bar_item *retval; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_name) == FAILURE) + { + return; + } + name = ZSTR_VAL(z_name); + retval = weechat_bar_item_search ((const char *)name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_bar_item_update) +{ + API_FUNC_INIT(weechat_bar_item_update); + zend_string *z_name; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_name) == FAILURE) + { + return; + } + name = ZSTR_VAL(z_name); + weechat_bar_item_update ((const char *)name); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_bar_new) +{ + API_FUNC_INIT(weechat_bar_new); + zend_string *z_name; + zend_string *z_hidden; + zend_string *z_priority; + zend_string *z_type; + zend_string *z_condition; + zend_string *z_position; + zend_string *z_filling_top_bottom; + zend_string *z_filling_left_right; + zend_string *z_size; + zend_string *z_size_max; + zend_string *z_color_fg; + zend_string *z_color_delim; + zend_string *z_color_bg; + zend_string *z_separator; + zend_string *z_items; + struct t_gui_bar *retval; + char *name; + char *hidden; + char *priority; + char *type; + char *condition; + char *position; + char *filling_top_bottom; + char *filling_left_right; + char *size; + char *size_max; + char *color_fg; + char *color_delim; + char *color_bg; + char *separator; + char *items; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSSSSSSSSSSSS", &z_name, &z_hidden, &z_priority, &z_type, &z_condition, &z_position, &z_filling_top_bottom, &z_filling_left_right, &z_size, &z_size_max, &z_color_fg, &z_color_delim, &z_color_bg, &z_separator, &z_items) == FAILURE) + { + return; + } + name = ZSTR_VAL(z_name); + hidden = ZSTR_VAL(z_hidden); + priority = ZSTR_VAL(z_priority); + type = ZSTR_VAL(z_type); + condition = ZSTR_VAL(z_condition); + position = ZSTR_VAL(z_position); + filling_top_bottom = ZSTR_VAL(z_filling_top_bottom); + filling_left_right = ZSTR_VAL(z_filling_left_right); + size = ZSTR_VAL(z_size); + size_max = ZSTR_VAL(z_size_max); + color_fg = ZSTR_VAL(z_color_fg); + color_delim = ZSTR_VAL(z_color_delim); + color_bg = ZSTR_VAL(z_color_bg); + separator = ZSTR_VAL(z_separator); + items = ZSTR_VAL(z_items); + retval = weechat_bar_new ((const char *)name, (const char *)hidden, (const char *)priority, (const char *)type, (const char *)condition, (const char *)position, (const char *)filling_top_bottom, (const char *)filling_left_right, (const char *)size, (const char *)size_max, (const char *)color_fg, (const char *)color_delim, (const char *)color_bg, (const char *)separator, (const char *)items); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_bar_remove) +{ + API_FUNC_INIT(weechat_bar_remove); + zend_string *z_bar; + struct t_gui_bar *bar; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_bar) == FAILURE) + { + return; + } + bar = (struct t_gui_bar *)API_STR2PTR(ZSTR_VAL(z_bar)); + weechat_bar_remove (bar); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_bar_search) +{ + API_FUNC_INIT(weechat_bar_search); + zend_string *z_name; + struct t_gui_bar *retval; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_name) == FAILURE) + { + return; + } + name = ZSTR_VAL(z_name); + retval = weechat_bar_search ((const char *)name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_bar_set) +{ + API_FUNC_INIT(weechat_bar_set); + zend_string *z_bar; + zend_string *z_property; + zend_string *z_value; + int retval; + struct t_gui_bar *bar; + char *property; + char *value; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_bar, &z_property, &z_value) == FAILURE) + { + return; + } + bar = (struct t_gui_bar *)API_STR2PTR(ZSTR_VAL(z_bar)); + property = ZSTR_VAL(z_property); + value = ZSTR_VAL(z_value); + retval = weechat_bar_set (bar, (const char *)property, (const char *)value); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_bar_update) +{ + API_FUNC_INIT(weechat_bar_update); + zend_string *z_name; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_name) == FAILURE) + { + return; + } + name = ZSTR_VAL(z_name); + weechat_bar_update ((const char *)name); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_buffer_clear) +{ + API_FUNC_INIT(weechat_buffer_clear); + zend_string *z_buffer; + struct t_gui_buffer *buffer; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_buffer) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + weechat_buffer_clear (buffer); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_buffer_close) +{ + API_FUNC_INIT(weechat_buffer_close); + zend_string *z_buffer; + struct t_gui_buffer *buffer; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_buffer) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + weechat_buffer_close (buffer); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_buffer_get_integer) +{ + API_FUNC_INIT(weechat_buffer_get_integer); + zend_string *z_buffer; + zend_string *z_property; + int retval; + struct t_gui_buffer *buffer; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer, &z_property) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + property = ZSTR_VAL(z_property); + retval = weechat_buffer_get_integer (buffer, (const char *)property); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_buffer_get_pointer) +{ + API_FUNC_INIT(weechat_buffer_get_pointer); + zend_string *z_buffer; + zend_string *z_property; + void *retval; + struct t_gui_buffer *buffer; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer, &z_property) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + property = ZSTR_VAL(z_property); + retval = weechat_buffer_get_pointer (buffer, (const char *)property); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_buffer_get_string) +{ + API_FUNC_INIT(weechat_buffer_get_string); + zend_string *z_buffer; + zend_string *z_property; + const char *retval; + struct t_gui_buffer *buffer; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer, &z_property) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + property = ZSTR_VAL(z_property); + retval = weechat_buffer_get_string (buffer, (const char *)property); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_buffer_match_list) +{ + API_FUNC_INIT(weechat_buffer_match_list); + zend_string *z_buffer; + zend_string *z_string; + int retval; + struct t_gui_buffer *buffer; + char *string; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer, &z_string) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + string = ZSTR_VAL(z_string); + retval = weechat_buffer_match_list (buffer, (const char *)string); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_buffer_merge) +{ + API_FUNC_INIT(weechat_buffer_merge); + zend_string *z_buffer; + zend_string *z_target_buffer; + struct t_gui_buffer *buffer; + struct t_gui_buffer *target_buffer; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer, &z_target_buffer) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + target_buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_target_buffer)); + weechat_buffer_merge (buffer, target_buffer); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_buffer_search) +{ + API_FUNC_INIT(weechat_buffer_search); + zend_string *z_plugin; + zend_string *z_name; + struct t_gui_buffer *retval; + char *plugin; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_plugin, &z_name) == FAILURE) + { + return; + } + plugin = ZSTR_VAL(z_plugin); + name = ZSTR_VAL(z_name); + retval = weechat_buffer_search ((const char *)plugin, (const char *)name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_buffer_search_main) +{ + API_FUNC_INIT(weechat_buffer_search_main); + struct t_gui_buffer *retval; + if (zend_parse_parameters_none () == FAILURE) + { + return; + } + retval = weechat_buffer_search_main (); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_buffer_set) +{ + API_FUNC_INIT(weechat_buffer_set); + zend_string *z_buffer; + zend_string *z_property; + zend_string *z_value; + struct t_gui_buffer *buffer; + char *property; + char *value; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_property, &z_value) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + property = ZSTR_VAL(z_property); + value = ZSTR_VAL(z_value); + weechat_buffer_set (buffer, (const char *)property, (const char *)value); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_buffer_string_replace_local_var) +{ + API_FUNC_INIT(weechat_buffer_string_replace_local_var); + zend_string *z_buffer; + zend_string *z_string; + char *retval; + struct t_gui_buffer *buffer; + char *string; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer, &z_string) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + string = ZSTR_VAL(z_string); + retval = weechat_buffer_string_replace_local_var (buffer, (const char *)string); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_buffer_unmerge) +{ + API_FUNC_INIT(weechat_buffer_unmerge); + zend_string *z_buffer; + zend_long z_number; + struct t_gui_buffer *buffer; + int number; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl", &z_buffer, &z_number) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + number = (int)z_number; + weechat_buffer_unmerge (buffer, number); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_color) +{ + API_FUNC_INIT(weechat_color); + zend_string *z_color_name; + const char *retval; + char *color_name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_color_name) == FAILURE) + { + return; + } + color_name = ZSTR_VAL(z_color_name); + retval = weechat_color ((const char *)color_name); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_config_boolean) +{ + API_FUNC_INIT(weechat_config_boolean); + zend_string *z_option; + int retval; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + retval = weechat_config_boolean (option); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_boolean_default) +{ + API_FUNC_INIT(weechat_config_boolean_default); + zend_string *z_option; + int retval; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + retval = weechat_config_boolean_default (option); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_color) +{ + API_FUNC_INIT(weechat_config_color); + zend_string *z_option; + const char *retval; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + retval = weechat_config_color (option); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_config_color_default) +{ + API_FUNC_INIT(weechat_config_color_default); + zend_string *z_option; + const char *retval; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + retval = weechat_config_color_default (option); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_config_free) +{ + API_FUNC_INIT(weechat_config_free); + zend_string *z_config_file; + struct t_config_file *config_file; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_config_file) == FAILURE) + { + return; + } + config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file)); + weechat_config_free (config_file); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_config_get) +{ + API_FUNC_INIT(weechat_config_get); + zend_string *z_option_name; + struct t_config_option *retval; + char *option_name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option_name) == FAILURE) + { + return; + } + option_name = ZSTR_VAL(z_option_name); + retval = weechat_config_get ((const char *)option_name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_config_integer) +{ + API_FUNC_INIT(weechat_config_integer); + zend_string *z_option; + int retval; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + retval = weechat_config_integer (option); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_integer_default) +{ + API_FUNC_INIT(weechat_config_integer_default); + zend_string *z_option; + int retval; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + retval = weechat_config_integer_default (option); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_option_default_is_null) +{ + API_FUNC_INIT(weechat_config_option_default_is_null); + zend_string *z_option; + int retval; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + retval = weechat_config_option_default_is_null (option); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_option_free) +{ + API_FUNC_INIT(weechat_config_option_free); + zend_string *z_option; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + weechat_config_option_free (option); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_config_option_is_null) +{ + API_FUNC_INIT(weechat_config_option_is_null); + zend_string *z_option; + int retval; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + retval = weechat_config_option_is_null (option); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_option_rename) +{ + API_FUNC_INIT(weechat_config_option_rename); + zend_string *z_option; + zend_string *z_new_name; + struct t_config_option *option; + char *new_name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_option, &z_new_name) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + new_name = ZSTR_VAL(z_new_name); + weechat_config_option_rename (option, (const char *)new_name); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_config_option_reset) +{ + API_FUNC_INIT(weechat_config_option_reset); + zend_string *z_option; + zend_long z_run_callback; + int retval; + struct t_config_option *option; + int run_callback; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl", &z_option, &z_run_callback) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + run_callback = (int)z_run_callback; + retval = weechat_config_option_reset (option, run_callback); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_option_set) +{ + API_FUNC_INIT(weechat_config_option_set); + zend_string *z_option; + zend_string *z_value; + zend_long z_run_callback; + int retval; + struct t_config_option *option; + char *value; + int run_callback; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl", &z_option, &z_value, &z_run_callback) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + value = ZSTR_VAL(z_value); + run_callback = (int)z_run_callback; + retval = weechat_config_option_set (option, (const char *)value, run_callback); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_option_set_null) +{ + API_FUNC_INIT(weechat_config_option_set_null); + zend_string *z_option; + zend_long z_run_callback; + int retval; + struct t_config_option *option; + int run_callback; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl", &z_option, &z_run_callback) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + run_callback = (int)z_run_callback; + retval = weechat_config_option_set_null (option, run_callback); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_option_unset) +{ + API_FUNC_INIT(weechat_config_option_unset); + zend_string *z_option; + int retval; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + retval = weechat_config_option_unset (option); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_read) +{ + API_FUNC_INIT(weechat_config_read); + zend_string *z_config_file; + int retval; + struct t_config_file *config_file; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_config_file) == FAILURE) + { + return; + } + config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file)); + retval = weechat_config_read (config_file); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_reload) +{ + API_FUNC_INIT(weechat_config_reload); + zend_string *z_config_file; + int retval; + struct t_config_file *config_file; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_config_file) == FAILURE) + { + return; + } + config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file)); + retval = weechat_config_reload (config_file); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_search_option) +{ + API_FUNC_INIT(weechat_config_search_option); + zend_string *z_config_file; + zend_string *z_section; + zend_string *z_option_name; + struct t_config_option *retval; + struct t_config_file *config_file; + struct t_config_section *section; + char *option_name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_config_file, &z_section, &z_option_name) == FAILURE) + { + return; + } + config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file)); + section = (struct t_config_section *)API_STR2PTR(ZSTR_VAL(z_section)); + option_name = ZSTR_VAL(z_option_name); + retval = weechat_config_search_option (config_file, section, (const char *)option_name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_config_search_section) +{ + API_FUNC_INIT(weechat_config_search_section); + zend_string *z_config_file; + zend_string *z_section_name; + struct t_config_section *retval; + struct t_config_file *config_file; + char *section_name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_config_file, &z_section_name) == FAILURE) + { + return; + } + config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file)); + section_name = ZSTR_VAL(z_section_name); + retval = weechat_config_search_section (config_file, (const char *)section_name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_config_section_free) +{ + API_FUNC_INIT(weechat_config_section_free); + zend_string *z_section; + struct t_config_section *section; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_section) == FAILURE) + { + return; + } + section = (struct t_config_section *)API_STR2PTR(ZSTR_VAL(z_section)); + weechat_config_section_free (section); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_config_section_free_options) +{ + API_FUNC_INIT(weechat_config_section_free_options); + zend_string *z_section; + struct t_config_section *section; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_section) == FAILURE) + { + return; + } + section = (struct t_config_section *)API_STR2PTR(ZSTR_VAL(z_section)); + weechat_config_section_free_options (section); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_config_string) +{ + API_FUNC_INIT(weechat_config_string); + zend_string *z_option; + const char *retval; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + retval = weechat_config_string (option); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_config_string_default) +{ + API_FUNC_INIT(weechat_config_string_default); + zend_string *z_option; + const char *retval; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + retval = weechat_config_string_default (option); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_config_string_to_boolean) +{ + API_FUNC_INIT(weechat_config_string_to_boolean); + zend_string *z_text; + int retval; + char *text; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_text) == FAILURE) + { + return; + } + text = ZSTR_VAL(z_text); + retval = weechat_config_string_to_boolean ((const char *)text); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_write) +{ + API_FUNC_INIT(weechat_config_write); + zend_string *z_config_file; + int retval; + struct t_config_file *config_file; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_config_file) == FAILURE) + { + return; + } + config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file)); + retval = weechat_config_write (config_file); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_write_line) +{ + API_FUNC_INIT(weechat_config_write_line); + zend_string *z_config_file; + zend_string *z_option_name; + zend_string *z_value; + int retval; + struct t_config_file *config_file; + char *option_name; + char *value; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_config_file, &z_option_name, &z_value) == FAILURE) + { + return; + } + config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file)); + option_name = ZSTR_VAL(z_option_name); + value = ZSTR_VAL(z_value); + retval = weechat_config_write_line (config_file, (const char *)option_name, (const char *)value); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_write_option) +{ + API_FUNC_INIT(weechat_config_write_option); + zend_string *z_config_file; + zend_string *z_option; + int retval; + struct t_config_file *config_file; + struct t_config_option *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_config_file, &z_option) == FAILURE) + { + return; + } + config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file)); + option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option)); + retval = weechat_config_write_option (config_file, option); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_gettext) +{ + API_FUNC_INIT(weechat_gettext); + zend_string *z_string; + const char *retval; + char *string; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_string) == FAILURE) + { + return; + } + string = ZSTR_VAL(z_string); + retval = weechat_gettext ((const char *)string); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_hdata_char) +{ + API_FUNC_INIT(weechat_hdata_char); + zend_string *z_hdata; + zend_string *z_pointer; + zend_string *z_name; + char retval; + struct t_hdata *hdata; + void *pointer; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_char (hdata, pointer, (const char *)name); + RETURN_LONG((int)retval); +} + +PHP_FUNCTION(weechat_hdata_check_pointer) +{ + API_FUNC_INIT(weechat_hdata_check_pointer); + zend_string *z_hdata; + zend_string *z_list; + zend_string *z_pointer; + int retval; + struct t_hdata *hdata; + void *list; + void *pointer; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_list, &z_pointer) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + list = (void *)API_STR2PTR(ZSTR_VAL(z_list)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + retval = weechat_hdata_check_pointer (hdata, list, pointer); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_hdata_get) +{ + API_FUNC_INIT(weechat_hdata_get); + zend_string *z_hdata_name; + struct t_hdata *retval; + char *hdata_name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_hdata_name) == FAILURE) + { + return; + } + hdata_name = ZSTR_VAL(z_hdata_name); + retval = weechat_hdata_get ((const char *)hdata_name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hdata_get_list) +{ + API_FUNC_INIT(weechat_hdata_get_list); + zend_string *z_hdata; + zend_string *z_name; + void *retval; + struct t_hdata *hdata; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_hdata, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_get_list (hdata, (const char *)name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hdata_get_string) +{ + API_FUNC_INIT(weechat_hdata_get_string); + zend_string *z_hdata; + zend_string *z_property; + const char *retval; + struct t_hdata *hdata; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_hdata, &z_property) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + property = ZSTR_VAL(z_property); + retval = weechat_hdata_get_string (hdata, (const char *)property); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_hdata_get_var) +{ + API_FUNC_INIT(weechat_hdata_get_var); + zend_string *z_hdata; + zend_string *z_pointer; + zend_string *z_name; + void *retval; + struct t_hdata *hdata; + void *pointer; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_get_var (hdata, pointer, (const char *)name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hdata_get_var_array_size) +{ + API_FUNC_INIT(weechat_hdata_get_var_array_size); + zend_string *z_hdata; + zend_string *z_pointer; + zend_string *z_name; + int retval; + struct t_hdata *hdata; + void *pointer; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_get_var_array_size (hdata, pointer, (const char *)name); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_hdata_get_var_array_size_string) +{ + API_FUNC_INIT(weechat_hdata_get_var_array_size_string); + zend_string *z_hdata; + zend_string *z_pointer; + zend_string *z_name; + const char *retval; + struct t_hdata *hdata; + void *pointer; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_get_var_array_size_string (hdata, pointer, (const char *)name); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_hdata_get_var_hdata) +{ + API_FUNC_INIT(weechat_hdata_get_var_hdata); + zend_string *z_hdata; + zend_string *z_name; + const char *retval; + struct t_hdata *hdata; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_hdata, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_get_var_hdata (hdata, (const char *)name); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_hdata_get_var_offset) +{ + API_FUNC_INIT(weechat_hdata_get_var_offset); + zend_string *z_hdata; + zend_string *z_name; + int retval; + struct t_hdata *hdata; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_hdata, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_get_var_offset (hdata, (const char *)name); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_hdata_get_var_type) +{ + API_FUNC_INIT(weechat_hdata_get_var_type); + zend_string *z_hdata; + zend_string *z_name; + int retval; + struct t_hdata *hdata; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_hdata, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_get_var_type (hdata, (const char *)name); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_hdata_get_var_type_string) +{ + API_FUNC_INIT(weechat_hdata_get_var_type_string); + zend_string *z_hdata; + zend_string *z_name; + const char *retval; + struct t_hdata *hdata; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_hdata, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_get_var_type_string (hdata, (const char *)name); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_hdata_hashtable) +{ + API_FUNC_INIT(weechat_hdata_hashtable); + zend_string *z_hdata; + zend_string *z_pointer; + zend_string *z_name; + struct t_hashtable *retval; + struct t_hdata *hdata; + void *pointer; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_hashtable (hdata, pointer, (const char *)name); + weechat_php_hashtable_to_array(retval, return_value); +} + +PHP_FUNCTION(weechat_hdata_integer) +{ + API_FUNC_INIT(weechat_hdata_integer); + zend_string *z_hdata; + zend_string *z_pointer; + zend_string *z_name; + int retval; + struct t_hdata *hdata; + void *pointer; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_integer (hdata, pointer, (const char *)name); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_hdata_long) +{ + API_FUNC_INIT(weechat_hdata_long); + zend_string *z_hdata; + zend_string *z_pointer; + zend_string *z_name; + long retval; + struct t_hdata *hdata; + void *pointer; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_long (hdata, pointer, (const char *)name); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_hdata_move) +{ + API_FUNC_INIT(weechat_hdata_move); + zend_string *z_hdata; + zend_string *z_pointer; + zend_long z_count; + void *retval; + struct t_hdata *hdata; + void *pointer; + int count; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl", &z_hdata, &z_pointer, &z_count) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + count = (int)z_count; + retval = weechat_hdata_move (hdata, pointer, count); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hdata_pointer) +{ + API_FUNC_INIT(weechat_hdata_pointer); + zend_string *z_hdata; + zend_string *z_pointer; + zend_string *z_name; + void *retval; + struct t_hdata *hdata; + void *pointer; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_pointer (hdata, pointer, (const char *)name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hdata_search) +{ + API_FUNC_INIT(weechat_hdata_search); + zend_string *z_hdata; + zend_string *z_pointer; + zend_string *z_search; + zend_long z_move; + void *retval; + struct t_hdata *hdata; + void *pointer; + char *search; + int move; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSl", &z_hdata, &z_pointer, &z_search, &z_move) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + search = ZSTR_VAL(z_search); + move = (int)z_move; + retval = weechat_hdata_search (hdata, pointer, (const char *)search, move); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hdata_string) +{ + API_FUNC_INIT(weechat_hdata_string); + zend_string *z_hdata; + zend_string *z_pointer; + zend_string *z_name; + const char *retval; + struct t_hdata *hdata; + void *pointer; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_string (hdata, pointer, (const char *)name); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_hdata_time) +{ + API_FUNC_INIT(weechat_hdata_time); + zend_string *z_hdata; + zend_string *z_pointer; + zend_string *z_name; + time_t retval; + struct t_hdata *hdata; + void *pointer; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer, &z_name) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + name = ZSTR_VAL(z_name); + retval = weechat_hdata_time (hdata, pointer, (const char *)name); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_hdata_update) +{ + API_FUNC_INIT(weechat_hdata_update); + zend_string *z_hdata; + zend_string *z_pointer; + zval *z_hashtable; + int retval; + struct t_hdata *hdata; + void *pointer; + struct t_hashtable *hashtable; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSa", &z_hdata, &z_pointer, &z_hashtable) == FAILURE) + { + return; + } + hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata)); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + hashtable = weechat_php_array_to_hashtable(z_hashtable, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); + retval = weechat_hdata_update (hdata, pointer, hashtable); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_hook_completion_get_string) +{ + API_FUNC_INIT(weechat_hook_completion_get_string); + zend_string *z_completion; + zend_string *z_property; + const char *retval; + struct t_gui_completion *completion; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_completion, &z_property) == FAILURE) + { + return; + } + completion = (struct t_gui_completion *)API_STR2PTR(ZSTR_VAL(z_completion)); + property = ZSTR_VAL(z_property); + retval = weechat_hook_completion_get_string (completion, (const char *)property); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_hook_completion_list_add) +{ + API_FUNC_INIT(weechat_hook_completion_list_add); + zend_string *z_completion; + zend_string *z_word; + zend_long z_nick_completion; + zend_string *z_where; + struct t_gui_completion *completion; + char *word; + int nick_completion; + char *where; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSlS", &z_completion, &z_word, &z_nick_completion, &z_where) == FAILURE) + { + return; + } + completion = (struct t_gui_completion *)API_STR2PTR(ZSTR_VAL(z_completion)); + word = ZSTR_VAL(z_word); + nick_completion = (int)z_nick_completion; + where = ZSTR_VAL(z_where); + weechat_hook_completion_list_add (completion, (const char *)word, nick_completion, (const char *)where); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_hook_hsignal_send) +{ + API_FUNC_INIT(weechat_hook_hsignal_send); + zend_string *z_signal; + zval *z_hashtable; + int retval; + char *signal; + struct t_hashtable *hashtable; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sa", &z_signal, &z_hashtable) == FAILURE) + { + return; + } + signal = ZSTR_VAL(z_signal); + hashtable = weechat_php_array_to_hashtable(z_hashtable, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); + retval = weechat_hook_hsignal_send ((const char *)signal, hashtable); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_hook_modifier_exec) +{ + API_FUNC_INIT(weechat_hook_modifier_exec); + zend_string *z_modifier; + zend_string *z_modifier_data; + zend_string *z_string; + char *retval; + char *modifier; + char *modifier_data; + char *string; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_modifier, &z_modifier_data, &z_string) == FAILURE) + { + return; + } + modifier = ZSTR_VAL(z_modifier); + modifier_data = ZSTR_VAL(z_modifier_data); + string = ZSTR_VAL(z_string); + retval = weechat_hook_modifier_exec ((const char *)modifier, (const char *)modifier_data, (const char *)string); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_hook_set) +{ + API_FUNC_INIT(weechat_hook_set); + zend_string *z_hook; + zend_string *z_property; + zend_string *z_value; + struct t_hook *hook; + char *property; + char *value; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hook, &z_property, &z_value) == FAILURE) + { + return; + } + hook = (struct t_hook *)API_STR2PTR(ZSTR_VAL(z_hook)); + property = ZSTR_VAL(z_property); + value = ZSTR_VAL(z_value); + weechat_hook_set (hook, (const char *)property, (const char *)value); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_hook_signal_send) +{ + API_FUNC_INIT(weechat_hook_signal_send); + zend_string *z_signal; + zend_string *z_type_data; + zend_string *z_signal_data; + int retval; + char *signal; + char *type_data; + void *signal_data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_signal, &z_type_data, &z_signal_data) == FAILURE) + { + return; + } + signal = ZSTR_VAL(z_signal); + type_data = ZSTR_VAL(z_type_data); + signal_data = (void *)API_STR2PTR(ZSTR_VAL(z_signal_data)); + retval = weechat_hook_signal_send ((const char *)signal, (const char *)type_data, signal_data); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_iconv_from_internal) +{ + API_FUNC_INIT(weechat_iconv_from_internal); + zend_string *z_charset; + zend_string *z_string; + char *retval; + char *charset; + char *string; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_charset, &z_string) == FAILURE) + { + return; + } + charset = ZSTR_VAL(z_charset); + string = ZSTR_VAL(z_string); + retval = weechat_iconv_from_internal ((const char *)charset, (const char *)string); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_iconv_to_internal) +{ + API_FUNC_INIT(weechat_iconv_to_internal); + zend_string *z_charset; + zend_string *z_string; + char *retval; + char *charset; + char *string; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_charset, &z_string) == FAILURE) + { + return; + } + charset = ZSTR_VAL(z_charset); + string = ZSTR_VAL(z_string); + retval = weechat_iconv_to_internal ((const char *)charset, (const char *)string); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_info_get) +{ + API_FUNC_INIT(weechat_info_get); + zend_string *z_info_name; + zend_string *z_arguments; + const char *retval; + char *info_name; + char *arguments; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_info_name, &z_arguments) == FAILURE) + { + return; + } + info_name = ZSTR_VAL(z_info_name); + arguments = ZSTR_VAL(z_arguments); + retval = weechat_info_get ((const char *)info_name, (const char *)arguments); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_info_get_hashtable) +{ + API_FUNC_INIT(weechat_info_get_hashtable); + zend_string *z_info_name; + zval *z_hashtable; + struct t_hashtable *retval; + char *info_name; + struct t_hashtable *hashtable; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sa", &z_info_name, &z_hashtable) == FAILURE) + { + return; + } + info_name = ZSTR_VAL(z_info_name); + hashtable = weechat_php_array_to_hashtable(z_hashtable, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); + retval = weechat_info_get_hashtable ((const char *)info_name, hashtable); + weechat_php_hashtable_to_array(retval, return_value); +} + +PHP_FUNCTION(weechat_infolist_fields) +{ + API_FUNC_INIT(weechat_infolist_fields); + zend_string *z_infolist; + const char *retval; + struct t_infolist *infolist; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_infolist) == FAILURE) + { + return; + } + infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist)); + retval = weechat_infolist_fields (infolist); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_infolist_free) +{ + API_FUNC_INIT(weechat_infolist_free); + zend_string *z_infolist; + struct t_infolist *infolist; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_infolist) == FAILURE) + { + return; + } + infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist)); + weechat_infolist_free (infolist); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_infolist_get) +{ + API_FUNC_INIT(weechat_infolist_get); + zend_string *z_infolist_name; + zend_string *z_pointer; + zend_string *z_arguments; + struct t_infolist *retval; + char *infolist_name; + void *pointer; + char *arguments; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_infolist_name, &z_pointer, &z_arguments) == FAILURE) + { + return; + } + infolist_name = ZSTR_VAL(z_infolist_name); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + arguments = ZSTR_VAL(z_arguments); + retval = weechat_infolist_get ((const char *)infolist_name, pointer, (const char *)arguments); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_infolist_integer) +{ + API_FUNC_INIT(weechat_infolist_integer); + zend_string *z_infolist; + zend_string *z_var; + int retval; + struct t_infolist *infolist; + char *var; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_infolist, &z_var) == FAILURE) + { + return; + } + infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist)); + var = ZSTR_VAL(z_var); + retval = weechat_infolist_integer (infolist, (const char *)var); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_infolist_new) +{ + API_FUNC_INIT(weechat_infolist_new); + struct t_infolist *retval; + if (zend_parse_parameters_none () == FAILURE) + { + return; + } + retval = weechat_infolist_new (); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_infolist_new_item) +{ + API_FUNC_INIT(weechat_infolist_new_item); + zend_string *z_infolist; + struct t_infolist_item *retval; + struct t_infolist *infolist; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_infolist) == FAILURE) + { + return; + } + infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist)); + retval = weechat_infolist_new_item (infolist); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_infolist_new_var_integer) +{ + API_FUNC_INIT(weechat_infolist_new_var_integer); + zend_string *z_item; + zend_string *z_name; + zend_long z_value; + struct t_infolist_var *retval; + struct t_infolist_item *item; + char *name; + int value; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl", &z_item, &z_name, &z_value) == FAILURE) + { + return; + } + item = (struct t_infolist_item *)API_STR2PTR(ZSTR_VAL(z_item)); + name = ZSTR_VAL(z_name); + value = (int)z_value; + retval = weechat_infolist_new_var_integer (item, (const char *)name, value); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_infolist_new_var_pointer) +{ + API_FUNC_INIT(weechat_infolist_new_var_pointer); + zend_string *z_item; + zend_string *z_name; + zend_string *z_pointer; + struct t_infolist_var *retval; + struct t_infolist_item *item; + char *name; + void *pointer; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_item, &z_name, &z_pointer) == FAILURE) + { + return; + } + item = (struct t_infolist_item *)API_STR2PTR(ZSTR_VAL(z_item)); + name = ZSTR_VAL(z_name); + pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer)); + retval = weechat_infolist_new_var_pointer (item, (const char *)name, pointer); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_infolist_new_var_string) +{ + API_FUNC_INIT(weechat_infolist_new_var_string); + zend_string *z_item; + zend_string *z_name; + zend_string *z_value; + struct t_infolist_var *retval; + struct t_infolist_item *item; + char *name; + char *value; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_item, &z_name, &z_value) == FAILURE) + { + return; + } + item = (struct t_infolist_item *)API_STR2PTR(ZSTR_VAL(z_item)); + name = ZSTR_VAL(z_name); + value = ZSTR_VAL(z_value); + retval = weechat_infolist_new_var_string (item, (const char *)name, (const char *)value); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_infolist_new_var_time) +{ + API_FUNC_INIT(weechat_infolist_new_var_time); + zend_string *z_item; + zend_string *z_name; + zend_long z_time; + struct t_infolist_var *retval; + struct t_infolist_item *item; + char *name; + time_t time; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl", &z_item, &z_name, &z_time) == FAILURE) + { + return; + } + item = (struct t_infolist_item *)API_STR2PTR(ZSTR_VAL(z_item)); + name = ZSTR_VAL(z_name); + time = (time_t)z_time; + retval = weechat_infolist_new_var_time (item, (const char *)name, time); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_infolist_next) +{ + API_FUNC_INIT(weechat_infolist_next); + zend_string *z_infolist; + int retval; + struct t_infolist *infolist; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_infolist) == FAILURE) + { + return; + } + infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist)); + retval = weechat_infolist_next (infolist); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_infolist_pointer) +{ + API_FUNC_INIT(weechat_infolist_pointer); + zend_string *z_infolist; + zend_string *z_var; + void *retval; + struct t_infolist *infolist; + char *var; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_infolist, &z_var) == FAILURE) + { + return; + } + infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist)); + var = ZSTR_VAL(z_var); + retval = weechat_infolist_pointer (infolist, (const char *)var); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_infolist_prev) +{ + API_FUNC_INIT(weechat_infolist_prev); + zend_string *z_infolist; + int retval; + struct t_infolist *infolist; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_infolist) == FAILURE) + { + return; + } + infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist)); + retval = weechat_infolist_prev (infolist); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_infolist_reset_item_cursor) +{ + API_FUNC_INIT(weechat_infolist_reset_item_cursor); + zend_string *z_infolist; + struct t_infolist *infolist; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_infolist) == FAILURE) + { + return; + } + infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist)); + weechat_infolist_reset_item_cursor (infolist); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_infolist_search_var) +{ + API_FUNC_INIT(weechat_infolist_search_var); + zend_string *z_infolist; + zend_string *z_name; + struct t_infolist_var *retval; + struct t_infolist *infolist; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_infolist, &z_name) == FAILURE) + { + return; + } + infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist)); + name = ZSTR_VAL(z_name); + retval = weechat_infolist_search_var (infolist, (const char *)name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_infolist_string) +{ + API_FUNC_INIT(weechat_infolist_string); + zend_string *z_infolist; + zend_string *z_var; + const char *retval; + struct t_infolist *infolist; + char *var; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_infolist, &z_var) == FAILURE) + { + return; + } + infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist)); + var = ZSTR_VAL(z_var); + retval = weechat_infolist_string (infolist, (const char *)var); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_infolist_time) +{ + API_FUNC_INIT(weechat_infolist_time); + zend_string *z_infolist; + zend_string *z_var; + time_t retval; + struct t_infolist *infolist; + char *var; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_infolist, &z_var) == FAILURE) + { + return; + } + infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist)); + var = ZSTR_VAL(z_var); + retval = weechat_infolist_time (infolist, (const char *)var); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_key_bind) +{ + API_FUNC_INIT(weechat_key_bind); + zend_string *z_context; + zval *z_keys; + int retval; + char *context; + struct t_hashtable *keys; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sa", &z_context, &z_keys) == FAILURE) + { + return; + } + context = ZSTR_VAL(z_context); + keys = weechat_php_array_to_hashtable(z_keys, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); + retval = weechat_key_bind ((const char *)context, keys); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_key_unbind) +{ + API_FUNC_INIT(weechat_key_unbind); + zend_string *z_context; + zend_string *z_key; + int retval; + char *context; + char *key; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_context, &z_key) == FAILURE) + { + return; + } + context = ZSTR_VAL(z_context); + key = ZSTR_VAL(z_key); + retval = weechat_key_unbind ((const char *)context, (const char *)key); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_list_add) +{ + API_FUNC_INIT(weechat_list_add); + zend_string *z_weelist; + zend_string *z_data; + zend_string *z_where; + zend_string *z_user_data; + struct t_weelist_item *retval; + struct t_weelist *weelist; + char *data; + char *where; + void *user_data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSS", &z_weelist, &z_data, &z_where, &z_user_data) == FAILURE) + { + return; + } + weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist)); + data = ZSTR_VAL(z_data); + where = ZSTR_VAL(z_where); + user_data = (void *)API_STR2PTR(ZSTR_VAL(z_user_data)); + retval = weechat_list_add (weelist, (const char *)data, (const char *)where, user_data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_list_casesearch) +{ + API_FUNC_INIT(weechat_list_casesearch); + zend_string *z_weelist; + zend_string *z_data; + struct t_weelist_item *retval; + struct t_weelist *weelist; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_weelist, &z_data) == FAILURE) + { + return; + } + weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist)); + data = ZSTR_VAL(z_data); + retval = weechat_list_casesearch (weelist, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_list_casesearch_pos) +{ + API_FUNC_INIT(weechat_list_casesearch_pos); + zend_string *z_weelist; + zend_string *z_data; + int retval; + struct t_weelist *weelist; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_weelist, &z_data) == FAILURE) + { + return; + } + weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist)); + data = ZSTR_VAL(z_data); + retval = weechat_list_casesearch_pos (weelist, (const char *)data); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_list_free) +{ + API_FUNC_INIT(weechat_list_free); + zend_string *z_weelist; + struct t_weelist *weelist; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_weelist) == FAILURE) + { + return; + } + weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist)); + weechat_list_free (weelist); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_list_get) +{ + API_FUNC_INIT(weechat_list_get); + zend_string *z_weelist; + zend_long z_position; + struct t_weelist_item *retval; + struct t_weelist *weelist; + int position; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl", &z_weelist, &z_position) == FAILURE) + { + return; + } + weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist)); + position = (int)z_position; + retval = weechat_list_get (weelist, position); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_list_new) +{ + API_FUNC_INIT(weechat_list_new); + struct t_weelist *retval; + if (zend_parse_parameters_none () == FAILURE) + { + return; + } + retval = weechat_list_new (); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_list_next) +{ + API_FUNC_INIT(weechat_list_next); + zend_string *z_item; + struct t_weelist_item *retval; + struct t_weelist_item *item; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_item) == FAILURE) + { + return; + } + item = (struct t_weelist_item *)API_STR2PTR(ZSTR_VAL(z_item)); + retval = weechat_list_next (item); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_list_prev) +{ + API_FUNC_INIT(weechat_list_prev); + zend_string *z_item; + struct t_weelist_item *retval; + struct t_weelist_item *item; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_item) == FAILURE) + { + return; + } + item = (struct t_weelist_item *)API_STR2PTR(ZSTR_VAL(z_item)); + retval = weechat_list_prev (item); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_list_remove) +{ + API_FUNC_INIT(weechat_list_remove); + zend_string *z_weelist; + zend_string *z_item; + struct t_weelist *weelist; + struct t_weelist_item *item; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_weelist, &z_item) == FAILURE) + { + return; + } + weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist)); + item = (struct t_weelist_item *)API_STR2PTR(ZSTR_VAL(z_item)); + weechat_list_remove (weelist, item); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_list_remove_all) +{ + API_FUNC_INIT(weechat_list_remove_all); + zend_string *z_weelist; + struct t_weelist *weelist; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_weelist) == FAILURE) + { + return; + } + weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist)); + weechat_list_remove_all (weelist); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_list_search) +{ + API_FUNC_INIT(weechat_list_search); + zend_string *z_weelist; + zend_string *z_data; + struct t_weelist_item *retval; + struct t_weelist *weelist; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_weelist, &z_data) == FAILURE) + { + return; + } + weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist)); + data = ZSTR_VAL(z_data); + retval = weechat_list_search (weelist, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_list_search_pos) +{ + API_FUNC_INIT(weechat_list_search_pos); + zend_string *z_weelist; + zend_string *z_data; + int retval; + struct t_weelist *weelist; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_weelist, &z_data) == FAILURE) + { + return; + } + weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist)); + data = ZSTR_VAL(z_data); + retval = weechat_list_search_pos (weelist, (const char *)data); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_list_set) +{ + API_FUNC_INIT(weechat_list_set); + zend_string *z_item; + zend_string *z_value; + struct t_weelist_item *item; + char *value; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_item, &z_value) == FAILURE) + { + return; + } + item = (struct t_weelist_item *)API_STR2PTR(ZSTR_VAL(z_item)); + value = ZSTR_VAL(z_value); + weechat_list_set (item, (const char *)value); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_list_size) +{ + API_FUNC_INIT(weechat_list_size); + zend_string *z_weelist; + int retval; + struct t_weelist *weelist; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_weelist) == FAILURE) + { + return; + } + weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist)); + retval = weechat_list_size (weelist); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_list_string) +{ + API_FUNC_INIT(weechat_list_string); + zend_string *z_item; + const char *retval; + struct t_weelist_item *item; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_item) == FAILURE) + { + return; + } + item = (struct t_weelist_item *)API_STR2PTR(ZSTR_VAL(z_item)); + retval = weechat_list_string (item); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_mkdir) +{ + API_FUNC_INIT(weechat_mkdir); + zend_string *z_directory; + zend_long z_mode; + int retval; + char *directory; + int mode; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl", &z_directory, &z_mode) == FAILURE) + { + return; + } + directory = ZSTR_VAL(z_directory); + mode = (int)z_mode; + retval = weechat_mkdir ((const char *)directory, mode); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_mkdir_home) +{ + API_FUNC_INIT(weechat_mkdir_home); + zend_string *z_directory; + zend_long z_mode; + int retval; + char *directory; + int mode; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl", &z_directory, &z_mode) == FAILURE) + { + return; + } + directory = ZSTR_VAL(z_directory); + mode = (int)z_mode; + retval = weechat_mkdir_home ((const char *)directory, mode); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_mkdir_parents) +{ + API_FUNC_INIT(weechat_mkdir_parents); + zend_string *z_directory; + zend_long z_mode; + int retval; + char *directory; + int mode; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl", &z_directory, &z_mode) == FAILURE) + { + return; + } + directory = ZSTR_VAL(z_directory); + mode = (int)z_mode; + retval = weechat_mkdir_parents ((const char *)directory, mode); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_ngettext) +{ + API_FUNC_INIT(weechat_ngettext); + zend_string *z_single; + zend_string *z_plural; + zend_long z_count; + const char *retval; + char *single; + char *plural; + int count; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl", &z_single, &z_plural, &z_count) == FAILURE) + { + return; + } + single = ZSTR_VAL(z_single); + plural = ZSTR_VAL(z_plural); + count = (int)z_count; + retval = weechat_ngettext ((const char *)single, (const char *)plural, count); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_nicklist_add_group) +{ + API_FUNC_INIT(weechat_nicklist_add_group); + zend_string *z_buffer; + zend_string *z_parent_group; + zend_string *z_name; + zend_string *z_color; + zend_long z_visible; + struct t_gui_nick_group *retval; + struct t_gui_buffer *buffer; + struct t_gui_nick_group *parent_group; + char *name; + char *color; + int visible; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSl", &z_buffer, &z_parent_group, &z_name, &z_color, &z_visible) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + parent_group = (struct t_gui_nick_group *)API_STR2PTR(ZSTR_VAL(z_parent_group)); + name = ZSTR_VAL(z_name); + color = ZSTR_VAL(z_color); + visible = (int)z_visible; + retval = weechat_nicklist_add_group (buffer, parent_group, (const char *)name, (const char *)color, visible); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_nicklist_add_nick) +{ + API_FUNC_INIT(weechat_nicklist_add_nick); + zend_string *z_buffer; + zend_string *z_group; + zend_string *z_name; + zend_string *z_color; + zend_string *z_prefix; + zend_string *z_prefix_color; + zend_long z_visible; + struct t_gui_nick *retval; + struct t_gui_buffer *buffer; + struct t_gui_nick_group *group; + char *name; + char *color; + char *prefix; + char *prefix_color; + int visible; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSSSl", &z_buffer, &z_group, &z_name, &z_color, &z_prefix, &z_prefix_color, &z_visible) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + group = (struct t_gui_nick_group *)API_STR2PTR(ZSTR_VAL(z_group)); + name = ZSTR_VAL(z_name); + color = ZSTR_VAL(z_color); + prefix = ZSTR_VAL(z_prefix); + prefix_color = ZSTR_VAL(z_prefix_color); + visible = (int)z_visible; + retval = weechat_nicklist_add_nick (buffer, group, (const char *)name, (const char *)color, (const char *)prefix, (const char *)prefix_color, visible); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_nicklist_group_get_integer) +{ + API_FUNC_INIT(weechat_nicklist_group_get_integer); + zend_string *z_buffer; + zend_string *z_group; + zend_string *z_property; + int retval; + struct t_gui_buffer *buffer; + struct t_gui_nick_group *group; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_group, &z_property) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + group = (struct t_gui_nick_group *)API_STR2PTR(ZSTR_VAL(z_group)); + property = ZSTR_VAL(z_property); + retval = weechat_nicklist_group_get_integer (buffer, group, (const char *)property); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_nicklist_group_get_pointer) +{ + API_FUNC_INIT(weechat_nicklist_group_get_pointer); + zend_string *z_buffer; + zend_string *z_group; + zend_string *z_property; + void *retval; + struct t_gui_buffer *buffer; + struct t_gui_nick_group *group; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_group, &z_property) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + group = (struct t_gui_nick_group *)API_STR2PTR(ZSTR_VAL(z_group)); + property = ZSTR_VAL(z_property); + retval = weechat_nicklist_group_get_pointer (buffer, group, (const char *)property); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_nicklist_group_get_string) +{ + API_FUNC_INIT(weechat_nicklist_group_get_string); + zend_string *z_buffer; + zend_string *z_group; + zend_string *z_property; + const char *retval; + struct t_gui_buffer *buffer; + struct t_gui_nick_group *group; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_group, &z_property) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + group = (struct t_gui_nick_group *)API_STR2PTR(ZSTR_VAL(z_group)); + property = ZSTR_VAL(z_property); + retval = weechat_nicklist_group_get_string (buffer, group, (const char *)property); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_nicklist_group_set) +{ + API_FUNC_INIT(weechat_nicklist_group_set); + zend_string *z_buffer; + zend_string *z_group; + zend_string *z_property; + zend_string *z_value; + struct t_gui_buffer *buffer; + struct t_gui_nick_group *group; + char *property; + char *value; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSS", &z_buffer, &z_group, &z_property, &z_value) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + group = (struct t_gui_nick_group *)API_STR2PTR(ZSTR_VAL(z_group)); + property = ZSTR_VAL(z_property); + value = ZSTR_VAL(z_value); + weechat_nicklist_group_set (buffer, group, (const char *)property, (const char *)value); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_nicklist_nick_get_integer) +{ + API_FUNC_INIT(weechat_nicklist_nick_get_integer); + zend_string *z_buffer; + zend_string *z_nick; + zend_string *z_property; + int retval; + struct t_gui_buffer *buffer; + struct t_gui_nick *nick; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_nick, &z_property) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + nick = (struct t_gui_nick *)API_STR2PTR(ZSTR_VAL(z_nick)); + property = ZSTR_VAL(z_property); + retval = weechat_nicklist_nick_get_integer (buffer, nick, (const char *)property); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_nicklist_nick_get_pointer) +{ + API_FUNC_INIT(weechat_nicklist_nick_get_pointer); + zend_string *z_buffer; + zend_string *z_nick; + zend_string *z_property; + void *retval; + struct t_gui_buffer *buffer; + struct t_gui_nick *nick; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_nick, &z_property) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + nick = (struct t_gui_nick *)API_STR2PTR(ZSTR_VAL(z_nick)); + property = ZSTR_VAL(z_property); + retval = weechat_nicklist_nick_get_pointer (buffer, nick, (const char *)property); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_nicklist_nick_get_string) +{ + API_FUNC_INIT(weechat_nicklist_nick_get_string); + zend_string *z_buffer; + zend_string *z_nick; + zend_string *z_property; + const char *retval; + struct t_gui_buffer *buffer; + struct t_gui_nick *nick; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_nick, &z_property) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + nick = (struct t_gui_nick *)API_STR2PTR(ZSTR_VAL(z_nick)); + property = ZSTR_VAL(z_property); + retval = weechat_nicklist_nick_get_string (buffer, nick, (const char *)property); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_nicklist_nick_set) +{ + API_FUNC_INIT(weechat_nicklist_nick_set); + zend_string *z_buffer; + zend_string *z_nick; + zend_string *z_property; + zend_string *z_value; + struct t_gui_buffer *buffer; + struct t_gui_nick *nick; + char *property; + char *value; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSS", &z_buffer, &z_nick, &z_property, &z_value) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + nick = (struct t_gui_nick *)API_STR2PTR(ZSTR_VAL(z_nick)); + property = ZSTR_VAL(z_property); + value = ZSTR_VAL(z_value); + weechat_nicklist_nick_set (buffer, nick, (const char *)property, (const char *)value); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_nicklist_remove_all) +{ + API_FUNC_INIT(weechat_nicklist_remove_all); + zend_string *z_buffer; + struct t_gui_buffer *buffer; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_buffer) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + weechat_nicklist_remove_all (buffer); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_nicklist_remove_group) +{ + API_FUNC_INIT(weechat_nicklist_remove_group); + zend_string *z_buffer; + zend_string *z_group; + struct t_gui_buffer *buffer; + struct t_gui_nick_group *group; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer, &z_group) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + group = (struct t_gui_nick_group *)API_STR2PTR(ZSTR_VAL(z_group)); + weechat_nicklist_remove_group (buffer, group); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_nicklist_remove_nick) +{ + API_FUNC_INIT(weechat_nicklist_remove_nick); + zend_string *z_buffer; + zend_string *z_nick; + struct t_gui_buffer *buffer; + struct t_gui_nick *nick; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer, &z_nick) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + nick = (struct t_gui_nick *)API_STR2PTR(ZSTR_VAL(z_nick)); + weechat_nicklist_remove_nick (buffer, nick); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_nicklist_search_group) +{ + API_FUNC_INIT(weechat_nicklist_search_group); + zend_string *z_buffer; + zend_string *z_from_group; + zend_string *z_name; + struct t_gui_nick_group *retval; + struct t_gui_buffer *buffer; + struct t_gui_nick_group *from_group; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_from_group, &z_name) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + from_group = (struct t_gui_nick_group *)API_STR2PTR(ZSTR_VAL(z_from_group)); + name = ZSTR_VAL(z_name); + retval = weechat_nicklist_search_group (buffer, from_group, (const char *)name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_nicklist_search_nick) +{ + API_FUNC_INIT(weechat_nicklist_search_nick); + zend_string *z_buffer; + zend_string *z_from_group; + zend_string *z_name; + struct t_gui_nick *retval; + struct t_gui_buffer *buffer; + struct t_gui_nick_group *from_group; + char *name; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_from_group, &z_name) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + from_group = (struct t_gui_nick_group *)API_STR2PTR(ZSTR_VAL(z_from_group)); + name = ZSTR_VAL(z_name); + retval = weechat_nicklist_search_nick (buffer, from_group, (const char *)name); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_plugin_get_name) +{ + API_FUNC_INIT(weechat_plugin_get_name); + const char *retval; + if (zend_parse_parameters_none () == FAILURE) + { + return; + } + retval = weechat_plugin_get_name (weechat_php_plugin); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_bar_item_new) +{ + API_FUNC_INIT(weechat_bar_item_new); + zend_string *z_name; + zval *z_build_callback; + zend_string *z_data; + struct t_gui_bar_item *retval; + char *name; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_name, &z_build_callback, &z_data) == FAILURE) + { + return; + } + name = ZSTR_VAL(z_name); + weechat_php_get_function_name (z_build_callback, build_callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_bar_item_new (weechat_php_plugin, php_current_script, (const char *)name, weechat_php_bar_item_new_build_callback, (const char *)build_callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_buffer_new) +{ + API_FUNC_INIT(weechat_buffer_new); + zend_string *z_name; + zval *z_input_callback; + zend_string *z_data_input; + zval *z_close_callback; + zend_string *z_data_close; + struct t_gui_buffer *retval; + char *name; + char *data_input; + char *data_close; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzSzS", &z_name, &z_input_callback, &z_data_input, &z_close_callback, &z_data_close) == FAILURE) + { + return; + } + name = ZSTR_VAL(z_name); + weechat_php_get_function_name (z_input_callback, input_callback_name); + data_input = ZSTR_VAL(z_data_input); + weechat_php_get_function_name (z_close_callback, close_callback_name); + data_close = ZSTR_VAL(z_data_close); + retval = plugin_script_api_buffer_new (weechat_php_plugin, php_current_script, (const char *)name, weechat_php_buffer_new_input_callback, (const char *)input_callback_name, (const char *)data_input, weechat_php_buffer_new_close_callback, (const char *)close_callback_name, (const char *)data_close); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_charset_set) +{ + API_FUNC_INIT(weechat_charset_set); + zend_string *z_charset; + char *charset; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_charset) == FAILURE) + { + return; + } + charset = ZSTR_VAL(z_charset); + plugin_script_api_charset_set (php_current_script, (const char *)charset); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_command) +{ + API_FUNC_INIT(weechat_command); + zend_string *z_buffer; + zend_string *z_command; + int retval; + struct t_gui_buffer *buffer; + char *command; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer, &z_command) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + command = ZSTR_VAL(z_command); + retval = plugin_script_api_command (weechat_php_plugin, php_current_script, buffer, (const char *)command); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_get_plugin) +{ + API_FUNC_INIT(weechat_config_get_plugin); + zend_string *z_option; + const char *retval; + char *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = ZSTR_VAL(z_option); + retval = plugin_script_api_config_get_plugin (weechat_php_plugin, php_current_script, (const char *)option); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_config_is_set_plugin) +{ + API_FUNC_INIT(weechat_config_is_set_plugin); + zend_string *z_option; + int retval; + char *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = ZSTR_VAL(z_option); + retval = plugin_script_api_config_is_set_plugin (weechat_php_plugin, php_current_script, (const char *)option); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_new) +{ + API_FUNC_INIT(weechat_config_new); + zend_string *z_name; + zval *z_callback_reload; + zend_string *z_data; + struct t_config_file *retval; + char *name; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_name, &z_callback_reload, &z_data) == FAILURE) + { + return; + } + name = ZSTR_VAL(z_name); + weechat_php_get_function_name (z_callback_reload, callback_reload_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_config_new (weechat_php_plugin, php_current_script, (const char *)name, weechat_php_config_new_callback_reload, (const char *)callback_reload_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_config_new_option) +{ + API_FUNC_INIT(weechat_config_new_option); + zend_string *z_config_file; + zend_string *z_section; + zend_string *z_name; + zend_string *z_type; + zend_string *z_description; + zend_string *z_string_values; + zend_long z_min; + zend_long z_max; + zend_string *z_default_value; + zend_string *z_value; + zend_long z_null_value_allowed; + zval *z_callback_check_value; + zend_string *z_data_check_value; + zval *z_callback_change; + zend_string *z_data_change; + zval *z_callback_delete; + zend_string *z_data_delete; + struct t_config_option *retval; + struct t_config_file *config_file; + struct t_config_section *section; + char *name; + char *type; + char *description; + char *string_values; + int min; + int max; + char *default_value; + char *value; + int null_value_allowed; + char *data_check_value; + char *data_change; + char *data_delete; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSSSllSSlzSzSzS", &z_config_file, &z_section, &z_name, &z_type, &z_description, &z_string_values, &z_min, &z_max, &z_default_value, &z_value, &z_null_value_allowed, &z_callback_check_value, &z_data_check_value, &z_callback_change, &z_data_change, &z_callback_delete, &z_data_delete) == FAILURE) + { + return; + } + config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file)); + section = (struct t_config_section *)API_STR2PTR(ZSTR_VAL(z_section)); + name = ZSTR_VAL(z_name); + type = ZSTR_VAL(z_type); + description = ZSTR_VAL(z_description); + string_values = ZSTR_VAL(z_string_values); + min = (int)z_min; + max = (int)z_max; + default_value = ZSTR_VAL(z_default_value); + value = ZSTR_VAL(z_value); + null_value_allowed = (int)z_null_value_allowed; + weechat_php_get_function_name (z_callback_check_value, callback_check_value_name); + data_check_value = ZSTR_VAL(z_data_check_value); + weechat_php_get_function_name (z_callback_change, callback_change_name); + data_change = ZSTR_VAL(z_data_change); + weechat_php_get_function_name (z_callback_delete, callback_delete_name); + data_delete = ZSTR_VAL(z_data_delete); + retval = plugin_script_api_config_new_option (weechat_php_plugin, php_current_script, config_file, section, (const char *)name, (const char *)type, (const char *)description, (const char *)string_values, min, max, (const char *)default_value, (const char *)value, null_value_allowed, weechat_php_config_new_option_callback_check_value, (const char *)callback_check_value_name, (const char *)data_check_value, weechat_php_config_new_option_callback_change, (const char *)callback_change_name, (const char *)data_change, weechat_php_config_new_option_callback_delete, (const char *)callback_delete_name, (const char *)data_delete); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_config_new_section) +{ + API_FUNC_INIT(weechat_config_new_section); + zend_string *z_config_file; + zend_string *z_name; + zend_long z_user_can_add_options; + zend_long z_user_can_delete_options; + zval *z_callback_read; + zend_string *z_data_read; + zval *z_callback_write; + zend_string *z_data_write; + zval *z_callback_write_default; + zend_string *z_data_write_default; + zval *z_callback_create_option; + zend_string *z_data_create_option; + zval *z_callback_delete_option; + zend_string *z_data_delete_option; + struct t_config_section *retval; + struct t_config_file *config_file; + char *name; + int user_can_add_options; + int user_can_delete_options; + char *data_read; + char *data_write; + char *data_write_default; + char *data_create_option; + char *data_delete_option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSllzSzSzSzSzS", &z_config_file, &z_name, &z_user_can_add_options, &z_user_can_delete_options, &z_callback_read, &z_data_read, &z_callback_write, &z_data_write, &z_callback_write_default, &z_data_write_default, &z_callback_create_option, &z_data_create_option, &z_callback_delete_option, &z_data_delete_option) == FAILURE) + { + return; + } + config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file)); + name = ZSTR_VAL(z_name); + user_can_add_options = (int)z_user_can_add_options; + user_can_delete_options = (int)z_user_can_delete_options; + weechat_php_get_function_name (z_callback_read, callback_read_name); + data_read = ZSTR_VAL(z_data_read); + weechat_php_get_function_name (z_callback_write, callback_write_name); + data_write = ZSTR_VAL(z_data_write); + weechat_php_get_function_name (z_callback_write_default, callback_write_default_name); + data_write_default = ZSTR_VAL(z_data_write_default); + weechat_php_get_function_name (z_callback_create_option, callback_create_option_name); + data_create_option = ZSTR_VAL(z_data_create_option); + weechat_php_get_function_name (z_callback_delete_option, callback_delete_option_name); + data_delete_option = ZSTR_VAL(z_data_delete_option); + retval = plugin_script_api_config_new_section (weechat_php_plugin, php_current_script, config_file, (const char *)name, user_can_add_options, user_can_delete_options, weechat_php_config_new_section_callback_read, (const char *)callback_read_name, (const char *)data_read, weechat_php_config_new_section_callback_write, (const char *)callback_write_name, (const char *)data_write, weechat_php_config_new_section_callback_write_default, (const char *)callback_write_default_name, (const char *)data_write_default, weechat_php_config_new_section_callback_create_option, (const char *)callback_create_option_name, (const char *)data_create_option, weechat_php_config_new_section_callback_delete_option, (const char *)callback_delete_option_name, (const char *)data_delete_option); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_config_set_desc_plugin) +{ + API_FUNC_INIT(weechat_config_set_desc_plugin); + zend_string *z_option; + zend_string *z_description; + char *option; + char *description; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_option, &z_description) == FAILURE) + { + return; + } + option = ZSTR_VAL(z_option); + description = ZSTR_VAL(z_description); + plugin_script_api_config_set_desc_plugin (weechat_php_plugin, php_current_script, (const char *)option, (const char *)description); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_config_set_plugin) +{ + API_FUNC_INIT(weechat_config_set_plugin); + zend_string *z_option; + zend_string *z_value; + int retval; + char *option; + char *value; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_option, &z_value) == FAILURE) + { + return; + } + option = ZSTR_VAL(z_option); + value = ZSTR_VAL(z_value); + retval = plugin_script_api_config_set_plugin (weechat_php_plugin, php_current_script, (const char *)option, (const char *)value); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_config_unset_plugin) +{ + API_FUNC_INIT(weechat_config_unset_plugin); + zend_string *z_option; + int retval; + char *option; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE) + { + return; + } + option = ZSTR_VAL(z_option); + retval = plugin_script_api_config_unset_plugin (weechat_php_plugin, php_current_script, (const char *)option); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_hook_command) +{ + API_FUNC_INIT(weechat_hook_command); + zend_string *z_command; + zend_string *z_description; + zend_string *z_args; + zend_string *z_args_description; + zend_string *z_completion; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *command; + char *description; + char *args; + char *args_description; + char *completion; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSSzS", &z_command, &z_description, &z_args, &z_args_description, &z_completion, &z_callback, &z_data) == FAILURE) + { + return; + } + command = ZSTR_VAL(z_command); + description = ZSTR_VAL(z_description); + args = ZSTR_VAL(z_args); + args_description = ZSTR_VAL(z_args_description); + completion = ZSTR_VAL(z_completion); + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_command (weechat_php_plugin, php_current_script, (const char *)command, (const char *)description, (const char *)args, (const char *)args_description, (const char *)completion, weechat_php_hook_command_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_command_run) +{ + API_FUNC_INIT(weechat_hook_command_run); + zend_string *z_command; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *command; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_command, &z_callback, &z_data) == FAILURE) + { + return; + } + command = ZSTR_VAL(z_command); + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_command_run (weechat_php_plugin, php_current_script, (const char *)command, weechat_php_hook_command_run_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_completion) +{ + API_FUNC_INIT(weechat_hook_completion); + zend_string *z_completion; + zend_string *z_description; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *completion; + char *description; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSzS", &z_completion, &z_description, &z_callback, &z_data) == FAILURE) + { + return; + } + completion = ZSTR_VAL(z_completion); + description = ZSTR_VAL(z_description); + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_completion (weechat_php_plugin, php_current_script, (const char *)completion, (const char *)description, weechat_php_hook_completion_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_config) +{ + API_FUNC_INIT(weechat_hook_config); + zend_string *z_option; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *option; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_option, &z_callback, &z_data) == FAILURE) + { + return; + } + option = ZSTR_VAL(z_option); + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_config (weechat_php_plugin, php_current_script, (const char *)option, weechat_php_hook_config_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_connect) +{ + API_FUNC_INIT(weechat_hook_connect); + zend_string *z_proxy; + zend_string *z_address; + zend_long z_port; + zend_long z_ipv6; + zend_long z_retry; + zend_string *z_gnutls_sess; + zend_string *z_gnutls_cb; + zend_long z_gnutls_dhkey_size; + zend_string *z_gnutls_priorities; + zend_string *z_local_hostname; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *proxy; + char *address; + int port; + int ipv6; + int retry; + void *gnutls_sess; + void *gnutls_cb; + int gnutls_dhkey_size; + char *gnutls_priorities; + char *local_hostname; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSlllSSlSSzS", &z_proxy, &z_address, &z_port, &z_ipv6, &z_retry, &z_gnutls_sess, &z_gnutls_cb, &z_gnutls_dhkey_size, &z_gnutls_priorities, &z_local_hostname, &z_callback, &z_data) == FAILURE) + { + return; + } + proxy = ZSTR_VAL(z_proxy); + address = ZSTR_VAL(z_address); + port = (int)z_port; + ipv6 = (int)z_ipv6; + retry = (int)z_retry; + gnutls_sess = (void *)API_STR2PTR(ZSTR_VAL(z_gnutls_sess)); + gnutls_cb = (void *)API_STR2PTR(ZSTR_VAL(z_gnutls_cb)); + gnutls_dhkey_size = (int)z_gnutls_dhkey_size; + gnutls_priorities = ZSTR_VAL(z_gnutls_priorities); + local_hostname = ZSTR_VAL(z_local_hostname); + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_connect (weechat_php_plugin, php_current_script, (const char *)proxy, (const char *)address, port, ipv6, retry, gnutls_sess, gnutls_cb, gnutls_dhkey_size, (const char *)gnutls_priorities, (const char *)local_hostname, weechat_php_hook_connect_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_fd) +{ + API_FUNC_INIT(weechat_hook_fd); + zend_long z_fd; + zend_long z_flag_read; + zend_long z_flag_write; + zend_long z_flag_exception; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + int fd; + int flag_read; + int flag_write; + int flag_exception; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "llllzS", &z_fd, &z_flag_read, &z_flag_write, &z_flag_exception, &z_callback, &z_data) == FAILURE) + { + return; + } + fd = (int)z_fd; + flag_read = (int)z_flag_read; + flag_write = (int)z_flag_write; + flag_exception = (int)z_flag_exception; + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_fd (weechat_php_plugin, php_current_script, fd, flag_read, flag_write, flag_exception, weechat_php_hook_fd_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_focus) +{ + API_FUNC_INIT(weechat_hook_focus); + zend_string *z_area; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *area; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_area, &z_callback, &z_data) == FAILURE) + { + return; + } + area = ZSTR_VAL(z_area); + data = ZSTR_VAL(z_data); + weechat_php_get_function_name (z_callback, callback_name); + retval = plugin_script_api_hook_focus (weechat_php_plugin, + php_current_script, + area, + weechat_php_api_hook_focus_callback, + callback_name, + data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_hsignal) +{ + API_FUNC_INIT(weechat_hook_hsignal); + zend_string *z_signal; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *signal; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_signal, &z_callback, &z_data) == FAILURE) + { + return; + } + signal = ZSTR_VAL(z_signal); + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_hsignal (weechat_php_plugin, php_current_script, (const char *)signal, weechat_php_hook_hsignal_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_info) +{ + API_FUNC_INIT(weechat_hook_info); + zend_string *z_info_name; + zend_string *z_description; + zend_string *z_args_description; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *info_name; + char *description; + char *args_description; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSzS", &z_info_name, &z_description, &z_args_description, &z_callback, &z_data) == FAILURE) + { + return; + } + info_name = ZSTR_VAL(z_info_name); + description = ZSTR_VAL(z_description); + args_description = ZSTR_VAL(z_args_description); + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_info (weechat_php_plugin, php_current_script, (const char *)info_name, (const char *)description, (const char *)args_description, weechat_php_hook_info_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_info_hashtable) +{ + API_FUNC_INIT(weechat_hook_info_hashtable); + zend_string *z_info_name; + zend_string *z_description; + zend_string *z_args_description; + zend_string *z_output_description; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *info_name; + char *description; + char *args_description; + char *output_description; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSSzS", &z_info_name, &z_description, &z_args_description, &z_output_description, &z_callback, &z_data) == FAILURE) + { + return; + } + info_name = ZSTR_VAL(z_info_name); + description = ZSTR_VAL(z_description); + args_description = ZSTR_VAL(z_args_description); + output_description = ZSTR_VAL(z_output_description); + data = ZSTR_VAL(z_data); + weechat_php_get_function_name (z_callback, callback_name); + retval = plugin_script_api_hook_info_hashtable (weechat_php_plugin, + php_current_script, + info_name, + description, + args_description, + output_description, + weechat_php_api_hook_info_hashtable_callback, + callback_name, + data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_infolist) +{ + API_FUNC_INIT(weechat_hook_infolist); + zend_string *z_infolist_name; + zend_string *z_description; + zend_string *z_pointer_description; + zend_string *z_args_description; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *infolist_name; + char *description; + char *pointer_description; + char *args_description; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSzS", &z_infolist_name, &z_description, &z_pointer_description, &z_args_description, &z_callback, &z_data) == FAILURE) + { + return; + } + infolist_name = ZSTR_VAL(z_infolist_name); + description = ZSTR_VAL(z_description); + pointer_description = ZSTR_VAL(z_pointer_description); + args_description = ZSTR_VAL(z_args_description); + data = ZSTR_VAL(z_data); + weechat_php_get_function_name(z_callback, callback_name); + retval = plugin_script_api_hook_infolist (weechat_php_plugin, + php_current_script, + infolist_name, + description, + pointer_description, + args_description, + weechat_php_api_hook_infolist_callback, + callback_name, + data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_modifier) +{ + API_FUNC_INIT(weechat_hook_modifier); + zend_string *z_modifier; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *modifier; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_modifier, &z_callback, &z_data) == FAILURE) + { + return; + } + modifier = ZSTR_VAL(z_modifier); + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_modifier (weechat_php_plugin, php_current_script, (const char *)modifier, weechat_php_hook_modifier_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_print) +{ + API_FUNC_INIT(weechat_hook_print); + zend_string *z_buffer; + zend_string *z_tags; + zend_string *z_message; + zend_long z_strip_colors; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + struct t_gui_buffer *buffer; + char *tags; + char *message; + int strip_colors; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSlzS", &z_buffer, &z_tags, &z_message, &z_strip_colors, &z_callback, &z_data) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + tags = ZSTR_VAL(z_tags); + message = ZSTR_VAL(z_message); + strip_colors = (int)z_strip_colors; + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_print (weechat_php_plugin, php_current_script, buffer, (const char *)tags, (const char *)message, strip_colors, weechat_php_hook_print_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_process) +{ + API_FUNC_INIT(weechat_hook_process); + zend_string *z_command; + zend_long z_timeout; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *command; + int timeout; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SlzS", &z_command, &z_timeout, &z_callback, &z_data) == FAILURE) + { + return; + } + command = ZSTR_VAL(z_command); + timeout = (int)z_timeout; + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_process (weechat_php_plugin, php_current_script, (const char *)command, timeout, weechat_php_hook_process_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_process_hashtable) +{ + API_FUNC_INIT(weechat_hook_process_hashtable); + zend_string *z_command; + zval *z_options; + zend_long z_timeout; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *command; + struct t_hashtable *options; + int timeout; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SalzS", &z_command, &z_options, &z_timeout, &z_callback, &z_data) == FAILURE) + { + return; + } + command = ZSTR_VAL(z_command); + options = weechat_php_array_to_hashtable(z_options, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); + timeout = (int)z_timeout; + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_process_hashtable (weechat_php_plugin, php_current_script, (const char *)command, options, timeout, weechat_php_hook_process_hashtable_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_signal) +{ + API_FUNC_INIT(weechat_hook_signal); + zend_string *z_signal; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + char *signal; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_signal, &z_callback, &z_data) == FAILURE) + { + return; + } + signal = ZSTR_VAL(z_signal); + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_signal (weechat_php_plugin, php_current_script, (const char *)signal, weechat_php_hook_signal_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_hook_timer) +{ + API_FUNC_INIT(weechat_hook_timer); + zend_long z_interval; + zend_long z_align_second; + zend_long z_max_calls; + zval *z_callback; + zend_string *z_data; + struct t_hook *retval; + int interval; + int align_second; + int max_calls; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "lllzS", &z_interval, &z_align_second, &z_max_calls, &z_callback, &z_data) == FAILURE) + { + return; + } + interval = (int)z_interval; + align_second = (int)z_align_second; + max_calls = (int)z_max_calls; + weechat_php_get_function_name (z_callback, callback_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_hook_timer (weechat_php_plugin, php_current_script, interval, align_second, max_calls, weechat_php_hook_timer_callback, (const char *)callback_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_log_printf) +{ + API_FUNC_INIT(weechat_log_printf); + zend_string *z_format; + char *format; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_format) == FAILURE) + { + return; + } + format = ZSTR_VAL(z_format); + plugin_script_api_log_printf (weechat_php_plugin, php_current_script, "%s", format); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_printf) +{ + API_FUNC_INIT(weechat_printf); + zend_string *z_buffer; + zend_string *z_format; + struct t_gui_buffer *buffer; + char *format; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer, &z_format) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + format = ZSTR_VAL(z_format); + plugin_script_api_printf (weechat_php_plugin, php_current_script, buffer, "%s", format); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_printf_date_tags) +{ + API_FUNC_INIT(weechat_printf_date_tags); + zend_string *z_buffer; + zend_long z_date; + zend_string *z_tags; + zend_string *z_format; + struct t_gui_buffer *buffer; + time_t date; + char *tags; + char *format; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SlSS", &z_buffer, &z_date, &z_tags, &z_format) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + date = (time_t)z_date; + tags = ZSTR_VAL(z_tags); + format = ZSTR_VAL(z_format); + plugin_script_api_printf_date_tags (weechat_php_plugin, php_current_script, buffer, date, (const char *)tags, "%s", format); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_printf_y) +{ + API_FUNC_INIT(weechat_printf_y); + zend_string *z_buffer; + zend_long z_y; + zend_string *z_format; + struct t_gui_buffer *buffer; + int y; + char *format; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SlS", &z_buffer, &z_y, &z_format) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + y = (int)z_y; + format = ZSTR_VAL(z_format); + plugin_script_api_printf_y (weechat_php_plugin, php_current_script, buffer, y, "%s", format); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_upgrade_new) +{ + API_FUNC_INIT(weechat_upgrade_new); + zend_string *z_filename; + zval *z_callback_read; + zend_string *z_data; + struct t_upgrade_file *retval; + char *filename; + char *data; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_filename, &z_callback_read, &z_data) == FAILURE) + { + return; + } + filename = ZSTR_VAL(z_filename); + weechat_php_get_function_name (z_callback_read, callback_read_name); + data = ZSTR_VAL(z_data); + retval = plugin_script_api_upgrade_new (weechat_php_plugin, php_current_script, (const char *)filename, weechat_php_upgrade_new_callback_read, (const char *)callback_read_name, (const char *)data); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_prefix) +{ + API_FUNC_INIT(weechat_prefix); + zend_string *z_prefix; + const char *retval; + char *prefix; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_prefix) == FAILURE) + { + return; + } + prefix = ZSTR_VAL(z_prefix); + retval = weechat_prefix ((const char *)prefix); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_string_eval_expression) +{ + API_FUNC_INIT(weechat_string_eval_expression); + zend_string *z_expr; + zval *z_pointers; + zval *z_extra_vars; + zval *z_options; + char *retval; + char *expr; + struct t_hashtable *pointers; + struct t_hashtable *extra_vars; + struct t_hashtable *options; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "Saaa", &z_expr, &z_pointers, &z_extra_vars, &z_options) == FAILURE) + { + return; + } + expr = ZSTR_VAL(z_expr); + pointers = weechat_php_array_to_hashtable(z_pointers, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); + extra_vars = weechat_php_array_to_hashtable(z_extra_vars, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); + options = weechat_php_array_to_hashtable(z_options, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); + retval = weechat_string_eval_expression ((const char *)expr, pointers, extra_vars, options); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_string_eval_path_home) +{ + API_FUNC_INIT(weechat_string_eval_path_home); + zend_string *z_path; + zval *z_pointers; + zval *z_extra_vars; + zval *z_options; + char *retval; + char *path; + struct t_hashtable *pointers; + struct t_hashtable *extra_vars; + struct t_hashtable *options; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "Saaa", &z_path, &z_pointers, &z_extra_vars, &z_options) == FAILURE) + { + return; + } + path = ZSTR_VAL(z_path); + pointers = weechat_php_array_to_hashtable(z_pointers, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); + extra_vars = weechat_php_array_to_hashtable(z_extra_vars, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); + options = weechat_php_array_to_hashtable(z_options, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); + retval = weechat_string_eval_path_home ((const char *)path, pointers, extra_vars, options); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_string_has_highlight) +{ + API_FUNC_INIT(weechat_string_has_highlight); + zend_string *z_string; + zend_string *z_highlight_words; + int retval; + char *string; + char *highlight_words; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_string, &z_highlight_words) == FAILURE) + { + return; + } + string = ZSTR_VAL(z_string); + highlight_words = ZSTR_VAL(z_highlight_words); + retval = weechat_string_has_highlight ((const char *)string, (const char *)highlight_words); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_string_has_highlight_regex) +{ + API_FUNC_INIT(weechat_string_has_highlight_regex); + zend_string *z_string; + zend_string *z_regex; + int retval; + char *string; + char *regex; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_string, &z_regex) == FAILURE) + { + return; + } + string = ZSTR_VAL(z_string); + regex = ZSTR_VAL(z_regex); + retval = weechat_string_has_highlight_regex ((const char *)string, (const char *)regex); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_string_input_for_buffer) +{ + API_FUNC_INIT(weechat_string_input_for_buffer); + zend_string *z_string; + const char *retval; + char *string; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_string) == FAILURE) + { + return; + } + string = ZSTR_VAL(z_string); + retval = weechat_string_input_for_buffer ((const char *)string); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_string_is_command_char) +{ + API_FUNC_INIT(weechat_string_is_command_char); + zend_string *z_string; + int retval; + char *string; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_string) == FAILURE) + { + return; + } + string = ZSTR_VAL(z_string); + retval = weechat_string_is_command_char ((const char *)string); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_string_mask_to_regex) +{ + API_FUNC_INIT(weechat_string_mask_to_regex); + zend_string *z_mask; + char *retval; + char *mask; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_mask) == FAILURE) + { + return; + } + mask = ZSTR_VAL(z_mask); + retval = weechat_string_mask_to_regex ((const char *)mask); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_string_match) +{ + API_FUNC_INIT(weechat_string_match); + zend_string *z_string; + zend_string *z_mask; + zend_long z_case_sensitive; + int retval; + char *string; + char *mask; + int case_sensitive; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl", &z_string, &z_mask, &z_case_sensitive) == FAILURE) + { + return; + } + string = ZSTR_VAL(z_string); + mask = ZSTR_VAL(z_mask); + case_sensitive = (int)z_case_sensitive; + retval = weechat_string_match ((const char *)string, (const char *)mask, case_sensitive); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_string_remove_color) +{ + API_FUNC_INIT(weechat_string_remove_color); + zend_string *z_string; + zend_string *z_replacement; + char *retval; + char *string; + char *replacement; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_string, &z_replacement) == FAILURE) + { + return; + } + string = ZSTR_VAL(z_string); + replacement = ZSTR_VAL(z_replacement); + retval = weechat_string_remove_color ((const char *)string, (const char *)replacement); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_string_replace) +{ + API_FUNC_INIT(weechat_string_replace); + zend_string *z_string; + zend_string *z_search; + zend_string *z_replace; + char *retval; + char *string; + char *search; + char *replace; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_string, &z_search, &z_replace) == FAILURE) + { + return; + } + string = ZSTR_VAL(z_string); + search = ZSTR_VAL(z_search); + replace = ZSTR_VAL(z_replace); + retval = weechat_string_replace ((const char *)string, (const char *)search, (const char *)replace); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_strlen_screen) +{ + API_FUNC_INIT(weechat_strlen_screen); + zend_string *z_string; + int retval; + char *string; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_string) == FAILURE) + { + return; + } + string = ZSTR_VAL(z_string); + retval = weechat_strlen_screen ((const char *)string); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_unhook) +{ + API_FUNC_INIT(weechat_unhook); + zend_string *z_hook; + struct t_hook *hook; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_hook) == FAILURE) + { + return; + } + hook = (struct t_hook *)API_STR2PTR(ZSTR_VAL(z_hook)); + weechat_unhook (hook); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_unhook_all) +{ + API_FUNC_INIT(weechat_unhook_all); + zend_string *z_subplugin; + char *subplugin; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_subplugin) == FAILURE) + { + return; + } + subplugin = ZSTR_VAL(z_subplugin); + weechat_unhook_all ((const char *)subplugin); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_upgrade_close) +{ + API_FUNC_INIT(weechat_upgrade_close); + zend_string *z_upgrade_file; + struct t_upgrade_file *upgrade_file; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_upgrade_file) == FAILURE) + { + return; + } + upgrade_file = (struct t_upgrade_file *)API_STR2PTR(ZSTR_VAL(z_upgrade_file)); + weechat_upgrade_close (upgrade_file); + RETURN_NULL(); +} + +PHP_FUNCTION(weechat_upgrade_read) +{ + API_FUNC_INIT(weechat_upgrade_read); + zend_string *z_upgrade_file; + int retval; + struct t_upgrade_file *upgrade_file; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_upgrade_file) == FAILURE) + { + return; + } + upgrade_file = (struct t_upgrade_file *)API_STR2PTR(ZSTR_VAL(z_upgrade_file)); + retval = weechat_upgrade_read (upgrade_file); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_upgrade_write_object) +{ + API_FUNC_INIT(weechat_upgrade_write_object); + zend_string *z_upgrade_file; + zend_long z_object_id; + zend_string *z_infolist; + int retval; + struct t_upgrade_file *upgrade_file; + int object_id; + struct t_infolist *infolist; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SlS", &z_upgrade_file, &z_object_id, &z_infolist) == FAILURE) + { + return; + } + upgrade_file = (struct t_upgrade_file *)API_STR2PTR(ZSTR_VAL(z_upgrade_file)); + object_id = (int)z_object_id; + infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist)); + retval = weechat_upgrade_write_object (upgrade_file, object_id, infolist); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_window_get_integer) +{ + API_FUNC_INIT(weechat_window_get_integer); + zend_string *z_window; + zend_string *z_property; + int retval; + struct t_gui_window *window; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_window, &z_property) == FAILURE) + { + return; + } + window = (struct t_gui_window *)API_STR2PTR(ZSTR_VAL(z_window)); + property = ZSTR_VAL(z_property); + retval = weechat_window_get_integer (window, (const char *)property); + RETURN_LONG(retval); +} + +PHP_FUNCTION(weechat_window_get_pointer) +{ + API_FUNC_INIT(weechat_window_get_pointer); + zend_string *z_window; + zend_string *z_property; + void *retval; + struct t_gui_window *window; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_window, &z_property) == FAILURE) + { + return; + } + window = (struct t_gui_window *)API_STR2PTR(ZSTR_VAL(z_window)); + property = ZSTR_VAL(z_property); + retval = weechat_window_get_pointer (window, (const char *)property); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_window_get_string) +{ + API_FUNC_INIT(weechat_window_get_string); + zend_string *z_window; + zend_string *z_property; + const char *retval; + struct t_gui_window *window; + char *property; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_window, &z_property) == FAILURE) + { + return; + } + window = (struct t_gui_window *)API_STR2PTR(ZSTR_VAL(z_window)); + property = ZSTR_VAL(z_property); + retval = weechat_window_get_string (window, (const char *)property); + SAFE_RETURN_STRING(retval); +} + +PHP_FUNCTION(weechat_window_search_with_buffer) +{ + API_FUNC_INIT(weechat_window_search_with_buffer); + zend_string *z_buffer; + struct t_gui_window *retval; + struct t_gui_buffer *buffer; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_buffer) == FAILURE) + { + return; + } + buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer)); + retval = weechat_window_search_with_buffer (buffer); + char *__retstr = API_PTR2STR(retval); SAFE_RETURN_STRING(__retstr); +} + +PHP_FUNCTION(weechat_window_set_title) +{ + API_FUNC_INIT(weechat_window_set_title); + zend_string *z_title; + char *title; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_title) == FAILURE) + { + return; + } + title = ZSTR_VAL(z_title); + weechat_window_set_title ((const char *)title); + RETURN_NULL(); +} + +static void forget_hash_entry (HashTable *ht, INTERNAL_FUNCTION_PARAMETERS) +{ + zend_string *class_name; + zend_string *lc_name; + int re; + if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &class_name) == FAILURE) + { + return; + } + if (ZSTR_VAL(class_name)[0] == '\\') + { + lc_name = zend_string_alloc (ZSTR_LEN(class_name) - 1, 0); + zend_str_tolower_copy (ZSTR_VAL(lc_name), ZSTR_VAL(class_name) + 1, ZSTR_LEN(class_name) - 1); + } + else + { + lc_name = zend_string_tolower(class_name); + } + re = zend_hash_del (ht, lc_name); + zend_string_release (lc_name); + if (re == SUCCESS) + { + RETURN_TRUE; + } + RETURN_FALSE; +} + +PHP_FUNCTION(forget_class) +{ + forget_hash_entry(EG(class_table), INTERNAL_FUNCTION_PARAM_PASSTHRU); +} + +PHP_FUNCTION(forget_function) +{ + forget_hash_entry(EG(function_table), INTERNAL_FUNCTION_PARAM_PASSTHRU); +} |