void
irc_input_send_user_message (struct t_gui_buffer *buffer, char *text)
{
int max_length;
char *pos, *pos_max, *last_space, *pos_next, *next, saved_char;
IRC_GET_SERVER_CHANNEL(buffer);
if (!ptr_server || !ptr_channel || !text || !text[0])
return;
if (!ptr_server->is_connected)
{
weechat_printf (buffer,
_("%s%s: you are not connected to server"),
weechat_prefix ("error"), IRC_PLUGIN_NAME);
return;
}
next = NULL;
last_space = NULL;
saved_char = '\0';
max_length = 512 - 16 - 65 - 10 - strlen (ptr_server->nick) -
strlen (ptr_channel->name);
if (max_length > 0)
{
if ((int)strlen (text) > max_length)
{
pos = text;
pos_max = text + max_length;
while (pos && pos[0])
{
if (pos[0] == ' ')
last_space = pos;
pos_next = weechat_utf8_next_char (pos);
if (pos_next > pos_max)
break;
pos = pos_next;
}
if (last_space && (last_space < pos))
pos = last_space + 1;
saved_char = pos[0];
pos[0] = '\0';
next = pos;
}
}
irc_server_sendf (ptr_server, 1, "PRIVMSG %s :%s",
ptr_channel->name, text);
irc_input_user_message_display (buffer, text);
if (next)
{
next[0] = saved_char;
irc_input_send_user_message (buffer, next);
}
}
int
irc_input_data (struct t_gui_buffer *buffer, const char *input_data, int flags)
{
const char *ptr_data;
char *data_with_colors, *msg;
IRC_BUFFER_GET_SERVER_CHANNEL(buffer);
if (buffer == irc_raw_buffer)
{
if (weechat_strcasecmp (input_data, "q") == 0)
weechat_buffer_close (buffer);
}
else
{
/*
* if send unknown commands is enabled and that input data is a
* command, then send this command to IRC server
*/
if (weechat_config_boolean (irc_config_network_send_unknown_commands)
&& !weechat_string_input_for_buffer (input_data))
{
if (ptr_server)
{
irc_server_sendf (ptr_server, flags, NULL,
"%s", weechat_utf8_next_char (input_data));
}
return WEECHAT_RC_OK;
}
if (ptr_channel)
{
ptr_data = weechat_string_input_for_buffer (input_data);
if (!ptr_data)
ptr_data = input_data;
data_with_colors = irc_color_encode (
ptr_data,
weechat_config_boolean (irc_config_network_colors_send));
msg = strdup ((data_with_colors) ? data_with_colors : ptr_data);
if (msg)
{
irc_input_send_user_message (buffer, flags, NULL, msg);
free (msg);
}
if (data_with_colors)
free (data_with_colors);
}
else
{
weechat_printf (buffer,
_("%s%s: this buffer is not a channel!"),
weechat_prefix ("error"), IRC_PLUGIN_NAME);
}
}
return WEECHAT_RC_OK;
}
char *
rmodifier_replace_groups (const char *string, regmatch_t regex_match[],
const char *groups)
{
char *result, *result2, *str_group, *string_to_add;
const char *ptr_groups;
int length, num_group;
length = 1;
result = malloc (length);
if (!result)
return NULL;
result[0] = '\0';
ptr_groups = groups;
while (ptr_groups && ptr_groups[0])
{
if ((ptr_groups[0] >= '1') && (ptr_groups[0] <= '9'))
{
num_group = ptr_groups[0] - '0';
if (regex_match[num_group].rm_so >= 0)
{
str_group = weechat_strndup (string + regex_match[num_group].rm_so,
regex_match[num_group].rm_eo -regex_match[num_group].rm_so);
if (str_group)
{
string_to_add = NULL;
if (ptr_groups[1] == '*')
string_to_add = rmodifier_hide_string (str_group);
else
string_to_add = strdup (str_group);
if (string_to_add)
{
length += strlen (string_to_add);
result2 = realloc (result, length);
if (!result2)
{
if (result)
free (result);
return NULL;
}
result = result2;
strcat (result, string_to_add);
free (string_to_add);
}
free (str_group);
}
}
}
ptr_groups = weechat_utf8_next_char (ptr_groups);
}
return result;
}
void
alias_hook_command (struct t_alias *alias)
{
char *str_priority_name, *str_completion;
int length;
/*
* build string with priority and name: the alias priority is 2000, which
* is higher than default one (1000), so the alias is executed before a
* command (if a command with same name exists in core or in another plugin)
*/
length = strlen (alias->name) + 16 + 1;
str_priority_name = malloc (length);
if (str_priority_name)
snprintf (str_priority_name, length, "2000|%s", alias->name);
/*
* if alias has no custom completion, then default is to complete with
* completion template of target command, for example if alias is
* "/alias test /buffer", then str_completion will be "%%buffer"
*/
str_completion = NULL;
if (!alias->completion)
{
length = 2 + strlen (alias->command) + 1;
str_completion = malloc (length);
if (str_completion)
{
snprintf (str_completion, length, "%%%%%s",
(weechat_string_is_command_char (alias->command)) ?
weechat_utf8_next_char (alias->command) : alias->command);
}
}
alias->hook = weechat_hook_command ((str_priority_name) ? str_priority_name : alias->name,
alias->command,
NULL, NULL,
(str_completion) ? str_completion : alias->completion,
&alias_cb, alias);
if (str_priority_name)
free (str_priority_name);
if (str_completion)
free (str_completion);
}
int
weechat_aspell_string_is_simili_number (const char *word)
{
int utf8_char_int;
if (!word || !word[0])
return 0;
while (word && word[0])
{
utf8_char_int = weechat_utf8_char_int (word);
if (!iswpunct (utf8_char_int) && !iswdigit (utf8_char_int))
return 0;
word = weechat_utf8_next_char (word);
}
/* there are only digits or punctuation */
return 1;
}
int
irc_message_split_string (struct t_hashtable *hashtable,
const char *tags,
const char *host,
const char *command,
const char *target,
const char *prefix,
const char *arguments,
const char *suffix,
const char delimiter,
int max_length_host)
{
const char *pos, *pos_max, *pos_next, *pos_last_delim;
char message[1024], *dup_arguments;
int max_length, number;
max_length = 510;
if (max_length_host >= 0)
max_length -= max_length_host;
else
max_length -= (host) ? strlen (host) + 1 : 0;
max_length -= strlen (command) + 1;
if (target)
max_length -= strlen (target);
if (prefix)
max_length -= strlen (prefix);
if (suffix)
max_length -= strlen (suffix);
if (max_length < 2)
return 0;
/* debug message */
if (weechat_irc_plugin->debug >= 2)
{
weechat_printf (NULL,
"irc_message_split_string: tags='%s', host='%s', "
"command='%s', target='%s', prefix='%s', "
"arguments='%s', suffix='%s', max_length=%d",
tags, host, command, target, prefix, arguments, suffix,
max_length);
}
number = 1;
if (!arguments || !arguments[0])
{
snprintf (message, sizeof (message), "%s%s%s %s%s%s%s",
(host) ? host : "",
(host) ? " " : "",
command,
(target) ? target : "",
(target && target[0]) ? " " : "",
(prefix) ? prefix : "",
(suffix) ? suffix : "");
irc_message_split_add (hashtable, 1, tags, message, "");
return 1;
}
while (arguments && arguments[0])
{
pos = arguments;
pos_max = pos + max_length;
pos_last_delim = NULL;
while (pos && pos[0])
{
if (pos[0] == delimiter)
pos_last_delim = pos;
pos_next = weechat_utf8_next_char (pos);
if (pos_next > pos_max)
break;
pos = pos_next;
}
if (pos[0] && pos_last_delim)
pos = pos_last_delim;
dup_arguments = weechat_strndup (arguments, pos - arguments);
if (dup_arguments)
{
snprintf (message, sizeof (message), "%s%s%s %s%s%s%s%s",
(host) ? host : "",
(host) ? " " : "",
command,
(target) ? target : "",
(target && target[0]) ? " " : "",
(prefix) ? prefix : "",
dup_arguments,
(suffix) ? suffix : "");
irc_message_split_add (hashtable, number, tags, message,
dup_arguments);
number++;
free (dup_arguments);
}
arguments = (pos == pos_last_delim) ? pos + 1 : pos;
}
return 1;
}
int
trigger_regex_split (const char *str_regex,
int *regex_count, struct t_trigger_regex **regex)
{
const char *ptr_regex, *pos, *pos_replace, *pos_replace_end;
const char *pos_next_regex;
char *delimiter, *str_regex_escaped;
int rc, index, length_delimiter;
struct t_trigger_regex *new_regex;
rc = 0;
delimiter = NULL;
str_regex_escaped = NULL;
if (!regex_count || !regex)
goto end;
/* remove any existing regex */
trigger_regex_free (regex_count, regex);
if (!str_regex || !str_regex[0])
goto end;
/* min 3 chars, for example: "/a/" */
if (strlen (str_regex) < 3)
goto format_error;
/* parse regular expressions in the option */
ptr_regex = str_regex;
while (ptr_regex && ptr_regex[0])
{
if (delimiter)
{
free (delimiter);
delimiter = NULL;
}
/* search the delimiter (which can be more than one char) */
pos = weechat_utf8_next_char (ptr_regex);
while (pos[0] && (weechat_utf8_charcmp (ptr_regex, pos) == 0))
{
pos = weechat_utf8_next_char (pos);
}
if (!pos[0])
goto format_error;
delimiter = weechat_strndup (ptr_regex, pos - ptr_regex);
if (!delimiter)
goto memory_error;
length_delimiter = strlen (delimiter);
ptr_regex = pos;
if (!ptr_regex[0])
goto format_error;
/* search the start of replacement string */
pos_replace = strstr (ptr_regex, delimiter);
if (!pos_replace)
goto format_error;
/* search the end of replacement string */
pos_replace_end = strstr (pos_replace + length_delimiter, delimiter);
new_regex = realloc (*regex,
(*regex_count + 1) * sizeof ((*regex)[0]));
if (!new_regex)
goto memory_error;
*regex = new_regex;
(*regex_count)++;
index = *regex_count - 1;
/* initialize new regex */
(*regex)[index].variable = NULL;
(*regex)[index].str_regex = NULL;
(*regex)[index].regex = NULL;
(*regex)[index].replace = NULL;
(*regex)[index].replace_escaped = NULL;
/* set string with regex */
(*regex)[index].str_regex = weechat_strndup (ptr_regex,
pos_replace - ptr_regex);
if (!(*regex)[index].str_regex)
goto memory_error;
str_regex_escaped = weechat_string_convert_escaped_chars ((*regex)[index].str_regex);
if (!str_regex_escaped)
goto memory_error;
/* set regex */
(*regex)[index].regex = malloc (sizeof (*(*regex)[index].regex));
if (!(*regex)[index].regex)
goto memory_error;
if (weechat_string_regcomp ((*regex)[index].regex,
str_regex_escaped,
REG_EXTENDED | REG_ICASE) != 0)
{
free ((*regex)[index].regex);
(*regex)[index].regex = NULL;
goto compile_error;
}
/* set replace and replace_eval */
(*regex)[index].replace = (pos_replace_end) ?
weechat_strndup (pos_replace + length_delimiter,
pos_replace_end - pos_replace - length_delimiter) :
strdup (pos_replace + length_delimiter);
if (!(*regex)[index].replace)
goto memory_error;
(*regex)[index].replace_escaped =
weechat_string_convert_escaped_chars ((*regex)[index].replace);
if (!(*regex)[index].replace_escaped)
goto memory_error;
if (!pos_replace_end)
break;
/* set variable (optional) */
ptr_regex = pos_replace_end + length_delimiter;
if (!ptr_regex[0])
break;
if (ptr_regex[0] == ' ')
pos_next_regex = ptr_regex;
else
{
pos_next_regex = strchr (ptr_regex, ' ');
(*regex)[index].variable = (pos_next_regex) ?
weechat_strndup (ptr_regex, pos_next_regex - ptr_regex) :
strdup (ptr_regex);
if (!(*regex)[index].variable)
goto memory_error;
}
if (!pos_next_regex)
break;
/* skip spaces before next regex */
ptr_regex = pos_next_regex + 1;
while (ptr_regex[0] == ' ')
{
ptr_regex++;
}
}
goto end;
format_error:
rc = -1;
goto end;
compile_error:
rc = -2;
goto end;
memory_error:
rc = -3;
goto end;
end:
if (delimiter)
free (delimiter);
if (str_regex_escaped)
free (str_regex_escaped);
if (rc < 0)
trigger_regex_free (regex_count, regex);
return rc;
}
char *
weechat_aspell_modifier_cb (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, *pos_space, *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 utf8_char_int, 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) 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 = 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])
{
/* find start of word: it must start with an alphanumeric char */
utf8_char_int = weechat_utf8_char_int (ptr_string);
while ((!iswalnum (utf8_char_int)) || iswspace (utf8_char_int))
{
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;
utf8_char_int = weechat_utf8_char_int (ptr_string);
}
if (!ptr_string[0])
break;
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 = weechat_utf8_next_char (ptr_string);
utf8_char_int = weechat_utf8_char_int (ptr_end);
while (iswalnum (utf8_char_int) || (utf8_char_int == '\'')
|| (utf8_char_int == '-'))
{
word_end_pos++;
if (iswalnum (utf8_char_int))
{
/* pointer to last alphanumeric char in the word */
ptr_end_valid = ptr_end;
word_end_pos_valid = word_end_pos;
}
ptr_end = weechat_utf8_next_char (ptr_end);
if (!ptr_end[0])
break;
utf8_char_int = weechat_utf8_char_int (ptr_end);
}
ptr_end = 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))
{
/*
* word is an URL, then it is OK, and search for next space
* (will be end of word)
*/
word_ok = 1;
if (ptr_end[0])
{
utf8_char_int = weechat_utf8_char_int (ptr_end);
while (!iswspace (utf8_char_int))
{
ptr_end = weechat_utf8_next_char (ptr_end);
if (!ptr_end[0])
break;
utf8_char_int = 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 (buffer,
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");
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 *
weechat_aspell_modifier_cb (void *data, const char *modifier,
const char *modifier_data, const char *string)
{
long unsigned int value;
struct t_gui_buffer *buffer;
char *result, *ptr_string, *pos_space, *ptr_end, save_end;
const char *color_normal, *color_error;
int buffer_has_changed, utf8_char_int, char_size;
int length, index_result, length_word, word_ok;
int length_color_normal, length_color_error, rc;
/* make C compiler happy */
(void) data;
(void) modifier;
if (!aspell_enabled)
return NULL;
if (!string || !string[0])
return NULL;
rc = sscanf (modifier_data, "%lx", &value);
if ((rc == EOF) || (rc == 0))
return NULL;
buffer = (struct t_gui_buffer *)value;
buffer_has_changed = 0;
if (buffer != aspell_buffer_spellers)
{
weechat_aspell_create_spellers (buffer);
aspell_buffer_spellers = buffer;
buffer_has_changed = 1;
}
if (!weechat_aspell_spellers)
return NULL;
/* check text 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;
/*
* for performance: return last string built if input string is the
* same (for example user just change cursor position, or input text is
* refreshed with same content)
*/
if (!buffer_has_changed
&& aspell_last_modifier_string
&& (strcmp (string, aspell_last_modifier_string) == 0))
{
return (aspell_last_modifier_result) ?
strdup (aspell_last_modifier_result) : NULL;
}
/* free last modifier string and result */
if (aspell_last_modifier_string)
{
free (aspell_last_modifier_string);
aspell_last_modifier_string = NULL;
}
if (aspell_last_modifier_result)
{
free (aspell_last_modifier_result);
aspell_last_modifier_result = NULL;
}
/* save last modifier string received */
aspell_last_modifier_string = strdup (string);
color_normal = weechat_color ("bar_fg");
length_color_normal = strlen (color_normal);
color_error = weechat_color (weechat_config_string (weechat_aspell_config_look_color));
length_color_error = strlen (color_error);
length = strlen (string);
result = malloc (length + (length * length_color_error) + 1);
if (result)
{
result[0] = '\0';
ptr_string = aspell_last_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 = 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, aspell_last_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;
}
while (ptr_string[0])
{
/* find start of word */
utf8_char_int = weechat_utf8_char_int (ptr_string);
while ((!iswalnum (utf8_char_int) && (utf8_char_int != '\'')
&& (utf8_char_int != '-'))
|| iswspace (utf8_char_int))
{
char_size = weechat_utf8_char_size (ptr_string);
memcpy (result + index_result, ptr_string, char_size);
index_result += char_size;
ptr_string += char_size;
if (!ptr_string[0])
break;
utf8_char_int = weechat_utf8_char_int (ptr_string);
}
if (!ptr_string[0])
break;
ptr_end = weechat_utf8_next_char (ptr_string);
utf8_char_int = weechat_utf8_char_int (ptr_end);
while (iswalnum (utf8_char_int) || (utf8_char_int == '\'')
|| (utf8_char_int == '-'))
{
ptr_end = weechat_utf8_next_char (ptr_end);
if (!ptr_end[0])
break;
utf8_char_int = weechat_utf8_char_int (ptr_end);
}
word_ok = 0;
if (weechat_aspell_string_is_url (ptr_string))
{
/*
* word is an URL, then it is ok, and search for next space
* (will be end of word)
*/
word_ok = 1;
if (ptr_end[0])
{
utf8_char_int = weechat_utf8_char_int (ptr_end);
while (!iswspace (utf8_char_int))
{
ptr_end = weechat_utf8_next_char (ptr_end);
if (!ptr_end[0])
break;
utf8_char_int = 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 (buffer, 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;
}
result[index_result] = '\0';
}
if (!result)
return NULL;
aspell_last_modifier_result = strdup (result);
return result;
}
struct t_alias *
alias_new (const char *name, const char *command, const char *completion)
{
struct t_alias *new_alias, *ptr_alias, *pos_alias;
if (!name || !name[0] || !command || !command[0])
return NULL;
while (weechat_string_is_command_char (name))
{
name = weechat_utf8_next_char (name);
}
ptr_alias = alias_search (name);
if (ptr_alias)
alias_free (ptr_alias);
new_alias = malloc (sizeof (*new_alias));
if (new_alias)
{
new_alias->hook = NULL;
new_alias->name = strdup (name);
new_alias->command = strdup (command);
new_alias->completion = (completion) ? strdup (completion) : NULL;
new_alias->running = 0;
alias_hook_command (new_alias);
if (alias_list)
{
pos_alias = alias_find_pos (name);
if (pos_alias)
{
/* insert alias into the list (before alias found) */
new_alias->prev_alias = pos_alias->prev_alias;
new_alias->next_alias = pos_alias;
if (pos_alias->prev_alias)
(pos_alias->prev_alias)->next_alias = new_alias;
else
alias_list = new_alias;
pos_alias->prev_alias = new_alias;
}
else
{
/* add alias to end of list */
new_alias->prev_alias = last_alias;
new_alias->next_alias = NULL;
last_alias->next_alias = new_alias;
last_alias = new_alias;
}
}
else
{
new_alias->prev_alias = NULL;
new_alias->next_alias = NULL;
alias_list = new_alias;
last_alias = new_alias;
}
}
return new_alias;
}