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