char *
irc_bar_item_buffer_name_content (struct t_gui_buffer *buffer, int short_name)
{
char buf[512], buf_name[256], modes[128];
const char *name, *localvar_type;
int part_from_channel, display_server, is_channel;
struct t_irc_server *server;
struct t_irc_channel *channel;
if (!buffer)
return NULL;
buf_name[0] = '\0';
modes[0] = '\0';
display_server = (weechat_config_integer (irc_config_look_item_display_server) == IRC_CONFIG_LOOK_ITEM_DISPLAY_SERVER_NAME);
irc_buffer_get_server_and_channel (buffer, &server, &channel);
if (server || channel)
{
if (server && !channel)
{
snprintf (buf_name, sizeof (buf_name), "%s%s[%s%s%s]",
_("server"),
IRC_COLOR_BAR_DELIM,
(server && server->ssl_connected) ? IRC_COLOR_STATUS_NAME_SSL : IRC_COLOR_STATUS_NAME,
server->name,
IRC_COLOR_BAR_DELIM);
}
else
{
if (channel)
{
part_from_channel = ((channel->type == IRC_CHANNEL_TYPE_CHANNEL)
&& !channel->nicks);
snprintf (buf_name, sizeof (buf_name),
"%s%s%s%s%s%s%s%s%s%s",
(part_from_channel) ? IRC_COLOR_BAR_DELIM : "",
(part_from_channel) ? "(" : "",
(server && server->ssl_connected) ? IRC_COLOR_STATUS_NAME_SSL : IRC_COLOR_STATUS_NAME,
(server && display_server) ? server->name : "",
(server && display_server) ? IRC_COLOR_BAR_DELIM : "",
(server && display_server) ? "/" : "",
(server && server->ssl_connected) ? IRC_COLOR_STATUS_NAME_SSL : IRC_COLOR_STATUS_NAME,
(short_name) ? weechat_buffer_get_string (buffer, "short_name") : channel->name,
(part_from_channel) ? IRC_COLOR_BAR_DELIM : "",
(part_from_channel) ? ")" : "");
}
}
}
else
{
name = weechat_buffer_get_string (buffer,
(short_name) ? "short_name" : "name");
if (name)
{
localvar_type = weechat_buffer_get_string (buffer,
"localvar_type");
is_channel = (localvar_type
&& (strcmp (localvar_type, "channel") == 0));
if (is_channel)
{
name = weechat_buffer_get_string (buffer,
"localvar_channel");
}
snprintf (buf_name, sizeof (buf_name),
"%s%s%s%s%s%s",
(is_channel) ? IRC_COLOR_BAR_DELIM : "",
(is_channel) ? "(" : "",
IRC_COLOR_STATUS_NAME,
name,
(is_channel) ? IRC_COLOR_BAR_DELIM : "",
(is_channel) ? ")" : "");
}
}
snprintf (buf, sizeof (buf), "%s%s%s",
(server && server->ssl_connected) ? IRC_COLOR_STATUS_NAME_SSL : IRC_COLOR_STATUS_NAME,
buf_name,
modes);
return strdup (buf);
}
int
weechat_aspell_string_is_nick (struct t_gui_buffer *buffer, const char *word)
{
char *pos, *pos_nick_completer, *pos_space, saved_char;
const char *nick_completer, *buffer_type, *buffer_nick, *buffer_channel;
int rc, len_completer;
nick_completer = weechat_config_string (
weechat_config_get ("weechat.completion.nick_completer"));
len_completer = (nick_completer) ? strlen (nick_completer) : 0;
pos_nick_completer = (nick_completer) ?
strstr (word, nick_completer) : NULL;
pos_space = strchr (word, ' ');
pos = NULL;
if (pos_nick_completer && pos_space)
{
if ((pos_nick_completer < pos_space)
&& (pos_nick_completer + len_completer == pos_space))
{
pos = pos_nick_completer;
}
else
pos = pos_space;
}
else
{
pos = (pos_nick_completer && !pos_nick_completer[len_completer]) ?
pos_nick_completer : pos_space;
}
if (pos)
{
saved_char = pos[0];
pos[0] = '\0';
}
rc = (weechat_nicklist_search_nick (buffer, NULL, word)) ? 1 : 0;
if (!rc)
{
/* for "private" buffers, check if word is self or remote nick */
buffer_type = weechat_buffer_get_string (buffer, "localvar_type");
if (buffer_type && (strcmp (buffer_type, "private") == 0))
{
/* check self nick */
buffer_nick = weechat_buffer_get_string (buffer, "localvar_nick");
if (buffer_nick && (weechat_strcasecmp (buffer_nick, word) == 0))
{
rc = 1;
}
else
{
/* check remote nick */
buffer_channel = weechat_buffer_get_string (buffer,
"localvar_channel");
if (buffer_channel
&& (weechat_strcasecmp (buffer_channel, word) == 0))
{
rc = 1;
}
}
}
}
if (pos)
pos[0] = saved_char;
return rc;
}
char *
weechat_aspell_modifier_cb (const void *pointer, void *data,
const char *modifier,
const char *modifier_data, const char *string)
{
long unsigned int value;
struct t_gui_buffer *buffer;
struct t_aspell_speller_buffer *ptr_speller_buffer;
char *result, *ptr_string, *ptr_string_orig, *pos_space;
char *ptr_end, *ptr_end_valid, save_end;
char *word_for_suggestions, *old_suggestions, *suggestions;
char *word_and_suggestions;
const char *color_normal, *color_error, *ptr_suggestions;
int code_point, char_size;
int length, index_result, length_word, word_ok;
int length_color_normal, length_color_error, rc;
int input_pos, current_pos, word_start_pos, word_end_pos, word_end_pos_valid;
/* make C compiler happy */
(void) pointer;
(void) data;
(void) modifier;
if (!aspell_enabled)
return NULL;
if (!string)
return NULL;
rc = sscanf (modifier_data, "%lx", &value);
if ((rc == EOF) || (rc == 0))
return NULL;
buffer = (struct t_gui_buffer *)value;
/* check text during search only if option is enabled */
if (weechat_buffer_get_integer (buffer, "text_search")
&& !weechat_config_boolean (weechat_aspell_config_check_during_search))
return NULL;
/* get structure with speller info for buffer */
ptr_speller_buffer = weechat_hashtable_get (weechat_aspell_speller_buffer,
buffer);
if (!ptr_speller_buffer)
{
ptr_speller_buffer = weechat_aspell_speller_buffer_new (buffer);
if (!ptr_speller_buffer)
return NULL;
}
if (!ptr_speller_buffer->spellers)
return NULL;
/*
* for performance: return last string built if input string is the
* same (and cursor position is the same, if suggestions are enabled)
*/
input_pos = weechat_buffer_get_integer (buffer, "input_pos");
if (ptr_speller_buffer->modifier_string
&& (strcmp (string, ptr_speller_buffer->modifier_string) == 0)
&& ((weechat_config_integer (weechat_aspell_config_check_suggestions) < 0)
|| (input_pos == ptr_speller_buffer->input_pos)))
{
return (ptr_speller_buffer->modifier_result) ?
strdup (ptr_speller_buffer->modifier_result) : NULL;
}
/* free last modifier string and result */
if (ptr_speller_buffer->modifier_string)
{
free (ptr_speller_buffer->modifier_string);
ptr_speller_buffer->modifier_string = NULL;
}
if (ptr_speller_buffer->modifier_result)
{
free (ptr_speller_buffer->modifier_result);
ptr_speller_buffer->modifier_result = NULL;
}
word_for_suggestions = NULL;
/* save last modifier string received */
ptr_speller_buffer->modifier_string = strdup (string);
ptr_speller_buffer->input_pos = input_pos;
color_normal = weechat_color ("bar_fg");
length_color_normal = strlen (color_normal);
color_error = weechat_color (weechat_config_string (weechat_aspell_config_color_misspelled));
length_color_error = strlen (color_error);
length = strlen (string);
result = malloc (length + (length * length_color_error) + 1);
if (result)
{
result[0] = '\0';
ptr_string = ptr_speller_buffer->modifier_string;
index_result = 0;
/* check if string is a command */
if (!weechat_string_input_for_buffer (ptr_string))
{
char_size = weechat_utf8_char_size (ptr_string);
ptr_string += char_size;
pos_space = ptr_string;
while (pos_space && pos_space[0] && (pos_space[0] != ' '))
{
pos_space = (char *)weechat_utf8_next_char (pos_space);
}
if (!pos_space || !pos_space[0])
{
free (result);
return NULL;
}
pos_space[0] = '\0';
/* exit if command is not authorized for spell checking */
if (!weechat_aspell_command_authorized (ptr_string))
{
free (result);
return NULL;
}
memcpy (result + index_result,
ptr_speller_buffer->modifier_string,
char_size);
index_result += char_size;
strcpy (result + index_result, ptr_string);
index_result += strlen (ptr_string);
pos_space[0] = ' ';
ptr_string = pos_space;
}
current_pos = 0;
while (ptr_string[0])
{
ptr_string_orig = NULL;
/* find start of word: it must start with an alphanumeric char */
code_point = weechat_utf8_char_int (ptr_string);
while ((!iswalnum (code_point)) || iswspace (code_point))
{
if (!ptr_string_orig && !iswspace (code_point))
ptr_string_orig = ptr_string;
char_size = weechat_utf8_char_size (ptr_string);
memcpy (result + index_result, ptr_string, char_size);
index_result += char_size;
ptr_string += char_size;
current_pos++;
if (!ptr_string[0])
break;
code_point = weechat_utf8_char_int (ptr_string);
}
if (!ptr_string[0])
break;
if (!ptr_string_orig)
ptr_string_orig = ptr_string;
word_start_pos = current_pos;
word_end_pos = current_pos;
word_end_pos_valid = current_pos;
/* find end of word: ' and - allowed in word, but not at the end */
ptr_end_valid = ptr_string;
ptr_end = (char *)weechat_utf8_next_char (ptr_string);
code_point = weechat_utf8_char_int (ptr_end);
while (iswalnum (code_point) || (code_point == '\'')
|| (code_point == '-'))
{
word_end_pos++;
if (iswalnum (code_point))
{
/* pointer to last alphanumeric char in the word */
ptr_end_valid = ptr_end;
word_end_pos_valid = word_end_pos;
}
ptr_end = (char *)weechat_utf8_next_char (ptr_end);
if (!ptr_end[0])
break;
code_point = weechat_utf8_char_int (ptr_end);
}
ptr_end = (char *)weechat_utf8_next_char (ptr_end_valid);
word_end_pos = word_end_pos_valid;
word_ok = 0;
if (weechat_aspell_string_is_url (ptr_string)
|| weechat_aspell_string_is_nick (buffer, ptr_string_orig))
{
/*
* word is an URL or a nick, then it is OK: search for next
* space (will be end of word)
*/
word_ok = 1;
if (ptr_end[0])
{
code_point = weechat_utf8_char_int (ptr_end);
while (!iswspace (code_point))
{
ptr_end = (char *)weechat_utf8_next_char (ptr_end);
if (!ptr_end[0])
break;
code_point = weechat_utf8_char_int (ptr_end);
}
}
}
save_end = ptr_end[0];
ptr_end[0] = '\0';
length_word = ptr_end - ptr_string;
if (!word_ok)
{
if ((save_end != '\0')
|| (weechat_config_integer (weechat_aspell_config_check_real_time)))
{
word_ok = weechat_aspell_check_word (ptr_speller_buffer,
ptr_string);
if (!word_ok && (input_pos >= word_start_pos))
{
/*
* if word is misspelled and that cursor is after
* the beginning of this word, save the word (we will
* look for suggestions after this loop)
*/
if (word_for_suggestions)
free (word_for_suggestions);
word_for_suggestions = strdup (ptr_string);
}
}
else
word_ok = 1;
}
/* add error color */
if (!word_ok)
{
strcpy (result + index_result, color_error);
index_result += length_color_error;
}
/* add word */
strcpy (result + index_result, ptr_string);
index_result += length_word;
/* add normal color (after misspelled word) */
if (!word_ok)
{
strcpy (result + index_result, color_normal);
index_result += length_color_normal;
}
if (save_end == '\0')
break;
ptr_end[0] = save_end;
ptr_string = ptr_end;
current_pos = word_end_pos + 1;
}
result[index_result] = '\0';
}
/* save old suggestions in buffer */
ptr_suggestions = weechat_buffer_get_string (buffer,
"localvar_aspell_suggest");
old_suggestions = (ptr_suggestions) ? strdup (ptr_suggestions) : NULL;
/* if there is a misspelled word, get suggestions and set them in buffer */
if (word_for_suggestions)
{
suggestions = weechat_aspell_get_suggestions (ptr_speller_buffer,
word_for_suggestions);
if (suggestions)
{
length = strlen (word_for_suggestions) + 1 /* ":" */
+ strlen (suggestions) + 1;
word_and_suggestions = malloc (length);
if (word_and_suggestions)
{
snprintf (word_and_suggestions, length, "%s:%s",
word_for_suggestions, suggestions);
weechat_buffer_set (buffer, "localvar_set_aspell_suggest",
word_and_suggestions);
free (word_and_suggestions);
}
else
{
weechat_buffer_set (buffer, "localvar_del_aspell_suggest", "");
}
free (suggestions);
}
else
{
weechat_buffer_set (buffer, "localvar_del_aspell_suggest", "");
}
free (word_for_suggestions);
}
else
{
weechat_buffer_set (buffer, "localvar_del_aspell_suggest", "");
}
/*
* if suggestions have changed, update the bar item
* and send signal "aspell_suggest"
*/
ptr_suggestions = weechat_buffer_get_string (buffer,
"localvar_aspell_suggest");
if ((old_suggestions && !ptr_suggestions)
|| (!old_suggestions && ptr_suggestions)
|| (old_suggestions && ptr_suggestions
&& (strcmp (old_suggestions, ptr_suggestions) != 0)))
{
weechat_bar_item_update ("aspell_suggest");
(void) weechat_hook_signal_send ("aspell_suggest",
WEECHAT_HOOK_SIGNAL_POINTER, buffer);
}
if (old_suggestions)
free (old_suggestions);
if (!result)
return NULL;
ptr_speller_buffer->modifier_result = strdup (result);
return result;
}
char *
irc_bar_item_channel (void *data, struct t_gui_bar_item *item,
struct t_gui_window *window, struct t_gui_buffer *buffer,
struct t_hashtable *extra_info)
{
char buf[512], buf_name[256], modes[128];
const char *name;
int part_from_channel, display_server;
struct t_irc_server *server;
struct t_irc_channel *channel;
/* make C compiler happy */
(void) data;
(void) item;
(void) window;
(void) extra_info;
if (!buffer)
return NULL;
buf_name[0] = '\0';
modes[0] = '\0';
display_server = (weechat_config_integer (irc_config_look_item_display_server) == IRC_CONFIG_LOOK_ITEM_DISPLAY_SERVER_NAME);
irc_buffer_get_server_and_channel (buffer, &server, &channel);
if (server || channel)
{
if (server && !channel)
{
snprintf (buf_name, sizeof (buf_name), "%s%s[%s%s%s]",
_("server"),
IRC_COLOR_BAR_DELIM,
IRC_COLOR_STATUS_NAME,
server->name,
IRC_COLOR_BAR_DELIM);
}
else
{
if (channel)
{
part_from_channel = ((channel->type == IRC_CHANNEL_TYPE_CHANNEL)
&& !channel->nicks);
snprintf (buf_name, sizeof (buf_name),
"%s%s%s%s%s%s%s%s%s%s",
(part_from_channel) ? IRC_COLOR_BAR_DELIM : "",
(part_from_channel) ? "(" : "",
IRC_COLOR_STATUS_NAME,
(server && display_server) ? server->name : "",
(server && display_server) ? IRC_COLOR_BAR_DELIM : "",
(server && display_server) ? "/" : "",
IRC_COLOR_STATUS_NAME,
channel->name,
(part_from_channel) ? IRC_COLOR_BAR_DELIM : "",
(part_from_channel) ? ")" : "");
}
}
}
else
{
name = weechat_buffer_get_string (buffer, "name");
if (name)
snprintf (buf_name, sizeof (buf_name), "%s", name);
}
snprintf (buf, sizeof (buf), "%s%s%s",
IRC_COLOR_STATUS_NAME,
buf_name,
modes);
return strdup (buf);
}
int
charset_command_cb (void *data, struct t_gui_buffer *buffer, int argc,
char **argv, char **argv_eol)
{
struct t_config_section *ptr_section;
int length;
char *ptr_charset, *option_name;
const char *plugin_name, *name, *charset_modifier;
/* make C compiler happy */
(void) data;
if (argc < 2)
{
charset_display_charsets ();
return WEECHAT_RC_OK;
}
ptr_section = NULL;
plugin_name = weechat_buffer_get_string (buffer, "plugin");
name = weechat_buffer_get_string (buffer, "name");
charset_modifier = weechat_buffer_get_string (buffer,
"localvar_charset_modifier");
if (charset_modifier)
option_name = strdup (charset_modifier);
else
{
length = strlen (plugin_name) + 1 + strlen (name) + 1;
option_name = malloc (length);
if (!option_name)
return WEECHAT_RC_ERROR;
snprintf (option_name, length, "%s.%s", plugin_name, name);
}
if ((argc > 1) && (weechat_strcasecmp (argv[1], "reset") == 0))
{
charset_set (charset_config_section_decode, "decode", option_name,
NULL);
charset_set (charset_config_section_encode, "encode", option_name,
NULL);
}
else
{
if (argc > 2)
{
if (weechat_strcasecmp (argv[1], "decode") == 0)
{
ptr_section = charset_config_section_decode;
ptr_charset = argv_eol[2];
}
else if (weechat_strcasecmp (argv[1], "encode") == 0)
{
ptr_section = charset_config_section_encode;
ptr_charset = argv_eol[2];
}
if (!ptr_section)
{
weechat_printf (NULL,
_("%s%s: wrong charset type (decode or encode "
"expected)"),
weechat_prefix ("error"), CHARSET_PLUGIN_NAME);
if (option_name)
free (option_name);
return WEECHAT_RC_OK;
}
}
else
ptr_charset = argv_eol[1];
if (!charset_check (ptr_charset))
{
weechat_printf (NULL,
_("%s%s: invalid charset: \"%s\""),
weechat_prefix ("error"), CHARSET_PLUGIN_NAME,
ptr_charset);
if (option_name)
free (option_name);
return WEECHAT_RC_OK;
}
if (ptr_section)
{
charset_set (ptr_section, argv[1], option_name, ptr_charset);
}
else
{
charset_set (charset_config_section_decode, "decode", option_name,
ptr_charset);
charset_set (charset_config_section_encode, "encode", option_name,
ptr_charset);
}
}
free (option_name);
return WEECHAT_RC_OK;
}
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;
}
char *
weechat_aspell_bar_item_suggest (void *data, struct t_gui_bar_item *item,
struct t_gui_window *window,
struct t_gui_buffer *buffer,
struct t_hashtable *extra_info)
{
const char *ptr_suggestions, *pos;
char **suggestions, *suggestions2;
int i, num_suggestions, length;
/* make C compiler happy */
(void) data;
(void) item;
(void) window;
(void) extra_info;
if (!aspell_enabled)
return NULL;
if (!buffer)
return NULL;
ptr_suggestions = weechat_buffer_get_string (buffer,
"localvar_aspell_suggest");
if (!ptr_suggestions)
return NULL;
pos = strchr (ptr_suggestions, ':');
if (pos)
pos++;
else
pos = ptr_suggestions;
suggestions = weechat_string_split (pos, "/", 0, 0, &num_suggestions);
if (suggestions)
{
length = 64 + 1;
for (i = 0; i < num_suggestions; i++)
{
length += strlen (suggestions[i]) + 64;
}
suggestions2 = malloc (length);
if (suggestions2)
{
suggestions2[0] = '\0';
strcat (suggestions2,
weechat_color (weechat_config_string (weechat_aspell_config_color_suggestions)));
for (i = 0; i < num_suggestions; i++)
{
if (i > 0)
{
strcat (suggestions2, weechat_color ("bar_delim"));
strcat (suggestions2, "/");
strcat (suggestions2,
weechat_color (weechat_config_string (weechat_aspell_config_color_suggestions)));
}
strcat (suggestions2, suggestions[i]);
}
weechat_string_free_split (suggestions);
return suggestions2;
}
weechat_string_free_split (suggestions);
}
return strdup (pos);
}
char *
logger_get_mask_expanded (struct t_gui_buffer *buffer, const char *mask)
{
char *mask2, *mask_decoded, *mask_decoded2, *mask_decoded3, *mask_decoded4;
const char *dir_separator;
int length;
time_t seconds;
struct tm *date_tmp;
mask2 = NULL;
mask_decoded = NULL;
mask_decoded2 = NULL;
mask_decoded3 = NULL;
mask_decoded4 = NULL;
dir_separator = weechat_info_get ("dir_separator", "");
if (!dir_separator)
return NULL;
/*
* we first replace directory separator (commonly '/') by \01 because
* buffer mask can contain this char, and will be replaced by replacement
* char ('_' by default)
*/
mask2 = weechat_string_replace (mask, dir_separator, "\01");
if (!mask2)
goto end;
mask_decoded = weechat_buffer_string_replace_local_var (buffer, mask2);
if (!mask_decoded)
goto end;
mask_decoded2 = weechat_string_replace (mask_decoded,
dir_separator,
weechat_config_string (logger_config_file_replacement_char));
if (!mask_decoded2)
goto end;
/* restore directory separator */
mask_decoded3 = weechat_string_replace (mask_decoded2,
"\01", dir_separator);
if (!mask_decoded3)
goto end;
/* replace date/time specifiers in mask */
length = strlen (mask_decoded3) + 256 + 1;
mask_decoded4 = malloc (length);
if (!mask_decoded4)
goto end;
seconds = time (NULL);
date_tmp = localtime (&seconds);
mask_decoded4[0] = '\0';
strftime (mask_decoded4, length - 1, mask_decoded3, date_tmp);
/* convert to lower case? */
if (weechat_config_boolean (logger_config_file_name_lower_case))
weechat_string_tolower (mask_decoded4);
if (weechat_logger_plugin->debug)
{
weechat_printf_tags (NULL,
"no_log",
"%s: buffer = \"%s\", mask = \"%s\", "
"decoded mask = \"%s\"",
LOGGER_PLUGIN_NAME,
weechat_buffer_get_string (buffer, "name"),
mask, mask_decoded4);
}
end:
if (mask2)
free (mask2);
if (mask_decoded)
free (mask_decoded);
if (mask_decoded2)
free (mask_decoded2);
if (mask_decoded3)
free (mask_decoded3);
return mask_decoded4;
}