external/tinygettext/tinygettext/language.cpp

   1 //  tinygettext - A gettext replacement that works directly on .po files
   2 //  Copyright (C) 2006 Ingo Ruhnke <grumbel@gmx.de>
   3 //
   4 //  This program is free software; you can redistribute it and/or
   5 //  modify it under the terms of the GNU General Public License
   6 //  as published by the Free Software Foundation; either version 2
   7 //  of the License, or (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program; if not, write to the Free Software
  16 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17
  18 #include "language.hpp"
  19
  20 #include <map>
  21 #include <assert.h>
  22 #include <vector>
  23
  24 namespace tinygettext {
  25 \f
  26 struct LanguageSpec {
  27   /** Language code: "de", "en", ... */
  28   const char* language;
  29
  30   /** Country code: "BR", "DE", ..., can be 0 */
  31   const char* country;
  32
  33   /** Modifier/Varint: "Latn", "ije", "latin"..., can be 0 */
  34   const char* modifier;
  35
  36   /** Language name: "German", "English", "French", ... */
  37   const char* name;
  38 };
  39 \f
  40 /** Language Definitions */
  41 //*{
  42 LanguageSpec languages[] = {
  43   { "aa", 0,    0, "Afar"                        },
  44   { "af", 0,    0, "Afrikaans"                   },
  45   { "af", "ZA", 0, "Afrikaans (South Africa)"    },
  46   { "am", 0,    0, "Amharic"                     },
  47   { "ar", 0,    0, "Arabic"                      },
  48   { "ar", "AR", 0, "Arabic (Argentina)"          },
  49   { "ar", "OM", 0, "Arabic (Oman)"               },
  50   { "ar", "SA", 0, "Arabic (Saudi Arabia)"       },
  51   { "ar", "SY", 0, "Arabic (Syrian Arab Republic)" },
  52   { "ar", "TN", 0, "Arabic (Tunisia)"            },
  53   { "as", 0,    0, "Assamese"                    },
  54   { "ast",0,    0, "Asturian"                    },
  55   { "ay", 0,    0, "Aymara"                      },
  56   { "az", 0,    0, "Azerbaijani"                 },
  57   { "az", "IR", 0, "Azerbaijani (Iran)"          },
  58   { "be", 0,    0, "Belarusian"                  },
  59   { "be", 0, "latin", "Belarusian"               },
  60   { "bg", 0,    0, "Bulgarian"                   },
  61   { "bg", "BG", 0, "Bulgarian (Bulgaria)"        },
  62   { "bn", 0,    0, "Bengali"                     },
  63   { "bn", "BD", 0, "Bengali (Bangladesh)"        },
  64   { "bn", "IN", 0, "Bengali (India)"             },
  65   { "bo", 0,    0, "Tibetan"                     },
  66   { "br", 0,    0, "Breton"                      },
  67   { "bs", 0,    0, "Bosnian"                     },
  68   { "bs", "BA", 0, "Bosnian (Bosnia/Herzegovina)"},
  69   { "bs", "BS", 0, "Bosnian (Bahamas)"           },
  70   { "ca", "ES", "valencia", "Catalan (valencia)" },
  71   { "ca", "ES", 0, "Catalan (Spain)"             },
  72   { "ca", 0,    "valencia", "Catalan (valencia)" },
  73   { "ca", 0,    0, "Catalan"                     },
  74   { "co", 0,    0, "Corsican"                    },
  75   { "cs", 0,    0, "Czech"                       },
  76   { "cs", "CZ", 0, "Czech (Czech Republic)"      },
  77   { "cy", 0,    0, "Welsh"                       },
  78   { "cy", "GB", 0, "Welsh (Great Britain)"       },
  79   { "cz", 0,    0, "Unknown language"            },
  80   { "da", 0,    0, "Danish"                      },
  81   { "da", "DK", 0, "Danish (Denmark)"            },
  82   { "de", 0,    0, "German"                      },
  83   { "de", "AT", 0, "German (Austria)"            },
  84   { "de", "CH", 0, "German (Switzerland)"        },
  85   { "de", "DE", 0, "German (Germany)"            },
  86   { "dk", 0,    0, "Unknown language"            },
  87   { "dz", 0,    0, "Dzongkha"                    },
  88   { "el", 0,    0, "Greek"                       },
  89   { "el", "GR", 0, "Greek (Greece)"              },
  90   { "en", 0,    0, "English"                     },
  91   { "en", "AU", 0, "English (Australia)"         },
  92   { "en", "CA", 0, "English (Canada)"            },
  93   { "en", "GB", 0, "English (Great Britain)"     },
  94   { "en", "US", 0, "English (United States)"     },
  95   { "en", "ZA", 0, "English (South Africa)"      },
  96   { "en", 0, "boldquot", "English"               },
  97   { "en", 0, "quot", "English"                   },
  98   { "en", "US", "piglatin", "English"            },
  99   { "eo", 0,    0, "Esperanto"                   },
 100   { "es", 0,    0, "Spanish"                     },
 101   { "es", "AR", 0, "Spanish (Argentina)"         },
 102   { "es", "CL", 0, "Spanish (Chile)"             },
 103   { "es", "CO", 0, "Spanish (Colombia)"          },
 104   { "es", "CR", 0, "Spanish (Costa Rica)"        },
 105   { "es", "DO", 0, "Spanish (Dominican Republic)"},
 106   { "es", "EC", 0, "Spanish (Ecuador)"           },
 107   { "es", "ES", 0, "Spanish (Spain)"             },
 108   { "es", "GT", 0, "Spanish (Guatemala)"         },
 109   { "es", "HN", 0, "Spanish (Honduras)"          },
 110   { "es", "LA", 0, "Spanish (Laos)"              },
 111   { "es", "MX", 0, "Spanish (Mexico)"            },
 112   { "es", "NI", 0, "Spanish (Nicaragua)"         },
 113   { "es", "PA", 0, "Spanish (Panama)"            },
 114   { "es", "PE", 0, "Spanish (Peru)"              },
 115   { "es", "PR", 0, "Spanish (Puerto Rico)"       },
 116   { "es", "SV", 0, "Spanish (El Salvador)"       },
 117   { "es", "UY", 0, "Spanish (Uruguay)"           },
 118   { "es", "VE", 0, "Spanish (Venezuela)"         },
 119   { "et", 0,    0, "Estonian"                    },
 120   { "et", "EE", 0, "Estonian (Estonia)"          },
 121   { "et", "ET", 0, "Estonian (Ethiopia)"         },
 122   { "eu", 0,    0, "Basque"                      },
 123   { "eu", "ES", 0, "Basque (Spain)"              },
 124   { "fa", 0,    0, "Persian"                     },
 125   { "fa", "AF", 0, "Persian (Afghanistan)"       },
 126   { "fa", "IR", 0, "Persian (Iran)"              },
 127   { "fi", 0,    0, "Finnish"                     },
 128   { "fi", "FI", 0, "Finnish (Finland)"           },
 129   { "fo", 0,    0, "Faroese"                     },
 130   { "fo", "FO", 0, "Faeroese (Faroe Islands)"    },
 131   { "fr", 0,    0, "French"                      },
 132   { "fr", "CA", 0, "French (Canada)"             },
 133   { "fr", "CH", 0, "French (Switzerland)"        },
 134   { "fr", "FR", 0, "French (France)"             },
 135   { "fr", "LU", 0, "French (Luxembourg)"         },
 136   { "fy", 0,    0, "Frisian"                     },
 137   { "ga", 0,    0, "Irish"                       },
 138   { "gd", 0,    0, "Gaelic Scots"                },
 139   { "gl", 0,    0, "Galician"                    },
 140   { "gl", "ES", 0, "Galician (Spain)"            },
 141   { "gn", 0,    0, "Guarani"                     },
 142   { "gu", 0,    0, "Gujarati"                    },
 143   { "gv", 0,    0, "Manx"                        },
 144   { "ha", 0,    0, "Hausa"                       },
 145   { "he", 0,    0, "Hebrew"                      },
 146   { "he", "IL", 0, "Hebrew (Israel)"             },
 147   { "hi", 0,    0, "Hindi"                       },
 148   { "hr", 0,    0, "Croatian"                    },
 149   { "hr", "HR", 0, "Croatian (Croatia)"          },
 150   { "hu", 0,    0, "Hungarian"                   },
 151   { "hu", "HU", 0, "Hungarian (Hungary)"         },
 152   { "hy", 0,    0, "Armenian"                    },
 153   { "ia", 0,    0, "Interlingua"                 },
 154   { "id", 0,    0, "Indonesian"                  },
 155   { "id", "ID", 0, "Indonesian (Indonesia)"      },
 156   { "is", 0,    0, "Icelandic"                   },
 157   { "is", "IS", 0, "Icelandic (Iceland)"         },
 158   { "it", 0,    0, "Italian"                     },
 159   { "it", "CH", 0, "Italian (Switzerland)"       },
 160   { "it", "IT", 0, "Italian (Italy)"             },
 161   { "iu", 0,    0, "Inuktitut"                   },
 162   { "ja", 0,    0, "Japanese"                    },
 163   { "ja", "JP", 0, "Japanese (Japan)"            },
 164   { "ka", 0,    0, "Georgian"                    },
 165   { "kk", 0,    0, "Kazakh"                      },
 166   { "kl", 0,    0, "Kalaallisut"                 },
 167   { "km", 0,    0, "Khmer"                       },
 168   { "km", "KH", 0, "Khmer (Cambodia)"            },
 169   { "kn", 0,    0, "Kannada"                     },
 170   { "ko", 0,    0, "Korean"                      },
 171   { "ko", "KR", 0, "Korean (Korea)"              },
 172   { "ku", 0,    0, "Kurdish"                     },
 173   { "kw", 0,    0, "Cornish"                     },
 174   { "ky", 0,    0, "Kirghiz"                     },
 175   { "la", 0,    0, "Latin"                       },
 176   { "lo", 0,    0, "Lao"                         },
 177   { "lt", 0,    0, "Lithuanian"                  },
 178   { "lt", "LT", 0, "Lithuanian (Lithuania)"      },
 179   { "lv", 0,    0, "Latvian"                     },
 180   { "lv", "LV", 0, "Latvian (Latvia)"            },
 181   { "mg", 0,    0, "Malagasy"                    },
 182   { "mi", 0,    0, "Maori"                       },
 183   { "mk", 0,    0, "Macedonian"                  },
 184   { "mk", "MK", 0, "Macedonian (Macedonia)"      },
 185   { "ml", 0,    0, "Malayalam"                   },
 186   { "mn", 0,    0, "Mongolian"                   },
 187   { "mr", 0,    0, "Marathi"                     },
 188   { "ms", 0,    0, "Malay"                       },
 189   { "ms", "MY", 0, "Malay (Malaysia)"            },
 190   { "mt", 0,    0, "Maltese"                     },
 191   { "my", 0,    0, "Burmese"                     },
 192   { "my", "MM", 0, "Burmese (Myanmar)"           },
 193   { "nb", 0,    0, "Norwegian Bokmal"            },
 194   { "nb", "NO", 0, "Norwegian Bokmål (Norway)"   },
 195   { "ne", 0,    0, "Nepali"                      },
 196   { "nl", 0,    0, "Dutch"                       },
 197   { "nl", "BE", 0, "Dutch (Belgium)"             },
 198   { "nl", "NL", 0, "Dutch (Netherlands)"         },
 199   { "nn", 0,    0, "Norwegian Nynorsk"           },
 200   { "nn", "NO", 0, "Norwegian Nynorsk (Norway)"  },
 201   { "no", 0,    0, "Norwegian"                   },
 202   { "no", "NO", 0, "Norwegian (Norway)"          },
 203   { "no", "NY", 0, "Norwegian (NY)"              },
 204   { "nr", 0,    0, "Ndebele, South"              },
 205   { "oc", 0,    0, "Occitan post 1500"           },
 206   { "om", 0,    0, "Oromo"                       },
 207   { "or", 0,    0, "Oriya"                       },
 208   { "pa", 0,    0, "Punjabi"                     },
 209   { "pl", 0,    0, "Polish"                      },
 210   { "pl", "PL", 0, "Polish (Poland)"             },
 211   { "ps", 0,    0, "Pashto"                      },
 212   { "pt", 0,    0, "Portuguese"                  },
 213   { "pt", "BR", 0, "Brazilian"                   },
 214   { "pt", "PT", 0, "Portuguese (Portugal)"       },
 215   { "qu", 0,    0, "Quechua"                     },
 216   { "rm", 0,    0, "Rhaeto-Romance"              },
 217   { "ro", 0,    0, "Romanian"                    },
 218   { "ro", "RO", 0, "Romanian (Romania)"          },
 219   { "ru", 0,    0, "Russian"                     },
 220   { "ru", "RU", 0, "Russian (Russia"             },
 221   { "rw", 0,    0, "Kinyarwanda"                 },
 222   { "sa", 0,    0, "Sanskrit"                    },
 223   { "sd", 0,    0, "Sindhi"                      },
 224   { "se", 0,    0, "Sami"                        },
 225   { "se", "NO", 0, "Sami (Norway)"               },
 226   { "si", 0,    0, "Sinhalese"                   },
 227   { "sk", 0,    0, "Slovak"                      },
 228   { "sk", "SK", 0, "Slovak (Slovakia)"           },
 229   { "sl", 0,    0, "Slovenian"                   },
 230   { "sl", "SI", 0, "Slovenian (Slovenia)"        },
 231   { "sl", "SL", 0, "Slovenian (Sierra Leone)"    },
 232   { "sm", 0,    0, "Samoan"                      },
 233   { "so", 0,    0, "Somali"                      },
 234   { "sp", 0,    0, "Unknown language"            },
 235   { "sq", 0,    0, "Albanian"                    },
 236   { "sq", "AL", 0, "Albanian (Albania)"          },
 237   { "sr", 0,    0, "Serbian"                     },
 238   { "sr", "YU", 0, "Serbian (Yugoslavia)"        },
 239   { "sr", 0,"ije", "Serbian"                     },
 240   { "sr", 0, "latin", "Serbian"                  },
 241   { "sr", 0, "Latn",  "Serbian"                  },
 242   { "ss", 0,    0, "Swati"                       },
 243   { "st", 0,    0, "Sotho"                       },
 244   { "sv", 0,    0, "Swedish"                     },
 245   { "sv", "SE", 0, "Swedish (Sweden)"            },
 246   { "sv", "SV", 0, "Swedish (El Salvador)"       },
 247   { "sw", 0,    0, "Swahili"                     },
 248   { "ta", 0,    0, "Tamil"                       },
 249   { "te", 0,    0, "Telugu"                      },
 250   { "tg", 0,    0, "Tajik"                       },
 251   { "th", 0,    0, "Thai"                        },
 252   { "th", "TH", 0, "Thai (Thailand)"             },
 253   { "ti", 0,    0, "Tigrinya"                    },
 254   { "tk", 0,    0, "Turkmen"                     },
 255   { "tl", 0,    0, "Tagalog"                     },
 256   { "to", 0,    0, "Tonga"                       },
 257   { "tr", 0,    0, "Turkish"                     },
 258   { "tr", "TR", 0, "Turkish (Turkey)"            },
 259   { "ts", 0,    0, "Tsonga"                      },
 260   { "tt", 0,    0, "Tatar"                       },
 261   { "ug", 0,    0, "Uighur"                      },
 262   { "uk", 0,    0, "Ukrainian"                   },
 263   { "uk", "UA", 0, "Ukrainian (Ukraine)"         },
 264   { "ur", 0,    0, "Urdu"                        },
 265   { "ur", "PK", 0, "Urdu (Pakistan)"             },
 266   { "uz", 0,    0, "Uzbek"                       },
 267   { "uz", 0, "cyrillic", "Uzbek"                 },
 268   { "vi", 0,    0, "Vietnamese"                  },
 269   { "vi", "VN", 0, "Vietnamese (Vietnam)"        },
 270   { "wa", 0,    0, "Walloon"                     },
 271   { "wo", 0,    0, "Wolof"                       },
 272   { "xh", 0,    0, "Xhosa"                       },
 273   { "yi", 0,    0, "Yiddish"                     },
 274   { "yo", 0,    0, "Yoruba"                      },
 275   { "zh", 0,    0, "Chinese"                     },
 276   { "zh", "CN", 0, "Chinese (simplified)"        },
 277   { "zh", "HK", 0, "Chinese (Hong Kong)"         },
 278   { "zh", "TW", 0, "Chinese (traditional)"       },
 279   { "zu", 0,    0, "Zulu"                        },
 280   { NULL, 0,    0, NULL                          }
 281 };
 282 //*}
 283 \f
 284 std::string
 285 resolve_language_alias(const std::string& name)
 286 {
 287   typedef std::map<std::string, std::string> Aliases;
 288   static Aliases language_aliases;
 289   if (language_aliases.empty())
 290   {
 291     // FIXME: Many of those are not useful for us, since we leave
 292     // encoding to the app, not to the language, we could/should
 293     // also match against all language names, not just aliases from
 294     // locale.alias
 295
 296     // Aliases taken from /etc/locale.alias
 297     language_aliases["bokmal"]           = "nb_NO.ISO-8859-1";
 298     language_aliases["bokmål"]           = "nb_NO.ISO-8859-1";
 299     language_aliases["catalan"]          = "ca_ES.ISO-8859-1";
 300     language_aliases["croatian"]         = "hr_HR.ISO-8859-2";
 301     language_aliases["czech"]            = "cs_CZ.ISO-8859-2";
 302     language_aliases["danish"]           = "da_DK.ISO-8859-1";
 303     language_aliases["dansk"]            = "da_DK.ISO-8859-1";
 304     language_aliases["deutsch"]          = "de_DE.ISO-8859-1";
 305     language_aliases["dutch"]            = "nl_NL.ISO-8859-1";
 306     language_aliases["eesti"]            = "et_EE.ISO-8859-1";
 307     language_aliases["estonian"]         = "et_EE.ISO-8859-1";
 308     language_aliases["finnish"]          = "fi_FI.ISO-8859-1";
 309     language_aliases["français"]         = "fr_FR.ISO-8859-1";
 310     language_aliases["french"]           = "fr_FR.ISO-8859-1";
 311     language_aliases["galego"]           = "gl_ES.ISO-8859-1";
 312     language_aliases["galician"]         = "gl_ES.ISO-8859-1";
 313     language_aliases["german"]           = "de_DE.ISO-8859-1";
 314     language_aliases["greek"]            = "el_GR.ISO-8859-7";
 315     language_aliases["hebrew"]           = "he_IL.ISO-8859-8";
 316     language_aliases["hrvatski"]         = "hr_HR.ISO-8859-2";
 317     language_aliases["hungarian"]        = "hu_HU.ISO-8859-2";
 318     language_aliases["icelandic"]        = "is_IS.ISO-8859-1";
 319     language_aliases["italian"]          = "it_IT.ISO-8859-1";
 320     language_aliases["japanese"]         = "ja_JP.eucJP";
 321     language_aliases["japanese.euc"]     = "ja_JP.eucJP";
 322     language_aliases["ja_JP"]            = "ja_JP.eucJP";
 323     language_aliases["ja_JP.ujis"]       = "ja_JP.eucJP";
 324     language_aliases["japanese.sjis"]    = "ja_JP.SJIS";
 325     language_aliases["korean"]           = "ko_KR.eucKR";
 326     language_aliases["korean.euc"]       = "ko_KR.eucKR";
 327     language_aliases["ko_KR"]            = "ko_KR.eucKR";
 328     language_aliases["lithuanian"]       = "lt_LT.ISO-8859-13";
 329     language_aliases["no_NO"]            = "nb_NO.ISO-8859-1";
 330     language_aliases["no_NO.ISO-8859-1"] = "nb_NO.ISO-8859-1";
 331     language_aliases["norwegian"]        = "nb_NO.ISO-8859-1";
 332     language_aliases["nynorsk"]          = "nn_NO.ISO-8859-1";
 333     language_aliases["polish"]           = "pl_PL.ISO-8859-2";
 334     language_aliases["portuguese"]       = "pt_PT.ISO-8859-1";
 335     language_aliases["romanian"]         = "ro_RO.ISO-8859-2";
 336     language_aliases["russian"]          = "ru_RU.ISO-8859-5";
 337     language_aliases["slovak"]           = "sk_SK.ISO-8859-2";
 338     language_aliases["slovene"]          = "sl_SI.ISO-8859-2";
 339     language_aliases["slovenian"]        = "sl_SI.ISO-8859-2";
 340     language_aliases["spanish"]          = "es_ES.ISO-8859-1";
 341     language_aliases["swedish"]          = "sv_SE.ISO-8859-1";
 342     language_aliases["thai"]             = "th_TH.TIS-620";
 343     language_aliases["turkish"]          = "tr_TR.ISO-8859-9";
 344   }
 345
 346   std::string name_lowercase;
 347   name_lowercase.resize(name.size());
 348   for(std::string::size_type i = 0; i < name.size(); ++i)
 349     name_lowercase[i] = static_cast<char>(tolower(name[i]));
 350
 351   Aliases::iterator i = language_aliases.find(name_lowercase);
 352   if (i != language_aliases.end())
 353   {
 354     return i->second;
 355   }
 356   else
 357   {
 358     return name;
 359   }
 360 }
 361 \f
 362 Language
 363 Language::from_spec(const std::string& language, const std::string& country, const std::string& modifier)
 364 {
 365   static std::map<std::string, std::vector<LanguageSpec*> > language_map;
 366
 367   if (language_map.empty())
 368   { // Init language_map
 369     for(int i = 0; languages[i].language != NULL; ++i)
 370       language_map[languages[i].language].push_back(&languages[i]);
 371   }
 372
 373   std::map<std::string, std::vector<LanguageSpec*> >::iterator i = language_map.find(language);
 374   if (i != language_map.end())
 375   {
 376     std::vector<LanguageSpec*>& lst = i->second;
 377
 378     LanguageSpec tmpspec;
 379     tmpspec.language = language.c_str();
 380     tmpspec.country  = country.c_str();
 381     tmpspec.modifier = modifier.c_str();
 382     Language tmplang(&tmpspec);
 383
 384     LanguageSpec* best_match = 0;
 385     int best_match_score = 0;
 386     for(std::vector<LanguageSpec*>::iterator j = lst.begin(); j != lst.end(); ++j)
 387     { // Search for the language that best matches the given spec, value country more then modifier
 388       int score = Language::match(Language(*j), tmplang);
 389
 390       if (score > best_match_score)
 391       {
 392         best_match = *j;
 393         best_match_score = score;
 394       }
 395     }
 396     assert(best_match);
 397     return Language(best_match);
 398   }
 399   else
 400   {
 401     return Language();
 402   }
 403 }
 404
 405 Language
 406 Language::from_name(const std::string& spec_str)
 407 {
 408   return from_env(resolve_language_alias(spec_str));
 409 }
 410
 411 Language
 412 Language::from_env(const std::string& env)
 413 {
 414   // Split LANGUAGE_COUNTRY.CODESET@MODIFIER into parts
 415   std::string::size_type ln = env.find('_');
 416   std::string::size_type dt = env.find('.');
 417   std::string::size_type at = env.find('@');
 418
 419   std::string language;
 420   std::string country;
 421   std::string codeset;
 422   std::string modifier;
 423
 424   //std::cout << ln << " " << dt << " " << at << std::endl;
 425
 426   language = env.substr(0, std::min(std::min(ln, dt), at));
 427
 428   if (ln != std::string::npos && ln+1 < env.size()) // _
 429   {
 430     country = env.substr(ln+1, (std::min(dt, at) == std::string::npos) ? std::string::npos : std::min(dt, at) - (ln+1));
 431   }
 432
 433   if (dt != std::string::npos && dt+1 < env.size()) // .
 434   {
 435     codeset = env.substr(dt+1, (at == std::string::npos) ? std::string::npos : (at - (dt+1)));
 436   }
 437
 438   if (at != std::string::npos && at+1 < env.size()) // @
 439   {
 440     modifier = env.substr(at+1);
 441   }
 442
 443   return from_spec(language, country, modifier);
 444 }
 445 \f
 446 Language::Language(LanguageSpec* language_spec_)
 447   : language_spec(language_spec_)
 448 {
 449 }
 450
 451 Language::Language()
 452   : language_spec(0)
 453 {
 454 }
 455
 456 int
 457 Language::match(const Language& lhs, const Language& rhs)
 458 {
 459   if (lhs.get_language() != rhs.get_language())
 460   {
 461     return 0;
 462   }
 463   else
 464   {
 465     static int match_tbl[3][3] = {
 466       // modifier match, wildchard, miss
 467       { 9, 8, 5 }, // country match
 468       { 7, 6, 3 }, // country wildcard
 469       { 4, 2, 1 }, // country miss
 470     };
 471
 472     int c;
 473     if (lhs.get_country() == rhs.get_country())
 474       c = 0;
 475     else if (lhs.get_country().empty() || rhs.get_country().empty())
 476       c = 1;
 477     else
 478       c = 2;
 479
 480     int m;
 481     if (lhs.get_modifier() == rhs.get_modifier())
 482       m = 0;
 483     else if (lhs.get_modifier().empty() || rhs.get_modifier().empty())
 484       m = 1;
 485     else
 486       m = 2;
 487
 488     return match_tbl[c][m];
 489   }
 490 }
 491
 492 std::string
 493 Language::get_language() const
 494 {
 495   if (language_spec)
 496     return language_spec->language;
 497   else
 498     return "";
 499 }
 500
 501 std::string
 502 Language::get_country()  const
 503 {
 504   if (language_spec && language_spec->country)
 505     return language_spec->country;
 506   else
 507     return "";
 508 }
 509
 510 std::string
 511 Language::get_modifier() const
 512 {
 513   if (language_spec && language_spec->modifier)
 514     return language_spec->modifier;
 515   else
 516     return "";
 517 }
 518
 519 std::string
 520 Language::get_name()  const
 521 {
 522   if (language_spec)
 523     return language_spec->name;
 524   else
 525     return "";
 526 }
 527
 528 std::string
 529 Language::str() const
 530 {
 531   if (language_spec)
 532   {
 533     std::string var;
 534     var += language_spec->language;
 535     if (language_spec->country)
 536     {
 537       var += "_";
 538       var += language_spec->country;
 539     }
 540
 541     if (language_spec->modifier)
 542     {
 543       var += "@";
 544       var += language_spec->modifier;
 545     }
 546     return var;
 547   }
 548   else
 549   {
 550     return "";
 551   }
 552 }
 553
 554 bool
 555 Language::operator==(const Language& rhs)
 556 {
 557   return language_spec == rhs.language_spec;
 558 }
 559
 560 bool
 561 Language::operator!=(const Language& rhs)
 562 {
 563   return language_spec != rhs.language_spec;
 564 }
 565 \f
 566 } // namespace tinygettext
 567
 568 /* EOF */