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 typedef std::map<docstring, MyThes *> Thesauri;
 138
 139 } // namespace anon
 140
 141
 142 struct Thesaurus::Private
 143 {
 144         ~Private(Thesaurus & parent): parent_(parent)
 145         {
 146                 for (Thesauri::iterator it = thes_.begin();
 147                      it != thes_.end(); ++it) {
 148                         delete it->second;
 149                 }
 150         }
 151
 152         ///
 153         Thesaurus & parent_;
 154
 155         /// add a thesaurus to the list
 156         bool addThesaurus(docstring const & lang);
 157
 158         /// the thesauri
 159         Thesauri thes_;
 160 };
 161
 162 bool Thesaurus::Private::addThesaurus(docstring const & lang)
 163 {
 164         string const thes_path = external_path(lyxrc.thesaurusdir_path);
 165         LYXERR(Debug::FILES, "thesaurus path: " << thes_path);
 166         if (thes_path.empty())
 167                 return false;
 168
 169         if (parent_.thesaurusAvailable(lang))
 170                 return true;
 171
 172         FileNameList const idx_files = FileName(thes_path).dirList("idx");
 173         FileNameList const data_files = FileName(thes_path).dirList("dat");
 174         string idx;
 175         string data;
 176
 177         for (FileNameList::const_iterator it = idx_files.begin();
 178              it != idx_files.end(); ++it) {
 179                 LYXERR(Debug::FILES, "found thesaurus idx file: " << it->onlyFileName());
 180                 if (contains(it->onlyFileName(), to_ascii(lang))) {
 181                         idx = it->absFilename();
 182                         LYXERR(Debug::FILES, "selected thesaurus idx file: " << idx);
 183                         break;
 184                         }
 185                 }
 186
 187         for (support::FileNameList::const_iterator it = data_files.begin();
 188              it != data_files.end(); ++it) {
 189                 LYXERR(Debug::FILES, "found thesaurus data file: " << it->onlyFileName());
 190                 if (contains(it->onlyFileName(), to_ascii(lang))) {
 191                         data = it->absFilename();
 192                         LYXERR(Debug::FILES, "selected thesaurus data file: " << data);
 193                         break;
 194                         }
 195                 }
 196
 197         if (idx.empty() || data.empty())
 198                 return false;
 199
 200         char const * af = idx.c_str();
 201         char const * df = data.c_str();
 202         thes_[lang] = new MyThes(af, df);
 203         return true;
 204 }
 205
 206
 207 bool Thesaurus::thesaurusAvailable(docstring const & lang) const
 208 {
 209         for (Thesauri::const_iterator it = d->thes_.begin();
 210              it != d->thes_.end(); ++it) {
 211                 if (it->first == lang)
 212                         if (it->second)
 213                                 return true;
 214         }
 215
 216         return false;
 217 }
 218
 219
 220 Thesaurus::Meanings Thesaurus::lookup(docstring const & t, docstring const & lang)
 221 {
 222         Meanings meanings;
 223         MyThes * mythes = 0;
 224
 225         if (!d->addThesaurus(lang))
 226                 return meanings;
 227
 228         for (Thesauri::const_iterator it = d->thes_.begin();
 229              it != d->thes_.end(); ++it) {
 230                 if (it->first == lang) {
 231                         mythes = it->second;
 232                         break;
 233                 }
 234         }
 235
 236         if (!mythes)
 237                 return meanings;
 238
 239         string const encoding = mythes->get_th_encoding();
 240
 241         mentry * pmean;
 242         string const text = to_iconv_encoding(support::lowercase(t), encoding);
 243         int len = strlen(text.c_str());
 244         int count = mythes->Lookup(text.c_str(), len, &pmean);
 245         if (!count)
 246                 return meanings;
 247
 248         // don't change value of pmean or count
 249         // they are needed for the CleanUpAfterLookup routine
 250         mentry * pm = pmean;
 251         docstring meaning;
 252         docstring ret;
 253         for (int i = 0; i < count; i++) {
 254                 meaning = from_iconv_encoding(string(pm->defn), encoding);
 255                 // remove silly item
 256                 if (support::prefixIs(meaning, '-'))
 257                         meaning = support::ltrim(meaning, "- ");
 258                 for (int j = 0; j < pm->count; j++) {
 259                         ret = from_iconv_encoding(string(pm->psyns[j]), encoding);
 260                 }
 261         meanings[meaning].push_back(ret);
 262         pm++;
 263         }
 264         // now clean up all allocated memory
 265         mythes->CleanUpAfterLookup(&pmean, count);
 266
 267         for (Meanings::iterator it = meanings.begin();
 268              it != meanings.end(); ++it)
 269                 sort(it->second.begin(), it->second.end());
 270
 271         return meanings;
 272 }
 273
 274 #else
 275
 276 struct Thesaurus::Private
 277 {
 278 };
 279
 280
 281 Thesaurus::Meanings Thesaurus::lookup(docstring const &, docstring const &)
 282 {
 283         return Meanings();
 284 }
 285
 286
 287 bool Thesaurus::thesaurusAvailable(docstring const &) const
 288 {
 289         return false;
 290 }
 291
 292 #endif // HAVE_LIBMYTHES
 293 #endif // HAVE_LIBAIKSAURUS
 294
 295 Thesaurus::Thesaurus() : d(new Thesaurus::Private)
 296 {
 297 }
 298
 299
 300 Thesaurus::~Thesaurus()
 301 {
 302         delete d;
 303 }
 304
 305 // Global instance
 306 Thesaurus thesaurus;
 307
 308
 309 } // namespace lyx