diff options
Diffstat (limited to 'src')
30 files changed, 1518 insertions, 1475 deletions
diff --git a/src/core/wee-command.c b/src/core/wee-command.c index 3fdc1a836..a36fdacf5 100644 --- a/src/core/wee-command.c +++ b/src/core/wee-command.c @@ -1126,11 +1126,11 @@ command_help (void *data, struct t_gui_buffer *buffer, _("type"), _("string")); gui_chat_printf (NULL, " %s: %s", _("values"), string); - gui_chat_printf (NULL, " %s: '%s'", + gui_chat_printf (NULL, " %s: \"%s\"", _("default value"), ptr_option->string_values[CONFIG_INTEGER_DEFAULT(ptr_option)]); gui_chat_printf (NULL, - " %s: '%s%s%s'", + " %s: \"%s%s%s\"", _("current value"), GUI_COLOR(GUI_COLOR_CHAT_HOST), ptr_option->string_values[CONFIG_INTEGER(ptr_option)], @@ -1178,10 +1178,10 @@ command_help (void *data, struct t_gui_buffer *buffer, ptr_option->max); break; } - gui_chat_printf (NULL, " %s: '%s'", + gui_chat_printf (NULL, " %s: \"%s\"", _("default value"), CONFIG_STRING_DEFAULT(ptr_option)); - gui_chat_printf (NULL, " %s: '%s%s%s'", + gui_chat_printf (NULL, " %s: \"%s%s%s\"", _("current value"), GUI_COLOR(GUI_COLOR_CHAT_HOST), CONFIG_STRING(ptr_option), @@ -1516,7 +1516,8 @@ command_layout_display_tree (struct t_gui_layout_window *layout_window, /* leaf */ snprintf (format, sizeof (format), "%%-%ds%s", indent * 2, - _("leaf: id: %d, parent: %d, plugin: '%s', buffer: '%s'")); + _("leaf: id: %d, parent: %d, plugin: \"%s\", " + "buffer: \"%s\"")); gui_chat_printf (NULL, format, " ", layout_window->internal_id, diff --git a/src/core/wee-config-file.c b/src/core/wee-config-file.c index 67524806f..637f20150 100644 --- a/src/core/wee-config-file.c +++ b/src/core/wee-config-file.c @@ -2393,8 +2393,8 @@ config_file_print_stdout (struct t_config_file *config_file) { case CONFIG_OPTION_TYPE_BOOLEAN: string_iconv_fprintf (stdout, _(" . type: boolean\n")); - string_iconv_fprintf (stdout, _(" . values: 'on' or 'off'\n")); - string_iconv_fprintf (stdout, _(" . default value: '%s'\n"), + string_iconv_fprintf (stdout, _(" . values: \"on\" or \"off\"\n")); + string_iconv_fprintf (stdout, _(" . default value: \"%s\"\n"), (CONFIG_BOOLEAN_DEFAULT(ptr_option) == CONFIG_BOOLEAN_TRUE) ? "on" : "off"); break; @@ -2406,14 +2406,14 @@ config_file_print_stdout (struct t_config_file *config_file) i = 0; while (ptr_option->string_values[i]) { - string_iconv_fprintf (stdout, "'%s'", + string_iconv_fprintf (stdout, "\"%s\"", ptr_option->string_values[i]); if (ptr_option->string_values[i + 1]) string_iconv_fprintf (stdout, ", "); i++; } string_iconv_fprintf (stdout, "\n"); - string_iconv_fprintf (stdout, _(" . default value: '%s'\n"), + string_iconv_fprintf (stdout, _(" . default value: \"%s\"\n"), ptr_option->string_values[CONFIG_INTEGER_DEFAULT(ptr_option)]); } else @@ -2443,14 +2443,14 @@ config_file_print_stdout (struct t_config_file *config_file) ptr_option->max); break; } - string_iconv_fprintf (stdout, _(" . default value: '%s'\n"), + string_iconv_fprintf (stdout, _(" . default value: \"%s\"\n"), CONFIG_STRING_DEFAULT(ptr_option)); break; case CONFIG_OPTION_TYPE_COLOR: color_name = gui_color_get_name (CONFIG_COLOR_DEFAULT(ptr_option)); string_iconv_fprintf (stdout, _(" . type: color\n")); string_iconv_fprintf (stdout, _(" . values: color (depends on GUI used)\n")); - string_iconv_fprintf (stdout, _(" . default value: '%s'\n"), + string_iconv_fprintf (stdout, _(" . default value: \"%s\"\n"), color_name); break; case CONFIG_NUM_OPTION_TYPES: diff --git a/src/core/wee-hook.c b/src/core/wee-hook.c index 56861714f..0de375a52 100644 --- a/src/core/wee-hook.c +++ b/src/core/wee-hook.c @@ -176,14 +176,14 @@ hook_remove_from_list (struct t_hook *hook) last_weechat_hook[hook->type] = hook->prev_hook; if (hook->prev_hook) { - hook->prev_hook->next_hook = hook->next_hook; + (hook->prev_hook)->next_hook = hook->next_hook; new_hooks = weechat_hooks[hook->type]; } else new_hooks = hook->next_hook; if (hook->next_hook) - hook->next_hook->prev_hook = hook->prev_hook; + (hook->next_hook)->prev_hook = hook->prev_hook; free (hook); diff --git a/src/core/wee-upgrade-file.c b/src/core/wee-upgrade-file.c index e8f5fa13a..a8ee02d42 100644 --- a/src/core/wee-upgrade-file.c +++ b/src/core/wee-upgrade-file.c @@ -54,7 +54,7 @@ upgrade_file_error (struct t_upgrade_file *upgrade_file, char *message1, char *message2, char *file, int line) { gui_chat_printf (NULL, - _("%sError upgrading WeeChat with file '%s':"), + _("%sError upgrading WeeChat with file \"%s\":"), gui_chat_prefix[GUI_CHAT_PREFIX_ERROR], upgrade_file->filename); gui_chat_printf (NULL, diff --git a/src/gui/gui-bar-item.c b/src/gui/gui-bar-item.c index 12d35fb5b..e2820a6fb 100644 --- a/src/gui/gui-bar-item.c +++ b/src/gui/gui-bar-item.c @@ -570,9 +570,9 @@ gui_bar_item_free (struct t_gui_bar_item *item) { /* remove bar item from bar items list */ if (item->prev_item) - item->prev_item->next_item = item->next_item; + (item->prev_item)->next_item = item->next_item; if (item->next_item) - item->next_item->prev_item = item->prev_item; + (item->next_item)->prev_item = item->prev_item; if (gui_bar_items == item) gui_bar_items = item->next_item; if (last_gui_bar_item == item) @@ -751,6 +751,8 @@ gui_bar_item_default_input_text (void *data, struct t_gui_bar_item *item, struct t_gui_window *window, int max_width, int max_height) { + char *new_input, str_buffer[128]; + /* make C compiler happy */ (void) data; (void) item; @@ -759,6 +761,17 @@ gui_bar_item_default_input_text (void *data, struct t_gui_bar_item *item, if (!window) window = gui_current_window; + + snprintf (str_buffer, sizeof (str_buffer), + "0x%x", (unsigned int)(window->buffer)); + + new_input = hook_modifier_exec (NULL, + "weechat_input_text_display", + str_buffer, + (window->buffer->input_buffer) ? + window->buffer->input_buffer : ""); + if (new_input) + return new_input; return (window->buffer->input_buffer) ? strdup (window->buffer->input_buffer) : NULL; diff --git a/src/gui/gui-buffer.c b/src/gui/gui-buffer.c index 1df8fca4c..b5298d004 100644 --- a/src/gui/gui-buffer.c +++ b/src/gui/gui-buffer.c @@ -118,12 +118,12 @@ gui_buffer_insert (struct t_gui_buffer *buffer) /* add buffer to the end */ buffer->number = (last_gui_buffer) ? last_gui_buffer->number + 1 : 1; buffer->prev_buffer = last_gui_buffer; + buffer->next_buffer = NULL; if (gui_buffers) last_gui_buffer->next_buffer = buffer; else gui_buffers = buffer; last_gui_buffer = buffer; - buffer->next_buffer = NULL; } } @@ -205,9 +205,7 @@ gui_buffer_new (struct t_weechat_plugin *plugin, new_buffer->input_nick = NULL; new_buffer->input_buffer_alloc = GUI_BUFFER_INPUT_BLOCK_SIZE; new_buffer->input_buffer = malloc (GUI_BUFFER_INPUT_BLOCK_SIZE); - new_buffer->input_buffer_color_mask = malloc (GUI_BUFFER_INPUT_BLOCK_SIZE); new_buffer->input_buffer[0] = '\0'; - new_buffer->input_buffer_color_mask[0] = '\0'; new_buffer->input_buffer_size = 0; new_buffer->input_buffer_length = 0; new_buffer->input_buffer_pos = 0; @@ -994,8 +992,6 @@ gui_buffer_close (struct t_gui_buffer *buffer, int switch_to_another) free (buffer->name); if (buffer->input_buffer) free (buffer->input_buffer); - if (buffer->input_buffer_color_mask) - free (buffer->input_buffer_color_mask); if (buffer->completion) gui_completion_free (buffer->completion); gui_history_buffer_free (buffer); @@ -1011,9 +1007,9 @@ gui_buffer_close (struct t_gui_buffer *buffer, int switch_to_another) /* remove buffer from buffers list */ if (buffer->prev_buffer) - buffer->prev_buffer->next_buffer = buffer->next_buffer; + (buffer->prev_buffer)->next_buffer = buffer->next_buffer; if (buffer->next_buffer) - buffer->next_buffer->prev_buffer = buffer->prev_buffer; + (buffer->next_buffer)->prev_buffer = buffer->prev_buffer; if (gui_buffers == buffer) gui_buffers = buffer->next_buffer; if (last_gui_buffer == buffer) @@ -1449,7 +1445,6 @@ gui_buffer_print_log () log_printf (" input_callback_data. . : 0x%x", ptr_buffer->input_callback_data); log_printf (" input_nick . . . . . . : '%s'", ptr_buffer->input_nick); log_printf (" input_buffer . . . . . : '%s'", ptr_buffer->input_buffer); - log_printf (" input_buffer_color_mask: '%s'", ptr_buffer->input_buffer_color_mask); log_printf (" input_buffer_alloc . . : %d", ptr_buffer->input_buffer_alloc); log_printf (" input_buffer_size. . . : %d", ptr_buffer->input_buffer_size); log_printf (" input_buffer_length. . : %d", ptr_buffer->input_buffer_length); diff --git a/src/gui/gui-buffer.h b/src/gui/gui-buffer.h index 966447c9f..225f2bb5e 100644 --- a/src/gui/gui-buffer.h +++ b/src/gui/gui-buffer.h @@ -121,7 +121,6 @@ struct t_gui_buffer /* to this buffer */ char *input_nick; /* self nick */ char *input_buffer; /* input buffer */ - char *input_buffer_color_mask; /* color mask for input buffer */ int input_buffer_alloc; /* input buffer: allocated size */ int input_buffer_size; /* buffer size in bytes */ int input_buffer_length; /* number of chars in buffer */ diff --git a/src/gui/gui-chat.c b/src/gui/gui-chat.c index cac78bd17..48431b0ef 100644 --- a/src/gui/gui-chat.c +++ b/src/gui/gui-chat.c @@ -680,9 +680,9 @@ gui_chat_line_free (struct t_gui_buffer *buffer, struct t_gui_line *line) /* remove line from lines list */ if (line->prev_line) - line->prev_line->next_line = line->next_line; + (line->prev_line)->next_line = line->next_line; if (line->next_line) - line->next_line->prev_line = line->prev_line; + (line->next_line)->prev_line = line->prev_line; if (buffer->lines == line) buffer->lines = line->next_line; if (buffer->last_line == line) diff --git a/src/gui/gui-completion.c b/src/gui/gui-completion.c index f104d6119..1e313e940 100644 --- a/src/gui/gui-completion.c +++ b/src/gui/gui-completion.c @@ -156,9 +156,9 @@ gui_completion_partial_list_free (struct t_gui_completion_partial *item) { /* remove partial completion item from list */ if (item->prev_item) - item->prev_item->next_item = item->next_item; + (item->prev_item)->next_item = item->next_item; if (item->next_item) - item->next_item->prev_item = item->prev_item; + (item->next_item)->prev_item = item->prev_item; if (gui_completion_partial_list == item) gui_completion_partial_list = item->next_item; if (last_gui_completion_partial == item) diff --git a/src/gui/gui-filter.c b/src/gui/gui-filter.c index d27343a4f..577264b68 100644 --- a/src/gui/gui-filter.c +++ b/src/gui/gui-filter.c @@ -381,9 +381,9 @@ gui_filter_free (struct t_gui_filter *filter) /* remove filter from filters list */ if (filter->prev_filter) - filter->prev_filter->next_filter = filter->next_filter; + (filter->prev_filter)->next_filter = filter->next_filter; if (filter->next_filter) - filter->next_filter->prev_filter = filter->prev_filter; + (filter->next_filter)->prev_filter = filter->prev_filter; if (gui_filters == filter) gui_filters = filter->next_filter; if (last_gui_filter == filter) diff --git a/src/gui/gui-input.c b/src/gui/gui-input.c index 890d13c66..439cc18ac 100644 --- a/src/gui/gui-input.c +++ b/src/gui/gui-input.c @@ -114,30 +114,11 @@ gui_input_optimize_size (struct t_gui_buffer *buffer) { buffer->input_buffer_alloc = optimal_size; buffer->input_buffer = realloc (buffer->input_buffer, optimal_size); - buffer->input_buffer_color_mask = realloc (buffer->input_buffer_color_mask, - optimal_size); } } } /* - * gui_input_init_color_mask: initialize color mask for input buffer - */ - -void -gui_input_init_color_mask (struct t_gui_buffer *buffer) -{ - int i; - - if (buffer->input) - { - for (i = 0; i < buffer->input_buffer_size; i++) - buffer->input_buffer_color_mask[i] = ' '; - buffer->input_buffer_color_mask[buffer->input_buffer_size] = '\0'; - } -} - -/* * gui_input_move: move data in input buffer */ @@ -151,8 +132,6 @@ gui_input_move (struct t_gui_buffer *buffer, char *target, const char *source, pos_source = source - buffer->input_buffer; memmove (target, source, size); - memmove (buffer->input_buffer_color_mask + pos_target, - buffer->input_buffer_color_mask + pos_source, size); } /* @@ -166,7 +145,7 @@ int gui_input_insert_string (struct t_gui_buffer *buffer, const char *string, int pos) { - int i, pos_start, size, length; + int pos_start, size, length; char *ptr_start; char *buffer_before_insert, *string2; @@ -187,24 +166,16 @@ gui_input_insert_string (struct t_gui_buffer *buffer, const char *string, buffer->input_buffer_length += length; gui_input_optimize_size (buffer); buffer->input_buffer[buffer->input_buffer_size] = '\0'; - buffer->input_buffer_color_mask[buffer->input_buffer_size] = '\0'; /* move end of string to the right */ ptr_start = utf8_add_offset (buffer->input_buffer, pos); pos_start = ptr_start - buffer->input_buffer; memmove (ptr_start + size, ptr_start, strlen (ptr_start)); - memmove (buffer->input_buffer_color_mask + pos_start + size, - buffer->input_buffer_color_mask + pos_start, - strlen (buffer->input_buffer_color_mask + pos_start)); /* insert new string */ ptr_start = utf8_add_offset (buffer->input_buffer, pos); pos_start = ptr_start - buffer->input_buffer; strncpy (ptr_start, string, size); - for (i = 0; i < size; i++) - { - buffer->input_buffer_color_mask[pos_start + i] = ' '; - } buffer->input_buffer_pos += length; @@ -360,7 +331,6 @@ gui_input_return () else if (gui_current_window->buffer->input_buffer_size > 0) { gui_current_window->buffer->input_buffer[gui_current_window->buffer->input_buffer_size] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[gui_current_window->buffer->input_buffer_size] = '\0'; command = strdup (gui_current_window->buffer->input_buffer); if (!command) return; @@ -368,7 +338,6 @@ gui_input_return () gui_current_window->buffer->input_buffer); gui_history_global_add (gui_current_window->buffer->input_buffer); gui_current_window->buffer->input_buffer[0] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[0] = '\0'; gui_current_window->buffer->input_buffer_size = 0; gui_current_window->buffer->input_buffer_length = 0; gui_current_window->buffer->input_buffer_pos = 0; @@ -407,15 +376,12 @@ gui_input_complete (struct t_gui_buffer *buffer) buffer->completion->diff_length; gui_input_optimize_size (buffer); buffer->input_buffer[buffer->input_buffer_size] = '\0'; - buffer->input_buffer_color_mask[buffer->input_buffer_size] = '\0'; for (i = buffer->input_buffer_size - 1; i >= buffer->completion->position_replace + (int)strlen (buffer->completion->word_found); i--) { buffer->input_buffer[i] = buffer->input_buffer[i - buffer->completion->diff_size]; - buffer->input_buffer_color_mask[i] = - buffer->input_buffer_color_mask[i - buffer->completion->diff_size]; } } else @@ -426,23 +392,16 @@ gui_input_complete (struct t_gui_buffer *buffer) { buffer->input_buffer[i] = buffer->input_buffer[i - buffer->completion->diff_size]; - buffer->input_buffer_color_mask[i] = - buffer->input_buffer_color_mask[i - buffer->completion->diff_size]; } buffer->input_buffer_size += buffer->completion->diff_size; buffer->input_buffer_length += buffer->completion->diff_length; gui_input_optimize_size (buffer); buffer->input_buffer[buffer->input_buffer_size] = '\0'; - buffer->input_buffer_color_mask[buffer->input_buffer_size] = '\0'; } strncpy (buffer->input_buffer + buffer->completion->position_replace, buffer->completion->word_found, strlen (buffer->completion->word_found)); - for (i = 0; i < (int)strlen (buffer->completion->word_found); i++) - { - buffer->input_buffer_color_mask[buffer->completion->position_replace + i] = ' '; - } buffer->input_buffer_pos = utf8_pos (buffer->input_buffer, buffer->completion->position_replace) + @@ -590,7 +549,6 @@ gui_input_delete_previous_char () gui_current_window->buffer->input_buffer_length--; gui_current_window->buffer->input_buffer_pos--; gui_current_window->buffer->input_buffer[gui_current_window->buffer->input_buffer_size] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[gui_current_window->buffer->input_buffer_size] = '\0'; gui_input_optimize_size (gui_current_window->buffer); gui_completion_stop (gui_current_window->buffer->completion, 1); gui_buffer_ask_input_refresh (gui_current_window->buffer, 1); @@ -623,7 +581,6 @@ gui_input_delete_next_char () gui_current_window->buffer->input_buffer_size -= char_size; gui_current_window->buffer->input_buffer_length--; gui_current_window->buffer->input_buffer[gui_current_window->buffer->input_buffer_size] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[gui_current_window->buffer->input_buffer_size] = '\0'; gui_input_optimize_size (gui_current_window->buffer); gui_completion_stop (gui_current_window->buffer->completion, 1); gui_buffer_ask_input_refresh (gui_current_window->buffer, 1); @@ -683,7 +640,6 @@ gui_input_delete_previous_word () gui_current_window->buffer->input_buffer_size -= size_deleted; gui_current_window->buffer->input_buffer_length -= length_deleted; gui_current_window->buffer->input_buffer[gui_current_window->buffer->input_buffer_size] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[gui_current_window->buffer->input_buffer_size] = '\0'; gui_current_window->buffer->input_buffer_pos -= length_deleted; gui_input_optimize_size (gui_current_window->buffer); gui_completion_stop (gui_current_window->buffer->completion, 1); @@ -725,7 +681,6 @@ gui_input_delete_next_word () gui_current_window->buffer->input_buffer_size -= size_deleted; gui_current_window->buffer->input_buffer_length -= length_deleted; gui_current_window->buffer->input_buffer[gui_current_window->buffer->input_buffer_size] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[gui_current_window->buffer->input_buffer_size] = '\0'; gui_input_optimize_size (gui_current_window->buffer); gui_completion_stop (gui_current_window->buffer->completion, 1); gui_buffer_ask_input_refresh (gui_current_window->buffer, 1); @@ -762,7 +717,6 @@ gui_input_delete_beginning_of_line () gui_current_window->buffer->input_buffer_size -= size_deleted; gui_current_window->buffer->input_buffer_length -= length_deleted; gui_current_window->buffer->input_buffer[gui_current_window->buffer->input_buffer_size] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[gui_current_window->buffer->input_buffer_size] = '\0'; gui_current_window->buffer->input_buffer_pos = 0; gui_input_optimize_size (gui_current_window->buffer); gui_completion_stop (gui_current_window->buffer->completion, 1); @@ -795,7 +749,6 @@ gui_input_delete_end_of_line (const char *args) length_deleted = utf8_strlen (start); gui_input_clipboard_copy (start, size_deleted); start[0] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[pos_start] = '\0'; gui_current_window->buffer->input_buffer_size = strlen (gui_current_window->buffer->input_buffer); gui_current_window->buffer->input_buffer_length = utf8_strlen (gui_current_window->buffer->input_buffer); gui_input_optimize_size (gui_current_window->buffer); @@ -815,7 +768,6 @@ gui_input_delete_line () if (gui_current_window->buffer->input) { gui_current_window->buffer->input_buffer[0] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[0] = '\0'; gui_current_window->buffer->input_buffer_size = 0; gui_current_window->buffer->input_buffer_length = 0; gui_current_window->buffer->input_buffer_pos = 0; @@ -859,12 +811,6 @@ gui_input_transpose_chars () memcpy (prev_char, start, size_start_char); memcpy (prev_char + size_start_char, saved_char, size_prev_char); - memcpy (saved_char, gui_current_window->buffer->input_buffer_color_mask + pos_prev_char, size_prev_char); - memcpy (gui_current_window->buffer->input_buffer_color_mask + pos_prev_char, - gui_current_window->buffer->input_buffer_color_mask + pos_start, size_start_char); - memcpy (gui_current_window->buffer->input_buffer_color_mask + pos_prev_char + size_start_char, - saved_char, size_prev_char); - gui_current_window->buffer->input_buffer_pos++; gui_completion_stop (gui_current_window->buffer->completion, 1); @@ -1072,7 +1018,6 @@ gui_input_history_previous () if (gui_current_window->buffer->input_buffer_size > 0) { gui_current_window->buffer->input_buffer[gui_current_window->buffer->input_buffer_size] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[gui_current_window->buffer->input_buffer_size] = '\0'; gui_history_buffer_add (gui_current_window->buffer, gui_current_window->buffer->input_buffer); gui_history_global_add (gui_current_window->buffer->input_buffer); } @@ -1082,7 +1027,6 @@ gui_input_history_previous () if (gui_current_window->buffer->input_buffer_size > 0) { gui_current_window->buffer->input_buffer[gui_current_window->buffer->input_buffer_size] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[gui_current_window->buffer->input_buffer_size] = '\0'; if (gui_current_window->buffer->ptr_history->prev_history->text) free(gui_current_window->buffer->ptr_history->prev_history->text); gui_current_window->buffer->ptr_history->prev_history->text = strdup (gui_current_window->buffer->input_buffer); @@ -1098,7 +1042,6 @@ gui_input_history_previous () gui_current_window->buffer->input_buffer_1st_display = 0; strcpy (gui_current_window->buffer->input_buffer, gui_current_window->buffer->ptr_history->text); - gui_input_init_color_mask (gui_current_window->buffer); gui_buffer_ask_input_refresh (gui_current_window->buffer, 1); } gui_input_text_changed_signal (); @@ -1137,7 +1080,6 @@ gui_input_history_next () else { gui_current_window->buffer->input_buffer[0] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[0] = '\0'; gui_current_window->buffer->input_buffer_size = 0; gui_current_window->buffer->input_buffer_length = 0; } @@ -1149,7 +1091,6 @@ gui_input_history_next () { strcpy (gui_current_window->buffer->input_buffer, gui_current_window->buffer->ptr_history->text); - gui_input_init_color_mask (gui_current_window->buffer); } gui_buffer_ask_input_refresh (gui_current_window->buffer, 1); } @@ -1159,11 +1100,9 @@ gui_input_history_next () if (gui_current_window->buffer->input_buffer_size > 0) { gui_current_window->buffer->input_buffer[gui_current_window->buffer->input_buffer_size] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[gui_current_window->buffer->input_buffer_size] = '\0'; gui_history_buffer_add (gui_current_window->buffer, gui_current_window->buffer->input_buffer); gui_history_global_add (gui_current_window->buffer->input_buffer); gui_current_window->buffer->input_buffer[0] = '\0'; - gui_current_window->buffer->input_buffer_color_mask[0] = '\0'; gui_current_window->buffer->input_buffer_size = 0; gui_current_window->buffer->input_buffer_length = 0; gui_current_window->buffer->input_buffer_pos = 0; @@ -1214,7 +1153,6 @@ gui_input_history_global_previous () gui_current_window->buffer->input_buffer_1st_display = 0; strcpy (gui_current_window->buffer->input_buffer, history_global_ptr->text); - gui_input_init_color_mask (gui_current_window->buffer); gui_buffer_ask_input_refresh (gui_current_window->buffer, 1); gui_input_text_changed_signal (); } @@ -1255,7 +1193,6 @@ gui_input_history_global_next () { strcpy (gui_current_window->buffer->input_buffer, history_global_ptr->text); - gui_input_init_color_mask (gui_current_window->buffer); } gui_buffer_ask_input_refresh (gui_current_window->buffer, 1); gui_input_text_changed_signal (); diff --git a/src/gui/gui-input.h b/src/gui/gui-input.h index 601b62ce0..9cf4c11e6 100644 --- a/src/gui/gui-input.h +++ b/src/gui/gui-input.h @@ -33,7 +33,6 @@ extern void gui_input_prompt_changed_signal (); extern void gui_input_text_changed_signal (); extern void gui_input_search_signal (); extern void gui_input_optimize_size (struct t_gui_buffer *buffer); -extern void gui_input_init_color_mask (struct t_gui_buffer *buffer); extern void gui_input_move (struct t_gui_buffer *buffer, char *target, const char *source, int size); extern int gui_input_insert_string (struct t_gui_buffer *buffer, diff --git a/src/gui/gui-layout.c b/src/gui/gui-layout.c index ad89f1f56..db9985a23 100644 --- a/src/gui/gui-layout.c +++ b/src/gui/gui-layout.c @@ -61,9 +61,9 @@ gui_layout_buffer_remove (struct t_gui_layout_buffer *layout_buffer) /* remove layout from list */ if (layout_buffer->prev_layout) - layout_buffer->prev_layout->next_layout = layout_buffer->next_layout; + (layout_buffer->prev_layout)->next_layout = layout_buffer->next_layout; if (layout_buffer->next_layout) - layout_buffer->next_layout->prev_layout = layout_buffer->prev_layout; + (layout_buffer->next_layout)->prev_layout = layout_buffer->prev_layout; if (gui_layout_buffers == layout_buffer) gui_layout_buffers = layout_buffer->next_layout; if (last_gui_layout_buffer == layout_buffer) diff --git a/src/gui/gui-nicklist.c b/src/gui/gui-nicklist.c index 37cfcae18..b77fc96d6 100644 --- a/src/gui/gui-nicklist.c +++ b/src/gui/gui-nicklist.c @@ -276,6 +276,7 @@ gui_nicklist_search_nick (struct t_gui_buffer *buffer, const char *name) { struct t_gui_nick *ptr_nick; + struct t_gui_nick_group *ptr_group; for (ptr_nick = (from_group) ? from_group->nicks : buffer->nicklist_root->nicks; ptr_nick; ptr_nick = ptr_nick->next_nick) @@ -283,6 +284,15 @@ gui_nicklist_search_nick (struct t_gui_buffer *buffer, if (strcmp (ptr_nick->name, name) == 0) return ptr_nick; } + + /* search nick in child groups */ + for (ptr_group = (from_group) ? from_group->childs : buffer->nicklist_root->childs; + ptr_group; ptr_group = ptr_group->next_group) + { + ptr_nick = gui_nicklist_search_nick (buffer, ptr_group, name); + if (ptr_nick) + return ptr_nick; + } /* nick not found */ return NULL; @@ -337,13 +347,13 @@ gui_nicklist_remove_nick (struct t_gui_buffer *buffer, /* remove nick from list */ if (nick->prev_nick) - nick->prev_nick->next_nick = nick->next_nick; + (nick->prev_nick)->next_nick = nick->next_nick; if (nick->next_nick) - nick->next_nick->prev_nick = nick->prev_nick; - if (nick->group->nicks == nick) - nick->group->nicks = nick->next_nick; - if (nick->group->last_nick == nick) - nick->group->last_nick = nick->prev_nick; + (nick->next_nick)->prev_nick = nick->prev_nick; + if ((nick->group)->nicks == nick) + (nick->group)->nicks = nick->next_nick; + if ((nick->group)->last_nick == nick) + (nick->group)->last_nick = nick->prev_nick; /* free data */ if (nick->name) @@ -391,13 +401,13 @@ gui_nicklist_remove_group (struct t_gui_buffer *buffer, { /* remove group from list */ if (group->prev_group) - group->prev_group->next_group = group->next_group; + (group->prev_group)->next_group = group->next_group; if (group->next_group) - group->next_group->prev_group = group->prev_group; - if (group->parent->childs == group) - group->parent->childs = group->next_group; - if (group->parent->last_child == group) - group->parent->last_child = group->prev_group; + (group->next_group)->prev_group = group->prev_group; + if ((group->parent)->childs == group) + (group->parent)->childs = group->next_group; + if ((group->parent)->last_child == group) + (group->parent)->last_child = group->prev_group; } else { diff --git a/src/gui/gui-window.c b/src/gui/gui-window.c index 967333a5f..8611c61e6 100644 --- a/src/gui/gui-window.c +++ b/src/gui/gui-window.c @@ -387,9 +387,9 @@ gui_window_free (struct t_gui_window *window) /* remove window from windows list */ if (window->prev_window) - window->prev_window->next_window = window->next_window; + (window->prev_window)->next_window = window->next_window; if (window->next_window) - window->next_window->prev_window = window->prev_window; + (window->next_window)->prev_window = window->prev_window; if (gui_windows == window) gui_windows = window->next_window; if (last_gui_window == window) diff --git a/src/plugins/CMakeLists.txt b/src/plugins/CMakeLists.txt index b9b9e97db..a3ef91c8d 100644 --- a/src/plugins/CMakeLists.txt +++ b/src/plugins/CMakeLists.txt @@ -31,13 +31,13 @@ IF(NOT DISABLE_ALIAS) ADD_SUBDIRECTORY( alias ) ENDIF(NOT DISABLE_ALIAS) -IF(ENABLE_ASPELL) +IF(NOT DISABLE_ASPELL) # Check for aspell libraries FIND_PACKAGE(Aspell) IF(ASPELL_FOUND) ADD_SUBDIRECTORY( aspell ) ENDIF(ASPELL_FOUND) -ENDIF(ENABLE_ASPELL) +ENDIF(NOT DISABLE_ASPELL) IF(NOT DISABLE_CHARSET) # Check for iconv support. diff --git a/src/plugins/aspell/CMakeLists.txt b/src/plugins/aspell/CMakeLists.txt index 7104243d8..d8f31d51c 100644 --- a/src/plugins/aspell/CMakeLists.txt +++ b/src/plugins/aspell/CMakeLists.txt @@ -14,7 +14,10 @@ # along with this program. If not, see <http://www.gnu.org/licenses/>. # -ADD_LIBRARY(aspell MODULE aspell.c aspell.h) +ADD_LIBRARY(aspell MODULE +aspell.c aspell.h +aspell-config.c aspell-config.h +aspell-speller.c aspell-speller.h) SET_TARGET_PROPERTIES(aspell PROPERTIES PREFIX "") IF(ASPELL_FOUND) diff --git a/src/plugins/aspell/Makefile.am b/src/plugins/aspell/Makefile.am index 893632111..595cb97ac 100644 --- a/src/plugins/aspell/Makefile.am +++ b/src/plugins/aspell/Makefile.am @@ -20,6 +20,11 @@ libdir = ${weechat_libdir}/plugins lib_LTLIBRARIES = aspell.la -aspell_la_SOURCES = aspell.c aspell.h +aspell_la_SOURCES = aspell.c \ + aspell.h \ + aspell-config.c \ + aspell-config.h \ + aspell-speller.c \ + aspell-speller.h aspell_la_LDFLAGS = -module aspell_la_LIBADD = $(ASPELL_LFLAGS) diff --git a/src/plugins/aspell/aspell-config.c b/src/plugins/aspell/aspell-config.c new file mode 100644 index 000000000..b9eee52d7 --- /dev/null +++ b/src/plugins/aspell/aspell-config.c @@ -0,0 +1,338 @@ +/* + * Copyright (c) 2003-2008 by FlashCode <flashcode@flashtux.org> + * See README for License detail, AUTHORS for developers list. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +/* aspell-config.c: aspell configuration options */ + + +#include <stdlib.h> +#include <string.h> +#include <limits.h> + +#include "../weechat-plugin.h" +#include "aspell.h" +#include "aspell-config.h" +#include "aspell-speller.h" + + +struct t_config_file *weechat_aspell_config_file = NULL; +struct t_config_section *weechat_aspell_config_section_dict = NULL; + +/* aspell config, look section */ + +struct t_config_option *weechat_aspell_config_look_color; + +/* aspell config, check section */ + +struct t_config_option *weechat_aspell_config_check_commands; +struct t_config_option *weechat_aspell_config_check_default_dict; +struct t_config_option *weechat_aspell_config_check_real_time; +struct t_config_option *weechat_aspell_config_check_word_min_length; + + +char **weechat_aspell_commands_to_check = NULL; +int weechat_aspell_count_commands_to_check = 0; +int *weechat_aspell_length_commands_to_check = NULL; + + +/* + * weechat_aspell_config_change_commands: called when list of commands is + * changed + */ + +void +weechat_aspell_config_change_commands (void *data, + struct t_config_option *option) +{ + char *value; + int i; + + /* make C compiler happy */ + (void) data; + + if (weechat_aspell_commands_to_check) + { + weechat_string_free_exploded (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_explode (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]); + } + } + } +} + +/* + * weechat_aspell_config_change_default_dict: called when default dictionary + * is changed + */ + +void +weechat_aspell_config_change_default_dict (void *data, + struct t_config_option *option) +{ + /* make C compiler happy */ + (void) data; + (void) option; + + weechat_aspell_create_spellers (weechat_current_buffer); +} + +/* + * weechat_aspell_config_create_option: set a dictionary for a buffer + */ + +int +weechat_aspell_config_create_option (void *data, + struct t_config_file *config_file, + struct t_config_section *section, + const char *option_name, + const char *value) +{ + struct t_config_option *ptr_option; + int rc; + + /* make C compiler happy */ + (void) data; + + rc = WEECHAT_CONFIG_OPTION_SET_ERROR; + + if (value && value[0]) + weechat_aspell_speller_check_dictionaries (value); + + if (option_name) + { + ptr_option = weechat_config_search_option (config_file, section, + option_name); + if (ptr_option) + { + if (value && value[0]) + rc = weechat_config_option_set (ptr_option, value, 1); + else + { + weechat_config_option_free (ptr_option); + rc = WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE; + } + } + else + { + if (value && value[0]) + { + ptr_option = weechat_config_new_option ( + config_file, section, + option_name, "string", + _("comma separated list of dictionaries to use on this buffer"), + NULL, 0, 0, value, NULL, NULL, NULL, NULL, NULL, NULL); + rc = (ptr_option) ? + WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE : WEECHAT_CONFIG_OPTION_SET_ERROR; + } + else + rc = WEECHAT_CONFIG_OPTION_SET_OK_SAME_VALUE; + } + } + + if (rc == WEECHAT_CONFIG_OPTION_SET_ERROR) + { + weechat_printf (NULL, + _("%s%s: error creating aspell dictionary \"%s\" => \"%s\""), + weechat_prefix ("error"), ASPELL_PLUGIN_NAME, + option_name, value); + } + else + weechat_aspell_create_spellers (weechat_current_buffer); + + return rc; +} + +/* + * weechat_aspell_config_get_dict: get a dictionary list for a buffer + */ + +struct t_config_option * +weechat_aspell_config_get_dict (const char *name) +{ + return weechat_config_search_option (weechat_aspell_config_file, + weechat_aspell_config_section_dict, + name); +} + +/* + * weechat_aspell_config_set_dict: set a dictionary list for a buffer + */ + +int +weechat_aspell_config_set_dict (const char *name, const char *value) +{ + return weechat_aspell_config_create_option (NULL, + weechat_aspell_config_file, + weechat_aspell_config_section_dict, + name, + value); +} + +/* + * weechat_aspell_config_init: init aspell configuration file + * return: 1 if ok, 0 if error + */ + +int +weechat_aspell_config_init () +{ + struct t_config_section *ptr_section; + + weechat_aspell_config_file = weechat_config_new (ASPELL_CONFIG_NAME, + NULL, NULL); + if (!weechat_aspell_config_file) + return 0; + + /* look */ + ptr_section = weechat_config_new_section (weechat_aspell_config_file, "look", + 0, 0, + NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL); + if (!ptr_section) + { + weechat_config_free (weechat_aspell_config_file); + return 0; + } + + weechat_aspell_config_look_color = weechat_config_new_option ( + weechat_aspell_config_file, ptr_section, + "color", "color", + N_("color used for mispelled words"), + NULL, 0, 0, "lightred", NULL, NULL, NULL, NULL, NULL, NULL); + + /* check */ + ptr_section = weechat_config_new_section (weechat_aspell_config_file, "check", + 0, 0, + NULL, NULL, NULL, NULL, + NULL, NULL, NULL, NULL); + if (!ptr_section) + { + weechat_config_free (weechat_aspell_config_file); + return 0; + } + + weechat_aspell_config_check_commands = weechat_config_new_option ( + weechat_aspell_config_file, ptr_section, + "commands", "string", + N_("comma separated list of commands for which spell checking is " + "enabled (spell checking is disabled for all other commands)"), + NULL, 0, 0, + "ame,amsg,away,command,cycle,kick,kickban,me,msg,notice,part,query," + "quit,topic", + NULL, NULL, &weechat_aspell_config_change_commands, NULL, NULL, NULL); + weechat_aspell_config_check_default_dict = weechat_config_new_option ( + weechat_aspell_config_file, ptr_section, + "default_dict", "string", + N_("default dictionary (or comma separated list of dictionaries) to " + "use when buffer has no dictionary defined (leave blank to disable " + "aspell on buffers for which you didn't explicitely enabled it)"), + NULL, 0, 0, "", + NULL, NULL, &weechat_aspell_config_change_default_dict, NULL, NULL, NULL); + weechat_aspell_config_check_word_min_length = weechat_config_new_option ( + weechat_aspell_config_file, ptr_section, + "word_min_length", "integer", + N_("minimum length for a word to be spell checked (use 0 to check all " + "words)"), + NULL, 0, INT_MAX, "2", NULL, NULL, NULL, NULL, NULL, NULL); + weechat_aspell_config_check_real_time = weechat_config_new_option ( + weechat_aspell_config_file, ptr_section, + "real_time", "boolean", + N_("real-time spell checking of words (slower, disabled by default: " + "words are checked only if there's delimiter after)"), + NULL, 0, 0, "off", NULL, NULL, NULL, NULL, NULL, NULL); + + ptr_section = weechat_config_new_section (weechat_aspell_config_file, "dict", + 1, 1, + NULL, NULL, + NULL, NULL, + NULL, NULL, + &weechat_aspell_config_create_option, NULL); + if (!ptr_section) + { + weechat_config_free (weechat_aspell_config_file); + return 0; + } + + weechat_aspell_config_section_dict = ptr_section; + + return 1; +} + +/* + * weechat_aspell_config_read: read aspell configuration file + */ + +int +weechat_aspell_config_read () +{ + int rc; + + rc = weechat_config_read (weechat_aspell_config_file); + if (rc == WEECHAT_CONFIG_READ_OK) + { + weechat_aspell_config_change_commands (NULL, + weechat_aspell_config_check_commands); + } + + return rc; +} + +/* + * weechat_aspell_config_write: write aspell configuration file + */ + +int +weechat_aspell_config_write () +{ + return weechat_config_write (weechat_aspell_config_file); +} + +/* + * aspell_config_free: free aspell configuration + */ + +void +weechat_aspell_config_free () +{ + weechat_config_free (weechat_aspell_config_file); + + if (weechat_aspell_commands_to_check) + weechat_string_free_exploded (weechat_aspell_commands_to_check); + if (weechat_aspell_length_commands_to_check) + free (weechat_aspell_length_commands_to_check); +} diff --git a/src/plugins/aspell/aspell-config.h b/src/plugins/aspell/aspell-config.h new file mode 100644 index 000000000..f307d3ff1 --- /dev/null +++ b/src/plugins/aspell/aspell-config.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2003-2008 by FlashCode <flashcode@flashtux.org> + * See README for License detail, AUTHORS for developers list. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef __WEECHAT_ASPELL_CONFIG_H +#define __WEECHAT_ASPELL_CONFIG_H 1 + +#define ASPELL_CONFIG_NAME "aspell" + + +extern struct t_config_option *weechat_aspell_config_look_color; + +extern struct t_config_option *weechat_aspell_config_check_default_dict; +extern struct t_config_option *weechat_aspell_config_check_real_time; +extern struct t_config_option *weechat_aspell_config_check_word_min_length; + +extern char **weechat_aspell_commands_to_check; +extern int weechat_aspell_count_commands_to_check; +extern int *weechat_aspell_length_commands_to_check; + +extern struct t_config_option *weechat_aspell_config_get_dict (const char *name); +extern int weechat_aspell_config_set_dict (const char *name, const char *value); +extern int weechat_aspell_config_init (); +extern int weechat_aspell_config_read (); +extern int weechat_aspell_config_write (); +extern void weechat_aspell_config_free (); + +#endif /* aspell-config.h */ diff --git a/src/plugins/aspell/aspell-speller.c b/src/plugins/aspell/aspell-speller.c new file mode 100644 index 000000000..f066cc64a --- /dev/null +++ b/src/plugins/aspell/aspell-speller.c @@ -0,0 +1,237 @@ +/* + * Copyright (c) 2003-2008 by FlashCode <flashcode@flashtux.org> + * See README for License detail, AUTHORS for developers list. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +/* aspell-speller.c: speller management for aspell plugin */ + + +#include <stdlib.h> +#include <string.h> + +#include "../weechat-plugin.h" +#include "aspell.h" +#include "aspell-speller.h" + + +struct t_aspell_speller *weechat_aspell_spellers = NULL; +struct t_aspell_speller *last_weechat_aspell_speller = NULL; + + +/* + * weechat_aspell_speller_exists: return 1 if an aspell dict exists for a lang, + * 0 otherwise + */ + +int +weechat_aspell_speller_exists (const char *lang) +{ + struct AspellConfig *config; + AspellDictInfoList *list; + AspellDictInfoEnumeration *el; + const AspellDictInfo *dict; + int rc; + + rc = 0; + + config = new_aspell_config (); + list = get_aspell_dict_info_list (config); + el = aspell_dict_info_list_elements (list); + + while ((dict = aspell_dict_info_enumeration_next (el))) + { + if (strcmp (dict->name, lang) == 0) + { + rc = 1; + break; + } + } + + delete_aspell_dict_info_enumeration (el); + delete_aspell_config (config); + + return rc; +} + +/* + * weechat_aspell_speller_check_dictionaries: check dictionaries (called when + * user creates/changes dictionaries + * for a buffer) + */ + +void +weechat_aspell_speller_check_dictionaries (const char *dict_list) +{ + char **argv; + int argc, i; + + if (dict_list) + { + argv = weechat_string_explode (dict_list, ",", 0, 0, &argc); + if (argv) + { + for (i = 0; i < argc; i++) + { + if (!weechat_aspell_speller_exists (argv[i])) + { + weechat_printf (NULL, + _("%s: warning: dictionary \"%s\" is not " + "available on your system"), + ASPELL_PLUGIN_NAME, argv[i]); + } + } + weechat_string_free_exploded (argv); + } + } +} + +/* + * weechat_aspell_speller_search: search a speller + */ + +struct t_aspell_speller * +weechat_aspell_speller_search (const char *lang) +{ + struct t_aspell_speller *ptr_speller; + + for (ptr_speller = weechat_aspell_spellers; ptr_speller; + ptr_speller = ptr_speller->next_speller) + { + if (strcmp (ptr_speller->lang, lang) == 0) + return ptr_speller; + } + + /* no speller found */ + return NULL; +} + +/* + * weechat_aspell_speller_new: create and add a new speller instance + */ + +struct t_aspell_speller * +weechat_aspell_speller_new (const char *lang) +{ + struct t_aspell_speller *new_speller; + AspellConfig *config; + AspellCanHaveError *ret; + + if (!lang) + return NULL; + + if (aspell_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); + + 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; + } + + /* create and add a new speller cell */ + new_speller = malloc (sizeof (*new_speller)); + if (!new_speller) + { + weechat_printf (NULL, + _("%s%s: not enough memory to create new speller"), + weechat_prefix ("error"), ASPELL_PLUGIN_NAME); + return NULL; + } + + new_speller->speller = to_aspell_speller (ret); + new_speller->lang = strdup (lang); + + /* add speller to list */ + new_speller->prev_speller = last_weechat_aspell_speller; + new_speller->next_speller = NULL; + if (weechat_aspell_spellers) + last_weechat_aspell_speller->next_speller = new_speller; + else + weechat_aspell_spellers = new_speller; + last_weechat_aspell_speller = new_speller; + + /* free config */ + delete_aspell_config (config); + + return new_speller; +} + +/* + * weechat_aspell_speller_free: remove a speller instance + */ + +void +weechat_aspell_speller_free (struct t_aspell_speller *speller) +{ + if (!speller) + return; + + if (aspell_debug) + { + weechat_printf (NULL, + "%s: removing speller for lang \"%s\"", + ASPELL_PLUGIN_NAME, speller->lang); + } + + /* free data */ + if (speller->speller) + { + aspell_speller_save_all_word_lists (speller->speller); + delete_aspell_speller (speller->speller); + } + if (speller->lang) + free (speller->lang); + + /* remove speller from list */ + if (speller->prev_speller) + (speller->prev_speller)->next_speller = speller->next_speller; + if (speller->next_speller) + (speller->next_speller)->prev_speller = speller->prev_speller; + if (weechat_aspell_spellers == speller) + weechat_aspell_spellers = speller->next_speller; + if (last_weechat_aspell_speller == speller) + last_weechat_aspell_speller = speller->prev_speller; + + free (speller); +} + +/* + * weechat_aspell_speller_free_all: free all spellers + */ + +void +weechat_aspell_speller_free_all () +{ + while (weechat_aspell_spellers) + { + weechat_aspell_speller_free (weechat_aspell_spellers); + } +} diff --git a/src/plugins/aspell/aspell-speller.h b/src/plugins/aspell/aspell-speller.h new file mode 100644 index 000000000..fb6f92bcf --- /dev/null +++ b/src/plugins/aspell/aspell-speller.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2003-2008 by FlashCode <flashcode@flashtux.org> + * See README for License detail, AUTHORS for developers list. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + + +#ifndef __WEECHAT_ASPELL_SPELLER_H +#define __WEECHAT_ASPELL_SPELLER_H 1 + +struct t_aspell_speller +{ + AspellSpeller *speller; /* aspell speller */ + char *lang; /* language */ + + struct t_aspell_speller *prev_speller; /* pointer to next speller */ + struct t_aspell_speller *next_speller; /* pointer to previous speller */ +}; + +extern struct t_aspell_speller *weechat_aspell_spellers; + +extern int weechat_aspell_speller_exists (const char *lang); +extern struct t_aspell_speller *weechat_aspell_speller_search (const char *lang); +extern void weechat_aspell_speller_check_dictionaries (const char *dict_list); +extern struct t_aspell_speller *weechat_aspell_speller_new (const char *lang); +extern void weechat_aspell_speller_free (struct t_aspell_speller *speller); +extern void weechat_aspell_speller_free_all (); + +#endif /* aspell-speller.h */ diff --git a/src/plugins/aspell/aspell.c b/src/plugins/aspell/aspell.c index dd302895f..b44f78dea 100644 --- a/src/plugins/aspell/aspell.c +++ b/src/plugins/aspell/aspell.c @@ -16,7 +16,7 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. */ -/* aspell.c: Aspell plugin support for WeeChat */ +/* aspell.c: aspell plugin for WeeChat */ #include <stdio.h> @@ -27,1432 +27,1008 @@ #include "../weechat-plugin.h" #include "aspell.h" +#include "aspell-config.h" +#include "aspell-speller.h" -WEECHAT_PLUGIN_NAME("aspell"); +WEECHAT_PLUGIN_NAME(ASPELL_PLUGIN_NAME); WEECHAT_PLUGIN_DESCRIPTION("Aspell plugin for WeeChat"); WEECHAT_PLUGIN_AUTHOR("FlashCode <flashcode@flashtux.org>"); WEECHAT_PLUGIN_VERSION(WEECHAT_VERSION); WEECHAT_PLUGIN_WEECHAT_VERSION(WEECHAT_VERSION); -WEECHAT_LICENSE("GPL"); +WEECHAT_PLUGIN_LICENSE("GPL3"); struct t_weechat_plugin *weechat_aspell_plugin = NULL; -#define weechat_plugin weechat_aspell_plugin -aspell_speller_t *aspell_plugin_speller = NULL; -aspell_config_t *aspell_plugin_config = NULL; -aspell_options_t aspell_plugin_options; +int aspell_debug = 0; +char *aspell_last_modifier_string = NULL; /* last str. received by modifier */ +char *aspell_last_modifier_result = NULL; /* last str. built by modifier */ -/* - * weechat_aspell_new_speller : create a new speller cell - */ - -aspell_speller_t * -weechat_aspell_new_speller (void) +/* aspell supported langs (updated on of 2008-10-17) */ +struct t_aspell_code langs_avail[] = { - aspell_speller_t *s; - - s = malloc (sizeof (*s)); - if (!s) - { - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [ERROR] : unable to alloc memory.", _PLUGIN_NAME); - return NULL; - } - - s->speller= NULL; - s->lang = NULL; - s->refs = 0; - s->prev_speller = NULL; - s->next_speller = NULL; - - return s; -} - -/* - * weechat_aspell_free_speller : free a speller cell - */ - -void -weechat_aspell_free_speller (aspell_speller_t *s) + { "af", "Afrikaans" }, + { "am", "Amharic" }, + { "ar", "Arabic" }, + { "az", "Azerbaijani" }, + { "be", "Belarusian" }, + { "bg", "Bulgarian" }, + { "bn", "Bengali" }, + { "br", "Breton" }, + { "ca", "Catalan" }, + { "cs", "Czech" }, + { "csb", "Kashubian" }, + { "cy", "Welsh" }, + { "da", "Danish" }, + { "de", "German" }, + { "de-alt", "German - Old Spelling" }, + { "el", "Greek" }, + { "en", "English" }, + { "eo", "Esperanto" }, + { "es", "Spanish" }, + { "et", "Estonian" }, + { "fa", "Persian" }, + { "fi", "Finnish" }, + { "fo", "Faroese" }, + { "fr", "French" }, + { "fy", "Frisian" }, + { "ga", "Irish" }, + { "gd", "Scottish Gaelic" }, + { "gl", "Galician" }, + { "gu", "Gujarati" }, + { "gv", "Manx Gaelic" }, + { "he", "Hebrew" }, + { "hi", "Hindi" }, + { "hil", "Hiligaynon" }, + { "hr", "Croatian" }, + { "hsb", "Upper Sorbian" }, + { "hu", "Hungarian" }, + { "hy", "Armenian" }, + { "ia", "Interlingua" }, + { "id", "Indonesian" }, + { "is", "Icelandic" }, + { "it", "Italian" }, + { "ku", "Kurdi" }, + { "la", "Latin" }, + { "lt", "Lithuanian" }, + { "lv", "Latvian" }, + { "mg", "Malagasy" }, + { "mi", "Maori" }, + { "mk", "Macedonian" }, + { "ml", "Malayalam" }, + { "mn", "Mongolian" }, + { "mr", "Marathi" }, + { "ms", "Malay" }, + { "mt", "Maltese" }, + { "nb", "Norwegian Bokmal" }, + { "nds", "Low Saxon" }, + { "nl", "Dutch" }, + { "nn", "Norwegian Nynorsk" }, + { "ny", "Chichewa" }, + { "or", "Oriya" }, + { "pa", "Punjabi" }, + { "pl", "Polish" }, + { "pt_BR", "Brazilian Portuguese" }, + { "pt_PT", "Portuguese" }, + { "qu", "Quechua" }, + { "ro", "Romanian" }, + { "ru", "Russian" }, + { "rw", "Kinyarwanda" }, + { "sc", "Sardinian" }, + { "sk", "Slovak" }, + { "sl", "Slovenian" }, + { "sr", "Serbian" }, + { "sv", "Swedish" }, + { "sw", "Swahili" }, + { "ta", "Tamil" }, + { "te", "Telugu" }, + { "tet", "Tetum" }, + { "tk", "Turkmen" }, + { "tl", "Tagalog" }, + { "tn", "Setswana" }, + { "tr", "Turkish" }, + { "uk", "Ukrainian" }, + { "uz", "Uzbek" }, + { "vi", "Vietnamese" }, + { "wa", "Walloon" }, + { "yi", "Yiddish" }, + { "zu", "Zulu" }, + { NULL, NULL} +}; + +struct t_aspell_code countries_avail[] = { - if (s) - { - if (s->speller) - { - aspell_speller_save_all_word_lists (s->speller); - delete_aspell_speller (s->speller); - } - if (s->lang) - free(s->lang); - free(s); - } -} + { "AT", "Austria" }, + { "BR", "Brazil" }, + { "CA", "Canada" }, + { "CH", "Switzerland" }, + { "DE", "Germany" }, + { "FR", "France" }, + { "GB", "Great Britain" }, + { "PT", "Portugal" }, + { "SK", "Slovakia" }, + { "US", "United States of America" }, + { NULL, NULL} +}; + /* - * weechat_aspell_speller_list_search : search a speller cell + * weechat_aspell_debug_cb: callback for "debug" signal */ -aspell_speller_t * -weechat_aspell_speller_list_search (char *lang) +int +weechat_aspell_debug_cb (void *data, const char *signal, const char *type_data, + void *signal_data) { - aspell_speller_t *p, *r = NULL; + /* make C compiler happy */ + (void) data; + (void) signal; - for(p = aspell_plugin_speller; p; p = p->next_speller) + if (strcmp (type_data, WEECHAT_HOOK_SIGNAL_STRING) == 0) { - if (strcmp(p->lang, lang) == 0) - { - r = p; - break; - } + if (weechat_strcasecmp ((char *)signal_data, ASPELL_PLUGIN_NAME) == 0) + { + aspell_debug ^= 1; + if (aspell_debug) + { + weechat_printf (NULL, _("%s: debug enabled"), + ASPELL_PLUGIN_NAME); + } + else + { + weechat_printf (NULL, _("%s: debug disabled"), + ASPELL_PLUGIN_NAME); + } + } } - return r; + return WEECHAT_RC_OK; } /* - * weechat_aspell_speller_list_add : create and add a new speller instance + * weechat_aspell_build_option_name: build option name with a buffer */ -int -weechat_aspell_speller_list_add (char *lang) +char * +weechat_aspell_build_option_name (struct t_gui_buffer *buffer) { - aspell_speller_t *s; - AspellConfig *config; - AspellCanHaveError *ret; - - /* create a speller instance for the newly created cell */ - config = new_aspell_config(); - aspell_config_replace (config, "lang", lang); + char *plugin_name, *name, *option_name; + int length; - ret = new_aspell_speller (config); - - if (aspell_error (ret) != 0) - { - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [ERROR] : %s", - _PLUGIN_NAME, aspell_error_message (ret)); - delete_aspell_config (config); - delete_aspell_can_have_error (ret); - return 0; - } - - /* create and add a new speller cell */ - s = weechat_aspell_new_speller(); - if (!s) - return 0; + if (!buffer) + return NULL; - s->next_speller = aspell_plugin_speller; - if (aspell_plugin_speller) - aspell_plugin_speller->prev_speller = s; - aspell_plugin_speller = s; + plugin_name = weechat_buffer_get_string (buffer, "plugin"); + name = weechat_buffer_get_string (buffer, "name"); - s->lang = strdup (lang); - s->refs = 1; - s->speller = to_aspell_speller (ret); + length = strlen (plugin_name) + 1 + strlen (name) + 1; + option_name = malloc (length); + if (!option_name) + return NULL; - delete_aspell_config (config); + snprintf (option_name, length, "%s.%s", plugin_name, name); - return 1; + return option_name; } /* - * weechat_aspell_speller_list_remove : remove a speller instance + * weechat_aspell_get_dict: get dictionary list for a buffer + * we first try with all arguments, then remove one by + * one to find dict (from specific to general dict) */ -int -weechat_aspell_speller_list_remove(char *lang) +char * +weechat_aspell_get_dict (struct t_gui_buffer *buffer) { - aspell_speller_t *p; - int r = 0; - - if (!aspell_plugin_speller || !lang) - return 0; + char *name, *option_name, *ptr_end; + struct t_config_option *ptr_option; - if (!aspell_plugin_speller->prev_speller - && !aspell_plugin_speller->next_speller) - { - weechat_aspell_free_speller (aspell_plugin_speller); - aspell_plugin_speller = NULL; - return 1; - } - - for(p = aspell_plugin_speller; p; p = p->next_speller) + name = weechat_aspell_build_option_name (buffer); + if (!name) + return NULL; + + option_name = strdup (name); + if (option_name) { - if (strcmp(p->lang, lang) == 0) - { - if (p->prev_speller) - p->prev_speller->next_speller = p->next_speller; - else - aspell_plugin_speller = p->next_speller; - - if (p->next_speller) - p->next_speller->prev_speller = p->prev_speller; - - weechat_aspell_free_speller (p); - r = 1; - break; - } + 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); } - return r; + /* 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; } /* - * weechat_aspell_new_config : create a new config cell + * weechat_aspell_set_dict: set a dictionary list for a buffer */ -aspell_config_t * -weechat_aspell_new_config (void) +void +weechat_aspell_set_dict (struct t_gui_buffer *buffer, const char *value) { - aspell_config_t *c; + char *name; + + name = weechat_aspell_build_option_name (buffer); + if (!name) + return; - c = malloc (sizeof (*c)); - if (!c) + if (weechat_aspell_config_set_dict (name, value) > 0) { - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [ERROR] : unable to alloc memory.", _PLUGIN_NAME); - return NULL; + if (value && value[0]) + weechat_printf (NULL, "%s: %s => %s", + ASPELL_PLUGIN_NAME, name, value); + else + weechat_printf (NULL, _("%s: %s: removed"), + ASPELL_PLUGIN_NAME, name); } - - c->server = NULL; - c->channel = NULL; - c->speller = NULL; - c->prev_config = NULL; - c->next_config = NULL; - return c; + free (name); } /* - * weechat_aspell_free_config : free a config cell + * weechat_aspell_spellers_already_ok: check if current spellers are already ok + * return 1 if already ok, 0 if spellers + * must be free then created again */ -void -weechat_aspell_free_config (aspell_config_t *c) +int +weechat_aspell_spellers_already_ok (const char *dict_list) { - if (c) + char **argv; + int argc, rc, i; + struct t_aspell_speller *ptr_speller; + + if (!dict_list && !weechat_aspell_spellers) + return 1; + + if (!dict_list || !weechat_aspell_spellers) + return 0; + + rc = 0; + + argv = weechat_string_explode (dict_list, ",", 0, 0, &argc); + if (argv) { - if (c->server) - free(c->server); - if (c->channel) - free(c->channel); - - free(c); + ptr_speller = weechat_aspell_spellers; + for (i = 0; (i < argc) && ptr_speller; i++) + { + if (strcmp (ptr_speller->lang, argv[i]) == 0) + { + rc = 1; + break; + } + ptr_speller = ptr_speller->next_speller; + } + weechat_string_free_exploded (argv); } + + return rc; } /* - * weechat_aspell_config_list_search : search a config cell + * weechat_aspell_create_spellers: create spellers for a buffer */ -aspell_config_t * -weechat_aspell_config_list_search (char *server, char *channel) +void +weechat_aspell_create_spellers (struct t_gui_buffer *buffer) { - aspell_config_t *p, *r = NULL; - - if (!server || !channel) - return NULL; + char *dict_list, **argv; + int argc, i; - for(p = aspell_plugin_config; p; p = p->next_config) + if (buffer) { - if (strcmp(p->server, server) == 0 - && strcmp(p->channel, channel) == 0) - { - r = p; - break; - } + dict_list = weechat_aspell_get_dict (buffer); + if (!weechat_aspell_spellers_already_ok (dict_list)) + { + weechat_aspell_speller_free_all (); + if (dict_list) + { + argv = weechat_string_explode (dict_list, ",", 0, 0, &argc); + if (argv) + { + for (i = 0; i < argc; i++) + { + weechat_aspell_speller_new (argv[i]); + } + weechat_string_free_exploded (argv); + } + } + } } - - return r; } /* - * weechat_aspell_config_list_add : create and add a new config + * weechat_aspell_buffer_switch_cb: callback for "buffer_switch" signel */ int -weechat_aspell_config_list_add (char *server, char *channel) +weechat_aspell_buffer_switch_cb (void *data, const char *signal, + const char *type_data, void *signal_data) { - aspell_config_t *c; - - c = weechat_aspell_new_config(); - if (!c) - return 0; - - c->channel = strdup (channel); - c->server = strdup (server); - - c->next_config = aspell_plugin_config; - if (aspell_plugin_config) - aspell_plugin_config->prev_config = c; - aspell_plugin_config = c; + /* make C compiler happy */ + (void) data; + (void) signal; + (void) type_data; - return 1; -} - -/* - * weechat_aspell_config_list_remove : remove a speller config - */ - -int -weechat_aspell_config_list_remove(char *server, char *channel) -{ - aspell_config_t *p; - int r = 0; - - if (!aspell_plugin_config || !server || !channel) - return 0; - - if (!aspell_plugin_config->prev_config - && !aspell_plugin_config) - { - weechat_aspell_free_config (aspell_plugin_config); - aspell_plugin_config = NULL; - return 1; - } + weechat_aspell_create_spellers (signal_data); - for(p = aspell_plugin_config; p; p = p->next_config) - { - if (strcmp(p->server, server) == 0 - && strcmp(p->channel, channel) == 0) - { - if (p->prev_config) - p->prev_config->next_config = p->next_config; - else - aspell_plugin_config = p->next_config; - - if (p->next_config) - p->next_config->prev_config = p->prev_config; - weechat_aspell_free_config (p); - r = 1; - break; - } - } - - return r; + return WEECHAT_RC_OK; } /* - * weechat_aspell_iso_to_lang : - * convert an aspell iso lang code - * in its english full name + * weechat_aspell_iso_to_lang: convert an aspell iso lang code in its english + * full name * */ char * -weechat_aspell_iso_to_lang (char *code) +weechat_aspell_iso_to_lang (const char *code) { - iso_langs_t *p; - char *l; - - l = NULL; + int i; - for(p = langs_avail; p->code; ++p) + for (i = 0; langs_avail[i].code; i++) { - if (strcmp(p->code, code) == 0) - { - l = strdup(p->name); - break; - } + if (strcmp (langs_avail[i].code, code) == 0) + return strdup (langs_avail[i].name); } - - if (!l) - l = strdup ("Unknown"); - - return l; + + /* lang code not found */ + return strdup ("Unknown"); } /* - * weechat_aspell_iso_to_country : - * convert an aspell iso country - * code in its english full name + * weechat_aspell_iso_to_country: convert an aspell iso country code in its + * english full name */ char * -weechat_aspell_iso_to_country (char *code) +weechat_aspell_iso_to_country (const char *code) { - iso_countries_t *p; - char *c; - - c = NULL; + int i; - for(p = countries_avail; p->code; ++p) + for (i = 0; countries_avail[i].code; i++) { - if (strcmp(p->code, code) == 0) - { - c = strdup(p->name); - break; - } + if (strcmp (countries_avail[i].code, code) == 0) + return strdup (countries_avail[i].name); } - - if (!c) - c = strdup ("Unknown"); - - return c; -} - -/* - * weechat_aspell_speller_exists : - * return 1 if an aspell dict exists - * for a lang, 0 otherwise - */ - -int -weechat_aspell_speller_exists (char *lang) -{ - struct AspellConfig *config; - AspellDictInfoList *l; - AspellDictInfoEnumeration *el; - const AspellDictInfo *di; - int r; - - r = 0; - config = new_aspell_config(); - l = get_aspell_dict_info_list (config); - el = aspell_dict_info_list_elements (l); - di = NULL; - while (( di = aspell_dict_info_enumeration_next (el))) - { - if (strcmp(di->name, lang) == 0) - { - r = 1; - break; - } - } - - delete_aspell_dict_info_enumeration (el); - delete_aspell_config (config); - - return r; + /* country code not found */ + return strdup ("Unknown"); } /* - * weechat_aspell_speller_list_dicts : - * list all aspell dict installed on system and display them + * weechat_aspell_speller_list_dicts: list all aspell dict installed on system + * and display them */ void -weechat_aspell_speller_list_dicts (void) +weechat_aspell_speller_list_dicts () { - char *country, *lang, *p; + char *country, *lang, *pos; char buffer[192]; struct AspellConfig *config; - AspellDictInfoList *l; + AspellDictInfoList *list; AspellDictInfoEnumeration *el; - const AspellDictInfo *di; + const AspellDictInfo *dict; config = new_aspell_config(); - l = get_aspell_dict_info_list (config); - el = aspell_dict_info_list_elements (l); - di = NULL; - - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, "[%s] *** dictionnaries list :", _PLUGIN_NAME); - - while (( di = aspell_dict_info_enumeration_next (el))) - { - country = NULL; - p = strchr (di->code, '_'); - - if (p) - { - *p = '\0'; - lang = weechat_aspell_iso_to_lang ((char*) di->code); - *p = '_'; - country = weechat_aspell_iso_to_country (p+1); - } - else - lang = weechat_aspell_iso_to_lang ((char*) di->code); - - if (strlen (di->jargon) == 0) - { - if (p) - snprintf (buffer, sizeof(buffer), "%-22s %s (%s)", di->name, lang, country); - else - snprintf (buffer, sizeof(buffer), "%-22s %s", di->name, lang); - } - else - { - if (p) - snprintf (buffer, sizeof(buffer), "%-22s %s (%s - %s)", di->name, lang, country, di->jargon); - else - snprintf (buffer, sizeof(buffer), "%-22s %s (%s)", di->name, lang, di->jargon); - } - - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, "[%s] - %s", _PLUGIN_NAME, buffer); - - if (lang) - free (lang); - if (country) - free (country); - } - - delete_aspell_dict_info_enumeration (el); - delete_aspell_config (config); -} - -/* - * weechat_aspell_config_show : display plugin settings - */ - -void -weechat_aspell_config_show (void) -{ - aspell_config_t *p; + list = get_aspell_dict_info_list (config); + el = aspell_dict_info_list_elements (list); - if (!aspell_plugin_config) - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [SHOW] *** No buffers with spellchecking enable", - _PLUGIN_NAME); - else - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [SHOW] *** Spellchecking is active on the following buffers :", - _PLUGIN_NAME); - - for(p = aspell_plugin_config; p; p = p->next_config) - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [SHOW] -> %s@%s with lang '%s'", - _PLUGIN_NAME, p->channel, p->server, p->speller->lang); - - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [SHOW] *** plugin options :", _PLUGIN_NAME); - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [SHOW] -> word-size = %d", - _PLUGIN_NAME, aspell_plugin_options.word_size); - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [SHOW] -> color = %s", - _PLUGIN_NAME, aspell_plugin_options.color_name); - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - aspell_plugin_options.check_sync == 1 - ? "[%s] [SHOW] -> realtime spellchecking is enable" - : "[%s] [SHOW] -> asynchronous spellchecking is enable" - , - _PLUGIN_NAME); -} - -/* - * weechat_aspell_config_addword : adding a word in personnal dictionaries - */ - -int -weechat_aspell_config_addword(char *word) -{ - char *server, *channel; - aspell_config_t *c; - int ret; + weechat_printf (NULL, ""); + weechat_printf (NULL, + /* TRANSLATORS: %s is "aspell" */ + _( "%s dictionnaries list:"), + ASPELL_PLUGIN_NAME); - ret = 0; - channel = weechat_aspell_plugin->get_info (weechat_aspell_plugin, "channel", NULL); - server = weechat_aspell_plugin->get_info (weechat_aspell_plugin, "server", NULL); - - if (!server || !channel) - return 0; - - c = weechat_aspell_config_list_search (server, channel); - if (c) { - if (aspell_speller_add_to_personal ( - c->speller->speller, (const char *) word, strlen(word)) == 1) - ret = 1; + while ((dict = aspell_dict_info_enumeration_next (el))) + { + country = NULL; + pos = strchr (dict->code, '_'); + + if (pos) + { + pos[0] = '\0'; + lang = weechat_aspell_iso_to_lang ((char*)dict->code); + pos[0] = '_'; + country = weechat_aspell_iso_to_country (pos + 1); + } + else + lang = weechat_aspell_iso_to_lang ((char*)dict->code); + + if (strlen (dict->jargon) == 0) + { + if (pos) + { + snprintf (buffer, sizeof (buffer), "%-22s %s (%s)", + dict->name, lang, country); + } + else + { + snprintf (buffer, sizeof (buffer), "%-22s %s", + dict->name, lang); + } + } + else + { + if (pos) + { + snprintf (buffer, sizeof (buffer), "%-22s %s (%s - %s)", + dict->name, lang, country, dict->jargon); + } + else + { + snprintf (buffer, sizeof (buffer), "%-22s %s (%s)", + dict->name, lang, dict->jargon); + } + } + + weechat_printf (NULL, " %s", buffer); + + if (lang) + free (lang); + if (country) + free (country); } - if (ret) - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [ADD-WORD] word '%s' successfully added in your personnal dictionnary", - _PLUGIN_NAME, word); - else - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [ADD-WORD] an error occured while adding word '%s' in your personnal dict", - _PLUGIN_NAME, word); - - if (server) - free (server); - if (channel) - free (channel); - - return ret; + delete_aspell_dict_info_enumeration (el); + delete_aspell_config (config); } /* - * weechat_aspell_config_dump : display debug infos + * weechat_aspell_add_word : add a word in personnal dictionary */ void -weechat_aspell_config_dump (void) +weechat_aspell_add_word (const char *lang, const char *word) { - aspell_config_t *p; - aspell_speller_t *s; - - if (!aspell_plugin_config) - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [DEBUG] [CONFIG] no config", - _PLUGIN_NAME); - - for(p = aspell_plugin_config; p; p = p->next_config) - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [DEBUG] [CONFIG] @%p server='%s' channel='%s' @speller=%p lang='%s' @p=%p @n=%p", - _PLUGIN_NAME, p, p->server, p->channel, p->speller, p->speller->lang, p->prev_config, p->next_config); + struct t_aspell_speller *new_speller, *ptr_speller; - if (!aspell_plugin_speller) - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [DEBUG] [SPELLER] no speller", - _PLUGIN_NAME); - - for(s = aspell_plugin_speller; s; s = s->next_speller) - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [DEBUG] [SPELLER] @%p lang='%s' refs=%d @engine=%p @p=%p @n=%p", - _PLUGIN_NAME, s, s->lang, s->refs, s->speller, s->prev_speller, s->next_speller); -} - -/* - * weechat_aspell_config_enable_for : internal subroutine - */ - -void -weechat_aspell_config_enable_for (char *server, char *channel, char *lang) -{ - aspell_config_t *c; - aspell_speller_t *s; - - if (!weechat_aspell_speller_exists (lang)) + new_speller = NULL; + ptr_speller = weechat_aspell_speller_search (lang); + if (!ptr_speller) { - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [WARN] '%s' dictionary doesn't seems to be available on your system", - _PLUGIN_NAME, lang); - return; - } - - c = weechat_aspell_config_list_search (server, channel); - if (c) - { - c->speller->refs--; - if (c->speller->refs == 0) - weechat_aspell_speller_list_remove (c->speller->lang); - weechat_aspell_config_list_remove (server, channel); + if (!weechat_aspell_speller_exists (lang)) + { + weechat_printf (NULL, + _("%s: error: dictionary \"%s\" is not " + "available on your system"), + ASPELL_PLUGIN_NAME, lang); + return; + } + new_speller = weechat_aspell_speller_new (lang); + if (!new_speller) + return; + ptr_speller = new_speller; } - if (!weechat_aspell_config_list_add (server, channel)) + if (aspell_speller_add_to_personal (ptr_speller->speller, + word, + strlen (word)) == 1) { - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [ERROR] enabling spell checking on %s@%s failed", - _PLUGIN_NAME, channel, server); - return; - } - - s = weechat_aspell_speller_list_search (lang); - - if (!s) { - weechat_aspell_speller_list_add (lang); - s = aspell_plugin_speller; + weechat_printf (NULL, + _("%s: word \"%s\" added to personal dictionary"), + ASPELL_PLUGIN_NAME, word); } else - s->refs++; - - aspell_plugin_config->speller = s; - -} - -/* - * weechat_aspell_config_enable : - * enabling given lang spell checking on current server/channel - */ - -void -weechat_aspell_config_enable (char *lang) -{ - char *channel, *server; - - channel = weechat_aspell_plugin->get_info (weechat_aspell_plugin, "channel", NULL); - server = weechat_aspell_plugin->get_info (weechat_aspell_plugin, "server", NULL); - - if (!server || !channel) { - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [WARN] you are not in a channel", - _PLUGIN_NAME); - return; + weechat_printf (NULL, + _("%s%s: failed to add word to personal " + "dictionary"), + weechat_prefix ("error"), ASPELL_PLUGIN_NAME); } - weechat_aspell_config_enable_for (server, channel, lang); - - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] spell checking '%s' is now active on %s@%s", - _PLUGIN_NAME, lang, channel, server); - - if (channel) - free (channel); - if (server) - free (server); + if (new_speller) + weechat_aspell_speller_free (new_speller); } /* - * weechat_aspell_config_disable : - * disabling spell checking on current server/channel + * weechat_aspell_command_authorized: return 1 if command is authorized for + * spell checking, otherwise 0 */ -void -weechat_aspell_config_disable (void) +int +weechat_aspell_command_authorized (const char *command) { - aspell_config_t *c; - char *channel, *server; + int length_command, i; - channel = weechat_aspell_plugin->get_info (weechat_aspell_plugin, "channel", NULL); - server = weechat_aspell_plugin->get_info (weechat_aspell_plugin, "server", NULL); - - if (!server || !channel) - { - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [WARN] you are not in a channel", - _PLUGIN_NAME, NULL, NULL); - return; - } + if (!command) + return 1; - c = weechat_aspell_config_list_search (server, channel); - if (!c) + length_command = strlen (command); + + for (i = 0; i < weechat_aspell_count_commands_to_check; i++) { - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [WARN] spell checking is not active on %s@%s", - _PLUGIN_NAME, channel, server); - if (channel) - free (channel); - if (server) - free (server); - return; + if ((weechat_aspell_length_commands_to_check[i] == length_command) + && (weechat_strcasecmp (command, + weechat_aspell_commands_to_check[i]) == 0)) + { + /* command is authorized */ + return 1; + } } - c->speller->refs--; - if (c->speller->refs == 0) - weechat_aspell_speller_list_remove (c->speller->lang); - - weechat_aspell_config_list_remove (server, channel); - - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] spell checking is now inactive on %s@%s", - _PLUGIN_NAME, channel, server); - - if (channel) - free (channel); - if (server) - free (server); + /* command is not authorized */ + return 0; } /* - * weechat_aspell_config_set : setting options values + * weechat_aspell_string_strip_punctuation: strip punctuation chars at the + * begining and at the end of a word */ -int -weechat_aspell_config_set(char *option, char *value) +char * +weechat_aspell_string_strip_punctuation (const char *word) { - int c; + const char *ptr_start, *ptr_end; - if (strcmp (option, "word-size") == 0) - { - aspell_plugin_options.word_size = atoi ((value == NULL) ? "" : value); - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [SET] setting %s = %d", - _PLUGIN_NAME, option, aspell_plugin_options.word_size); - } - else if (strcmp (option, "toggle-check-mode") == 0) - { - aspell_plugin_options.check_sync = aspell_plugin_options.check_sync == 1 ? 0 : 1; - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - aspell_plugin_options.check_sync == 1 - ? "[%s] [SET] spellchecking is now set in realtime mode" - : "[%s] [SET] spellchecking is now set in asynchronous mode", - _PLUGIN_NAME, option); - } - else if (strcmp (option, "color") == 0) + if (!word) + return NULL; + + ptr_start = word; + while (ptr_start[0]) { - c = weechat_aspell_plugin->get_irc_color (weechat_aspell_plugin, (value == NULL) ? "" : value); - if (c == -1) - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [SET] setting %s = %s failed : color '%s' is unknown", - _PLUGIN_NAME, option, - (value == NULL) ? "" : value, - (value == NULL) ? "" : value); - else - { - aspell_plugin_options.color = c; - if (aspell_plugin_options.color_name) - free (aspell_plugin_options.color_name); - aspell_plugin_options.color_name = strdup (value); - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, - "[%s] [SET] setting %s = %s", - _PLUGIN_NAME, option, aspell_plugin_options.color_name); - } + if (!ispunct (ptr_start[0])) + break; + ptr_start++; } - else - return 0; - - return 1; -} -/* - * weechat_aspell_config_save : saving plugin config - */ - -int -weechat_aspell_config_save (void) -{ - aspell_config_t *p, *q; - char *servers, *channels, *option; - char **servers_list; - int n, i, s, found; + if (!ptr_start[0]) + return strdup (""); - servers = NULL; - - weechat_aspell_plugin->set_plugin_config (weechat_aspell_plugin, "servers", ""); + ptr_end = ptr_start + strlen (ptr_start) - 1; - for(p = aspell_plugin_config; p; p = p->next_config) + while (ptr_end >= ptr_start) { - servers = weechat_aspell_plugin->get_plugin_config (weechat_aspell_plugin, "servers"); - - if (!servers) - weechat_aspell_plugin->set_plugin_config (weechat_aspell_plugin, "servers", p->server); - else if (strlen (servers) == 0) - { - weechat_aspell_plugin->set_plugin_config (weechat_aspell_plugin, "servers", p->server); - free (servers); - } - else - { - servers_list = weechat_aspell_plugin->explode_string (weechat_aspell_plugin, servers, " ", 0, &s); - if (servers_list) - { - found = 0; - for (i=0; i<s; i++) - { - if (strcmp (servers_list[i], p->server) == 0) - { - found = 1; - break; - } - } - if (found == 0) - { - n = strlen (servers) + strlen (p->server) + 2; - servers = realloc (servers, n); - strcat (servers, " "); - strcat (servers, p->server); - weechat_aspell_plugin->set_plugin_config (weechat_aspell_plugin, "servers", servers); - } - free (servers_list); - } - free (servers); - } - - channels = NULL; - for(q = aspell_plugin_config; q; q = q->next_config) - { - if (strcmp (p->server, q->server) == 0) - { - if (!channels) - channels = strdup (q->channel); - else - { - n = strlen (channels) + strlen (q->channel) + 2; - channels = realloc (channels, n); - strcat (channels, " "); - strcat (channels, q->channel); - } - - n = 7 + strlen (p->server) + strlen (q->channel); - option = malloc (n); - snprintf (option, n, "lang_%s_%s", p->server, q->channel); - weechat_aspell_plugin->set_plugin_config (weechat_aspell_plugin, option, q->speller->lang); - free (option); - } - } - - if (channels) - { - n = 10 + strlen (p->server); - option = malloc (n); - snprintf (option, n, "channels_%s", p->server); - weechat_aspell_plugin->set_plugin_config (weechat_aspell_plugin, option, channels); - free (option); - free (channels); - } + if (!ispunct (ptr_end[0])) + break; + ptr_end--; } - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, "[%s] [SAVE] configuration saved", _PLUGIN_NAME); - return 1; + if (ptr_end < ptr_start) + return strdup (""); + + return weechat_strndup (ptr_start, ptr_end - ptr_start + 1); } /* - * weechat_aspell_config_load : loading plugin config + * weechat_aspell_string_is_url: detect if a word is an url */ -int -weechat_aspell_config_load(void) +int +weechat_aspell_string_is_url (const char *word) { - char *servers, *channels, *lang; - char *option_s, *option_l; - char **servers_list, **channels_list; - int i, j, s, c, n; - - servers = weechat_aspell_plugin->get_plugin_config (weechat_aspell_plugin, "servers"); - if (!servers) - return 0; - - servers_list = weechat_aspell_plugin->explode_string (weechat_aspell_plugin, servers, " ", 0, &s); - - if (servers_list) - { - for (i=0; i<s; i++) - { - n = 10 + strlen (servers_list[i]); - option_s = malloc (n); - snprintf (option_s, n, "channels_%s", servers_list[i]); - - channels = weechat_aspell_plugin->get_plugin_config (weechat_aspell_plugin, option_s); - if (channels) - { - channels_list = weechat_aspell_plugin->explode_string (weechat_aspell_plugin, channels, " ", 0, &c); - if (channels_list) - { - for (j=0; j<c; j++) - { - n = 7 + strlen (servers_list[i]) + strlen (channels_list[j]); - option_l = malloc (n); - snprintf (option_l, n, "lang_%s_%s", servers_list[i], channels_list[j]); - - lang = weechat_aspell_plugin->get_plugin_config (weechat_aspell_plugin, option_l); - if (lang) - { - weechat_aspell_config_enable_for (servers_list[i], channels_list[j], lang); - free (lang); - } - free (option_l); - } - weechat_aspell_plugin->free_exploded_string (weechat_aspell_plugin, channels_list); - } - free (channels); - } - free (option_s); - } - - weechat_aspell_plugin->free_exploded_string (weechat_aspell_plugin, servers_list); - } - - weechat_aspell_plugin->print_server (weechat_aspell_plugin, "[%s] [LOAD] configuration loaded", _PLUGIN_NAME); - return 1; + if ((weechat_strncasecmp(word, "http://", 7) == 0) + || (weechat_strncasecmp(word, "https://", 8) == 0) + || (weechat_strncasecmp(word, "ftp://", 6) == 0) + || (weechat_strncasecmp(word, "tftp://", 7) == 0) + || (weechat_strncasecmp(word, "ftps://", 7) == 0) + || (weechat_strncasecmp(word, "ssh://", 6) == 0) + || (weechat_strncasecmp(word, "fish://", 7) == 0) + || (weechat_strncasecmp(word, "dict://", 7) == 0) + || (weechat_strncasecmp(word, "ldap://", 7) == 0) + || (weechat_strncasecmp(word, "file://", 7) == 0) + || (weechat_strncasecmp(word, "telnet://", 9) == 0) + || (weechat_strncasecmp(word, "gopher://", 9) == 0) + || (weechat_strncasecmp(word, "irc://", 6) == 0) + || (weechat_strncasecmp(word, "ircs://", 7) == 0) + || (weechat_strncasecmp(word, "irc6://", 7) == 0) + || (weechat_strncasecmp(word, "irc6s://", 8) == 0) + || (weechat_strncasecmp(word, "cvs://", 6) == 0) + || (weechat_strncasecmp(word, "svn://", 6) == 0) + || (weechat_strncasecmp(word, "svn+ssh://", 10) == 0) + || (weechat_strncasecmp(word, "git://", 6) == 0)) + return 1; + + return 0; } /* - * weechat_aspell_options_save : saving plugin options + * weechat_aspell_string_is_simili_number: detect if a word is made of chars and + * punctuation */ int -weechat_aspell_options_save(void) +weechat_aspell_string_is_simili_number (const char *word) { - char buf[8]; + const char *ptr_word; - snprintf (buf, sizeof(buf), "%d", aspell_plugin_options.word_size); - weechat_aspell_plugin->set_plugin_config (weechat_aspell_plugin, "word-size", buf); + if (!word) + return 0; - snprintf (buf, sizeof(buf), "%d", aspell_plugin_options.check_sync); - weechat_aspell_plugin->set_plugin_config (weechat_aspell_plugin, "check-sync", buf); + ptr_word = word; + while (ptr_word[0]) + { + if (!ispunct (ptr_word[0]) && !isdigit (ptr_word[0])) + return 0; + ptr_word++; + } - weechat_aspell_plugin->set_plugin_config (weechat_aspell_plugin, "color", aspell_plugin_options.color_name); - - weechat_aspell_plugin->print (weechat_aspell_plugin, NULL, NULL, "[%s] [SAVE] options saved", _PLUGIN_NAME); + /* there's only digit or punctuation */ return 1; } /* - * weechat_aspell_options_load : loading plugin options + * weechat_aspell_check_word: spell check a word + * return 1 if word is ok, 0 if word is mispelled */ int -weechat_aspell_options_load(void) +weechat_aspell_check_word (struct t_gui_buffer *buffer, const char *word) { - char *buffer; - int n; + char *clean_word; + struct t_aspell_speller *ptr_speller; + int rc; - buffer = weechat_aspell_plugin->get_plugin_config (weechat_aspell_plugin, "word-size"); - if (buffer) - { - aspell_plugin_options.word_size = atoi (buffer); - free (buffer); - } - else - aspell_plugin_options.word_size = _PLUGIN_OPTION_WORD_SIZE; + clean_word = weechat_aspell_string_strip_punctuation (word); - buffer = weechat_aspell_plugin->get_plugin_config (weechat_aspell_plugin, "check-sync"); - if (buffer) - { - aspell_plugin_options.check_sync = atoi (buffer); - if (aspell_plugin_options.check_sync != 0 && aspell_plugin_options.check_sync != 1) - aspell_plugin_options.check_sync = _PLUGIN_OPTION_CHECK_SYNC; - free (buffer); - } - else - aspell_plugin_options.check_sync = _PLUGIN_OPTION_CHECK_SYNC; + if (!clean_word) + return 1; + rc = 0; - buffer = weechat_aspell_plugin->get_plugin_config (weechat_aspell_plugin, "color"); - if (buffer) - { - n = weechat_aspell_plugin->get_irc_color (weechat_aspell_plugin, buffer); - if (n == -1) - { - aspell_plugin_options.color = weechat_aspell_plugin->get_irc_color (weechat_aspell_plugin, _PLUGIN_OPTION_COLOR); - aspell_plugin_options.color_name = strdup (_PLUGIN_OPTION_COLOR); - } - else - { - aspell_plugin_options.color = n; - aspell_plugin_options.color_name = strdup (buffer); - } - free (buffer); - } - else { - aspell_plugin_options.color = weechat_aspell_plugin->get_irc_color (weechat_aspell_plugin, _PLUGIN_OPTION_COLOR); - aspell_plugin_options.color_name = strdup (_PLUGIN_OPTION_COLOR); + /* word too small? then do not check word */ + if ((weechat_config_integer (weechat_aspell_config_check_word_min_length) > 0) + && ((int)strlen (clean_word) < weechat_config_integer (weechat_aspell_config_check_word_min_length))) + rc = 1; + else + { + /* word is URL? then do not check word */ + if (weechat_aspell_string_is_url (clean_word)) + rc = 1; + else + { + /* word is a number? then do not check word */ + if (weechat_aspell_string_is_simili_number (clean_word)) + rc = 1; + else + { + /* word is a nick of nicklist on this buffer? then do not check word */ + if (weechat_nicklist_search_nick (buffer, NULL, clean_word)) + rc = 1; + else + { + /* check word with all spellers for this buffer (order is important) */ + for (ptr_speller = weechat_aspell_spellers; ptr_speller; + ptr_speller = ptr_speller->next_speller) + { + if (aspell_speller_check (ptr_speller->speller, clean_word, -1) == 1) + { + rc = 1; + break; + } + } + } + } + } } - weechat_aspell_plugin->print_server (weechat_aspell_plugin, "[%s] [LOAD] options loaded", _PLUGIN_NAME); - return 1; + free (clean_word); + + return rc; } /* - * weechat_aspell_speller_command : manage "/aspell" uses + * weechat_aspell_modifier_cb: modifier for input text */ -int -weechat_aspell_speller_command (t_weechat_plugin *p, - int argc, char **argv, - char *handler_args, - void *handler_pointer) +char * +weechat_aspell_modifier_cb (void *data, const char *modifier, + const char *modifier_data, const char *string) { - char helpcmd[32]; - char **args; - int c, r; + struct t_gui_buffer *buffer; + unsigned int value; + char *result, *ptr_string, *pos_space, *color_normal, *color_error; + int length, index_result, length_word, word_ok; + int length_color_normal, length_color_error; /* make C compiler happy */ - (void) p; - (void) handler_args; - (void) handler_pointer; - - snprintf(helpcmd, sizeof(helpcmd), "/help %s", plugin_command); - r = 0; - - if ((argc == 3) && argv[1] && argv[2]) - { - args = weechat_aspell_plugin->explode_string (weechat_aspell_plugin, argv[2], " ", 0, &c); - if (args) - { - if (c >= 1) - { - if (strcmp (args[0], "dictlist") == 0) - { - weechat_aspell_speller_list_dicts (); - r = 1; - } - else if (strcmp (args[0], "show") == 0) - { - weechat_aspell_config_show (); - r = 1; - } - else if (strcmp (args[0], "save") == 0) - { - weechat_aspell_config_save (); - weechat_aspell_options_save(); - r = 1; - } - else if (strcmp (args[0], "dump") == 0) - { - weechat_aspell_config_dump (); - r = 1; - } - else if (strcmp (args[0], "enable") == 0) - { - if (c >= 2) - { - weechat_aspell_config_enable (args[1]); - r = 1; - } - } - else if (strcmp (args[0], "disable") == 0) - weechat_aspell_config_disable (); - else if (strcmp (args[0], "set") == 0) - { - if (c >= 2) - { - r = weechat_aspell_config_set (args[1], args[2]); - } - } - else if (strcmp (args[0], "add-word") == 0) - { - if (c >= 2) - { - weechat_aspell_config_addword (args[1]); - r = 1; - } - } - - } - weechat_aspell_plugin->free_exploded_string (weechat_aspell_plugin, args); - } - } - - if (r == 0) - weechat_aspell_plugin->exec_command (weechat_aspell_plugin, NULL, NULL, helpcmd); + (void) data; + (void) modifier; - return PLUGIN_RC_OK; -} - -/* - * weechat_aspell_nick_in_server_channel : - * check presence of a nick in a server/channel - */ - -int -weechat_aspell_nick_in_channel (char *nick, char *server, char *channel) -{ - t_plugin_nick_info *nick_info, *ptr_nick; - int ret; - - ret = 0; - if (!nick || !server || ! channel) - return ret; + if (!string) + return NULL; - nick_info = weechat_aspell_plugin->get_nick_info ( - weechat_aspell_plugin, server, channel); - if (!nick_info) - return ret; - - for(ptr_nick = nick_info; ptr_nick; ptr_nick = ptr_nick->next_nick) - { - if (strcmp (nick, ptr_nick->nick) == 0) { - ret = 1; - break; - } - } + sscanf (modifier_data, "%x", &value); + buffer = (struct t_gui_buffer *)value; - weechat_aspell_plugin->free_nick_info (weechat_aspell_plugin, nick_info); - - return ret; -} - -/* - * weechat_aspell_clean_word : - * strip punct chars at the begining and at the end of a word - */ - -char * -weechat_aspell_clean_word (char *word, int *offset) -{ - int len; - char *buffer, *w, *p; - - if (!word) - return NULL; + if (!weechat_aspell_spellers) + return NULL; - buffer = strdup (word); - - *offset = 0; - p = buffer; - while (p) + /* for performance: return last stirng built if input string is the + same (for example user just change cursor position, or input text is + refreshed with same content */ + if (aspell_last_modifier_string + && (strcmp (string, aspell_last_modifier_string) == 0)) { - if (!ispunct(*p)) - break; - p++; - (*offset)++; + return (aspell_last_modifier_result) ? + strdup (aspell_last_modifier_result) : NULL; } - - p = buffer + strlen(buffer) - 1; - while (p >= buffer) + + /* free last modifier string and result */ + if (aspell_last_modifier_string) { - if (!ispunct(*p)) - break; - p--; + free (aspell_last_modifier_string); + aspell_last_modifier_string = NULL; } - - len = p - buffer - *offset + 1; - if (len <= 0) + if (aspell_last_modifier_result) { - free (buffer); - return NULL; + free (aspell_last_modifier_result); + aspell_last_modifier_result = NULL; } - w = malloc (len+1); - - if (w) { - memcpy (w, buffer + *offset, len); - w[len] = '\0'; - } - - free (buffer); - - return w; -} - -/* - * weechat_aspell_is_simili_number : - * detect if a word is made of chars and punctation - */ - -int -weechat_aspell_is_simili_number (char *word) -{ - int len, ret, i; + /* save last modifier string received */ + aspell_last_modifier_string = strdup (string); - ret = 1; - len = strlen (word); + color_normal = weechat_color (weechat_config_string (weechat_config_get ("weechat.color.input"))); + length_color_normal = strlen (color_normal); + color_error = weechat_color (weechat_config_string (weechat_aspell_config_look_color)); + length_color_error = strlen (color_error); - if (!word) - return 0; + length = strlen (string); + result = malloc (length + (length * length_color_error)); + result[0] = '\0'; - for (i=0; i<len; i++) + if (result) { - if (!ispunct(word[i]) && !isdigit(word[i])) - { - ret = 0; - break; - } + ptr_string = aspell_last_modifier_string; + index_result = 0; + + /* check if string is a command */ + if ((ptr_string[0] == '/') && ptr_string[1] && (ptr_string[1] != '/') + && (ptr_string[1] != ' ')) + { + ptr_string++; + pos_space = strchr (ptr_string, ' '); + if (!pos_space) + { + 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; + } + result[index_result++] = '/'; + strcpy (result + index_result, ptr_string); + index_result += strlen (ptr_string); + + pos_space[0] = ' '; + ptr_string = pos_space; + } + + while (ptr_string[0]) + { + while (ptr_string[0] == ' ') + { + result[index_result++] = ' '; + ptr_string++; + } + if (!ptr_string[0]) + break; + + pos_space = strchr (ptr_string, ' '); + if (pos_space) + { + pos_space[0] = '\0'; + length_word = pos_space - ptr_string; + } + else + length_word = strlen (ptr_string); + + word_ok = weechat_aspell_check_word (buffer, ptr_string); + + /* 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 mispelled word) */ + if (!word_ok) + { + strcpy (result + index_result, color_normal); + index_result += length_color_normal; + } + + if (pos_space) + { + pos_space[0] = ' '; + ptr_string = pos_space; + } + else + break; + } + + result[index_result] = '\0'; } - return ret; -} - -/* - * weechat_aspell_is_url : - * detect if a word is an url - */ - -int -weechat_aspell_is_url (char *word) -{ - int ret; - - ret = 0; - if (strncasecmp(word, "http://", 7) == 0 - || strncasecmp(word, "https://", 8) == 0 - || strncasecmp(word, "ftp://", 6) == 0 - || strncasecmp(word, "tftp://", 7) == 0 - || strncasecmp(word, "ftps://", 7) == 0 - || strncasecmp(word, "ssh://", 6) == 0 - || strncasecmp(word, "fish://", 7) == 0 - || strncasecmp(word, "dict://", 7) == 0 - || strncasecmp(word, "ldap://", 7) == 0 - || strncasecmp(word, "file://", 7) == 0 - || strncasecmp(word, "telnet://", 9) == 0 - || strncasecmp(word, "gopher://", 9) == 0 - || strncasecmp(word, "irc://", 6) == 0 - || strncasecmp(word, "ircs://", 7) == 0 - || strncasecmp(word, "irc6://", 7) == 0 - || strncasecmp(word, "irc6s://", 8) == 0 - || strncasecmp(word, "cvs://", 6) == 0 - || strncasecmp(word, "svn://", 6) == 0 - || strncasecmp(word, "svn+ssh://", 10) == 0) - ret = 1; - return ret; + if (!result) + return NULL; + + aspell_last_modifier_result = strdup (result); + return result; } /* - * weechat_aspell_keyb_check : handler to check spelling on input line + * weechat_aspell_command_cb: callback for /aspell command */ int -weechat_aspell_keyb_check (t_weechat_plugin *p, int argc, char **argv, - char *handler_args, void *handler_pointer) +weechat_aspell_command_cb (void *data, struct t_gui_buffer *buffer, + int argc, char **argv, char **argv_eol) { - char *server, *channel; - aspell_config_t *c; - cmds_keep_t *cmd; - int keep_cmd_found; - char *input, *ptr_input, *pos_space, *clword; - int count, offset; + char *dicts; /* make C compiler happy */ - (void) p; - (void) handler_args; - (void) handler_pointer; - - channel = weechat_aspell_plugin->get_info (weechat_aspell_plugin, "channel", NULL); - server = weechat_aspell_plugin->get_info (weechat_aspell_plugin, "server", NULL); - - if (!server || !channel) - return PLUGIN_RC_OK; - - c = weechat_aspell_config_list_search (server, channel); - if (!c) - return PLUGIN_RC_OK; - - if (aspell_plugin_options.check_sync == 0 && argv[0] && argv[0][0]) - { - if (argv[0][0] == '*' && !ispunct (argv[0][1]) && !isspace (argv[0][1])) - return PLUGIN_RC_OK; - } - - if (!(argc == 3 && argv[1] && argv[2])) - return PLUGIN_RC_OK; - - if (strcmp (argv[1], argv[2]) == 0) - return PLUGIN_RC_OK; + (void) data; - input = weechat_aspell_plugin->get_info (weechat_aspell_plugin, "input", NULL); - if (!input) - return PLUGIN_RC_OK; - - if (!input[0]) - return PLUGIN_RC_OK; - - if (input[0] == '/') + if (argc > 1) { - keep_cmd_found = 0; - for(cmd = cmd_tokeep; cmd->cmd; ++cmd) - { - if (strncasecmp (input, cmd->cmd, cmd->len) == 0) { - keep_cmd_found = 1; - break; - } - } - if (keep_cmd_found == 0) - return PLUGIN_RC_OK; + if (weechat_strcasecmp (argv[1], "dictlist") == 0) + { + weechat_aspell_speller_list_dicts (); + return WEECHAT_RC_OK; + } + 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; + } + if (weechat_strcasecmp (argv[1], "enable") == 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; + } + if (weechat_strcasecmp (argv[1], "disable") == 0) + { + weechat_aspell_set_dict (buffer, NULL); + return WEECHAT_RC_OK; + } } - count = 0; - ptr_input = input; - weechat_aspell_plugin->input_color (weechat_aspell_plugin, 0, 0, 0); - while (ptr_input && ptr_input[0]) - { - pos_space = strchr (ptr_input, ' '); - if (pos_space) - pos_space[0] = '\0'; - - if (ptr_input[0] != '/' && ptr_input[0] != '-' && ptr_input[0] != '#') - { - clword = weechat_aspell_clean_word (ptr_input, &offset); - if (clword) - { - if ( (int) strlen (clword) >= aspell_plugin_options.word_size) - { - if (!weechat_aspell_is_url (clword)) - { - if (!weechat_aspell_is_simili_number (clword)) - { - if (!weechat_aspell_nick_in_channel (clword, server, channel)) - { - if (aspell_speller_check (c->speller->speller, clword, -1) != 1) - { - if (count == 0) - weechat_aspell_plugin->input_color (weechat_aspell_plugin, 0, 0, 0); - weechat_aspell_plugin->input_color (weechat_aspell_plugin, aspell_plugin_options.color, - ptr_input - input + offset, strlen (clword)); - count++; - } - } - } - } - } - free (clword); - } - } - - if (pos_space) - { - pos_space[0] = ' '; - ptr_input = pos_space + 1; - while (ptr_input[0] == ' ') - ptr_input++; - } - else - ptr_input = NULL; - } - weechat_aspell_plugin->input_color (weechat_aspell_plugin, -1, 0, 0); - - free (input); - - return PLUGIN_RC_OK; + return WEECHAT_RC_OK; } /* - * weechat_plugin_init : init function, called when plugin is loaded + * weechat_plugin_init : init aspell plugin */ int -weechat_plugin_init (t_weechat_plugin *plugin) +weechat_plugin_init (struct t_weechat_plugin *plugin, int argc, char *argv[]) { - char help[1024]; - aspell_plugin_speller = NULL; - aspell_plugin_config = NULL; - weechat_aspell_plugin = plugin; - - snprintf (help, sizeof(help), - " show : show plugin configuration\n" - "dictlist : show installed dictionnaries\n" - " save : save plugin configuration\n" - " enable : enable aspell on current channel/server\n" - " disable : disable aspell on current channel/server\n" - "add-word : add a word in your personnal aspell dict\n" - " dump : show plugins internals (usefull for debug)\n" - " set : setting options\n" - " OPTION := { word-size SIZE | toogle-check-mode | color COLOR }\n" - " word-size : minimum size for a word to be checked (default : %d)\n" - " toggle-check-mode : switch between a realtime or an asynchronous checking\n" - " color : color of the mispelled words\n" - "\n" - " *NB : input line beginning with a '/' is not checked\n", - _PLUGIN_OPTION_WORD_SIZE); - - weechat_aspell_plugin->cmd_handler_add (weechat_aspell_plugin, "aspell", - "Aspell Plugin configuration", - "{ show | save | dictlist | set [OPTION [VALUE]] | add-word WORD | enable LANG | disable | dump }", - help, - "show|dictlist|save|enable|disable|set|add-word|dump word-size|toggle-check-mode|color", - &weechat_aspell_speller_command, NULL, NULL); - - weechat_aspell_plugin->keyboard_handler_add ( - weechat_aspell_plugin, &weechat_aspell_keyb_check, NULL, NULL); - - weechat_aspell_options_load (); - weechat_aspell_config_load (); - - return PLUGIN_RC_OK; + /* make C compiler happy */ + (void) argc; + (void) argv; + + weechat_plugin = plugin; + + if (!weechat_aspell_config_init ()) + return WEECHAT_RC_ERROR; + + if (weechat_aspell_config_read () < 0) + return WEECHAT_RC_ERROR; + + /* callback for debug */ + weechat_hook_signal ("debug", &weechat_aspell_debug_cb, NULL); + + /* command /aspell */ + weechat_hook_command ("aspell", + N_("aspell plugin configuration"), + N_("[list | enable lang | disable | addword [lang] " + "word]"), + N_(" list: show installed dictionnaries\n" + " enable: enable aspell on current buffer\n" + "disable: disable aspell on current buffer\n" + "addword: add a word in your personnal aspell dictionary\n" + "\n" + "Input line beginning with a '/' is not checked, " + "except for some commands."), + "list|enable|disable|addword", + &weechat_aspell_command_cb, NULL); + + /* callback for buffer_switch */ + weechat_hook_signal ("buffer_switch", + &weechat_aspell_buffer_switch_cb, NULL); + + /* callback for spell checking input text */ + weechat_hook_modifier ("weechat_input_text_display", + &weechat_aspell_modifier_cb, NULL); + + weechat_aspell_create_spellers (weechat_current_buffer); + + return WEECHAT_RC_OK; } /* - * weechat_plugin_end : end function, called when plugin is unloaded + * weechat_plugin_end : end aspell plugin */ -void -weechat_plugin_end (t_weechat_plugin *p) +int +weechat_plugin_end (struct t_weechat_plugin *plugin) { - aspell_speller_t *s, *t; - aspell_config_t *c, *d; - /* make C compiler happy */ - (void) p; + (void) plugin; - weechat_aspell_options_save (); - weechat_aspell_config_save (); - - /* freeing memory */ + weechat_aspell_config_write (); - /* options */ - if (aspell_plugin_options.color_name) - free (aspell_plugin_options.color_name); - - /* spellers */ - s = aspell_plugin_speller; - while ( s != NULL) - { - t = s; - s = s->next_speller; - weechat_aspell_free_speller (t); - } + weechat_aspell_speller_free_all (); - /* config */ - c = aspell_plugin_config; - while ( c != NULL) - { - d = c; - c = c->next_config; - weechat_aspell_free_config (c); - } + if (aspell_last_modifier_string) + free (aspell_last_modifier_string); + if (aspell_last_modifier_result) + free (aspell_last_modifier_result); + + weechat_aspell_config_free (); + + return WEECHAT_RC_OK; } diff --git a/src/plugins/aspell/aspell.h b/src/plugins/aspell/aspell.h index 71d528960..42dc2217b 100644 --- a/src/plugins/aspell/aspell.h +++ b/src/plugins/aspell/aspell.h @@ -16,180 +16,28 @@ * along with this program. If not, see <http://www.gnu.org/licenses/>. */ -/* weechat-aspell.h: Aspell plugin support for WeeChat */ #ifndef __WEECHAT_ASPELL_H #define __WEECHAT_ASPELL_H 1 #include <aspell.h> -#define _PLUGIN_OPTION_WORD_SIZE 2 -#define _PLUGIN_OPTION_CHECK_SYNC 0 -#define _PLUGIN_OPTION_COLOR "red" +#define weechat_plugin weechat_aspell_plugin +#define ASPELL_PLUGIN_NAME "aspell" -typedef struct aspell_speller_t -{ - AspellSpeller *speller; - char *lang; - int refs; - - struct aspell_speller_t *prev_speller; - struct aspell_speller_t *next_speller; -} aspell_speller_t; - -typedef struct aspell_config_t -{ - char *server; - char *channel; - aspell_speller_t *speller; - - struct aspell_config_t *prev_config; - struct aspell_config_t *next_config; -} aspell_config_t; - -typedef struct aspell_options_t -{ - int word_size; - int check_sync; - int color; - char *color_name; -} aspell_options_t; - -typedef struct iso_langs_t +struct t_aspell_code { char *code; char *name; -} iso_langs_t; - -typedef struct iso_countries_t -{ - char *code; - char *name; -} iso_countries_t; +}; -typedef struct cmds_keep_t -{ - char *cmd; - int len; -} cmds_keep_t; +extern int aspell_debug; -/* aspell supported langs 2006-05-27 */ -iso_langs_t langs_avail[] = -{ - { "af", "Afrikaans"}, - { "am", "Amharic"}, - { "az", "Azerbaijani"}, - { "be", "Belarusian"}, - { "bg", "Bulgarian"}, - { "bn", "Bengali"}, - { "br", "Breton"}, - { "ca", "Catalan"}, - { "cs", "Czech"}, - { "csb", "Kashubian"}, - { "cy", "Welsh"}, - { "da", "Danish"}, - { "de", "German"}, - { "el", "Greek Modern"}, - { "en", "English"}, - { "eo", "Esperanto"}, - { "es", "Spanish"}, - { "et", "Estonian"}, - { "fa", "Persian"}, - { "fi", "Finnish"}, - { "fo", "Faroese"}, - { "fr", "French"}, - { "ga", "Irish"}, - { "gd", "Gaelic"}, - { "gl", "Galician"}, - { "gu", "Gujarati"}, - { "gv", "Manx"}, - { "he", "Hebrew"}, - { "hi", "Hiligaynon"}, - { "hr", "Croatian"}, - { "hsb", "Upper Sorbian"}, - { "hu", "Hungarian"}, - { "ia", "Interlingua"}, - { "id", "Indonesian"}, - { "is", "Icelandic"}, - { "it", "Italian"}, - { "ku", "Kurdish"}, - { "la", "Latin"}, - { "lt", "Lithuanian"}, - { "lv", "Latvian"}, - { "mg", "Malagasy"}, - { "mi", "Maori"}, - { "mk", "Macedonian"}, - { "mn", "Mongolian"}, - { "mr", "Marathi"}, - { "ms", "Malay"}, - { "mt", "Maltese"}, - { "nb", "Norwegian Bokmal"}, - { "nds", "Saxon Low"}, - { "nl", "Flemish"}, - { "nn", "Norwegian Nynorsk"}, - { "no", "Norwegian"}, - { "ny", "Nyanja"}, - { "or", "Oriya"}, - { "pa", "Panjabi"}, - { "pl", "Polish"}, - { "pt", "Portuguese"}, - { "qu", "Quechua"}, - { "ro", "Romanian"}, - { "ru", "Russian"}, - { "rw", "Kinyarwanda"}, - { "sc", "Sardinian"}, - { "sk", "Slovak"}, - { "sl", "Slovenian"}, - { "sr", "Serbian"}, - { "sv", "Swedish"}, - { "sw", "Swahili"}, - { "ta", "Tamil"}, - { "te", "Telugu"}, - { "tet", "Tetum"}, - { "tl", "Tagalog"}, - { "tn", "Tswana"}, - { "tr", "Turkish"}, - { "uk", "Ukrainian"}, - { "uz", "Uzbek"}, - { "vi", "Vietnamese"}, - { "wa", "Walloon"}, - { "yi", "Yiddish"}, - { "zu", "Zulu"}, - { NULL, NULL} -}; +extern struct t_weechat_plugin *weechat_aspell_plugin; -iso_countries_t countries_avail[] = -{ - { "AT", "Austria" }, - { "BR", "Brazil" }, - { "CA", "Canada" }, - { "CH", "Switzerland" }, - { "DE", "Germany" }, - { "FR", "France" }, - { "GB", "Great Britain" }, - { "PT", "Portugal" }, - { "SK", "Slovakia" }, - { "US", "United States of America" }, - { NULL, NULL} -}; +extern struct t_aspell_code langs_avail[]; +extern struct t_aspell_code countries_avail[]; -/* internal or irc commands to be use with spellchecking */ -cmds_keep_t cmd_tokeep[] = -{ - { "/builtin ", 9 }, - { "/ame " , 5 }, - { "/amsg " , 6 }, - { "/away " , 6 }, - { "/cycle " , 7 }, - { "/kick " , 6 }, - { "/kickban " , 9 }, - { "/me " , 4 }, - { "/notice " , 8 }, - { "/part " , 6 }, - { "/query " , 7 }, - { "/quit " , 6 }, - { "/topic " , 7 }, - { NULL, 0} -}; +extern void weechat_aspell_create_spellers (struct t_gui_buffer *buffer); #endif /* aspell.h */ diff --git a/src/plugins/charset/charset.c b/src/plugins/charset/charset.c index b76d1dc5e..d124d6d10 100644 --- a/src/plugins/charset/charset.c +++ b/src/plugins/charset/charset.c @@ -354,7 +354,7 @@ charset_decode_cb (void *data, const char *modifier, const char *modifier_data, { weechat_printf (NULL, "charset: debug: using 'decode' charset: %s " - "(modifier='%s', modifier_data='%s', string='%s')", + "(modifier=\"%s\", modifier_data=\"%s\", string=\"%s\")", charset, modifier, modifier_data, string); } if (charset && charset[0]) @@ -383,7 +383,7 @@ charset_encode_cb (void *data, const char *modifier, const char *modifier_data, { weechat_printf (NULL, "charset: debug: using 'encode' charset: %s " - "(modifier='%s', modifier_data='%s', string='%s')", + "(modifier=\"%s\", modifier_data=\"%s\", string=\"%s\")", charset, modifier, modifier_data, string); } if (charset && charset[0]) @@ -407,11 +407,11 @@ charset_set (struct t_config_section *section, const char *type, value) > 0) { if (value && value[0]) - weechat_printf (NULL, _("Charset: %s, %s => %s"), - type, name, value); + weechat_printf (NULL, "%s: %s, %s => %s", + CHARSET_PLUGIN_NAME, type, name, value); else - weechat_printf (NULL, _("Charset: %s, %s: removed"), - type, name); + weechat_printf (NULL, _("%s: %s, %s: removed"), + CHARSET_PLUGIN_NAME, type, name); } } diff --git a/src/plugins/demo/demo.c b/src/plugins/demo/demo.c index 08c4dc5fd..bedb096f9 100644 --- a/src/plugins/demo/demo.c +++ b/src/plugins/demo/demo.c @@ -87,7 +87,7 @@ demo_printf_command_cb (void *data, struct t_gui_buffer *buffer, int argc, if (argc > 1) weechat_printf (buffer, - "demo_printf: '%s'", argv_eol[1]); + "demo_printf: \"%s\"", argv_eol[1]); else { weechat_printf (buffer, @@ -121,7 +121,7 @@ demo_buffer_input_data_cb (void *data, struct t_gui_buffer *buffer, weechat_printf (buffer, "buffer_input_data_cb: buffer = %x (%s), " - "input_data = '%s'", + "input_data = \"%s\"", buffer, weechat_buffer_get_string (buffer, "name"), input_data); @@ -372,7 +372,7 @@ demo_signal_cb (void *data, const char *signal, const char *type_data, { weechat_printf (NULL, _("demo_signal: signal: %s, type_data: %s, " - "signal_data: '%s'"), + "signal_data: \"%s\""), signal, type_data, (char *)signal_data); } else if (strcmp (type_data, WEECHAT_HOOK_SIGNAL_INT) == 0) diff --git a/src/plugins/irc/irc-command.c b/src/plugins/irc/irc-command.c index 7d6d7b987..e89865ed1 100644 --- a/src/plugins/irc/irc-command.c +++ b/src/plugins/irc/irc-command.c @@ -2795,7 +2795,7 @@ irc_command_server (void *data, struct t_gui_buffer *buffer, int argc, { weechat_printf (NULL, ""); weechat_printf (NULL, - _("Servers with '%s':"), + _("Servers with \"%s\":"), server_name); } one_server_found = 1; diff --git a/src/plugins/irc/irc-ignore.c b/src/plugins/irc/irc-ignore.c index 22d827436..d69b05edf 100644 --- a/src/plugins/irc/irc-ignore.c +++ b/src/plugins/irc/irc-ignore.c @@ -230,9 +230,9 @@ irc_ignore_free (struct t_irc_ignore *ignore) /* remove filter from filters list */ if (ignore->prev_ignore) - ignore->prev_ignore->next_ignore = ignore->next_ignore; + (ignore->prev_ignore)->next_ignore = ignore->next_ignore; if (ignore->next_ignore) - ignore->next_ignore->prev_ignore = ignore->prev_ignore; + (ignore->next_ignore)->prev_ignore = ignore->prev_ignore; if (irc_ignore_list == ignore) irc_ignore_list = ignore->next_ignore; if (last_irc_ignore == ignore) diff --git a/src/plugins/logger/logger-config.h b/src/plugins/logger/logger-config.h index e789e7f7a..c2c1d6fa1 100644 --- a/src/plugins/logger/logger-config.h +++ b/src/plugins/logger/logger-config.h @@ -23,8 +23,6 @@ #define LOGGER_CONFIG_NAME "logger" -extern struct t_config_file *logger_config_file; - extern struct t_config_option *logger_config_look_backlog; extern struct t_config_option *logger_config_file_auto_log; diff --git a/src/plugins/scripts/script.c b/src/plugins/scripts/script.c index 71211a702..7a880d97a 100644 --- a/src/plugins/scripts/script.c +++ b/src/plugins/scripts/script.c @@ -179,7 +179,7 @@ script_ptr2str (void *pointer) if (!pointer) return strdup (""); - snprintf (pointer_str, sizeof (pointer_str) - 1, + snprintf (pointer_str, sizeof (pointer_str), "0x%x", (unsigned int)pointer); return strdup (pointer_str); |