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