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