src/support/Messages.cpp

   1 /* \file Messages.cpp
   2  * This file is part of LyX, the document processor.
   3  * Licence details can be found in the file COPYING.
   4  *
   5  * \author Lars Gullik Bjønnes
   6  *
   7  * Full author contact details are available in file CREDITS.
   8  */
   9
  10 #include <config.h>
  11
  12 #include "support/Messages.h"
  13
  14 #include "support/debug.h"
  15 #include "support/docstring.h"
  16 #include "support/environment.h"
  17 #include "support/Package.h"
  18 #include "support/unicode.h"
  19
  20 #include <boost/assert.hpp>
  21
  22 #include <cerrno>
  23
  24 using std::map;
  25 using std::string;
  26
  27 namespace {
  28
  29 using lyx::docstring;
  30 using lyx::from_ascii;
  31
  32 void cleanTranslation(docstring & trans)
  33 {
  34         /*
  35           Some english words have different translations, depending on
  36           context. In these cases the original string is augmented by
  37           context information (e.g. "To:[[as in 'From page x to page
  38           y']]" and "To:[[as in 'From format x to format y']]". This
  39           means that we need to filter out everything in double square
  40           brackets at the end of the string, otherwise the user sees
  41           bogus messages. If we are unable to honour the request we
  42           just return what we got in.
  43         */
  44         size_t const pos1 = trans.find(from_ascii("[["));
  45         if (pos1 != docstring::npos) {
  46                 size_t const pos2 = trans.find(from_ascii("]]"), pos1);
  47                 if (pos2 != docstring::npos)
  48                         trans.erase(pos1, pos2 - pos1 + 2);
  49         }
  50 }
  51
  52 }
  53
  54
  55 #ifdef ENABLE_NLS
  56
  57 #  ifdef HAVE_LOCALE_H
  58 #    include <locale.h>
  59 #  endif
  60
  61 #  if HAVE_GETTEXT
  62 #    include <libintl.h>      // use the header already in the system *EK*
  63 #  else
  64 #    include "../../intl/libintl.h"
  65 #  endif
  66
  67 namespace lyx {
  68
  69 using support::package;
  70 using support::getEnv;
  71 using support::setEnv;
  72
  73
  74 // This version use the traditional gettext.
  75 Messages::Messages(string const & l)
  76         : lang_(l), warned_(false)
  77 {
  78         // strip off any encoding suffix, i.e., assume 8-bit po files
  79         size_t i = lang_.find(".");
  80         lang_ = lang_.substr(0, i);
  81         LYXERR(Debug::DEBUG, "language(" << lang_ << ")");
  82 }
  83
  84
  85 void Messages::init()
  86 {
  87         errno = 0;
  88         string const locale_dir = package().locale_dir().toFilesystemEncoding();
  89         char const * c = bindtextdomain(PACKAGE, locale_dir.c_str());
  90         int e = errno;
  91         if (e) {
  92                 LYXERR(Debug::DEBUG, "Error code: " << errno << '\n'
  93                         << "Directory : " << package().locale_dir().absFilename() << '\n'
  94                         << "Rtn value : " << c);
  95         }
  96
  97         if (!bind_textdomain_codeset(PACKAGE, ucs4_codeset)) {
  98                 LYXERR(Debug::DEBUG, "Error code: " << errno << '\n'
  99                         << "Codeset   : " << ucs4_codeset);
 100         }
 101
 102         textdomain(PACKAGE);
 103 }
 104
 105
 106 docstring const Messages::get(string const & m) const
 107 {
 108         if (m.empty())
 109                 return docstring();
 110
 111         // Look for the translated string in the cache.
 112         TranslationCache::iterator it = cache_.find(m);
 113         if (it != cache_.end())
 114                 return it->second;
 115
 116         // The string was not found, use gettext to generate it
 117
 118         string const oldLANGUAGE = getEnv("LANGUAGE");
 119         string const oldLC_ALL = getEnv("LC_ALL");
 120         if (!lang_.empty()) {
 121                 // This GNU extension overrides any language locale
 122                 // wrt gettext.
 123                 setEnv("LANGUAGE", lang_);
 124                 // However, setting LANGUAGE does nothing when the
 125                 // locale is "C". Therefore we set the locale to
 126                 // something that is believed to exist on most
 127                 // systems. The idea is that one should be able to
 128                 // load German documents even without having de_DE
 129                 // installed.
 130                 setEnv("LC_ALL", "en_US");
 131 #ifdef HAVE_LC_MESSAGES
 132                 setlocale(LC_MESSAGES, "");
 133 #endif
 134         }
 135
 136         char const * m_c = m.c_str();
 137         char const * trans_c = gettext(m_c);
 138         docstring trans;
 139         if (!trans_c)
 140                 LYXERR0("Undefined result from gettext");
 141         else if (trans_c == m_c) {
 142                 LYXERR(Debug::DEBUG, "Same as entered returned");
 143                 trans = from_ascii(m);
 144         } else {
 145                 LYXERR(Debug::DEBUG, "We got a translation");
 146                 // m is actually not a char const * but ucs4 data
 147                 trans = reinterpret_cast<char_type const *>(trans_c);
 148         }
 149
 150         cleanTranslation(trans);
 151
 152         // Reset environment variables as they were.
 153         if (!lang_.empty()) {
 154                 // Reset everything as it was.
 155                 setEnv("LANGUAGE", oldLANGUAGE);
 156                 setEnv("LC_ALL", oldLC_ALL);
 157 #ifdef HAVE_LC_MESSAGES
 158                 setlocale(LC_MESSAGES, "");
 159 #endif
 160         }
 161
 162         std::pair<TranslationCache::iterator, bool> result =
 163                 cache_.insert(std::make_pair(m, trans));
 164
 165         BOOST_ASSERT(result.second);
 166
 167         return result.first->second;
 168 }
 169
 170 } // namespace lyx
 171
 172 #else // ENABLE_NLS
 173 // This is the dummy variant.
 174
 175 namespace lyx {
 176
 177 Messages::Messages(string const & l) {}
 178
 179 void Messages::init()
 180 {
 181 }
 182
 183
 184 docstring const Messages::get(string const & m) const
 185 {
 186         docstring trans = from_ascii(m);
 187         cleanTranslation(trans);
 188         return trans;
 189 }
 190
 191 } // namespace lyx
 192
 193 #endif
 194
 195 #if 0
 196
 197 -#include <locale>
 198
 199 namespace lyx {
 200
 201 // This version of the Pimpl utilizes the message capability of
 202 // libstdc++ that is distributed with GNU G++.
 203 class Messages::Pimpl {
 204 public:
 205         typedef std::messages<char>::catalog catalog;
 206
 207         Pimpl(string const & l)
 208                 : lang_(l),
 209                   loc_gl(lang_.c_str()),
 210                   mssg_gl(std::use_facet<std::messages<char> >(loc_gl))
 211         {
 212                 //LYXERR("Messages: language(" << l << ") in dir(" << dir << ")");
 213
 214                 string const locale_dir = package().locale_dir().toFilesystemEncoding();
 215                 cat_gl = mssg_gl.open(PACKAGE, loc_gl, locale_dir.c_str());
 216
 217         }
 218
 219         ~Pimpl()
 220         {
 221                 mssg_gl.close(cat_gl);
 222         }
 223
 224         docstring const get(string const & msg) const
 225         {
 226                 return mssg_gl.get(cat_gl, 0, 0, msg);
 227         }
 228 private:
 229         ///
 230         string lang_;
 231         ///
 232         std::locale loc_gl;
 233         ///
 234         std::messages<char> const & mssg_gl;
 235         ///
 236         catalog cat_gl;
 237 };
 238
 239 } // namespace lyx
 240
 241 #endif