Added tinygettext sources

tinygettext/.svn/all-wcprops

@@ -0,0 +1,125 @@
+K 25
+svn:wc:ra_dav:version-url
+V 35
+/svn/!svn/ver/200/trunk/tinygettext
+END
+po_parser.hpp
+K 25
+svn:wc:ra_dav:version-url
+V 49
+/svn/!svn/ver/174/trunk/tinygettext/po_parser.hpp
+END
+dictionary_manager.cpp
+K 25
+svn:wc:ra_dav:version-url
+V 58
+/svn/!svn/ver/174/trunk/tinygettext/dictionary_manager.cpp
+END
+log_stream.hpp
+K 25
+svn:wc:ra_dav:version-url
+V 50
+/svn/!svn/ver/174/trunk/tinygettext/log_stream.hpp
+END
+dictionary_manager.hpp
+K 25
+svn:wc:ra_dav:version-url
+V 58
+/svn/!svn/ver/184/trunk/tinygettext/dictionary_manager.hpp
+END
+plural_forms.cpp
+K 25
+svn:wc:ra_dav:version-url
+V 52
+/svn/!svn/ver/189/trunk/tinygettext/plural_forms.cpp
+END
+dictionary.cpp
+K 25
+svn:wc:ra_dav:version-url
+V 50
+/svn/!svn/ver/179/trunk/tinygettext/dictionary.cpp
+END
+plural_forms.hpp
+K 25
+svn:wc:ra_dav:version-url
+V 52
+/svn/!svn/ver/182/trunk/tinygettext/plural_forms.hpp
+END
+dictionary.hpp
+K 25
+svn:wc:ra_dav:version-url
+V 50
+/svn/!svn/ver/182/trunk/tinygettext/dictionary.hpp
+END
+iconv.cpp
+K 25
+svn:wc:ra_dav:version-url
+V 45
+/svn/!svn/ver/180/trunk/tinygettext/iconv.cpp
+END
+log.cpp
+K 25
+svn:wc:ra_dav:version-url
+V 43
+/svn/!svn/ver/178/trunk/tinygettext/log.cpp
+END
+language.cpp
+K 25
+svn:wc:ra_dav:version-url
+V 48
+/svn/!svn/ver/200/trunk/tinygettext/language.cpp
+END
+iconv.hpp
+K 25
+svn:wc:ra_dav:version-url
+V 45
+/svn/!svn/ver/186/trunk/tinygettext/iconv.hpp
+END
+unix_file_system.cpp
+K 25
+svn:wc:ra_dav:version-url
+V 56
+/svn/!svn/ver/170/trunk/tinygettext/unix_file_system.cpp
+END
+log.hpp
+K 25
+svn:wc:ra_dav:version-url
+V 43
+/svn/!svn/ver/174/trunk/tinygettext/log.hpp
+END
+tinygettext.cpp
+K 25
+svn:wc:ra_dav:version-url
+V 51
+/svn/!svn/ver/169/trunk/tinygettext/tinygettext.cpp
+END
+language.hpp
+K 25
+svn:wc:ra_dav:version-url
+V 48
+/svn/!svn/ver/200/trunk/tinygettext/language.hpp
+END
+file_system.hpp
+K 25
+svn:wc:ra_dav:version-url
+V 51
+/svn/!svn/ver/170/trunk/tinygettext/file_system.hpp
+END
+po_parser.cpp
+K 25
+svn:wc:ra_dav:version-url
+V 49
+/svn/!svn/ver/197/trunk/tinygettext/po_parser.cpp
+END
+unix_file_system.hpp
+K 25
+svn:wc:ra_dav:version-url
+V 56
+/svn/!svn/ver/170/trunk/tinygettext/unix_file_system.hpp
+END
+tinygettext.hpp
+K 25
+svn:wc:ra_dav:version-url
+V 51
+/svn/!svn/ver/182/trunk/tinygettext/tinygettext.hpp
+END

tinygettext/.svn/dir-prop-base

@@ -0,0 +1,6 @@
+K 10
+svn:ignore
+V 17
+.sconsign.dblite
+
+END

tinygettext/.svn/entries

@@ -0,0 +1,708 @@
+10
+
+dir
+201
+http://tinygettext.googlecode.com/svn/trunk/tinygettext
+http://tinygettext.googlecode.com/svn
+
+
+
+2011-10-03T14:29:31.206762Z
+200
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+eb69f7b0-e952-11dd-ab07-b19b4dad1b3d
+
+po_parser.hpp
+file
+
+
+
+
+2013-03-31T22:08:18.028058Z
+23a6240f2f82af40b78364b62c79c387
+2009-11-18T20:47:52.021855Z
+174
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2156
+
+dictionary_manager.cpp
+file
+
+
+
+
+2013-03-31T22:08:18.027058Z
+2c7bcfd033a603c55d96586e3c97b536
+2009-11-18T20:47:52.021855Z
+174
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+5865
+
+log_stream.hpp
+file
+
+
+
+
+2013-03-31T22:08:18.028058Z
+4acaa0a3746376e5ec3d4864e975c4de
+2009-11-18T20:47:52.021855Z
+174
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1371
+
+dictionary_manager.hpp
+file
+
+
+
+
+2013-03-31T22:08:18.028058Z
+b4cd5d8fe7302ea0647df874958c2bee
+2009-12-09T01:43:05.858128Z
+184
+man.is.allan
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2980
+
+plural_forms.cpp
+file
+
+
+
+
+2013-03-31T22:08:18.029058Z
+9570a882f3f77e074ec8f55cfc5c2077
+2010-01-26T00:53:32.449628Z
+189
+ohnobinki
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+4555
+
+dictionary.cpp
+file
+
+
+
+
+2013-03-31T22:08:18.028058Z
+c82c8e83ca22c4c588c0ab8d2d14f134
+2009-11-20T00:30:18.104800Z
+179
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+5276
+
+plural_forms.hpp
+file
+
+
+
+
+2013-03-31T22:08:18.029058Z
+1eb30a9a4a99b52802ce121b6c6701e2
+2009-11-26T23:34:52.689682Z
+182
+man.is.allan
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1769
+
+dictionary.hpp
+file
+
+
+
+
+2013-03-31T22:08:18.029058Z
+9b1be1854f4dbf398f02ac5cdb658785
+2009-11-26T23:34:52.689682Z
+182
+man.is.allan
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+4726
+
+iconv.cpp
+file
+
+
+
+
+2013-03-31T22:08:18.029058Z
+23c1ea5199beac2e3bccc02329ea30ca
+2009-11-25T16:18:41.773196Z
+180
+man.is.allan
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+4073
+
+log.cpp
+file
+
+
+
+
+2013-03-31T22:08:18.030058Z
+cb040aa8dc7f7f602bc62f4279b1236a
+2009-11-18T21:35:45.007212Z
+178
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1740
+
+language.cpp
+file
+
+
+
+
+2013-03-31T22:08:18.031058Z
+4a9b65c6575c2c847ce5f81d68d7e7db
+2011-10-03T14:29:31.206762Z
+200
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+21855
+
+iconv.hpp
+file
+
+
+
+
+2013-03-31T22:08:18.030058Z
+49d0731b3c455c4cb9cc6b314afff6f4
+2009-12-11T00:43:23.913823Z
+186
+man.is.allan
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1958
+
+unix_file_system.cpp
+file
+
+
+
+
+2013-03-31T22:08:18.031058Z
+2c1d00fcf3505d0d18a60565b797e593
+2009-11-18T18:53:41.281736Z
+170
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1691
+
+log.hpp
+file
+
+
+
+
+2013-03-31T22:08:18.031058Z
+6645d3a149c2572a71d7232faa22bc98
+2009-11-18T20:47:52.021855Z
+174
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1622
+
+language.hpp
+file
+
+
+
+
+2013-03-31T22:08:18.031058Z
+b82a50a374cc1c7d9289f7a8a7f67a6f
+2011-10-03T14:29:31.206762Z
+200
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+3005
+
+tinygettext.cpp
+file
+
+
+
+
+2013-03-31T22:08:18.032058Z
+8963dacdd6aedba77fe5464cc01b2879
+2009-11-18T18:00:07.161229Z
+169
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+918
+
+file_system.hpp
+file
+
+
+
+
+2013-03-31T22:08:18.032058Z
+bab55b50d74395a5050304af206fa1bf
+2009-11-18T18:53:41.281736Z
+170
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1319
+
+po_parser.cpp
+file
+
+
+
+
+2013-03-31T22:08:18.032058Z
+f7e5187aa51357032661922d84e329bb
+2010-08-18T03:13:51.230190Z
+197
+ohnobinki
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+12070
+
+unix_file_system.hpp
+file
+
+
+
+
+2013-03-31T22:08:18.032058Z
+2639f21bd1dced18ce566244f5e53444
+2009-11-18T18:53:41.281736Z
+170
+grumbel
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1272
+
+tinygettext.hpp
+file
+
+
+
+
+2013-03-31T22:08:18.033058Z
+e7182b1ddca1efcca3d075e0b0333d24
+2009-11-26T23:34:52.689682Z
+182
+man.is.allan
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1045
+

tinygettext/.svn/prop-base/dictionary.cpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/dictionary.hpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/dictionary_manager.cpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/dictionary_manager.hpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/file_system.hpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/iconv.cpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/iconv.hpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/language.cpp.svn-base

@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 13
+svn:mergeinfo
+V 0
+
+END

tinygettext/.svn/prop-base/language.hpp.svn-base

@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 13
+svn:mergeinfo
+V 0
+
+END

tinygettext/.svn/prop-base/log.cpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/log.hpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/log_stream.hpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/plural_forms.cpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/plural_forms.hpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/po_parser.cpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/po_parser.hpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/tinygettext.cpp.svn-base

@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 13
+svn:mergeinfo
+V 0
+
+END

tinygettext/.svn/prop-base/tinygettext.hpp.svn-base

@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 13
+svn:mergeinfo
+V 0
+
+END

tinygettext/.svn/prop-base/unix_file_system.cpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/prop-base/unix_file_system.hpp.svn-base

@@ -0,0 +1,5 @@
+K 13
+svn:eol-style
+V 6
+native
+END

tinygettext/.svn/text-base/dictionary.cpp.svn-base

@@ -0,0 +1,208 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include <assert.h>
+#include "log_stream.hpp"
+#include "dictionary.hpp"
+
+namespace tinygettext {
+
+Dictionary::Dictionary(const std::string& charset_) :
+  entries(),
+  ctxt_entries(),
+  charset(charset_),
+  plural_forms()
+{
+}
+
+Dictionary::~Dictionary()
+{
+}
+
+std::string
+Dictionary::get_charset() const
+{
+  return charset;
+}
+
+void
+Dictionary::set_plural_forms(const PluralForms& plural_forms_)
+{
+  plural_forms = plural_forms_;
+}
+
+PluralForms
+Dictionary::get_plural_forms() const
+{
+  return plural_forms;
+}
+
+std::string
+Dictionary::translate_plural(const std::string& msgid, const std::string& msgid_plural, int num)
+{
+  return translate_plural(entries, msgid, msgid_plural, num);
+}
+
+std::string
+Dictionary::translate_plural(const Entries& dict, const std::string& msgid, const std::string& msgid_plural, int count)
+{
+  Entries::const_iterator i = dict.find(msgid);
+  const std::vector<std::string>& msgstrs = i->second;
+
+  if (i != dict.end())
+  {
+    unsigned int n = 0;
+    n = plural_forms.get_plural(count);
+    assert(/*n >= 0 &&*/ n < msgstrs.size());
+
+    if (!msgstrs[n].empty())
+      return msgstrs[n];
+    else
+      if (count == 1) // default to english rules
+        return msgid;
+      else
+        return msgid_plural;
+  }
+  else
+  {
+    log_info << "Couldn't translate: " << msgid << std::endl;
+    log_info << "Candidates: " << std::endl;
+    for (i = dict.begin(); i != dict.end(); ++i)
+      log_info << "'" << i->first << "'" << std::endl;
+
+    if (count == 1) // default to english rules
+      return msgid;
+    else
+      return msgid_plural;
+  }
+}
+
+std::string
+Dictionary::translate(const std::string& msgid)
+{
+  return translate(entries, msgid);
+}
+
+std::string
+Dictionary::translate(const Entries& dict, const std::string& msgid)
+{
+  Entries::const_iterator i = dict.find(msgid);
+  if (i != dict.end() && !i->second.empty())
+  {
+    return i->second[0];
+  }
+  else
+  {
+    log_info << "Couldn't translate: " << msgid << std::endl;
+    return msgid;
+  } 
+}
+
+std::string
+Dictionary::translate_ctxt(const std::string& msgctxt, const std::string& msgid)
+{
+  CtxtEntries::iterator i = ctxt_entries.find(msgctxt);
+  if (i != ctxt_entries.end())
+  {
+    return translate(i->second, msgid);
+  }
+  else
+  {
+    log_info << "Couldn't translate: " << msgid << std::endl;
+    return msgid;
+  }
+}
+
+std::string
+Dictionary::translate_ctxt_plural(const std::string& msgctxt, 
+                                  const std::string& msgid, const std::string& msgidplural, int num)
+{
+  CtxtEntries::iterator i = ctxt_entries.find(msgctxt);
+  if (i != ctxt_entries.end())
+  {
+    return translate_plural(i->second, msgid, msgidplural, num);
+  }
+  else
+  {
+    log_info << "Couldn't translate: " << msgid << std::endl;
+    if (num != 1) // default to english
+      return msgidplural;
+    else
+      return msgid;
+  }
+}
+
+void
+Dictionary::add_translation(const std::string& msgid, const std::string& ,
+                            const std::vector<std::string>& msgstrs)
+{
+  // Do we need msgid2 for anything? its after all supplied to the
+  // translate call, so we just throw it away here
+  entries[msgid] = msgstrs;
+}
+
+void
+Dictionary::add_translation(const std::string& msgid, const std::string& msgstr)
+{
+  std::vector<std::string>& vec = entries[msgid];
+  if (vec.empty())
+  {
+    vec.push_back(msgstr);
+  }
+  else
+  {
+    log_warning << "collision in add_translation: '" 
+                << msgid << "' -> '" << msgstr << "' vs '" << vec[0] << "'" << std::endl;
+    vec[0] = msgstr;
+  }
+}
+
+void
+Dictionary::add_translation(const std::string& msgctxt, 
+                            const std::string& msgid, const std::string& msgid_plural,
+                            const std::vector<std::string>& msgstrs)
+{
+  std::vector<std::string>& vec = ctxt_entries[msgctxt][msgid];
+  if (vec.empty())
+  {
+    vec = msgstrs;
+  }
+  else
+  {
+    log_warning << "collision in add_translation(\"" << msgctxt << "\", \"" << msgid << "\", \"" << msgid_plural << "\")" << std::endl;
+    vec = msgstrs;
+  }
+}
+
+void
+Dictionary::add_translation(const std::string& msgctxt, const std::string& msgid, const std::string& msgstr)
+{
+  std::vector<std::string>& vec = ctxt_entries[msgctxt][msgid];
+  if (vec.empty())
+  {
+    vec.push_back(msgstr);
+  }
+  else
+  {
+    log_warning << "collision in add_translation(\"" << msgctxt << "\", \"" << msgid << "\")" << std::endl;
+    vec[0] = msgstr;
+  }
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/.svn/text-base/dictionary.hpp.svn-base

@@ -0,0 +1,123 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_DICTIONARY_HPP
+#define HEADER_TINYGETTEXT_DICTIONARY_HPP
+
+#include <map>
+#include <vector>
+#include <string>
+#include "plural_forms.hpp"
+
+namespace tinygettext {
+
+/** A simple dictionary class that mimics gettext() behaviour. Each
+    Dictionary only works for a single language, for managing multiple
+    languages and .po files at once use the DictionaryManager. */
+class Dictionary
+{
+private:
+  typedef std::map<std::string, std::vector<std::string> > Entries;
+  Entries entries;
+
+  typedef std::map<std::string, Entries> CtxtEntries;
+  CtxtEntries ctxt_entries;
+
+  std::string charset;
+  PluralForms plural_forms;
+
+  std::string translate(const Entries& dict, const std::string& msgid);
+  std::string translate_plural(const Entries& dict, const std::string& msgid, const std::string& msgidplural, int num);
+
+public:
+  /** Constructs a dictionary converting to the specified \a charset (default UTF-8) */
+  Dictionary(const std::string& charset = "UTF-8");
+  ~Dictionary();
+
+  /** Return the charset used for this dictionary */
+  std::string get_charset() const;
+
+  void set_plural_forms(const PluralForms&);
+  PluralForms get_plural_forms() const;
+
+
+  /** Translate the string \a msgid. */
+  std::string translate(const std::string& msgid);
+
+  /** Translate the string \a msgid to its correct plural form, based
+      on the number of items given by \a num. \a msgid_plural is \a msgid in
+      plural form. */
+  std::string translate_plural(const std::string& msgid, const std::string& msgidplural, int num);
+
+  /** Translate the string \a msgid that is in context \a msgctx. A
+      context is a way to disambiguate msgids that contain the same
+      letters, but different meaning. For example "exit" might mean to
+      quit doing something or it might refer to a door that leads
+      outside (i.e. 'Ausgang' vs 'Beenden' in german) */
+  std::string translate_ctxt(const std::string& msgctxt, const std::string& msgid);
+
+  std::string translate_ctxt_plural(const std::string& msgctxt, const std::string& msgid, const std::string& msgidplural, int num);
+
+  /** Add a translation from \a msgid to \a msgstr to the dictionary,
+      where \a msgid is the singular form of the message, msgid_plural the
+      plural form and msgstrs a table of translations. The right
+      translation will be calculated based on the \a num argument to
+      translate(). */
+  void add_translation(const std::string& msgid, const std::string& msgid_plural,
+                       const std::vector<std::string>& msgstrs);
+  void add_translation(const std::string& msgctxt, 
+                       const std::string& msgid, const std::string& msgid_plural,
+                       const std::vector<std::string>& msgstrs);
+
+  /** Add a translation from \a msgid to \a msgstr to the
+      dictionary */
+  void add_translation(const std::string& msgid, const std::string& msgstr);
+  void add_translation(const std::string& msgctxt, const std::string& msgid, const std::string& msgstr);
+
+  /** Iterate over all messages, Func is of type:
+      void func(const std::string& msgid, const std::vector<std::string>& msgstrs) */
+  template<class Func>
+  Func foreach(Func func) 
+  {
+    for(Entries::iterator i = entries.begin(); i != entries.end(); ++i)
+    {
+      func(i->first, i->second);
+    }
+    return func;
+  }
+
+  /** Iterate over all messages with a context, Func is of type:
+      void func(const std::string& ctxt, const std::string& msgid, const std::vector<std::string>& msgstrs) */
+  template<class Func>
+  Func foreach_ctxt(Func func) 
+  {
+    for(CtxtEntries::iterator i = ctxt_entries.begin(); i != ctxt_entries.end(); ++i)
+    {
+      for(Entries::iterator j = i->second.begin(); j != i->second.end(); ++j)
+      {
+        func(i->first, j->first, j->second);
+      }
+    }
+    return func;
+  }
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/.svn/text-base/dictionary_manager.cpp.svn-base

@@ -0,0 +1,242 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "dictionary_manager.hpp"
+
+#include <memory>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fstream>
+#include <algorithm>
+
+#include "log_stream.hpp"
+#include "po_parser.hpp"
+#include "unix_file_system.hpp"
+
+namespace tinygettext {
+
+static bool has_suffix(const std::string& lhs, const std::string rhs)
+{
+  if (lhs.length() < rhs.length())
+    return false;
+  else
+    return lhs.compare(lhs.length() - rhs.length(), rhs.length(), rhs) == 0;
+}
+
+DictionaryManager::DictionaryManager(const std::string& charset_) :
+  dictionaries(),
+  search_path(),
+  charset(charset_),
+  use_fuzzy(true),
+  current_language(),
+  current_dict(0),
+  empty_dict(),
+  filesystem(new UnixFileSystem)
+{
+}
+
+DictionaryManager::~DictionaryManager()
+{
+  for(Dictionaries::iterator i = dictionaries.begin(); i != dictionaries.end(); ++i)
+  {
+    delete i->second;
+  }
+}
+
+void
+DictionaryManager::clear_cache()
+{
+  for(Dictionaries::iterator i = dictionaries.begin(); i != dictionaries.end(); ++i)
+  {
+    delete i->second;
+  }
+  dictionaries.clear();
+
+  current_dict = 0;
+}
+
+Dictionary&
+DictionaryManager::get_dictionary()
+{
+  if (current_dict)
+  {
+    return *current_dict; 
+  }
+  else
+  {
+    if (current_language)
+    {
+      current_dict = &get_dictionary(current_language);
+      return *current_dict;
+    }
+    else
+    {
+      return empty_dict;
+    }
+  }
+}
+
+Dictionary&
+DictionaryManager::get_dictionary(const Language& language)
+{
+  //log_debug << "Dictionary for language \"" << spec << "\" requested" << std::endl;
+  //log_debug << "...normalized as \"" << lang << "\"" << std::endl;
+  assert(language);
+
+  Dictionaries::iterator i = dictionaries.find(language); 
+  if (i != dictionaries.end())
+  {
+    return *i->second;
+  }
+  else // Dictionary for languages lang isn't loaded, so we load it
+  {
+    //log_debug << "get_dictionary: " << lang << std::endl;
+    Dictionary* dict = new Dictionary(charset);
+
+    dictionaries[language] = dict;
+
+    for (SearchPath::reverse_iterator p = search_path.rbegin(); p != search_path.rend(); ++p)
+    {
+      std::vector<std::string> files = filesystem->open_directory(*p);
+
+      std::string best_filename;
+      int best_score = 0;
+
+      for(std::vector<std::string>::iterator filename = files.begin(); filename != files.end(); filename++)
+      {
+        // check if filename matches requested language
+        if (has_suffix(*filename, ".po"))
+        { // ignore anything that isn't a .po file
+          Language po_language = Language::from_env(filename->substr(0, filename->size()-3));
+
+          if (!po_language)
+          {
+            log_warning << *filename << ": warning: ignoring, unknown language" << std::endl;
+          }
+          else
+          {
+            int score = Language::match(language, po_language);
+                          
+            if (score > best_score)
+            {
+              best_score = score;
+              best_filename = *filename;
+            }
+          }
+        }
+      }
+              
+      if (!best_filename.empty())
+      {
+        std::string pofile = *p + "/" + best_filename;
+        try 
+        {
+          std::auto_ptr<std::istream> in = filesystem->open_file(pofile);
+          if (!in.get())
+          {
+            log_error << "error: failure opening: " << pofile << std::endl;
+          }
+          else
+          {
+            POParser::parse(pofile, *in, *dict);
+          }
+        }
+        catch(std::exception& e) 
+        {
+          log_error << "error: failure parsing: " << pofile << std::endl;
+          log_error << e.what() << "" << std::endl;
+        }
+      }
+    }
+
+    return *dict;
+  }
+}
+
+std::set<Language>
+DictionaryManager::get_languages()
+{
+  std::set<Language> languages;
+
+  for (SearchPath::iterator p = search_path.begin(); p != search_path.end(); ++p)
+  {
+    std::vector<std::string> files = filesystem->open_directory(*p);
+
+    for(std::vector<std::string>::iterator file = files.begin(); file != files.end(); ++file)
+    {
+      if (has_suffix(*file, ".po")) 
+      {
+        languages.insert(Language::from_env(file->substr(0, file->size()-3)));
+      }
+    }
+  }
+  return languages;
+}
+
+void
+DictionaryManager::set_language(const Language& language)
+{
+  if (current_language != language)
+  {
+    current_language = language;
+    current_dict     = 0;
+  }
+}
+
+Language
+DictionaryManager::get_language() const
+{
+  return current_language;
+}
+
+void
+DictionaryManager::set_charset(const std::string& charset_)
+{
+  clear_cache(); // changing charset invalidates cache
+  charset = charset_;
+}
+
+void
+DictionaryManager::set_use_fuzzy(bool t)
+{
+  clear_cache();
+  use_fuzzy = t;
+}
+
+bool
+DictionaryManager::get_use_fuzzy() const
+{
+  return use_fuzzy;
+}
+
+void
+DictionaryManager::add_directory(const std::string& pathname)
+{
+  clear_cache(); // adding directories invalidates cache
+  search_path.push_back(pathname);
+}
+
+void
+DictionaryManager::set_filesystem(std::auto_ptr<FileSystem> filesystem_)
+{
+  filesystem = filesystem_;
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/.svn/text-base/dictionary_manager.hpp.svn-base

@@ -0,0 +1,99 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_DICTIONARY_MANAGER_HPP
+#define HEADER_TINYGETTEXT_DICTIONARY_MANAGER_HPP
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <memory>
+
+#include "dictionary.hpp"
+#include "language.hpp"
+
+namespace tinygettext {
+
+class FileSystem;
+
+/** Manager class for dictionaries, you give it a bunch of directories
+    with .po files and it will then automatically load the right file
+    on demand depending on which language was set. */
+class DictionaryManager
+{
+private:
+  typedef std::map<Language, Dictionary*> Dictionaries;
+  Dictionaries dictionaries;
+
+  typedef std::vector<std::string> SearchPath;
+  SearchPath search_path;
+
+  std::string charset;
+  bool        use_fuzzy;
+  
+  Language    current_language;
+  Dictionary* current_dict;
+
+  Dictionary  empty_dict;
+
+  std::auto_ptr<FileSystem> filesystem;
+
+  void clear_cache();
+
+public:
+  DictionaryManager(const std::string& charset_ = "UTF-8");
+  ~DictionaryManager();
+
+  /** Return the currently active dictionary, if none is set, an empty
+      dictionary is returned. */
+  Dictionary& get_dictionary();
+
+  /** Get dictionary for language */
+  Dictionary& get_dictionary(const Language& language);
+
+  /** Set a language based on a four? letter country code */
+  void set_language(const Language& language);
+
+  /** returns the (normalized) country code of the currently used language */
+  Language get_language() const;
+
+  void set_use_fuzzy(bool t);
+  bool get_use_fuzzy() const;
+
+  /** Set a charset that will be set on the returned dictionaries */
+  void set_charset(const std::string& charset);
+
+  /** Add a directory to the search path for dictionaries, earlier
+      added directories have higher priority then later added ones */
+  void add_directory(const std::string& pathname);
+
+  /** Return a set of the available languages in their country code */
+  std::set<Language> get_languages();
+
+  void set_filesystem(std::auto_ptr<FileSystem> filesystem);
+
+private:
+  DictionaryManager (const DictionaryManager&);
+  DictionaryManager& operator= (const DictionaryManager&);
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/.svn/text-base/file_system.hpp.svn-base

@@ -0,0 +1,42 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_FILE_SYSTEM_HPP
+#define HEADER_TINYGETTEXT_FILE_SYSTEM_HPP
+
+#include <vector>
+#include <memory>
+#include <iosfwd>
+#include <string>
+
+namespace tinygettext {
+
+class FileSystem 
+{
+public:
+  virtual ~FileSystem() {}
+
+  virtual std::vector<std::string>    open_directory(const std::string& pathname) =0;
+  virtual std::auto_ptr<std::istream> open_file(const std::string& filename)      =0;
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */
+

tinygettext/.svn/text-base/iconv.cpp.svn-base

@@ -0,0 +1,148 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include <ctype.h>
+#include <assert.h>
+#include <sstream>
+#include <errno.h>
+#include <stdexcept>
+#include <string.h>
+#include <stdlib.h>
+
+#include "iconv.hpp"
+#include "log_stream.hpp"
+
+namespace tinygettext {
+
+#ifndef tinygettext_ICONV_CONST
+#  define tinygettext_ICONV_CONST 
+#endif
+
+IConv::IConv() 
+  : to_charset(),
+    from_charset(),
+    cd(0)
+{}
+ 
+IConv::IConv(const std::string& from_charset_, const std::string& to_charset_)
+  : to_charset(),
+    from_charset(),
+    cd(0)
+{
+  set_charsets(from_charset_, to_charset_);
+}
+ 
+IConv::~IConv()
+{
+  if (cd)
+    tinygettext_iconv_close(cd);
+}
+ 
+void
+IConv::set_charsets(const std::string& from_charset_, const std::string& to_charset_)
+{
+  if (cd)
+    tinygettext_iconv_close(cd);
+
+  from_charset = from_charset_;
+  to_charset   = to_charset_;
+
+  for(std::string::iterator i = to_charset.begin(); i != to_charset.end(); ++i)
+    *i = static_cast<char>(toupper(*i));
+
+  for(std::string::iterator i = from_charset.begin(); i != from_charset.end(); ++i)
+    *i = static_cast<char>(toupper(*i));
+
+  if (to_charset == from_charset)
+  {
+    cd = 0;
+  }
+  else
+  {
+    cd = tinygettext_iconv_open(to_charset.c_str(), from_charset.c_str());
+    if (cd == reinterpret_cast<tinygettext_iconv_t>(-1))
+    {
+      if(errno == EINVAL)
+      {
+        std::ostringstream str;
+        str << "IConv construction failed: conversion from '" << from_charset
+            << "' to '" << to_charset << "' not available";
+        throw std::runtime_error(str.str());
+      }
+      else
+      {
+        std::ostringstream str;
+        str << "IConv: construction failed: " << strerror(errno);
+        throw std::runtime_error(str.str());
+      }
+    }
+  }
+}
+
+/// Convert a string from encoding to another.
+std::string
+IConv::convert(const std::string& text)
+{
+  if (!cd)
+  {
+    return text;
+  }
+  else
+  {
+    size_t inbytesleft  = text.size();
+    size_t outbytesleft = 4*inbytesleft; // Worst case scenario: ASCII -> UTF-32?
+
+    // We try to avoid to much copying around, so we write directly into
+    // a std::string
+    tinygettext_ICONV_CONST char* inbuf = const_cast<char*>(&text[0]);
+    std::string result(outbytesleft, 'X');
+    char* outbuf = &result[0]; 
+  
+    // Try to convert the text.
+    size_t ret = tinygettext_iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
+    if (ret == static_cast<size_t>(-1))
+    {
+      if (errno == EILSEQ || errno == EINVAL)
+      { // invalid multibyte sequence
+        tinygettext_iconv(cd, NULL, NULL, NULL, NULL); // reset state
+
+        // FIXME: Could try to skip the invalid byte and continue
+        log_error << "error: tinygettext:iconv: invalid multibyte sequence in:  \"" << text << "\"" << std::endl;
+      }
+      else if (errno == E2BIG)
+      { // output buffer to small
+        assert(!"tinygettext/iconv.cpp: E2BIG: This should never be reached");
+      }
+      else if (errno == EBADF)
+      {
+        assert(!"tinygettext/iconv.cpp: EBADF: This should never be reached");
+      }
+      else
+      {
+        assert(!"tinygettext/iconv.cpp: <unknown>: This should never be reached");
+      }
+    }
+
+    result.resize(4*text.size() - outbytesleft);
+
+    return result;
+  }
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/.svn/text-base/iconv.hpp.svn-base

@@ -0,0 +1,71 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//  
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//  
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef HEADER_TINYGETTEXT_ICONV_HPP
+#define HEADER_TINYGETTEXT_ICONV_HPP
+
+#include <string>
+
+#ifdef HAVE_SDL
+#  include "SDL.h"
+
+#  define tinygettext_ICONV_CONST const
+#  define tinygettext_iconv_t     SDL_iconv_t
+#  define tinygettext_iconv       SDL_iconv
+#  define tinygettext_iconv_open  SDL_iconv_open
+#  define tinygettext_iconv_close SDL_iconv_close 
+#else
+#  include <iconv.h>
+
+#  ifdef HAVE_ICONV_CONST
+#    define tinygettext_ICONV_CONST ICONV_CONST
+#  else
+#    define tinygettext_ICONV_CONST 
+#  endif
+
+#  define tinygettext_iconv_t     iconv_t
+#  define tinygettext_iconv       iconv
+#  define tinygettext_iconv_open  iconv_open
+#  define tinygettext_iconv_close iconv_close 
+#endif
+
+namespace tinygettext {
+
+class IConv
+{
+private:
+  std::string to_charset;
+  std::string from_charset;
+  tinygettext_iconv_t cd;
+
+public:
+  IConv();
+  IConv(const std::string& fromcode, const std::string& tocode);
+  ~IConv();
+
+  void set_charsets(const std::string& fromcode, const std::string& tocode);
+  std::string convert(const std::string& text);
+
+private:
+  IConv (const IConv&);
+  IConv& operator= (const IConv&);
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/.svn/text-base/language.cpp.svn-base

@@ -0,0 +1,568 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "language.hpp"
+
+#include <map>
+#include <assert.h>
+#include <vector>
+
+namespace tinygettext {
+
+struct LanguageSpec {
+  /** Language code: "de", "en", ... */
+  const char* language;
+
+  /** Country code: "BR", "DE", ..., can be 0 */
+  const char* country;
+
+  /** Modifier/Varint: "Latn", "ije", "latin"..., can be 0 */
+  const char* modifier;
+
+  /** Language name: "German", "English", "French", ... */
+  const char* name;
+};
+
+/** Language Definitions */
+//*{
+LanguageSpec languages[] = {
+  { "aa", 0,    0, "Afar"                        },
+  { "af", 0,    0, "Afrikaans"                   },
+  { "af", "ZA", 0, "Afrikaans (South Africa)"    },
+  { "am", 0,    0, "Amharic"                     },
+  { "ar", 0,    0, "Arabic"                      },
+  { "ar", "AR", 0, "Arabic (Argentina)"          },
+  { "ar", "OM", 0, "Arabic (Oman)"               },
+  { "ar", "SA", 0, "Arabic (Saudi Arabia)"       },
+  { "ar", "SY", 0, "Arabic (Syrian Arab Republic)" },
+  { "ar", "TN", 0, "Arabic (Tunisia)"            },
+  { "as", 0,    0, "Assamese"                    },
+  { "ast",0,    0, "Asturian"                    },
+  { "ay", 0,    0, "Aymara"                      },
+  { "az", 0,    0, "Azerbaijani"                 },
+  { "az", "IR", 0, "Azerbaijani (Iran)"          },
+  { "be", 0,    0, "Belarusian"                  },
+  { "be", 0, "latin", "Belarusian"               },
+  { "bg", 0,    0, "Bulgarian"                   },
+  { "bg", "BG", 0, "Bulgarian (Bulgaria)"        },
+  { "bn", 0,    0, "Bengali"                     },
+  { "bn", "BD", 0, "Bengali (Bangladesh)"        },
+  { "bn", "IN", 0, "Bengali (India)"             },
+  { "bo", 0,    0, "Tibetan"                     },
+  { "br", 0,    0, "Breton"                      },
+  { "bs", 0,    0, "Bosnian"                     },
+  { "bs", "BA", 0, "Bosnian (Bosnia/Herzegovina)"},
+  { "bs", "BS", 0, "Bosnian (Bahamas)"           },
+  { "ca", "ES", "valencia", "Catalan (valencia)" },
+  { "ca", "ES", 0, "Catalan (Spain)"             },
+  { "ca", 0,    "valencia", "Catalan (valencia)" },
+  { "ca", 0,    0, "Catalan"                     },
+  { "co", 0,    0, "Corsican"                    },
+  { "cs", 0,    0, "Czech"                       },
+  { "cs", "CZ", 0, "Czech (Czech Republic)"      },
+  { "cy", 0,    0, "Welsh"                       },
+  { "cy", "GB", 0, "Welsh (Great Britain)"       },
+  { "cz", 0,    0, "Unknown language"            },
+  { "da", 0,    0, "Danish"                      },
+  { "da", "DK", 0, "Danish (Denmark)"            },
+  { "de", 0,    0, "German"                      },
+  { "de", "AT", 0, "German (Austria)"            },
+  { "de", "CH", 0, "German (Switzerland)"        },
+  { "de", "DE", 0, "German (Germany)"            },
+  { "dk", 0,    0, "Unknown language"            },
+  { "dz", 0,    0, "Dzongkha"                    },
+  { "el", 0,    0, "Greek"                       },
+  { "el", "GR", 0, "Greek (Greece)"              },
+  { "en", 0,    0, "English"                     },
+  { "en", "AU", 0, "English (Australia)"         },
+  { "en", "CA", 0, "English (Canada)"            },
+  { "en", "GB", 0, "English (Great Britain)"     },
+  { "en", "US", 0, "English (United States)"     },
+  { "en", "ZA", 0, "English (South Africa)"      },
+  { "en", 0, "boldquot", "English"               },
+  { "en", 0, "quot", "English"                   },
+  { "en", "US", "piglatin", "English"            },
+  { "eo", 0,    0, "Esperanto"                   },
+  { "es", 0,    0, "Spanish"                     },
+  { "es", "AR", 0, "Spanish (Argentina)"         },
+  { "es", "CL", 0, "Spanish (Chile)"             },
+  { "es", "CO", 0, "Spanish (Colombia)"          },
+  { "es", "CR", 0, "Spanish (Costa Rica)"        },
+  { "es", "DO", 0, "Spanish (Dominican Republic)"},
+  { "es", "EC", 0, "Spanish (Ecuador)"           },
+  { "es", "ES", 0, "Spanish (Spain)"             },
+  { "es", "GT", 0, "Spanish (Guatemala)"         },
+  { "es", "HN", 0, "Spanish (Honduras)"          },
+  { "es", "LA", 0, "Spanish (Laos)"              },
+  { "es", "MX", 0, "Spanish (Mexico)"            },
+  { "es", "NI", 0, "Spanish (Nicaragua)"         },
+  { "es", "PA", 0, "Spanish (Panama)"            },
+  { "es", "PE", 0, "Spanish (Peru)"              },
+  { "es", "PR", 0, "Spanish (Puerto Rico)"       },
+  { "es", "SV", 0, "Spanish (El Salvador)"       },
+  { "es", "UY", 0, "Spanish (Uruguay)"           },
+  { "es", "VE", 0, "Spanish (Venezuela)"         },
+  { "et", 0,    0, "Estonian"                    },
+  { "et", "EE", 0, "Estonian (Estonia)"          },
+  { "et", "ET", 0, "Estonian (Ethiopia)"         },
+  { "eu", 0,    0, "Basque"                      },
+  { "eu", "ES", 0, "Basque (Spain)"              },
+  { "fa", 0,    0, "Persian"                     },
+  { "fa", "AF", 0, "Persian (Afghanistan)"       },
+  { "fa", "IR", 0, "Persian (Iran)"              },
+  { "fi", 0,    0, "Finnish"                     },
+  { "fi", "FI", 0, "Finnish (Finland)"           },
+  { "fo", 0,    0, "Faroese"                     },
+  { "fo", "FO", 0, "Faeroese (Faroe Islands)"    },
+  { "fr", 0,    0, "French"                      },
+  { "fr", "CA", 0, "French (Canada)"             },
+  { "fr", "CH", 0, "French (Switzerland)"        },
+  { "fr", "FR", 0, "French (France)"             },
+  { "fr", "LU", 0, "French (Luxembourg)"         },
+  { "fy", 0,    0, "Frisian"                     },
+  { "ga", 0,    0, "Irish"                       },
+  { "gd", 0,    0, "Gaelic Scots"                },
+  { "gl", 0,    0, "Galician"                    },
+  { "gl", "ES", 0, "Galician (Spain)"            },
+  { "gn", 0,    0, "Guarani"                     },
+  { "gu", 0,    0, "Gujarati"                    },
+  { "gv", 0,    0, "Manx"                        },
+  { "ha", 0,    0, "Hausa"                       },
+  { "he", 0,    0, "Hebrew"                      },
+  { "he", "IL", 0, "Hebrew (Israel)"             },
+  { "hi", 0,    0, "Hindi"                       },
+  { "hr", 0,    0, "Croatian"                    },
+  { "hr", "HR", 0, "Croatian (Croatia)"          },
+  { "hu", 0,    0, "Hungarian"                   },
+  { "hu", "HU", 0, "Hungarian (Hungary)"         },
+  { "hy", 0,    0, "Armenian"                    },
+  { "ia", 0,    0, "Interlingua"                 },
+  { "id", 0,    0, "Indonesian"                  },
+  { "id", "ID", 0, "Indonesian (Indonesia)"      },
+  { "is", 0,    0, "Icelandic"                   },
+  { "is", "IS", 0, "Icelandic (Iceland)"         },
+  { "it", 0,    0, "Italian"                     },
+  { "it", "CH", 0, "Italian (Switzerland)"       },
+  { "it", "IT", 0, "Italian (Italy)"             },
+  { "iu", 0,    0, "Inuktitut"                   },
+  { "ja", 0,    0, "Japanese"                    },
+  { "ja", "JP", 0, "Japanese (Japan)"            },
+  { "ka", 0,    0, "Georgian"                    },
+  { "kk", 0,    0, "Kazakh"                      },
+  { "kl", 0,    0, "Kalaallisut"                 },
+  { "km", 0,    0, "Khmer"                       },
+  { "km", "KH", 0, "Khmer (Cambodia)"            },
+  { "kn", 0,    0, "Kannada"                     },
+  { "ko", 0,    0, "Korean"                      },
+  { "ko", "KR", 0, "Korean (Korea)"              },
+  { "ku", 0,    0, "Kurdish"                     },
+  { "kw", 0,    0, "Cornish"                     },
+  { "ky", 0,    0, "Kirghiz"                     },
+  { "la", 0,    0, "Latin"                       },
+  { "lo", 0,    0, "Lao"                         },
+  { "lt", 0,    0, "Lithuanian"                  },
+  { "lt", "LT", 0, "Lithuanian (Lithuania)"      },
+  { "lv", 0,    0, "Latvian"                     },
+  { "lv", "LV", 0, "Latvian (Latvia)"            },
+  { "mg", 0,    0, "Malagasy"                    },
+  { "mi", 0,    0, "Maori"                       },
+  { "mk", 0,    0, "Macedonian"                  },
+  { "mk", "MK", 0, "Macedonian (Macedonia)"      },
+  { "ml", 0,    0, "Malayalam"                   },
+  { "mn", 0,    0, "Mongolian"                   },
+  { "mr", 0,    0, "Marathi"                     },
+  { "ms", 0,    0, "Malay"                       },
+  { "ms", "MY", 0, "Malay (Malaysia)"            },
+  { "mt", 0,    0, "Maltese"                     },
+  { "my", 0,    0, "Burmese"                     },
+  { "my", "MM", 0, "Burmese (Myanmar)"           },
+  { "nb", 0,    0, "Norwegian Bokmal"            },
+  { "nb", "NO", 0, "Norwegian Bokmål (Norway)"   },
+  { "ne", 0,    0, "Nepali"                      },
+  { "nl", 0,    0, "Dutch"                       },
+  { "nl", "BE", 0, "Dutch (Belgium)"             },
+  { "nl", "NL", 0, "Dutch (Netherlands)"         },
+  { "nn", 0,    0, "Norwegian Nynorsk"           },
+  { "nn", "NO", 0, "Norwegian Nynorsk (Norway)"  },
+  { "no", 0,    0, "Norwegian"                   },
+  { "no", "NO", 0, "Norwegian (Norway)"          },
+  { "no", "NY", 0, "Norwegian (NY)"              },
+  { "nr", 0,    0, "Ndebele, South"              },
+  { "oc", 0,    0, "Occitan post 1500"           },
+  { "om", 0,    0, "Oromo"                       },
+  { "or", 0,    0, "Oriya"                       },
+  { "pa", 0,    0, "Punjabi"                     },
+  { "pl", 0,    0, "Polish"                      },
+  { "pl", "PL", 0, "Polish (Poland)"             },
+  { "ps", 0,    0, "Pashto"                      },
+  { "pt", 0,    0, "Portuguese"                  },
+  { "pt", "BR", 0, "Brazilian"                   },
+  { "pt", "PT", 0, "Portuguese (Portugal)"       },
+  { "qu", 0,    0, "Quechua"                     },
+  { "rm", 0,    0, "Rhaeto-Romance"              },
+  { "ro", 0,    0, "Romanian"                    },
+  { "ro", "RO", 0, "Romanian (Romania)"          },
+  { "ru", 0,    0, "Russian"                     },
+  { "ru", "RU", 0, "Russian (Russia"             },
+  { "rw", 0,    0, "Kinyarwanda"                 },
+  { "sa", 0,    0, "Sanskrit"                    },
+  { "sd", 0,    0, "Sindhi"                      },
+  { "se", 0,    0, "Sami"                        },
+  { "se", "NO", 0, "Sami (Norway)"               },
+  { "si", 0,    0, "Sinhalese"                   },
+  { "sk", 0,    0, "Slovak"                      },
+  { "sk", "SK", 0, "Slovak (Slovakia)"           },
+  { "sl", 0,    0, "Slovenian"                   },
+  { "sl", "SI", 0, "Slovenian (Slovenia)"        },
+  { "sl", "SL", 0, "Slovenian (Sierra Leone)"    },
+  { "sm", 0,    0, "Samoan"                      },
+  { "so", 0,    0, "Somali"                      },
+  { "sp", 0,    0, "Unknown language"            },
+  { "sq", 0,    0, "Albanian"                    },
+  { "sq", "AL", 0, "Albanian (Albania)"          },
+  { "sr", 0,    0, "Serbian"                     },
+  { "sr", "YU", 0, "Serbian (Yugoslavia)"        },
+  { "sr", 0,"ije", "Serbian"                     },
+  { "sr", 0, "latin", "Serbian"                  },
+  { "sr", 0, "Latn",  "Serbian"                  },
+  { "ss", 0,    0, "Swati"                       },
+  { "st", 0,    0, "Sotho"                       },
+  { "sv", 0,    0, "Swedish"                     },
+  { "sv", "SE", 0, "Swedish (Sweden)"            },
+  { "sv", "SV", 0, "Swedish (El Salvador)"       },
+  { "sw", 0,    0, "Swahili"                     },
+  { "ta", 0,    0, "Tamil"                       },
+  { "te", 0,    0, "Telugu"                      },
+  { "tg", 0,    0, "Tajik"                       },
+  { "th", 0,    0, "Thai"                        },
+  { "th", "TH", 0, "Thai (Thailand)"             },
+  { "ti", 0,    0, "Tigrinya"                    },
+  { "tk", 0,    0, "Turkmen"                     },
+  { "tl", 0,    0, "Tagalog"                     },
+  { "to", 0,    0, "Tonga"                       },
+  { "tr", 0,    0, "Turkish"                     },
+  { "tr", "TR", 0, "Turkish (Turkey)"            },
+  { "ts", 0,    0, "Tsonga"                      },
+  { "tt", 0,    0, "Tatar"                       },
+  { "ug", 0,    0, "Uighur"                      },
+  { "uk", 0,    0, "Ukrainian"                   },
+  { "uk", "UA", 0, "Ukrainian (Ukraine)"         },
+  { "ur", 0,    0, "Urdu"                        },
+  { "ur", "PK", 0, "Urdu (Pakistan)"             },
+  { "uz", 0,    0, "Uzbek"                       },
+  { "uz", 0, "cyrillic", "Uzbek"                 },
+  { "vi", 0,    0, "Vietnamese"                  },
+  { "vi", "VN", 0, "Vietnamese (Vietnam)"        },
+  { "wa", 0,    0, "Walloon"                     },
+  { "wo", 0,    0, "Wolof"                       },
+  { "xh", 0,    0, "Xhosa"                       },
+  { "yi", 0,    0, "Yiddish"                     },
+  { "yo", 0,    0, "Yoruba"                      },
+  { "zh", 0,    0, "Chinese"                     },
+  { "zh", "CN", 0, "Chinese (simplified)"        },
+  { "zh", "HK", 0, "Chinese (Hong Kong)"         },
+  { "zh", "TW", 0, "Chinese (traditional)"       },
+  { "zu", 0,    0, "Zulu"                        },
+  { NULL, 0,    0, NULL                          }
+};
+//*}
+
+std::string
+resolve_language_alias(const std::string& name)
+{
+  typedef std::map<std::string, std::string> Aliases;
+  static Aliases language_aliases;
+  if (language_aliases.empty())
+  {
+    // FIXME: Many of those are not useful for us, since we leave
+    // encoding to the app, not to the language, we could/should
+    // also match against all language names, not just aliases from
+    // locale.alias
+
+    // Aliases taken from /etc/locale.alias
+    language_aliases["bokmal"]           = "nb_NO.ISO-8859-1";
+    language_aliases["bokmål"]           = "nb_NO.ISO-8859-1";
+    language_aliases["catalan"]          = "ca_ES.ISO-8859-1";
+    language_aliases["croatian"]         = "hr_HR.ISO-8859-2";
+    language_aliases["czech"]            = "cs_CZ.ISO-8859-2";
+    language_aliases["danish"]           = "da_DK.ISO-8859-1";
+    language_aliases["dansk"]            = "da_DK.ISO-8859-1";
+    language_aliases["deutsch"]          = "de_DE.ISO-8859-1";
+    language_aliases["dutch"]            = "nl_NL.ISO-8859-1";
+    language_aliases["eesti"]            = "et_EE.ISO-8859-1";
+    language_aliases["estonian"]         = "et_EE.ISO-8859-1";
+    language_aliases["finnish"]          = "fi_FI.ISO-8859-1";
+    language_aliases["français"]         = "fr_FR.ISO-8859-1";
+    language_aliases["french"]           = "fr_FR.ISO-8859-1";
+    language_aliases["galego"]           = "gl_ES.ISO-8859-1";
+    language_aliases["galician"]         = "gl_ES.ISO-8859-1";
+    language_aliases["german"]           = "de_DE.ISO-8859-1";
+    language_aliases["greek"]            = "el_GR.ISO-8859-7";
+    language_aliases["hebrew"]           = "he_IL.ISO-8859-8";
+    language_aliases["hrvatski"]         = "hr_HR.ISO-8859-2";
+    language_aliases["hungarian"]        = "hu_HU.ISO-8859-2";
+    language_aliases["icelandic"]        = "is_IS.ISO-8859-1";
+    language_aliases["italian"]          = "it_IT.ISO-8859-1";
+    language_aliases["japanese"]         = "ja_JP.eucJP";
+    language_aliases["japanese.euc"]     = "ja_JP.eucJP";
+    language_aliases["ja_JP"]            = "ja_JP.eucJP";
+    language_aliases["ja_JP.ujis"]       = "ja_JP.eucJP";
+    language_aliases["japanese.sjis"]    = "ja_JP.SJIS";
+    language_aliases["korean"]           = "ko_KR.eucKR";
+    language_aliases["korean.euc"]       = "ko_KR.eucKR";
+    language_aliases["ko_KR"]            = "ko_KR.eucKR";
+    language_aliases["lithuanian"]       = "lt_LT.ISO-8859-13";
+    language_aliases["no_NO"]            = "nb_NO.ISO-8859-1";
+    language_aliases["no_NO.ISO-8859-1"] = "nb_NO.ISO-8859-1";
+    language_aliases["norwegian"]        = "nb_NO.ISO-8859-1";
+    language_aliases["nynorsk"]          = "nn_NO.ISO-8859-1";
+    language_aliases["polish"]           = "pl_PL.ISO-8859-2";
+    language_aliases["portuguese"]       = "pt_PT.ISO-8859-1";
+    language_aliases["romanian"]         = "ro_RO.ISO-8859-2";
+    language_aliases["russian"]          = "ru_RU.ISO-8859-5";
+    language_aliases["slovak"]           = "sk_SK.ISO-8859-2";
+    language_aliases["slovene"]          = "sl_SI.ISO-8859-2";
+    language_aliases["slovenian"]        = "sl_SI.ISO-8859-2";
+    language_aliases["spanish"]          = "es_ES.ISO-8859-1";
+    language_aliases["swedish"]          = "sv_SE.ISO-8859-1";
+    language_aliases["thai"]             = "th_TH.TIS-620";
+    language_aliases["turkish"]          = "tr_TR.ISO-8859-9";
+  }
+
+  std::string name_lowercase;
+  name_lowercase.resize(name.size());
+  for(std::string::size_type i = 0; i < name.size(); ++i)
+    name_lowercase[i] = static_cast<char>(tolower(name[i]));
+
+  Aliases::iterator i = language_aliases.find(name_lowercase);
+  if (i != language_aliases.end()) 
+  {
+    return i->second;
+  }
+  else
+  {
+    return name;
+  }
+}
+
+Language
+Language::from_spec(const std::string& language, const std::string& country, const std::string& modifier)
+{
+  static std::map<std::string, std::vector<LanguageSpec*> > language_map;
+
+  if (language_map.empty())
+  { // Init language_map
+    for(int i = 0; languages[i].language != NULL; ++i)
+      language_map[languages[i].language].push_back(&languages[i]);
+  }
+  
+  std::map<std::string, std::vector<LanguageSpec*> >::iterator i = language_map.find(language);
+  if (i != language_map.end())
+  {
+    std::vector<LanguageSpec*>& lst = i->second;
+
+    LanguageSpec tmpspec;
+    tmpspec.language = language.c_str();
+    tmpspec.country  = country.c_str();
+    tmpspec.modifier = modifier.c_str();
+    Language tmplang(&tmpspec);
+      
+    LanguageSpec* best_match = 0;
+    int best_match_score = 0;
+    for(std::vector<LanguageSpec*>::iterator j = lst.begin(); j != lst.end(); ++j)
+    { // Search for the language that best matches the given spec, value country more then modifier
+      int score = Language::match(Language(*j), tmplang);
+
+      if (score > best_match_score)
+      {
+        best_match = *j;
+        best_match_score = score;
+      }
+    }
+    assert(best_match);
+    return Language(best_match);
+  }
+  else
+  {
+    return Language();
+  }
+}
+
+Language
+Language::from_name(const std::string& spec_str)
+{
+  return from_env(resolve_language_alias(spec_str));
+}
+
+Language
+Language::from_env(const std::string& env)
+{
+  // Split LANGUAGE_COUNTRY.CODESET@MODIFIER into parts
+  std::string::size_type ln = env.find('_');
+  std::string::size_type dt = env.find('.');
+  std::string::size_type at = env.find('@');
+
+  std::string language;
+  std::string country;
+  std::string codeset;
+  std::string modifier;
+
+  //std::cout << ln << " " << dt << " " << at << std::endl;
+
+  language = env.substr(0, std::min(std::min(ln, dt), at));
+
+  if (ln != std::string::npos && ln+1 < env.size()) // _
+  {
+    country = env.substr(ln+1, (std::min(dt, at) == std::string::npos) ? std::string::npos : std::min(dt, at) - (ln+1));
+  }
+
+  if (dt != std::string::npos && dt+1 < env.size()) // .
+  {
+    codeset = env.substr(dt+1, (at == std::string::npos) ? std::string::npos : (at - (dt+1)));
+  }
+
+  if (at != std::string::npos && at+1 < env.size()) // @
+  {
+    modifier = env.substr(at+1);
+  }
+
+  return from_spec(language, country, modifier);
+}
+
+Language::Language(LanguageSpec* language_spec_)
+  : language_spec(language_spec_)
+{
+}
+
+Language::Language()
+  : language_spec(0)
+{
+}
+
+int
+Language::match(const Language& lhs, const Language& rhs)
+{
+  if (lhs.get_language() != rhs.get_language())
+  {
+    return 0;
+  }
+  else
+  {
+    static int match_tbl[3][3] = {
+      // modifier match, wildchard, miss
+      { 9, 8, 5 }, // country match
+      { 7, 6, 3 }, // country wildcard
+      { 4, 2, 1 }, // country miss
+    };
+  
+    int c;
+    if (lhs.get_country() == rhs.get_country())
+      c = 0;
+    else if (lhs.get_country().empty() || rhs.get_country().empty())
+      c = 1;
+    else
+      c = 2;
+  
+    int m;
+    if (lhs.get_modifier() == rhs.get_modifier())
+      m = 0;
+    else if (lhs.get_modifier().empty() || rhs.get_modifier().empty())
+      m = 1;
+    else
+      m = 2;
+
+    return match_tbl[c][m];
+  }
+}
+
+std::string
+Language::get_language() const
+{
+  if (language_spec)
+    return language_spec->language;
+  else
+    return "";
+}
+
+std::string
+Language::get_country()  const
+{
+  if (language_spec && language_spec->country)
+    return language_spec->country;
+  else
+    return "";
+}
+
+std::string
+Language::get_modifier() const
+{
+  if (language_spec && language_spec->modifier)
+    return language_spec->modifier;
+  else
+    return "";
+}
+
+std::string
+Language::get_name()  const
+{
+  if (language_spec)
+    return language_spec->name;
+  else
+    return "";
+}
+
+std::string
+Language::str() const
+{
+  if (language_spec)
+  {
+    std::string var;
+    var += language_spec->language;
+    if (language_spec->country)
+    {
+      var += "_";
+      var += language_spec->country;
+    }
+
+    if (language_spec->modifier)
+    {
+      var += "@";
+      var += language_spec->modifier;
+    }
+    return var;
+  }
+  else
+  {
+    return "";
+  }
+}
+
+bool
+Language::operator==(const Language& rhs) const
+{
+  return language_spec == rhs.language_spec;
+}
+
+bool
+Language::operator!=(const Language& rhs) const
+{
+  return language_spec != rhs.language_spec;
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/.svn/text-base/language.hpp.svn-base

@@ -0,0 +1,91 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_LANGUAGE_HPP
+#define HEADER_TINYGETTEXT_LANGUAGE_HPP
+
+#include <string>
+
+namespace tinygettext {
+
+struct LanguageSpec;
+
+/** Lightweight wrapper around LanguageSpec */
+class Language
+{
+private:
+  LanguageSpec* language_spec;
+
+  Language(LanguageSpec* language_spec);
+
+public:
+  /** Create a language from language and country code:
+      Example: Languge("de", "DE"); */
+  static Language from_spec(const std::string& language, 
+                            const std::string& country = std::string(), 
+                            const std::string& modifier = std::string());
+
+  /** Create a language from language and country code:
+      Example: Languge("deutsch"); 
+      Example: Languge("de_DE"); */
+  static Language from_name(const std::string& str);
+
+  /** Create a language from an environment variable style string (e.g de_DE.UTF-8@modifier) */
+  static Language from_env(const std::string& env);
+
+  /** Compares two Languages, returns 0 on missmatch and a score
+      between 1 and 9 on match, the higher the score the better the
+      match */
+  static int match(const Language& lhs, const Language& rhs);
+
+  /** Create an undefined Language object */
+  Language();
+  
+  operator bool() const { return language_spec; }
+
+  /** Returns the language code (i.e. de, en, fr) */
+  std::string get_language() const;
+
+  /** Returns the country code (i.e. DE, AT, US) */
+  std::string get_country()  const;
+
+  /** Returns the modifier of the language (i.e. latn or Latn for
+      Serbian with non-cyrilic characters) */
+  std::string get_modifier()  const;
+
+  /** Returns the human readable name of the Language */
+  std::string get_name() const;
+
+  /** Returns the Language as string in the form of an environment
+      variable: {language}_{country}@{modifier} */
+  std::string str() const;
+
+  bool operator==(const Language& rhs) const;
+  bool operator!=(const Language& rhs) const;
+
+  friend bool operator<(const Language& lhs, const Language& rhs);
+};
+
+inline bool operator<(const Language& lhs, const Language& rhs) {
+  return lhs.language_spec < rhs.language_spec;
+}
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/.svn/text-base/log.cpp.svn-base

@@ -0,0 +1,70 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include <iostream>
+#include "log.hpp"
+
+namespace tinygettext {
+
+Log::log_callback_t Log::log_info_callback    = &Log::default_log_callback;
+Log::log_callback_t Log::log_warning_callback = &Log::default_log_callback;
+Log::log_callback_t Log::log_error_callback   = &Log::default_log_callback;
+
+void
+Log::default_log_callback(const std::string& str)
+{
+  std::cerr << "tinygettext: " << str;
+}
+
+void
+Log::set_log_info_callback(log_callback_t callback)
+{
+  log_info_callback = callback;
+}
+
+void
+Log::set_log_warning_callback(log_callback_t callback)
+{
+  log_warning_callback = callback;
+}
+
+void
+Log::set_log_error_callback(log_callback_t callback)
+{
+  log_error_callback = callback;
+}
+
+Log::Log(log_callback_t callback_) :
+  callback(callback_),
+  out()
+{
+}
+
+Log::~Log() 
+{
+  callback(out.str());
+}
+
+std::ostream&
+Log::get() 
+{
+  return out; 
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/.svn/text-base/log.hpp.svn-base

@@ -0,0 +1,56 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_LOG_HPP
+#define HEADER_TINYGETTEXT_LOG_HPP
+
+#include <sstream>
+
+namespace tinygettext {
+
+class Log
+{
+public:
+  typedef void (*log_callback_t)(const std::string&);
+
+  static log_callback_t log_info_callback;
+  static log_callback_t log_warning_callback;
+  static log_callback_t log_error_callback;
+
+
+  static void default_log_callback(const std::string& str);
+
+  static void set_log_info_callback(log_callback_t callback);
+  static void set_log_warning_callback(log_callback_t callback);
+  static void set_log_error_callback(log_callback_t callback);
+
+private:
+  log_callback_t callback;
+  std::ostringstream out;
+
+public:
+  Log(log_callback_t callback);
+  ~Log();
+  
+  std::ostream& get();
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/.svn/text-base/log_stream.hpp.svn-base

@@ -0,0 +1,34 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_LOG_STREAM_HPP
+#define HEADER_TINYGETTEXT_LOG_STREAM_HPP
+
+#include "log.hpp"
+
+namespace tinygettext {
+
+// FIXME: very bad to have such things in the API
+#define log_error   if (!Log::log_error_callback);   else (Log(Log::log_error_callback)).get()
+#define log_warning if (!Log::log_warning_callback); else (Log(Log::log_warning_callback)).get()
+#define log_info    if (!Log::log_info_callback);    else (Log(Log::log_warning_callback)).get()
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/.svn/text-base/plural_forms.cpp.svn-base

@@ -0,0 +1,89 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "plural_forms.hpp"
+
+#include <map>
+
+namespace tinygettext {
+
+/** 
+ *  Plural functions are used to select a string that matches a given
+ *  count. \a n is the count and the return value is the string index
+ *  used in the .po file, for example:
+ *   
+ *   msgstr[0] = "You got %d error";
+ *   msgstr[1] = "You got %d errors";        
+ *          ^-- return value of plural function 
+ */
+unsigned int plural1(int )     { return 0; }
+unsigned int plural2_1(int n)  { return (n != 1); }
+unsigned int plural2_2(int n)  { return (n > 1); }
+unsigned int plural2_mk(int n) { return n==1 || n%10==1 ? 0 : 1; }
+unsigned int plural3_lv(int n) { return static_cast<unsigned int>(n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2); }
+unsigned int plural3_ga(int n) { return static_cast<unsigned int>(n==1 ? 0 : n==2 ? 1 : 2); }
+unsigned int plural3_lt(int n) { return static_cast<unsigned int>(n%10==1 && n%100!=11 ? 0 : n%10>=2 && (n%100<10 || n%100>=20) ? 1 : 2); }
+unsigned int plural3_1(int n)  { return static_cast<unsigned int>(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2); }
+unsigned int plural3_sk(int n) { return static_cast<unsigned int>( (n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2 ); }
+unsigned int plural3_pl(int n) { return static_cast<unsigned int>(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2); }
+unsigned int plural3_sl(int n) { return static_cast<unsigned int>(n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3); }
+unsigned int plural4_ar(int n) { return static_cast<unsigned int>( n==1 ? 0 : n==2 ? 1 : n>=3 && n<=10 ? 2 : 3 ); }
+
+PluralForms
+PluralForms::from_string(const std::string& str)
+{
+  static std::map<std::string, struct PluralForms> plural_forms;
+    
+  if (plural_forms.empty())
+  {
+    // Note that the plural forms here shouldn't contain any spaces
+    plural_forms["Plural-Forms:nplurals=1;plural=0;"] = PluralForms(1, plural1);
+    plural_forms["Plural-Forms:nplurals=2;plural=(n!=1);"] = PluralForms(2, plural2_1);
+    plural_forms["Plural-Forms:nplurals=2;plural=n!=1;"] = PluralForms(2, plural2_1);
+    plural_forms["Plural-Forms:nplurals=2;plural=(n>1);"] = PluralForms(2, plural2_2);
+    plural_forms["Plural-Forms:nplurals=2;plural=n==1||n%10==1?0:1;"] = PluralForms(2, plural2_mk);
+    plural_forms["Plural-Forms:nplurals=3;plural=n%10==1&&n%100!=11?0:n!=0?1:2);"] = PluralForms(2, plural3_lv);
+    plural_forms["Plural-Forms:nplurals=3;plural=n==1?0:n==2?1:2;"] = PluralForms(3, plural3_ga);
+    plural_forms["Plural-Forms:nplurals=3;plural=(n%10==1&&n%100!=11?0:n%10>=2&&(n%100<10||n%100>=20)?1:2);"] = PluralForms(3, plural3_lt);
+    plural_forms["Plural-Forms:nplurals=3;plural=(n%10==1&&n%100!=11?0:n%10>=2&&n%10<=4&&(n%100<10||n%100>=20)?1:2);"] = PluralForms(3, plural3_1);
+    plural_forms["Plural-Forms:nplurals=3;plural=(n==1)?0:(n>=2&&n<=4)?1:2;"] = PluralForms(3, plural3_sk);
+    plural_forms["Plural-Forms:nplurals=3;plural=(n==1?0:n%10>=2&&n%10<=4&&(n%100<10||n%100>=20)?1:2);"] = PluralForms(3, plural3_pl);
+    plural_forms["Plural-Forms:nplurals=3;plural=(n%100==1?0:n%100==2?1:n%100==3||n%100==4?2:3);"] = PluralForms(3, plural3_sl);
+
+    plural_forms["Plural-Forms:nplurals=4;plural=n==1?0:n==2?1:n>=3&&n<=10?2:3;"]=PluralForms(4, plural4_ar);
+  }
+  
+  // Remove spaces from string before lookup
+  std::string space_less_str;
+  for(std::string::size_type i = 0; i < str.size(); ++i)
+    if (!isspace(str[i]))
+      space_less_str += str[i];
+  
+  std::map<std::string, struct PluralForms>::const_iterator it= plural_forms.find(space_less_str);
+  if (it != plural_forms.end())
+  {
+    return it->second;
+  }
+  else
+  {
+    return PluralForms();
+  }
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/.svn/text-base/plural_forms.hpp.svn-base

@@ -0,0 +1,61 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_PLURAL_FORMS_HPP
+#define HEADER_TINYGETTEXT_PLURAL_FORMS_HPP
+
+#include <string>
+
+namespace tinygettext {
+
+typedef unsigned int (*PluralFunc)(int n);
+
+class PluralForms
+{
+private:
+  unsigned int nplural;
+  PluralFunc   plural;
+
+public:
+  static PluralForms from_string(const std::string& str);
+
+  PluralForms()
+    : nplural(0),
+      plural(0)
+  {}
+
+  PluralForms(unsigned int nplural_, PluralFunc plural_)
+    : nplural(nplural_), 
+      plural(plural_)
+  {}
+
+  unsigned int get_nplural() const { return nplural; }
+  unsigned int get_plural(int n) const { if (plural) return plural(n); else return 0; }
+
+  bool operator==(const PluralForms& other) { return nplural == other.nplural && plural == other.plural; }
+  bool operator!=(const PluralForms& other) { return !(*this == other); }
+
+  operator bool() const {
+    return plural;
+  }
+};
+
+} // namespace tinygettext
+
+#endif 
+
+/* EOF */

tinygettext/.svn/text-base/po_parser.cpp.svn-base

@@ -0,0 +1,496 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "po_parser.hpp"
+
+#include <iostream>
+#include <ctype.h>
+#include <string>
+#include <istream>
+#include <string.h>
+#include <map>
+#include <stdlib.h>
+
+#include "language.hpp"
+#include "log_stream.hpp"
+#include "iconv.hpp"
+#include "dictionary.hpp"
+#include "plural_forms.hpp"
+
+namespace tinygettext {
+
+bool POParser::pedantic = true;
+
+void
+POParser::parse(const std::string& filename, std::istream& in, Dictionary& dict)
+{
+  POParser parser(filename, in, dict);
+  parser.parse();
+}
+
+class POParserError {};
+
+POParser::POParser(const std::string& filename_, std::istream& in_, Dictionary& dict_, bool use_fuzzy_) :
+  filename(filename_), 
+  in(in_), 
+  dict(dict_), 
+  use_fuzzy(use_fuzzy_),
+  running(false), 
+  eof(false), 
+  big5(false),
+  line_number(0), 
+  current_line(), 
+  conv()
+{
+}
+
+POParser::~POParser()
+{
+}
+
+void
+POParser::warning(const std::string& msg)
+{
+  log_warning << filename << ":" << line_number << ": warning: " << msg << ": " << current_line << std::endl;
+  //log_warning << "Line: " << current_line << std::endl;
+}
+
+void
+POParser::error(const std::string& msg)
+{
+  log_error << filename << ":" << line_number << ": error: " << msg  << ": " << current_line << std::endl;
+
+  // Try to recover from an error by searching for start of another entry
+  do
+    next_line();
+  while(!eof && !is_empty_line());
+
+  throw POParserError();
+}
+
+void
+POParser::next_line()
+{
+  line_number += 1;
+  if (!std::getline(in, current_line))
+    eof = true;
+}
+
+void
+POParser::get_string_line(std::ostringstream& out,unsigned int skip)
+{
+  if (skip+1 >= static_cast<unsigned int>(current_line.size()))
+    error("unexpected end of line");
+
+  if (current_line[skip] != '"')
+    error("expected start of string '\"'");
+  
+  std::string::size_type i;
+  for(i = skip+1; current_line[i] != '\"'; ++i)
+  {
+    if (big5 && static_cast<unsigned char>(current_line[i]) >= 0x81 && static_cast<unsigned char>(current_line[i]) <= 0xfe)
+    {
+      out << current_line[i];
+
+      i += 1;
+          
+      if (i >= current_line.size())
+        error("invalid big5 encoding");
+          
+      out << current_line[i];
+    }
+    else if (i >= current_line.size())
+    {
+      error("unexpected end of string");
+    }
+    else if (current_line[i] == '\\')
+    {
+      i += 1;
+
+      if (i >= current_line.size())
+        error("unexpected end of string in handling '\\'");
+
+      switch (current_line[i])
+      {
+        case 'a':  out << '\a'; break;
+        case 'b':  out << '\b'; break;
+        case 'v':  out << '\v'; break;
+        case 'n':  out << '\n'; break;
+        case 't':  out << '\t'; break;
+        case 'r':  out << '\r'; break;
+        case '"':  out << '"'; break;
+        case '\\': out << '\\'; break;
+        default: 
+          std::ostringstream err;
+          err << "unhandled escape '\\" << current_line[i] << "'";
+          warning(err.str());
+
+          out << current_line[i-1] << current_line[i];
+          break;
+      }
+    }
+    else
+    {
+      out << current_line[i];
+    }
+  }
+
+  // process trailing garbage in line and warn if there is any
+  for(i = i+1; i < current_line.size(); ++i)
+    if (!isspace(current_line[i]))
+    {
+      warning("unexpected garbage after string ignoren");
+      break;
+    }
+}
+
+std::string
+POParser::get_string(unsigned int skip)
+{
+  std::ostringstream out;
+
+  if (skip+1 >= static_cast<unsigned int>(current_line.size()))
+    error("unexpected end of line");
+
+  if (current_line[skip] == ' ' && current_line[skip+1] == '"')
+  {
+    get_string_line(out, skip+1);
+  }
+  else
+  {
+    if (pedantic)
+      warning("keyword and string must be seperated by a single space");
+
+    for(;;)
+    {
+      if (skip >= static_cast<unsigned int>(current_line.size()))
+        error("unexpected end of line");
+      else if (current_line[skip] == '\"')
+      {
+        get_string_line(out, skip);
+        break;
+      }
+      else if (!isspace(current_line[skip]))
+      {
+        error("string must start with '\"'");
+      }
+      else
+      {
+        // skip space
+      }
+
+      skip += 1;
+    }
+  }
+  
+next:
+  next_line();
+  for(std::string::size_type i = 0; i < current_line.size(); ++i)
+  {
+    if (current_line[i] == '"')
+    {
+      if (i == 1)
+        if (pedantic)
+          warning("leading whitespace before string");
+
+      get_string_line(out, i);
+      goto next;
+    }
+    else if (isspace(current_line[i]))
+    {
+      // skip
+    }
+    else
+    {
+      break;
+    }
+  }
+
+  return out.str();
+}
+
+static bool has_prefix(const std::string& lhs, const std::string rhs)
+{
+  if (lhs.length() < rhs.length())
+    return false;
+  else
+    return lhs.compare(0, rhs.length(), rhs) == 0;
+}
+
+void
+POParser::parse_header(const std::string& header)
+{
+  std::string from_charset;
+  std::string::size_type start = 0;
+  for(std::string::size_type i = 0; i < header.length(); ++i)
+  {
+    if (header[i] == '\n')
+    {
+      std::string line = header.substr(start, i - start);
+
+      if (has_prefix(line, "Content-Type:"))
+      {
+        // from_charset = line.substr(len);
+        unsigned int len = strlen("Content-Type: text/plain; charset=");
+        if (line.compare(0, len, "Content-Type: text/plain; charset=") == 0)
+        {
+          from_charset = line.substr(len);
+
+          for(std::string::iterator ch = from_charset.begin(); ch != from_charset.end(); ++ch)
+            *ch = static_cast<char>(toupper(*ch));
+        }
+        else
+        {
+          warning("malformed Content-Type header");
+        }
+      }
+      else if (has_prefix(line, "Plural-Forms:"))
+      {
+        PluralForms plural_forms = PluralForms::from_string(line);
+        if (!plural_forms)
+        {
+          warning("unknown Plural-Forms given");
+        }
+        else
+        {
+          if (!dict.get_plural_forms())
+          {
+            dict.set_plural_forms(plural_forms);
+          }
+          else
+          {
+            if (dict.get_plural_forms() != plural_forms)
+            {
+              warning("Plural-Forms missmatch between .po file and dictionary");
+            }
+          }
+        }
+      }
+      start = i+1;
+    }
+  }
+
+  if (from_charset.empty() || from_charset == "CHARSET")
+  {
+    warning("charset not specified for .po, fallback to utf-8");
+    from_charset = "UTF-8";
+  }
+  else if (from_charset == "BIG5")
+  {
+    big5 = true;
+  }
+
+  conv.set_charsets(from_charset, dict.get_charset());
+}
+
+bool
+POParser::is_empty_line()
+{
+  if (current_line.empty())
+  {
+    return true;
+  }
+  else if (current_line[0] == '#')
+  { // handle comments as empty lines
+    if (current_line.size() == 1 || (current_line.size() >= 2 && isspace(current_line[1])))
+      return true;
+    else
+      return false;
+  }
+  else
+  {
+    for(std::string::iterator i = current_line.begin(); i != current_line.end(); ++i)
+    {
+      if (!isspace(*i))
+        return false;
+    }
+  }
+  return true;
+}
+
+bool
+POParser::prefix(const char* prefix_str)
+{
+  return current_line.compare(0, strlen(prefix_str), prefix_str) == 0;
+}
+
+void
+POParser::parse()
+{
+  next_line();
+
+  // skip UTF-8 intro that some text editors produce
+  // see http://en.wikipedia.org/wiki/Byte-order_mark
+  if (current_line.size() >= 3 &&
+      current_line[0] == static_cast<char>(0xef) &&
+      current_line[1] == static_cast<char>(0xbb) &&
+      current_line[2] == static_cast<char>(0xbf))
+  {
+    current_line = current_line.substr(3);
+  }
+
+  // Parser structure
+  while(!eof)
+  {
+    try 
+    {
+      bool fuzzy =  false;
+      bool has_msgctxt = false;
+      std::string msgctxt;
+      std::string msgid;
+
+      while(prefix("#"))
+      {
+        if (current_line.size() >= 2 && current_line[1] == ',')
+        {
+          // FIXME: Rather simplistic hunt for fuzzy flag
+          if (current_line.find("fuzzy", 2) != std::string::npos)
+            fuzzy = true;
+        }
+
+        next_line();
+      }
+
+      if (!is_empty_line())
+      {
+        if (prefix("msgctxt"))
+        {
+          has_msgctxt = true;
+          msgctxt = get_string(7);
+        }
+
+        if (prefix("msgid"))
+          msgid = get_string(5);
+        else
+          error("expected 'msgid'");
+
+        if (prefix("msgid_plural"))
+        {
+          std::string msgid_plural = get_string(12);
+          std::vector<std::string> msgstr_num;
+	  bool saw_nonempty_msgstr = false;
+
+        next:
+          if (is_empty_line())
+          {
+            if (msgstr_num.empty())
+              error("expected 'msgstr[N] (0 <= N <= 9)'");
+          }
+          else if (prefix("msgstr[") &&
+                   current_line.size() > 8 && 
+                   isdigit(current_line[7]) && current_line[8] == ']')
+          {
+            unsigned int number = static_cast<unsigned int>(current_line[7] - '0');
+	    std::string msgstr = get_string(9);
+
+	    if(!msgstr.empty())
+	      saw_nonempty_msgstr = true;
+
+            if (number >= msgstr_num.size())
+              msgstr_num.resize(number+1);
+
+            msgstr_num[number] = conv.convert(msgstr);
+            goto next;
+          }
+          else 
+          {
+            error("expected 'msgstr[N]'");
+          }
+
+          if (!is_empty_line())
+            error("expected 'msgstr[N]' or empty line");
+
+	  if (saw_nonempty_msgstr)
+	  {
+	    if (use_fuzzy || !fuzzy)
+            {
+	      if (!dict.get_plural_forms())
+	      {
+		warning("msgstr[N] seen, but no Plural-Forms given");
+	      }
+	      else
+	      {
+		if (msgstr_num.size() != dict.get_plural_forms().get_nplural())
+		{
+		  warning("msgstr[N] count doesn't match Plural-Forms.nplural");
+		}
+	      }
+
+	      if (has_msgctxt)
+		dict.add_translation(msgctxt, msgid, msgid_plural, msgstr_num);
+	      else
+		dict.add_translation(msgid, msgid_plural, msgstr_num);
+	    }
+
+	    if (0)
+	    {
+	      std::cout << (fuzzy?"fuzzy":"not-fuzzy") << std::endl;
+	      std::cout << "msgid \"" << msgid << "\"" << std::endl;
+	      std::cout << "msgid_plural \"" << msgid_plural << "\"" << std::endl;
+	      for(std::vector<std::string>::size_type i = 0; i < msgstr_num.size(); ++i)
+		std::cout << "msgstr[" << i << "] \"" << conv.convert(msgstr_num[i]) << "\"" << std::endl;
+	      std::cout << std::endl;
+	    }
+	  }
+        }
+        else if (prefix("msgstr"))
+        {
+          std::string msgstr = get_string(6);
+
+          if (msgid.empty())
+          {
+            parse_header(msgstr);
+          }
+          else if(!msgstr.empty())
+          {
+            if (use_fuzzy || !fuzzy)
+            {
+              if (has_msgctxt)
+                dict.add_translation(msgctxt, msgid, conv.convert(msgstr));
+              else
+                dict.add_translation(msgid, conv.convert(msgstr));
+            }
+
+            if (0)
+            {
+              std::cout << (fuzzy?"fuzzy":"not-fuzzy") << std::endl;
+              std::cout << "msgid \"" << msgid << "\"" << std::endl;
+              std::cout << "msgstr \"" << conv.convert(msgstr) << "\"" << std::endl;
+              std::cout << std::endl;
+            }
+          }
+        }
+        else
+        {
+          error("expected 'msgstr' or 'msgid_plural'");
+        }
+      }
+      
+      if (!is_empty_line())
+        error("expected empty line");
+
+      next_line();
+    }
+    catch(POParserError&)
+    {          
+    }
+  }
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/.svn/text-base/po_parser.hpp.svn-base

@@ -0,0 +1,75 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_PO_PARSER_HPP
+#define HEADER_TINYGETTEXT_PO_PARSER_HPP
+
+#include <iosfwd>
+
+#include "iconv.hpp"
+
+namespace tinygettext {
+
+class Dictionary;
+
+class POParser
+{
+private:
+  std::string filename;
+  std::istream& in;
+  Dictionary& dict;
+  bool  use_fuzzy;
+
+  bool running;
+  bool eof;
+  bool big5;
+
+  int line_number;
+  std::string current_line;
+
+  IConv conv;
+  
+  POParser(const std::string& filename, std::istream& in_, Dictionary& dict_, bool use_fuzzy = true);
+  ~POParser();
+
+  void parse_header(const std::string& header);
+  void parse();
+  void next_line();
+  std::string get_string(unsigned int skip);
+  void get_string_line(std::ostringstream& str,unsigned int skip);
+  bool is_empty_line();
+  bool prefix(const char* );
+  void error(const std::string& msg) __attribute__((__noreturn__));
+  void warning(const std::string& msg);
+
+public:
+  /** @param filename name of the istream, only used in error messages
+      @param in stream from which the PO file is read.
+      @param dict dictionary to which the strings are written */
+  static void parse(const std::string& filename, std::istream& in, Dictionary& dict);
+  static bool pedantic;
+
+private:
+  POParser (const POParser&);
+  POParser& operator= (const POParser&);
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/.svn/text-base/tinygettext.cpp.svn-base

@@ -0,0 +1,22 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+namespace tinygettext {
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/.svn/text-base/tinygettext.hpp.svn-base

@@ -0,0 +1,27 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_TINYGETTEXT_HPP
+#define HEADER_TINYGETTEXT_TINYGETTEXT_HPP
+
+#include "dictionary.hpp"
+#include "dictionary_manager.hpp"
+#include "language.hpp"
+
+#endif
+
+/* EOF */

tinygettext/.svn/text-base/unix_file_system.cpp.svn-base

@@ -0,0 +1,65 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "unix_file_system.hpp"
+
+#include <sys/types.h>
+#include <fstream>
+#include <dirent.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <string.h>
+
+namespace tinygettext {
+
+UnixFileSystem::UnixFileSystem()
+{
+}
+
+std::vector<std::string>
+UnixFileSystem::open_directory(const std::string& pathname)
+{
+  DIR* dir = opendir(pathname.c_str());
+  if (!dir)
+  {
+    // FIXME: error handling
+    return std::vector<std::string>();
+  }
+  else
+  {
+    std::vector<std::string> files;
+
+    struct dirent* dp;
+    while((dp = readdir(dir)) != 0)
+    {
+      files.push_back(dp->d_name);
+    }
+    closedir(dir);
+
+    return files;
+  }
+}
+  
+std::auto_ptr<std::istream>
+UnixFileSystem::open_file(const std::string& filename)
+{
+  return std::auto_ptr<std::istream>(new std::ifstream(filename.c_str()));
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/.svn/text-base/unix_file_system.hpp.svn-base

@@ -0,0 +1,38 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_UNIX_FILE_SYSTEM_HPP
+#define HEADER_TINYGETTEXT_UNIX_FILE_SYSTEM_HPP
+
+#include "file_system.hpp"
+
+namespace tinygettext {
+
+class UnixFileSystem : public FileSystem
+{
+public:
+  UnixFileSystem();
+
+  std::vector<std::string>    open_directory(const std::string& pathname);
+  std::auto_ptr<std::istream> open_file(const std::string& filename);
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/dictionary.cpp

@@ -0,0 +1,208 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include <assert.h>
+#include "log_stream.hpp"
+#include "dictionary.hpp"
+
+namespace tinygettext {
+
+Dictionary::Dictionary(const std::string& charset_) :
+  entries(),
+  ctxt_entries(),
+  charset(charset_),
+  plural_forms()
+{
+}
+
+Dictionary::~Dictionary()
+{
+}
+
+std::string
+Dictionary::get_charset() const
+{
+  return charset;
+}
+
+void
+Dictionary::set_plural_forms(const PluralForms& plural_forms_)
+{
+  plural_forms = plural_forms_;
+}
+
+PluralForms
+Dictionary::get_plural_forms() const
+{
+  return plural_forms;
+}
+
+std::string
+Dictionary::translate_plural(const std::string& msgid, const std::string& msgid_plural, int num)
+{
+  return translate_plural(entries, msgid, msgid_plural, num);
+}
+
+std::string
+Dictionary::translate_plural(const Entries& dict, const std::string& msgid, const std::string& msgid_plural, int count)
+{
+  Entries::const_iterator i = dict.find(msgid);
+  const std::vector<std::string>& msgstrs = i->second;
+
+  if (i != dict.end())
+  {
+    unsigned int n = 0;
+    n = plural_forms.get_plural(count);
+    assert(/*n >= 0 &&*/ n < msgstrs.size());
+
+    if (!msgstrs[n].empty())
+      return msgstrs[n];
+    else
+      if (count == 1) // default to english rules
+        return msgid;
+      else
+        return msgid_plural;
+  }
+  else
+  {
+    log_info << "Couldn't translate: " << msgid << std::endl;
+    log_info << "Candidates: " << std::endl;
+    for (i = dict.begin(); i != dict.end(); ++i)
+      log_info << "'" << i->first << "'" << std::endl;
+
+    if (count == 1) // default to english rules
+      return msgid;
+    else
+      return msgid_plural;
+  }
+}
+
+std::string
+Dictionary::translate(const std::string& msgid)
+{
+  return translate(entries, msgid);
+}
+
+std::string
+Dictionary::translate(const Entries& dict, const std::string& msgid)
+{
+  Entries::const_iterator i = dict.find(msgid);
+  if (i != dict.end() && !i->second.empty())
+  {
+    return i->second[0];
+  }
+  else
+  {
+    log_info << "Couldn't translate: " << msgid << std::endl;
+    return msgid;
+  } 
+}
+
+std::string
+Dictionary::translate_ctxt(const std::string& msgctxt, const std::string& msgid)
+{
+  CtxtEntries::iterator i = ctxt_entries.find(msgctxt);
+  if (i != ctxt_entries.end())
+  {
+    return translate(i->second, msgid);
+  }
+  else
+  {
+    log_info << "Couldn't translate: " << msgid << std::endl;
+    return msgid;
+  }
+}
+
+std::string
+Dictionary::translate_ctxt_plural(const std::string& msgctxt, 
+                                  const std::string& msgid, const std::string& msgidplural, int num)
+{
+  CtxtEntries::iterator i = ctxt_entries.find(msgctxt);
+  if (i != ctxt_entries.end())
+  {
+    return translate_plural(i->second, msgid, msgidplural, num);
+  }
+  else
+  {
+    log_info << "Couldn't translate: " << msgid << std::endl;
+    if (num != 1) // default to english
+      return msgidplural;
+    else
+      return msgid;
+  }
+}
+
+void
+Dictionary::add_translation(const std::string& msgid, const std::string& ,
+                            const std::vector<std::string>& msgstrs)
+{
+  // Do we need msgid2 for anything? its after all supplied to the
+  // translate call, so we just throw it away here
+  entries[msgid] = msgstrs;
+}
+
+void
+Dictionary::add_translation(const std::string& msgid, const std::string& msgstr)
+{
+  std::vector<std::string>& vec = entries[msgid];
+  if (vec.empty())
+  {
+    vec.push_back(msgstr);
+  }
+  else
+  {
+    log_warning << "collision in add_translation: '" 
+                << msgid << "' -> '" << msgstr << "' vs '" << vec[0] << "'" << std::endl;
+    vec[0] = msgstr;
+  }
+}
+
+void
+Dictionary::add_translation(const std::string& msgctxt, 
+                            const std::string& msgid, const std::string& msgid_plural,
+                            const std::vector<std::string>& msgstrs)
+{
+  std::vector<std::string>& vec = ctxt_entries[msgctxt][msgid];
+  if (vec.empty())
+  {
+    vec = msgstrs;
+  }
+  else
+  {
+    log_warning << "collision in add_translation(\"" << msgctxt << "\", \"" << msgid << "\", \"" << msgid_plural << "\")" << std::endl;
+    vec = msgstrs;
+  }
+}
+
+void
+Dictionary::add_translation(const std::string& msgctxt, const std::string& msgid, const std::string& msgstr)
+{
+  std::vector<std::string>& vec = ctxt_entries[msgctxt][msgid];
+  if (vec.empty())
+  {
+    vec.push_back(msgstr);
+  }
+  else
+  {
+    log_warning << "collision in add_translation(\"" << msgctxt << "\", \"" << msgid << "\")" << std::endl;
+    vec[0] = msgstr;
+  }
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/dictionary.hpp

@@ -0,0 +1,123 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_DICTIONARY_HPP
+#define HEADER_TINYGETTEXT_DICTIONARY_HPP
+
+#include <map>
+#include <vector>
+#include <string>
+#include "plural_forms.hpp"
+
+namespace tinygettext {
+
+/** A simple dictionary class that mimics gettext() behaviour. Each
+    Dictionary only works for a single language, for managing multiple
+    languages and .po files at once use the DictionaryManager. */
+class Dictionary
+{
+private:
+  typedef std::map<std::string, std::vector<std::string> > Entries;
+  Entries entries;
+
+  typedef std::map<std::string, Entries> CtxtEntries;
+  CtxtEntries ctxt_entries;
+
+  std::string charset;
+  PluralForms plural_forms;
+
+  std::string translate(const Entries& dict, const std::string& msgid);
+  std::string translate_plural(const Entries& dict, const std::string& msgid, const std::string& msgidplural, int num);
+
+public:
+  /** Constructs a dictionary converting to the specified \a charset (default UTF-8) */
+  Dictionary(const std::string& charset = "UTF-8");
+  ~Dictionary();
+
+  /** Return the charset used for this dictionary */
+  std::string get_charset() const;
+
+  void set_plural_forms(const PluralForms&);
+  PluralForms get_plural_forms() const;
+
+
+  /** Translate the string \a msgid. */
+  std::string translate(const std::string& msgid);
+
+  /** Translate the string \a msgid to its correct plural form, based
+      on the number of items given by \a num. \a msgid_plural is \a msgid in
+      plural form. */
+  std::string translate_plural(const std::string& msgid, const std::string& msgidplural, int num);
+
+  /** Translate the string \a msgid that is in context \a msgctx. A
+      context is a way to disambiguate msgids that contain the same
+      letters, but different meaning. For example "exit" might mean to
+      quit doing something or it might refer to a door that leads
+      outside (i.e. 'Ausgang' vs 'Beenden' in german) */
+  std::string translate_ctxt(const std::string& msgctxt, const std::string& msgid);
+
+  std::string translate_ctxt_plural(const std::string& msgctxt, const std::string& msgid, const std::string& msgidplural, int num);
+
+  /** Add a translation from \a msgid to \a msgstr to the dictionary,
+      where \a msgid is the singular form of the message, msgid_plural the
+      plural form and msgstrs a table of translations. The right
+      translation will be calculated based on the \a num argument to
+      translate(). */
+  void add_translation(const std::string& msgid, const std::string& msgid_plural,
+                       const std::vector<std::string>& msgstrs);
+  void add_translation(const std::string& msgctxt, 
+                       const std::string& msgid, const std::string& msgid_plural,
+                       const std::vector<std::string>& msgstrs);
+
+  /** Add a translation from \a msgid to \a msgstr to the
+      dictionary */
+  void add_translation(const std::string& msgid, const std::string& msgstr);
+  void add_translation(const std::string& msgctxt, const std::string& msgid, const std::string& msgstr);
+
+  /** Iterate over all messages, Func is of type:
+      void func(const std::string& msgid, const std::vector<std::string>& msgstrs) */
+  template<class Func>
+  Func foreach(Func func) 
+  {
+    for(Entries::iterator i = entries.begin(); i != entries.end(); ++i)
+    {
+      func(i->first, i->second);
+    }
+    return func;
+  }
+
+  /** Iterate over all messages with a context, Func is of type:
+      void func(const std::string& ctxt, const std::string& msgid, const std::vector<std::string>& msgstrs) */
+  template<class Func>
+  Func foreach_ctxt(Func func) 
+  {
+    for(CtxtEntries::iterator i = ctxt_entries.begin(); i != ctxt_entries.end(); ++i)
+    {
+      for(Entries::iterator j = i->second.begin(); j != i->second.end(); ++j)
+      {
+        func(i->first, j->first, j->second);
+      }
+    }
+    return func;
+  }
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/dictionary_manager.cpp

@@ -0,0 +1,242 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "dictionary_manager.hpp"
+
+#include <memory>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fstream>
+#include <algorithm>
+
+#include "log_stream.hpp"
+#include "po_parser.hpp"
+#include "unix_file_system.hpp"
+
+namespace tinygettext {
+
+static bool has_suffix(const std::string& lhs, const std::string rhs)
+{
+  if (lhs.length() < rhs.length())
+    return false;
+  else
+    return lhs.compare(lhs.length() - rhs.length(), rhs.length(), rhs) == 0;
+}
+
+DictionaryManager::DictionaryManager(const std::string& charset_) :
+  dictionaries(),
+  search_path(),
+  charset(charset_),
+  use_fuzzy(true),
+  current_language(),
+  current_dict(0),
+  empty_dict(),
+  filesystem(new UnixFileSystem)
+{
+}
+
+DictionaryManager::~DictionaryManager()
+{
+  for(Dictionaries::iterator i = dictionaries.begin(); i != dictionaries.end(); ++i)
+  {
+    delete i->second;
+  }
+}
+
+void
+DictionaryManager::clear_cache()
+{
+  for(Dictionaries::iterator i = dictionaries.begin(); i != dictionaries.end(); ++i)
+  {
+    delete i->second;
+  }
+  dictionaries.clear();
+
+  current_dict = 0;
+}
+
+Dictionary&
+DictionaryManager::get_dictionary()
+{
+  if (current_dict)
+  {
+    return *current_dict; 
+  }
+  else
+  {
+    if (current_language)
+    {
+      current_dict = &get_dictionary(current_language);
+      return *current_dict;
+    }
+    else
+    {
+      return empty_dict;
+    }
+  }
+}
+
+Dictionary&
+DictionaryManager::get_dictionary(const Language& language)
+{
+  //log_debug << "Dictionary for language \"" << spec << "\" requested" << std::endl;
+  //log_debug << "...normalized as \"" << lang << "\"" << std::endl;
+  assert(language);
+
+  Dictionaries::iterator i = dictionaries.find(language); 
+  if (i != dictionaries.end())
+  {
+    return *i->second;
+  }
+  else // Dictionary for languages lang isn't loaded, so we load it
+  {
+    //log_debug << "get_dictionary: " << lang << std::endl;
+    Dictionary* dict = new Dictionary(charset);
+
+    dictionaries[language] = dict;
+
+    for (SearchPath::reverse_iterator p = search_path.rbegin(); p != search_path.rend(); ++p)
+    {
+      std::vector<std::string> files = filesystem->open_directory(*p);
+
+      std::string best_filename;
+      int best_score = 0;
+
+      for(std::vector<std::string>::iterator filename = files.begin(); filename != files.end(); filename++)
+      {
+        // check if filename matches requested language
+        if (has_suffix(*filename, ".po"))
+        { // ignore anything that isn't a .po file
+          Language po_language = Language::from_env(filename->substr(0, filename->size()-3));
+
+          if (!po_language)
+          {
+            log_warning << *filename << ": warning: ignoring, unknown language" << std::endl;
+          }
+          else
+          {
+            int score = Language::match(language, po_language);
+                          
+            if (score > best_score)
+            {
+              best_score = score;
+              best_filename = *filename;
+            }
+          }
+        }
+      }
+              
+      if (!best_filename.empty())
+      {
+        std::string pofile = *p + "/" + best_filename;
+        try 
+        {
+          std::auto_ptr<std::istream> in = filesystem->open_file(pofile);
+          if (!in.get())
+          {
+            log_error << "error: failure opening: " << pofile << std::endl;
+          }
+          else
+          {
+            POParser::parse(pofile, *in, *dict);
+          }
+        }
+        catch(std::exception& e) 
+        {
+          log_error << "error: failure parsing: " << pofile << std::endl;
+          log_error << e.what() << "" << std::endl;
+        }
+      }
+    }
+
+    return *dict;
+  }
+}
+
+std::set<Language>
+DictionaryManager::get_languages()
+{
+  std::set<Language> languages;
+
+  for (SearchPath::iterator p = search_path.begin(); p != search_path.end(); ++p)
+  {
+    std::vector<std::string> files = filesystem->open_directory(*p);
+
+    for(std::vector<std::string>::iterator file = files.begin(); file != files.end(); ++file)
+    {
+      if (has_suffix(*file, ".po")) 
+      {
+        languages.insert(Language::from_env(file->substr(0, file->size()-3)));
+      }
+    }
+  }
+  return languages;
+}
+
+void
+DictionaryManager::set_language(const Language& language)
+{
+  if (current_language != language)
+  {
+    current_language = language;
+    current_dict     = 0;
+  }
+}
+
+Language
+DictionaryManager::get_language() const
+{
+  return current_language;
+}
+
+void
+DictionaryManager::set_charset(const std::string& charset_)
+{
+  clear_cache(); // changing charset invalidates cache
+  charset = charset_;
+}
+
+void
+DictionaryManager::set_use_fuzzy(bool t)
+{
+  clear_cache();
+  use_fuzzy = t;
+}
+
+bool
+DictionaryManager::get_use_fuzzy() const
+{
+  return use_fuzzy;
+}
+
+void
+DictionaryManager::add_directory(const std::string& pathname)
+{
+  clear_cache(); // adding directories invalidates cache
+  search_path.push_back(pathname);
+}
+
+void
+DictionaryManager::set_filesystem(std::auto_ptr<FileSystem> filesystem_)
+{
+  filesystem = filesystem_;
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/dictionary_manager.hpp

@@ -0,0 +1,99 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_DICTIONARY_MANAGER_HPP
+#define HEADER_TINYGETTEXT_DICTIONARY_MANAGER_HPP
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <memory>
+
+#include "dictionary.hpp"
+#include "language.hpp"
+
+namespace tinygettext {
+
+class FileSystem;
+
+/** Manager class for dictionaries, you give it a bunch of directories
+    with .po files and it will then automatically load the right file
+    on demand depending on which language was set. */
+class DictionaryManager
+{
+private:
+  typedef std::map<Language, Dictionary*> Dictionaries;
+  Dictionaries dictionaries;
+
+  typedef std::vector<std::string> SearchPath;
+  SearchPath search_path;
+
+  std::string charset;
+  bool        use_fuzzy;
+  
+  Language    current_language;
+  Dictionary* current_dict;
+
+  Dictionary  empty_dict;
+
+  std::auto_ptr<FileSystem> filesystem;
+
+  void clear_cache();
+
+public:
+  DictionaryManager(const std::string& charset_ = "UTF-8");
+  ~DictionaryManager();
+
+  /** Return the currently active dictionary, if none is set, an empty
+      dictionary is returned. */
+  Dictionary& get_dictionary();
+
+  /** Get dictionary for language */
+  Dictionary& get_dictionary(const Language& language);
+
+  /** Set a language based on a four? letter country code */
+  void set_language(const Language& language);
+
+  /** returns the (normalized) country code of the currently used language */
+  Language get_language() const;
+
+  void set_use_fuzzy(bool t);
+  bool get_use_fuzzy() const;
+
+  /** Set a charset that will be set on the returned dictionaries */
+  void set_charset(const std::string& charset);
+
+  /** Add a directory to the search path for dictionaries, earlier
+      added directories have higher priority then later added ones */
+  void add_directory(const std::string& pathname);
+
+  /** Return a set of the available languages in their country code */
+  std::set<Language> get_languages();
+
+  void set_filesystem(std::auto_ptr<FileSystem> filesystem);
+
+private:
+  DictionaryManager (const DictionaryManager&);
+  DictionaryManager& operator= (const DictionaryManager&);
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/file_system.hpp

@@ -0,0 +1,42 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_FILE_SYSTEM_HPP
+#define HEADER_TINYGETTEXT_FILE_SYSTEM_HPP
+
+#include <vector>
+#include <memory>
+#include <iosfwd>
+#include <string>
+
+namespace tinygettext {
+
+class FileSystem 
+{
+public:
+  virtual ~FileSystem() {}
+
+  virtual std::vector<std::string>    open_directory(const std::string& pathname) =0;
+  virtual std::auto_ptr<std::istream> open_file(const std::string& filename)      =0;
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */
+

tinygettext/iconv.cpp

@@ -0,0 +1,148 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include <ctype.h>
+#include <assert.h>
+#include <sstream>
+#include <errno.h>
+#include <stdexcept>
+#include <string.h>
+#include <stdlib.h>
+
+#include "iconv.hpp"
+#include "log_stream.hpp"
+
+namespace tinygettext {
+
+#ifndef tinygettext_ICONV_CONST
+#  define tinygettext_ICONV_CONST 
+#endif
+
+IConv::IConv() 
+  : to_charset(),
+    from_charset(),
+    cd(0)
+{}
+ 
+IConv::IConv(const std::string& from_charset_, const std::string& to_charset_)
+  : to_charset(),
+    from_charset(),
+    cd(0)
+{
+  set_charsets(from_charset_, to_charset_);
+}
+ 
+IConv::~IConv()
+{
+  if (cd)
+    tinygettext_iconv_close(cd);
+}
+ 
+void
+IConv::set_charsets(const std::string& from_charset_, const std::string& to_charset_)
+{
+  if (cd)
+    tinygettext_iconv_close(cd);
+
+  from_charset = from_charset_;
+  to_charset   = to_charset_;
+
+  for(std::string::iterator i = to_charset.begin(); i != to_charset.end(); ++i)
+    *i = static_cast<char>(toupper(*i));
+
+  for(std::string::iterator i = from_charset.begin(); i != from_charset.end(); ++i)
+    *i = static_cast<char>(toupper(*i));
+
+  if (to_charset == from_charset)
+  {
+    cd = 0;
+  }
+  else
+  {
+    cd = tinygettext_iconv_open(to_charset.c_str(), from_charset.c_str());
+    if (cd == reinterpret_cast<tinygettext_iconv_t>(-1))
+    {
+      if(errno == EINVAL)
+      {
+        std::ostringstream str;
+        str << "IConv construction failed: conversion from '" << from_charset
+            << "' to '" << to_charset << "' not available";
+        throw std::runtime_error(str.str());
+      }
+      else
+      {
+        std::ostringstream str;
+        str << "IConv: construction failed: " << strerror(errno);
+        throw std::runtime_error(str.str());
+      }
+    }
+  }
+}
+
+/// Convert a string from encoding to another.
+std::string
+IConv::convert(const std::string& text)
+{
+  if (!cd)
+  {
+    return text;
+  }
+  else
+  {
+    size_t inbytesleft  = text.size();
+    size_t outbytesleft = 4*inbytesleft; // Worst case scenario: ASCII -> UTF-32?
+
+    // We try to avoid to much copying around, so we write directly into
+    // a std::string
+    tinygettext_ICONV_CONST char* inbuf = const_cast<char*>(&text[0]);
+    std::string result(outbytesleft, 'X');
+    char* outbuf = &result[0]; 
+  
+    // Try to convert the text.
+    size_t ret = tinygettext_iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
+    if (ret == static_cast<size_t>(-1))
+    {
+      if (errno == EILSEQ || errno == EINVAL)
+      { // invalid multibyte sequence
+        tinygettext_iconv(cd, NULL, NULL, NULL, NULL); // reset state
+
+        // FIXME: Could try to skip the invalid byte and continue
+        log_error << "error: tinygettext:iconv: invalid multibyte sequence in:  \"" << text << "\"" << std::endl;
+      }
+      else if (errno == E2BIG)
+      { // output buffer to small
+        assert(!"tinygettext/iconv.cpp: E2BIG: This should never be reached");
+      }
+      else if (errno == EBADF)
+      {
+        assert(!"tinygettext/iconv.cpp: EBADF: This should never be reached");
+      }
+      else
+      {
+        assert(!"tinygettext/iconv.cpp: <unknown>: This should never be reached");
+      }
+    }
+
+    result.resize(4*text.size() - outbytesleft);
+
+    return result;
+  }
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/iconv.hpp

@@ -0,0 +1,71 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//  
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//  
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef HEADER_TINYGETTEXT_ICONV_HPP
+#define HEADER_TINYGETTEXT_ICONV_HPP
+
+#include <string>
+
+#ifdef HAVE_SDL
+#  include "SDL.h"
+
+#  define tinygettext_ICONV_CONST const
+#  define tinygettext_iconv_t     SDL_iconv_t
+#  define tinygettext_iconv       SDL_iconv
+#  define tinygettext_iconv_open  SDL_iconv_open
+#  define tinygettext_iconv_close SDL_iconv_close 
+#else
+#  include <iconv.h>
+
+#  ifdef HAVE_ICONV_CONST
+#    define tinygettext_ICONV_CONST ICONV_CONST
+#  else
+#    define tinygettext_ICONV_CONST 
+#  endif
+
+#  define tinygettext_iconv_t     iconv_t
+#  define tinygettext_iconv       iconv
+#  define tinygettext_iconv_open  iconv_open
+#  define tinygettext_iconv_close iconv_close 
+#endif
+
+namespace tinygettext {
+
+class IConv
+{
+private:
+  std::string to_charset;
+  std::string from_charset;
+  tinygettext_iconv_t cd;
+
+public:
+  IConv();
+  IConv(const std::string& fromcode, const std::string& tocode);
+  ~IConv();
+
+  void set_charsets(const std::string& fromcode, const std::string& tocode);
+  std::string convert(const std::string& text);
+
+private:
+  IConv (const IConv&);
+  IConv& operator= (const IConv&);
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/language.cpp

@@ -0,0 +1,568 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "language.hpp"
+
+#include <map>
+#include <assert.h>
+#include <vector>
+
+namespace tinygettext {
+
+struct LanguageSpec {
+  /** Language code: "de", "en", ... */
+  const char* language;
+
+  /** Country code: "BR", "DE", ..., can be 0 */
+  const char* country;
+
+  /** Modifier/Varint: "Latn", "ije", "latin"..., can be 0 */
+  const char* modifier;
+
+  /** Language name: "German", "English", "French", ... */
+  const char* name;
+};
+
+/** Language Definitions */
+//*{
+LanguageSpec languages[] = {
+  { "aa", 0,    0, "Afar"                        },
+  { "af", 0,    0, "Afrikaans"                   },
+  { "af", "ZA", 0, "Afrikaans (South Africa)"    },
+  { "am", 0,    0, "Amharic"                     },
+  { "ar", 0,    0, "Arabic"                      },
+  { "ar", "AR", 0, "Arabic (Argentina)"          },
+  { "ar", "OM", 0, "Arabic (Oman)"               },
+  { "ar", "SA", 0, "Arabic (Saudi Arabia)"       },
+  { "ar", "SY", 0, "Arabic (Syrian Arab Republic)" },
+  { "ar", "TN", 0, "Arabic (Tunisia)"            },
+  { "as", 0,    0, "Assamese"                    },
+  { "ast",0,    0, "Asturian"                    },
+  { "ay", 0,    0, "Aymara"                      },
+  { "az", 0,    0, "Azerbaijani"                 },
+  { "az", "IR", 0, "Azerbaijani (Iran)"          },
+  { "be", 0,    0, "Belarusian"                  },
+  { "be", 0, "latin", "Belarusian"               },
+  { "bg", 0,    0, "Bulgarian"                   },
+  { "bg", "BG", 0, "Bulgarian (Bulgaria)"        },
+  { "bn", 0,    0, "Bengali"                     },
+  { "bn", "BD", 0, "Bengali (Bangladesh)"        },
+  { "bn", "IN", 0, "Bengali (India)"             },
+  { "bo", 0,    0, "Tibetan"                     },
+  { "br", 0,    0, "Breton"                      },
+  { "bs", 0,    0, "Bosnian"                     },
+  { "bs", "BA", 0, "Bosnian (Bosnia/Herzegovina)"},
+  { "bs", "BS", 0, "Bosnian (Bahamas)"           },
+  { "ca", "ES", "valencia", "Catalan (valencia)" },
+  { "ca", "ES", 0, "Catalan (Spain)"             },
+  { "ca", 0,    "valencia", "Catalan (valencia)" },
+  { "ca", 0,    0, "Catalan"                     },
+  { "co", 0,    0, "Corsican"                    },
+  { "cs", 0,    0, "Czech"                       },
+  { "cs", "CZ", 0, "Czech (Czech Republic)"      },
+  { "cy", 0,    0, "Welsh"                       },
+  { "cy", "GB", 0, "Welsh (Great Britain)"       },
+  { "cz", 0,    0, "Unknown language"            },
+  { "da", 0,    0, "Danish"                      },
+  { "da", "DK", 0, "Danish (Denmark)"            },
+  { "de", 0,    0, "German"                      },
+  { "de", "AT", 0, "German (Austria)"            },
+  { "de", "CH", 0, "German (Switzerland)"        },
+  { "de", "DE", 0, "German (Germany)"            },
+  { "dk", 0,    0, "Unknown language"            },
+  { "dz", 0,    0, "Dzongkha"                    },
+  { "el", 0,    0, "Greek"                       },
+  { "el", "GR", 0, "Greek (Greece)"              },
+  { "en", 0,    0, "English"                     },
+  { "en", "AU", 0, "English (Australia)"         },
+  { "en", "CA", 0, "English (Canada)"            },
+  { "en", "GB", 0, "English (Great Britain)"     },
+  { "en", "US", 0, "English (United States)"     },
+  { "en", "ZA", 0, "English (South Africa)"      },
+  { "en", 0, "boldquot", "English"               },
+  { "en", 0, "quot", "English"                   },
+  { "en", "US", "piglatin", "English"            },
+  { "eo", 0,    0, "Esperanto"                   },
+  { "es", 0,    0, "Spanish"                     },
+  { "es", "AR", 0, "Spanish (Argentina)"         },
+  { "es", "CL", 0, "Spanish (Chile)"             },
+  { "es", "CO", 0, "Spanish (Colombia)"          },
+  { "es", "CR", 0, "Spanish (Costa Rica)"        },
+  { "es", "DO", 0, "Spanish (Dominican Republic)"},
+  { "es", "EC", 0, "Spanish (Ecuador)"           },
+  { "es", "ES", 0, "Spanish (Spain)"             },
+  { "es", "GT", 0, "Spanish (Guatemala)"         },
+  { "es", "HN", 0, "Spanish (Honduras)"          },
+  { "es", "LA", 0, "Spanish (Laos)"              },
+  { "es", "MX", 0, "Spanish (Mexico)"            },
+  { "es", "NI", 0, "Spanish (Nicaragua)"         },
+  { "es", "PA", 0, "Spanish (Panama)"            },
+  { "es", "PE", 0, "Spanish (Peru)"              },
+  { "es", "PR", 0, "Spanish (Puerto Rico)"       },
+  { "es", "SV", 0, "Spanish (El Salvador)"       },
+  { "es", "UY", 0, "Spanish (Uruguay)"           },
+  { "es", "VE", 0, "Spanish (Venezuela)"         },
+  { "et", 0,    0, "Estonian"                    },
+  { "et", "EE", 0, "Estonian (Estonia)"          },
+  { "et", "ET", 0, "Estonian (Ethiopia)"         },
+  { "eu", 0,    0, "Basque"                      },
+  { "eu", "ES", 0, "Basque (Spain)"              },
+  { "fa", 0,    0, "Persian"                     },
+  { "fa", "AF", 0, "Persian (Afghanistan)"       },
+  { "fa", "IR", 0, "Persian (Iran)"              },
+  { "fi", 0,    0, "Finnish"                     },
+  { "fi", "FI", 0, "Finnish (Finland)"           },
+  { "fo", 0,    0, "Faroese"                     },
+  { "fo", "FO", 0, "Faeroese (Faroe Islands)"    },
+  { "fr", 0,    0, "French"                      },
+  { "fr", "CA", 0, "French (Canada)"             },
+  { "fr", "CH", 0, "French (Switzerland)"        },
+  { "fr", "FR", 0, "French (France)"             },
+  { "fr", "LU", 0, "French (Luxembourg)"         },
+  { "fy", 0,    0, "Frisian"                     },
+  { "ga", 0,    0, "Irish"                       },
+  { "gd", 0,    0, "Gaelic Scots"                },
+  { "gl", 0,    0, "Galician"                    },
+  { "gl", "ES", 0, "Galician (Spain)"            },
+  { "gn", 0,    0, "Guarani"                     },
+  { "gu", 0,    0, "Gujarati"                    },
+  { "gv", 0,    0, "Manx"                        },
+  { "ha", 0,    0, "Hausa"                       },
+  { "he", 0,    0, "Hebrew"                      },
+  { "he", "IL", 0, "Hebrew (Israel)"             },
+  { "hi", 0,    0, "Hindi"                       },
+  { "hr", 0,    0, "Croatian"                    },
+  { "hr", "HR", 0, "Croatian (Croatia)"          },
+  { "hu", 0,    0, "Hungarian"                   },
+  { "hu", "HU", 0, "Hungarian (Hungary)"         },
+  { "hy", 0,    0, "Armenian"                    },
+  { "ia", 0,    0, "Interlingua"                 },
+  { "id", 0,    0, "Indonesian"                  },
+  { "id", "ID", 0, "Indonesian (Indonesia)"      },
+  { "is", 0,    0, "Icelandic"                   },
+  { "is", "IS", 0, "Icelandic (Iceland)"         },
+  { "it", 0,    0, "Italian"                     },
+  { "it", "CH", 0, "Italian (Switzerland)"       },
+  { "it", "IT", 0, "Italian (Italy)"             },
+  { "iu", 0,    0, "Inuktitut"                   },
+  { "ja", 0,    0, "Japanese"                    },
+  { "ja", "JP", 0, "Japanese (Japan)"            },
+  { "ka", 0,    0, "Georgian"                    },
+  { "kk", 0,    0, "Kazakh"                      },
+  { "kl", 0,    0, "Kalaallisut"                 },
+  { "km", 0,    0, "Khmer"                       },
+  { "km", "KH", 0, "Khmer (Cambodia)"            },
+  { "kn", 0,    0, "Kannada"                     },
+  { "ko", 0,    0, "Korean"                      },
+  { "ko", "KR", 0, "Korean (Korea)"              },
+  { "ku", 0,    0, "Kurdish"                     },
+  { "kw", 0,    0, "Cornish"                     },
+  { "ky", 0,    0, "Kirghiz"                     },
+  { "la", 0,    0, "Latin"                       },
+  { "lo", 0,    0, "Lao"                         },
+  { "lt", 0,    0, "Lithuanian"                  },
+  { "lt", "LT", 0, "Lithuanian (Lithuania)"      },
+  { "lv", 0,    0, "Latvian"                     },
+  { "lv", "LV", 0, "Latvian (Latvia)"            },
+  { "mg", 0,    0, "Malagasy"                    },
+  { "mi", 0,    0, "Maori"                       },
+  { "mk", 0,    0, "Macedonian"                  },
+  { "mk", "MK", 0, "Macedonian (Macedonia)"      },
+  { "ml", 0,    0, "Malayalam"                   },
+  { "mn", 0,    0, "Mongolian"                   },
+  { "mr", 0,    0, "Marathi"                     },
+  { "ms", 0,    0, "Malay"                       },
+  { "ms", "MY", 0, "Malay (Malaysia)"            },
+  { "mt", 0,    0, "Maltese"                     },
+  { "my", 0,    0, "Burmese"                     },
+  { "my", "MM", 0, "Burmese (Myanmar)"           },
+  { "nb", 0,    0, "Norwegian Bokmal"            },
+  { "nb", "NO", 0, "Norwegian Bokmål (Norway)"   },
+  { "ne", 0,    0, "Nepali"                      },
+  { "nl", 0,    0, "Dutch"                       },
+  { "nl", "BE", 0, "Dutch (Belgium)"             },
+  { "nl", "NL", 0, "Dutch (Netherlands)"         },
+  { "nn", 0,    0, "Norwegian Nynorsk"           },
+  { "nn", "NO", 0, "Norwegian Nynorsk (Norway)"  },
+  { "no", 0,    0, "Norwegian"                   },
+  { "no", "NO", 0, "Norwegian (Norway)"          },
+  { "no", "NY", 0, "Norwegian (NY)"              },
+  { "nr", 0,    0, "Ndebele, South"              },
+  { "oc", 0,    0, "Occitan post 1500"           },
+  { "om", 0,    0, "Oromo"                       },
+  { "or", 0,    0, "Oriya"                       },
+  { "pa", 0,    0, "Punjabi"                     },
+  { "pl", 0,    0, "Polish"                      },
+  { "pl", "PL", 0, "Polish (Poland)"             },
+  { "ps", 0,    0, "Pashto"                      },
+  { "pt", 0,    0, "Portuguese"                  },
+  { "pt", "BR", 0, "Brazilian"                   },
+  { "pt", "PT", 0, "Portuguese (Portugal)"       },
+  { "qu", 0,    0, "Quechua"                     },
+  { "rm", 0,    0, "Rhaeto-Romance"              },
+  { "ro", 0,    0, "Romanian"                    },
+  { "ro", "RO", 0, "Romanian (Romania)"          },
+  { "ru", 0,    0, "Russian"                     },
+  { "ru", "RU", 0, "Russian (Russia"             },
+  { "rw", 0,    0, "Kinyarwanda"                 },
+  { "sa", 0,    0, "Sanskrit"                    },
+  { "sd", 0,    0, "Sindhi"                      },
+  { "se", 0,    0, "Sami"                        },
+  { "se", "NO", 0, "Sami (Norway)"               },
+  { "si", 0,    0, "Sinhalese"                   },
+  { "sk", 0,    0, "Slovak"                      },
+  { "sk", "SK", 0, "Slovak (Slovakia)"           },
+  { "sl", 0,    0, "Slovenian"                   },
+  { "sl", "SI", 0, "Slovenian (Slovenia)"        },
+  { "sl", "SL", 0, "Slovenian (Sierra Leone)"    },
+  { "sm", 0,    0, "Samoan"                      },
+  { "so", 0,    0, "Somali"                      },
+  { "sp", 0,    0, "Unknown language"            },
+  { "sq", 0,    0, "Albanian"                    },
+  { "sq", "AL", 0, "Albanian (Albania)"          },
+  { "sr", 0,    0, "Serbian"                     },
+  { "sr", "YU", 0, "Serbian (Yugoslavia)"        },
+  { "sr", 0,"ije", "Serbian"                     },
+  { "sr", 0, "latin", "Serbian"                  },
+  { "sr", 0, "Latn",  "Serbian"                  },
+  { "ss", 0,    0, "Swati"                       },
+  { "st", 0,    0, "Sotho"                       },
+  { "sv", 0,    0, "Swedish"                     },
+  { "sv", "SE", 0, "Swedish (Sweden)"            },
+  { "sv", "SV", 0, "Swedish (El Salvador)"       },
+  { "sw", 0,    0, "Swahili"                     },
+  { "ta", 0,    0, "Tamil"                       },
+  { "te", 0,    0, "Telugu"                      },
+  { "tg", 0,    0, "Tajik"                       },
+  { "th", 0,    0, "Thai"                        },
+  { "th", "TH", 0, "Thai (Thailand)"             },
+  { "ti", 0,    0, "Tigrinya"                    },
+  { "tk", 0,    0, "Turkmen"                     },
+  { "tl", 0,    0, "Tagalog"                     },
+  { "to", 0,    0, "Tonga"                       },
+  { "tr", 0,    0, "Turkish"                     },
+  { "tr", "TR", 0, "Turkish (Turkey)"            },
+  { "ts", 0,    0, "Tsonga"                      },
+  { "tt", 0,    0, "Tatar"                       },
+  { "ug", 0,    0, "Uighur"                      },
+  { "uk", 0,    0, "Ukrainian"                   },
+  { "uk", "UA", 0, "Ukrainian (Ukraine)"         },
+  { "ur", 0,    0, "Urdu"                        },
+  { "ur", "PK", 0, "Urdu (Pakistan)"             },
+  { "uz", 0,    0, "Uzbek"                       },
+  { "uz", 0, "cyrillic", "Uzbek"                 },
+  { "vi", 0,    0, "Vietnamese"                  },
+  { "vi", "VN", 0, "Vietnamese (Vietnam)"        },
+  { "wa", 0,    0, "Walloon"                     },
+  { "wo", 0,    0, "Wolof"                       },
+  { "xh", 0,    0, "Xhosa"                       },
+  { "yi", 0,    0, "Yiddish"                     },
+  { "yo", 0,    0, "Yoruba"                      },
+  { "zh", 0,    0, "Chinese"                     },
+  { "zh", "CN", 0, "Chinese (simplified)"        },
+  { "zh", "HK", 0, "Chinese (Hong Kong)"         },
+  { "zh", "TW", 0, "Chinese (traditional)"       },
+  { "zu", 0,    0, "Zulu"                        },
+  { NULL, 0,    0, NULL                          }
+};
+//*}
+
+std::string
+resolve_language_alias(const std::string& name)
+{
+  typedef std::map<std::string, std::string> Aliases;
+  static Aliases language_aliases;
+  if (language_aliases.empty())
+  {
+    // FIXME: Many of those are not useful for us, since we leave
+    // encoding to the app, not to the language, we could/should
+    // also match against all language names, not just aliases from
+    // locale.alias
+
+    // Aliases taken from /etc/locale.alias
+    language_aliases["bokmal"]           = "nb_NO.ISO-8859-1";
+    language_aliases["bokmål"]           = "nb_NO.ISO-8859-1";
+    language_aliases["catalan"]          = "ca_ES.ISO-8859-1";
+    language_aliases["croatian"]         = "hr_HR.ISO-8859-2";
+    language_aliases["czech"]            = "cs_CZ.ISO-8859-2";
+    language_aliases["danish"]           = "da_DK.ISO-8859-1";
+    language_aliases["dansk"]            = "da_DK.ISO-8859-1";
+    language_aliases["deutsch"]          = "de_DE.ISO-8859-1";
+    language_aliases["dutch"]            = "nl_NL.ISO-8859-1";
+    language_aliases["eesti"]            = "et_EE.ISO-8859-1";
+    language_aliases["estonian"]         = "et_EE.ISO-8859-1";
+    language_aliases["finnish"]          = "fi_FI.ISO-8859-1";
+    language_aliases["français"]         = "fr_FR.ISO-8859-1";
+    language_aliases["french"]           = "fr_FR.ISO-8859-1";
+    language_aliases["galego"]           = "gl_ES.ISO-8859-1";
+    language_aliases["galician"]         = "gl_ES.ISO-8859-1";
+    language_aliases["german"]           = "de_DE.ISO-8859-1";
+    language_aliases["greek"]            = "el_GR.ISO-8859-7";
+    language_aliases["hebrew"]           = "he_IL.ISO-8859-8";
+    language_aliases["hrvatski"]         = "hr_HR.ISO-8859-2";
+    language_aliases["hungarian"]        = "hu_HU.ISO-8859-2";
+    language_aliases["icelandic"]        = "is_IS.ISO-8859-1";
+    language_aliases["italian"]          = "it_IT.ISO-8859-1";
+    language_aliases["japanese"]         = "ja_JP.eucJP";
+    language_aliases["japanese.euc"]     = "ja_JP.eucJP";
+    language_aliases["ja_JP"]            = "ja_JP.eucJP";
+    language_aliases["ja_JP.ujis"]       = "ja_JP.eucJP";
+    language_aliases["japanese.sjis"]    = "ja_JP.SJIS";
+    language_aliases["korean"]           = "ko_KR.eucKR";
+    language_aliases["korean.euc"]       = "ko_KR.eucKR";
+    language_aliases["ko_KR"]            = "ko_KR.eucKR";
+    language_aliases["lithuanian"]       = "lt_LT.ISO-8859-13";
+    language_aliases["no_NO"]            = "nb_NO.ISO-8859-1";
+    language_aliases["no_NO.ISO-8859-1"] = "nb_NO.ISO-8859-1";
+    language_aliases["norwegian"]        = "nb_NO.ISO-8859-1";
+    language_aliases["nynorsk"]          = "nn_NO.ISO-8859-1";
+    language_aliases["polish"]           = "pl_PL.ISO-8859-2";
+    language_aliases["portuguese"]       = "pt_PT.ISO-8859-1";
+    language_aliases["romanian"]         = "ro_RO.ISO-8859-2";
+    language_aliases["russian"]          = "ru_RU.ISO-8859-5";
+    language_aliases["slovak"]           = "sk_SK.ISO-8859-2";
+    language_aliases["slovene"]          = "sl_SI.ISO-8859-2";
+    language_aliases["slovenian"]        = "sl_SI.ISO-8859-2";
+    language_aliases["spanish"]          = "es_ES.ISO-8859-1";
+    language_aliases["swedish"]          = "sv_SE.ISO-8859-1";
+    language_aliases["thai"]             = "th_TH.TIS-620";
+    language_aliases["turkish"]          = "tr_TR.ISO-8859-9";
+  }
+
+  std::string name_lowercase;
+  name_lowercase.resize(name.size());
+  for(std::string::size_type i = 0; i < name.size(); ++i)
+    name_lowercase[i] = static_cast<char>(tolower(name[i]));
+
+  Aliases::iterator i = language_aliases.find(name_lowercase);
+  if (i != language_aliases.end()) 
+  {
+    return i->second;
+  }
+  else
+  {
+    return name;
+  }
+}
+
+Language
+Language::from_spec(const std::string& language, const std::string& country, const std::string& modifier)
+{
+  static std::map<std::string, std::vector<LanguageSpec*> > language_map;
+
+  if (language_map.empty())
+  { // Init language_map
+    for(int i = 0; languages[i].language != NULL; ++i)
+      language_map[languages[i].language].push_back(&languages[i]);
+  }
+  
+  std::map<std::string, std::vector<LanguageSpec*> >::iterator i = language_map.find(language);
+  if (i != language_map.end())
+  {
+    std::vector<LanguageSpec*>& lst = i->second;
+
+    LanguageSpec tmpspec;
+    tmpspec.language = language.c_str();
+    tmpspec.country  = country.c_str();
+    tmpspec.modifier = modifier.c_str();
+    Language tmplang(&tmpspec);
+      
+    LanguageSpec* best_match = 0;
+    int best_match_score = 0;
+    for(std::vector<LanguageSpec*>::iterator j = lst.begin(); j != lst.end(); ++j)
+    { // Search for the language that best matches the given spec, value country more then modifier
+      int score = Language::match(Language(*j), tmplang);
+
+      if (score > best_match_score)
+      {
+        best_match = *j;
+        best_match_score = score;
+      }
+    }
+    assert(best_match);
+    return Language(best_match);
+  }
+  else
+  {
+    return Language();
+  }
+}
+
+Language
+Language::from_name(const std::string& spec_str)
+{
+  return from_env(resolve_language_alias(spec_str));
+}
+
+Language
+Language::from_env(const std::string& env)
+{
+  // Split LANGUAGE_COUNTRY.CODESET@MODIFIER into parts
+  std::string::size_type ln = env.find('_');
+  std::string::size_type dt = env.find('.');
+  std::string::size_type at = env.find('@');
+
+  std::string language;
+  std::string country;
+  std::string codeset;
+  std::string modifier;
+
+  //std::cout << ln << " " << dt << " " << at << std::endl;
+
+  language = env.substr(0, std::min(std::min(ln, dt), at));
+
+  if (ln != std::string::npos && ln+1 < env.size()) // _
+  {
+    country = env.substr(ln+1, (std::min(dt, at) == std::string::npos) ? std::string::npos : std::min(dt, at) - (ln+1));
+  }
+
+  if (dt != std::string::npos && dt+1 < env.size()) // .
+  {
+    codeset = env.substr(dt+1, (at == std::string::npos) ? std::string::npos : (at - (dt+1)));
+  }
+
+  if (at != std::string::npos && at+1 < env.size()) // @
+  {
+    modifier = env.substr(at+1);
+  }
+
+  return from_spec(language, country, modifier);
+}
+
+Language::Language(LanguageSpec* language_spec_)
+  : language_spec(language_spec_)
+{
+}
+
+Language::Language()
+  : language_spec(0)
+{
+}
+
+int
+Language::match(const Language& lhs, const Language& rhs)
+{
+  if (lhs.get_language() != rhs.get_language())
+  {
+    return 0;
+  }
+  else
+  {
+    static int match_tbl[3][3] = {
+      // modifier match, wildchard, miss
+      { 9, 8, 5 }, // country match
+      { 7, 6, 3 }, // country wildcard
+      { 4, 2, 1 }, // country miss
+    };
+  
+    int c;
+    if (lhs.get_country() == rhs.get_country())
+      c = 0;
+    else if (lhs.get_country().empty() || rhs.get_country().empty())
+      c = 1;
+    else
+      c = 2;
+  
+    int m;
+    if (lhs.get_modifier() == rhs.get_modifier())
+      m = 0;
+    else if (lhs.get_modifier().empty() || rhs.get_modifier().empty())
+      m = 1;
+    else
+      m = 2;
+
+    return match_tbl[c][m];
+  }
+}
+
+std::string
+Language::get_language() const
+{
+  if (language_spec)
+    return language_spec->language;
+  else
+    return "";
+}
+
+std::string
+Language::get_country()  const
+{
+  if (language_spec && language_spec->country)
+    return language_spec->country;
+  else
+    return "";
+}
+
+std::string
+Language::get_modifier() const
+{
+  if (language_spec && language_spec->modifier)
+    return language_spec->modifier;
+  else
+    return "";
+}
+
+std::string
+Language::get_name()  const
+{
+  if (language_spec)
+    return language_spec->name;
+  else
+    return "";
+}
+
+std::string
+Language::str() const
+{
+  if (language_spec)
+  {
+    std::string var;
+    var += language_spec->language;
+    if (language_spec->country)
+    {
+      var += "_";
+      var += language_spec->country;
+    }
+
+    if (language_spec->modifier)
+    {
+      var += "@";
+      var += language_spec->modifier;
+    }
+    return var;
+  }
+  else
+  {
+    return "";
+  }
+}
+
+bool
+Language::operator==(const Language& rhs) const
+{
+  return language_spec == rhs.language_spec;
+}
+
+bool
+Language::operator!=(const Language& rhs) const
+{
+  return language_spec != rhs.language_spec;
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/language.hpp

@@ -0,0 +1,91 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_LANGUAGE_HPP
+#define HEADER_TINYGETTEXT_LANGUAGE_HPP
+
+#include <string>
+
+namespace tinygettext {
+
+struct LanguageSpec;
+
+/** Lightweight wrapper around LanguageSpec */
+class Language
+{
+private:
+  LanguageSpec* language_spec;
+
+  Language(LanguageSpec* language_spec);
+
+public:
+  /** Create a language from language and country code:
+      Example: Languge("de", "DE"); */
+  static Language from_spec(const std::string& language, 
+                            const std::string& country = std::string(), 
+                            const std::string& modifier = std::string());
+
+  /** Create a language from language and country code:
+      Example: Languge("deutsch"); 
+      Example: Languge("de_DE"); */
+  static Language from_name(const std::string& str);
+
+  /** Create a language from an environment variable style string (e.g de_DE.UTF-8@modifier) */
+  static Language from_env(const std::string& env);
+
+  /** Compares two Languages, returns 0 on missmatch and a score
+      between 1 and 9 on match, the higher the score the better the
+      match */
+  static int match(const Language& lhs, const Language& rhs);
+
+  /** Create an undefined Language object */
+  Language();
+  
+  operator bool() const { return language_spec; }
+
+  /** Returns the language code (i.e. de, en, fr) */
+  std::string get_language() const;
+
+  /** Returns the country code (i.e. DE, AT, US) */
+  std::string get_country()  const;
+
+  /** Returns the modifier of the language (i.e. latn or Latn for
+      Serbian with non-cyrilic characters) */
+  std::string get_modifier()  const;
+
+  /** Returns the human readable name of the Language */
+  std::string get_name() const;
+
+  /** Returns the Language as string in the form of an environment
+      variable: {language}_{country}@{modifier} */
+  std::string str() const;
+
+  bool operator==(const Language& rhs) const;
+  bool operator!=(const Language& rhs) const;
+
+  friend bool operator<(const Language& lhs, const Language& rhs);
+};
+
+inline bool operator<(const Language& lhs, const Language& rhs) {
+  return lhs.language_spec < rhs.language_spec;
+}
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/log.cpp

@@ -0,0 +1,70 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include <iostream>
+#include "log.hpp"
+
+namespace tinygettext {
+
+Log::log_callback_t Log::log_info_callback    = &Log::default_log_callback;
+Log::log_callback_t Log::log_warning_callback = &Log::default_log_callback;
+Log::log_callback_t Log::log_error_callback   = &Log::default_log_callback;
+
+void
+Log::default_log_callback(const std::string& str)
+{
+  std::cerr << "tinygettext: " << str;
+}
+
+void
+Log::set_log_info_callback(log_callback_t callback)
+{
+  log_info_callback = callback;
+}
+
+void
+Log::set_log_warning_callback(log_callback_t callback)
+{
+  log_warning_callback = callback;
+}
+
+void
+Log::set_log_error_callback(log_callback_t callback)
+{
+  log_error_callback = callback;
+}
+
+Log::Log(log_callback_t callback_) :
+  callback(callback_),
+  out()
+{
+}
+
+Log::~Log() 
+{
+  callback(out.str());
+}
+
+std::ostream&
+Log::get() 
+{
+  return out; 
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/log.hpp

@@ -0,0 +1,56 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_LOG_HPP
+#define HEADER_TINYGETTEXT_LOG_HPP
+
+#include <sstream>
+
+namespace tinygettext {
+
+class Log
+{
+public:
+  typedef void (*log_callback_t)(const std::string&);
+
+  static log_callback_t log_info_callback;
+  static log_callback_t log_warning_callback;
+  static log_callback_t log_error_callback;
+
+
+  static void default_log_callback(const std::string& str);
+
+  static void set_log_info_callback(log_callback_t callback);
+  static void set_log_warning_callback(log_callback_t callback);
+  static void set_log_error_callback(log_callback_t callback);
+
+private:
+  log_callback_t callback;
+  std::ostringstream out;
+
+public:
+  Log(log_callback_t callback);
+  ~Log();
+  
+  std::ostream& get();
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/log_stream.hpp

@@ -0,0 +1,34 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_LOG_STREAM_HPP
+#define HEADER_TINYGETTEXT_LOG_STREAM_HPP
+
+#include "log.hpp"
+
+namespace tinygettext {
+
+// FIXME: very bad to have such things in the API
+#define log_error   if (!Log::log_error_callback);   else (Log(Log::log_error_callback)).get()
+#define log_warning if (!Log::log_warning_callback); else (Log(Log::log_warning_callback)).get()
+#define log_info    if (!Log::log_info_callback);    else (Log(Log::log_warning_callback)).get()
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/plural_forms.cpp

@@ -0,0 +1,89 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "plural_forms.hpp"
+
+#include <map>
+
+namespace tinygettext {
+
+/** 
+ *  Plural functions are used to select a string that matches a given
+ *  count. \a n is the count and the return value is the string index
+ *  used in the .po file, for example:
+ *   
+ *   msgstr[0] = "You got %d error";
+ *   msgstr[1] = "You got %d errors";        
+ *          ^-- return value of plural function 
+ */
+unsigned int plural1(int )     { return 0; }
+unsigned int plural2_1(int n)  { return (n != 1); }
+unsigned int plural2_2(int n)  { return (n > 1); }
+unsigned int plural2_mk(int n) { return n==1 || n%10==1 ? 0 : 1; }
+unsigned int plural3_lv(int n) { return static_cast<unsigned int>(n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2); }
+unsigned int plural3_ga(int n) { return static_cast<unsigned int>(n==1 ? 0 : n==2 ? 1 : 2); }
+unsigned int plural3_lt(int n) { return static_cast<unsigned int>(n%10==1 && n%100!=11 ? 0 : n%10>=2 && (n%100<10 || n%100>=20) ? 1 : 2); }
+unsigned int plural3_1(int n)  { return static_cast<unsigned int>(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2); }
+unsigned int plural3_sk(int n) { return static_cast<unsigned int>( (n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2 ); }
+unsigned int plural3_pl(int n) { return static_cast<unsigned int>(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2); }
+unsigned int plural3_sl(int n) { return static_cast<unsigned int>(n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3); }
+unsigned int plural4_ar(int n) { return static_cast<unsigned int>( n==1 ? 0 : n==2 ? 1 : n>=3 && n<=10 ? 2 : 3 ); }
+
+PluralForms
+PluralForms::from_string(const std::string& str)
+{
+  static std::map<std::string, struct PluralForms> plural_forms;
+    
+  if (plural_forms.empty())
+  {
+    // Note that the plural forms here shouldn't contain any spaces
+    plural_forms["Plural-Forms:nplurals=1;plural=0;"] = PluralForms(1, plural1);
+    plural_forms["Plural-Forms:nplurals=2;plural=(n!=1);"] = PluralForms(2, plural2_1);
+    plural_forms["Plural-Forms:nplurals=2;plural=n!=1;"] = PluralForms(2, plural2_1);
+    plural_forms["Plural-Forms:nplurals=2;plural=(n>1);"] = PluralForms(2, plural2_2);
+    plural_forms["Plural-Forms:nplurals=2;plural=n==1||n%10==1?0:1;"] = PluralForms(2, plural2_mk);
+    plural_forms["Plural-Forms:nplurals=3;plural=n%10==1&&n%100!=11?0:n!=0?1:2);"] = PluralForms(2, plural3_lv);
+    plural_forms["Plural-Forms:nplurals=3;plural=n==1?0:n==2?1:2;"] = PluralForms(3, plural3_ga);
+    plural_forms["Plural-Forms:nplurals=3;plural=(n%10==1&&n%100!=11?0:n%10>=2&&(n%100<10||n%100>=20)?1:2);"] = PluralForms(3, plural3_lt);
+    plural_forms["Plural-Forms:nplurals=3;plural=(n%10==1&&n%100!=11?0:n%10>=2&&n%10<=4&&(n%100<10||n%100>=20)?1:2);"] = PluralForms(3, plural3_1);
+    plural_forms["Plural-Forms:nplurals=3;plural=(n==1)?0:(n>=2&&n<=4)?1:2;"] = PluralForms(3, plural3_sk);
+    plural_forms["Plural-Forms:nplurals=3;plural=(n==1?0:n%10>=2&&n%10<=4&&(n%100<10||n%100>=20)?1:2);"] = PluralForms(3, plural3_pl);
+    plural_forms["Plural-Forms:nplurals=3;plural=(n%100==1?0:n%100==2?1:n%100==3||n%100==4?2:3);"] = PluralForms(3, plural3_sl);
+
+    plural_forms["Plural-Forms:nplurals=4;plural=n==1?0:n==2?1:n>=3&&n<=10?2:3;"]=PluralForms(4, plural4_ar);
+  }
+  
+  // Remove spaces from string before lookup
+  std::string space_less_str;
+  for(std::string::size_type i = 0; i < str.size(); ++i)
+    if (!isspace(str[i]))
+      space_less_str += str[i];
+  
+  std::map<std::string, struct PluralForms>::const_iterator it= plural_forms.find(space_less_str);
+  if (it != plural_forms.end())
+  {
+    return it->second;
+  }
+  else
+  {
+    return PluralForms();
+  }
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/plural_forms.hpp

@@ -0,0 +1,61 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_PLURAL_FORMS_HPP
+#define HEADER_TINYGETTEXT_PLURAL_FORMS_HPP
+
+#include <string>
+
+namespace tinygettext {
+
+typedef unsigned int (*PluralFunc)(int n);
+
+class PluralForms
+{
+private:
+  unsigned int nplural;
+  PluralFunc   plural;
+
+public:
+  static PluralForms from_string(const std::string& str);
+
+  PluralForms()
+    : nplural(0),
+      plural(0)
+  {}
+
+  PluralForms(unsigned int nplural_, PluralFunc plural_)
+    : nplural(nplural_), 
+      plural(plural_)
+  {}
+
+  unsigned int get_nplural() const { return nplural; }
+  unsigned int get_plural(int n) const { if (plural) return plural(n); else return 0; }
+
+  bool operator==(const PluralForms& other) { return nplural == other.nplural && plural == other.plural; }
+  bool operator!=(const PluralForms& other) { return !(*this == other); }
+
+  operator bool() const {
+    return plural;
+  }
+};
+
+} // namespace tinygettext
+
+#endif 
+
+/* EOF */

tinygettext/po_parser.cpp

@@ -0,0 +1,496 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "po_parser.hpp"
+
+#include <iostream>
+#include <ctype.h>
+#include <string>
+#include <istream>
+#include <string.h>
+#include <map>
+#include <stdlib.h>
+
+#include "language.hpp"
+#include "log_stream.hpp"
+#include "iconv.hpp"
+#include "dictionary.hpp"
+#include "plural_forms.hpp"
+
+namespace tinygettext {
+
+bool POParser::pedantic = true;
+
+void
+POParser::parse(const std::string& filename, std::istream& in, Dictionary& dict)
+{
+  POParser parser(filename, in, dict);
+  parser.parse();
+}
+
+class POParserError {};
+
+POParser::POParser(const std::string& filename_, std::istream& in_, Dictionary& dict_, bool use_fuzzy_) :
+  filename(filename_), 
+  in(in_), 
+  dict(dict_), 
+  use_fuzzy(use_fuzzy_),
+  running(false), 
+  eof(false), 
+  big5(false),
+  line_number(0), 
+  current_line(), 
+  conv()
+{
+}
+
+POParser::~POParser()
+{
+}
+
+void
+POParser::warning(const std::string& msg)
+{
+  log_warning << filename << ":" << line_number << ": warning: " << msg << ": " << current_line << std::endl;
+  //log_warning << "Line: " << current_line << std::endl;
+}
+
+void
+POParser::error(const std::string& msg)
+{
+  log_error << filename << ":" << line_number << ": error: " << msg  << ": " << current_line << std::endl;
+
+  // Try to recover from an error by searching for start of another entry
+  do
+    next_line();
+  while(!eof && !is_empty_line());
+
+  throw POParserError();
+}
+
+void
+POParser::next_line()
+{
+  line_number += 1;
+  if (!std::getline(in, current_line))
+    eof = true;
+}
+
+void
+POParser::get_string_line(std::ostringstream& out,unsigned int skip)
+{
+  if (skip+1 >= static_cast<unsigned int>(current_line.size()))
+    error("unexpected end of line");
+
+  if (current_line[skip] != '"')
+    error("expected start of string '\"'");
+  
+  std::string::size_type i;
+  for(i = skip+1; current_line[i] != '\"'; ++i)
+  {
+    if (big5 && static_cast<unsigned char>(current_line[i]) >= 0x81 && static_cast<unsigned char>(current_line[i]) <= 0xfe)
+    {
+      out << current_line[i];
+
+      i += 1;
+          
+      if (i >= current_line.size())
+        error("invalid big5 encoding");
+          
+      out << current_line[i];
+    }
+    else if (i >= current_line.size())
+    {
+      error("unexpected end of string");
+    }
+    else if (current_line[i] == '\\')
+    {
+      i += 1;
+
+      if (i >= current_line.size())
+        error("unexpected end of string in handling '\\'");
+
+      switch (current_line[i])
+      {
+        case 'a':  out << '\a'; break;
+        case 'b':  out << '\b'; break;
+        case 'v':  out << '\v'; break;
+        case 'n':  out << '\n'; break;
+        case 't':  out << '\t'; break;
+        case 'r':  out << '\r'; break;
+        case '"':  out << '"'; break;
+        case '\\': out << '\\'; break;
+        default: 
+          std::ostringstream err;
+          err << "unhandled escape '\\" << current_line[i] << "'";
+          warning(err.str());
+
+          out << current_line[i-1] << current_line[i];
+          break;
+      }
+    }
+    else
+    {
+      out << current_line[i];
+    }
+  }
+
+  // process trailing garbage in line and warn if there is any
+  for(i = i+1; i < current_line.size(); ++i)
+    if (!isspace(current_line[i]))
+    {
+      warning("unexpected garbage after string ignoren");
+      break;
+    }
+}
+
+std::string
+POParser::get_string(unsigned int skip)
+{
+  std::ostringstream out;
+
+  if (skip+1 >= static_cast<unsigned int>(current_line.size()))
+    error("unexpected end of line");
+
+  if (current_line[skip] == ' ' && current_line[skip+1] == '"')
+  {
+    get_string_line(out, skip+1);
+  }
+  else
+  {
+    if (pedantic)
+      warning("keyword and string must be seperated by a single space");
+
+    for(;;)
+    {
+      if (skip >= static_cast<unsigned int>(current_line.size()))
+        error("unexpected end of line");
+      else if (current_line[skip] == '\"')
+      {
+        get_string_line(out, skip);
+        break;
+      }
+      else if (!isspace(current_line[skip]))
+      {
+        error("string must start with '\"'");
+      }
+      else
+      {
+        // skip space
+      }
+
+      skip += 1;
+    }
+  }
+  
+next:
+  next_line();
+  for(std::string::size_type i = 0; i < current_line.size(); ++i)
+  {
+    if (current_line[i] == '"')
+    {
+      if (i == 1)
+        if (pedantic)
+          warning("leading whitespace before string");
+
+      get_string_line(out, i);
+      goto next;
+    }
+    else if (isspace(current_line[i]))
+    {
+      // skip
+    }
+    else
+    {
+      break;
+    }
+  }
+
+  return out.str();
+}
+
+static bool has_prefix(const std::string& lhs, const std::string rhs)
+{
+  if (lhs.length() < rhs.length())
+    return false;
+  else
+    return lhs.compare(0, rhs.length(), rhs) == 0;
+}
+
+void
+POParser::parse_header(const std::string& header)
+{
+  std::string from_charset;
+  std::string::size_type start = 0;
+  for(std::string::size_type i = 0; i < header.length(); ++i)
+  {
+    if (header[i] == '\n')
+    {
+      std::string line = header.substr(start, i - start);
+
+      if (has_prefix(line, "Content-Type:"))
+      {
+        // from_charset = line.substr(len);
+        unsigned int len = strlen("Content-Type: text/plain; charset=");
+        if (line.compare(0, len, "Content-Type: text/plain; charset=") == 0)
+        {
+          from_charset = line.substr(len);
+
+          for(std::string::iterator ch = from_charset.begin(); ch != from_charset.end(); ++ch)
+            *ch = static_cast<char>(toupper(*ch));
+        }
+        else
+        {
+          warning("malformed Content-Type header");
+        }
+      }
+      else if (has_prefix(line, "Plural-Forms:"))
+      {
+        PluralForms plural_forms = PluralForms::from_string(line);
+        if (!plural_forms)
+        {
+          warning("unknown Plural-Forms given");
+        }
+        else
+        {
+          if (!dict.get_plural_forms())
+          {
+            dict.set_plural_forms(plural_forms);
+          }
+          else
+          {
+            if (dict.get_plural_forms() != plural_forms)
+            {
+              warning("Plural-Forms missmatch between .po file and dictionary");
+            }
+          }
+        }
+      }
+      start = i+1;
+    }
+  }
+
+  if (from_charset.empty() || from_charset == "CHARSET")
+  {
+    warning("charset not specified for .po, fallback to utf-8");
+    from_charset = "UTF-8";
+  }
+  else if (from_charset == "BIG5")
+  {
+    big5 = true;
+  }
+
+  conv.set_charsets(from_charset, dict.get_charset());
+}
+
+bool
+POParser::is_empty_line()
+{
+  if (current_line.empty())
+  {
+    return true;
+  }
+  else if (current_line[0] == '#')
+  { // handle comments as empty lines
+    if (current_line.size() == 1 || (current_line.size() >= 2 && isspace(current_line[1])))
+      return true;
+    else
+      return false;
+  }
+  else
+  {
+    for(std::string::iterator i = current_line.begin(); i != current_line.end(); ++i)
+    {
+      if (!isspace(*i))
+        return false;
+    }
+  }
+  return true;
+}
+
+bool
+POParser::prefix(const char* prefix_str)
+{
+  return current_line.compare(0, strlen(prefix_str), prefix_str) == 0;
+}
+
+void
+POParser::parse()
+{
+  next_line();
+
+  // skip UTF-8 intro that some text editors produce
+  // see http://en.wikipedia.org/wiki/Byte-order_mark
+  if (current_line.size() >= 3 &&
+      current_line[0] == static_cast<char>(0xef) &&
+      current_line[1] == static_cast<char>(0xbb) &&
+      current_line[2] == static_cast<char>(0xbf))
+  {
+    current_line = current_line.substr(3);
+  }
+
+  // Parser structure
+  while(!eof)
+  {
+    try 
+    {
+      bool fuzzy =  false;
+      bool has_msgctxt = false;
+      std::string msgctxt;
+      std::string msgid;
+
+      while(prefix("#"))
+      {
+        if (current_line.size() >= 2 && current_line[1] == ',')
+        {
+          // FIXME: Rather simplistic hunt for fuzzy flag
+          if (current_line.find("fuzzy", 2) != std::string::npos)
+            fuzzy = true;
+        }
+
+        next_line();
+      }
+
+      if (!is_empty_line())
+      {
+        if (prefix("msgctxt"))
+        {
+          has_msgctxt = true;
+          msgctxt = get_string(7);
+        }
+
+        if (prefix("msgid"))
+          msgid = get_string(5);
+        else
+          error("expected 'msgid'");
+
+        if (prefix("msgid_plural"))
+        {
+          std::string msgid_plural = get_string(12);
+          std::vector<std::string> msgstr_num;
+	  bool saw_nonempty_msgstr = false;
+
+        next:
+          if (is_empty_line())
+          {
+            if (msgstr_num.empty())
+              error("expected 'msgstr[N] (0 <= N <= 9)'");
+          }
+          else if (prefix("msgstr[") &&
+                   current_line.size() > 8 && 
+                   isdigit(current_line[7]) && current_line[8] == ']')
+          {
+            unsigned int number = static_cast<unsigned int>(current_line[7] - '0');
+	    std::string msgstr = get_string(9);
+
+	    if(!msgstr.empty())
+	      saw_nonempty_msgstr = true;
+
+            if (number >= msgstr_num.size())
+              msgstr_num.resize(number+1);
+
+            msgstr_num[number] = conv.convert(msgstr);
+            goto next;
+          }
+          else 
+          {
+            error("expected 'msgstr[N]'");
+          }
+
+          if (!is_empty_line())
+            error("expected 'msgstr[N]' or empty line");
+
+	  if (saw_nonempty_msgstr)
+	  {
+	    if (use_fuzzy || !fuzzy)
+            {
+	      if (!dict.get_plural_forms())
+	      {
+		warning("msgstr[N] seen, but no Plural-Forms given");
+	      }
+	      else
+	      {
+		if (msgstr_num.size() != dict.get_plural_forms().get_nplural())
+		{
+		  warning("msgstr[N] count doesn't match Plural-Forms.nplural");
+		}
+	      }
+
+	      if (has_msgctxt)
+		dict.add_translation(msgctxt, msgid, msgid_plural, msgstr_num);
+	      else
+		dict.add_translation(msgid, msgid_plural, msgstr_num);
+	    }
+
+	    if (0)
+	    {
+	      std::cout << (fuzzy?"fuzzy":"not-fuzzy") << std::endl;
+	      std::cout << "msgid \"" << msgid << "\"" << std::endl;
+	      std::cout << "msgid_plural \"" << msgid_plural << "\"" << std::endl;
+	      for(std::vector<std::string>::size_type i = 0; i < msgstr_num.size(); ++i)
+		std::cout << "msgstr[" << i << "] \"" << conv.convert(msgstr_num[i]) << "\"" << std::endl;
+	      std::cout << std::endl;
+	    }
+	  }
+        }
+        else if (prefix("msgstr"))
+        {
+          std::string msgstr = get_string(6);
+
+          if (msgid.empty())
+          {
+            parse_header(msgstr);
+          }
+          else if(!msgstr.empty())
+          {
+            if (use_fuzzy || !fuzzy)
+            {
+              if (has_msgctxt)
+                dict.add_translation(msgctxt, msgid, conv.convert(msgstr));
+              else
+                dict.add_translation(msgid, conv.convert(msgstr));
+            }
+
+            if (0)
+            {
+              std::cout << (fuzzy?"fuzzy":"not-fuzzy") << std::endl;
+              std::cout << "msgid \"" << msgid << "\"" << std::endl;
+              std::cout << "msgstr \"" << conv.convert(msgstr) << "\"" << std::endl;
+              std::cout << std::endl;
+            }
+          }
+        }
+        else
+        {
+          error("expected 'msgstr' or 'msgid_plural'");
+        }
+      }
+      
+      if (!is_empty_line())
+        error("expected empty line");
+
+      next_line();
+    }
+    catch(POParserError&)
+    {          
+    }
+  }
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/po_parser.hpp

@@ -0,0 +1,75 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_PO_PARSER_HPP
+#define HEADER_TINYGETTEXT_PO_PARSER_HPP
+
+#include <iosfwd>
+
+#include "iconv.hpp"
+
+namespace tinygettext {
+
+class Dictionary;
+
+class POParser
+{
+private:
+  std::string filename;
+  std::istream& in;
+  Dictionary& dict;
+  bool  use_fuzzy;
+
+  bool running;
+  bool eof;
+  bool big5;
+
+  int line_number;
+  std::string current_line;
+
+  IConv conv;
+  
+  POParser(const std::string& filename, std::istream& in_, Dictionary& dict_, bool use_fuzzy = true);
+  ~POParser();
+
+  void parse_header(const std::string& header);
+  void parse();
+  void next_line();
+  std::string get_string(unsigned int skip);
+  void get_string_line(std::ostringstream& str,unsigned int skip);
+  bool is_empty_line();
+  bool prefix(const char* );
+  void error(const std::string& msg) __attribute__((__noreturn__));
+  void warning(const std::string& msg);
+
+public:
+  /** @param filename name of the istream, only used in error messages
+      @param in stream from which the PO file is read.
+      @param dict dictionary to which the strings are written */
+  static void parse(const std::string& filename, std::istream& in, Dictionary& dict);
+  static bool pedantic;
+
+private:
+  POParser (const POParser&);
+  POParser& operator= (const POParser&);
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */

tinygettext/tinygettext.cpp

@@ -0,0 +1,22 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+namespace tinygettext {
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/tinygettext.hpp

@@ -0,0 +1,27 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_TINYGETTEXT_HPP
+#define HEADER_TINYGETTEXT_TINYGETTEXT_HPP
+
+#include "dictionary.hpp"
+#include "dictionary_manager.hpp"
+#include "language.hpp"
+
+#endif
+
+/* EOF */

tinygettext/unix_file_system.cpp

@@ -0,0 +1,65 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "unix_file_system.hpp"
+
+#include <sys/types.h>
+#include <fstream>
+#include <dirent.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <string.h>
+
+namespace tinygettext {
+
+UnixFileSystem::UnixFileSystem()
+{
+}
+
+std::vector<std::string>
+UnixFileSystem::open_directory(const std::string& pathname)
+{
+  DIR* dir = opendir(pathname.c_str());
+  if (!dir)
+  {
+    // FIXME: error handling
+    return std::vector<std::string>();
+  }
+  else
+  {
+    std::vector<std::string> files;
+
+    struct dirent* dp;
+    while((dp = readdir(dir)) != 0)
+    {
+      files.push_back(dp->d_name);
+    }
+    closedir(dir);
+
+    return files;
+  }
+}
+  
+std::auto_ptr<std::istream>
+UnixFileSystem::open_file(const std::string& filename)
+{
+  return std::auto_ptr<std::istream>(new std::ifstream(filename.c_str()));
+}
+
+} // namespace tinygettext
+
+/* EOF */

tinygettext/unix_file_system.hpp

@@ -0,0 +1,38 @@
+//  tinygettext - A gettext replacement that works directly on .po files
+//  Copyright (C) 2009 Ingo Ruhnke <grumbel@gmx.de>
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 2
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef HEADER_TINYGETTEXT_UNIX_FILE_SYSTEM_HPP
+#define HEADER_TINYGETTEXT_UNIX_FILE_SYSTEM_HPP
+
+#include "file_system.hpp"
+
+namespace tinygettext {
+
+class UnixFileSystem : public FileSystem
+{
+public:
+  UnixFileSystem();
+
+  std::vector<std::string>    open_directory(const std::string& pathname);
+  std::auto_ptr<std::istream> open_file(const std::string& filename);
+};
+
+} // namespace tinygettext
+
+#endif
+
+/* EOF */