src/editor/spell.c

   1 /*
   2    Editor spell checker
   3
   4    Copyright (C) 2012
   5    The Free Software Foundation, Inc.
   6
   7    Written by:
   8    Ilia Maslakov <il.smind@gmail.com>, 2012
   9
  10    This file is part of the Midnight Commander.
  11
  12    The Midnight Commander is free software: you can redistribute it
  13    and/or modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation, either version 3 of the License,
  15    or (at your option) any later version.
  16
  17    The Midnight Commander is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 #include <config.h>
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <gmodule.h>
  31 #include <aspell.h>
  32
  33 #ifdef HAVE_CHARSET
  34 #include "lib/charsets.h"
  35 #endif
  36 #include "lib/strutil.h"
  37
  38 #include "edit-impl.h"
  39 #include "spell.h"
  40
  41 /*** global variables ****************************************************************************/
  42
  43 /*** file scope macro definitions ****************************************************************/
  44
  45 /*** file scope type declarations ****************************************************************/
  46
  47 typedef struct aspell_struct
  48 {
  49     AspellConfig *config;
  50     AspellSpeller *speller;
  51 } spell_t;
  52
  53 /*** file scope variables ************************************************************************/
  54
  55 static GModule *spell_module = NULL;
  56 static spell_t *global_speller = NULL;
  57
  58 static struct AspellConfig *(*mc_new_aspell_config) (void);
  59 static int (*mc_aspell_config_replace) (struct AspellConfig * ths, const char *key,
  60                                         const char *value);
  61 static struct AspellCanHaveError *(*mc_new_aspell_speller) (struct AspellConfig * config);
  62 static unsigned int (*mc_aspell_error_number) (const struct AspellCanHaveError * ths);
  63 static const char *(*mc_aspell_speller_error_message) (const struct AspellSpeller * ths);
  64 const struct AspellError *(*mc_aspell_speller_error) (const struct AspellSpeller * ths);
  65
  66 static struct AspellSpeller *(*mc_to_aspell_speller) (struct AspellCanHaveError * obj);
  67 static int (*mc_aspell_speller_check) (struct AspellSpeller * ths, const char *word, int word_size);
  68 static const struct AspellWordList *(*mc_aspell_speller_suggest) (struct AspellSpeller * ths,
  69                                                                   const char *word, int word_size);
  70 static struct AspellStringEnumeration *(*mc_aspell_word_list_elements) (const struct AspellWordList
  71                                                                         * ths);
  72 static const char *(*mc_aspell_config_retrieve) (struct AspellConfig * ths, const char *key);
  73 static void (*mc_delete_aspell_speller) (struct AspellSpeller * ths);
  74 static void (*mc_delete_aspell_config) (struct AspellConfig * ths);
  75 static void (*mc_delete_aspell_can_have_error) (struct AspellCanHaveError * ths);
  76 static const char *(*mc_aspell_error_message) (const struct AspellCanHaveError * ths);
  77 static void (*mc_delete_aspell_string_enumeration) (struct AspellStringEnumeration * ths);
  78 static struct AspellDictInfoEnumeration *(*mc_aspell_dict_info_list_elements)
  79     (const struct AspellDictInfoList * ths);
  80 static struct AspellDictInfoList *(*mc_get_aspell_dict_info_list) (struct AspellConfig * config);
  81 static const struct AspellDictInfo *(*mc_aspell_dict_info_enumeration_next)
  82     (struct AspellDictInfoEnumeration * ths);
  83 static const char *(*mc_aspell_string_enumeration_next) (struct AspellStringEnumeration * ths);
  84 static void (*mc_delete_aspell_dict_info_enumeration) (struct AspellDictInfoEnumeration * ths);
  85 static unsigned int (*mc_aspell_word_list_size) (const struct AspellWordList * ths);
  86 static const struct AspellError *(*mc_aspell_error) (const struct AspellCanHaveError * ths);
  87 static int (*mc_aspell_speller_add_to_personal) (struct AspellSpeller * ths, const char *word,
  88                                                  int word_size);
  89 static int (*mc_aspell_speller_save_all_word_lists) (struct AspellSpeller * ths);
  90
  91 static struct
  92 {
  93     const char *code;
  94     const char *name;
  95 } spell_codes_map[] =
  96 {
  97     /* *INDENT-OFF* */
  98     {"br", "Breton"},
  99     {"cs", "Czech"},
 100     {"cy", "Welsh"},
 101     {"da", "Danish"},
 102     {"de", "German"},
 103     {"el", "Greek"},
 104     {"en", "English"},
 105     {"en_GB", "British English"},
 106     {"en_CA", "Canadian English"},
 107     {"en_US", "American English"},
 108     {"eo", "Esperanto"},
 109     {"es", "Spanish"},
 110     {"fo", "Faroese"},
 111     {"fr", "French"},
 112     {"it", "Italian"},
 113     {"nl", "Dutch"},
 114     {"no", "Norwegian"},
 115     {"pl", "Polish"},
 116     {"pt", "Portuguese"},
 117     {"ro", "Romanian"},
 118     {"ru", "Russian"},
 119     {"sk", "Slovak"},
 120     {"sv", "Swedish"},
 121     {"uk", "Ukrainian"},
 122     {NULL, NULL}
 123     /* *INDENT-ON* */
 124 };
 125
 126 /*** file scope functions ************************************************************************/
 127 /* --------------------------------------------------------------------------------------------- */
 128 /**
 129  * Found the language name by language code. For example: en_US -> American English.
 130  *
 131  * @param code Short name of the language (ru, en, pl, uk, etc...)
 132  * @returns the language name
 133  */
 134
 135 static const char *
 136 spell_decode_lang (const char *code)
 137 {
 138     size_t i;
 139
 140     for (i = 0; spell_codes_map[i].code != NULL; i++)
 141     {
 142         if (strcmp (spell_codes_map[i].code, code) == 0)
 143             return spell_codes_map[i].name;
 144     }
 145
 146     return code;
 147 }
 148
 149 /* --------------------------------------------------------------------------------------------- */
 150 /**
 151  * Checks if aspell library and symbols are available.
 152  *
 153  * @returns FALSE or error
 154  */
 155
 156 static gboolean
 157 spell_available (void)
 158 {
 159     gchar *spell_module_fname;
 160     gboolean ret = FALSE;
 161
 162     if (spell_module != NULL)
 163         return TRUE;
 164
 165     spell_module_fname = g_module_build_path (NULL, "libaspell");
 166     spell_module = g_module_open (spell_module_fname, G_MODULE_BIND_LAZY);
 167
 168     g_free (spell_module_fname);
 169
 170     if (spell_module == NULL)
 171         return FALSE;
 172
 173     if (!g_module_symbol (spell_module, "new_aspell_config", (void *) &mc_new_aspell_config))
 174         goto error_ret;
 175
 176     if (!g_module_symbol (spell_module, "aspell_dict_info_list_elements",
 177                           (void *) &mc_aspell_dict_info_list_elements))
 178         goto error_ret;
 179
 180     if (!g_module_symbol (spell_module, "aspell_dict_info_enumeration_next",
 181                           (void *) &mc_aspell_dict_info_enumeration_next))
 182         goto error_ret;
 183
 184     if (!g_module_symbol (spell_module, "new_aspell_speller", (void *) &mc_new_aspell_speller))
 185         goto error_ret;
 186
 187     if (!g_module_symbol (spell_module, "aspell_error_number", (void *) &mc_aspell_error_number))
 188         goto error_ret;
 189
 190     if (!g_module_symbol (spell_module, "aspell_speller_error_message",
 191                           (void *) &mc_aspell_speller_error_message))
 192         goto error_ret;
 193
 194     if (!g_module_symbol (spell_module, "aspell_speller_error", (void *) &mc_aspell_speller_error))
 195         goto error_ret;
 196
 197     if (!g_module_symbol (spell_module, "aspell_error", (void *) &mc_aspell_error))
 198         goto error_ret;
 199
 200     if (!g_module_symbol (spell_module, "to_aspell_speller", (void *) &mc_to_aspell_speller))
 201         goto error_ret;
 202
 203     if (!g_module_symbol (spell_module, "aspell_speller_check", (void *) &mc_aspell_speller_check))
 204         goto error_ret;
 205
 206     if (!g_module_symbol
 207         (spell_module, "aspell_speller_suggest", (void *) &mc_aspell_speller_suggest))
 208         goto error_ret;
 209
 210     if (!g_module_symbol
 211         (spell_module, "aspell_word_list_elements", (void *) &mc_aspell_word_list_elements))
 212         goto error_ret;
 213
 214     if (!g_module_symbol (spell_module, "aspell_string_enumeration_next",
 215                           (void *) &mc_aspell_string_enumeration_next))
 216         goto error_ret;
 217
 218     if (!g_module_symbol
 219         (spell_module, "aspell_config_replace", (void *) &mc_aspell_config_replace))
 220         goto error_ret;
 221
 222     if (!g_module_symbol (spell_module, "aspell_error_message", (void *) &mc_aspell_error_message))
 223         goto error_ret;
 224
 225     if (!g_module_symbol
 226         (spell_module, "delete_aspell_speller", (void *) &mc_delete_aspell_speller))
 227         goto error_ret;
 228
 229     if (!g_module_symbol (spell_module, "delete_aspell_config", (void *) &mc_delete_aspell_config))
 230         goto error_ret;
 231
 232     if (!g_module_symbol (spell_module, "delete_aspell_string_enumeration",
 233                           (void *) &mc_delete_aspell_string_enumeration))
 234         goto error_ret;
 235
 236     if (!g_module_symbol (spell_module, "get_aspell_dict_info_list",
 237                           (void *) &mc_get_aspell_dict_info_list))
 238         goto error_ret;
 239
 240     if (!g_module_symbol (spell_module, "delete_aspell_can_have_error",
 241                           (void *) &mc_delete_aspell_can_have_error))
 242         goto error_ret;
 243
 244     if (!g_module_symbol (spell_module, "delete_aspell_dict_info_enumeration",
 245                           (void *) &mc_delete_aspell_dict_info_enumeration))
 246         goto error_ret;
 247
 248     if (!g_module_symbol
 249         (spell_module, "aspell_config_retrieve", (void *) &mc_aspell_config_retrieve))
 250         goto error_ret;
 251
 252     if (!g_module_symbol
 253         (spell_module, "aspell_word_list_size", (void *) &mc_aspell_word_list_size))
 254         goto error_ret;
 255
 256     if (!g_module_symbol (spell_module, "aspell_speller_add_to_personal",
 257                           (void *) &mc_aspell_speller_add_to_personal))
 258         goto error_ret;
 259
 260     if (!g_module_symbol (spell_module, "aspell_speller_save_all_word_lists",
 261                           (void *) &mc_aspell_speller_save_all_word_lists))
 262         goto error_ret;
 263
 264     ret = TRUE;
 265
 266   error_ret:
 267     if (!ret)
 268     {
 269         g_module_close (spell_module);
 270         spell_module = NULL;
 271     }
 272     return ret;
 273 }
 274
 275 /* --------------------------------------------------------------------------------------------- */
 276 /*** public functions ****************************************************************************/
 277 /* --------------------------------------------------------------------------------------------- */
 278 /**
 279  * Initialization of Aspell support.
 280  */
 281
 282 void
 283 aspell_init (void)
 284 {
 285     AspellCanHaveError *error = NULL;
 286
 287     if (global_speller != NULL)
 288         return;
 289
 290     global_speller = g_try_malloc (sizeof (spell_t));
 291     if (global_speller == NULL)
 292         return;
 293
 294     if (!spell_available ())
 295     {
 296         g_free (global_speller);
 297         global_speller = NULL;
 298         return;
 299     }
 300
 301     global_speller->config = mc_new_aspell_config ();
 302     global_speller->speller = NULL;
 303
 304     error = mc_new_aspell_speller (global_speller->config);
 305
 306     if (mc_aspell_error_number (error) == 0)
 307         global_speller->speller = mc_to_aspell_speller (error);
 308     else
 309     {
 310         edit_error_dialog (_("Error"), mc_aspell_error_message (error));
 311         mc_delete_aspell_can_have_error (error);
 312         aspell_clean ();
 313     }
 314 }
 315
 316 /* --------------------------------------------------------------------------------------------- */
 317 /**
 318  * Deinitialization of Aspell support.
 319  */
 320
 321 void
 322 aspell_clean (void)
 323 {
 324     if (global_speller == NULL)
 325         return;
 326
 327     if (global_speller->speller != NULL)
 328         mc_delete_aspell_speller (global_speller->speller);
 329
 330     if (global_speller->config != NULL)
 331         mc_delete_aspell_config (global_speller->config);
 332
 333     g_free (global_speller);
 334     global_speller = NULL;
 335
 336     g_module_close (spell_module);
 337     spell_module = NULL;
 338 }
 339
 340 /* --------------------------------------------------------------------------------------------- */
 341 /**
 342  * Get array of available languages.
 343  *
 344  * @param lang_list Array of languages. Must be cleared before use
 345  * @returns language list length
 346  */
 347
 348 unsigned int
 349 aspell_get_lang_list (GArray * lang_list)
 350 {
 351     AspellDictInfoList *dlist;
 352     AspellDictInfoEnumeration *elem;
 353     const AspellDictInfo *entry;
 354     unsigned int i = 0;
 355
 356     if (spell_module == NULL)
 357         return 0;
 358
 359     /* the returned pointer should _not_ need to be deleted */
 360     dlist = mc_get_aspell_dict_info_list (global_speller->config);
 361     elem = mc_aspell_dict_info_list_elements (dlist);
 362
 363     while ((entry = mc_aspell_dict_info_enumeration_next (elem)) != NULL)
 364     {
 365         if (entry->name != NULL)
 366         {
 367             char *tmp;
 368
 369             tmp = g_strdup (entry->name);
 370             g_array_append_val (lang_list, tmp);
 371             i++;
 372         }
 373     }
 374
 375     mc_delete_aspell_dict_info_enumeration (elem);
 376
 377     return i;
 378 }
 379
 380 /* --------------------------------------------------------------------------------------------- */
 381 /**
 382  * Clear the array of languages.
 383  *
 384  * @param array Array of languages
 385  */
 386
 387 void
 388 aspell_array_clean (GArray * array)
 389 {
 390     if (array != NULL)
 391     {
 392         guint i = 0;
 393
 394         for (i = 0; i < array->len; ++i)
 395         {
 396             char *tmp;
 397
 398             tmp = g_array_index (array, char *, i);
 399             g_free (tmp);
 400         }
 401         g_array_free (array, TRUE);
 402     }
 403 }
 404
 405 /* --------------------------------------------------------------------------------------------- */
 406 /**
 407  * Get the current language name.
 408  *
 409  * @returns Language name
 410  */
 411
 412 const char *
 413 aspell_get_lang (void)
 414 {
 415     const char *code;
 416
 417     code = mc_aspell_config_retrieve (global_speller->config, "lang");
 418     return spell_decode_lang (code);
 419 }
 420
 421 /* --------------------------------------------------------------------------------------------- */
 422 /**
 423  * Set the language.
 424  *
 425  * @param lang Language name
 426  * @returns FALSE or error
 427  */
 428
 429 gboolean
 430 aspell_set_lang (const char *lang)
 431 {
 432     if (lang != NULL)
 433     {
 434         int res;
 435         AspellCanHaveError *error;
 436         const char *spell_codeset;
 437
 438 #ifdef HAVE_CHARSET
 439         if (mc_global.source_codepage > 0)
 440             spell_codeset = get_codepage_id (mc_global.source_codepage);
 441         else
 442 #endif
 443             spell_codeset = str_detect_termencoding ();
 444
 445         res = mc_aspell_config_replace (global_speller->config, "lang", lang);
 446         res = mc_aspell_config_replace (global_speller->config, "encoding", spell_codeset);
 447
 448         /* the returned pointer should _not_ need to be deleted */
 449         if (global_speller->speller != NULL)
 450             mc_delete_aspell_speller (global_speller->speller);
 451
 452         global_speller->speller = NULL;
 453
 454         error = mc_new_aspell_speller (global_speller->config);
 455         if (mc_aspell_error (error) != 0)
 456         {
 457             mc_delete_aspell_can_have_error (error);
 458             return FALSE;
 459         }
 460
 461         global_speller->speller = mc_to_aspell_speller (error);
 462     }
 463     return TRUE;
 464 }
 465
 466 /* --------------------------------------------------------------------------------------------- */
 467 /**
 468  * Check word.
 469  *
 470  * @param word Word for spell check
 471  * @param word_size Word size (in bytes)
 472  * @returns FALSE if word is not in the dictionary
 473  */
 474
 475 gboolean
 476 aspell_check (const char *word, const int word_size)
 477 {
 478     int res = 0;
 479
 480     if (word != NULL && global_speller != NULL && global_speller->speller != NULL)
 481         res = mc_aspell_speller_check (global_speller->speller, word, word_size);
 482
 483     return (res == 1);
 484 }
 485
 486 /* --------------------------------------------------------------------------------------------- */
 487 /**
 488  * Examine dictionaries and suggest possible words that may repalce the incorrect word.
 489  *
 490  * @param suggest array of words to iterate through
 491  * @param word Word for spell check
 492  * @param word_size Word size (in bytes)
 493  * @returns count of suggests for the word
 494  */
 495
 496 unsigned int
 497 aspell_suggest (GArray * suggest, const char *word, const int word_size)
 498 {
 499     unsigned int size = 0;
 500
 501     if (word != NULL && global_speller != NULL && global_speller->speller != NULL)
 502     {
 503         const AspellWordList *wordlist;
 504
 505         wordlist = mc_aspell_speller_suggest (global_speller->speller, word, word_size);
 506         if (wordlist != NULL)
 507         {
 508             AspellStringEnumeration *elements = NULL;
 509             unsigned int i;
 510
 511             elements = mc_aspell_word_list_elements (wordlist);
 512             size = mc_aspell_word_list_size (wordlist);
 513
 514             for (i = 0; i < size; i++)
 515             {
 516                 const char *cur_sugg_word;
 517
 518                 cur_sugg_word = g_strdup (mc_aspell_string_enumeration_next (elements));
 519                 if (cur_sugg_word != NULL)
 520                     g_array_append_val (suggest, cur_sugg_word);
 521             }
 522
 523             mc_delete_aspell_string_enumeration (elements);
 524         }
 525     }
 526
 527     return size;
 528 }
 529
 530 /* --------------------------------------------------------------------------------------------- */
 531 /*
 532  * Add word to personal dictionary.
 533  *
 534  * @param word Word for spell check
 535  * @param word_size  Word size (in bytes)
 536  * @returns FALSE or error
 537  */
 538 gboolean
 539 aspell_add_to_dict (const char *word, int word_size)
 540 {
 541     mc_aspell_speller_add_to_personal (global_speller->speller, word, word_size);
 542
 543     if (mc_aspell_speller_error (global_speller->speller) != 0)
 544     {
 545         edit_error_dialog (_("Error"), mc_aspell_speller_error_message (global_speller->speller));
 546         return FALSE;
 547     }
 548
 549     mc_aspell_speller_save_all_word_lists (global_speller->speller);
 550
 551     if (mc_aspell_speller_error (global_speller->speller) != 0)
 552     {
 553         edit_error_dialog (_("Error"), mc_aspell_speller_error_message (global_speller->speller));
 554         return FALSE;
 555     }
 556
 557     return TRUE;
 558 }
 559
 560 /* --------------------------------------------------------------------------------------------- */