/*
 * weechat-php-api.c - PHP API functions
 *
 * Copyright (C) 2006-2017 Adam Saponara <as@php.net>
 * Copyright (C) 2017-2022 Sébastien Helleu <flashcode@flashtux.org>
 *
 * This file is part of WeeChat, the extensible chat client.
 *
 * WeeChat is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * WeeChat is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with WeeChat.  If not, see <https://www.gnu.org/licenses/>.
 *
 * OpenSSL licensing:
 *
 *   Additional permission under GNU GPL version 3 section 7:
 *
 *   If you modify the Program, or any covered work, by linking or
 *   combining it with the OpenSSL project's OpenSSL library (or a
 *   modified version of that library), containing parts covered by the
 *   terms of the OpenSSL or SSLeay licenses, the licensors of the Program
 *   grant you additional permission to convey the resulting work.
 *   Corresponding Source for a non-source form of such a combination
 *   shall include the source code for the parts of OpenSSL used as well
 *   as that of the covered work.
 */

#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(__name)                                                \
    PHP_FUNCTION(weechat_##__name)
#define API_INIT_FUNC(__init, __name, __ret)                            \
    char *php_function_name = __name;                                   \
    if (__init                                                          \
        && (!php_current_script || !php_current_script->name))          \
    {                                                                   \
        WEECHAT_SCRIPT_MSG_NOT_INIT(PHP_CURRENT_SCRIPT_NAME,            \
                                    php_function_name);                 \
        __ret;                                                          \
    }
#define API_WRONG_ARGS(__ret)                                           \
    {                                                                   \
        WEECHAT_SCRIPT_MSG_WRONG_ARGS(PHP_CURRENT_SCRIPT_NAME,          \
                                      php_function_name);               \
        __ret;                                                          \
    }
#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 API_RETURN_OK RETURN_LONG((long)1)
#define API_RETURN_ERROR RETURN_LONG((long)0)
#define API_RETURN_EMPTY RETURN_NULL()
#define API_RETURN_STRING(__string)                                     \
    RETURN_STRING((__string) ? (__string) : "")
#define API_RETURN_STRING_FREE(__string)                                \
    if (__string)                                                       \
    {                                                                   \
        RETVAL_STRING(__string);                                        \
        free (__string);                                                \
        return;                                                         \
    }                                                                   \
    RETURN_STRING("");
#define API_RETURN_INT(__int) RETURN_LONG(__int)
#define API_RETURN_LONG(__long) RETURN_LONG(__long)
#define weechat_php_get_function_name(__zfunc, __str)                   \
    const 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' };


/*
 * Registers a PHP script.
 */

API_FUNC(register)
{
    zend_string *name, *author, *version, *license, *description, *charset;
    zval *shutdown_func;
    const char *shutdown_func_name;

    API_INIT_FUNC(0, "register", API_RETURN_ERROR);
    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);
        API_RETURN_ERROR;
    }
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSSzS",
                               &name, &author, &version, &license, &description,
                               &shutdown_func, &charset) == FAILURE)
    {
        API_WRONG_ARGS(API_RETURN_ERROR);
    }

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

    /* 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_data,
                                            (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
    {
        API_RETURN_ERROR;
    }

    API_RETURN_OK;
}

/*
 * Generic PHP callback function.
 */

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

/*
 * Wrappers for functions in scripting API.
 *
 * For more info about these functions, look at their implementation in WeeChat
 * core.
 */

API_FUNC(plugin_get_name)
{
    zend_string *z_plugin;
    struct t_weechat_plugin *plugin;
    const char *result;

    API_INIT_FUNC(1, "plugin_get_name", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_plugin) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    plugin = API_STR2PTR(ZSTR_VAL(z_plugin));

    result = weechat_plugin_get_name (plugin);

    API_RETURN_STRING(result);
}

API_FUNC(charset_set)
{
    zend_string *z_charset;
    char *charset;

    API_INIT_FUNC(1, "charset_set", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_charset) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    charset = ZSTR_VAL(z_charset);

    plugin_script_api_charset_set (php_current_script, (const char *)charset);

    API_RETURN_OK;
}

API_FUNC(iconv_to_internal)
{
    zend_string *z_charset, *z_string;
    char *charset, *string, *result;

    API_INIT_FUNC(1, "iconv_to_internal", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS",
                               &z_charset, &z_string) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    charset = ZSTR_VAL(z_charset);
    string = ZSTR_VAL(z_string);

    result = weechat_iconv_to_internal ((const char *)charset,
                                        (const char *)string);

    API_RETURN_STRING_FREE(result);
}

API_FUNC(iconv_from_internal)
{
    zend_string *z_charset, *z_string;
    char *charset, *string, *result;

    API_INIT_FUNC(1, "iconv_from_internal", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS",
                               &z_charset, &z_string) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    charset = ZSTR_VAL(z_charset);
    string = ZSTR_VAL(z_string);

    result = weechat_iconv_from_internal ((const char *)charset,
                                          (const char *)string);

    API_RETURN_STRING_FREE(result);
}

API_FUNC(gettext)
{
    zend_string *z_string;
    char *string;
    const char *result;

    API_INIT_FUNC(1, "gettext", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_string) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    string = ZSTR_VAL(z_string);

    result = weechat_gettext ((const char *)string);

    API_RETURN_STRING(result);
}

API_FUNC(ngettext)
{
    zend_string *z_single, *z_plural;
    zend_long z_count;
    char *single, *plural;
    int count;
    const char *result;

    API_INIT_FUNC(1, "ngettext", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl",
                               &z_single, &z_plural, &z_count) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    single = ZSTR_VAL(z_single);
    plural = ZSTR_VAL(z_plural);
    count = (int)z_count;

    result = weechat_ngettext ((const char *)single,
                               (const char *)plural,
                               count);

    API_RETURN_STRING(result);
}

API_FUNC(strlen_screen)
{
    zend_string *z_string;
    char *string;
    int result;

    API_INIT_FUNC(1, "strlen_screen", API_RETURN_INT(0));

    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_string) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    string = ZSTR_VAL(z_string);

    result = weechat_strlen_screen ((const char *)string);

    API_RETURN_INT(result);
}

API_FUNC(string_match)
{
    zend_string *z_string, *z_mask;
    zend_long z_case_sensitive;
    int case_sensitive, result;
    char *string, *mask;

    API_INIT_FUNC(1, "string_match", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl", &z_string, &z_mask,
                               &z_case_sensitive) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    string = ZSTR_VAL(z_string);
    mask = ZSTR_VAL(z_mask);
    case_sensitive = (int)z_case_sensitive;

    result = weechat_string_match ((const char *)string,
                                   (const char *)mask,
                                   case_sensitive);

    API_RETURN_INT(result);
}

API_FUNC(string_match_list)
{
    zend_string *z_string, *z_masks;
    zend_long z_case_sensitive;
    int case_sensitive, result;
    char *string, *masks;

    API_INIT_FUNC(1, "string_match_list", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl", &z_string, &z_masks,
                               &z_case_sensitive) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    string = ZSTR_VAL(z_string);
    masks = ZSTR_VAL(z_masks);
    case_sensitive = (int)z_case_sensitive;

    result = plugin_script_api_string_match_list (weechat_php_plugin,
                                                  (const char *)string,
                                                  (const char *)masks,
                                                  case_sensitive);

    API_RETURN_INT(result);
}

API_FUNC(string_has_highlight)
{
    zend_string *z_string, *z_highlight_words;
    char *string, *highlight_words;
    int result;

    API_INIT_FUNC(1, "string_has_highlight", API_RETURN_INT(0));

    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_string,
                               &z_highlight_words) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    string = ZSTR_VAL(z_string);
    highlight_words = ZSTR_VAL(z_highlight_words);

    result = weechat_string_has_highlight ((const char *)string,
                                           (const char *)highlight_words);

    API_RETURN_INT(result);
}

API_FUNC(string_has_highlight_regex)
{
    zend_string *z_string, *z_regex;
    char *string, *regex;
    int result;

    API_INIT_FUNC(1, "string_has_highlight_regex", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_string,
                               &z_regex) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    string = ZSTR_VAL(z_string);
    regex = ZSTR_VAL(z_regex);

    result = weechat_string_has_highlight_regex ((const char *)string,
                                                 (const char *)regex);

    API_RETURN_INT(result);
}

API_FUNC(string_mask_to_regex)
{
    zend_string *z_mask;
    char *mask, *result;

    API_INIT_FUNC(1, "string_mask_to_regex", API_RETURN_EMPTY);

    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_mask) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    mask = ZSTR_VAL(z_mask);

    result = weechat_string_mask_to_regex ((const char *)mask);

    API_RETURN_STRING_FREE(result);
}

API_FUNC(string_format_size)
{
    zend_long z_size;
    char *result;

    API_INIT_FUNC(1, "string_format_size", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "l", &z_size) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    result = weechat_string_format_size ((unsigned long long)z_size);

    API_RETURN_STRING_FREE(result);
}

API_FUNC(string_color_code_size)
{
    zend_string *z_string;
    char *string;
    int result;

    API_INIT_FUNC(1, "string_color_code_size", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_string) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    string = ZSTR_VAL(z_string);

    result = weechat_string_color_code_size ((const char *)string);

    API_RETURN_INT(result);
}

API_FUNC(string_remove_color)
{
    zend_string *z_string, *z_replacement;
    char *string, *replacement, *result;

    API_INIT_FUNC(1, "string_remove_color", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_string,
                               &z_replacement) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    string = ZSTR_VAL(z_string);
    replacement = ZSTR_VAL(z_replacement);

    result = weechat_string_remove_color ((const char *)string,
                                          (const char *)replacement);

    API_RETURN_STRING_FREE(result);
}

API_FUNC(string_is_command_char)
{
    zend_string *z_string;
    char *string;
    int result;

    API_INIT_FUNC(1, "string_is_command_char", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_string) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    string = ZSTR_VAL(z_string);

    result = weechat_string_is_command_char ((const char *)string);

    API_RETURN_INT(result);
}

API_FUNC(string_input_for_buffer)
{
    zend_string *z_string;
    char *string;
    const char *result;

    API_INIT_FUNC(1, "string_input_for_buffer", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_string) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    string = ZSTR_VAL(z_string);

    result = weechat_string_input_for_buffer ((const char *)string);

    API_RETURN_STRING(result);
}

API_FUNC(string_eval_expression)
{
    zend_string *z_expr;
    zval *z_pointers, *z_extra_vars, *z_options;
    char *expr, *result;
    struct t_hashtable *pointers, *extra_vars, *options;

    API_INIT_FUNC(1, "string_eval_expression", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "Saaa", &z_expr, &z_pointers,
                               &z_extra_vars, &z_options) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    expr = ZSTR_VAL(z_expr);
    pointers = weechat_php_array_to_hashtable (
        z_pointers,
        WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
        WEECHAT_HASHTABLE_STRING,
        WEECHAT_HASHTABLE_POINTER);
    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);

    result = weechat_string_eval_expression ((const char *)expr,
                                             pointers,
                                             extra_vars,
                                             options);

    if (pointers)
        weechat_hashtable_free (pointers);
    if (extra_vars)
        weechat_hashtable_free (extra_vars);
    if (options)
        weechat_hashtable_free (options);

    API_RETURN_STRING_FREE(result);
}

API_FUNC(string_eval_path_home)
{
    zend_string *z_path;
    zval *z_pointers, *z_extra_vars, *z_options;
    char *path, *result;
    struct t_hashtable *pointers, *extra_vars, *options;

    API_INIT_FUNC(1, "string_eval_path_home", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "Saaa",
                               &z_path, &z_pointers, &z_extra_vars,
                               &z_options) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    path = ZSTR_VAL(z_path);
    pointers = weechat_php_array_to_hashtable (
        z_pointers,
        WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
        WEECHAT_HASHTABLE_STRING,
        WEECHAT_HASHTABLE_POINTER);
    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);

    result = weechat_string_eval_path_home ((const char *)path,
                                            pointers,
                                            extra_vars,
                                            options);

    if (pointers)
        weechat_hashtable_free (pointers);
    if (extra_vars)
        weechat_hashtable_free (extra_vars);
    if (options)
        weechat_hashtable_free (options);

    API_RETURN_STRING_FREE(result);
}

API_FUNC(mkdir_home)
{
    zend_string *z_directory;
    zend_long z_mode;
    char *directory;
    int mode;

    API_INIT_FUNC(1, "mkdir_home", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl", &z_directory,
                               &z_mode) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    directory = ZSTR_VAL(z_directory);
    mode = (int)z_mode;

    if (weechat_mkdir_home ((const char *)directory, mode))
        API_RETURN_OK;

    API_RETURN_ERROR;
}

API_FUNC(mkdir)
{
    zend_string *z_directory;
    zend_long z_mode;
    char *directory;
    int mode;

    API_INIT_FUNC(1, "mkdir", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl", &z_directory,
                               &z_mode) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    directory = ZSTR_VAL(z_directory);
    mode = (int)z_mode;

    if (weechat_mkdir ((const char *)directory, mode))
        API_RETURN_OK;

    API_RETURN_ERROR;
}

API_FUNC(mkdir_parents)
{
    zend_string *z_directory;
    zend_long z_mode;
    char *directory;
    int mode;

    API_INIT_FUNC(1, "mkdir_parents", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl", &z_directory,
                               &z_mode) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    directory = ZSTR_VAL(z_directory);
    mode = (int)z_mode;

    if (weechat_mkdir_parents ((const char *)directory, mode))
        API_RETURN_OK;

    API_RETURN_ERROR;
}

API_FUNC(list_new)
{
    const char *result;

    API_INIT_FUNC(1, "list_new", API_RETURN_EMPTY);
    if (zend_parse_parameters_none () == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    result = API_PTR2STR(weechat_list_new ());

    API_RETURN_STRING(result);
}

API_FUNC(list_add)
{
    zend_string *z_weelist, *z_data, *z_where, *z_user_data;
    struct t_weelist *weelist;
    char *data, *where;
    void *user_data;
    const char *result;

    API_INIT_FUNC(1, "list_add", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSS", &z_weelist, &z_data,
                               &z_where, &z_user_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(weechat_list_add (weelist,
                                           (const char *)data,
                                           (const char *)where,
                                           user_data));

    API_RETURN_STRING(result);
}

API_FUNC(list_search)
{
    zend_string *z_weelist, *z_data;
    struct t_weelist *weelist;
    char *data;
    const char *result;

    API_INIT_FUNC(1, "list_search", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_weelist,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist));
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(weechat_list_search (weelist, (const char *)data));

    API_RETURN_STRING(result);
}

API_FUNC(list_search_pos)
{
    zend_string *z_weelist, *z_data;
    struct t_weelist *weelist;
    char *data;
    int result;

    API_INIT_FUNC(1, "list_search_pos", API_RETURN_INT(-1));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_weelist,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(-1));

    weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist));
    data = ZSTR_VAL(z_data);

    result = weechat_list_search_pos (weelist, (const char *)data);

    API_RETURN_INT(result);
}

API_FUNC(list_casesearch)
{
    zend_string *z_weelist, *z_data;
    struct t_weelist *weelist;
    char *data;
    const char *result;

    API_INIT_FUNC(1, "list_casesearch", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_weelist,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist));
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(
        weechat_list_casesearch (weelist, (const char *)data));

    API_RETURN_STRING(result);
}

API_FUNC(list_casesearch_pos)
{
    zend_string *z_weelist, *z_data;
    struct t_weelist *weelist;
    char *data;
    int result;

    API_INIT_FUNC(1, "list_casesearch_pos", API_RETURN_INT(-1));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_weelist,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(-1));

    weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist));
    data = ZSTR_VAL(z_data);

    result = weechat_list_casesearch_pos (weelist, (const char *)data);

    API_RETURN_INT(result);
}

API_FUNC(list_get)
{
    zend_string *z_weelist;
    zend_long z_position;
    struct t_weelist *weelist;
    int position;
    const char *result;

    API_INIT_FUNC(1, "list_get", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl", &z_weelist,
                               &z_position) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist));
    position = (int)z_position;

    result = API_PTR2STR(weechat_list_get (weelist, position));

    API_RETURN_STRING(result);
}

API_FUNC(list_set)
{
    zend_string *z_item, *z_value;
    struct t_weelist_item *item;
    char *value;

    API_INIT_FUNC(1, "list_set", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_item,
                               &z_value) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    item = (struct t_weelist_item *)API_STR2PTR(ZSTR_VAL(z_item));
    value = ZSTR_VAL(z_value);

    weechat_list_set (item, (const char *)value);

    API_RETURN_OK;
}

API_FUNC(list_next)
{
    zend_string *z_item;
    struct t_weelist_item *item;
    const char *result;

    API_INIT_FUNC(1, "list_next", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_item) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    item = (struct t_weelist_item *)API_STR2PTR(ZSTR_VAL(z_item));

    result = API_PTR2STR(weechat_list_next (item));

    API_RETURN_STRING(result);
}

API_FUNC(list_prev)
{
    zend_string *z_item;
    struct t_weelist_item *item;
    const char *result;

    API_INIT_FUNC(1, "list_prev", API_RETURN_EMPTY);

    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_item) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    item = (struct t_weelist_item *)API_STR2PTR(ZSTR_VAL(z_item));

    result = API_PTR2STR(weechat_list_prev (item));

    API_RETURN_STRING(result);
}

API_FUNC(list_string)
{
    zend_string *z_item;
    const char *result;
    struct t_weelist_item *item;

    API_INIT_FUNC(1, "list_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_item) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    item = (struct t_weelist_item *)API_STR2PTR(ZSTR_VAL(z_item));

    result = weechat_list_string (item);

    API_RETURN_STRING(result);
}

API_FUNC(list_size)
{
    zend_string *z_weelist;
    struct t_weelist *weelist;
    int result;

    API_INIT_FUNC(1, "list_size", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_weelist) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist));

    result = weechat_list_size (weelist);

    API_RETURN_INT(result);
}

API_FUNC(list_remove)
{
    zend_string *z_weelist, *z_item;
    struct t_weelist *weelist;
    struct t_weelist_item *item;

    API_INIT_FUNC(1, "list_remove", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_weelist,
                               &z_item) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

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

    API_RETURN_OK;
}

API_FUNC(list_remove_all)
{
    zend_string *z_weelist;
    struct t_weelist *weelist;

    API_INIT_FUNC(1, "list_remove_all", API_RETURN_ERROR);

    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_weelist) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist));

    weechat_list_remove_all (weelist);

    API_RETURN_OK;
}

API_FUNC(list_free)
{
    zend_string *z_weelist;
    struct t_weelist *weelist;

    API_INIT_FUNC(1, "list_free", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_weelist) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    weelist = (struct t_weelist *)API_STR2PTR(ZSTR_VAL(z_weelist));

    weechat_list_free (weelist);

    API_RETURN_OK;
}

static int
weechat_php_api_config_reload_cb (const void *pointer, void *data,
                                  struct t_config_file *config_file)
{
    int rc;
    void *func_argv[2];

    func_argv[1] = (char *)API_PTR2STR(config_file);

    weechat_php_cb (pointer, data, func_argv, "ss",
                    WEECHAT_SCRIPT_EXEC_INT, &rc);

    return rc;
}

API_FUNC(config_new)
{
    zend_string *z_name;
    zval *z_callback_reload;
    zend_string *z_data;
    char *name, *data;
    const char *result;

    API_INIT_FUNC(1, "config_new", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_name,
                               &z_callback_reload, &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    name = ZSTR_VAL(z_name);
    weechat_php_get_function_name (z_callback_reload, callback_reload_name);
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(
        plugin_script_api_config_new (
            weechat_php_plugin,
            php_current_script,
            (const char *)name,
            &weechat_php_api_config_reload_cb,
            (const char *)callback_reload_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

static int
weechat_php_api_config_section_read_cb (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] = (char *)API_PTR2STR(config_file);
    func_argv[2] = (char *)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);

    return rc;
}

static int
weechat_php_api_config_section_write_cb (const void *pointer, void *data,
                                         struct t_config_file *config_file,
                                         const char *section_name)
{
    int rc;
    void *func_argv[3];

    func_argv[1] = (char *)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);

    return rc;
}

static int
weechat_php_api_config_section_write_default_cb (const void *pointer,
                                                 void *data,
                                                 struct t_config_file *config_file,
                                                 const char *section_name)
{
    int rc;
    void *func_argv[3];

    func_argv[1] = (char *)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);

    return rc;
}

static int
weechat_php_api_config_section_create_option_cb (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] = (char *)API_PTR2STR(config_file);
    func_argv[2] = (char *)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);

    return rc;
}

static int
weechat_php_api_config_section_delete_option_cb (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] = (char *)API_PTR2STR(config_file);
    func_argv[2] = (char *)API_PTR2STR(section);
    func_argv[3] = (char *)API_PTR2STR(option);

    weechat_php_cb (pointer, data, func_argv, "ssss",
                    WEECHAT_SCRIPT_EXEC_INT, &rc);

    return rc;
}

API_FUNC(config_new_section)
{
    zend_string *z_config_file, *z_name;
    zend_long z_user_can_add_options, z_user_can_delete_options;
    zval *z_callback_read, *z_callback_write, *z_callback_write_default;
    zval *z_callback_create_option, *z_callback_delete_option;
    zend_string *z_data_read, *z_data_write, *z_data_write_default;
    zend_string *z_data_create_option, *z_data_delete_option;
    struct t_config_file *config_file;
    char *name;
    int user_can_add_options, user_can_delete_options;
    char *data_read, *data_write, *data_write_default;
    char *data_create_option, *data_delete_option;
    const char *result;

    API_INIT_FUNC(1, "config_new_section", API_RETURN_EMPTY);
    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)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        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_api_config_section_read_cb,
            (const char *)callback_read_name,
            (const char *)data_read,
            &weechat_php_api_config_section_write_cb,
            (const char *)callback_write_name,
            (const char *)data_write,
            &weechat_php_api_config_section_write_default_cb,
            (const char *)callback_write_default_name,
            (const char *)data_write_default,
            &weechat_php_api_config_section_create_option_cb,
            (const char *)callback_create_option_name,
            (const char *)data_create_option,
            &weechat_php_api_config_section_delete_option_cb,
            (const char *)callback_delete_option_name,
            (const char *)data_delete_option));

    API_RETURN_STRING(result);
}

API_FUNC(config_search_section)
{
    zend_string *z_config_file, *z_section_name;
    struct t_config_file *config_file;
    char *section_name;
    const char *result;

    API_INIT_FUNC(1, "config_search_section", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_config_file,
                               &z_section_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file));
    section_name = ZSTR_VAL(z_section_name);

    result = API_PTR2STR(
        weechat_config_search_section (config_file,
                                       (const char *)section_name));

    API_RETURN_STRING(result);
}

static int
weechat_php_api_config_option_check_value_cb (const void *pointer,
                                              void *data,
                                              struct t_config_option *option,
                                              const char *value)
{
    int rc;
    void *func_argv[3];

    func_argv[1] = (char *)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);

    return rc;
}

static void
weechat_php_api_config_option_change_cb (const void *pointer,
                                         void *data,
                                         struct t_config_option *option)
{
    int *rc;
    void *func_argv[2];

    func_argv[1] = (char *)API_PTR2STR(option);

    weechat_php_cb (pointer, data, func_argv, "ss",
                    WEECHAT_SCRIPT_EXEC_INT, &rc);
}

static void
weechat_php_api_config_option_delete_cb (const void *pointer,
                                         void *data,
                                         struct t_config_option *option)
{
    int rc;
    void *func_argv[2];

    func_argv[1] = (char *)API_PTR2STR(option);

    weechat_php_cb (pointer, data, func_argv, "ss",
                   WEECHAT_SCRIPT_EXEC_INT, &rc);
}

API_FUNC(config_new_option)
{
    zend_string *z_config_file, *z_section, *z_name, *z_type, *z_description;
    zend_string *z_string_values, *z_default_value, *z_value;
    zend_string *z_data_check_value, *z_data_change, *z_data_delete;
    zend_long z_min, z_max, z_null_value_allowed;
    zval *z_callback_check_value, *z_callback_change, *z_callback_delete;
    struct t_config_file *config_file;
    struct t_config_section *section;
    char *name, *type, *description, *string_values, *default_value, *value;
    char *data_check_value, *data_change, *data_delete;
    int min, max, null_value_allowed;
    const char *result;

    API_INIT_FUNC(1, "config_new_option", API_RETURN_EMPTY);
    if (zend_parse_parameters (
            ZEND_NUM_ARGS(), "SSSSSSllS!S!lzSzSzS", &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)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    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 = z_default_value ? ZSTR_VAL(z_default_value) : NULL;
    value = z_value ? ZSTR_VAL(z_value) : NULL;
    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);

    result = API_PTR2STR(
        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_api_config_option_check_value_cb,
            (const char *)callback_check_value_name,
            (const char *)data_check_value,
            &weechat_php_api_config_option_change_cb,
            (const char *)callback_change_name,
            (const char *)data_change,
            &weechat_php_api_config_option_delete_cb,
            (const char *)callback_delete_name,
            (const char *)data_delete));

    API_RETURN_STRING(result);
}

API_FUNC(config_search_option)
{
    zend_string *z_config_file, *z_section, *z_option_name;
    struct t_config_file *config_file;
    struct t_config_section *section;
    char *option_name;
    const char *result;

    API_INIT_FUNC(1, "config_search_option", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS",
                               &z_config_file, &z_section,
                               &z_option_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        weechat_config_search_option (config_file, section,
                                      (const char *)option_name));

    API_RETURN_STRING(result);
}

API_FUNC(config_string_to_boolean)
{
    zend_string *z_text;
    char *text;
    int result;

    API_INIT_FUNC(1, "config_string_to_boolean", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_text) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    text = ZSTR_VAL(z_text);

    result = weechat_config_string_to_boolean ((const char *)text);

    API_RETURN_INT(result);
}

API_FUNC(config_option_reset)
{
    zend_string *z_option;
    zend_long z_run_callback;
    struct t_config_option *option;
    int run_callback, result;

    API_INIT_FUNC(1, "config_option_reset", API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl",
                               &z_option, &z_run_callback) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));
    run_callback = (int)z_run_callback;

    result = weechat_config_option_reset (option, run_callback);

    API_RETURN_INT(result);
}

API_FUNC(config_option_set)
{
    zend_string *z_option, *z_value;
    zend_long z_run_callback;
    struct t_config_option *option;
    char *value;
    int run_callback, result;

    API_INIT_FUNC(1, "config_option_set",  API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl",
                               &z_option, &z_value,
                               &z_run_callback) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));
    value = ZSTR_VAL(z_value);
    run_callback = (int)z_run_callback;

    result = weechat_config_option_set (option, (const char *)value,
                                        run_callback);

    API_RETURN_INT(result);
}

API_FUNC(config_option_set_null)
{
    zend_string *z_option;
    zend_long z_run_callback;
    struct t_config_option *option;
    int run_callback, result;

    API_INIT_FUNC(1, "config_option_set_null", API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl",
                               &z_option, &z_run_callback) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));
    run_callback = (int)z_run_callback;

    result = weechat_config_option_set_null (option, run_callback);

    API_RETURN_INT(result);
}

API_FUNC(config_option_unset)
{
    zend_string *z_option;
    struct t_config_option *option;
    int result;

    API_INIT_FUNC(1, "config_option_unset", API_RETURN_INT(WEECHAT_CONFIG_OPTION_UNSET_ERROR));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_OPTION_UNSET_ERROR));

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    result = weechat_config_option_unset (option);

    API_RETURN_INT(result);
}

API_FUNC(config_option_rename)
{
    zend_string *z_option, *z_new_name;
    struct t_config_option *option;
    char *new_name;

    API_INIT_FUNC(1, "config_option_rename", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS",
                               &z_option, &z_new_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

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

    API_RETURN_OK;
}

API_FUNC(config_option_is_null)
{
    zend_string *z_option;
    struct t_config_option *option;
    int result;

    API_INIT_FUNC(1, "config_option_is_null", API_RETURN_INT(1));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(1));

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    result = weechat_config_option_is_null (option);

    API_RETURN_INT(result);
}

API_FUNC(config_option_default_is_null)
{
    zend_string *z_option;
    struct t_config_option *option;
    int result;

    API_INIT_FUNC(1, "config_option_default_is_null", API_RETURN_INT(1));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(1));

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    result = weechat_config_option_default_is_null (option);

    API_RETURN_INT(result);
}

API_FUNC(config_boolean)
{
    zend_string *z_option;
    struct t_config_option *option;
    int result;

    API_INIT_FUNC(1, "config_boolean", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    result = weechat_config_boolean (option);

    API_RETURN_INT(result);
}

API_FUNC(config_boolean_default)
{
    zend_string *z_option;
    struct t_config_option *option;
    int result;

    API_INIT_FUNC(1, "config_boolean_default", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    result = weechat_config_boolean_default (option);

    API_RETURN_INT(result);
}

API_FUNC(config_integer)
{
    zend_string *z_option;
    struct t_config_option *option;
    int result;

    API_INIT_FUNC(1, "config_integer", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    result = weechat_config_integer (option);

    API_RETURN_INT(result);
}

API_FUNC(config_integer_default)
{
    zend_string *z_option;
    struct t_config_option *option;
    int result;

    API_INIT_FUNC(1, "config_integer_default", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    result = weechat_config_integer_default (option);

    API_RETURN_INT(result);
}

API_FUNC(config_string)
{
    zend_string *z_option;
    struct t_config_option *option;
    const char *result;

    API_INIT_FUNC(1, "config_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    result = weechat_config_string (option);

    API_RETURN_STRING(result);
}

API_FUNC(config_string_default)
{
    zend_string *z_option;
    struct t_config_option *option;
    const char *result;

    API_INIT_FUNC(1, "config_string_default", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    result = weechat_config_string_default (option);

    API_RETURN_STRING(result);
}

API_FUNC(config_color)
{
    zend_string *z_option;
    struct t_config_option *option;
    const char *result;

    API_INIT_FUNC(1, "config_color", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    result = weechat_config_color (option);

    API_RETURN_STRING(result);
}

API_FUNC(config_color_default)
{
    zend_string *z_option;
    struct t_config_option *option;
    const char *result;

    API_INIT_FUNC(1, "config_color_default", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    result = weechat_config_color_default (option);

    API_RETURN_STRING(result);
}

API_FUNC(config_write_option)
{
    zend_string *z_config_file, *z_option;
    struct t_config_file *config_file;
    struct t_config_option *option;

    API_INIT_FUNC(1, "config_write_option", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_config_file,
                               &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file));
    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    weechat_config_write_option (config_file, option);

    API_RETURN_OK;
}

API_FUNC(config_write_line)
{
    zend_string *z_config_file, *z_option_name, *z_value;
    struct t_config_file *config_file;
    char *option_name, *value;

    API_INIT_FUNC(1, "config_write_line", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_config_file,
                               &z_option_name, &z_value) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

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

    weechat_config_write_line (config_file,
                               (const char *)option_name,
                               (const char *)value);

    API_RETURN_OK;
}

API_FUNC(config_write)
{
    zend_string *z_config_file;
    struct t_config_file *config_file;
    int result;

    API_INIT_FUNC(1, "config_write", API_RETURN_INT(WEECHAT_CONFIG_WRITE_ERROR));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S",
                               &z_config_file) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_WRITE_ERROR));

    config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file));

    result = weechat_config_write (config_file);

    API_RETURN_INT(result);
}

API_FUNC(config_read)
{
    zend_string *z_config_file;
    struct t_config_file *config_file;
    int result;

    API_INIT_FUNC(1, "config_read", API_RETURN_INT(WEECHAT_CONFIG_READ_FILE_NOT_FOUND));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S",
                               &z_config_file) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_READ_FILE_NOT_FOUND));

    config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file));

    result = weechat_config_read (config_file);

    API_RETURN_INT(result);
}

API_FUNC(config_reload)
{
    zend_string *z_config_file;
    struct t_config_file *config_file;
    int result;

    API_INIT_FUNC(1, "config_reload", API_RETURN_INT(WEECHAT_CONFIG_READ_FILE_NOT_FOUND));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S",
                               &z_config_file) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_READ_FILE_NOT_FOUND));

    config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file));

    result = weechat_config_reload (config_file);

    API_RETURN_INT(result);
}

API_FUNC(config_option_free)
{
    zend_string *z_option;
    struct t_config_option *option;

    API_INIT_FUNC(1, "config_option_free", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    option = (struct t_config_option *)API_STR2PTR(ZSTR_VAL(z_option));

    weechat_config_option_free (option);

    API_RETURN_OK;
}

API_FUNC(config_section_free_options)
{
    zend_string *z_section;
    struct t_config_section *section;

    API_INIT_FUNC(1, "config_section_free_options", API_RETURN_ERROR);

    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_section) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    section = (struct t_config_section *)API_STR2PTR(ZSTR_VAL(z_section));

    weechat_config_section_free_options (section);

    API_RETURN_OK;
}

API_FUNC(config_section_free)
{
    zend_string *z_section;
    struct t_config_section *section;

    API_INIT_FUNC(1, "config_section_free", API_RETURN_ERROR);

    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_section) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    section = (struct t_config_section *)API_STR2PTR(ZSTR_VAL(z_section));

    weechat_config_section_free (section);

    API_RETURN_OK;
}

API_FUNC(config_free)
{
    zend_string *z_config_file;
    struct t_config_file *config_file;

    API_INIT_FUNC(1, "config_free", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S",
                               &z_config_file) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    config_file = (struct t_config_file *)API_STR2PTR(ZSTR_VAL(z_config_file));

    weechat_config_free (config_file);

    API_RETURN_OK;
}

API_FUNC(config_get)
{
    zend_string *z_option_name;
    char *option_name;
    const char *result;

    API_INIT_FUNC(1, "config_get", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S",
                               &z_option_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    option_name = ZSTR_VAL(z_option_name);

    result = API_PTR2STR(weechat_config_get ((const char *)option_name));

    API_RETURN_STRING(result);
}

API_FUNC(config_get_plugin)
{
    zend_string *z_option;
    char *option;
    const char *result;

    API_INIT_FUNC(1, "config_get_plugin", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    option = ZSTR_VAL(z_option);

    result = plugin_script_api_config_get_plugin (weechat_php_plugin,
                                                  php_current_script,
                                                  (const char *)option);

    API_RETURN_STRING(result);
}

API_FUNC(config_is_set_plugin)
{
    zend_string *z_option;
    char *option;
    int result;

    API_INIT_FUNC(1, "config_is_set_plugin", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    option = ZSTR_VAL(z_option);

    result = plugin_script_api_config_is_set_plugin (weechat_php_plugin,
                                                     php_current_script,
                                                     (const char *)option);

    API_RETURN_INT(result);
}

API_FUNC(config_set_plugin)
{
    zend_string *z_option, *z_value;
    char *option, *value;
    int result;

    API_INIT_FUNC(1, "config_set_plugin", API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_option,
                               &z_value) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_OPTION_SET_ERROR));

    option = ZSTR_VAL(z_option);
    value = ZSTR_VAL(z_value);

    result = plugin_script_api_config_set_plugin (weechat_php_plugin,
                                                  php_current_script,
                                                  (const char *)option,
                                                  (const char *)value);

    API_RETURN_INT(result);
}

API_FUNC(config_set_desc_plugin)
{
    zend_string *z_option, *z_description;
    char *option, *description;

    API_INIT_FUNC(1, "config_set_desc_plugin", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_option,
                               &z_description) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

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

    API_RETURN_OK;
}

API_FUNC(config_unset_plugin)
{
    zend_string *z_option;
    char *option;
    int result;

    API_INIT_FUNC(1, "config_unset_plugin", API_RETURN_INT(WEECHAT_CONFIG_OPTION_UNSET_ERROR));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_option) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_CONFIG_OPTION_UNSET_ERROR));

    option = ZSTR_VAL(z_option);

    result = plugin_script_api_config_unset_plugin (weechat_php_plugin,
                                                    php_current_script,
                                                    (const char *)option);

    API_RETURN_INT(result);
}

API_FUNC(key_bind)
{
    zend_string *z_context;
    zval *z_keys;
    char *context;
    struct t_hashtable *keys;
    int result;

    API_INIT_FUNC(1, "key_bind", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sa", &z_context,
                               &z_keys) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    context = ZSTR_VAL(z_context);
    keys = weechat_php_array_to_hashtable (z_keys,
                                           WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
                                           WEECHAT_HASHTABLE_STRING,
                                           WEECHAT_HASHTABLE_STRING);

    result = weechat_key_bind ((const char *)context, keys);

    if (keys)
        weechat_hashtable_free (keys);

    API_RETURN_INT(result);
}

API_FUNC(key_unbind)
{
    zend_string *z_context, *z_key;
    int result;
    char *context, *key;

    API_INIT_FUNC(1, "key_unbind", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_context,
                               &z_key) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    context = ZSTR_VAL(z_context);
    key = ZSTR_VAL(z_key);

    result = weechat_key_unbind ((const char *)context, (const char *)key);

    API_RETURN_INT(result);
}

API_FUNC(prefix)
{
    zend_string *z_prefix;
    char *prefix;
    const char *result;

    API_INIT_FUNC(0, "prefix", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_prefix) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    prefix = ZSTR_VAL(z_prefix);

    result = weechat_prefix ((const char *)prefix);

    API_RETURN_STRING(result);
}

API_FUNC(color)
{
    zend_string *z_color_name;
    char *color_name;
    const char *result;

    API_INIT_FUNC(0, "color", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_color_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    color_name = ZSTR_VAL(z_color_name);

    result = weechat_color ((const char *)color_name);

    API_RETURN_STRING(result);
}

API_FUNC(print)
{
    zend_string *z_buffer, *z_message;
    struct t_gui_buffer *buffer;
    char *message;

    API_INIT_FUNC(0, "print", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer,
                               &z_message) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));
    message = ZSTR_VAL(z_message);

    plugin_script_api_printf (weechat_php_plugin, php_current_script, buffer,
                              "%s", message);

    API_RETURN_OK;
}

API_FUNC(print_date_tags)
{
    zend_string *z_buffer, *z_tags, *z_message;
    zend_long z_date;
    struct t_gui_buffer *buffer;
    time_t date;
    char *tags, *message;

    API_INIT_FUNC(1, "print_date_tags", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SlSS", &z_buffer, &z_date,
                               &z_tags, &z_message) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));
    date = (time_t)z_date;
    tags = ZSTR_VAL(z_tags);
    message = ZSTR_VAL(z_message);

    plugin_script_api_printf_date_tags (weechat_php_plugin,
                                        php_current_script,
                                        buffer,
                                        date,
                                        (const char *)tags,
                                        "%s",
                                        message);

    API_RETURN_OK;
}

API_FUNC(print_y)
{
    zend_string *z_buffer, *z_message;
    zend_long z_y;
    struct t_gui_buffer *buffer;
    int y;
    char *message;

    API_INIT_FUNC(1, "print_y", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SlS", &z_buffer, &z_y,
                               &z_message) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));
    y = (int)z_y;
    message = ZSTR_VAL(z_message);

    plugin_script_api_printf_y (weechat_php_plugin,
                                php_current_script,
                                buffer,
                                y,
                                "%s",
                                message);

    API_RETURN_OK;
}

API_FUNC(print_y_date_tags)
{
    zend_string *z_buffer, *z_tags, *z_message;
    zend_long z_y, z_date;
    struct t_gui_buffer *buffer;
    int y;
    time_t date;
    char *tags, *message;

    API_INIT_FUNC(1, "print_y_date_tags", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SllSS", &z_buffer, &z_y,
                               &z_date, &z_tags, &z_message) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));
    y = (int)z_y;
    date = (time_t)z_date;
    tags = ZSTR_VAL(z_tags);
    message = ZSTR_VAL(z_message);

    plugin_script_api_printf_y_date_tags (weechat_php_plugin,
                                          php_current_script,
                                          buffer,
                                          y,
                                          date,
                                          (const char *)tags,
                                          "%s",
                                          message);

    API_RETURN_OK;
}

API_FUNC(log_print)
{
    zend_string *z_message;
    char *message;

    API_INIT_FUNC(1, "log_print", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_message) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    message = ZSTR_VAL(z_message);

    plugin_script_api_log_printf (weechat_php_plugin, php_current_script,
                                  "%s", message);

    API_RETURN_OK;
}

static int
weechat_php_api_hook_command_cb (const void *pointer, void *data,
                                 struct t_gui_buffer *buffer,
                                 int argc, char **argv, char **argv_eol)
{
    int rc;
    void *func_argv[3];

    /* make C compiler happy */
    (void) argv;

    func_argv[1] = (char *)API_PTR2STR(buffer);
    func_argv[2] = (argc > 1) ? argv_eol[1] : weechat_php_empty_arg;

    weechat_php_cb (pointer, data, func_argv, "sss",
                    WEECHAT_SCRIPT_EXEC_INT, &rc);

    return rc;
}

API_FUNC(hook_command)
{
    zend_string *z_command, *z_description, *z_args, *z_args_description;
    zend_string *z_completion, *z_data;
    zval *z_callback;
    char *command, *description, *args, *args_description, *completion, *data;
    const char *result;

    API_INIT_FUNC(1, "hook_command", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSSzS", &z_command,
                               &z_description, &z_args, &z_args_description,
                               &z_completion, &z_callback, &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        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_api_hook_command_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

static int
weechat_php_api_hook_completion_cb (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] = (char *)API_PTR2STR(buffer);
    func_argv[3] = (char *)API_PTR2STR(completion);

    weechat_php_cb (pointer, data, func_argv, "ssss",
                    WEECHAT_SCRIPT_EXEC_INT, &rc);

    return rc;
}

API_FUNC(hook_completion)
{
    zend_string *z_completion, *z_description, *z_data;
    zval *z_callback;
    char *completion, *description, *data;
    const char *result;

    API_INIT_FUNC(1, "hook_completion", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSzS",
                               &z_completion, &z_description, &z_callback,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    completion = ZSTR_VAL(z_completion);
    description = ZSTR_VAL(z_description);
    weechat_php_get_function_name (z_callback, callback_name);
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(
        plugin_script_api_hook_completion (
            weechat_php_plugin,
            php_current_script,
            (const char *)completion,
            (const char *)description,
            &weechat_php_api_hook_completion_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

/*
 * This function deprecated since WeeChat 2.9, kept for compatibility.
 * It is replaced by completion_get_string.
 */

API_FUNC(hook_completion_get_string)
{
    zend_string *z_completion, *z_property;
    struct t_gui_completion *completion;
    char *property;
    const char *result;

    API_INIT_FUNC(1, "hook_completion_get_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_completion,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    completion = (struct t_gui_completion *)API_STR2PTR(ZSTR_VAL(z_completion));
    property = ZSTR_VAL(z_property);

    result = weechat_hook_completion_get_string (completion,
                                                 (const char *)property);

    API_RETURN_STRING(result);
}

/*
 * This function deprecated since WeeChat 2.9, kept for compatibility.
 * It is replaced by completion_list_add.
 */

API_FUNC(hook_completion_list_add)
{
    zend_string *z_completion, *z_word, *z_where;
    zend_long z_nick_completion;
    struct t_gui_completion *completion;
    char *word, *where;
    int nick_completion;

    API_INIT_FUNC(1, "hook_completion_list_add", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSlS", &z_completion,
                               &z_word, &z_nick_completion, &z_where) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

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

    API_RETURN_OK;
}

static int
weechat_php_api_hook_command_run_cb (const void *pointer, void *data,
                                     struct t_gui_buffer *buffer,
                                     const char *command)
{
    int rc;
    void *func_argv[3];

    func_argv[1] = (char *)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);

    return rc;
}

API_FUNC(hook_command_run)
{
    zend_string *z_command, *z_data;
    zval *z_callback;
    char *command, *data;
    const char *result;

    API_INIT_FUNC(1, "hook_command_run", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_command, &z_callback,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    command = ZSTR_VAL(z_command);
    weechat_php_get_function_name (z_callback, callback_name);
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(
        plugin_script_api_hook_command_run (
            weechat_php_plugin,
            php_current_script,
            (const char *)command,
            &weechat_php_api_hook_command_run_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

static int
weechat_php_api_hook_timer_cb (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;
}

API_FUNC(hook_timer)
{
    zend_long z_interval, z_align_second, z_max_calls;
    zval *z_callback;
    zend_string *z_data;
    int interval, align_second, max_calls;
    char *data;
    const char *result;

    API_INIT_FUNC(1, "hook_timer", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "lllzS", &z_interval,
                               &z_align_second, &z_max_calls, &z_callback,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        plugin_script_api_hook_timer (
            weechat_php_plugin,
            php_current_script,
            interval,
            align_second,
            max_calls,
            &weechat_php_api_hook_timer_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

static int
weechat_php_api_hook_fd_cb (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;
}

API_FUNC(hook_fd)
{
    zend_long z_fd, z_flag_read, z_flag_write, z_flag_exception;
    zval *z_callback;
    zend_string *z_data;
    int fd, flag_read, flag_write, flag_exception;
    char *data;
    const char *result;

    API_INIT_FUNC(1, "hook_fd", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "llllzS", &z_fd, &z_flag_read,
                               &z_flag_write, &z_flag_exception, &z_callback,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        plugin_script_api_hook_fd (
            weechat_php_plugin,
            php_current_script, fd,
            flag_read,
            flag_write,
            flag_exception,
            &weechat_php_api_hook_fd_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

static int
weechat_php_api_hook_process_cb (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;
}

API_FUNC(hook_process)
{
    zend_string *z_command, *z_data;
    zend_long z_timeout;
    zval *z_callback;
    char *command, *data;
    int timeout;
    const char *result;

    API_INIT_FUNC(1, "hook_process", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SlzS", &z_command, &z_timeout,
                               &z_callback, &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    command = ZSTR_VAL(z_command);
    timeout = (int)z_timeout;
    weechat_php_get_function_name (z_callback, callback_name);
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(
        plugin_script_api_hook_process (
            weechat_php_plugin,
            php_current_script,
            (const char *)command,
            timeout,
            &weechat_php_api_hook_process_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

static int
weechat_php_api_hook_process_hashtable_cb (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;
}

API_FUNC(hook_process_hashtable)
{
    zend_string *z_command, *z_data;
    zval *z_options, *z_callback;
    zend_long z_timeout;
    char *command, *data;
    struct t_hashtable *options;
    int timeout;
    const char *result;

    API_INIT_FUNC(1, "hook_process_hashtable", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SalzS", &z_command,
                               &z_options, &z_timeout, &z_callback,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        plugin_script_api_hook_process_hashtable (
            weechat_php_plugin,
            php_current_script,
            (const char *)command,
            options,
            timeout,
            &weechat_php_api_hook_process_hashtable_cb,
            (const char *)callback_name,
            (const char *)data));

    if (options)
        weechat_hashtable_free (options);

    API_RETURN_STRING(result);
}

static int
weechat_php_api_hook_connect_cb (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;
}

API_FUNC(hook_connect)
{
    zend_string *z_proxy, *z_address, *z_gnutls_sess, *z_gnutls_cb;
    zend_string *z_gnutls_priorities, *z_local_hostname, *z_data;
    zend_long z_port, z_ipv6, z_retry, z_gnutls_dhkey_size;
    zval *z_callback;
    char *proxy, *address, *gnutls_priorities, *local_hostname, *data;
    int port, ipv6, retry;
    void *gnutls_sess, *gnutls_cb;
    int gnutls_dhkey_size;
    const char *result;

    API_INIT_FUNC(1, "hook_connect", API_RETURN_EMPTY);
    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)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        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_api_hook_connect_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

struct t_hashtable *
weechat_php_api_hook_line_cb (const void *pointer, void *data,
                              struct t_hashtable *line)
{
    struct t_hashtable *rc;
    void *func_argv[2];

    func_argv[1] = line;

    weechat_php_cb (pointer, data, func_argv, "sh",
                    WEECHAT_SCRIPT_EXEC_HASHTABLE, &rc);

    return rc;
}

API_FUNC(hook_line)
{
    zend_string *z_buffer_type, *z_buffer_name, *z_tags, *z_data;
    zval *z_callback;
    char *buffer_type, *buffer_name, *tags, *data;
    const char *result;

    API_INIT_FUNC(1, "hook_line", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSzS",
                               &z_buffer_type, &z_buffer_name, &z_tags,
                               &z_callback, &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    weechat_php_get_function_name (z_callback, callback_name);
    buffer_type = ZSTR_VAL(z_buffer_type);
    buffer_name = ZSTR_VAL(z_buffer_name);
    tags = ZSTR_VAL(z_tags);
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(
        plugin_script_api_hook_line (
            weechat_php_plugin,
            php_current_script,
            (const char *)buffer_type,
            (const char *)buffer_name,
            (const char *)tags,
            &weechat_php_api_hook_line_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

static int
weechat_php_api_hook_print_cb (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] = (char *)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);

    return rc;
}

API_FUNC(hook_print)
{
    zend_string *z_buffer, *z_tags, *z_message, *z_data;
    zend_long z_strip_colors;
    zval *z_callback;
    struct t_gui_buffer *buffer;
    char *tags, *message, *data;
    int strip_colors;
    const char *result;

    API_INIT_FUNC(1, "hook_print", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSlzS", &z_buffer, &z_tags,
                               &z_message, &z_strip_colors, &z_callback,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        plugin_script_api_hook_print (
            weechat_php_plugin,
            php_current_script,
            buffer,
            (const char *)tags,
            (const char *)message,
            strip_colors,
            &weechat_php_api_hook_print_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

static int
weechat_php_api_hook_signal_cb (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;
}

API_FUNC(hook_signal)
{
    zend_string *z_signal, *z_data;
    zval *z_callback;
    char *signal, *data;
    const char *result;

    API_INIT_FUNC(1, "hook_signal", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_signal, &z_callback,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    signal = ZSTR_VAL(z_signal);
    weechat_php_get_function_name (z_callback, callback_name);
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(
        plugin_script_api_hook_signal (
            weechat_php_plugin,
            php_current_script,
            (const char *)signal,
            &weechat_php_api_hook_signal_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

API_FUNC(hook_signal_send)
{
    zend_string *z_signal, *z_type_data, *z_signal_data;
    char *signal, *type_data;
    void *signal_data;
    int result;

    API_INIT_FUNC(1, "hook_signal_send", API_RETURN_INT(WEECHAT_RC_ERROR));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_signal, &z_type_data,
                               &z_signal_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_RC_ERROR));

    signal = ZSTR_VAL(z_signal);
    type_data = ZSTR_VAL(z_type_data);
    signal_data = (void *)API_STR2PTR(ZSTR_VAL(z_signal_data));
    result = weechat_hook_signal_send ((const char *)signal,
                                       (const char *)type_data, signal_data);

    API_RETURN_INT(result);
}

static int
weechat_php_api_hook_hsignal_cb (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;
}

API_FUNC(hook_hsignal)
{
    zend_string *z_signal, *z_data;
    zval *z_callback;
    char *signal, *data;
    const char *result;

    API_INIT_FUNC(1, "hook_hsignal", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_signal, &z_callback,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    signal = ZSTR_VAL(z_signal);
    weechat_php_get_function_name (z_callback, callback_name);
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(
        plugin_script_api_hook_hsignal (
            weechat_php_plugin,
            php_current_script,
            (const char *)signal,
            &weechat_php_api_hook_hsignal_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

API_FUNC(hook_hsignal_send)
{
    zend_string *z_signal;
    zval *z_hashtable;
    char *signal;
    struct t_hashtable *hashtable;
    int result;

    API_INIT_FUNC(1, "hook_hsignal_send", API_RETURN_INT(WEECHAT_RC_ERROR));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sa", &z_signal,
                               &z_hashtable) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_RC_ERROR));

    signal = ZSTR_VAL(z_signal);
    hashtable = weechat_php_array_to_hashtable (
        z_hashtable,
        WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
        WEECHAT_HASHTABLE_STRING,
        WEECHAT_HASHTABLE_STRING);

    result = weechat_hook_hsignal_send ((const char *)signal, hashtable);

    if (hashtable)
        weechat_hashtable_free (hashtable);

    API_RETURN_INT(result);
}

static int
weechat_php_api_hook_config_cb (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;
}

API_FUNC(hook_config)
{
    zend_string *z_option, *z_data;
    zval *z_callback;
    char *option, *data;
    const char *result;

    API_INIT_FUNC(1, "hook_config", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_option, &z_callback,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    option = ZSTR_VAL(z_option);
    weechat_php_get_function_name (z_callback, callback_name);
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(
        plugin_script_api_hook_config (
            weechat_php_plugin,
            php_current_script,
            (const char *)option,
            &weechat_php_api_hook_config_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

static char *
weechat_php_api_hook_modifier_cb (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;
}

API_FUNC(hook_modifier)
{
    zend_string *z_modifier, *z_data;
    zval *z_callback;
    char *modifier, *data;
    const char *result;

    API_INIT_FUNC(1, "hook_modifier", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_modifier,
                               &z_callback, &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    modifier = ZSTR_VAL(z_modifier);
    weechat_php_get_function_name (z_callback, callback_name);
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(
        plugin_script_api_hook_modifier (
            weechat_php_plugin,
            php_current_script,
            (const char *)modifier,
            &weechat_php_api_hook_modifier_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

API_FUNC(hook_modifier_exec)
{
    zend_string *z_modifier, *z_modifier_data, *z_string;
    char *modifier, *modifier_data, *string, *result;

    API_INIT_FUNC(1, "hook_modifier_exec", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_modifier,
                               &z_modifier_data, &z_string) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    modifier = ZSTR_VAL(z_modifier);
    modifier_data = ZSTR_VAL(z_modifier_data);
    string = ZSTR_VAL(z_string);

    result = weechat_hook_modifier_exec ((const char *)modifier,
                                         (const char *)modifier_data,
                                         (const char *)string);

    API_RETURN_STRING_FREE(result);
}

static char *
weechat_php_api_hook_info_cb (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;
}

API_FUNC(hook_info)
{
    zend_string *z_info_name, *z_description, *z_args_description, *z_data;
    zval *z_callback;
    char *info_name, *description, *args_description, *data;
    const char *result;

    API_INIT_FUNC(1, "hook_info", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSzS", &z_info_name,
                               &z_description, &z_args_description,
                               &z_callback, &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        plugin_script_api_hook_info (
            weechat_php_plugin,
            php_current_script,
            (const char *)info_name,
            (const char *)description,
            (const char *)args_description,
            &weechat_php_api_hook_info_cb,
            (const char *)callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

struct t_hashtable *
weechat_php_api_hook_info_hashtable_cb (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;
}

API_FUNC(hook_info_hashtable)
{
    zend_string *z_info_name, *z_description, *z_args_description;
    zend_string *z_output_description, *z_data;
    zval *z_callback;
    char *info_name, *description, *args_description, *output_description;
    char *data;
    const char *result;

    API_INIT_FUNC(1, "hook_info_hashtable", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSSzS", &z_info_name,
                               &z_description, &z_args_description,
                               &z_output_description, &z_callback,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        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_cb,
            callback_name,
            data));

    API_RETURN_STRING(result);
}

struct t_infolist *
weechat_php_api_hook_infolist_cb (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] = (char *)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_POINTER, &rc);

    return rc;
}

API_FUNC(hook_infolist)
{
    zend_string *z_infolist_name, *z_description, *z_pointer_description;
    zend_string *z_args_description, *z_data;
    zval *z_callback;
    char *infolist_name, *description, *pointer_description, *args_description;
    char *data;
    const char *result;

    API_INIT_FUNC(1, "hook_infolist", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSzS", &z_infolist_name,
                               &z_description, &z_pointer_description,
                               &z_args_description, &z_callback,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        plugin_script_api_hook_infolist (
            weechat_php_plugin,
            php_current_script,
            infolist_name,
            description,
            pointer_description,
            args_description,
            &weechat_php_api_hook_infolist_cb,
            callback_name,
            data));

    API_RETURN_STRING(result);
}

struct t_hashtable *
weechat_php_api_hook_focus_cb (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;
}

API_FUNC(hook_focus)
{
    zend_string *z_area, *z_data;
    zval *z_callback;
    char *area, *data;
    const char *result;

    API_INIT_FUNC(1, "hook_focus", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_area, &z_callback,
                               &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    area = ZSTR_VAL(z_area);
    data = ZSTR_VAL(z_data);
    weechat_php_get_function_name (z_callback, callback_name);

    result = API_PTR2STR(
        plugin_script_api_hook_focus (
            weechat_php_plugin,
            php_current_script,
            area,
            &weechat_php_api_hook_focus_cb,
            callback_name,
            data));

    API_RETURN_STRING(result);
}

API_FUNC(hook_set)
{
    zend_string *z_hook, *z_property, *z_value;
    struct t_hook *hook;
    char *property, *value;

    API_INIT_FUNC(1, "hook_set", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hook, &z_property,
                               &z_value) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

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

    API_RETURN_OK;
}

API_FUNC(unhook)
{
    zend_string *z_hook;
    struct t_hook *hook;

    API_INIT_FUNC(1, "unhook", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_hook) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    hook = (struct t_hook *)API_STR2PTR(ZSTR_VAL(z_hook));

    weechat_unhook (hook);

    API_RETURN_OK;
}

API_FUNC(unhook_all)
{
    zend_string *z_subplugin;
    char *subplugin;

    API_INIT_FUNC(1, "unhook_all", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_subplugin) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    subplugin = ZSTR_VAL(z_subplugin);

    weechat_unhook_all ((const char *)subplugin);

    API_RETURN_OK;
}

int
weechat_php_api_buffer_input_data_cb (const void *pointer, void *data,
                                      struct t_gui_buffer *buffer,
                                      const char *input_data)
{
    int rc;
    void *func_argv[3];

    func_argv[1] = (char *)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);

    return rc;
}

int
weechat_php_api_buffer_close_cb (const void *pointer, void *data,
                                 struct t_gui_buffer *buffer)
{
    int rc;
    void *func_argv[2];

    func_argv[1] = (char *)API_PTR2STR(buffer);

    weechat_php_cb (pointer, data, func_argv, "ss",
                    WEECHAT_SCRIPT_EXEC_INT, &rc);

    return rc;
}

API_FUNC(buffer_new)
{
    zend_string *z_name, *z_data_input, *z_data_close;
    zval *z_input_callback, *z_close_callback;
    char *name, *data_input, *data_close;
    const char *result;

    API_INIT_FUNC(1, "buffer_new", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzSzS", &z_name,
                               &z_input_callback, &z_data_input,
                               &z_close_callback, &z_data_close) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        plugin_script_api_buffer_new (
            weechat_php_plugin,
            php_current_script,
            (const char *)name,
            &weechat_php_api_buffer_input_data_cb,
            (const char *)input_callback_name,
            (const char *)data_input,
            &weechat_php_api_buffer_close_cb,
            (const char *)close_callback_name,
            (const char *)data_close));

    API_RETURN_STRING(result);
}

API_FUNC(buffer_new_props)
{
    zend_string *z_name, *z_data_input, *z_data_close;
    zval *z_properties, *z_input_callback, *z_close_callback;
    char *name, *data_input, *data_close;
    struct t_hashtable *properties;
    const char *result;

    API_INIT_FUNC(1, "buffer_new_props", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SazSzS", &z_name,
                               &z_properties, &z_input_callback, &z_data_input,
                               &z_close_callback, &z_data_close) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    name = ZSTR_VAL(z_name);
    properties = weechat_php_array_to_hashtable (
        z_properties,
        WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
        WEECHAT_HASHTABLE_STRING,
        WEECHAT_HASHTABLE_STRING);
    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);

    result = API_PTR2STR(
        plugin_script_api_buffer_new_props (
            weechat_php_plugin,
            php_current_script,
            (const char *)name,
            properties,
            &weechat_php_api_buffer_input_data_cb,
            (const char *)input_callback_name,
            (const char *)data_input,
            &weechat_php_api_buffer_close_cb,
            (const char *)close_callback_name,
            (const char *)data_close));

    if (properties)
        weechat_hashtable_free (properties);

    API_RETURN_STRING(result);
}

API_FUNC(buffer_search)
{
    zend_string *z_plugin, *z_name;
    char *plugin, *name;
    const char *result;

    API_INIT_FUNC(1, "buffer_search", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_plugin,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    plugin = ZSTR_VAL(z_plugin);
    name = ZSTR_VAL(z_name);

    result = API_PTR2STR(
        weechat_buffer_search ((const char *)plugin, (const char *)name));

    API_RETURN_STRING(result);
}

API_FUNC(buffer_search_main)
{
    const char *result;

    API_INIT_FUNC(1, "buffer_search_main", API_RETURN_EMPTY);
    if (zend_parse_parameters_none () == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    result = API_PTR2STR(weechat_buffer_search_main ());

    API_RETURN_STRING(result);
}

API_FUNC(current_buffer)
{
    const char *result;

    API_INIT_FUNC(1, "current_buffer", API_RETURN_EMPTY);
    if (zend_parse_parameters_none () == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    result = API_PTR2STR(weechat_current_buffer ());

    API_RETURN_STRING(result);
}

API_FUNC(buffer_clear)
{
    zend_string *z_buffer;
    struct t_gui_buffer *buffer;

    API_INIT_FUNC(1, "buffer_clear", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_buffer) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));

    weechat_buffer_clear (buffer);

    API_RETURN_OK;
}

API_FUNC(buffer_close)
{
    zend_string *z_buffer;
    struct t_gui_buffer *buffer;

    API_INIT_FUNC(1, "buffer_close", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_buffer) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));

    weechat_buffer_close (buffer);

    API_RETURN_OK;
}

API_FUNC(buffer_merge)
{
    zend_string *z_buffer;
    zend_string *z_target_buffer;
    struct t_gui_buffer *buffer;
    struct t_gui_buffer *target_buffer;

    API_INIT_FUNC(1, "buffer_merge", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer,
                               &z_target_buffer) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

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

    API_RETURN_OK;
}

API_FUNC(buffer_unmerge)
{
    zend_string *z_buffer;
    zend_long z_number;
    struct t_gui_buffer *buffer;
    int number;

    API_INIT_FUNC(1, "buffer_unmerge", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sl", &z_buffer,
                               &z_number) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));
    number = (int)z_number;

    weechat_buffer_unmerge (buffer, number);

    API_RETURN_OK;
}

API_FUNC(buffer_get_integer)
{
    zend_string *z_buffer, *z_property;
    struct t_gui_buffer *buffer;
    char *property;
    int result;

    API_INIT_FUNC(1, "buffer_get_integer", API_RETURN_INT(-1));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(-1));

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));
    property = ZSTR_VAL(z_property);

    result = weechat_buffer_get_integer (buffer, (const char *)property);

    API_RETURN_INT(result);
}

API_FUNC(buffer_get_string)
{
    zend_string *z_buffer, *z_property;
    const char *result;
    struct t_gui_buffer *buffer;
    char *property;

    API_INIT_FUNC(1, "buffer_get_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));
    property = ZSTR_VAL(z_property);

    result = weechat_buffer_get_string (buffer, (const char *)property);

    API_RETURN_STRING(result);
}

API_FUNC(buffer_get_pointer)
{
    zend_string *z_buffer, *z_property;
    struct t_gui_buffer *buffer;
    char *property;
    const char *result;

    API_INIT_FUNC(1, "buffer_get_pointer", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));
    property = ZSTR_VAL(z_property);

    result = API_PTR2STR(
        weechat_buffer_get_pointer (buffer, (const char *)property));

    API_RETURN_STRING(result);
}

API_FUNC(buffer_set)
{
    zend_string *z_buffer, *z_property, *z_value;
    struct t_gui_buffer *buffer;
    char *property, *value;

    API_INIT_FUNC(1, "buffer_set", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_property,
                               &z_value) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

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

    API_RETURN_OK;
}

API_FUNC(buffer_string_replace_local_var)
{
    zend_string *z_buffer, *z_string;
    struct t_gui_buffer *buffer;
    char *string, *result;

    API_INIT_FUNC(1, "buffer_string_replace_local_var", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer,
                               &z_string) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));
    string = ZSTR_VAL(z_string);

    result = weechat_buffer_string_replace_local_var (buffer,
                                                      (const char *)string);

    API_RETURN_STRING_FREE(result);
}

API_FUNC(buffer_match_list)
{
    zend_string *z_buffer, *z_string;
    struct t_gui_buffer *buffer;
    char *string;
    int result;

    API_INIT_FUNC(1, "buffer_match_list", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer,
                               &z_string) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));
    string = ZSTR_VAL(z_string);

    result = weechat_buffer_match_list (buffer, (const char *)string);

    API_RETURN_INT(result);
}

API_FUNC(current_window)
{
    const char *result;

    API_INIT_FUNC(1, "current_window", API_RETURN_EMPTY);
    if (zend_parse_parameters_none () == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    result = API_PTR2STR(weechat_current_window ());

    API_RETURN_STRING(result);
}

API_FUNC(window_search_with_buffer)
{
    zend_string *z_buffer;
    struct t_gui_buffer *buffer;
    const char *result;

    API_INIT_FUNC(1, "window_search_with_buffer", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_buffer) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));

    result = API_PTR2STR(weechat_window_search_with_buffer (buffer));

    API_RETURN_STRING(result);
}

API_FUNC(window_get_integer)
{
    zend_string *z_window, *z_property;
    struct t_gui_window *window;
    char *property;
    int result;

    API_INIT_FUNC(1, "window_get_integer", API_RETURN_INT(-1));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_window,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(-1));

    window = (struct t_gui_window *)API_STR2PTR(ZSTR_VAL(z_window));
    property = ZSTR_VAL(z_property);

    result = weechat_window_get_integer (window, (const char *)property);

    API_RETURN_INT(result);
}

API_FUNC(window_get_string)
{
    zend_string *z_window, *z_property;
    struct t_gui_window *window;
    char *property;
    const char *result;

    API_INIT_FUNC(1, "window_get_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_window,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    window = (struct t_gui_window *)API_STR2PTR(ZSTR_VAL(z_window));
    property = ZSTR_VAL(z_property);

    result = weechat_window_get_string (window, (const char *)property);

    API_RETURN_STRING(result);
}

API_FUNC(window_get_pointer)
{
    zend_string *z_window, *z_property;
    struct t_gui_window *window;
    char *property;
    const char *result;

    API_INIT_FUNC(1, "window_get_pointer", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_window,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    window = (struct t_gui_window *)API_STR2PTR(ZSTR_VAL(z_window));
    property = ZSTR_VAL(z_property);

    result = API_PTR2STR(
        weechat_window_get_pointer (window, (const char *)property));

    API_RETURN_STRING(result);
}

API_FUNC(window_set_title)
{
    zend_string *z_title;
    char *title;

    API_INIT_FUNC(1, "window_set_title", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_title) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    title = ZSTR_VAL(z_title);

    weechat_window_set_title ((const char *)title);

    API_RETURN_OK;
}

API_FUNC(nicklist_add_group)
{
    zend_string *z_buffer, *z_parent_group, *z_name, *z_color;
    zend_long z_visible;
    struct t_gui_buffer *buffer;
    struct t_gui_nick_group *parent_group;
    char *name, *color;
    int visible;
    const char *result;

    API_INIT_FUNC(1, "nicklist_add_group", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSl", &z_buffer,
                               &z_parent_group, &z_name, &z_color,
                               &z_visible) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    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;

    result = API_PTR2STR(weechat_nicklist_add_group (buffer,
                                                     parent_group,
                                                     (const char *)name,
                                                     (const char *)color,
                                                     visible));

    API_RETURN_STRING(result);
}

API_FUNC(nicklist_search_group)
{
    zend_string *z_buffer, *z_from_group, *z_name;
    struct t_gui_buffer *buffer;
    struct t_gui_nick_group *from_group;
    char *name;
    const char *result;

    API_INIT_FUNC(1, "nicklist_search_group", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer,
                               &z_from_group, &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(weechat_nicklist_search_group (buffer,
                                                        from_group,
                                                        (const char *)name));

    API_RETURN_STRING(result);
}

API_FUNC(nicklist_add_nick)
{
    zend_string *z_buffer, *z_group, *z_name, *z_color, *z_prefix;
    zend_string *z_prefix_color;
    zend_long z_visible;
    struct t_gui_buffer *buffer;
    struct t_gui_nick_group *group;
    char *name, *color, *prefix, *prefix_color;
    int visible;
    const char *result;

    API_INIT_FUNC(1, "nicklist_add_nick", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSSSl", &z_buffer,
                               &z_group, &z_name, &z_color, &z_prefix,
                               &z_prefix_color, &z_visible) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    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;

    result = API_PTR2STR(
        weechat_nicklist_add_nick (
            buffer,
            group,
            (const char *)name,
            (const char *)color,
            (const char *)prefix,
            (const char *)prefix_color,
            visible));

    API_RETURN_STRING(result);
}

API_FUNC(nicklist_search_nick)
{
    zend_string *z_buffer, *z_from_group, *z_name;
    struct t_gui_buffer *buffer;
    struct t_gui_nick_group *from_group;
    char *name;
    const char *result;

    API_INIT_FUNC(1, "nicklist_search_nick", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer,
                               &z_from_group, &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(weechat_nicklist_search_nick (buffer,
                                                       from_group,
                                                       (const char *)name));

    API_RETURN_STRING(result);
}

API_FUNC(nicklist_remove_group)
{
    zend_string *z_buffer, *z_group;
    struct t_gui_buffer *buffer;
    struct t_gui_nick_group *group;

    API_INIT_FUNC(1, "nicklist_remove_group", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer,
                               &z_group) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

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

    API_RETURN_OK;
}

API_FUNC(nicklist_remove_nick)
{
    zend_string *z_buffer, *z_nick;
    struct t_gui_buffer *buffer;
    struct t_gui_nick *nick;

    API_INIT_FUNC(1, "nicklist_remove_nick", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer,
                               &z_nick) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

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

    API_RETURN_OK;
}

API_FUNC(nicklist_remove_all)
{
    zend_string *z_buffer;
    struct t_gui_buffer *buffer;

    API_INIT_FUNC(1, "nicklist_remove_all", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_buffer) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));

    weechat_nicklist_remove_all (buffer);

    API_RETURN_OK;
}

API_FUNC(nicklist_group_get_integer)
{
    zend_string *z_buffer, *z_group, *z_property;
    struct t_gui_buffer *buffer;
    struct t_gui_nick_group *group;
    char *property;
    int result;

    API_INIT_FUNC(1, "nicklist_group_get_integer", API_RETURN_INT(-1));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_group,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(-1));

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

    result = weechat_nicklist_group_get_integer (buffer,
                                                 group,
                                                 (const char *)property);

    API_RETURN_INT(result);
}

API_FUNC(nicklist_group_get_string)
{
    zend_string *z_buffer, *z_group, *z_property;
    struct t_gui_buffer *buffer;
    struct t_gui_nick_group *group;
    char *property;
    const char *result;

    API_INIT_FUNC(1, "nicklist_group_get_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_group,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = weechat_nicklist_group_get_string (buffer,
                                                group,
                                                (const char *)property);

    API_RETURN_STRING(result);
}

API_FUNC(nicklist_group_get_pointer)
{
    zend_string *z_buffer, *z_group, *z_property;
    struct t_gui_buffer *buffer;
    struct t_gui_nick_group *group;
    char *property;
    const char *result;

    API_INIT_FUNC(1, "nicklist_group_get_pointer", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_group,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        weechat_nicklist_group_get_pointer (buffer,
                                            group,
                                            (const char *)property));

    API_RETURN_STRING(result);
}

API_FUNC(nicklist_group_set)
{
    zend_string *z_buffer, *z_group, *z_property, *z_value;
    struct t_gui_buffer *buffer;
    struct t_gui_nick_group *group;
    char *property, *value;

    API_INIT_FUNC(1, "nicklist_group_set", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSS", &z_buffer, &z_group,
                               &z_property, &z_value) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

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

    API_RETURN_OK;
}

API_FUNC(nicklist_nick_get_integer)
{
    zend_string *z_buffer, *z_nick, *z_property;
    struct t_gui_buffer *buffer;
    struct t_gui_nick *nick;
    char *property;
    int result;

    API_INIT_FUNC(1, "nicklist_nick_get_integer", API_RETURN_INT(-1));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_nick,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(-1));

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

    result = weechat_nicklist_nick_get_integer (buffer,
                                                nick,
                                                (const char *)property);

    API_RETURN_INT(result);
}

API_FUNC(nicklist_nick_get_string)
{
    zend_string *z_buffer, *z_nick, *z_property;
    struct t_gui_buffer *buffer;
    struct t_gui_nick *nick;
    char *property;
    const char *result;

    API_INIT_FUNC(1, "nicklist_nick_get_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_nick,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = weechat_nicklist_nick_get_string (buffer,
                                               nick,
                                               (const char *)property);

    API_RETURN_STRING(result);
}

API_FUNC(nicklist_nick_get_pointer)
{
    zend_string *z_buffer, *z_nick, *z_property;
    struct t_gui_buffer *buffer;
    struct t_gui_nick *nick;
    char *property;
    const char *result;

    API_INIT_FUNC(1, "nicklist_nick_get_pointer", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_buffer, &z_nick,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = API_PTR2STR(
        weechat_nicklist_nick_get_pointer (buffer,
                                           nick,
                                           (const char *)property));

    API_RETURN_STRING(result);
}

API_FUNC(nicklist_nick_set)
{
    zend_string *z_buffer, *z_nick, *z_property, *z_value;
    struct t_gui_buffer *buffer;
    struct t_gui_nick *nick;
    char *property, *value;

    API_INIT_FUNC(1, "nicklist_nick_set", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSS", &z_buffer, &z_nick,
                               &z_property, &z_value) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

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

    API_RETURN_OK;
}

API_FUNC(bar_item_search)
{
    zend_string *z_name;
    char *name;
    const char *result;

    API_INIT_FUNC(1, "bar_item_search", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    name = ZSTR_VAL(z_name);

    result = API_PTR2STR(weechat_bar_item_search ((const char *)name));

    API_RETURN_STRING(result);
}

static char *
weechat_php_api_bar_item_new_build_cb (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] = (char *)API_PTR2STR(item);
    func_argv[2] = (char *)API_PTR2STR(window);
    func_argv[3] = (char *)API_PTR2STR(buffer);
    func_argv[4] = extra_info;

    weechat_php_cb (pointer, data, func_argv, "ssssh",
                    WEECHAT_SCRIPT_EXEC_STRING, &rc);

    return rc;
}

API_FUNC(bar_item_new)
{
    zend_string *z_name, *z_data;
    zval *z_build_callback;
    char *name, *data;
    const char *result;

    API_INIT_FUNC(1, "bar_item_new", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_name,
                               &z_build_callback, &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    name = ZSTR_VAL(z_name);
    weechat_php_get_function_name (z_build_callback, build_callback_name);
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(
        plugin_script_api_bar_item_new (
            weechat_php_plugin,
            php_current_script,
            (const char *)name,
            &weechat_php_api_bar_item_new_build_cb,
            (const char *)build_callback_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

API_FUNC(bar_item_update)
{
    zend_string *z_name;
    char *name;

    API_INIT_FUNC(1, "bar_item_update", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    name = ZSTR_VAL(z_name);

    weechat_bar_item_update ((const char *)name);

    API_RETURN_OK;
}

API_FUNC(bar_item_remove)
{
    zend_string *z_item;
    struct t_gui_bar_item *item;

    API_INIT_FUNC(1, "bar_item_remove", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_item) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    item = (struct t_gui_bar_item *)API_STR2PTR(ZSTR_VAL(z_item));

    weechat_bar_item_remove (item);

    API_RETURN_OK;
}

API_FUNC(bar_search)
{
    zend_string *z_name;
    char *name;
    const char *result;

    API_INIT_FUNC(1, "bar_search", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    name = ZSTR_VAL(z_name);

    result = API_PTR2STR(weechat_bar_search ((const char *)name));

    API_RETURN_STRING(result);
}

API_FUNC(bar_new)
{
    zend_string *z_name, *z_hidden, *z_priority, *z_type, *z_condition;
    zend_string *z_position, *z_filling_top_bottom, *z_filling_left_right;
    zend_string *z_size, *z_size_max, *z_color_fg, *z_color_delim, *z_color_bg;
    zend_string *z_color_bg_inactive, *z_separator, *z_items;
    char *name, *hidden, *priority, *type, *condition, *position;
    char *filling_top_bottom, *filling_left_right, *size, *size_max, *color_fg;
    char *color_delim, *color_bg, *color_bg_inactive, *separator, *items;
    const char *result;

    API_INIT_FUNC(1, "bar_new", API_RETURN_EMPTY);
    if (zend_parse_parameters (
            ZEND_NUM_ARGS(), "SSSSSSSSSSSSSSSS", &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_color_bg_inactive,
            &z_separator, &z_items) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    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);
    color_bg_inactive = ZSTR_VAL(z_color_bg_inactive);
    separator = ZSTR_VAL(z_separator);
    items = ZSTR_VAL(z_items);

    result = API_PTR2STR(
        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 *)color_bg_inactive,
            (const char *)separator,
            (const char *)items));

    API_RETURN_STRING(result);
}

API_FUNC(bar_set)
{
    zend_string *z_bar, *z_property, *z_value;
    struct t_gui_bar *bar;
    char *property, *value;
    int result;

    API_INIT_FUNC(1, "bar_set", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_bar, &z_property,
                               &z_value) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    bar = (struct t_gui_bar *)API_STR2PTR(ZSTR_VAL(z_bar));
    property = ZSTR_VAL(z_property);
    value = ZSTR_VAL(z_value);

    result = weechat_bar_set (bar, (const char *)property, (const char *)value);

    API_RETURN_INT(result);
}

API_FUNC(bar_update)
{
    zend_string *z_name;
    char *name;

    API_INIT_FUNC(1, "bar_update", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    name = ZSTR_VAL(z_name);
    weechat_bar_update ((const char *)name);

    API_RETURN_OK;
}

API_FUNC(bar_remove)
{
    zend_string *z_bar;
    struct t_gui_bar *bar;

    API_INIT_FUNC(1, "bar_remove", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_bar) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    bar = (struct t_gui_bar *)API_STR2PTR(ZSTR_VAL(z_bar));

    weechat_bar_remove (bar);

    API_RETURN_OK;
}

API_FUNC(command)
{
    zend_string *z_buffer, *z_command;
    struct t_gui_buffer *buffer;
    char *command;
    int result;

    API_INIT_FUNC(1, "command", API_RETURN_INT(WEECHAT_RC_ERROR));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_buffer,
                               &z_command) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_RC_ERROR));

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));
    command = ZSTR_VAL(z_command);

    result = plugin_script_api_command (weechat_php_plugin,
                                        php_current_script,
                                        buffer,
                                        (const char *)command);

    API_RETURN_INT(result);
}

API_FUNC(command_options)
{
    zend_string *z_buffer, *z_command;
    zval *z_options;
    struct t_gui_buffer *buffer;
    char *command;
    struct t_hashtable *options;
    int result;

    API_INIT_FUNC(1, "command", API_RETURN_INT(WEECHAT_RC_ERROR));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSa", &z_buffer,
                               &z_command, &z_options) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(WEECHAT_RC_ERROR));

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));
    command = ZSTR_VAL(z_command);
    options = weechat_php_array_to_hashtable (
        z_options,
        WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
        WEECHAT_HASHTABLE_STRING,
        WEECHAT_HASHTABLE_STRING);

    result = plugin_script_api_command_options (weechat_php_plugin,
                                                php_current_script,
                                                buffer,
                                                (const char *)command,
                                                options);

    if (options)
        weechat_hashtable_free (options);

    API_RETURN_INT(result);
}

API_FUNC(completion_new)
{
    zend_string *z_buffer;
    struct t_gui_buffer *buffer;
    const char *result;

    API_INIT_FUNC(1, "completion_new", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_buffer) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    buffer = (struct t_gui_buffer *)API_STR2PTR(ZSTR_VAL(z_buffer));

    result = API_PTR2STR(weechat_completion_new (buffer));

    API_RETURN_STRING(result);
}

API_FUNC(completion_search)
{
    zend_string *z_completion, *z_data;
    zend_long z_position, z_direction;
    char *data;
    struct t_gui_completion *completion;
    int position, direction, rc;

    API_INIT_FUNC(1, "completion_search", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSll", &z_completion, &z_data,
                               &z_position, &z_direction) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    completion = (struct t_gui_completion *)API_STR2PTR(ZSTR_VAL(z_completion));
    data = ZSTR_VAL(z_data);
    position = (int)z_position;
    direction = (int)z_direction;

    rc = weechat_completion_search (completion, data, position, direction);

    API_RETURN_INT(rc);
}

API_FUNC(completion_get_string)
{
    zend_string *z_completion, *z_property;
    struct t_gui_completion *completion;
    char *property;
    const char *result;

    API_INIT_FUNC(1, "completion_get_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_completion,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    completion = (struct t_gui_completion *)API_STR2PTR(ZSTR_VAL(z_completion));
    property = ZSTR_VAL(z_property);

    result = weechat_completion_get_string (completion,
                                            (const char *)property);

    API_RETURN_STRING(result);
}

API_FUNC(completion_list_add)
{
    zend_string *z_completion, *z_word, *z_where;
    zend_long z_nick_completion;
    struct t_gui_completion *completion;
    char *word, *where;
    int nick_completion;

    API_INIT_FUNC(1, "completion_list_add", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSlS", &z_completion,
                               &z_word, &z_nick_completion, &z_where) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    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_completion_list_add (completion,
                                 (const char *)word,
                                 nick_completion,
                                 (const char *)where);

    API_RETURN_OK;
}

API_FUNC(completion_free)
{
    zend_string *z_completion;
    struct t_gui_completion *completion;

    API_INIT_FUNC(1, "completion_free", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_completion) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    completion = (struct t_gui_completion *)API_STR2PTR(ZSTR_VAL(z_completion));

    weechat_completion_free (completion);

    API_RETURN_OK;
}

API_FUNC(info_get)
{
    zend_string *z_info_name, *z_arguments;
    char *info_name, *arguments, *result;

    API_INIT_FUNC(1, "info_get", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_info_name,
                               &z_arguments) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    info_name = ZSTR_VAL(z_info_name);
    arguments = ZSTR_VAL(z_arguments);

    result = weechat_info_get ((const char *)info_name,
                               (const char *)arguments);

    API_RETURN_STRING_FREE(result);
}

API_FUNC(info_get_hashtable)
{
    zend_string *z_info_name;
    zval *z_hashtable;
    char *info_name;
    struct t_hashtable *hashtable, *result;

    API_INIT_FUNC(1, "info_get_hashtable", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "Sa", &z_info_name,
                               &z_hashtable) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

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

    result = weechat_info_get_hashtable ((const char *)info_name, hashtable);

    if (hashtable)
        weechat_hashtable_free (hashtable);

    weechat_php_hashtable_to_array (result, return_value);
}

API_FUNC(infolist_new)
{
    const char *result;

    API_INIT_FUNC(1, "infolist_new", API_RETURN_EMPTY);
    if (zend_parse_parameters_none () == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    result = API_PTR2STR(weechat_infolist_new ());

    API_RETURN_STRING(result);
}

API_FUNC(infolist_new_item)
{
    zend_string *z_infolist;
    struct t_infolist *infolist;
    const char *result;

    API_INIT_FUNC(1, "infolist_new_item", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_infolist) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist));

    result = API_PTR2STR(weechat_infolist_new_item (infolist));

    API_RETURN_STRING(result);
}

API_FUNC(infolist_new_var_integer)
{
    zend_string *z_item, *z_name;
    zend_long z_value;
    struct t_infolist_item *item;
    char *name;
    int value;
    const char *result;

    API_INIT_FUNC(1, "infolist_new_var_integer", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl", &z_item, &z_name,
                               &z_value) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    item = (struct t_infolist_item *)API_STR2PTR(ZSTR_VAL(z_item));
    name = ZSTR_VAL(z_name);
    value = (int)z_value;

    result = API_PTR2STR(weechat_infolist_new_var_integer (item,
                                                           (const char *)name,
                                                           value));

    API_RETURN_STRING(result);
}

API_FUNC(infolist_new_var_string)
{
    zend_string *z_item, *z_name, *z_value;
    struct t_infolist_item *item;
    char *name, *value;
    const char *result;

    API_INIT_FUNC(1, "infolist_new_var_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_item, &z_name,
                               &z_value) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    item = (struct t_infolist_item *)API_STR2PTR(ZSTR_VAL(z_item));
    name = ZSTR_VAL(z_name);
    value = ZSTR_VAL(z_value);

    result = API_PTR2STR(
        weechat_infolist_new_var_string (item,
                                         (const char *)name,
                                         (const char *)value));

    API_RETURN_STRING(result);
}

API_FUNC(infolist_new_var_pointer)
{
    zend_string *z_item, *z_name, *z_pointer;
    struct t_infolist_item *item;
    char *name;
    void *pointer;
    const char *result;

    API_INIT_FUNC(1, "infolist_new_var_pointer", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_item, &z_name,
                               &z_pointer) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    item = (struct t_infolist_item *)API_STR2PTR(ZSTR_VAL(z_item));
    name = ZSTR_VAL(z_name);
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));

    result = API_PTR2STR(
        weechat_infolist_new_var_pointer (item,
                                          (const char *)name,
                                          pointer));

    API_RETURN_STRING(result);
}

API_FUNC(infolist_new_var_time)
{
    zend_string *z_item, *z_name;
    zend_long z_time;
    struct t_infolist_item *item;
    char *name;
    time_t time;
    const char *result;

    API_INIT_FUNC(1, "infolist_new_var_time", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl", &z_item, &z_name,
                               &z_time) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    item = (struct t_infolist_item *)API_STR2PTR(ZSTR_VAL(z_item));
    name = ZSTR_VAL(z_name);
    time = (time_t)z_time;

    result = API_PTR2STR(
        weechat_infolist_new_var_time (item, (const char *)name, time));

    API_RETURN_STRING(result);
}

API_FUNC(infolist_search_var)
{
    zend_string *z_infolist, *z_name;
    struct t_infolist *infolist;
    char *name;
    const char *result;

    API_INIT_FUNC(1, "infolist_search_var", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_infolist,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist));
    name = ZSTR_VAL(z_name);

    result = API_PTR2STR(
        weechat_infolist_search_var (infolist, (const char *)name));

    API_RETURN_STRING(result);
}

API_FUNC(infolist_get)
{
    zend_string *z_infolist_name, *z_pointer, *z_arguments;
    char *infolist_name, *arguments;
    void *pointer;
    const char *result;

    API_INIT_FUNC(1, "infolist_get", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_infolist_name,
                               &z_pointer, &z_arguments) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    infolist_name = ZSTR_VAL(z_infolist_name);
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));
    arguments = ZSTR_VAL(z_arguments);

    result = API_PTR2STR(
        weechat_infolist_get ((const char *)infolist_name,
                              pointer,
                              (const char *)arguments));

    API_RETURN_STRING(result);
}

API_FUNC(infolist_next)
{
    zend_string *z_infolist;
    struct t_infolist *infolist;
    int result;

    API_INIT_FUNC(1, "infolist_next", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_infolist) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist));

    result = weechat_infolist_next (infolist);

    API_RETURN_INT(result);
}

API_FUNC(infolist_prev)
{
    zend_string *z_infolist;
    struct t_infolist *infolist;
    int result;

    API_INIT_FUNC(1, "infolist_prev", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_infolist) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist));

    result = weechat_infolist_prev (infolist);

    API_RETURN_INT(result);
}

API_FUNC(infolist_reset_item_cursor)
{
    zend_string *z_infolist;
    struct t_infolist *infolist;

    API_INIT_FUNC(1, "infolist_reset_item_cursor", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_infolist) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist));

    weechat_infolist_reset_item_cursor (infolist);

    API_RETURN_OK;
}

API_FUNC(infolist_fields)
{
    zend_string *z_infolist;
    struct t_infolist *infolist;
    const char *result;

    API_INIT_FUNC(1, "infolist_fields", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_infolist) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist));

    result = weechat_infolist_fields (infolist);

    API_RETURN_STRING(result);
}

API_FUNC(infolist_integer)
{
    zend_string *z_infolist, *z_var;
    struct t_infolist *infolist;
    char *var;
    int result;

    API_INIT_FUNC(1, "infolist_integer", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_infolist,
                               &z_var) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist));
    var = ZSTR_VAL(z_var);

    result = weechat_infolist_integer (infolist, (const char *)var);

    API_RETURN_INT(result);
}

API_FUNC(infolist_string)
{
    zend_string *z_infolist, *z_var;
    struct t_infolist *infolist;
    char *var;
    const char *result;

    API_INIT_FUNC(1, "infolist_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_infolist,
                               &z_var) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist));
    var = ZSTR_VAL(z_var);

    result = weechat_infolist_string (infolist, (const char *)var);

    API_RETURN_STRING(result);
}

API_FUNC(infolist_pointer)
{
    zend_string *z_infolist, *z_var;
    struct t_infolist *infolist;
    char *var;
    const char *result;

    API_INIT_FUNC(1, "infolist_pointer", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_infolist,
                               &z_var) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist));
    var = ZSTR_VAL(z_var);

    result = API_PTR2STR(
        weechat_infolist_pointer (infolist, (const char *)var));

    API_RETURN_STRING(result);
}

API_FUNC(infolist_time)
{
    zend_string *z_infolist, *z_var;
    struct t_infolist *infolist;
    char *var;
    time_t time;

    API_INIT_FUNC(1, "infolist_time", API_RETURN_LONG(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_infolist,
                               &z_var) == FAILURE)
        API_WRONG_ARGS(API_RETURN_LONG(0));

    infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist));
    var = ZSTR_VAL(z_var);

    time = weechat_infolist_time (infolist, (const char *)var);

    API_RETURN_LONG(time);
}

API_FUNC(infolist_free)
{
    zend_string *z_infolist;
    struct t_infolist *infolist;

    API_INIT_FUNC(1, "infolist_free", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_infolist) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    infolist = (struct t_infolist *)API_STR2PTR(ZSTR_VAL(z_infolist));

    weechat_infolist_free (infolist);

    API_RETURN_OK;
}

API_FUNC(hdata_get)
{
    zend_string *z_hdata_name;
    char *hdata_name;
    const char *result;

    API_INIT_FUNC(1, "hdata_get", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S", &z_hdata_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    hdata_name = ZSTR_VAL(z_hdata_name);

    result = API_PTR2STR(weechat_hdata_get ((const char *)hdata_name));

    API_RETURN_STRING(result);
}

API_FUNC(hdata_get_var_offset)
{
    zend_string *z_hdata, *z_name;
    struct t_hdata *hdata;
    char *name;
    int result;

    API_INIT_FUNC(1, "hdata_get_var_offset", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_hdata,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    name = ZSTR_VAL(z_name);

    result = weechat_hdata_get_var_offset (hdata, (const char *)name);

    API_RETURN_INT(result);
}

API_FUNC(hdata_get_var_type_string)
{
    zend_string *z_hdata, *z_name;
    struct t_hdata *hdata;
    char *name;
    const char *result;

    API_INIT_FUNC(1, "hdata_get_var_type_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_hdata,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    name = ZSTR_VAL(z_name);

    result = weechat_hdata_get_var_type_string (hdata, (const char *)name);

    API_RETURN_STRING(result);
}

API_FUNC(hdata_get_var_array_size)
{
    zend_string *z_hdata, *z_pointer, *z_name;
    struct t_hdata *hdata;
    void *pointer;
    char *name;
    int result;

    API_INIT_FUNC(1, "hdata_get_var_array_size", API_RETURN_INT(-1));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(-1));

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));
    name = ZSTR_VAL(z_name);

    result = weechat_hdata_get_var_array_size (hdata,
                                               pointer,
                                               (const char *)name);

    API_RETURN_INT(result);
}

API_FUNC(hdata_get_var_array_size_string)
{
    zend_string *z_hdata, *z_pointer, *z_name;
    struct t_hdata *hdata;
    void *pointer;
    char *name;
    const char *result;

    API_INIT_FUNC(1, "hdata_get_var_array_size_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));
    name = ZSTR_VAL(z_name);

    result = weechat_hdata_get_var_array_size_string (hdata,
                                                      pointer,
                                                      (const char *)name);

    API_RETURN_STRING(result);
}

API_FUNC(hdata_get_var_hdata)
{
    zend_string *z_hdata, *z_name;
    struct t_hdata *hdata;
    char *name;
    const char *result;

    API_INIT_FUNC(1, "hdata_get_var_hdata", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_hdata,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    name = ZSTR_VAL(z_name);

    result = weechat_hdata_get_var_hdata (hdata, (const char *)name);

    API_RETURN_STRING(result);
}

API_FUNC(hdata_get_list)
{
    zend_string *z_hdata, *z_name;
    struct t_hdata *hdata;
    char *name;
    const char *result;

    API_INIT_FUNC(1, "hdata_get_list", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_hdata,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    name = ZSTR_VAL(z_name);

    result = API_PTR2STR(
        weechat_hdata_get_list (hdata, (const char *)name));

    API_RETURN_STRING(result);
}

API_FUNC(hdata_check_pointer)
{
    zend_string *z_hdata, *z_list, *z_pointer;
    struct t_hdata *hdata;
    void *list, *pointer;
    int result;

    API_INIT_FUNC(1, "hdata_check_pointer", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_list,
                               &z_pointer) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

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

    result = weechat_hdata_check_pointer (hdata, list, pointer);

    API_RETURN_INT(result);
}

API_FUNC(hdata_move)
{
    zend_string *z_hdata, *z_pointer;
    zend_long z_count;
    struct t_hdata *hdata;
    void *pointer;
    int count;
    const char *result;

    API_INIT_FUNC(1, "hdata_move", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSl", &z_hdata, &z_pointer,
                               &z_count) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));
    count = (int)z_count;

    result = API_PTR2STR(weechat_hdata_move (hdata, pointer, count));

    API_RETURN_STRING(result);
}

API_FUNC(hdata_search)
{
    zend_string *z_hdata, *z_pointer, *z_search;
    zval *z_pointers, *z_extra_vars, *z_options;
    zend_long z_move;
    struct t_hdata *hdata;
    void *pointer;
    char *search;
    int move;
    const char *result;
    struct t_hashtable *pointers, *extra_vars, *options;

    API_INIT_FUNC(1, "hdata_search", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSaaal", &z_hdata,
                               &z_pointer, &z_search, &z_pointers,
                               &z_extra_vars, &z_options, &z_move) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));
    search = ZSTR_VAL(z_search);
    pointers = weechat_php_array_to_hashtable (
        z_pointers,
        WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE,
        WEECHAT_HASHTABLE_STRING,
        WEECHAT_HASHTABLE_POINTER);
    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);
    move = (int)z_move;

    result = API_PTR2STR(
        weechat_hdata_search (
            hdata,
            pointer,
            (const char *)search,
            pointers,
            extra_vars,
            options,
            move));

    if (pointers)
        weechat_hashtable_free (pointers);
    if (extra_vars)
        weechat_hashtable_free (extra_vars);
    if (options)
        weechat_hashtable_free (options);

    API_RETURN_STRING(result);
}

API_FUNC(hdata_char)
{
    zend_string *z_hdata, *z_pointer, *z_name;
    struct t_hdata *hdata;
    void *pointer;
    char *name, result;

    API_INIT_FUNC(1, "hdata_char", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));
    name = ZSTR_VAL(z_name);

    result = weechat_hdata_char (hdata, pointer, (const char *)name);

    API_RETURN_INT((int)result);
}

API_FUNC(hdata_integer)
{
    zend_string *z_hdata, *z_pointer, *z_name;
    struct t_hdata *hdata;
    void *pointer;
    char *name;
    int result;

    API_INIT_FUNC(1, "hdata_integer", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));
    name = ZSTR_VAL(z_name);

    result = weechat_hdata_integer (hdata, pointer, (const char *)name);

    API_RETURN_INT(result);
}

API_FUNC(hdata_long)
{
    zend_string *z_hdata, *z_pointer, *z_name;
    struct t_hdata *hdata;
    void *pointer;
    char *name;
    long result;

    API_INIT_FUNC(1, "hdata_long", API_RETURN_LONG(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_LONG(0));

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));
    name = ZSTR_VAL(z_name);

    result = weechat_hdata_long (hdata, pointer, (const char *)name);

    API_RETURN_LONG(result);
}

API_FUNC(hdata_string)
{
    zend_string *z_hdata, *z_pointer, *z_name;
    struct t_hdata *hdata;
    void *pointer;
    char *name;
    const char *result;

    API_INIT_FUNC(1, "hdata_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));
    name = ZSTR_VAL(z_name);

    result = weechat_hdata_string (hdata, pointer, (const char *)name);

    API_RETURN_STRING(result);
}

API_FUNC(hdata_pointer)
{
    zend_string *z_hdata, *z_pointer, *z_name;
    struct t_hdata *hdata;
    void *pointer;
    char *name;
    const char *result;

    API_INIT_FUNC(1, "hdata_pointer", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));
    name = ZSTR_VAL(z_name);

    result = API_PTR2STR(
        weechat_hdata_pointer (hdata, pointer, (const char *)name));

    API_RETURN_STRING(result);
}

API_FUNC(hdata_time)
{
    zend_string *z_hdata, *z_pointer, *z_name;
    struct t_hdata *hdata;
    void *pointer;
    char *name;
    time_t result;

    API_INIT_FUNC(1, "hdata_time", API_RETURN_LONG(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_LONG(0));

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));
    name = ZSTR_VAL(z_name);

    result = weechat_hdata_time (hdata, pointer, (const char *)name);

    API_RETURN_LONG(result);
}

API_FUNC(hdata_hashtable)
{
    zend_string *z_hdata, *z_pointer, *z_name;
    struct t_hdata *hdata;
    void *pointer;
    char *name;
    struct t_hashtable *result;

    API_INIT_FUNC(1, "hdata_hashtable", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSS", &z_hdata, &z_pointer,
                               &z_name) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    pointer = (void *)API_STR2PTR(ZSTR_VAL(z_pointer));
    name = ZSTR_VAL(z_name);

    result = weechat_hdata_hashtable (hdata, pointer, (const char *)name);

    weechat_php_hashtable_to_array (result, return_value);
}

API_FUNC(hdata_compare)
{
    zend_string *z_hdata, *z_pointer1, *z_pointer2, *z_name;
    zend_long z_case_sensitive;
    struct t_hdata *hdata;
    void *pointer1, *pointer2;
    char *name;
    int case_sensitive, result;

    API_INIT_FUNC(1, "hdata_compare", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSSSl", &z_hdata, &z_pointer1,
                               &z_pointer2, &z_name,
                               &z_case_sensitive) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    pointer1 = (void *)API_STR2PTR(ZSTR_VAL(z_pointer1));
    pointer2 = (void *)API_STR2PTR(ZSTR_VAL(z_pointer2));
    name = (void *)API_STR2PTR(ZSTR_VAL(z_name));
    case_sensitive = (int)z_case_sensitive;

    result = weechat_hdata_compare (hdata, pointer1, pointer2, name,
                                    case_sensitive);

    API_RETURN_INT(result);
}

API_FUNC(hdata_update)
{
    zend_string *z_hdata, *z_pointer;
    zval *z_hashtable;
    int result;
    struct t_hdata *hdata;
    void *pointer;
    struct t_hashtable *hashtable;

    API_INIT_FUNC(1, "hdata_update", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SSa", &z_hdata, &z_pointer,
                               &z_hashtable) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

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

    result = weechat_hdata_update (hdata, pointer, hashtable);

    if (hashtable)
        weechat_hashtable_free (hashtable);

    API_RETURN_INT(result);
}

API_FUNC(hdata_get_string)
{
    zend_string *z_hdata, *z_property;
    struct t_hdata *hdata;
    char *property;
    const char *result;

    API_INIT_FUNC(1, "hdata_get_string", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SS", &z_hdata,
                               &z_property) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    hdata = (struct t_hdata *)API_STR2PTR(ZSTR_VAL(z_hdata));
    property = ZSTR_VAL(z_property);

    result = weechat_hdata_get_string (hdata, (const char *)property);

    API_RETURN_STRING(result);
}

static int
weechat_php_api_upgrade_read_cb (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] = (char *)API_PTR2STR(upgrade_file);
    func_argv[2] = &object_id;
    func_argv[3] = (char *)API_PTR2STR(infolist);

    weechat_php_cb (pointer, data, func_argv, "ssis",
                    WEECHAT_SCRIPT_EXEC_INT, &rc);

    return rc;
}

API_FUNC(upgrade_new)
{
    zend_string *z_filename, *z_data;
    zval *z_callback_read;
    char *filename;
    char *data;
    const char *result;

    API_INIT_FUNC(1, "upgrade_new", API_RETURN_EMPTY);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SzS", &z_filename,
                               &z_callback_read, &z_data) == FAILURE)
        API_WRONG_ARGS(API_RETURN_EMPTY);

    filename = ZSTR_VAL(z_filename);
    weechat_php_get_function_name (z_callback_read, callback_read_name);
    data = ZSTR_VAL(z_data);

    result = API_PTR2STR(
        plugin_script_api_upgrade_new (
            weechat_php_plugin,
            php_current_script,
            (const char *)filename,
            &weechat_php_api_upgrade_read_cb,
            (const char *)callback_read_name,
            (const char *)data));

    API_RETURN_STRING(result);
}

API_FUNC(upgrade_write_object)
{
    zend_string *z_upgrade_file, *z_infolist;
    zend_long z_object_id;
    struct t_upgrade_file *upgrade_file;
    int object_id;
    struct t_infolist *infolist;
    int result;

    API_INIT_FUNC(1, "upgrade_write_object", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "SlS", &z_upgrade_file,
                               &z_object_id, &z_infolist) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

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

    result = weechat_upgrade_write_object (upgrade_file, object_id, infolist);

    API_RETURN_INT(result);
}

API_FUNC(upgrade_read)
{
    zend_string *z_upgrade_file;
    struct t_upgrade_file *upgrade_file;
    int result;

    API_INIT_FUNC(1, "upgrade_read", API_RETURN_INT(0));
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S",
                               &z_upgrade_file) == FAILURE)
        API_WRONG_ARGS(API_RETURN_INT(0));

    upgrade_file = (struct t_upgrade_file *)API_STR2PTR(ZSTR_VAL(z_upgrade_file));

    result = weechat_upgrade_read (upgrade_file);

    API_RETURN_INT(result);
}

API_FUNC(upgrade_close)
{
    zend_string *z_upgrade_file;
    struct t_upgrade_file *upgrade_file;

    API_INIT_FUNC(1, "upgrade_close", API_RETURN_ERROR);
    if (zend_parse_parameters (ZEND_NUM_ARGS(), "S",
                               &z_upgrade_file) == FAILURE)
        API_WRONG_ARGS(API_RETURN_ERROR);

    upgrade_file = (struct t_upgrade_file *)API_STR2PTR(ZSTR_VAL(z_upgrade_file));

    weechat_upgrade_close (upgrade_file);

    API_RETURN_OK;
}

static void
forget_hash_entry (HashTable *ht, INTERNAL_FUNCTION_PARAMETERS)
{
#if PHP_VERSION_ID >= 80000
    /* make C compiler happy */
    (void) ht;
    (void) execute_data;

    RETURN_FALSE;
#else
    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;
#endif
}

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