src/tinygettext/tinygettext.cpp

   1 //  $Id$
   2 //
   3 //  TinyGetText
   4 //  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
   5 //
   6 //  This program is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU General Public License
   8 //  as published by the Free Software Foundation; either version 2
   9 //  of the License, or (at your option) any later version.
  10 //
  11 //  This program is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 //  GNU General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU General Public License
  17 //  along with this program; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19
  20 #include <config.h>
  21
  22 #include <sys/types.h>
  23 #include <iconv.h>
  24 #include <fstream>
  25 #include <iostream>
  26 #include <ctype.h>
  27 #include <errno.h>
  28
  29 #include "tinygettext.hpp"
  30 #include "log.hpp"
  31 #include "physfs/physfs_stream.hpp"
  32 #include "log.hpp"
  33 #include "findlocale.hpp"
  34
  35 //#define TRANSLATION_DEBUG
  36
  37 namespace TinyGetText {
  38
  39 /** Convert \a which is in \a from_charset to \a to_charset and return it */
  40 std::string convert(const std::string& text,
  41                     const std::string& from_charset,
  42                     const std::string& to_charset)
  43 {
  44   if (from_charset == to_charset)
  45     return text;
  46
  47   iconv_t cd = iconv_open(to_charset.c_str(), from_charset.c_str());
  48
  49   size_t in_len = text.length();
  50   size_t out_len = text.length()*3; // FIXME: cross fingers that this is enough
  51
  52   char*  out_orig = new char[out_len];
  53   char*  in_orig  = new char[in_len+1];
  54   strcpy(in_orig, text.c_str());
  55
  56   char* out = out_orig;
  57   ICONV_CONST char* in  = in_orig;
  58   size_t out_len_temp = out_len; // iconv is counting down the bytes it has
  59                                  // written from this...
  60
  61   size_t retval = iconv(cd, &in, &in_len, &out, &out_len_temp);
  62   out_len -= out_len_temp; // see above
  63   if (retval == (size_t) -1)
  64     {
  65       log_warning << strerror(errno) << std::endl;
  66       log_warning << "Error: conversion from " << from_charset << " to " << to_charset << " went wrong: " << retval << std::endl;
  67       return "";
  68     }
  69   iconv_close(cd);
  70
  71   std::string ret(out_orig, out_len);
  72   delete[] out_orig;
  73   delete[] in_orig;
  74   return ret;
  75 }
  76
  77 bool has_suffix(const std::string& lhs, const std::string rhs)
  78 {
  79   if (lhs.length() < rhs.length())
  80     return false;
  81   else
  82     return lhs.compare(lhs.length() - rhs.length(), rhs.length(), rhs) == 0;
  83 }
  84
  85 bool has_prefix(const std::string& lhs, const std::string rhs)
  86 {
  87   if (lhs.length() < rhs.length())
  88     return false;
  89   else
  90     return lhs.compare(0, rhs.length(), rhs) == 0;
  91 }
  92
  93 int plural1(int )     { return 0; }
  94 int plural2_1(int n)  { return (n != 1); }
  95 int plural2_2(int n)  { return (n > 1); }
  96 int plural3_lv(int n) { return (n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2); }
  97 int plural3_ga(int n) { return n==1 ? 0 : n==2 ? 1 : 2; }
  98 int plural3_lt(int n) { return (n%10==1 && n%100!=11 ? 0 : n%10>=2 && (n%100<10 || n%100>=20) ? 1 : 2); }
  99 int plural3_1(int n)  { return (n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2); }
 100 int plural3_sk(int n) { return (n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2; }
 101 int plural3_pl(int n) { return (n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2); }
 102 int plural3_sl(int n) { return (n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3); }
 103
 104 /** Language Definitions */
 105 //*{
 106 LanguageDef lang_hu("hu", "Hungarian",         1, plural1); // "nplurals=1; plural=0;"
 107 LanguageDef lang_ja("ja", "Japanese",          1, plural1); // "nplurals=1; plural=0;"
 108 LanguageDef lang_ko("ko", "Korean",            1, plural1); // "nplurals=1; plural=0;"
 109 LanguageDef lang_tr("tr", "Turkish",           1, plural1); // "nplurals=1; plural=0;"
 110 LanguageDef lang_da("da", "Danish",            2, plural2_1); // "nplurals=2; plural=(n != 1);"
 111 LanguageDef lang_nl("nl", "Dutch",             2, plural2_1); // "nplurals=2; plural=(n != 1);"
 112 LanguageDef lang_en("en", "English",           2, plural2_1); // "nplurals=2; plural=(n != 1);"
 113 LanguageDef lang_fo("fo", "Faroese",           2, plural2_1); // "nplurals=2; plural=(n != 1);"
 114 LanguageDef lang_de("de", "German",            2, plural2_1); // "nplurals=2; plural=(n != 1);"
 115 LanguageDef lang_nb("nb", "Norwegian Bokmal",  2, plural2_1); // "nplurals=2; plural=(n != 1);"
 116 LanguageDef lang_no("no", "Norwegian",         2, plural2_1); // "nplurals=2; plural=(n != 1);"
 117 LanguageDef lang_nn("nn", "Norwegian Nynorsk", 2, plural2_1); // "nplurals=2; plural=(n != 1);"
 118 LanguageDef lang_sv("sv", "Swedish",           2, plural2_1); // "nplurals=2; plural=(n != 1);"
 119 LanguageDef lang_et("et", "Estonian",          2, plural2_1); // "nplurals=2; plural=(n != 1);"
 120 LanguageDef lang_fi("fi", "Finnish",           2, plural2_1); // "nplurals=2; plural=(n != 1);"
 121 LanguageDef lang_el("el", "Greek",             2, plural2_1); // "nplurals=2; plural=(n != 1);"
 122 LanguageDef lang_he("he", "Hebrew",            2, plural2_1); // "nplurals=2; plural=(n != 1);"
 123 LanguageDef lang_it("it", "Italian",           2, plural2_1); // "nplurals=2; plural=(n != 1);"
 124 LanguageDef lang_pt("pt", "Portuguese",        2, plural2_1); // "nplurals=2; plural=(n != 1);"
 125 LanguageDef lang_es("es", "Spanish",           2, plural2_1); // "nplurals=2; plural=(n != 1);"
 126 LanguageDef lang_eo("eo", "Esperanto",         2, plural2_1); // "nplurals=2; plural=(n != 1);"
 127 LanguageDef lang_fr("fr", "French",            2, plural2_2); // "nplurals=2; plural=(n > 1);"
 128 LanguageDef lang_pt_BR("pt_BR", "Brazilian",   2, plural2_2); // "nplurals=2; plural=(n > 1);"
 129 LanguageDef lang_lv("lv", "Latvian",           3, plural3_lv); // "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2);"
 130 LanguageDef lang_ga("ga", "Irish",             3, plural3_ga); // "nplurals=3; plural=n==1 ? 0 : n==2 ? 1 : 2;"
 131 LanguageDef lang_lt("lt", "Lithuanian",        3, plural3_lt); // "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && (n%100<10 || n%100>=20) ? 1 : 2);"
 132 LanguageDef lang_hr("hr", "Croatian",          3, plural3_1); // "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"
 133 LanguageDef lang_cs("cs", "Czech",             3, plural3_1); // "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"
 134 LanguageDef lang_ru("ru", "Russian",           3, plural3_1); // "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"
 135 LanguageDef lang_uk("uk", "Ukrainian",         3, plural3_1); // "nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);"
 136 LanguageDef lang_sk("sk", "Slovak",            3, plural3_sk); // "nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;"
 137 LanguageDef lang_pl("pl", "Polish",            3, plural3_pl); // "nplurals=3; plural=(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);
 138 LanguageDef lang_sl("sl", "Slovenian",         3, plural3_sl); // "nplurals=4; plural=(n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3);"
 139 //*}
 140
 141 LanguageDef&
 142 get_language_def(const std::string& name)
 143 {
 144   if (name == "hu") return lang_hu;
 145   else if (name == "ja") return lang_ja;
 146   else if (name == "ko") return lang_ko;
 147   else if (name == "tr") return lang_tr;
 148   else if (name == "da") return lang_da;
 149   else if (name == "nl") return lang_nl;
 150   else if (name == "en") return lang_en;
 151   else if (name == "fo") return lang_fo;
 152   else if (name == "de") return lang_de;
 153   else if (name == "nb") return lang_nb;
 154   else if (name == "no") return lang_no;
 155   else if (name == "nn") return lang_nn;
 156   else if (name == "sv") return lang_sv;
 157   else if (name == "et") return lang_et;
 158   else if (name == "fi") return lang_fi;
 159   else if (name == "el") return lang_el;
 160   else if (name == "he") return lang_he;
 161   else if (name == "it") return lang_it;
 162   else if (name == "pt") return lang_pt;
 163   else if (name == "es") return lang_es;
 164   else if (name == "eo") return lang_eo;
 165   else if (name == "fr") return lang_fr;
 166   else if (name == "pt_BR") return lang_pt_BR;
 167   else if (name == "lv") return lang_lv;
 168   else if (name == "ga") return lang_ga;
 169   else if (name == "lt") return lang_lt;
 170   else if (name == "hr") return lang_hr;
 171   else if (name == "cs") return lang_cs;
 172   else if (name == "ru") return lang_ru;
 173   else if (name == "uk") return lang_uk;
 174   else if (name == "sk") return lang_sk;
 175   else if (name == "pl") return lang_pl;
 176   else if (name == "sl") return lang_sl;
 177   else return lang_en;
 178 }
 179
 180 DictionaryManager::DictionaryManager()
 181   : current_dict(&empty_dict)
 182 {
 183   parseLocaleAliases();
 184   // Environment variable SUPERTUX_LANG overrides language settings.
 185   const char* lang = getenv( "SUPERTUX_LANG" );
 186   if( lang ){
 187     set_language( lang );
 188     return;
 189   }
 190   // use findlocale to setup language
 191   FL_Locale *locale;
 192   FL_FindLocale( &locale, FL_MESSAGES );
 193       if( locale->lang)
 194         set_language( locale->lang );
 195   FL_FreeLocale( &locale );
 196 }
 197
 198 void
 199 DictionaryManager::parseLocaleAliases()
 200 {
 201   // try to parse language alias list
 202   std::ifstream in("/usr/share/locale/locale.alias");
 203
 204   char c = ' ';
 205   while(in.good() && !in.eof()) {
 206     while(isspace(c) && !in.eof())
 207       in.get(c);
 208
 209     if(c == '#') { // skip comments
 210       while(c != '\n' && !in.eof())
 211         in.get(c);
 212       continue;
 213     }
 214
 215     std::string alias;
 216     while(!isspace(c) && !in.eof()) {
 217       alias += c;
 218       in.get(c);
 219     }
 220     while(isspace(c) && !in.eof())
 221       in.get(c);
 222     std::string language;
 223     while(!isspace(c) && !in.eof()) {
 224       language += c;
 225       in.get(c);
 226     }
 227
 228     if(in.eof())
 229       break;
 230     set_language_alias(alias, language);
 231   }
 232 }
 233
 234 Dictionary&
 235 DictionaryManager::get_dictionary(const std::string& spec)
 236 {
 237   std::string lang = get_language_from_spec(spec);
 238   Dictionaries::iterator i = dictionaries.find(get_language_from_spec(lang));
 239   if (i != dictionaries.end())
 240     {
 241       return i->second;
 242     }
 243   else // Dictionary for languages lang isn't loaded, so we load it
 244     {
 245       //log_debug << "get_dictionary: " << lang << std::endl;
 246       Dictionary& dict = dictionaries[lang];
 247
 248       dict.set_language(get_language_def(lang));
 249       if(charset != "")
 250         dict.set_charset(charset);
 251
 252       for (SearchPath::iterator p = search_path.begin(); p != search_path.end(); ++p)
 253         {
 254           char** files = PHYSFS_enumerateFiles(p->c_str());
 255           if(!files)
 256             {
 257               log_warning << "Error: enumerateFiles() failed on " << *p << std::endl;
 258             }
 259           else
 260             {
 261               for(const char* const* filename = files;
 262                       *filename != 0; filename++) {
 263                 if(std::string(*filename) == lang + ".po") {
 264                   std::string pofile = *p + "/" + *filename;
 265                   try {
 266                       IFileStream in(pofile);
 267                       read_po_file(dict, in);
 268                   } catch(std::exception& e) {
 269                       log_warning << "Error: Failure file opening: " << pofile << std::endl;
 270                       log_warning << e.what() << "" << std::endl;
 271                   }
 272                 }
 273               }
 274               PHYSFS_freeList(files);
 275             }
 276         }
 277
 278       return dict;
 279     }
 280 }
 281
 282 std::set<std::string>
 283 DictionaryManager::get_languages()
 284 {
 285   std::set<std::string> languages;
 286
 287   for (SearchPath::iterator p = search_path.begin(); p != search_path.end(); ++p)
 288     {
 289       char** files = PHYSFS_enumerateFiles(p->c_str());
 290       if (!files)
 291         {
 292           log_warning << "Error: opendir() failed on " << *p << std::endl;
 293         }
 294       else
 295         {
 296           for(const char* const* file = files; *file != 0; file++) {
 297               if(has_suffix(*file, ".po")) {
 298                   std::string filename = *file;
 299                   languages.insert(filename.substr(0, filename.length()-3));
 300               }
 301           }
 302           PHYSFS_freeList(files);
 303         }
 304     }
 305   return languages;
 306 }
 307
 308 void
 309 DictionaryManager::set_language(const std::string& lang)
 310 {
 311   language = get_language_from_spec(lang);
 312   current_dict = & (get_dictionary(language));
 313 }
 314
 315 const std::string&
 316 DictionaryManager::get_language() const
 317 {
 318   return language;
 319 }
 320
 321 void
 322 DictionaryManager::set_charset(const std::string& charset)
 323 {
 324   dictionaries.clear(); // changing charset invalidates cache
 325   this->charset = charset;
 326   set_language(language);
 327 }
 328
 329 void
 330 DictionaryManager::set_language_alias(const std::string& alias,
 331     const std::string& language)
 332 {
 333   language_aliases.insert(std::make_pair(alias, language));
 334 }
 335
 336 std::string
 337 DictionaryManager::get_language_from_spec(const std::string& spec)
 338 {
 339   std::string lang = spec;
 340   Aliases::iterator i = language_aliases.find(lang);
 341   if(i != language_aliases.end()) {
 342     lang = i->second;
 343   }
 344
 345   std::string::size_type s = lang.find_first_of("_.");
 346   if(s == std::string::npos)
 347     return lang;
 348
 349   return std::string(lang, 0, s);
 350 }
 351
 352 void
 353 DictionaryManager::add_directory(const std::string& pathname)
 354 {
 355   dictionaries.clear(); // adding directories invalidates cache
 356   search_path.push_back(pathname);
 357   set_language(language);
 358 }
 359
 360 //---------------------------------------------------------------------------
 361
 362 Dictionary::Dictionary(const LanguageDef& language_, const std::string& charset_)
 363   : language(language_), charset(charset_)
 364 {
 365 }
 366
 367 Dictionary::Dictionary()
 368   : language(lang_en)
 369 {
 370 }
 371
 372 std::string
 373 Dictionary::get_charset() const
 374 {
 375   return charset;
 376 }
 377
 378 void
 379 Dictionary::set_charset(const std::string& charset_)
 380 {
 381   charset = charset_;
 382 }
 383
 384 void
 385 Dictionary::set_language(const LanguageDef& lang)
 386 {
 387   language = lang;
 388 }
 389
 390 std::string
 391 Dictionary::translate(const std::string& msgid, const std::string& msgid2, int num)
 392 {
 393   PluralEntries::iterator i = plural_entries.find(msgid);
 394   std::map<int, std::string>& msgstrs = i->second;
 395
 396   if (i != plural_entries.end() && !msgstrs.empty())
 397     {
 398       int g = language.plural(num);
 399       std::map<int, std::string>::iterator j = msgstrs.find(g);
 400       if (j != msgstrs.end())
 401         {
 402           return j->second;
 403         }
 404       else
 405         {
 406           // Return the first translation, in case we can't translate the specific number
 407           return msgstrs.begin()->second;
 408         }
 409     }
 410   else
 411     {
 412 #ifdef TRANSLATION_DEBUG
 413       log_warning << "Couldn't translate: " << msgid << std::endl;
 414       log_warning << "Candidates: " << std::endl;
 415       for (PluralEntries::iterator i = plural_entries.begin(); i != plural_entries.end(); ++i)
 416         log_debug << "'" << i->first << "'" << std::endl;
 417 #endif
 418
 419       if (plural2_1(num)) // default to english rules
 420         return msgid2;
 421       else
 422         return msgid;
 423     }
 424 }
 425
 426 const char*
 427 Dictionary::translate(const char* msgid)
 428 {
 429   Entries::iterator i = entries.find(msgid);
 430   if (i != entries.end() && !i->second.empty())
 431     {
 432       return i->second.c_str();
 433     }
 434   else
 435     {
 436 #ifdef TRANSLATION_DBEUG
 437       log_warning << "Couldn't translate: " << msgid << std::endl;
 438 #endif
 439       return msgid;
 440     }
 441 }
 442
 443 std::string
 444 Dictionary::translate(const std::string& msgid)
 445 {
 446   Entries::iterator i = entries.find(msgid);
 447   if (i != entries.end() && !i->second.empty())
 448     {
 449       return i->second;
 450     }
 451   else
 452     {
 453 #ifdef TRANSLATION_DBEUG
 454       log_warning << "Couldn't translate: " << msgid << std::endl;
 455 #endif
 456       return msgid;
 457     }
 458 }
 459
 460 void
 461 Dictionary::add_translation(const std::string& msgid, const std::string& ,
 462                             const std::map<int, std::string>& msgstrs)
 463 {
 464   // Do we need msgid2 for anything? its after all supplied to the
 465   // translate call, so we just throw it away
 466   plural_entries[msgid] = msgstrs;
 467 }
 468
 469 void
 470 Dictionary::add_translation(const std::string& msgid, const std::string& msgstr)
 471 {
 472   entries[msgid] = msgstr;
 473 }
 474
 475 class POFileReader
 476 {
 477 private:
 478   struct Token
 479   {
 480     std::string keyword;
 481     std::string content;
 482   };
 483
 484   Dictionary& dict;
 485
 486   std::string from_charset;
 487   std::string to_charset;
 488
 489   std::string current_msgid;
 490   std::string current_msgid_plural;
 491   std::map<int, std::string> msgstr_plural;
 492
 493   int line_num;
 494
 495   enum { WANT_MSGID, WANT_MSGSTR, WANT_MSGSTR_PLURAL, WANT_MSGID_PLURAL } state;
 496
 497 public:
 498   POFileReader(std::istream& in, Dictionary& dict_)
 499     : dict(dict_)
 500   {
 501     state = WANT_MSGID;
 502     line_num = 0;
 503     char c = in.get();
 504     if(c == (char) 0xef) { // skip UTF-8 intro that some texteditors produce
 505         in.get();
 506         in.get();
 507     } else {
 508         in.unget();
 509     }
 510     tokenize_po(in);
 511   }
 512
 513   void parse_header(const std::string& header)
 514   {
 515     // Seperate the header in lines
 516     typedef std::vector<std::string> Lines;
 517     Lines lines;
 518
 519     std::string::size_type start = 0;
 520     for(std::string::size_type i = 0; i < header.length(); ++i)
 521       {
 522         if (header[i] == '\n')
 523           {
 524             lines.push_back(header.substr(start, i - start));
 525             start = i+1;
 526           }
 527       }
 528
 529     for(Lines::iterator i = lines.begin(); i != lines.end(); ++i)
 530       {
 531         if (has_prefix(*i, "Content-Type: text/plain; charset=")) {
 532           from_charset = i->substr(strlen("Content-Type: text/plain; charset="));
 533         }
 534       }
 535
 536     if (from_charset.empty() || from_charset == "CHARSET")
 537       {
 538         log_warning << "Error: Charset not specified for .po, fallback to ISO-8859-1" << std::endl;
 539         from_charset = "ISO-8859-1";
 540       }
 541
 542     to_charset = dict.get_charset();
 543     if (to_charset.empty())
 544       { // No charset requested from the dict, use utf-8
 545         to_charset = "utf-8";
 546         dict.set_charset(from_charset);
 547       }
 548   }
 549
 550   void add_token(const Token& token)
 551   {
 552     switch(state)
 553       {
 554       case WANT_MSGID:
 555         if (token.keyword == "msgid")
 556           {
 557             current_msgid = token.content;
 558             state = WANT_MSGID_PLURAL;
 559           }
 560         else if (token.keyword.empty())
 561           {
 562             //log_warning << "Got EOF, everything looks ok." << std::endl;
 563           }
 564         else
 565           {
 566             log_warning << "tinygettext: expected 'msgid' keyword, got " << token.keyword << " at line " << line_num << std::endl;
 567           }
 568         break;
 569
 570       case WANT_MSGID_PLURAL:
 571         if (token.keyword == "msgid_plural")
 572           {
 573             current_msgid_plural = token.content;
 574             state = WANT_MSGSTR_PLURAL;
 575           }
 576         else
 577           {
 578             state = WANT_MSGSTR;
 579             add_token(token);
 580           }
 581         break;
 582
 583       case WANT_MSGSTR:
 584         if (token.keyword == "msgstr")
 585           {
 586             if (current_msgid == "")
 587               { // .po Header is hidden in the msgid with the empty string
 588                 parse_header(token.content);
 589               }
 590             else
 591               {
 592                 dict.add_translation(current_msgid, convert(token.content, from_charset, to_charset));
 593               }
 594             state = WANT_MSGID;
 595           }
 596         else
 597           {
 598             log_warning << "tinygettext: expected 'msgstr' keyword, got " << token.keyword << " at line " << line_num << std::endl;
 599           }
 600         break;
 601
 602       case WANT_MSGSTR_PLURAL:
 603         if (has_prefix(token.keyword, "msgstr["))
 604           {
 605             int num;
 606             if (sscanf(token.keyword.c_str(), "msgstr[%d]", &num) != 1)
 607               {
 608                 log_warning << "Error: Couldn't parse: " << token.keyword << std::endl;
 609               }
 610             else
 611               {
 612                 msgstr_plural[num] = convert(token.content, from_charset, to_charset);
 613               }
 614           }
 615         else
 616           {
 617             dict.add_translation(current_msgid, current_msgid_plural, msgstr_plural);
 618
 619             state = WANT_MSGID;
 620             add_token(token);
 621           }
 622         break;
 623       }
 624   }
 625
 626   inline int getchar(std::istream& in)
 627   {
 628     int c = in.get();
 629     if (c == '\n')
 630       line_num += 1;
 631     return c;
 632   }
 633
 634   void tokenize_po(std::istream& in)
 635   {
 636     enum State { READ_KEYWORD,
 637                  READ_CONTENT,
 638                  READ_CONTENT_IN_STRING,
 639                  SKIP_COMMENT };
 640
 641     State state = READ_KEYWORD;
 642     int c;
 643     Token token;
 644
 645     while((c = getchar(in)) != EOF)
 646       {
 647         //log_debug << "Lexing char: " << char(c) << " " << state << std::endl;
 648         switch(state)
 649           {
 650           case READ_KEYWORD:
 651             if (c == '#')
 652               {
 653                 state = SKIP_COMMENT;
 654               }
 655             else
 656               {
 657                 // Read a new token
 658                 token = Token();
 659
 660                 do { // Read keyword
 661                   token.keyword += c;
 662                 } while((c = getchar(in)) != EOF && !isspace(c));
 663                 in.unget();
 664
 665                 state = READ_CONTENT;
 666               }
 667             break;
 668
 669           case READ_CONTENT:
 670             while((c = getchar(in)) != EOF)
 671               {
 672                 if (c == '"') {
 673                   // Found start of content
 674                   state = READ_CONTENT_IN_STRING;
 675                   break;
 676                 } else if (isspace(c)) {
 677                   // skip
 678                 } else { // Read something that may be a keyword
 679                   in.unget();
 680                   state = READ_KEYWORD;
 681                   add_token(token);
 682                   break;
 683                 }
 684               }
 685             break;
 686
 687           case READ_CONTENT_IN_STRING:
 688             if (c == '\\') {
 689               c = getchar(in);
 690               if (c != EOF)
 691                 {
 692                   if (c == 'n') token.content += '\n';
 693                   else if (c == 't') token.content += '\t';
 694                   else if (c == 'r') token.content += '\r';
 695                   else if (c == '"') token.content += '"';
 696                   else
 697                     {
 698                       log_warning << "Unhandled escape character: " << char(c) << std::endl;
 699                     }
 700                 }
 701               else
 702                 {
 703                   log_warning << "Unterminated string" << std::endl;
 704                 }
 705             } else if (c == '"') { // Content string is terminated
 706               state = READ_CONTENT;
 707             } else {
 708               token.content += c;
 709             }
 710             break;
 711
 712           case SKIP_COMMENT:
 713             if (c == '\n')
 714               state = READ_KEYWORD;
 715             break;
 716           }
 717       }
 718     add_token(token);
 719   }
 720 };
 721
 722 void read_po_file(Dictionary& dict_, std::istream& in)
 723 {
 724   POFileReader reader(in, dict_);
 725 }
 726
 727 } // namespace TinyGetText
 728
 729 /* EOF */