src/Thesaurus.cpp

   1 /**
   2  * \file Thesaurus.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author John Levon
   7  * \author Jürgen Spitzmüller
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include "Thesaurus.h"
  15
  16 #include "support/debug.h"
  17 #include "support/gettext.h"
  18 #include "LyXRC.h"
  19
  20 #include "support/FileNameList.h"
  21 #include "support/filetools.h"
  22 #include "support/lstrings.h"
  23 #include "support/os.h"
  24 #include "support/unicode.h"
  25
  26 #include "frontends/alert.h"
  27
  28 #ifdef HAVE_LIBMYTHES
  29 #include MYTHES_H_LOCATION
  30 #else
  31 #ifdef HAVE_LIBAIKSAURUS
  32 #include AIKSAURUS_H_LOCATION
  33 #endif // HAVE_LIBAIKSAURUS
  34 #endif // !HAVE_LIBMYTHES
  35
  36 #include <algorithm>
  37 #include <cstring>
  38
  39 using namespace std;
  40 using namespace lyx::support;
  41 using namespace lyx::support::os;
  42
  43 namespace lyx {
  44
  45 #ifdef HAVE_LIBAIKSAURUS
  46
  47 struct Thesaurus::Private
  48 {
  49         Private(): thes_(new Aiksaurus) {}
  50         Aiksaurus * thes_;
  51 };
  52
  53 Thesaurus::Meanings Thesaurus::lookup(docstring const & t, docstring const &)
  54 {
  55         Meanings meanings;
  56
  57         // aiksaurus is for english text only, therefore it does not work
  58         // with non-ascii strings.
  59         // The interface of the Thesaurus class uses docstring because a
  60         // non-english thesaurus is possible in theory.
  61         if (!support::isAscii(t))
  62                 // to_ascii() would assert
  63                 return meanings;
  64
  65         string const text = to_ascii(t);
  66
  67         docstring error = from_ascii(d->thes_->error());
  68         if (!error.empty()) {
  69                 static bool sent_error = false;
  70                 if (!sent_error) {
  71                         frontend::Alert::error(_("Thesaurus failure"),
  72                                      bformat(_("Aiksaurus returned the following error:\n\n%1$s."),
  73                                              error));
  74                         sent_error = true;
  75                 }
  76                 return meanings;
  77         }
  78         if (!d->thes_->find(text.c_str()))
  79                 return meanings;
  80
  81         // weird api, but ...
  82
  83         int prev_meaning = -1;
  84         int cur_meaning;
  85         docstring meaning;
  86
  87         // correct, returns "" at the end
  88         string ret = d->thes_->next(cur_meaning);
  89
  90         while (!ret.empty()) {
  91                 if (cur_meaning != prev_meaning) {
  92                         meaning = from_ascii(ret);
  93                         ret = d->thes_->next(cur_meaning);
  94                         prev_meaning = cur_meaning;
  95                 } else {
  96                         if (ret != text)
  97                                 meanings[meaning].push_back(from_ascii(ret));
  98                 }
  99
 100                 ret = d->thes_->next(cur_meaning);
 101         }
 102
 103         for (Meanings::iterator it = meanings.begin();
 104              it != meanings.end(); ++it)
 105                 sort(it->second.begin(), it->second.end());
 106
 107         return meanings;
 108 }
 109
 110
 111 bool Thesaurus::thesaurusAvailable(docstring const & lang) const
 112 {
 113         // we support English only
 114         return prefixIs(lang, from_ascii("en_"));
 115 }
 116
 117 #else // HAVE_LIBAIKSAURUS
 118 #ifdef HAVE_LIBMYTHES
 119
 120 namespace {
 121
 122 string const to_iconv_encoding(docstring const & s, string const & encoding)
 123 {
 124         std::vector<char> const encoded =
 125                 ucs4_to_eightbit(s.data(), s.length(), encoding);
 126         return string(encoded.begin(), encoded.end());
 127 }
 128
 129
 130 docstring const from_iconv_encoding(string const & s, string const & encoding)
 131 {
 132         std::vector<char_type> const ucs4 =
 133                 eightbit_to_ucs4(s.data(), s.length(), encoding);
 134         return docstring(ucs4.begin(), ucs4.end());
 135 }
 136
 137 } // namespace anon
 138
 139
 140 struct Thesaurus::Private
 141 {
 142         ~Private()
 143         {
 144                 for (Thesauri::iterator it = thes_.begin();
 145                      it != thes_.end(); ++it) {
 146                         delete it->second;
 147                 }
 148         }
 149
 150         /// add a thesaurus to the list
 151         bool addThesaurus(docstring const & lang);
 152
 153         typedef std::map<docstring, MyThes *> Thesauri;
 154         /// the thesauri
 155         Thesauri thes_;
 156 };
 157
 158 bool Thesaurus::Private::addThesaurus(docstring const & lang)
 159 {
 160         string const thes_path = external_path(lyxrc.thesaurusdir_path);
 161         LYXERR(Debug::FILES, "thesaurus path: " << thes_path);
 162         if (thes_path.empty())
 163                 return false;
 164
 165         if (thesaurusAvailable(lang))
 166                 return true;
 167
 168         FileNameList const idx_files = FileName(thes_path).dirList("idx");
 169         FileNameList const data_files = FileName(thes_path).dirList("dat");
 170         string idx;
 171         string data;
 172
 173         for (FileNameList::const_iterator it = idx_files.begin();
 174              it != idx_files.end(); ++it) {
 175                 LYXERR(Debug::FILES, "found thesaurus idx file: " << it->onlyFileName());
 176                 if (contains(it->onlyFileName(), to_ascii(lang))) {
 177                         idx = it->absFilename();
 178                         LYXERR(Debug::FILES, "selected thesaurus idx file: " << idx);
 179                         break;
 180                         }
 181                 }
 182
 183         for (support::FileNameList::const_iterator it = data_files.begin();
 184              it != data_files.end(); ++it) {
 185                 LYXERR(Debug::FILES, "found thesaurus data file: " << it->onlyFileName());
 186                 if (contains(it->onlyFileName(), to_ascii(lang))) {
 187                         data = it->absFilename();
 188                         LYXERR(Debug::FILES, "selected thesaurus data file: " << data);
 189                         break;
 190                         }
 191                 }
 192
 193         if (idx.empty() || data.empty())
 194                 return false;
 195
 196         char const * af = idx.c_str();
 197         char const * df = data.c_str();
 198         thes_[lang] = new MyThes(af, df);
 199         return true;
 200 }
 201
 202
 203 bool Thesaurus::thesaurusAvailable(docstring const & lang) const
 204 {
 205         for (Thesauri::const_iterator it = d->thes_.begin();
 206              it != d->thes_.end(); ++it) {
 207                 if (it->first == lang)
 208                         if (it->second)
 209                                 return true;
 210         }
 211
 212         return false;
 213 }
 214
 215
 216 Thesaurus::Meanings Thesaurus::lookup(docstring const & t, docstring const & lang)
 217 {
 218         Meanings meanings;
 219         MyThes * mythes = 0;
 220
 221         if (!d->addThesaurus(lang))
 222                 return meanings;
 223
 224         for (Thesauri::const_iterator it = d->thes_.begin();
 225              it != d->thes_.end(); ++it) {
 226                 if (it->first == lang) {
 227                         mythes = it->second;
 228                         break;
 229                 }
 230         }
 231
 232         if (!mythes)
 233                 return meanings;
 234
 235         string const encoding = mythes->get_th_encoding();
 236
 237         mentry * pmean;
 238         string const text = to_iconv_encoding(support::lowercase(t), encoding);
 239         int len = strlen(text.c_str());
 240         int count = mythes->Lookup(text.c_str(), len, &pmean);
 241         if (!count)
 242                 return meanings;
 243
 244         // don't change value of pmean or count
 245         // they are needed for the CleanUpAfterLookup routine
 246         mentry * pm = pmean;
 247         docstring meaning;
 248         docstring ret;
 249         for (int i = 0; i < count; i++) {
 250                 meaning = from_iconv_encoding(string(pm->defn), encoding);
 251                 // remove silly item
 252                 if (support::prefixIs(meaning, '-'))
 253                         meaning = support::ltrim(meaning, "- ");
 254                 for (int j = 0; j < pm->count; j++) {
 255                         ret = from_iconv_encoding(string(pm->psyns[j]), encoding);
 256                 }
 257         meanings[meaning].push_back(ret);
 258         pm++;
 259         }
 260         // now clean up all allocated memory
 261         mythes->CleanUpAfterLookup(&pmean, count);
 262
 263         for (Meanings::iterator it = meanings.begin();
 264              it != meanings.end(); ++it)
 265                 sort(it->second.begin(), it->second.end());
 266
 267         return meanings;
 268 }
 269
 270 #else
 271
 272 struct Thesaurus::Private
 273 {
 274 };
 275
 276
 277 Thesaurus::Meanings Thesaurus::lookup(docstring const &, docstring const &)
 278 {
 279         return Meanings();
 280 }
 281
 282
 283 bool Thesaurus::thesaurusAvailable(docstring const &) const
 284 {
 285         return false;
 286 }
 287
 288 #endif // HAVE_LIBMYTHES
 289 #endif // HAVE_LIBAIKSAURUS
 290
 291 Thesaurus::Thesaurus() : d(new Thesaurus::Private)
 292 {
 293 }
 294
 295
 296 Thesaurus::~Thesaurus()
 297 {
 298         delete d;
 299 }
 300
 301 // Global instance
 302 Thesaurus thesaurus;
 303
 304
 305 } // namespace lyx