src/Language.cpp

   1 /**
   2  * \file Language.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Lars Gullik Bjønnes
   7  * \author Jean-Marc Lasgouttes
   8  * \author Jürgen Spitzmüller
   9  * \author Dekel Tsur
  10  *
  11  * Full author contact details are available in file CREDITS.
  12  */
  13
  14 #include <config.h>
  15
  16 #include "Language.h"
  17
  18 #include "Encoding.h"
  19 #include "Lexer.h"
  20 #include "LyXRC.h"
  21
  22 #include "support/debug.h"
  23 #include "support/FileName.h"
  24 #include "support/lstrings.h"
  25
  26 using namespace std;
  27 using namespace lyx::support;
  28
  29
  30 namespace lyx {
  31
  32 Languages languages;
  33 Language ignore_lang;
  34 Language latex_lang;
  35 Language const * default_language;
  36 Language const * ignore_language = &ignore_lang;
  37 Language const * latex_language = &latex_lang;
  38 Language const * reset_language = 0;
  39
  40
  41 bool Language::readLanguage(Lexer & lex)
  42 {
  43         enum LanguageTags {
  44                 LA_BABELNAME = 1,
  45                 LA_ENCODING,
  46                 LA_END,
  47                 LA_GUINAME,
  48                 LA_INTERNAL_ENC,
  49                 LA_LANG_CODE,
  50                 LA_LANG_VARIETY,
  51                 LA_POSTBABELPREAMBLE,
  52                 LA_PREBABELPREAMBLE,
  53                 LA_RTL
  54         };
  55
  56         // Keep these sorted alphabetically!
  57         LexerKeyword languageTags[] = {
  58                 { "babelname",            LA_BABELNAME },
  59                 { "encoding",             LA_ENCODING },
  60                 { "end",                  LA_END },
  61                 { "guiname",              LA_GUINAME },
  62                 { "internalencoding",     LA_INTERNAL_ENC },
  63                 { "langcode",             LA_LANG_CODE },
  64                 { "langvariety",          LA_LANG_VARIETY },
  65                 { "postbabelpreamble",    LA_POSTBABELPREAMBLE },
  66                 { "prebabelpreamble",     LA_PREBABELPREAMBLE },
  67                 { "rtl",                  LA_RTL }
  68         };
  69
  70         bool error = false;
  71         bool finished = false;
  72         lex.pushTable(languageTags);
  73         // parse style section
  74         while (!finished && lex.isOK() && !error) {
  75                 int le = lex.lex();
  76                 // See comment in LyXRC.cpp.
  77                 switch (le) {
  78                 case Lexer::LEX_FEOF:
  79                         continue;
  80
  81                 case Lexer::LEX_UNDEF: // parse error
  82                         lex.printError("Unknown language tag `$$Token'");
  83                         error = true;
  84                         continue;
  85
  86                 default:
  87                         break;
  88                 }
  89                 switch (static_cast<LanguageTags>(le)) {
  90                 case LA_END: // end of structure
  91                         finished = true;
  92                         break;
  93                 case LA_BABELNAME:
  94                         lex >> babel_;
  95                         break;
  96                 case LA_ENCODING:
  97                         lex >> encodingStr_;
  98                         break;
  99                 case LA_GUINAME:
 100                         lex >> display_;
 101                         break;
 102                 case LA_INTERNAL_ENC:
 103                         lex >> internal_enc_;
 104                         break;
 105                 case LA_LANG_CODE:
 106                         lex >> code_;
 107                         break;
 108                 case LA_LANG_VARIETY:
 109                         lex >> variety_;
 110                         break;
 111                 case LA_POSTBABELPREAMBLE:
 112                         babel_postsettings_ =
 113                                 lex.getLongString("EndPostBabelPreamble");
 114                         break;
 115                 case LA_PREBABELPREAMBLE:
 116                         babel_presettings_ =
 117                                 lex.getLongString("EndPreBabelPreamble");
 118                         break;
 119                 case LA_RTL:
 120                         lex >> rightToLeft_;
 121                         break;
 122                 }
 123         }
 124         lex.popTable();
 125         return finished && !error;
 126 }
 127
 128
 129 bool Language::read(Lexer & lex)
 130 {
 131         encoding_ = 0;
 132         internal_enc_ = 0;
 133         rightToLeft_ = 0;
 134
 135         if (!lex.next()) {
 136                 lex.printError("No name given for language: `$$Token'.");
 137                 return false;
 138         }
 139
 140         lang_ = lex.getString();
 141         LYXERR(Debug::INFO, "Reading language " << lang_);
 142         if (!readLanguage(lex)) {
 143                 LYXERR0("Error parsing language `" << lang_ << '\'');
 144                 return false;
 145         }
 146
 147         encoding_ = encodings.fromLyXName(encodingStr_);
 148         if (!encoding_ && !encodingStr_.empty()) {
 149                 encoding_ = encodings.fromLyXName("iso8859-1");
 150                 LYXERR0("Unknown encoding " << encodingStr_);
 151         }
 152         return true;
 153 }
 154
 155 void Languages::read(FileName const & filename)
 156 {
 157         Lexer lex;
 158         lex.setFile(filename);
 159         lex.setContext("Languages::read");
 160         while (lex.isOK()) {
 161                 int le = lex.lex();
 162                 switch (le) {
 163                 case Lexer::LEX_FEOF:
 164                         continue;
 165
 166                 default:
 167                         break;
 168                 }
 169                 if (lex.getString() != "Language") {
 170                         lex.printError("Unknown Language tag `$$Token'");
 171                         continue;
 172                 }
 173                 Language l;
 174                 l.read(lex);
 175                 if (!lex)
 176                         break;
 177                 if (l.lang() == "latex")
 178                         latex_lang = l;
 179                 else if (l.lang() == "ignore")
 180                         ignore_lang = l;
 181                 else
 182                         languagelist[l.lang()] = l;
 183         }
 184
 185         default_language = getLanguage(lyxrc.default_language);
 186         if (!default_language) {
 187                 LYXERR0("Default language \"" << lyxrc.default_language
 188                        << "\" not found!");
 189                 default_language = getLanguage("english");
 190                 if (!default_language)
 191                         default_language = &(*languagelist.begin()).second;
 192                 LYXERR0("Using \"" << default_language->lang() << "\" instead!");
 193         }
 194 }
 195
 196
 197 Language const * Languages::getLanguage(string const & language) const
 198 {
 199         if (language == "reset")
 200                 return reset_language;
 201         if (language == "ignore")
 202                 return ignore_language;
 203         const_iterator it = languagelist.find(language);
 204         return it == languagelist.end() ? reset_language : &it->second;
 205 }
 206
 207
 208 } // namespace lyx