src/HunspellChecker.cpp

   1 /**
   2  * \file HunspellChecker.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Abdelrazak Younes
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "HunspellChecker.h"
  14
  15 #include "LyXRC.h"
  16 #include "WordLangTuple.h"
  17
  18 #include "frontends/alert.h"
  19
  20 #include "support/debug.h"
  21 #include "support/docstring_list.h"
  22 #include "support/filetools.h"
  23 #include "support/FileName.h"
  24 #include "support/gettext.h"
  25 #include "support/lassert.h"
  26 #include "support/lstrings.h"
  27 #include "support/os.h"
  28
  29 #include <hunspell/hunspell.hxx>
  30
  31 #include <map>
  32 #include <string>
  33 #include <vector>
  34
  35 using namespace std;
  36 using namespace lyx::support;
  37 using namespace lyx::support::os;
  38
  39 namespace lyx {
  40
  41 namespace {
  42
  43 typedef map<std::string, Hunspell *> Spellers;
  44 typedef vector<WordLangTuple> IgnoreList;
  45
  46 } // anon namespace
  47
  48 struct HunspellChecker::Private
  49 {
  50         Private() {}
  51
  52         ~Private();
  53
  54         bool haveDictionary(string const & lang, string & hpath);
  55         Hunspell * addSpeller(string const & lang);
  56         Hunspell * speller(string const & lang);
  57         /// ignored words
  58         bool isIgnored(WordLangTuple const & wl) const;
  59
  60         /// the spellers
  61         Spellers spellers_;
  62         ///
  63         IgnoreList ignored_;
  64 };
  65
  66
  67 HunspellChecker::Private::~Private()
  68 {
  69         Spellers::iterator it = spellers_.begin();
  70         Spellers::iterator end = spellers_.end();
  71
  72         for (; it != end; ++it) {
  73                 delete it->second;
  74         }
  75 }
  76
  77
  78 namespace {
  79 bool haveLanguageFiles(string const & hpath)
  80 {
  81         FileName const affix(hpath + ".aff");
  82         FileName const dict(hpath + ".dic");
  83         if (!affix.isReadableFile()) {
  84                 // FIXME: We should indicate somehow that this language is not
  85                 // supported.
  86                 LYXERR(Debug::FILES, "Hunspell affix file " << affix << " does not exist");
  87                 return false;
  88         }
  89         if (!dict.isReadableFile()) {
  90                 LYXERR(Debug::FILES, "Hunspell dictionary file " << dict << " does not exist");
  91                 return false;
  92         }
  93         return true;
  94 }
  95 }
  96
  97
  98 bool HunspellChecker::Private::haveDictionary(string const & lang, string & hunspell_path)
  99 {
 100         LYXERR(Debug::FILES, "hunspell path: " << external_path(hunspell_path));
 101         if (hunspell_path.empty()) {
 102                 // FIXME We'd like to issue a better error message here, but there seems
 103                 // to be a problem about thread safety, or something of the sort. If
 104                 // we issue the message using frontend::Alert, then the code comes
 105                 // back through here while the box is waiting, and causes some kind
 106                 // of crash.
 107                 static bool warned = false;
 108                 if (!warned) {
 109                         warned = true;
 110                         LYXERR0("Hunspell path not set.");
 111                         //frontend::Alert::error(_("Hunspell Path Not Found"),
 112                         //              _("You must set the Hunspell dictionary path in Tools>Preferences>Paths."));
 113                 }
 114                 return false;
 115         }
 116
 117         hunspell_path = external_path(addName(hunspell_path, lang));
 118         if (!haveLanguageFiles(hunspell_path)) {
 119                 // try with '_' replaced by '-'
 120                 hunspell_path = subst(hunspell_path, '_', '-');
 121                 if (!haveLanguageFiles(hunspell_path)) {
 122                         // FIXME: We should indicate somehow that this language is not
 123                         // supported, probably by popping a warning. But we'll need to
 124                         // remember which warnings we've issued.
 125                         return false;
 126                 }
 127         }
 128         return true;
 129 }
 130
 131
 132 Hunspell * HunspellChecker::Private::addSpeller(string const & lang)
 133 {
 134         string hunspell_path = lyxrc.hunspelldir_path;
 135
 136         if (!haveDictionary(lang, hunspell_path))
 137                 return 0;
 138
 139         FileName const affix(hunspell_path + ".aff");
 140         FileName const dict(hunspell_path + ".dic");
 141         Hunspell * h = new Hunspell(affix.absFilename().c_str(), dict.absFilename().c_str());
 142         spellers_[lang] = h;
 143         return h;
 144 }
 145
 146
 147 Hunspell * HunspellChecker::Private::speller(string const & lang)
 148 {
 149         Spellers::iterator it = spellers_.find(lang);
 150         if (it != spellers_.end())
 151                 return it->second;
 152
 153         return addSpeller(lang);
 154 }
 155
 156
 157 bool HunspellChecker::Private::isIgnored(WordLangTuple const & wl) const
 158 {
 159         IgnoreList::const_iterator it = ignored_.begin();
 160         for (; it != ignored_.end(); ++it) {
 161                 if ((*it).lang()->code() != wl.lang()->code())
 162                         continue;
 163                 if ((*it).word() == wl.word())
 164                         return true;
 165         }
 166         return false;
 167 }
 168
 169
 170 HunspellChecker::HunspellChecker(): d(new Private)
 171 {
 172 }
 173
 174
 175 HunspellChecker::~HunspellChecker()
 176 {
 177         delete d;
 178 }
 179
 180
 181 SpellChecker::Result HunspellChecker::check(WordLangTuple const & wl)
 182 {
 183         if (d->isIgnored(wl))
 184                 return OK;
 185
 186         string const word_to_check = to_utf8(wl.word());
 187         Hunspell * h = d->speller(wl.lang()->code());
 188         if (!h)
 189                 return OK;
 190         int info;
 191         if (h->spell(word_to_check.c_str(), &info))
 192                 return OK;
 193
 194         if (info & SPELL_COMPOUND) {
 195                 // FIXME: What to do with that?
 196                 LYXERR(Debug::FILES, "Hunspell compound word found " << word_to_check);
 197         }
 198         if (info & SPELL_FORBIDDEN) {
 199                 // FIXME: What to do with that?
 200                 LYXERR(Debug::FILES, "Hunspell explicit forbidden word found " << word_to_check);
 201         }
 202
 203         return UNKNOWN_WORD;
 204 }
 205
 206
 207 void HunspellChecker::insert(WordLangTuple const & wl)
 208 {
 209         string const word_to_check = to_utf8(wl.word());
 210         Hunspell * h = d->speller(wl.lang()->code());
 211         if (!h)
 212                 return;
 213         h->add(word_to_check.c_str());
 214 }
 215
 216
 217 void HunspellChecker::accept(WordLangTuple const & wl)
 218 {
 219         d->ignored_.push_back(wl);
 220 }
 221
 222
 223 void HunspellChecker::suggest(WordLangTuple const & wl,
 224         docstring_list & suggestions)
 225 {
 226         suggestions.clear();
 227         string const word_to_check = to_utf8(wl.word());
 228         Hunspell * h = d->speller(wl.lang()->code());
 229         if (!h)
 230                 return;
 231         char ** suggestion_list;
 232         int const suggestion_number = h->suggest(&suggestion_list, word_to_check.c_str());
 233         if (suggestion_number <= 0)
 234                 return;
 235         for (int i = 0; i != suggestion_number; ++i)
 236                 suggestions.push_back(from_utf8(suggestion_list[i]));
 237         h->free_list(&suggestion_list, suggestion_number);
 238 }
 239
 240
 241 bool HunspellChecker::hasDictionary(Language const * lang) const
 242 {
 243         if (!lang)
 244                 return false;
 245         string hunspell_path = lyxrc.hunspelldir_path;
 246         return (d->haveDictionary(lang->code(), hunspell_path));
 247 }
 248
 249
 250 docstring const HunspellChecker::error()
 251 {
 252         return docstring();
 253 }
 254
 255
 256 } // namespace lyx