void
exec_buffer_set_callbacks ()
{
struct t_infolist *ptr_infolist;
struct t_gui_buffer *ptr_buffer;
const char *plugin_name;
ptr_infolist = weechat_infolist_get ("buffer", NULL, "");
if (ptr_infolist)
{
while (weechat_infolist_next (ptr_infolist))
{
ptr_buffer = weechat_infolist_pointer (ptr_infolist, "pointer");
plugin_name = weechat_infolist_string (ptr_infolist, "plugin_name");
if (ptr_buffer && plugin_name
&& (strcmp (plugin_name, EXEC_PLUGIN_NAME) == 0))
{
weechat_buffer_set_pointer (ptr_buffer, "close_callback",
&exec_buffer_close_cb);
weechat_buffer_set_pointer (ptr_buffer, "input_callback",
&exec_buffer_input_cb);
}
}
weechat_infolist_free (ptr_infolist);
}
}
void
irc_upgrade_set_buffer_callbacks ()
{
struct t_infolist *infolist;
struct t_gui_buffer *ptr_buffer;
const char *type;
infolist = weechat_infolist_get ("buffer", NULL, NULL);
if (infolist)
{
while (weechat_infolist_next (infolist))
{
if (weechat_infolist_pointer (infolist, "plugin") == weechat_irc_plugin)
{
ptr_buffer = weechat_infolist_pointer (infolist, "pointer");
weechat_buffer_set_pointer (ptr_buffer, "close_callback", &irc_buffer_close_cb);
weechat_buffer_set_pointer (ptr_buffer, "input_callback", &irc_input_data_cb);
type = weechat_buffer_get_string (ptr_buffer, "localvar_type");
if (type && (strcmp (type, "channel") == 0))
{
weechat_buffer_set_pointer (ptr_buffer, "nickcmp_callback",
&irc_buffer_nickcmp_cb);
}
if (strcmp (weechat_infolist_string (infolist, "name"),
IRC_RAW_BUFFER_NAME) == 0)
{
irc_raw_buffer = ptr_buffer;
}
}
}
weechat_infolist_free (infolist);
}
}
void
relay_upgrade_set_buffer_callbacks ()
{
struct t_infolist *infolist;
struct t_gui_buffer *ptr_buffer;
infolist = weechat_infolist_get ("buffer", NULL, NULL);
if (infolist)
{
while (weechat_infolist_next (infolist))
{
if (weechat_infolist_pointer (infolist, "plugin") == weechat_relay_plugin)
{
ptr_buffer = weechat_infolist_pointer (infolist, "pointer");
weechat_buffer_set_pointer (ptr_buffer, "close_callback", &relay_buffer_close_cb);
weechat_buffer_set_pointer (ptr_buffer, "input_callback", &relay_buffer_input_cb);
if (strcmp (weechat_infolist_string (infolist, "name"),
RELAY_BUFFER_NAME) == 0)
{
relay_buffer = ptr_buffer;
}
if (strcmp (weechat_infolist_string (infolist, "name"),
RELAY_RAW_BUFFER_NAME) == 0)
{
relay_raw_buffer = ptr_buffer;
}
}
}
weechat_infolist_free (infolist);
}
}
AspellSpeller *
weechat_aspell_speller_new (const char *lang)
{
AspellConfig *config;
AspellCanHaveError *ret;
AspellSpeller *new_speller;
struct t_infolist *infolist;
if (!lang)
return NULL;
if (weechat_aspell_plugin->debug)
{
weechat_printf (NULL,
"%s: creating new speller for lang \"%s\"",
ASPELL_PLUGIN_NAME, lang);
}
/* create a speller instance for the newly created cell */
config = new_aspell_config();
aspell_config_replace (config, "lang", lang);
/* apply all options on speller */
infolist = weechat_infolist_get ("option", NULL, "aspell.option.*");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
aspell_config_replace (config,
weechat_infolist_string (infolist, "option_name"),
weechat_infolist_string (infolist, "value"));
}
weechat_infolist_free (infolist);
}
ret = new_aspell_speller (config);
if (aspell_error (ret) != 0)
{
weechat_printf (NULL,
"%s%s: error: %s",
weechat_prefix ("error"), ASPELL_PLUGIN_NAME,
aspell_error_message (ret));
delete_aspell_config (config);
delete_aspell_can_have_error (ret);
return NULL;
}
new_speller = to_aspell_speller (ret);
weechat_hashtable_set (weechat_aspell_spellers, lang, new_speller);
/* free configuration */
delete_aspell_config (config);
return new_speller;
}
void
logger_list ()
{
struct t_infolist *ptr_infolist;
struct t_logger_buffer *ptr_logger_buffer;
struct t_gui_buffer *ptr_buffer;
char status[128];
weechat_printf (NULL, "");
weechat_printf (NULL, _("Logging on buffers:"));
ptr_infolist = weechat_infolist_get ("buffer", NULL, NULL);
if (ptr_infolist)
{
while (weechat_infolist_next (ptr_infolist))
{
ptr_buffer = weechat_infolist_pointer (ptr_infolist, "pointer");
if (ptr_buffer)
{
ptr_logger_buffer = logger_buffer_search_buffer (ptr_buffer);
if (ptr_logger_buffer)
{
snprintf (status, sizeof (status),
_("logging (level: %d)"),
ptr_logger_buffer->log_level);
}
else
{
snprintf (status, sizeof (status), "%s", _("not logging"));
}
weechat_printf (NULL,
" %s[%s%d%s]%s (%s) %s%s%s: %s%s%s%s",
weechat_color("chat_delimiters"),
weechat_color("chat"),
weechat_infolist_integer (ptr_infolist, "number"),
weechat_color("chat_delimiters"),
weechat_color("chat"),
weechat_infolist_string (ptr_infolist, "plugin_name"),
weechat_color("chat_buffer"),
weechat_infolist_string (ptr_infolist, "name"),
weechat_color("chat"),
status,
(ptr_logger_buffer) ? " (" : "",
(ptr_logger_buffer) ?
((ptr_logger_buffer->log_filename) ?
ptr_logger_buffer->log_filename : _("log not started")) : "",
(ptr_logger_buffer) ? ")" : "");
}
}
weechat_infolist_free (ptr_infolist);
}
}
void
logger_start_buffer_all (int write_info_line)
{
struct t_infolist *ptr_infolist;
ptr_infolist = weechat_infolist_get ("buffer", NULL, NULL);
if (ptr_infolist)
{
while (weechat_infolist_next (ptr_infolist))
{
logger_start_buffer (weechat_infolist_pointer (ptr_infolist,
"pointer"),
write_info_line);
}
weechat_infolist_free (ptr_infolist);
}
}
void
weechat_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);
}
int
relay_completion_protocol_name_cb (void *data, const char *completion_item,
struct t_gui_buffer *buffer,
struct t_gui_completion *completion)
{
struct t_infolist *infolist;
char protocol_name[512];
/* make C compiler happy */
(void) data;
(void) buffer;
(void) completion_item;
infolist = weechat_infolist_get("irc_server", NULL, NULL);
if (infolist)
{
while (weechat_infolist_next (infolist))
{
snprintf (protocol_name, sizeof (protocol_name), "irc.%s",
weechat_infolist_string (infolist, "name"));
weechat_hook_completion_list_add (completion, protocol_name,
0, WEECHAT_LIST_POS_SORT);
snprintf (protocol_name, sizeof (protocol_name), "ssl.irc.%s",
weechat_infolist_string (infolist, "name"));
weechat_hook_completion_list_add (completion, protocol_name,
0, WEECHAT_LIST_POS_SORT);
}
weechat_infolist_free (infolist);
}
weechat_hook_completion_list_add (completion, "weechat",
0, WEECHAT_LIST_POS_SORT);
weechat_hook_completion_list_add (completion, "ssl.weechat",
0, WEECHAT_LIST_POS_SORT);
return WEECHAT_RC_OK;
}
void
logger_adjust_log_filenames ()
{
struct t_infolist *ptr_infolist;
struct t_logger_buffer *ptr_logger_buffer;
struct t_gui_buffer *ptr_buffer;
char *log_filename;
ptr_infolist = weechat_infolist_get ("buffer", NULL, NULL);
if (ptr_infolist)
{
while (weechat_infolist_next (ptr_infolist))
{
ptr_buffer = weechat_infolist_pointer (ptr_infolist, "pointer");
ptr_logger_buffer = logger_buffer_search_buffer (ptr_buffer);
if (ptr_logger_buffer && ptr_logger_buffer->log_filename)
{
log_filename = logger_get_filename (ptr_logger_buffer->buffer);
if (log_filename)
{
if (strcmp (log_filename, ptr_logger_buffer->log_filename) != 0)
{
/*
* log filename has changed (probably due to day
* change),then we'll use new filename
*/
logger_stop (ptr_logger_buffer, 1);
logger_start_buffer (ptr_buffer, 1);
}
free (log_filename);
}
}
}
weechat_infolist_free (ptr_infolist);
}
}
struct t_weelist *
script_buffer_get_script_usage (struct t_script_repo *script)
{
struct t_weelist *list;
char hdata_name[128], str_option[256], str_info[1024];
int config_files;
const char *ptr_name_hdata_callback, *type;
struct t_hdata *ptr_hdata_script, *ptr_hdata_callback;
struct t_hdata *ptr_hdata_config_file, *ptr_hdata_bar_item;
void *ptr_script, *ptr_callback;
struct t_config_file *ptr_config_file;
struct t_hook *ptr_hook;
struct t_gui_bar_item *ptr_bar_item;
struct t_infolist *infolist;
config_files = 0;
snprintf (hdata_name, sizeof (hdata_name),
"%s_script", script_language[script->language]);
ptr_hdata_script = weechat_hdata_get (hdata_name);
if (!ptr_hdata_script)
return NULL;
ptr_script = script_buffer_get_script_pointer (script, ptr_hdata_script);
if (!ptr_script)
return NULL;
ptr_name_hdata_callback = weechat_hdata_get_var_hdata (ptr_hdata_script,
"callbacks");
if (!ptr_name_hdata_callback)
return NULL;
ptr_hdata_callback = weechat_hdata_get (ptr_name_hdata_callback);
if (!ptr_hdata_callback)
return NULL;
list = weechat_list_new ();
ptr_hdata_config_file = weechat_hdata_get ("config_file");
ptr_hdata_bar_item = weechat_hdata_get ("bar_item");
ptr_callback = weechat_hdata_pointer (ptr_hdata_script,
ptr_script,
"callbacks");
while (ptr_callback)
{
str_info[0] = '\0';
ptr_config_file = weechat_hdata_pointer (ptr_hdata_callback,
ptr_callback,
"config_file");
ptr_hook = weechat_hdata_pointer (ptr_hdata_callback,
ptr_callback,
"hook");
ptr_bar_item = weechat_hdata_pointer (ptr_hdata_callback,
ptr_callback,
"bar_item");
if (ptr_config_file)
{
snprintf (str_info, sizeof (str_info),
_("configuration file \"%s\" (options %s.*)"),
weechat_hdata_string (ptr_hdata_config_file,
ptr_config_file,
"filename"),
weechat_hdata_string (ptr_hdata_config_file,
ptr_config_file,
"name"));
config_files++;
}
else if (ptr_hook)
{
infolist = weechat_infolist_get ("hook", ptr_hook, NULL);
if (infolist)
{
if (weechat_infolist_next (infolist))
{
type = weechat_infolist_string (infolist, "type");
if (type)
{
if (strcmp (type, "command") == 0)
{
snprintf (str_info, sizeof (str_info),
_("command /%s"),
weechat_infolist_string (infolist,
"command"));
}
else if (strcmp (type, "completion") == 0)
{
snprintf (str_info, sizeof (str_info),
_("completion %%(%s)"),
weechat_infolist_string (infolist,
"completion_item"));
}
else if (strcmp (type, "info") == 0)
{
snprintf (str_info, sizeof (str_info),
"info \"%s\"",
weechat_infolist_string (infolist,
"info_name"));
}
else if (strcmp (type, "info_hashtable") == 0)
{
snprintf (str_info, sizeof (str_info),
"info_hashtable \"%s\"",
weechat_infolist_string (infolist,
"info_name"));
}
else if (strcmp (type, "infolist") == 0)
{
snprintf (str_info, sizeof (str_info),
"infolist \"%s\"",
weechat_infolist_string (infolist,
"infolist_name"));
}
}
}
weechat_infolist_free (infolist);
}
}
else if (ptr_bar_item)
{
snprintf (str_info, sizeof (str_info),
_("bar item \"%s\""),
weechat_hdata_string (ptr_hdata_bar_item,
ptr_bar_item,
"name"));
}
if (str_info[0])
{
weechat_list_add (list, str_info,
WEECHAT_LIST_POS_END, NULL);
}
ptr_callback = weechat_hdata_move (ptr_hdata_callback,
ptr_callback,
1);
}
snprintf (str_option, sizeof (str_option),
"plugins.var.%s.%s.*",
script_language[script->language],
weechat_hdata_string (ptr_hdata_script, ptr_script, "name"));
infolist = weechat_infolist_get ("option", NULL, str_option);
if (infolist)
{
if (weechat_infolist_next (infolist))
{
snprintf (str_info, sizeof (str_info),
_("options %s%s%s"),
str_option,
(config_files > 0) ? " " : "",
(config_files > 0) ? _("(old options?)") : "");
weechat_list_add (list, str_info,
WEECHAT_LIST_POS_END, NULL);
}
weechat_infolist_free (infolist);
}
return list;
}
void
relay_weechat_msg_add_infolist (struct t_relay_weechat_msg *msg,
const char *name,
void *pointer,
const char *arguments)
{
struct t_infolist *ptr_infolist;
const char *fields;
char **list_fields;
void *buf_ptr;
int num_fields, i, buf_size;
int pos_count_items, count_items, pos_count_vars, count_vars;
uint32_t count32;
ptr_infolist = weechat_infolist_get (name, pointer, arguments);
if (!ptr_infolist)
return;
/* start infolist in message */
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_INFOLIST);
relay_weechat_msg_add_string (msg, name);
/* count of items will be set later, with number of items in infolist */
pos_count_items = msg->data_size;
count_items = 0;
relay_weechat_msg_add_int (msg, 0);
while (weechat_infolist_next (ptr_infolist))
{
fields = weechat_infolist_fields (ptr_infolist);
if (fields)
{
list_fields = weechat_string_split (fields, ",", 0, 0, &num_fields);
if (list_fields)
{
count_items++;
pos_count_vars = msg->data_size;
count_vars = 0;
relay_weechat_msg_add_int (msg, 0);
for (i = 0; i < num_fields; i++)
{
if (strlen (list_fields[i]) > 2)
{
count_vars++;
relay_weechat_msg_add_string (msg, list_fields[i] + 2);
switch (list_fields[i][0])
{
case 'i':
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_INT);
relay_weechat_msg_add_int (msg,
weechat_infolist_integer (ptr_infolist,
list_fields[i] + 2));
break;
case 's':
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_STRING);
relay_weechat_msg_add_string (msg,
weechat_infolist_string (ptr_infolist,
list_fields[i] + 2));
break;
case 'p':
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_POINTER);
relay_weechat_msg_add_pointer (msg,
weechat_infolist_pointer (ptr_infolist,
list_fields[i] + 2));
break;
case 'b':
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_BUFFER);
buf_ptr = weechat_infolist_buffer (ptr_infolist,
list_fields[i] + 2,
&buf_size);
relay_weechat_msg_add_buffer (msg, buf_ptr, buf_size);
break;
case 't':
relay_weechat_msg_add_type (msg, RELAY_WEECHAT_MSG_OBJ_TIME);
relay_weechat_msg_add_time (msg,
weechat_infolist_time (ptr_infolist,
list_fields[i] + 2));
break;
}
}
}
/* set count of variables in item */
count32 = htonl ((uint32_t)count_vars);
relay_weechat_msg_set_bytes (msg, pos_count_vars, &count32, 4);
weechat_string_free_split (list_fields);
}
}
}
/* set count of items */
count32 = htonl ((uint32_t)count_items);
relay_weechat_msg_set_bytes (msg, pos_count_items, &count32, 4);
weechat_infolist_free (ptr_infolist);
}
int
exec_command_run (struct t_gui_buffer *buffer,
int argc, char **argv, char **argv_eol, int start_arg)
{
char str_buffer[512];
struct t_exec_cmd *new_exec_cmd;
struct t_exec_cmd_options cmd_options;
struct t_hashtable *process_options;
struct t_infolist *ptr_infolist;
struct t_gui_buffer *ptr_new_buffer;
/* parse command options */
cmd_options.command_index = -1;
cmd_options.use_shell = 0;
cmd_options.detached = 0;
cmd_options.pipe_stdin = 0;
cmd_options.timeout = 0;
cmd_options.ptr_buffer_name = NULL;
cmd_options.ptr_buffer = buffer;
cmd_options.output_to_buffer = 0;
cmd_options.new_buffer = 0;
cmd_options.new_buffer_clear = 0;
cmd_options.switch_to_buffer = 1;
cmd_options.line_numbers = -1;
cmd_options.flush = 1;
cmd_options.color = EXEC_COLOR_AUTO;
cmd_options.display_rc = 1;
cmd_options.ptr_command_name = NULL;
cmd_options.pipe_command = NULL;
cmd_options.hsignal = NULL;
/* parse default options */
if (!exec_command_parse_options (&cmd_options,
exec_config_cmd_num_options,
exec_config_cmd_options,
0, 0))
{
weechat_printf (NULL,
_("%s%s: invalid options in option "
"exec.command.default_options"),
weechat_prefix ("error"), EXEC_PLUGIN_NAME);
return WEECHAT_RC_ERROR;
}
if (!exec_command_parse_options (&cmd_options, argc, argv, start_arg, 1))
return WEECHAT_RC_ERROR;
/* options "-bg" and "-o"/"-n" are incompatible */
if (cmd_options.detached
&& (cmd_options.output_to_buffer || cmd_options.new_buffer))
return WEECHAT_RC_ERROR;
/* options "-pipe" and "-bg"/"-o"/"-n" are incompatible */
if (cmd_options.pipe_command
&& (cmd_options.detached || cmd_options.output_to_buffer
|| cmd_options.new_buffer))
return WEECHAT_RC_ERROR;
/* command not found? */
if (cmd_options.command_index < 0)
return WEECHAT_RC_ERROR;
new_exec_cmd = exec_add ();
if (!new_exec_cmd)
return WEECHAT_RC_ERROR;
/* create hashtable for weechat_hook_process_hashtable() */
process_options = weechat_hashtable_new (32,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_STRING,
NULL,
NULL);
if (!process_options)
{
exec_free (new_exec_cmd);
return WEECHAT_RC_ERROR;
}
/* automatically disable shell if we are downloading an URL */
if (strncmp (argv_eol[cmd_options.command_index], "url:", 4) == 0)
cmd_options.use_shell = 0;
if (cmd_options.use_shell)
{
/* command will be: sh -c "command arguments..." */
weechat_hashtable_set (process_options, "arg1", "-c");
weechat_hashtable_set (process_options, "arg2",
argv_eol[cmd_options.command_index]);
}
if (cmd_options.pipe_stdin)
weechat_hashtable_set (process_options, "stdin", "1");
if (cmd_options.detached)
weechat_hashtable_set (process_options, "detached", "1");
if (cmd_options.flush)
weechat_hashtable_set (process_options, "buffer_flush", "1");
/* set variables in new command (before running the command) */
new_exec_cmd->name = (cmd_options.ptr_command_name) ?
strdup (cmd_options.ptr_command_name) : NULL;
new_exec_cmd->command = strdup (argv_eol[cmd_options.command_index]);
new_exec_cmd->detached = cmd_options.detached;
if (!cmd_options.detached && !cmd_options.pipe_command
&& !cmd_options.hsignal)
{
if (cmd_options.ptr_buffer_name && !cmd_options.ptr_buffer)
{
/* output in a new buffer using given name */
new_exec_cmd->output_to_buffer = 0;
snprintf (str_buffer, sizeof (str_buffer),
"exec.%s", cmd_options.ptr_buffer_name);
ptr_new_buffer = exec_buffer_new (str_buffer,
(cmd_options.new_buffer == 2),
cmd_options.new_buffer_clear,
cmd_options.switch_to_buffer);
if (ptr_new_buffer)
{
new_exec_cmd->buffer_full_name =
strdup (weechat_buffer_get_string (ptr_new_buffer,
"full_name"));
}
}
else if (cmd_options.new_buffer)
{
/* output in a new buffer using automatic name */
if (new_exec_cmd->name)
{
snprintf (str_buffer, sizeof (str_buffer),
"exec.%s", new_exec_cmd->name);
}
else
{
snprintf (str_buffer, sizeof (str_buffer),
"exec.%d", new_exec_cmd->number);
}
ptr_new_buffer = exec_buffer_new (str_buffer,
(cmd_options.new_buffer == 2),
cmd_options.new_buffer_clear,
cmd_options.switch_to_buffer);
if (ptr_new_buffer)
{
new_exec_cmd->buffer_full_name =
strdup (weechat_buffer_get_string (ptr_new_buffer,
"full_name"));
}
}
else if (cmd_options.ptr_buffer)
{
new_exec_cmd->buffer_full_name =
strdup (weechat_buffer_get_string (cmd_options.ptr_buffer,
"full_name"));
if (cmd_options.switch_to_buffer)
weechat_buffer_set (cmd_options.ptr_buffer, "display", "1");
}
if (cmd_options.ptr_buffer
&& (strcmp (weechat_buffer_get_string (cmd_options.ptr_buffer, "plugin"),
EXEC_PLUGIN_NAME) == 0))
{
cmd_options.output_to_buffer = 0;
cmd_options.new_buffer = 1;
}
}
new_exec_cmd->output_to_buffer = cmd_options.output_to_buffer;
new_exec_cmd->line_numbers = (cmd_options.line_numbers < 0) ?
cmd_options.new_buffer : cmd_options.line_numbers;
new_exec_cmd->color = cmd_options.color;
new_exec_cmd->display_rc = cmd_options.display_rc;
new_exec_cmd->pipe_command = cmd_options.pipe_command;
new_exec_cmd->hsignal = cmd_options.hsignal;
/* execute the command */
if (weechat_exec_plugin->debug >= 1)
{
weechat_printf (NULL, "%s: executing command: \"%s%s%s\"",
EXEC_PLUGIN_NAME,
(cmd_options.use_shell) ? "" : "sh -c '",
argv_eol[cmd_options.command_index],
(cmd_options.use_shell) ? "" : "'");
}
new_exec_cmd->hook = weechat_hook_process_hashtable (
(cmd_options.use_shell) ? "sh" : argv_eol[cmd_options.command_index],
process_options,
cmd_options.timeout * 1000,
&exec_process_cb,
new_exec_cmd);
if (new_exec_cmd->hook)
{
/* get PID of command */
ptr_infolist = weechat_infolist_get ("hook", new_exec_cmd->hook, NULL);
if (ptr_infolist)
{
if (weechat_infolist_next (ptr_infolist))
{
new_exec_cmd->pid = weechat_infolist_integer (ptr_infolist,
"child_pid");
}
weechat_infolist_free (ptr_infolist);
}
}
else
{
exec_free (new_exec_cmd);
weechat_printf (NULL,
_("%s%s: failed to run command \"%s\""),
weechat_prefix ("error"), EXEC_PLUGIN_NAME,
argv_eol[cmd_options.command_index]);
}
weechat_hashtable_free (process_options);
return WEECHAT_RC_OK;
}
int
weechat_aspell_command_cb (void *data, struct t_gui_buffer *buffer,
int argc, char **argv, char **argv_eol)
{
char *dicts;
const char *default_dict;
struct t_infolist *infolist;
int number;
/* make C compiler happy */
(void) data;
if (argc == 1)
{
/* display aspell status */
weechat_printf (NULL, "");
weechat_printf (NULL,
/* TRANSLATORS: second "%s" is "aspell" or "enchant" */
_("%s (using %s)"),
(aspell_enabled) ? _("Spell checking is enabled") : _("Spell checking is disabled"),
#ifdef USE_ENCHANT
"enchant"
#else
"aspell"
#endif
);
default_dict = weechat_config_string (weechat_aspell_config_check_default_dict);
weechat_printf (NULL,
_("Default dictionary: %s"),
(default_dict && default_dict[0]) ?
default_dict : _("(not set)"));
number = 0;
infolist = weechat_infolist_get ("option", NULL, "aspell.dict.*");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
if (number == 0)
weechat_printf (NULL, _("Specific dictionaries on buffers:"));
number++;
weechat_printf (NULL, " %s: %s",
weechat_infolist_string (infolist, "option_name"),
weechat_infolist_string (infolist, "value"));
}
weechat_infolist_free (infolist);
}
return WEECHAT_RC_OK;
}
/* enable aspell */
if (weechat_strcasecmp (argv[1], "enable") == 0)
{
weechat_config_option_set (weechat_aspell_config_check_enabled, "1", 1);
weechat_printf (NULL, _("Aspell enabled"));
return WEECHAT_RC_OK;
}
/* disable aspell */
if (weechat_strcasecmp (argv[1], "disable") == 0)
{
weechat_config_option_set (weechat_aspell_config_check_enabled, "0", 1);
weechat_printf (NULL, _("Aspell disabled"));
return WEECHAT_RC_OK;
}
/* toggle aspell */
if (weechat_strcasecmp (argv[1], "toggle") == 0)
{
if (aspell_enabled)
{
weechat_config_option_set (weechat_aspell_config_check_enabled, "0", 1);
weechat_printf (NULL, _("Aspell disabled"));
}
else
{
weechat_config_option_set (weechat_aspell_config_check_enabled, "1", 1);
weechat_printf (NULL, _("Aspell enabled"));
}
return WEECHAT_RC_OK;
}
/* list of dictionaries */
if (weechat_strcasecmp (argv[1], "listdict") == 0)
{
weechat_aspell_command_speller_list_dicts ();
return WEECHAT_RC_OK;
}
/* set dictionary for current buffer */
if (weechat_strcasecmp (argv[1], "setdict") == 0)
{
if (argc < 3)
return WEECHAT_RC_ERROR;
dicts = weechat_string_replace (argv_eol[2], " ", "");
weechat_aspell_command_set_dict (buffer,
(dicts) ? dicts : argv[2]);
if (dicts)
free (dicts);
return WEECHAT_RC_OK;
}
/* delete dictionary used on current buffer */
if (weechat_strcasecmp (argv[1], "deldict") == 0)
{
weechat_aspell_command_set_dict (buffer, NULL);
return WEECHAT_RC_OK;
}
/* add word to personal dictionary */
if (weechat_strcasecmp (argv[1], "addword") == 0)
{
if (argc < 3)
return WEECHAT_RC_ERROR;
if (argc > 3)
{
/* use a given dict */
weechat_aspell_command_add_word (buffer, argv[2], argv_eol[3]);
}
else
{
/* use default dict */
weechat_aspell_command_add_word (buffer, NULL, argv_eol[2]);
}
return WEECHAT_RC_OK;
}
return WEECHAT_RC_ERROR;
}
AspellSpeller *
#endif /* USE_ENCHANT */
weechat_aspell_speller_new (const char *lang)
{
#ifdef USE_ENCHANT
EnchantDict *new_speller;
#else
AspellConfig *config;
AspellCanHaveError *ret;
AspellSpeller *new_speller;
#endif /* USE_ENCHANT */
struct t_infolist *infolist;
if (!lang)
return NULL;
if (weechat_aspell_plugin->debug)
{
weechat_printf (NULL,
"%s: creating new speller for lang \"%s\"",
ASPELL_PLUGIN_NAME, lang);
}
#ifdef USE_ENCHANT
new_speller = enchant_broker_request_dict (broker, lang);
if (!new_speller)
{
weechat_printf (NULL,
_("%s%s: error: unable to create speller for lang \"%s\""),
weechat_prefix ("error"), ASPELL_PLUGIN_NAME,
lang);
return NULL;
}
#else
/* create a speller instance for the newly created cell */
config = new_aspell_config ();
aspell_config_replace (config, "lang", lang);
#endif /* USE_ENCHANT */
/* apply all options */
infolist = weechat_infolist_get ("option", NULL, "aspell.option.*");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
#ifdef USE_ENCHANT
/* TODO: set option with enchant */
#else
aspell_config_replace (config,
weechat_infolist_string (infolist, "option_name"),
weechat_infolist_string (infolist, "value"));
#endif /* USE_ENCHANT */
}
weechat_infolist_free (infolist);
}
#ifndef USE_ENCHANT
ret = new_aspell_speller (config);
if (aspell_error (ret) != 0)
{
weechat_printf (NULL,
"%s%s: error: %s",
weechat_prefix ("error"), ASPELL_PLUGIN_NAME,
aspell_error_message (ret));
delete_aspell_config (config);
delete_aspell_can_have_error (ret);
return NULL;
}
new_speller = to_aspell_speller (ret);
#endif /* USE_ENCHANT */
weechat_hashtable_set (weechat_aspell_spellers, lang, new_speller);
#ifndef USE_ENCHANT
/* free configuration */
delete_aspell_config (config);
#endif /* USE_ENCHANT */
return new_speller;
}
int
weechat_aspell_command_cb (void *data, struct t_gui_buffer *buffer,
int argc, char **argv, char **argv_eol)
{
char *dicts;
const char *default_dict;
struct t_infolist *infolist;
int number;
/* make C compiler happy */
(void) data;
if (argc == 1)
{
/* display aspell status */
weechat_printf (NULL, "");
weechat_printf (NULL, "%s",
(aspell_enabled) ?
_("Aspell is enabled") : _("Aspell is disabled"));
default_dict = weechat_config_string (weechat_aspell_config_check_default_dict);
weechat_printf (NULL,
_("Default dictionary: %s"),
(default_dict && default_dict[0]) ?
default_dict : _("(not set)"));
number = 0;
infolist = weechat_infolist_get ("option", NULL, "aspell.dict.*");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
if (number == 0)
weechat_printf (NULL, _("Specific dictionaries on buffers:"));
number++;
weechat_printf (NULL, " %s: %s",
weechat_infolist_string (infolist, "option_name"),
weechat_infolist_string (infolist, "value"));
}
weechat_infolist_free (infolist);
}
return WEECHAT_RC_OK;
}
/* enable aspell */
if (weechat_strcasecmp (argv[1], "enable") == 0)
{
weechat_config_option_set (weechat_aspell_config_check_enabled, "1", 1);
weechat_printf (NULL, _("Aspell enabled"));
return WEECHAT_RC_OK;
}
/* disable aspell */
if (weechat_strcasecmp (argv[1], "disable") == 0)
{
weechat_config_option_set (weechat_aspell_config_check_enabled, "0", 1);
weechat_printf (NULL, _("Aspell disabled"));
return WEECHAT_RC_OK;
}
/* toggle aspell */
if (weechat_strcasecmp (argv[1], "toggle") == 0)
{
if (aspell_enabled)
{
weechat_config_option_set (weechat_aspell_config_check_enabled, "0", 1);
weechat_printf (NULL, _("Aspell disabled"));
}
else
{
weechat_config_option_set (weechat_aspell_config_check_enabled, "1", 1);
weechat_printf (NULL, _("Aspell enabled"));
}
return WEECHAT_RC_OK;
}
/* list of dictionaries */
if (weechat_strcasecmp (argv[1], "listdict") == 0)
{
weechat_aspell_speller_list_dicts ();
return WEECHAT_RC_OK;
}
/* set dictionary for current buffer */
if (weechat_strcasecmp (argv[1], "setdict") == 0)
{
if (argc > 2)
{
dicts = weechat_string_replace (argv_eol[2], " ", "");
weechat_aspell_set_dict (buffer,
(dicts) ? dicts : argv[2]);
if (dicts)
free (dicts);
}
return WEECHAT_RC_OK;
}
/* delete dictionary used on current buffer */
if (weechat_strcasecmp (argv[1], "deldict") == 0)
{
weechat_aspell_set_dict (buffer, NULL);
return WEECHAT_RC_OK;
}
/* add word to personal dictionary */
if (weechat_strcasecmp (argv[1], "addword") == 0)
{
if (argc > 3)
weechat_aspell_add_word (argv[2], argv_eol[3]);
else
{
if (!weechat_aspell_spellers)
{
weechat_printf (NULL,
_("%s%s: no dictionary on this buffer for "
"adding word"),
weechat_prefix ("error"),
ASPELL_PLUGIN_NAME);
}
else if (weechat_aspell_spellers->next_speller)
{
weechat_printf (NULL,
_("%s%s: many dictionaries are defined for "
"this buffer, please specify dictionary"),
weechat_prefix ("error"),
ASPELL_PLUGIN_NAME);
}
else
weechat_aspell_add_word (weechat_aspell_spellers->lang,
argv_eol[2]);
}
return WEECHAT_RC_OK;
}
return WEECHAT_RC_ERROR;
}
struct t_weelist *
script_buffer_get_script_usage (struct t_script_repo *script)
{
struct t_weelist *list;
char hdata_name[128], str_option[256], str_info[1024];
int config_files;
struct t_hdata *hdata_script, *hdata_config, *hdata_bar_item;
void *ptr_script, *callback_pointer;
struct t_config_file *ptr_config;
struct t_gui_bar_item *ptr_bar_item;
struct t_infolist *infolist;
config_files = 0;
snprintf (hdata_name, sizeof (hdata_name),
"%s_script", script_language[script->language]);
hdata_script = weechat_hdata_get (hdata_name);
if (!hdata_script)
return NULL;
ptr_script = script_buffer_get_script_pointer (script, hdata_script);
if (!ptr_script)
return NULL;
list = weechat_list_new ();
/* get configuration files created by the script */
hdata_config = weechat_hdata_get ("config_file");
ptr_config = weechat_hdata_get_list (hdata_config, "config_files");
while (ptr_config)
{
callback_pointer = weechat_hdata_pointer (
hdata_config, ptr_config, "callback_reload_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
_("configuration file \"%s\" (options %s.*)"),
weechat_hdata_string (hdata_config, ptr_config,
"filename"),
weechat_hdata_string (hdata_config, ptr_config,
"name"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
config_files++;
}
ptr_config = weechat_hdata_move (hdata_config, ptr_config, 1);
}
/* get the commands created by the script */
infolist = weechat_infolist_get ("hook", NULL, "command");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
callback_pointer = weechat_infolist_pointer (infolist,
"callback_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
_("command /%s"),
weechat_infolist_string (infolist,
"command"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
}
}
weechat_infolist_free (infolist);
}
/* get the completions created by the script */
infolist = weechat_infolist_get ("hook", NULL, "completion");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
callback_pointer = weechat_infolist_pointer (infolist,
"callback_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
_("completion %%(%s)"),
weechat_infolist_string (infolist,
"completion_item"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
}
}
weechat_infolist_free (infolist);
}
/* get the infos created by the script */
infolist = weechat_infolist_get ("hook", NULL, "info");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
callback_pointer = weechat_infolist_pointer (infolist,
"callback_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
"info \"%s\"",
weechat_infolist_string (infolist,
"info_name"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
}
}
weechat_infolist_free (infolist);
}
/* get the infos (hashtable) created by the script */
infolist = weechat_infolist_get ("hook", NULL, "info_hashtable");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
callback_pointer = weechat_infolist_pointer (infolist,
"callback_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
"info_hashtable \"%s\"",
weechat_infolist_string (infolist,
"info_name"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
}
}
weechat_infolist_free (infolist);
}
/* get the infolists created by the script */
infolist = weechat_infolist_get ("hook", NULL, "infolist");
if (infolist)
{
while (weechat_infolist_next (infolist))
{
callback_pointer = weechat_infolist_pointer (infolist,
"callback_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
"infolist \"%s\"",
weechat_infolist_string (infolist,
"infolist_name"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
}
}
weechat_infolist_free (infolist);
}
/* get the bar items created by the script */
hdata_bar_item = weechat_hdata_get ("bar_item");
ptr_bar_item = weechat_hdata_get_list (hdata_bar_item, "gui_bar_items");
while (ptr_bar_item)
{
callback_pointer = weechat_hdata_pointer (hdata_bar_item, ptr_bar_item,
"build_callback_pointer");
if (callback_pointer == ptr_script)
{
snprintf (str_info, sizeof (str_info),
_("bar item \"%s\""),
weechat_hdata_string (hdata_bar_item,
ptr_bar_item,
"name"));
weechat_list_add (list, str_info, WEECHAT_LIST_POS_END, NULL);
}
ptr_bar_item = weechat_hdata_move (hdata_bar_item, ptr_bar_item, 1);
}
/* get the script options (in plugins.var) */
snprintf (str_option, sizeof (str_option),
"plugins.var.%s.%s.*",
script_language[script->language],
weechat_hdata_string (hdata_script, ptr_script, "name"));
infolist = weechat_infolist_get ("option", NULL, str_option);
if (infolist)
{
if (weechat_infolist_next (infolist))
{
snprintf (str_info, sizeof (str_info),
_("options %s%s%s"),
str_option,
(config_files > 0) ? " " : "",
(config_files > 0) ? _("(old options?)") : "");
weechat_list_add (list, str_info,
WEECHAT_LIST_POS_END, NULL);
}
weechat_infolist_free (infolist);
}
return list;
}
