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

char *script_config_get_dir (){    const char *weechat_home;    char *path, *path2;    weechat_home = weechat_info_get ("weechat_dir", NULL);    path = weechat_string_expand_home (weechat_config_string (script_config_scripts_dir));    path2 = weechat_string_replace ((path) ?                                    path : weechat_config_string (script_config_scripts_dir),                                    "%h", weechat_home);    if (path && path2)    {        free (path);        path = NULL;    }    if (path2)        return path2;    if (path)        return path;    return strdup (weechat_config_string (script_config_scripts_dir));}

voidbuflist_config_change_format (const void *pointer, void *data,                              struct t_config_option *option){    /* make C compiler happy */    (void) pointer;    (void) data;    (void) option;    if (buflist_config_format_buffer_eval)        free (buflist_config_format_buffer_eval);    buflist_config_format_buffer_eval = buflist_config_add_eval_for_formats (        weechat_config_string (buflist_config_format_buffer));    if (buflist_config_format_buffer_current_eval)        free (buflist_config_format_buffer_current_eval);    buflist_config_format_buffer_current_eval = buflist_config_add_eval_for_formats (        weechat_config_string (buflist_config_format_buffer_current));    if (buflist_config_format_hotlist_eval)        free (buflist_config_format_hotlist_eval);    buflist_config_format_hotlist_eval = buflist_config_add_eval_for_formats (        weechat_config_string (buflist_config_format_hotlist));    buflist_bar_item_update (0);}

const char *irc_ctcp_get_reply (struct t_irc_server *server, const char *ctcp){    struct t_config_option *ptr_option;    char option_name[512];    snprintf (option_name, sizeof (option_name), "%s.%s", server->name, ctcp);    /* search for CTCP in config file, for server */    ptr_option = weechat_config_search_option (irc_config_file,                                               irc_config_section_ctcp,                                               option_name);    if (ptr_option)        return weechat_config_string (ptr_option);    /* search for CTCP in config file */    ptr_option = weechat_config_search_option (irc_config_file,                                               irc_config_section_ctcp,                                               ctcp);    if (ptr_option)        return weechat_config_string (ptr_option);    /*     * no CTCP reply found in config, then return default reply, or NULL     * for unknown CTCP     */    return irc_ctcp_get_default_reply (ctcp);}

voidscript_config_unhold (const char *name_with_extension){    char **items, *hold;    int num_items, i, length;    length = strlen (weechat_config_string (script_config_scripts_hold)) + 1;    hold = malloc (length);    if (hold)    {        hold[0] = '/0';        items = weechat_string_split (weechat_config_string (script_config_scripts_hold),                                      ",", 0, 0, &num_items);        if (items)        {            for (i = 0; i < num_items; i++)            {                if (strcmp (items[i], name_with_extension) != 0)                {                    if (hold[0])                        strcat (hold, ",");                    strcat (hold, items[i]);                }            }            weechat_string_free_split (items);        }        weechat_config_option_set (script_config_scripts_hold, hold, 0);        free (hold);    }}

int weechat_plugin_init(struct t_weechat_plugin *plugin, int argc, char *argv[]) {    weechat_plugin = plugin;    SilcClientParams params;    if (silc_plugin_config_init() < 0) {        weechat_log_printf("could not initialize SILC plugin config");        return WEECHAT_RC_ERROR;    }    if (silc_plugin_config_read() < 0) {        weechat_log_printf("could not read SILC plugin config file");        return WEECHAT_RC_ERROR;    }    memset(&params, 0, sizeof(params));    params.threads = TRUE;    silc_plugin = silc_calloc(1, sizeof(*silc_plugin));    if (!silc_plugin) {        weechat_log_printf("could not allocate plugin context");        return WEECHAT_RC_ERROR;    }    weechat_log_printf("SILC plugin context allocated");    silc_plugin->client = silc_client_alloc(&ops, &params, silc_plugin, NULL);    if (!silc_plugin->client) {        weechat_log_printf("could not allocate SILC client");        return WEECHAT_RC_ERROR;    }    weechat_log_printf("SILC client allocated");    if (!silc_client_init(silc_plugin->client, weechat_config_string(option_default_username),                silc_net_localhost(), weechat_config_string(option_default_realname), silc_running, silc_plugin)) {        weechat_log_printf("could not initialize SILC client");        return WEECHAT_RC_ERROR;    }    // tick the client once to complete the initialization    silc_client_run_one(silc_plugin->client);    weechat_log_printf("SILC client initialized");    silc_plugin_get_keypair("weechat", "", 1, &silc_plugin->public_key, &silc_plugin->private_key);    server_list = malloc(sizeof(struct SilcPluginServer));    memset(server_list, 0, sizeof(struct SilcPluginServer));    weechat_hook_command("silc", "This is the SILC plugin", "", "", NULL, &command_silc, NULL);    weechat_hook_timer(50, 0, 0, &timer_silc, NULL);    silc_bar_init();    return WEECHAT_RC_OK;}

const char *weechat_aspell_get_dict (struct t_gui_buffer *buffer){    char *name, *option_name, *ptr_end;    struct t_config_option *ptr_option;    name = weechat_aspell_build_option_name (buffer);    if (!name)        return NULL;    option_name = strdup (name);    if (option_name)    {        ptr_end = option_name + strlen (option_name);        while (ptr_end >= option_name)        {            ptr_option = weechat_aspell_config_get_dict (option_name);            if (ptr_option)            {                free (option_name);                free (name);                return weechat_config_string (ptr_option);            }            ptr_end--;            while ((ptr_end >= option_name) && (ptr_end[0] != '.'))            {                ptr_end--;            }            if ((ptr_end >= option_name) && (ptr_end[0] == '.'))                ptr_end[0] = '/0';        }        ptr_option = weechat_aspell_config_get_dict (option_name);        free (option_name);        free (name);        if (ptr_option)            return weechat_config_string (ptr_option);    }    else        free (name);    /* nothing found => return default dictionary (if set) */    if (weechat_config_string (weechat_aspell_config_check_default_dict)        && weechat_config_string (weechat_aspell_config_check_default_dict)[0])        return weechat_config_string (weechat_aspell_config_check_default_dict);    /* no default dictionary set */    return NULL;}

const char *logger_get_mask_for_buffer (struct t_gui_buffer *buffer){    char *name, *option_name, *ptr_end;    struct t_config_option *ptr_option;    name = logger_build_option_name (buffer);    if (!name)        return NULL;    option_name = strdup (name);    if (option_name)    {        ptr_end = option_name + strlen (option_name);        while (ptr_end >= option_name)        {            ptr_option = logger_config_get_mask (option_name);            if (ptr_option)            {                free (option_name);                free (name);                return weechat_config_string (ptr_option);            }            ptr_end--;            while ((ptr_end >= option_name) && (ptr_end[0] != '.'))            {                ptr_end--;            }            if ((ptr_end >= option_name) && (ptr_end[0] == '.'))                ptr_end[0] = '/0';        }        ptr_option = logger_config_get_mask (option_name);        free (option_name);        free (name);        if (ptr_option)            return weechat_config_string (ptr_option);    }    else        free (name);    /* nothing found => return default mask (if set) */    if (weechat_config_string (logger_config_file_mask)        && weechat_config_string (logger_config_file_mask)[0])        return weechat_config_string (logger_config_file_mask);    /* no default mask set */    return NULL;}

voidrelay_weechat_alloc (struct t_relay_client *client){    struct t_relay_weechat_data *weechat_data;    const char *password;    password = weechat_config_string (relay_config_network_password);    client->protocol_data = malloc (sizeof (*weechat_data));    if (client->protocol_data)    {        RELAY_WEECHAT_DATA(client, password_ok) = (password && password[0]) ? 0 : 1;#ifdef HAVE_ZLIB        RELAY_WEECHAT_DATA(client, compression) = 1;#else        RELAY_WEECHAT_DATA(client, compression) = 0;#endif        RELAY_WEECHAT_DATA(client, buffers_sync) =            weechat_hashtable_new (16,                                   WEECHAT_HASHTABLE_STRING,                                   WEECHAT_HASHTABLE_INTEGER,                                   NULL,                                   NULL);        RELAY_WEECHAT_DATA(client, hook_signal_buffer) = NULL;        RELAY_WEECHAT_DATA(client, hook_signal_nicklist) = NULL;        RELAY_WEECHAT_DATA(client, buffers_nicklist) =            weechat_hashtable_new (16,                                   WEECHAT_HASHTABLE_STRING,                                   WEECHAT_HASHTABLE_STRING,                                   NULL,                                   NULL);        RELAY_WEECHAT_DATA(client, hook_timer_nicklist) = NULL;    }}

voidrelay_config_change_network_allowed_ips (void *data,                                         struct t_config_option *option){    const char *allowed_ips;    /* make C compiler happy */    (void) data;    (void) option;    if (relay_config_regex_allowed_ips)    {        regfree (relay_config_regex_allowed_ips);        free (relay_config_regex_allowed_ips);        relay_config_regex_allowed_ips = NULL;    }    allowed_ips = weechat_config_string (relay_config_network_allowed_ips);    if (allowed_ips && allowed_ips[0])    {        relay_config_regex_allowed_ips = malloc (sizeof (*relay_config_regex_allowed_ips));        if (relay_config_regex_allowed_ips)        {            if (weechat_string_regcomp (relay_config_regex_allowed_ips,                                        allowed_ips,                                        REG_EXTENDED | REG_ICASE) != 0)            {                free (relay_config_regex_allowed_ips);                relay_config_regex_allowed_ips = NULL;            }        }    }}

voidrelay_config_change_irc_backlog_tags (void *data,                                      struct t_config_option *option){    char **items;    int num_items, i;    /* make C compiler happy */    (void) data;    (void) option;    if (!relay_config_hashtable_irc_backlog_tags)    {        relay_config_hashtable_irc_backlog_tags = weechat_hashtable_new (32,                                                                         WEECHAT_HASHTABLE_STRING,                                                                         WEECHAT_HASHTABLE_STRING,                                                                         NULL,                                                                         NULL);    }    else        weechat_hashtable_remove_all (relay_config_hashtable_irc_backlog_tags);    items = weechat_string_split (weechat_config_string (relay_config_irc_backlog_tags),                                  ";", 0, 0, &num_items);    if (items)    {        for (i = 0; i < num_items; i++)        {            weechat_hashtable_set (relay_config_hashtable_irc_backlog_tags,                                   items[i],                                   NULL);        }        weechat_string_free_split (items);    }}

voidlogger_stop (struct t_logger_buffer *logger_buffer, int write_info_line){    time_t seconds;    struct tm *date_tmp;    char buf_time[256];    if (!logger_buffer)        return;    if (logger_buffer->log_enabled && logger_buffer->log_file)    {        if (write_info_line && weechat_config_boolean (logger_config_file_info_lines))        {            buf_time[0] = '/0';            seconds = time (NULL);            date_tmp = localtime (&seconds);            if (date_tmp)            {                strftime (buf_time, sizeof (buf_time) - 1,                          weechat_config_string (logger_config_file_time_format),                          date_tmp);            }            logger_write_line (logger_buffer,                               _("%s/t****  End of log  ****"),                               buf_time);        }        fclose (logger_buffer->log_file);        logger_buffer->log_file = NULL;    }    logger_buffer_free (logger_buffer);}

intirc_mode_smart_filtered (struct t_irc_server *server, char mode){    const char *ptr_modes;    ptr_modes = weechat_config_string (irc_config_look_smart_filter_mode);    /* if empty value, there's no smart filtering on mode messages */    if (!ptr_modes || !ptr_modes[0])        return 0;    /* if var is "*", ALL modes are smart filtered */    if (strcmp (ptr_modes, "*") == 0)        return 1;    /* if var is "+", modes from server prefixes are filtered */    if (strcmp (ptr_modes, "+") == 0)        return strchr (irc_server_get_prefix_modes (server), mode) ? 1 : 0;    /*     * if var starts with "-", smart filter all modes except following modes     * example: "-kl": smart filter all modes but not k/l     */    if (ptr_modes[0] == '-')        return (strchr (ptr_modes + 1, mode)) ? 0 : 1;    /*     * explicit list of modes to smart filter     * example: "ovh": smart filter modes o/v/h     */    return (strchr (ptr_modes, mode)) ? 1 : 0;}

const char *charset_get (struct t_config_section *section, const char *name,             struct t_config_option *default_charset){    char *option_name, *ptr_end;    struct t_config_option *ptr_option;    option_name = strdup (name);    if (option_name)    {        ptr_end = option_name + strlen (option_name);        while (ptr_end >= option_name)        {            ptr_option = weechat_config_search_option (charset_config_file,                                                       section,                                                       option_name);            if (ptr_option)            {                free (option_name);                return weechat_config_string (ptr_option);            }            ptr_end--;            while ((ptr_end >= option_name) && (ptr_end[0] != '.'))            {                ptr_end--;            }            if ((ptr_end >= option_name) && (ptr_end[0] == '.'))                ptr_end[0] = '/0';        }        ptr_option = weechat_config_search_option (charset_config_file,                                                   section,                                                   option_name);        free (option_name);        if (ptr_option)            return weechat_config_string (ptr_option);    }    /* nothing found => return default decode/encode charset (if set) */    if (weechat_config_string (default_charset)        && weechat_config_string (default_charset)[0])        return weechat_config_string (default_charset);    /* no default charset set */    return NULL;}

intlogger_print_cb (void *data, struct t_gui_buffer *buffer, time_t date,                 int tags_count, const char **tags,                 int displayed, int highlight,                 const char *prefix, const char *message){    struct t_logger_buffer *ptr_logger_buffer;    struct tm *date_tmp;    char buf_time[256];    int line_log_level, prefix_is_nick;    /* make C compiler happy */    (void) data;    (void) displayed;    (void) highlight;    logger_get_line_tag_info (tags_count, tags, &line_log_level,                              &prefix_is_nick);    if (line_log_level >= 0)    {        ptr_logger_buffer = logger_buffer_search_buffer (buffer);        if (ptr_logger_buffer            && ptr_logger_buffer->log_enabled            && (date > 0)            && (line_log_level <= ptr_logger_buffer->log_level))        {            buf_time[0] = '/0';            date_tmp = localtime (&date);            if (date_tmp)            {                strftime (buf_time, sizeof (buf_time) - 1,                          weechat_config_string (logger_config_file_time_format),                          date_tmp);            }            logger_write_line (ptr_logger_buffer,                               "%s/t%s%s%s/t%s",                               buf_time,                               (prefix && prefix_is_nick) ? weechat_config_string (logger_config_file_nick_prefix) : "",                               (prefix) ? prefix : "",                               (prefix && prefix_is_nick) ? weechat_config_string (logger_config_file_nick_suffix) : "",                               message);        }    }    return WEECHAT_RC_OK;}

voidscript_buffer_refresh (int clear){    struct t_script_repo *ptr_script;    int line;    char str_title[1024];    if (!script_buffer)        return;    if (clear)    {        weechat_buffer_clear (script_buffer);        script_buffer_selected_line = (script_repo_count_displayed > 0) ? 0 : -1;    }    if (script_buffer_detail_script)    {        snprintf (str_title, sizeof (str_title),                  "%s",                  _("Alt+key/input: v=back to list d=jump to diff"));    }    else    {        snprintf (str_title, sizeof (str_title),                  _("%d/%d scripts (filter: %s) | Sort: %s | "                    "Alt+key/input: i=install, r=remove, l=load, L=reload, "                    "u=unload, A=autoload, h=(un)hold, v=view script | "                    "Input: q=close, $=refresh, s:x,y=sort, words=filter, "                    "*=reset filter | Mouse: left=select, right=install/remove"),                  script_repo_count_displayed,                  script_repo_count,                  (script_repo_filter) ? script_repo_filter : "*",                  weechat_config_string (script_config_look_sort));    }    weechat_buffer_set (script_buffer, "title", str_title);    if (script_buffer_detail_script)    {        /* detail on a script */        script_buffer_display_detail_script (script_buffer_detail_script);    }    else    {        /* list of scripts */        line = 0;        for (ptr_script = scripts_repo; ptr_script;             ptr_script = ptr_script->next_script)        {            if (ptr_script->displayed)            {                script_buffer_display_line_script (line, ptr_script);                line++;            }        }    }}

voidtrigger_command_display_trigger (struct t_trigger *trigger, int verbose){    trigger_command_display_trigger_internal (        trigger->name,        weechat_config_boolean (trigger->options[TRIGGER_OPTION_ENABLED]),        weechat_config_string (trigger->options[TRIGGER_OPTION_HOOK]),        weechat_config_string (trigger->options[TRIGGER_OPTION_ARGUMENTS]),        weechat_config_string (trigger->options[TRIGGER_OPTION_CONDITIONS]),        trigger->hooks_count,        trigger->hook_count_cb,        trigger->hook_count_cmd,        trigger->regex_count,        trigger->regex,        trigger->commands_count,        trigger->commands,        weechat_config_integer (trigger->options[TRIGGER_OPTION_RETURN_CODE]),        verbose);}

voidscript_config_hold (const char *name_with_extension){    char **items, *hold;    int num_items, i, length;    length = strlen (weechat_config_string (script_config_scripts_hold)) +        1 + strlen (name_with_extension) + 1;    hold = malloc (length);    if (hold)    {        hold[0] = '/0';        items = weechat_string_split (            weechat_config_string (script_config_scripts_hold),            ",",            WEECHAT_STRING_SPLIT_STRIP_LEFT            | WEECHAT_STRING_SPLIT_STRIP_RIGHT            | WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,            0,            &num_items);        if (items)        {            for (i = 0; i < num_items; i++)            {                if (strcmp (items[i], name_with_extension) != 0)                {                    if (hold[0])                        strcat (hold, ",");                    strcat (hold, items[i]);                }            }            weechat_string_free_split (items);        }        if (hold[0])            strcat (hold, ",");        strcat (hold, name_with_extension);        weechat_config_option_set (script_config_scripts_hold, hold, 0);        free (hold);    }}

voidrelay_network_set_ssl_cert_key (int verbose){#ifdef HAVE_GNUTLS    char *certkey_path, *certkey_path2;    int ret;    gnutls_certificate_free_credentials (relay_gnutls_x509_cred);    gnutls_certificate_allocate_credentials (&relay_gnutls_x509_cred);    relay_network_init_ssl_cert_key_ok = 0;    certkey_path = weechat_string_expand_home (weechat_config_string (relay_config_network_ssl_cert_key));    if (certkey_path)    {        certkey_path2 = weechat_string_replace (certkey_path, "%h",                                                weechat_info_get ("weechat_dir",                                                                  NULL));        if (certkey_path2)        {            ret = gnutls_certificate_set_x509_key_file (relay_gnutls_x509_cred,                                                        certkey_path2,                                                        certkey_path2,                                                        GNUTLS_X509_FMT_PEM);            if (ret >= 0)            {                relay_network_init_ssl_cert_key_ok = 1;                if (verbose)                {                    weechat_printf (NULL,                                    _("%s: SSL certificate and key have been "                                      "set"),                                    RELAY_PLUGIN_NAME);                }            }            else            {                if (verbose)                {                    weechat_printf (NULL,                                    _("%s%s: warning: no SSL certificate/key "                                      "found (option relay.network.ssl_cert_key)"),                                    weechat_prefix ("error"), RELAY_PLUGIN_NAME);                }            }            free (certkey_path2);        }        free (certkey_path);    }#else    /* make C compiler happy */    (void) verbose;#endif}

const char *script_config_get_diff_command (){    const char *diff_command;    char *dir_separator;    static char result[64];    struct stat st;    char *path, **paths, bin[4096];    int num_paths, i, rc;    diff_command = weechat_config_string (script_config_look_diff_command);    if (!diff_command || !diff_command[0])        return NULL;    if (strcmp (diff_command, "auto") == 0)    {        dir_separator = weechat_info_get ("dir_separator", "");        path = getenv ("PATH");        result[0] = '/0';        if (dir_separator && path)        {            paths = weechat_string_split (path, ":",                                          WEECHAT_STRING_SPLIT_STRIP_LEFT                                          | WEECHAT_STRING_SPLIT_STRIP_RIGHT                                          | WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,                                          0, &num_paths);            if (paths)            {                for (i = 0; i < num_paths; i++)                {                    snprintf (bin, sizeof (bin), "%s%s%s",                              paths[i], dir_separator, "git");                    rc = stat (bin, &st);                    if ((rc == 0) && (S_ISREG(st.st_mode)))                    {                        snprintf (result, sizeof (result),                                  "git diff --no-index");                        break;                    }                }                weechat_string_free_split (paths);            }        }        if (dir_separator)            free (dir_separator);        if (!result[0])            snprintf (result, sizeof (result), "diff");        return result;    }    return diff_command;}

char *rmodifier_hide_string (const char *string){    int length, i;    char *result;    if (!string || !string[0])        return NULL;    length = weechat_utf8_strlen (string);    result = malloc ((length * strlen (weechat_config_string (rmodifier_config_look_hide_char))) + 1);    if (!result)        return NULL;    result[0] = '/0';    for (i = 0; i < length; i++)    {        strcat (result, weechat_config_string (rmodifier_config_look_hide_char));    }    return result;}

struct t_trigger *trigger_new_with_options (const char *name, struct t_config_option **options){    struct t_trigger *new_trigger;    int i;    new_trigger = trigger_alloc (name);    if (!new_trigger)        return NULL;    for (i = 0; i < TRIGGER_NUM_OPTIONS; i++)    {        new_trigger->options[i] = options[i];    }    trigger_add (new_trigger, &triggers, &last_trigger);    triggers_count++;    if (trigger_regex_split (weechat_config_string (new_trigger->options[TRIGGER_OPTION_REGEX]),                             &new_trigger->regex_count,                             &new_trigger->regex) < 0)    {        weechat_printf (NULL,                        _("%s%s: invalid regular expression in trigger "                          "/"%s/""),                        weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,                        name);    }    trigger_split_command (weechat_config_string (new_trigger->options[TRIGGER_OPTION_COMMAND]),                           &new_trigger->commands_count,                           &new_trigger->commands);    if (weechat_config_boolean (new_trigger->options[TRIGGER_OPTION_ENABLED]))        trigger_hook (new_trigger);    return new_trigger;}

char *script_config_get_xml_filename (){    char *path, *filename;    int length;    path = weechat_string_eval_path_home (        weechat_config_string (script_config_scripts_path), NULL, NULL, NULL);    length = strlen (path) + 64;    filename = malloc (length);    if (filename)        snprintf (filename, length, "%s/plugins.xml.gz", path);    free (path);    return filename;}

voidrelay_network_set_priority (){#ifdef HAVE_GNUTLS    if (gnutls_priority_init (relay_gnutls_priority_cache,                              weechat_config_string (                                  relay_config_network_ssl_priorities),                              NULL) != GNUTLS_E_SUCCESS)    {        weechat_printf (NULL,                        _("%s%s: unable to initialize priority for SSL"),                        weechat_prefix ("error"), RELAY_PLUGIN_NAME);        free (relay_gnutls_priority_cache);        relay_gnutls_priority_cache = NULL;    }#endif}

voidweechat_aspell_speller_remove_unused (){    struct t_hashtable *used_spellers;    struct t_infolist *infolist;    if (weechat_aspell_plugin->debug)    {        weechat_printf (NULL,                        "%s: removing unused spellers",                        ASPELL_PLUGIN_NAME);    }    /* create a hashtable that will contain all used spellers */    used_spellers = weechat_hashtable_new (32,                                           WEECHAT_HASHTABLE_STRING,                                           WEECHAT_HASHTABLE_STRING,                                           NULL,                                           NULL);    if (!used_spellers)        return;    /* collect used spellers and store them in hashtable "used_spellers" */    weechat_aspell_speller_add_dicts_to_hash (used_spellers,                                              weechat_config_string (weechat_aspell_config_check_default_dict));    infolist = weechat_infolist_get ("option", NULL, "aspell.dict.*");    if (infolist)    {        while (weechat_infolist_next (infolist))        {            weechat_aspell_speller_add_dicts_to_hash (used_spellers,                                                      weechat_infolist_string (infolist, "value"));        }        weechat_infolist_free (infolist);    }    /*     * look at current spellers, and remove spellers that are not in hashtable     * "used_spellers"     */    weechat_hashtable_map (weechat_aspell_spellers,                           &weechat_aspell_speller_remove_unused_cb,                           used_spellers);    weechat_hashtable_free (used_spellers);}

const char *irc_notify_get_tags (struct t_config_option *option, const char *type,                     const char *nick){    static char string[1024];    const char *tags;    tags = weechat_config_string (option);    snprintf (string, sizeof (string), "irc_notify,irc_notify_%s,nick_%s%s%s",              type,              nick,              (tags && tags[0]) ? "," : "",              (tags && tags[0]) ? tags : "");    return string;}

voidtrigger_config_change_trigger_command (const void *pointer, void *data,                                       struct t_config_option *option){    struct t_trigger *ptr_trigger;    /* make C compiler happy */    (void) pointer;    (void) data;    ptr_trigger = trigger_search_with_option (option);    if (!ptr_trigger)        return;    trigger_split_command (weechat_config_string (option),                           &ptr_trigger->commands_count,                           &ptr_trigger->commands);}

struct t_trigger *trigger_copy (struct t_trigger *trigger, const char *name){    if (!name || !name[0] || !trigger_name_valid (name)        || trigger_search (name))    {        return NULL;    }    return trigger_new (        name,        weechat_config_string (trigger->options[TRIGGER_OPTION_ENABLED]),        weechat_config_string (trigger->options[TRIGGER_OPTION_HOOK]),        weechat_config_string (trigger->options[TRIGGER_OPTION_ARGUMENTS]),        weechat_config_string (trigger->options[TRIGGER_OPTION_CONDITIONS]),        weechat_config_string (trigger->options[TRIGGER_OPTION_REGEX]),        weechat_config_string (trigger->options[TRIGGER_OPTION_COMMAND]),        weechat_config_string (trigger->options[TRIGGER_OPTION_RETURN_CODE]),        weechat_config_string (trigger->options[TRIGGER_OPTION_POST_ACTION]));}

voidweechat_aspell_config_change_commands (const void *pointer, void *data,                                       struct t_config_option *option){    const char *value;    int i;    /* make C compiler happy */    (void) pointer;    (void) data;    if (weechat_aspell_commands_to_check)    {        weechat_string_free_split (weechat_aspell_commands_to_check);        weechat_aspell_commands_to_check = NULL;        weechat_aspell_count_commands_to_check = 0;    }    if (weechat_aspell_length_commands_to_check)    {        free (weechat_aspell_length_commands_to_check);        weechat_aspell_length_commands_to_check = NULL;    }    value = weechat_config_string (option);    if (value && value[0])    {        weechat_aspell_commands_to_check = weechat_string_split (value,                                                                 ",", 0, 0,                                                                 &weechat_aspell_count_commands_to_check);        if (weechat_aspell_count_commands_to_check > 0)        {            weechat_aspell_length_commands_to_check = malloc (weechat_aspell_count_commands_to_check *                                                              sizeof (int));            for (i = 0; i < weechat_aspell_count_commands_to_check; i++)            {                weechat_aspell_length_commands_to_check[i] = strlen (weechat_aspell_commands_to_check[i]);            }        }    }}

voidtrigger_config_change_trigger_regex (const void *pointer, void *data,                                     struct t_config_option *option){    struct t_trigger *ptr_trigger;    /* make C compiler happy */    (void) pointer;    (void) data;    ptr_trigger = trigger_search_with_option (option);    if (!ptr_trigger)        return;    switch (trigger_regex_split (weechat_config_string (option),                                 &ptr_trigger->regex_count,                                 &ptr_trigger->regex))    {        case 0: /* OK */            break;        case -1: /* format error */            weechat_printf (NULL,                            _("%s%s: invalid format for option /"regex/", "                              "see /help trigger.trigger.%s.regex"),                            weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,                            ptr_trigger->name);            break;        case -2: /* regex compilation error */            weechat_printf (NULL,                            _("%s%s: invalid regular expression in option "                              "/"regex/", see /help trigger.trigger.%s.regex"),                            weechat_prefix ("error"), TRIGGER_PLUGIN_NAME,                            ptr_trigger->name);            break;        case -3: /* memory error */            weechat_printf (NULL,                            _("%s%s: not enough memory"),                            weechat_prefix ("error"), TRIGGER_PLUGIN_NAME);            break;    }}