/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed * with this work for additional information regarding copyright * ownership. The ASF licenses this file to you under the Apache * License, Version 2.0 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at http://www.apache.org/licenses/LICENSE-2.0 . */ #include #include #include #include #include "i18nlangtag/mslangid.hxx" #include "i18nlangtag/languagetag.hxx" using namespace com::sun::star; // ======================================================================= static const LanguageType kSAME = 0xffff; namespace { inline LanguageType getOverrideLang( LanguageType nLang, LanguageType nOverride ) { return nOverride ? ((nOverride == kSAME) ? nLang : nOverride) : nLang; } } /* Usage of override mechanism: * If a table entry's mnOverride is not 0, an override entry with an mnLang * value of (mnOverride==kSAME ? mnLang : mnOverride) exists that should be * used instead. There MUST exist one such entry that does not have an * mnOverride value and within one table it MUST be located before any entry * with that mnLang and an mnOverride value of not 0. Usually kSAME is used as * override value, with rare exceptions, see tables below. * * The override serves these purposes: * - With getOverride() it indicates that there is a different language tag * (locale) that the requested language tag should be "canonicalized" to. * - With lookupFallbackLocale() a locale may be returned where the language * tag differs. * - With convertLanguageToLocaleImpl() and bIgnoreOverride=false the override * is followed and the override locale returned. * - With convertLocaleToLanguageImpl() a different LangID may be returned in * rare cases where the actual mapped ID differs. */ struct IsoLanguageCountryEntry { LanguageType mnLang; sal_Char maLanguage[4]; sal_Char maCountry[3]; LanguageType mnOverride; /** Obtain a language tag string with '-' separator. */ OUString getTagString() const; /** Obtain a locale. */ ::com::sun::star::lang::Locale getLocale() const; }; struct IsoLanguageScriptCountryEntry { LanguageType mnLang; sal_Char maLanguageScript[9]; ///< "ll-Ssss" or "lll-Ssss" sal_Char maCountry[3]; LanguageType mnOverride; /** Obtain a language tag string with '-' separator. */ OUString getTagString() const; /** Obtain a locale. */ ::com::sun::star::lang::Locale getLocale() const; /** If rStr starts with maLanguageScript ignoring case. We don't have OUString::startsWithIgnoreAsciiCaseAscii() */ bool startsInIgnoreAsciiCase( const OUString & rStr ) const; }; struct Bcp47CountryEntry { LanguageType mnLang; const sal_Char* mpBcp47; sal_Char maCountry[3]; const sal_Char* mpFallback; /** Obtain a language tag string with '-' separator. */ OUString getTagString() const; /** Obtain a locale. */ ::com::sun::star::lang::Locale getLocale() const; }; struct IsoLangEngEntry { LanguageType mnLang; sal_Char maCountry[3]; }; struct IsoLangNoneStdEntry { LanguageType mnLang; sal_Char maLanguage[4]; sal_Char maCountry[9]; }; struct IsoLangOtherEntry { LanguageType mnLang; const sal_Char* mpLanguage; }; // ----------------------------------------------------------------------- // Entries for languages are lower case, for countries upper case, as // recommended by rfc5646 (obsoletes rfc4646 (obsoletes rfc3066 (obsoletes // rfc1766))). convertIsoNamesToLanguage(), convertLocaleToLanguageImpl() // and lookupFallbackLocale() are case insensitive. // // Sort order: Most used first and within one language the default fallback // locale of that language first. // // The default entry for a LangID <-> ISO mapping has to be first. For // conversion of legacy mappings one LangID can map to multiple ISO codes // except if the LangID is primary-only, and one ISO code combination can map // to multiple LangIDs. For compatibility with already existing calls it can // also be a sequence as follows: // LANGUAGE_ENGLISH, "en", "" // LANGUAGE_ENGLISH_US, "en", "US" // Here, in a convertIsoNamesToLanguage() call "en-US" is converted to // LANGUAGE_ENGLISH_US and "en" is converted to LANGUAGE_ENGLISH. A call with // "en-ZZ" (not in table) would result in LANGUAGE_ENGLISH because the first // entry matching the language and not having a country is returned, regardless // of whether being sorted before or after other entries of the same language // with some country. To obtain a _locale_ (not language only) in the order // given, lookupFallbackLocale() must be called. // If the sequence instead was // LANGUAGE_ENGLISH_US, "en", "US" // LANGUAGE_ENGLISH, "en", "" // in a convertIsoNamesToLanguage() call "en-US" would still be converted to // LANGUAGE_ENGLISH_US, but "en" would _also_ be converted to // LANGUAGE_ENGLISH_US because no country was passed and it is the first entry // to match the language, see code. A call with "en-ZZ" (not in table) would // still result in LANGUAGE_ENGLISH. /* Currently (2013-08-29) only these primary LangID are still used literally in * code: * LANGUAGE_ENGLISH LANGUAGE_ARABIC_PRIMARY_ONLY */ static IsoLanguageCountryEntry const aImplIsoLangEntries[] = { // MS-LANGID codes, ISO639-1/2/3, ISO3166, override { LANGUAGE_ENGLISH, "en", "" , 0 }, { LANGUAGE_ENGLISH_US, "en", "US", 0 }, { LANGUAGE_ENGLISH_UK, "en", "GB", 0 }, { LANGUAGE_ENGLISH_AUS, "en", "AU", 0 }, { LANGUAGE_ENGLISH_CAN, "en", "CA", 0 }, { LANGUAGE_FRENCH, "fr", "FR", 0 }, { LANGUAGE_GERMAN, "de", "DE", 0 }, { LANGUAGE_ITALIAN, "it", "IT", 0 }, { LANGUAGE_DUTCH, "nl", "NL", 0 }, { LANGUAGE_SPANISH_MODERN, "es", "ES", 0 }, { LANGUAGE_SPANISH_DATED, "es", "ES", 0 }, { LANGUAGE_PORTUGUESE, "pt", "PT", 0 }, { LANGUAGE_PORTUGUESE_BRAZILIAN, "pt", "BR", 0 }, { LANGUAGE_DANISH, "da", "DK", 0 }, { LANGUAGE_GREEK, "el", "GR", 0 }, { LANGUAGE_CHINESE_SIMPLIFIED, "zh", "CN", 0 }, { LANGUAGE_CHINESE_SIMPLIFIED_LEGACY, "zh", "CN", 0 }, { LANGUAGE_CHINESE_TRADITIONAL, "zh", "TW", 0 }, { LANGUAGE_CHINESE_HONGKONG, "zh", "HK", 0 }, { LANGUAGE_CHINESE_SINGAPORE, "zh", "SG", 0 }, { LANGUAGE_CHINESE_MACAU, "zh", "MO", 0 }, { LANGUAGE_CHINESE_LSO, "zh", "" , 0 }, { LANGUAGE_YUE_CHINESE_HONGKONG, "yue", "HK", 0 }, { LANGUAGE_ENGLISH_HONG_KONG_SAR, "en", "HK", 0 }, { LANGUAGE_JAPANESE, "ja", "JP", 0 }, { LANGUAGE_KOREAN, "ko", "KR", 0 }, { LANGUAGE_KOREAN_JOHAB, "ko", "KR", 0 }, { LANGUAGE_USER_KOREAN_NORTH, "ko", "KP", 0 }, { LANGUAGE_SWEDISH, "sv", "SE", 0 }, { LANGUAGE_SWEDISH_FINLAND, "sv", "FI", 0 }, { LANGUAGE_FINNISH, "fi", "FI", 0 }, { LANGUAGE_RUSSIAN, "ru", "RU", 0 }, { LANGUAGE_TATAR, "tt", "RU", 0 }, { LANGUAGE_ENGLISH_NZ, "en", "NZ", 0 }, { LANGUAGE_ENGLISH_EIRE, "en", "IE", 0 }, { LANGUAGE_DUTCH_BELGIAN, "nl", "BE", 0 }, { LANGUAGE_FRENCH_BELGIAN, "fr", "BE", 0 }, { LANGUAGE_FRENCH_CANADIAN, "fr", "CA", 0 }, { LANGUAGE_FRENCH_SWISS, "fr", "CH", 0 }, { LANGUAGE_GERMAN_SWISS, "de", "CH", 0 }, { LANGUAGE_GERMAN_AUSTRIAN, "de", "AT", 0 }, { LANGUAGE_ITALIAN_SWISS, "it", "CH", 0 }, { LANGUAGE_ALBANIAN, "sq", "AL", 0 }, { LANGUAGE_ARABIC_SAUDI_ARABIA, "ar", "SA", 0 }, { LANGUAGE_ARABIC_EGYPT, "ar", "EG", 0 }, { LANGUAGE_ARABIC_UAE, "ar", "AE", 0 }, { LANGUAGE_ARABIC_IRAQ, "ar", "IQ", 0 }, { LANGUAGE_ARABIC_LIBYA, "ar", "LY", 0 }, { LANGUAGE_ARABIC_ALGERIA, "ar", "DZ", 0 }, { LANGUAGE_ARABIC_MOROCCO, "ar", "MA", 0 }, { LANGUAGE_ARABIC_TUNISIA, "ar", "TN", 0 }, { LANGUAGE_ARABIC_OMAN, "ar", "OM", 0 }, { LANGUAGE_ARABIC_YEMEN, "ar", "YE", 0 }, { LANGUAGE_ARABIC_SYRIA, "ar", "SY", 0 }, { LANGUAGE_ARABIC_JORDAN, "ar", "JO", 0 }, { LANGUAGE_ARABIC_LEBANON, "ar", "LB", 0 }, { LANGUAGE_ARABIC_KUWAIT, "ar", "KW", 0 }, { LANGUAGE_ARABIC_BAHRAIN, "ar", "BH", 0 }, { LANGUAGE_ARABIC_QATAR, "ar", "QA", 0 }, { LANGUAGE_USER_ARABIC_CHAD, "ar", "TD", 0 }, { LANGUAGE_USER_ARABIC_COMOROS, "ar", "KM", 0 }, { LANGUAGE_USER_ARABIC_DJIBOUTI, "ar", "DJ", 0 }, { LANGUAGE_USER_ARABIC_ERITREA, "ar", "ER", 0 }, { LANGUAGE_USER_ARABIC_ISRAEL, "ar", "IL", 0 }, { LANGUAGE_USER_ARABIC_MAURITANIA, "ar", "MR", 0 }, { LANGUAGE_USER_ARABIC_PALESTINE, "ar", "PS", 0 }, { LANGUAGE_USER_ARABIC_SOMALIA, "ar", "SO", 0 }, { LANGUAGE_USER_ARABIC_SUDAN, "ar", "SD", 0 }, { LANGUAGE_ARABIC_PRIMARY_ONLY, "ar", "" , 0 }, { LANGUAGE_BASQUE, "eu", "" , 0 }, { LANGUAGE_BULGARIAN, "bg", "BG", 0 }, { LANGUAGE_CZECH, "cs", "CZ", 0 }, { LANGUAGE_CZECH, "cz", "" , kSAME }, { LANGUAGE_ENGLISH_JAMAICA, "en", "JM", 0 }, { LANGUAGE_ENGLISH_CARRIBEAN, "en", "BS", 0 }, // not 100%, because AG is Bahamas { LANGUAGE_ENGLISH_BELIZE, "en", "BZ", 0 }, { LANGUAGE_ENGLISH_TRINIDAD, "en", "TT", 0 }, { LANGUAGE_ENGLISH_ZIMBABWE, "en", "ZW", 0 }, { LANGUAGE_ENGLISH_INDONESIA, "en", "ID", 0 }, { LANGUAGE_ESTONIAN, "et", "EE", 0 }, { LANGUAGE_FAEROESE, "fo", "FO", 0 }, { LANGUAGE_FARSI, "fa", "IR", 0 }, { LANGUAGE_FRENCH_LUXEMBOURG, "fr", "LU", 0 }, { LANGUAGE_FRENCH_MONACO, "fr", "MC", 0 }, { LANGUAGE_GERMAN_LUXEMBOURG, "de", "LU", 0 }, { LANGUAGE_GERMAN_LIECHTENSTEIN, "de", "LI", 0 }, { LANGUAGE_HEBREW, "he", "IL", 0 }, // new: old was "iw" { LANGUAGE_HEBREW, "iw", "IL", kSAME }, // old: new is "he" { LANGUAGE_HUNGARIAN, "hu", "HU", 0 }, { LANGUAGE_ICELANDIC, "is", "IS", 0 }, { LANGUAGE_INDONESIAN, "id", "ID", 0 }, // new: old was "in" { LANGUAGE_INDONESIAN, "in", "ID", kSAME }, // old: new is "id" { LANGUAGE_NORWEGIAN, "no", "NO", 0 }, { LANGUAGE_NORWEGIAN_BOKMAL, "nb", "NO", 0 }, { LANGUAGE_NORWEGIAN_BOKMAL_LSO, "nb", "" , 0 }, { LANGUAGE_NORWEGIAN_NYNORSK, "nn", "NO", 0 }, { LANGUAGE_NORWEGIAN_NYNORSK_LSO, "nn", "" , 0 }, { LANGUAGE_POLISH, "pl", "PL", 0 }, { LANGUAGE_RHAETO_ROMAN, "rm", "CH", 0 }, { LANGUAGE_ROMANIAN, "ro", "RO", 0 }, { LANGUAGE_ROMANIAN_MOLDOVA, "ro", "MD", 0 }, { LANGUAGE_SLOVAK, "sk", "SK", 0 }, { LANGUAGE_SLOVENIAN, "sl", "SI", 0 }, { LANGUAGE_SPANISH_MEXICAN, "es", "MX", 0 }, { LANGUAGE_SPANISH_GUATEMALA, "es", "GT", 0 }, { LANGUAGE_SPANISH_COSTARICA, "es", "CR", 0 }, { LANGUAGE_SPANISH_PANAMA, "es", "PA", 0 }, { LANGUAGE_SPANISH_DOMINICAN_REPUBLIC, "es", "DO", 0 }, { LANGUAGE_SPANISH_VENEZUELA, "es", "VE", 0 }, { LANGUAGE_SPANISH_COLOMBIA, "es", "CO", 0 }, { LANGUAGE_SPANISH_PERU, "es", "PE", 0 }, { LANGUAGE_SPANISH_ARGENTINA, "es", "AR", 0 }, { LANGUAGE_SPANISH_ECUADOR, "es", "EC", 0 }, { LANGUAGE_SPANISH_CHILE, "es", "CL", 0 }, { LANGUAGE_SPANISH_URUGUAY, "es", "UY", 0 }, { LANGUAGE_SPANISH_PARAGUAY, "es", "PY", 0 }, { LANGUAGE_SPANISH_BOLIVIA, "es", "BO", 0 }, { LANGUAGE_SPANISH_EL_SALVADOR, "es", "SV", 0 }, { LANGUAGE_SPANISH_HONDURAS, "es", "HN", 0 }, { LANGUAGE_SPANISH_NICARAGUA, "es", "NI", 0 }, { LANGUAGE_SPANISH_PUERTO_RICO, "es", "PR", 0 }, { LANGUAGE_SPANISH_UNITED_STATES, "es", "US", 0 }, { LANGUAGE_SPANISH_LATIN_AMERICA, "es", "" , 0 }, { LANGUAGE_TURKISH, "tr", "TR", 0 }, { LANGUAGE_UKRAINIAN, "uk", "UA", 0 }, { LANGUAGE_VIETNAMESE, "vi", "VN", 0 }, { LANGUAGE_LATVIAN, "lv", "LV", 0 }, { LANGUAGE_MACEDONIAN, "mk", "MK", 0 }, { LANGUAGE_MALAY_MALAYSIA, "ms", "MY", 0 }, { LANGUAGE_MALAY_BRUNEI_DARUSSALAM, "ms", "BN", 0 }, { LANGUAGE_ENGLISH_MALAYSIA, "en", "MY", 0 }, { LANGUAGE_THAI, "th", "TH", 0 }, { LANGUAGE_LITHUANIAN, "lt", "LT", 0 }, { LANGUAGE_LITHUANIAN_CLASSIC, "lt", "LT", 0 }, { LANGUAGE_CROATIAN, "hr", "HR", 0 }, // Croatian in Croatia { LANGUAGE_CROATIAN_BOSNIA_HERZEGOVINA, "hr", "BA", 0 }, { LANGUAGE_BOSNIAN_LATIN_BOSNIA_HERZEGOVINA, "bs", "BA", 0 }, { LANGUAGE_BOSNIAN_LSO, "bs", "" , 0 }, // so what is 'bs' vs 'bs-Latn'? { LANGUAGE_SERBIAN_CYRILLIC_SERBIA, "sr", "RS", 0 }, // Serbian Cyrillic in Serbia { LANGUAGE_OBSOLETE_USER_SERBIAN_CYRILLIC_SERBIA, "sr", "RS", 0 }, { LANGUAGE_SERBIAN_CYRILLIC_SAM, "sr", "CS", 0 }, // Serbian Cyrillic in Serbia and Montenegro { LANGUAGE_SERBIAN_CYRILLIC_SAM, "sr", "YU", kSAME }, // legacy Serbian Cyrillic in Serbia and Montenegro (former Yugoslavia); kludge, sr_CS not supported by ICU 2.6 (3.4 does) { LANGUAGE_SERBIAN_CYRILLIC_MONTENEGRO, "sr", "ME", 0 }, { LANGUAGE_OBSOLETE_USER_SERBIAN_CYRILLIC_MONTENEGRO, "sr", "ME", 0 }, { LANGUAGE_SERBIAN_CYRILLIC_BOSNIA_HERZEGOVINA, "sr", "BA", 0 }, { LANGUAGE_SERBIAN_CYRILLIC_LSO, "sr", "" , 0 }, { LANGUAGE_SERBIAN_LATIN_SERBIA, "sh", "RS", kSAME }, // legacy kludge, is sr-Latn-RS now { LANGUAGE_OBSOLETE_USER_SERBIAN_LATIN_SERBIA, "sh", "RS", kSAME }, // legacy kludge, is sr-Latn-RS now { LANGUAGE_SERBIAN_LATIN_SAM, "sh", "CS", kSAME }, // legacy kludge, is sr-Latn-CS now { LANGUAGE_SERBIAN_LATIN_SAM, "sh", "YU", kSAME }, // legacy kludge, is sr-Latn-YU now { LANGUAGE_SERBIAN_LATIN_MONTENEGRO, "sh", "ME", kSAME }, // legacy kludge, is sr-Latn-ME now { LANGUAGE_OBSOLETE_USER_SERBIAN_LATIN_MONTENEGRO, "sh", "ME", kSAME }, // legacy kludge, is sr-Latn-ME now { LANGUAGE_SERBIAN_LATIN_BOSNIA_HERZEGOVINA, "sh", "BA", kSAME }, // legacy kludge, is sr-Latn-BA now { LANGUAGE_SERBIAN_LATIN_LSO, "sh", "" , kSAME }, // legacy kludge, is sr-Latn now { LANGUAGE_ARMENIAN, "hy", "AM", 0 }, { LANGUAGE_AZERI_LATIN, "az", "AZ", 0 }, // macrolanguage code { LANGUAGE_UZBEK_LATIN, "uz", "UZ", 0 }, // macrolanguage code { LANGUAGE_UZBEK_LATIN_LSO, "uz", "" , 0 }, // macrolanguage code { LANGUAGE_BENGALI_BANGLADESH, "bn", "BD", 0 }, { LANGUAGE_BENGALI, "bn", "IN", 0 }, { LANGUAGE_BURMESE, "my", "MM", 0 }, { LANGUAGE_KAZAKH, "kk", "KZ", 0 }, { LANGUAGE_ENGLISH_INDIA, "en", "IN", 0 }, { LANGUAGE_URDU_INDIA, "ur", "IN", 0 }, { LANGUAGE_URDU_PAKISTAN, "ur", "PK", 0 }, { LANGUAGE_HINDI, "hi", "IN", 0 }, { LANGUAGE_GUJARATI, "gu", "IN", 0 }, { LANGUAGE_KANNADA, "kn", "IN", 0 }, { LANGUAGE_ASSAMESE, "as", "IN", 0 }, { LANGUAGE_KASHMIRI_INDIA, "ks", "IN", 0 }, { LANGUAGE_KASHMIRI, "ks", "" , kSAME }, // Kashmiri in "Jammu and Kashmir" ... no ISO3166 code for that { LANGUAGE_MALAYALAM, "ml", "IN", 0 }, { LANGUAGE_MANIPURI, "mni", "IN", 0 }, { LANGUAGE_MARATHI, "mr", "IN", 0 }, { LANGUAGE_KONKANI, "kok", "IN", 0 }, { LANGUAGE_NEPALI, "ne", "NP", 0 }, { LANGUAGE_NEPALI_INDIA, "ne", "IN", 0 }, { LANGUAGE_ORIYA, "or", "IN", 0 }, { LANGUAGE_PUNJABI, "pa", "IN", 0 }, { LANGUAGE_SANSKRIT, "sa", "IN", 0 }, { LANGUAGE_TAMIL, "ta", "IN", 0 }, { LANGUAGE_TAMIL_SRI_LANKA, "ta", "LK", 0 }, { LANGUAGE_TELUGU, "te", "IN", 0 }, { LANGUAGE_PUNJABI_PAKISTAN, "pnb", "PK", 0 }, { LANGUAGE_PUNJABI_ARABIC_LSO, "pnb", "" , 0 }, { LANGUAGE_PUNJABI_PAKISTAN, "lah", "PK", kSAME }, // macrolanguage code, earlier preferred 'lah' over 'pa' for Western Panjabi, now there is 'pnb' { LANGUAGE_PUNJABI_PAKISTAN, "pa", "PK", kSAME }, // MS maps this to 'pa-Arab-PK', but 'pa'='pan' Eastern Panjabi is not used in PK, only in IN { LANGUAGE_SINDHI_PAKISTAN, "sd", "PK", kSAME }, // Arabic script { LANGUAGE_SINDHI, "sd", "IN", 0 }, // TODO: there's Deva(nagari) and Arab(ic) script, MS maps this to 'sd-Deva-IN' { LANGUAGE_BELARUSIAN, "be", "BY", 0 }, { LANGUAGE_CATALAN, "ca", "ES", 0 }, // Spain (default) { LANGUAGE_CATALAN, "ca", "AD", 0 }, // Andorra //LANGUAGE_CATALAN_VALENCIAN ca-ES-valencia Bcp47CountryEntry takes precedence { LANGUAGE_CATALAN_VALENCIAN, "ca", "XV", kSAME }, // XV: ISO 3166 user-assigned; old workaround for UI localization only, in case it escaped to document content { LANGUAGE_CATALAN_VALENCIAN, "qcv", "ES", kSAME }, // qcv: ISO 639-3 reserved-for-local-use; old UI localization quirk only, in case it escaped to document content { LANGUAGE_FRENCH_CAMEROON, "fr", "CM", 0 }, { LANGUAGE_FRENCH_COTE_D_IVOIRE, "fr", "CI", 0 }, { LANGUAGE_FRENCH_MALI, "fr", "ML", 0 }, { LANGUAGE_FRENCH_SENEGAL, "fr", "SN", 0 }, { LANGUAGE_FRENCH_ZAIRE, "fr", "CD", 0 }, // Democratic Republic Of Congo { LANGUAGE_FRENCH_MOROCCO, "fr", "MA", 0 }, { LANGUAGE_FRENCH_REUNION, "fr", "RE", 0 }, { LANGUAGE_FRENCH, "fr", "" , 0 }, // needed as a catcher before other "fr" entries! { LANGUAGE_FRENCH_NORTH_AFRICA, "fr", "" , 0 }, { LANGUAGE_FRENCH_WEST_INDIES, "fr", "" , 0 }, // no ISO country code; MS "Neither defined nor reserved" { LANGUAGE_FRISIAN_NETHERLANDS, "fy", "NL", 0 }, { LANGUAGE_GAELIC_IRELAND, "ga", "IE", 0 }, { LANGUAGE_GAELIC_SCOTLAND, "gd", "GB", 0 }, { LANGUAGE_GAELIC_SCOTLAND_LEGACY, "gd", "GB", 0 }, { LANGUAGE_GALICIAN, "gl", "ES", 0 }, { LANGUAGE_GEORGIAN, "ka", "GE", 0 }, { LANGUAGE_KHMER, "km", "KH", 0 }, { LANGUAGE_KIRGHIZ, "ky", "KG", 0 }, { LANGUAGE_LAO, "lo", "LA", 0 }, { LANGUAGE_MALTESE, "mt", "MT", 0 }, { LANGUAGE_MONGOLIAN_CYRILLIC_MONGOLIA, "mn", "MN", 0 }, // macrolanguage code; should be khk-MN; Cyrillic script { LANGUAGE_MONGOLIAN_CYRILLIC_LSO, "mn", "" , 0 }, // macrolanguage code; should be khk; Cyrillic script { LANGUAGE_RUSSIAN_MOLDOVA, "mo", "MD", 0 }, { LANGUAGE_SWAHILI, "sw", "KE", 0 }, { LANGUAGE_USER_SWAHILI_TANZANIA, "sw", "TZ", 0 }, { LANGUAGE_TAJIK, "tg", "TJ", 0 }, { LANGUAGE_TAJIK_LSO, "tg", "" , 0 }, { LANGUAGE_TIBETAN, "bo", "CN", 0 }, // CN politically correct? { LANGUAGE_USER_TIBETAN_INDIA, "bo", "IN", 0 }, { LANGUAGE_USER_TIBETAN_BHUTAN, "bo", "BT", 0 }, // MS reserved, but with the ID error instead { LANGUAGE_DZONGKHA, "dz", "BT", 0 }, { LANGUAGE_USER_DZONGKHA_MAP_LONLY, "dz", "" , 0 }, // because of the MS error, see lang.h { LANGUAGE_TURKMEN, "tk", "TM", 0 }, { LANGUAGE_WELSH, "cy", "GB", 0 }, { LANGUAGE_SESOTHO, "st", "ZA", 0 }, { LANGUAGE_SEPEDI, "nso", "ZA", 0 }, { LANGUAGE_SEPEDI, "ns", "ZA", kSAME }, // fake "ns" for compatibility with existing OOo1.1.x localization to be able to read those documents { LANGUAGE_TSONGA, "ts", "ZA", 0 }, { LANGUAGE_TSWANA, "tn", "ZA", 0 }, { LANGUAGE_ENGLISH_SAFRICA, "en", "ZA", 0 }, { LANGUAGE_AFRIKAANS, "af", "ZA", 0 }, { LANGUAGE_VENDA, "ve", "ZA", 0 }, // default 639-1 { LANGUAGE_VENDA, "ven", "ZA", kSAME }, // 639-2 may have been used temporarily since 2004-07-23 { LANGUAGE_XHOSA, "xh", "ZA", 0 }, { LANGUAGE_ZULU, "zu", "ZA", 0 }, // { LANGUAGE_QUECHUA_COLOMBIA, "quc", "CO", 0 }, // MS reserved, and looks wrong, quc would be in Guatemala, not Colombia { LANGUAGE_QUECHUA_ECUADOR, "quz", "EC", 0 }, // MS { LANGUAGE_QUECHUA_ECUADOR, "qu", "EC", kSAME }, // macrolanguage code { LANGUAGE_QUECHUA_PERU, "quz", "PE", 0 }, // MS { LANGUAGE_QUECHUA_PERU, "qu", "PE", kSAME }, // macrolanguage code { LANGUAGE_QUECHUA_BOLIVIA, "qu", "BO", 0 }, // macrolanguage code, TODO instead: quh-BO or qul-BO; MS says quz-BO which is wrong { LANGUAGE_PASHTO, "ps", "AF", 0 }, { LANGUAGE_OROMO, "om", "ET", 0 }, { LANGUAGE_DHIVEHI, "dv", "MV", 0 }, { LANGUAGE_UIGHUR_CHINA, "ug", "CN", 0 }, { LANGUAGE_TIGRIGNA_ETHIOPIA, "ti", "ET", 0 }, { LANGUAGE_TIGRIGNA_ERITREA, "ti", "ER", 0 }, { LANGUAGE_AMHARIC_ETHIOPIA, "am", "ET", 0 }, { LANGUAGE_GUARANI_PARAGUAY, "gug", "PY", 0 }, { LANGUAGE_HAWAIIAN_UNITED_STATES, "haw", "US", 0 }, { LANGUAGE_EDO, "bin", "NG", 0 }, { LANGUAGE_FULFULDE_NIGERIA, "fuv", "NG", 0 }, { LANGUAGE_FULFULDE_NIGERIA, "ff", "NG", kSAME }, // macrolanguage code { LANGUAGE_FULFULDE_SENEGAL, "ff", "SN", 0 }, // macrolanguage code { LANGUAGE_HAUSA_NIGERIA, "ha", "NG", kSAME }, { LANGUAGE_USER_HAUSA_GHANA, "ha", "GH", kSAME }, { LANGUAGE_IGBO_NIGERIA, "ig", "NG", 0 }, { LANGUAGE_KANURI_NIGERIA, "kr", "NG", 0 }, { LANGUAGE_YORUBA, "yo", "NG", 0 }, { LANGUAGE_SOMALI, "so", "SO", 0 }, { LANGUAGE_PAPIAMENTU, "pap", "AN", 0 }, { LANGUAGE_USER_PAPIAMENTU_ARUBA, "pap", "AW", 0 }, { LANGUAGE_USER_PAPIAMENTU_CURACAO, "pap", "CW", 0 }, { LANGUAGE_USER_PAPIAMENTU_BONAIRE, "pap", "BQ", 0 }, { LANGUAGE_ENGLISH_SINGAPORE, "en", "SG", 0 }, { LANGUAGE_USER_YIDDISH_US, "yi", "US", 0 }, { LANGUAGE_YIDDISH, "yi", "IL", 0 }, // new: old was "ji" { LANGUAGE_YIDDISH, "ji", "IL", kSAME }, // old: new is "yi" { LANGUAGE_SYRIAC, "syr", "TR", 0 }, // "TR" according to http://www.ethnologue.com/show_language.asp?code=SYC { LANGUAGE_SINHALESE_SRI_LANKA, "si", "LK", 0 }, { LANGUAGE_CHEROKEE_UNITED_STATES, "chr", "US", kSAME }, { LANGUAGE_INUKTITUT_LATIN_CANADA, "iu", "CA", kSAME }, // macrolanguage code { LANGUAGE_INUKTITUT_LATIN_LSO, "iu", "" , kSAME }, // macrolanguage code { LANGUAGE_SAMI_NORTHERN_NORWAY, "se", "NO", 0 }, { LANGUAGE_SAMI_INARI, "smn", "FI", 0 }, { LANGUAGE_SAMI_INARI_LSO, "smn", "" , 0 }, { LANGUAGE_SAMI_LULE_NORWAY, "smj", "NO", 0 }, { LANGUAGE_SAMI_LULE_SWEDEN, "smj", "SE", 0 }, { LANGUAGE_SAMI_LULE_LSO, "smj", "" , 0 }, { LANGUAGE_SAMI_NORTHERN_FINLAND, "se", "FI", 0 }, { LANGUAGE_SAMI_NORTHERN_SWEDEN, "se", "SE", 0 }, { LANGUAGE_SAMI_SKOLT, "sms", "FI", 0 }, { LANGUAGE_SAMI_SKOLT_LSO, "sms", "" , 0 }, { LANGUAGE_SAMI_SOUTHERN_NORWAY, "sma", "NO", 0 }, { LANGUAGE_SAMI_SOUTHERN_SWEDEN, "sma", "SE", 0 }, { LANGUAGE_SAMI_SOUTHERN_LSO, "sma", "" , 0 }, { LANGUAGE_USER_SAMI_KILDIN_RUSSIA, "sjd", "RU", 0 }, { LANGUAGE_MAPUDUNGUN_CHILE, "arn", "CL", 0 }, { LANGUAGE_CORSICAN_FRANCE, "co", "FR", 0 }, { LANGUAGE_ALSATIAN_FRANCE, "gsw", "FR", 0 }, // in fact 'gsw' is Schwyzerduetsch (Swiss German), which is a dialect of Alemannic German, as is Alsatian. They aren't distinct languages and share this code. { LANGUAGE_YAKUT_RUSSIA, "sah", "RU", 0 }, { LANGUAGE_MOHAWK_CANADA, "moh", "CA", 0 }, { LANGUAGE_BASHKIR_RUSSIA, "ba", "RU", 0 }, { LANGUAGE_KICHE_GUATEMALA, "qut", "GT", 0 }, { LANGUAGE_DARI_AFGHANISTAN, "prs", "AF", 0 }, { LANGUAGE_DARI_AFGHANISTAN, "gbz", "AF", kSAME }, // was an error { LANGUAGE_WOLOF_SENEGAL, "wo", "SN", 0 }, { LANGUAGE_FILIPINO, "fil", "PH", 0 }, { LANGUAGE_USER_TAGALOG, "tl", "PH", 0 }, { LANGUAGE_ENGLISH_PHILIPPINES, "en", "PH", 0 }, { LANGUAGE_IBIBIO_NIGERIA, "ibb", "NG", 0 }, { LANGUAGE_YI, "ii", "CN", 0 }, { LANGUAGE_ENGLISH_ARAB_EMIRATES, "en", "AE", 0 }, // MS reserved { LANGUAGE_ENGLISH_BAHRAIN, "en", "BH", 0 }, // MS reserved { LANGUAGE_ENGLISH_EGYPT, "en", "EG", 0 }, // MS reserved { LANGUAGE_ENGLISH_JORDAN, "en", "JO", 0 }, // MS reserved { LANGUAGE_ENGLISH_KUWAIT, "en", "KW", 0 }, // MS reserved { LANGUAGE_ENGLISH_TURKEY, "en", "TR", 0 }, // MS reserved { LANGUAGE_ENGLISH_YEMEN, "en", "YE", 0 }, // MS reserved { LANGUAGE_TAMAZIGHT_LATIN_ALGERIA, "kab", "DZ", 0 }, // In practice Kabyle is the language used for this { LANGUAGE_OBSOLETE_USER_KABYLE, "kab", "DZ", 0 }, { LANGUAGE_TAMAZIGHT_LATIN_ALGERIA, "ber", "DZ", kSAME }, // In practice Algeria has standardized on Kabyle as the member of the "ber" collective which gets used there. { LANGUAGE_TAMAZIGHT_TIFINAGH_MOROCCO, "tmz", "MA", kSAME }, { LANGUAGE_TAMAZIGHT_MOROCCO, "tmz", "MA", 0 }, // MS reserved { LANGUAGE_TAMAZIGHT_TIFINAGH_MOROCCO, "ber", "MA", kSAME }, // Morocco is officially using Tifinagh for its Berber languages, old kludge to distinguish from LANGUAGE_TAMAZIGHT_LATIN_ALGERIA { LANGUAGE_USER_LATIN_VATICAN, "la", "VA", 0 }, { LANGUAGE_OBSOLETE_USER_LATIN, "la", "VA", 0 }, { LANGUAGE_LATIN_LSO, "la", "" , 0 }, { LANGUAGE_USER_ESPERANTO, "eo", "" , 0 }, { LANGUAGE_USER_INTERLINGUA, "ia", "" , 0 }, { LANGUAGE_MAORI_NEW_ZEALAND, "mi", "NZ", 0 }, { LANGUAGE_OBSOLETE_USER_MAORI, "mi", "NZ", 0 }, { LANGUAGE_KINYARWANDA_RWANDA, "rw", "RW", 0 }, { LANGUAGE_OBSOLETE_USER_KINYARWANDA, "rw", "RW", 0 }, { LANGUAGE_UPPER_SORBIAN_GERMANY, "hsb", "DE", 0 }, // MS maps this to 'wen-DE', which is nonsense. 'wen' is a collective language code, 'WEN' is a SIL code, see http://www.ethnologue.com/14/show_iso639.asp?code=wen and http://www.ethnologue.com/14/show_language.asp?code=WEN { LANGUAGE_OBSOLETE_USER_UPPER_SORBIAN,"hsb", "DE", 0 }, { LANGUAGE_LOWER_SORBIAN_GERMANY, "dsb", "DE", 0 }, // MS maps this to 'wee-DE', which is nonsense. 'WEE' is a SIL code, see http://www.ethnologue.com/14/show_language.asp?code=WEE { LANGUAGE_LOWER_SORBIAN_LSO, "dsb", "" , 0 }, { LANGUAGE_OBSOLETE_USER_LOWER_SORBIAN,"dsb", "DE", 0 }, { LANGUAGE_OCCITAN_FRANCE, "oc", "FR", 0 }, { LANGUAGE_OBSOLETE_USER_OCCITAN, "oc", "FR", 0 }, { LANGUAGE_USER_KURDISH_TURKEY, "ku", "TR", 0 }, { LANGUAGE_USER_KURDISH_SYRIA, "ku", "SY", 0 }, { LANGUAGE_USER_KURDISH_IRAQ, "ku", "IQ", 0 }, { LANGUAGE_USER_KURDISH_IRAN, "ku", "IR", 0 }, { LANGUAGE_USER_SARDINIAN, "sc", "IT", 0 }, // macrolanguage code { LANGUAGE_USER_SARDINIAN_CAMPIDANESE, "sro", "IT", 0 }, { LANGUAGE_USER_SARDINIAN_GALLURESE, "sdn", "IT", 0 }, { LANGUAGE_USER_SARDINIAN_LOGUDORESE, "src", "IT", 0 }, { LANGUAGE_USER_SARDINIAN_SASSARESE, "sdc", "IT", 0 }, { LANGUAGE_BRETON_FRANCE, "br", "FR", 0 }, { LANGUAGE_OBSOLETE_USER_BRETON, "br", "FR", 0 }, { LANGUAGE_KALAALLISUT_GREENLAND, "kl", "GL", 0 }, { LANGUAGE_OBSOLETE_USER_KALAALLISUT, "kl", "GL", 0 }, { LANGUAGE_USER_SWAZI, "ss", "ZA", 0 }, { LANGUAGE_USER_NDEBELE_SOUTH, "nr", "ZA", 0 }, { LANGUAGE_TSWANA_BOTSWANA, "tn", "BW", 0 }, { LANGUAGE_OBSOLETE_USER_TSWANA_BOTSWANA, "tn", "BW", 0 }, { LANGUAGE_USER_MOORE, "mos", "BF", 0 }, { LANGUAGE_USER_BAMBARA, "bm", "ML", 0 }, { LANGUAGE_USER_AKAN, "ak", "GH", 0 }, { LANGUAGE_LUXEMBOURGISH_LUXEMBOURG, "lb", "LU", 0 }, { LANGUAGE_OBSOLETE_USER_LUXEMBOURGISH, "lb", "LU", 0 }, { LANGUAGE_USER_FRIULIAN, "fur", "IT", 0 }, { LANGUAGE_USER_FIJIAN, "fj", "FJ", 0 }, { LANGUAGE_USER_AFRIKAANS_NAMIBIA, "af", "NA", 0 }, { LANGUAGE_USER_ENGLISH_NAMIBIA, "en", "NA", 0 }, { LANGUAGE_USER_WALLOON, "wa", "BE", 0 }, { LANGUAGE_USER_COPTIC, "cop", "EG", 0 }, { LANGUAGE_USER_GASCON, "gsc", "FR", 0 }, { LANGUAGE_USER_GERMAN_BELGIUM, "de", "BE", 0 }, { LANGUAGE_USER_CHUVASH, "cv", "RU", 0 }, { LANGUAGE_USER_EWE_GHANA, "ee", "GH", 0 }, { LANGUAGE_USER_ENGLISH_GHANA, "en", "GH", 0 }, { LANGUAGE_USER_SANGO, "sg", "CF", 0 }, { LANGUAGE_USER_GANDA, "lg", "UG", 0 }, { LANGUAGE_USER_LINGALA_DRCONGO, "ln", "CD", 0 }, { LANGUAGE_USER_LOW_GERMAN, "nds", "DE", 0 }, { LANGUAGE_USER_HILIGAYNON, "hil", "PH", 0 }, { LANGUAGE_USER_ENGLISH_MALAWI, "en", "MW", 0 }, /* en default for MW */ { LANGUAGE_USER_NYANJA, "ny", "MW", 0 }, { LANGUAGE_USER_KASHUBIAN, "csb", "PL", 0 }, { LANGUAGE_USER_SPANISH_CUBA, "es", "CU", 0 }, { LANGUAGE_USER_QUECHUA_NORTH_BOLIVIA, "qul", "BO", 0 }, { LANGUAGE_USER_QUECHUA_SOUTH_BOLIVIA, "quh", "BO", 0 }, { LANGUAGE_USER_BODO_INDIA, "brx", "IN", 0 }, { LANGUAGE_USER_DOGRI_INDIA, "dgo", "IN", 0 }, { LANGUAGE_USER_MAITHILI_INDIA, "mai", "IN", 0 }, { LANGUAGE_USER_SANTALI_INDIA, "sat", "IN", 0 }, { LANGUAGE_USER_TETUN, "tet", "ID", 0 }, { LANGUAGE_USER_TETUN_TIMOR_LESTE, "tet", "TL", 0 }, { LANGUAGE_USER_TOK_PISIN, "tpi", "PG", 0 }, { LANGUAGE_USER_SHUSWAP, "shs", "CA", 0 }, { LANGUAGE_USER_ANCIENT_GREEK, "grc", "GR", 0 }, { LANGUAGE_USER_ASTURIAN, "ast", "ES", 0 }, { LANGUAGE_USER_LATGALIAN, "ltg", "LV", 0 }, { LANGUAGE_USER_MAORE, "swb", "YT", 0 }, { LANGUAGE_USER_BUSHI, "buc", "YT", 0 }, { LANGUAGE_USER_TAHITIAN, "ty", "PF", 0 }, { LANGUAGE_MALAGASY_PLATEAU, "plt", "MG", 0 }, { LANGUAGE_MALAGASY_PLATEAU, "mg", "MG", kSAME }, { LANGUAGE_OBSOLETE_USER_MALAGASY_PLATEAU, "plt", "MG", 0 }, { LANGUAGE_USER_BAFIA, "ksf", "CM", 0 }, { LANGUAGE_USER_GIKUYU, "ki", "KE", 0 }, { LANGUAGE_USER_RUSYN_UKRAINE, "rue", "UA", 0 }, { LANGUAGE_USER_RUSYN_SLOVAKIA, "rue", "SK", 0 }, { LANGUAGE_USER_LIMBU, "lif", "NP", 0 }, { LANGUAGE_USER_LOJBAN, "jbo", "" , 0 }, { LANGUAGE_USER_HAITIAN, "ht", "HT", 0 }, { LANGUAGE_FRENCH_HAITI, "fr", "HT", 0 }, { LANGUAGE_USER_BEEMBE, "beq", "CG", 0 }, { LANGUAGE_USER_BEKWEL, "bkw", "CG", 0 }, { LANGUAGE_USER_KITUBA, "mkw", "CG", 0 }, { LANGUAGE_USER_LARI, "ldi", "CG", 0 }, { LANGUAGE_USER_MBOCHI, "mdw", "CG", 0 }, { LANGUAGE_USER_TEKE_EBOO, "ebo", "CG", 0 }, { LANGUAGE_USER_TEKE_IBALI, "tek", "CG", 0 }, { LANGUAGE_USER_TEKE_TYEE, "tyx", "CG", 0 }, { LANGUAGE_USER_VILI, "vif", "CG", 0 }, { LANGUAGE_USER_PORTUGUESE_ANGOLA, "pt", "AO", 0 }, { LANGUAGE_USER_MANX, "gv", "GB", 0 }, { LANGUAGE_USER_ARAGONESE, "an", "ES", 0 }, { LANGUAGE_USER_KEYID, "qtz", "" , 0 }, // key id pseudolanguage used for UI testing { LANGUAGE_USER_PALI_LATIN, "pli", "" , kSAME }, // Pali with Latin script, ISO 639-3 (sigh..) back-compat, Latin is not a default script though.. { LANGUAGE_USER_KYRGYZ_CHINA, "ky", "CN", 0 }, { LANGUAGE_USER_KOMI_ZYRIAN, "kpv", "RU", 0 }, { LANGUAGE_USER_KOMI_PERMYAK, "koi", "RU", 0 }, { LANGUAGE_USER_PITJANTJATJARA, "pjt", "AU", 0 }, { LANGUAGE_USER_ERZYA, "myv", "RU", 0 }, { LANGUAGE_USER_MARI_MEADOW, "mhr", "RU", 0 }, { LANGUAGE_USER_KHANTY, "kca", "RU", 0 }, { LANGUAGE_USER_LIVONIAN, "liv", "RU", 0 }, { LANGUAGE_USER_MOKSHA, "mdf", "RU", 0 }, { LANGUAGE_USER_MARI_HILL, "mrj", "RU", 0 }, { LANGUAGE_USER_NGANASAN, "nio", "RU", 0 }, { LANGUAGE_USER_OLONETS, "olo", "RU", 0 }, { LANGUAGE_USER_VEPS, "vep", "RU", 0 }, { LANGUAGE_USER_VORO, "vro", "EE", 0 }, { LANGUAGE_USER_NENETS, "yrk", "RU", 0 }, { LANGUAGE_USER_AKA, "axk", "CF", 0 }, { LANGUAGE_USER_AKA_CONGO, "axk", "CG", 0 }, { LANGUAGE_USER_DIBOLE, "bvx", "CG", 0 }, { LANGUAGE_USER_DOONDO, "dde", "CG", 0 }, { LANGUAGE_USER_KAAMBA, "xku", "CG", 0 }, { LANGUAGE_USER_KOONGO, "kng", "CD", 0 }, { LANGUAGE_USER_KOONGO_CONGO, "kng", "CG", 0 }, { LANGUAGE_USER_KUNYI, "njx", "CG", 0 }, { LANGUAGE_USER_NGUNGWEL, "ngz", "CG", 0 }, { LANGUAGE_USER_NJYEM, "njy", "CM", 0 }, { LANGUAGE_USER_NJYEM_CONGO, "njy", "CG", 0 }, { LANGUAGE_USER_PUNU, "puu", "GA", 0 }, { LANGUAGE_USER_PUNU_CONGO, "puu", "CG", 0 }, { LANGUAGE_USER_SUUNDI, "sdj", "CG", 0 }, { LANGUAGE_USER_TEKE_KUKUYA, "kkw", "CG", 0 }, { LANGUAGE_USER_TSAANGI, "tsa", "CG", 0 }, { LANGUAGE_USER_YAKA, "iyx", "CG", 0 }, { LANGUAGE_USER_YOMBE, "yom", "CD", 0 }, { LANGUAGE_USER_YOMBE_CONGO, "yom", "CG", 0 }, { LANGUAGE_USER_SIDAMA, "sid", "ET", 0 }, { LANGUAGE_USER_NKO, "nqo", "GN", 0 }, { LANGUAGE_USER_UDMURT, "udm", "RU", 0 }, { LANGUAGE_USER_CORNISH, "kw", "UK", 0 }, { LANGUAGE_USER_SAMI_PITE_SWEDEN, "sje", "SE", 0 }, { LANGUAGE_USER_NGAEBERE, "gym", "PA", 0 }, { LANGUAGE_USER_KUMYK, "kum", "RU", 0 }, { LANGUAGE_USER_NOGAI, "nog", "RU", 0 }, { LANGUAGE_USER_LADIN, "lld", "IT", 0 }, { LANGUAGE_USER_FRENCH_BURKINA_FASO, "fr", "BF", 0 }, { LANGUAGE_USER_PUINAVE, "pui", "CO", 0 }, { LANGUAGE_MULTIPLE, "mul", "" , 0 }, // multiple languages, many languages are used { LANGUAGE_UNDETERMINED, "und", "" , 0 }, // undetermined language, language cannot be identified { LANGUAGE_NONE, "zxx", "" , 0 }, // added to ISO 639-2 on 2006-01-11: Used to declare the absence of linguistic information { LANGUAGE_DONTKNOW, "", "" , 0 } // marks end of table }; static IsoLanguageScriptCountryEntry const aImplIsoLangScriptEntries[] = { // MS-LangID, ISO639-ISO15924, ISO3166, override { LANGUAGE_SERBIAN_LATIN_SERBIA, "sr-Latn", "RS", 0 }, { LANGUAGE_OBSOLETE_USER_SERBIAN_LATIN_SERBIA, "sr-Latn", "RS", 0 }, { LANGUAGE_SERBIAN_LATIN_MONTENEGRO, "sr-Latn", "ME", 0 }, { LANGUAGE_OBSOLETE_USER_SERBIAN_LATIN_MONTENEGRO,"sr-Latn", "ME", 0 }, { LANGUAGE_SERBIAN_LATIN_BOSNIA_HERZEGOVINA, "sr-Latn", "BA", 0 }, { LANGUAGE_SERBIAN_LATIN_SAM, "sr-Latn", "CS", 0 }, // Serbian Latin in Serbia and Montenegro; note that not all applications may know about the 'CS' reusage mess, see https://en.wikipedia.org/wiki/ISO_3166-2:CS { LANGUAGE_SERBIAN_LATIN_SAM, "sr-Latn", "YU", 0 }, // legacy Serbian Latin in Yugoslavia { LANGUAGE_SERBIAN_LATIN_LSO, "sr-Latn", "" , 0 }, { LANGUAGE_SERBIAN_LATIN_NEUTRAL, "sr-Latn", "" , 0 }, // MS lists this as 'sr' only, what a mess { LANGUAGE_SERBIAN_CYRILLIC_SERBIA, "sr-Cyrl", "RS", kSAME }, // MS { LANGUAGE_SERBIAN_CYRILLIC_MONTENEGRO, "sr-Cyrl", "ME", kSAME }, // MS { LANGUAGE_SERBIAN_CYRILLIC_BOSNIA_HERZEGOVINA, "sr-Cyrl", "BA", kSAME }, // MS { LANGUAGE_SERBIAN_CYRILLIC_SAM, "sr-Cyrl", "CS", kSAME }, // MS { LANGUAGE_SERBIAN_CYRILLIC_LSO, "sr-Cyrl", "" , kSAME }, // MS { LANGUAGE_BOSNIAN_CYRILLIC_BOSNIA_HERZEGOVINA, "bs-Cyrl", "BA", 0 }, { LANGUAGE_BOSNIAN_CYRILLIC_LSO, "bs-Cyrl", "" , 0 }, { LANGUAGE_AZERI_CYRILLIC, "az-Cyrl", "AZ", 0 }, // macrolanguage code { LANGUAGE_AZERI_CYRILLIC_LSO, "az-Cyrl", "" , 0 }, // macrolanguage code { LANGUAGE_UZBEK_CYRILLIC, "uz-Cyrl", "UZ", 0 }, // macrolanguage code { LANGUAGE_UZBEK_CYRILLIC_LSO, "uz-Cyrl", "" , 0 }, // macrolanguage code { LANGUAGE_MONGOLIAN_CYRILLIC_MONGOLIA, "mn-Cyrl", "MN", 0 }, // macrolanguage code; should be khk-MN or khk-Cyrl-MN { LANGUAGE_MONGOLIAN_CYRILLIC_LSO, "mn-Cyrl", "" , 0 }, // macrolanguage code; MS, should be khk or khk-Cyrl { LANGUAGE_MONGOLIAN_MONGOLIAN_MONGOLIA, "mn-Mong", "MN", 0 }, // macrolanguage code; MS, should be khk-Mong-MN { LANGUAGE_MONGOLIAN_MONGOLIAN_CHINA, "mn-Mong", "CN", 0 }, // macrolanguage code; MS, should actually be mvf-CN { LANGUAGE_MONGOLIAN_MONGOLIAN_LSO, "mn-Mong", "" , 0 }, // macrolanguage code { LANGUAGE_USER_PALI_LATIN, "pi-Latn", "" , 0 }, { LANGUAGE_USER_KARAKALPAK_LATIN, "kaa-Latn", "UZ", 0 }, { LANGUAGE_TAJIK, "tg-Cyrl", "TJ", 0 }, // MS { LANGUAGE_TAJIK_LSO, "tg-Cyrl", "" , 0 }, // MS { LANGUAGE_AZERI_LATIN, "az-Latn", "AZ", 0 }, // macrolanguage code; MS { LANGUAGE_AZERI_LATIN_LSO, "az-Latn", "" , 0 }, // macrolanguage code; MS { LANGUAGE_USER_YIDDISH_US, "yi-Hebr", "US", kSAME }, // macrolanguage code; MS, Hebr is suppress-script { LANGUAGE_YIDDISH, "yi-Hebr", "IL", kSAME }, // macrolanguage code; MS, Hebr is suppress-script { LANGUAGE_UZBEK_LATIN, "uz-Latn", "UZ", 0 }, // macrolanguage code { LANGUAGE_UZBEK_LATIN_LSO, "uz-Latn", "" , 0 }, // { LANGUAGE_SINDHI, "sd-Deva", "IN", 0 }, // MS, TODO: see comment above in aImplIsoLangEntries { LANGUAGE_SINDHI_PAKISTAN, "sd-Arab", "PK", 0 }, // MS { LANGUAGE_SINDHI_ARABIC_LSO, "sd-Arab", "" , 0 }, { LANGUAGE_CHEROKEE_UNITED_STATES, "chr-Cher", "US", 0 }, // MS { LANGUAGE_CHEROKEE_CHEROKEE_LSO, "chr-Cher", "" , 0 }, { LANGUAGE_INUKTITUT_SYLLABICS_CANADA, "iu-Cans", "CA", 0 }, // macrolanguage code, MS { LANGUAGE_INUKTITUT_SYLLABICS_LSO, "iu-Cans", "" , 0 }, // macrolanguage code, MS { LANGUAGE_INUKTITUT_LATIN_CANADA, "iu-Latn", "CA", 0 }, // macrolanguage code, MS { LANGUAGE_INUKTITUT_LATIN_LSO, "iu-Latn", "" , 0 }, // macrolanguage code, MS { LANGUAGE_TAMAZIGHT_TIFINAGH_MOROCCO, "tzm-Tfng", "MA", 0 }, { LANGUAGE_TAMAZIGHT_TIFINAGH_LSO, "tzm-Tfng", "" , 0 }, { LANGUAGE_KASHMIRI_INDIA, "ks-Deva", "IN", 0 }, // MS { LANGUAGE_KASHMIRI, "ks-Arab", "" , 0 }, // MS, Kashmiri in "Jammu and Kashmir" ... no ISO3166 code for that { LANGUAGE_HAUSA_NIGERIA, "ha-Latn", "NG", 0 }, // MS { LANGUAGE_USER_HAUSA_GHANA, "ha-Latn", "GH", 0 }, { LANGUAGE_HAUSA_LATIN_LSO, "ha-Latn", "" , 0 }, { LANGUAGE_LATIN_LSO, "la-Latn", "" , kSAME }, // MS, though Latn is suppress-script { LANGUAGE_TAI_NUA_CHINA, "tdd-Tale", "CN", 0 }, // MS reserved { LANGUAGE_LU_CHINA, "khb-Talu", "CN", 0 }, // MS reserved { LANGUAGE_KURDISH_ARABIC_IRAQ, "ku-Arab", "IQ", 0 }, // macrolanguage code, MS { LANGUAGE_KURDISH_ARABIC_LSO, "ku-Arab", "" , 0 }, // macrolanguage code { LANGUAGE_PUNJABI_PAKISTAN, "pnb-Arab", "PK", 0 }, { LANGUAGE_PUNJABI_ARABIC_LSO, "pnb-Arab", "" , 0 }, { LANGUAGE_PUNJABI_PAKISTAN, "pa-Arab", "PK", 0 }, // MS, incorrect { LANGUAGE_PUNJABI_ARABIC_LSO, "pa-Arab", "" , 0 }, // MS, incorrect { LANGUAGE_TAMAZIGHT_LATIN_ALGERIA, "tzm-Latn", "DZ", kSAME }, // MS { LANGUAGE_TAMAZIGHT_LATIN_LSO, "tzm-Latn", "" , 0 }, // MS { LANGUAGE_FULFULDE_SENEGAL, "ff-Latn", "SN", 0 }, // macrolanguage code, MS { LANGUAGE_FULFULDE_LATIN_LSO, "ff-Latn", "" , 0 }, // macrolanguage code { LANGUAGE_BOSNIAN_LATIN_BOSNIA_HERZEGOVINA, "bs-Latn", "BA", kSAME }, // MS, though Latn is suppress-script { LANGUAGE_BOSNIAN_LATIN_LSO, "bs-Latn", "" , LANGUAGE_BOSNIAN_LSO }, // MS, though Latn is suppress-script { LANGUAGE_CHINESE_TRADITIONAL_LSO, "zh-Hant", "" , 0 }, { LANGUAGE_DONTKNOW, "", "" , 0 } // marks end of table }; static Bcp47CountryEntry const aImplBcp47CountryEntries[] = { // MS-LangID full BCP47, ISO3166, ISO639-Variant or other fallback { LANGUAGE_CATALAN_VALENCIAN, "ca-ES-valencia", "ES", "ca-valencia" }, { LANGUAGE_OBSOLETE_USER_CATALAN_VALENCIAN, "ca-ES-valencia", "ES", "" }, // In case MS format files using the old value escaped into the wild, map them back. { LANGUAGE_USER_ENGLISH_UK_OED, "en-GB-oed", "GB", "" }, // grandfathered // { LANGUAGE_YUE_CHINESE_HONGKONG, "zh-yue-HK", "HK", "" }, // MS reserved, prefer yue-HK; do not add unless LanguageTag::simpleExtract() can handle it to not call liblangtag for rsc! { LANGUAGE_DONTKNOW, "", "", "" } // marks end of table }; static IsoLanguageCountryEntry aLastResortFallbackEntry = { LANGUAGE_ENGLISH_US, "en", "US", false }; OUString IsoLanguageCountryEntry::getTagString() const { if (maCountry[0]) return OUString( OUString::createFromAscii( maLanguage) + "-" + OUString::createFromAscii( maCountry)); else return OUString::createFromAscii( maLanguage); } ::com::sun::star::lang::Locale IsoLanguageCountryEntry::getLocale() const { return lang::Locale( OUString::createFromAscii( maLanguage), OUString::createFromAscii( maCountry), OUString()); } OUString IsoLanguageScriptCountryEntry::getTagString() const { if (maCountry[0]) return OUString( OUString::createFromAscii( maLanguageScript) + "-" + OUString::createFromAscii( maCountry)); else return OUString::createFromAscii( maLanguageScript); } ::com::sun::star::lang::Locale IsoLanguageScriptCountryEntry::getLocale() const { return lang::Locale( I18NLANGTAG_QLT, OUString::createFromAscii( maCountry), getTagString()); } bool IsoLanguageScriptCountryEntry::startsInIgnoreAsciiCase( const OUString & rStr ) const { return rStr.matchIgnoreAsciiCaseAsciiL( maLanguageScript, strlen( maLanguageScript), 0); } OUString Bcp47CountryEntry::getTagString() const { return OUString::createFromAscii( mpBcp47); } ::com::sun::star::lang::Locale Bcp47CountryEntry::getLocale() const { return lang::Locale( I18NLANGTAG_QLT, OUString::createFromAscii( maCountry), getTagString()); } // ----------------------------------------------------------------------- // In this table are the countries which should mapped to a specific // english language static IsoLangEngEntry const aImplIsoLangEngEntries[] = { { LANGUAGE_ENGLISH_UK, "AO" }, // Angola { LANGUAGE_ENGLISH_UK, "BJ" }, // Benin { LANGUAGE_ENGLISH_UK, "BW" }, // Botswana { LANGUAGE_ENGLISH_UK, "BI" }, // Burundi { LANGUAGE_ENGLISH_UK, "CM" }, // Cameroon { LANGUAGE_ENGLISH_UK, "GA" }, // Gabon { LANGUAGE_ENGLISH_UK, "GM" }, // Gambia { LANGUAGE_ENGLISH_UK, "GH" }, // Ghana { LANGUAGE_ENGLISH_UK, "GN" }, // Guinea { LANGUAGE_ENGLISH_UK, "LS" }, // Lesotho { LANGUAGE_ENGLISH_UK, "MW" }, // Malawi { LANGUAGE_ENGLISH_UK, "MT" }, // Malta { LANGUAGE_ENGLISH_UK, "NA" }, // Namibia { LANGUAGE_ENGLISH_UK, "NG" }, // Nigeria { LANGUAGE_ENGLISH_UK, "UG" }, // Uganda { LANGUAGE_ENGLISH_UK, "ZM" }, // Zambia { LANGUAGE_ENGLISH_UK, "ZW" }, // Zimbabwe { LANGUAGE_ENGLISH_UK, "SZ" }, // Swaziland { LANGUAGE_ENGLISH_UK, "NG" }, // Sierra Leone { LANGUAGE_ENGLISH_UK, "KN" }, // Saint Kitts and Nevis { LANGUAGE_ENGLISH_UK, "SH" }, // St. Helena { LANGUAGE_ENGLISH_UK, "IO" }, // British Indian Oceanic Territory { LANGUAGE_ENGLISH_UK, "FK" }, // Falkland Islands { LANGUAGE_ENGLISH_UK, "GI" }, // Gibraltar { LANGUAGE_ENGLISH_UK, "KI" }, // Kiribati { LANGUAGE_ENGLISH_UK, "VG" }, // Virgin Islands { LANGUAGE_ENGLISH_UK, "MU" }, // Mauritius { LANGUAGE_ENGLISH_UK, "FJ" }, // Fiji { LANGUAGE_ENGLISH_US, "KI" }, // Kiribati { LANGUAGE_ENGLISH_US, "LR" }, // Liberia { LANGUAGE_ENGLISH_US, "GU" }, // Guam { LANGUAGE_ENGLISH_US, "MH" }, // Marshall Islands { LANGUAGE_ENGLISH_US, "PW" }, // Palau { LANGUAGE_ENGLISH_CARRIBEAN, "AI" }, // Anguilla { LANGUAGE_ENGLISH_CARRIBEAN, "AG" }, // Antigua and Barbuda { LANGUAGE_ENGLISH_CARRIBEAN, "BS" }, // Bahamas { LANGUAGE_ENGLISH_CARRIBEAN, "BB" }, // Barbedos { LANGUAGE_ENGLISH_CARRIBEAN, "BM" }, // Bermuda { LANGUAGE_ENGLISH_CARRIBEAN, "KY" }, // Cayman Islands { LANGUAGE_ENGLISH_CARRIBEAN, "GD" }, // Grenada { LANGUAGE_ENGLISH_CARRIBEAN, "DM" }, // Dominica { LANGUAGE_ENGLISH_CARRIBEAN, "HT" }, // Haiti { LANGUAGE_ENGLISH_CARRIBEAN, "MS" }, // Montserrat { LANGUAGE_ENGLISH_CARRIBEAN, "FM" }, // Micronesia { LANGUAGE_ENGLISH_CARRIBEAN, "VC" }, // St. Vincent / Grenadines { LANGUAGE_ENGLISH_CARRIBEAN, "LC" }, // Saint Lucia { LANGUAGE_ENGLISH_CARRIBEAN, "TC" }, // Turks & Caicos Islands { LANGUAGE_ENGLISH_CARRIBEAN, "GY" }, // Guyana { LANGUAGE_ENGLISH_CARRIBEAN, "TT" }, // Trinidad and Tobago { LANGUAGE_ENGLISH_AUS, "CX" }, // Christmas Islands { LANGUAGE_ENGLISH_AUS, "CC" }, // Cocos (Keeling) Islands { LANGUAGE_ENGLISH_AUS, "NF" }, // Norfolk Island { LANGUAGE_ENGLISH_AUS, "PG" }, // Papua New Guinea { LANGUAGE_ENGLISH_AUS, "SB" }, // Solomon Islands { LANGUAGE_ENGLISH_AUS, "TV" }, // Tuvalu { LANGUAGE_ENGLISH_AUS, "NR" }, // Nauru { LANGUAGE_ENGLISH_NZ, "CK" }, // Cook Islands { LANGUAGE_ENGLISH_NZ, "NU" }, // Niue { LANGUAGE_ENGLISH_NZ, "TK" }, // Tokelau { LANGUAGE_ENGLISH_NZ, "TO" }, // Tonga { LANGUAGE_DONTKNOW, "" } // marks end of table }; // ----------------------------------------------------------------------- static IsoLangNoneStdEntry const aImplIsoNoneStdLangEntries[] = { { LANGUAGE_NORWEGIAN_BOKMAL, "no", "BOK" }, // registered subtags for "no" in rfc1766 { LANGUAGE_NORWEGIAN_NYNORSK, "no", "NYN" }, // registered subtags for "no" in rfc1766 { LANGUAGE_SERBIAN_LATIN_SAM, "sr", "latin" }, { LANGUAGE_SERBIAN_CYRILLIC_SAM, "sr", "cyrillic" }, { LANGUAGE_AZERI_LATIN, "az", "latin" }, { LANGUAGE_AZERI_CYRILLIC, "az", "cyrillic" }, { LANGUAGE_DONTKNOW, "", "" } // marks end of table }; // ----------------------------------------------------------------------- // in this table are only names to find the best language static IsoLangNoneStdEntry const aImplIsoNoneStdLangEntries2[] = { { LANGUAGE_NORWEGIAN_BOKMAL, "no", "bokmaal" }, { LANGUAGE_NORWEGIAN_BOKMAL, "no", "bokmal" }, { LANGUAGE_NORWEGIAN_NYNORSK, "no", "nynorsk" }, { LANGUAGE_DONTKNOW, "", "" } // marks end of table }; // ----------------------------------------------------------------------- // in this table are only names to find the best language static IsoLangOtherEntry const aImplOtherEntries[] = { { LANGUAGE_ENGLISH_US, "c" }, { LANGUAGE_CHINESE, "chinese" }, { LANGUAGE_GERMAN, "german" }, { LANGUAGE_JAPANESE, "japanese" }, { LANGUAGE_KOREAN, "korean" }, { LANGUAGE_ENGLISH_US, "posix" }, { LANGUAGE_CHINESE_TRADITIONAL, "tchinese" }, { LANGUAGE_DONTKNOW, NULL } // marks end of table }; // in this table are only privateuse names static IsoLangOtherEntry const aImplPrivateUseEntries[] = { { LANGUAGE_USER_PRIV_NOTRANSLATE, "x-no-translate" }, //! not BCP47 but legacy in .xcu configmgr { LANGUAGE_USER_PRIV_DEFAULT, "x-default" }, { LANGUAGE_USER_PRIV_COMMENT, "x-comment" }, { LANGUAGE_USER_PRIV_JOKER, "*" }, //! not BCP47 but transferable in configmgr { LANGUAGE_DONTKNOW, NULL } // marks end of table }; // ======================================================================= // static void MsLangId::Conversion::convertLanguageToLocaleImpl( LanguageType nLang, ::com::sun::star::lang::Locale & rLocale, bool bIgnoreOverride ) { const IsoLanguageScriptCountryEntry* pScriptEntryOverride = NULL; const IsoLanguageCountryEntry* pEntryOverride = NULL; Label_Override_Lang_Locale: // Search for LangID in BCP47 for (const Bcp47CountryEntry* pBcp47Entry = aImplBcp47CountryEntries; pBcp47Entry->mnLang != LANGUAGE_DONTKNOW; ++pBcp47Entry) { if (pBcp47Entry->mnLang == nLang) { rLocale.Language = I18NLANGTAG_QLT; rLocale.Country = OUString::createFromAscii( pBcp47Entry->maCountry); rLocale.Variant = pBcp47Entry->getTagString(); return; } } // Search for LangID in ISO lll-Ssss-CC for (const IsoLanguageScriptCountryEntry* pScriptEntry = aImplIsoLangScriptEntries; pScriptEntry->mnLang != LANGUAGE_DONTKNOW; ++pScriptEntry) { if (pScriptEntry->mnLang == nLang) { if (bIgnoreOverride || !pScriptEntry->mnOverride) { rLocale.Language = I18NLANGTAG_QLT; rLocale.Country = OUString::createFromAscii( pScriptEntry->maCountry); rLocale.Variant = pScriptEntry->getTagString(); return; } else if (pScriptEntry->mnOverride && pScriptEntryOverride != pScriptEntry) { pScriptEntryOverride = pScriptEntry; nLang = getOverrideLang( pScriptEntry->mnLang, pScriptEntry->mnOverride); goto Label_Override_Lang_Locale; } } } // Search for LangID in ISO lll-CC for (const IsoLanguageCountryEntry* pEntry = aImplIsoLangEntries; pEntry->mnLang != LANGUAGE_DONTKNOW; ++pEntry) { if (pEntry->mnLang == nLang) { if (bIgnoreOverride || !pEntry->mnOverride) { rLocale.Language = OUString::createFromAscii( pEntry->maLanguage ); rLocale.Country = OUString::createFromAscii( pEntry->maCountry ); rLocale.Variant = OUString(); return; } else if (pEntry->mnOverride && pEntryOverride != pEntry) { pEntryOverride = pEntry; nLang = getOverrideLang( pEntry->mnLang, pEntry->mnOverride); goto Label_Override_Lang_Locale; } } } // Look for privateuse definitions. for (const IsoLangOtherEntry* pPrivateEntry = aImplPrivateUseEntries; pPrivateEntry->mnLang != LANGUAGE_DONTKNOW; ++pPrivateEntry) { if (pPrivateEntry->mnLang == nLang) { rLocale.Language = I18NLANGTAG_QLT; rLocale.Country = OUString(); rLocale.Variant = OUString::createFromAscii( pPrivateEntry->mpLanguage ); return; } } // Not found. Passed rLocale argument remains unchanged. } // ----------------------------------------------------------------------- // static com::sun::star::lang::Locale MsLangId::Conversion::getLocale( const IsoLanguageCountryEntry * pEntry ) { if (pEntry->mnOverride) { lang::Locale aLocale; convertLanguageToLocaleImpl( getOverrideLang( pEntry->mnLang, pEntry->mnOverride), aLocale, false); return aLocale; } else return pEntry->getLocale(); } // static com::sun::star::lang::Locale MsLangId::Conversion::getLocale( const IsoLanguageScriptCountryEntry * pEntry ) { if (pEntry->mnOverride) { lang::Locale aLocale; convertLanguageToLocaleImpl( getOverrideLang( pEntry->mnLang, pEntry->mnOverride), aLocale, false); return aLocale; } else return pEntry->getLocale(); } // static ::com::sun::star::lang::Locale MsLangId::Conversion::lookupFallbackLocale( const ::com::sun::star::lang::Locale & rLocale ) { // language is lower case in table OUString aLowerLang = rLocale.Language.toAsciiLowerCase(); // country is upper case in table OUString aUpperCountry = rLocale.Country.toAsciiUpperCase(); sal_Int32 nCountryLen = aUpperCountry.getLength(); if (rLocale.Language == I18NLANGTAG_QLT) { // Search in BCP47, only full match and one fallback, for other // fallbacks only LanguageTag can decide. for (const Bcp47CountryEntry* pBcp47Entry = aImplBcp47CountryEntries; pBcp47Entry->mnLang != LANGUAGE_DONTKNOW; ++pBcp47Entry) { if ( rLocale.Variant.equalsIgnoreAsciiCase( pBcp47Entry->getTagString()) || rLocale.Variant.equalsIgnoreAsciiCaseAscii( pBcp47Entry->mpFallback)) return pBcp47Entry->getLocale(); } // Search in ISO lll-Ssss-CC const IsoLanguageScriptCountryEntry* pFirstScript = NULL; for (const IsoLanguageScriptCountryEntry* pScriptEntry = aImplIsoLangScriptEntries; pScriptEntry->mnLang != LANGUAGE_DONTKNOW; ++pScriptEntry) { if (pScriptEntry->startsInIgnoreAsciiCase( rLocale.Variant)) { if (rLocale.Variant.equalsIgnoreAsciiCase( pScriptEntry->getTagString())) return getLocale( pScriptEntry); // may override if (!pFirstScript) pFirstScript = pScriptEntry; } } // If at least a lll-Ssss matched, try that with country or use it as // fallback. if (pFirstScript) { // Check for country only if there is more than lll-Ssss-CC in tag // string, else we would had matched it already. if (!aUpperCountry.isEmpty() && rLocale.Variant.getLength() > 11) { for (const IsoLanguageScriptCountryEntry* pScriptEntry = pFirstScript; pScriptEntry->mnLang != LANGUAGE_DONTKNOW; ++pScriptEntry) { if (aUpperCountry.equalsAscii( pScriptEntry->maCountry) && pScriptEntry->startsInIgnoreAsciiCase( rLocale.Variant)) return getLocale( pScriptEntry); // may override } } return getLocale( pFirstScript); // may override } // Extract language from tag string, country is used as present in // Locale because in the tables that follow we have only ISO 3166 // countries and if that is in the tag string we also have it in the // Locale. sal_Int32 nIndex = 0; aLowerLang = rLocale.Variant.getToken( 0, '-', nIndex).toAsciiLowerCase(); // Nothing with "x-..." or "i-..." or any 1 letter in lll-CC table that // follows. if (aLowerLang.getLength() == 1) return aLastResortFallbackEntry.getLocale(); } // Search for locale and remember first lang-only. const IsoLanguageCountryEntry* pFirstLang = NULL; const IsoLanguageCountryEntry* pEntry = aImplIsoLangEntries; for ( ; pEntry->mnLang != LANGUAGE_DONTKNOW; ++pEntry) { if (aLowerLang.equalsAscii( pEntry->maLanguage)) { if (*pEntry->maCountry) { if (nCountryLen && aUpperCountry.equalsAscii( pEntry->maCountry)) return getLocale( pEntry); // may override } else { switch (pEntry->mnLang) { // These are known to have no country assigned. case LANGUAGE_BASQUE: case LANGUAGE_USER_ESPERANTO: case LANGUAGE_USER_INTERLINGUA: case LANGUAGE_USER_LOJBAN: case LANGUAGE_KASHMIRI: case LANGUAGE_USER_KEYID: return getLocale( pEntry); // may override default: ; // nothing } } if (!pFirstLang) pFirstLang = pEntry; } } // Language not found at all => use default. if (!pFirstLang) return aLastResortFallbackEntry.getLocale(); // Search for first entry of language with any country. pEntry = pFirstLang; for ( ; pEntry->mnLang != LANGUAGE_DONTKNOW; ++pEntry) { if (aLowerLang.equalsAscii( pEntry->maLanguage)) { if (*pEntry->maCountry) return getLocale( pEntry); // may override } } return aLastResortFallbackEntry.getLocale(); } // ======================================================================= // static LanguageType MsLangId::Conversion::convertPrivateUseToLanguage( const OUString& rPriv ) { for (const IsoLangOtherEntry* pPrivateEntry = aImplPrivateUseEntries; pPrivateEntry->mnLang != LANGUAGE_DONTKNOW; ++pPrivateEntry) { if ( rPriv.equalsIgnoreAsciiCaseAscii( pPrivateEntry->mpLanguage ) ) return pPrivateEntry->mnLang; } return LANGUAGE_DONTKNOW; } // static LanguageType MsLangId::Conversion::convertLocaleToLanguageImpl( const ::com::sun::star::lang::Locale& rLocale ) { if (rLocale.Language == I18NLANGTAG_QLT) { // "x-..." private use and the nasty "*" joker if (rLocale.Variant.startsWithIgnoreAsciiCase( "x-") || (rLocale.Variant == "*")) return convertPrivateUseToLanguage( rLocale.Variant); // Search in BCP47 for (const Bcp47CountryEntry* pBcp47Entry = aImplBcp47CountryEntries; pBcp47Entry->mnLang != LANGUAGE_DONTKNOW; ++pBcp47Entry) { if (rLocale.Variant.equalsIgnoreAsciiCase( pBcp47Entry->getTagString())) return pBcp47Entry->mnLang; } // Search in ISO lll-Ssss-CC for (const IsoLanguageScriptCountryEntry* pScriptEntry = aImplIsoLangScriptEntries; pScriptEntry->mnLang != LANGUAGE_DONTKNOW; ++pScriptEntry) { if (pScriptEntry->startsInIgnoreAsciiCase( rLocale.Variant)) { if (rLocale.Variant.equalsIgnoreAsciiCase( pScriptEntry->getTagString())) return getOverrideLang( pScriptEntry->mnLang, pScriptEntry->mnOverride); } } } else { // language is lower case in table OUString aLowerLang = rLocale.Language.toAsciiLowerCase(); // country is upper case in table OUString aUpperCountry = rLocale.Country.toAsciiUpperCase(); // Search in ISO lll-CC for (const IsoLanguageCountryEntry* pEntry = aImplIsoLangEntries; pEntry->mnLang != LANGUAGE_DONTKNOW; ++pEntry) { if (aLowerLang.equalsAscii( pEntry->maLanguage) && aUpperCountry.equalsAscii( pEntry->maCountry)) return getOverrideLang( pEntry->mnLang, pEntry->mnOverride); } } return LANGUAGE_DONTKNOW; } // static ::com::sun::star::lang::Locale MsLangId::Conversion::getOverride( const ::com::sun::star::lang::Locale& rLocale ) { if (rLocale.Language == I18NLANGTAG_QLT) { // "x-..." private use and the nasty "*" joker if (rLocale.Variant.startsWithIgnoreAsciiCase( "x-") || (rLocale.Variant == "*")) return rLocale; // no overrides // Search in BCP47 for (const Bcp47CountryEntry* pBcp47Entry = aImplBcp47CountryEntries; pBcp47Entry->mnLang != LANGUAGE_DONTKNOW; ++pBcp47Entry) { if (rLocale.Variant.equalsIgnoreAsciiCase( pBcp47Entry->getTagString())) return rLocale; // no overrides } // Search in ISO lll-Ssss-CC for (const IsoLanguageScriptCountryEntry* pScriptEntry = aImplIsoLangScriptEntries; pScriptEntry->mnLang != LANGUAGE_DONTKNOW; ++pScriptEntry) { if (pScriptEntry->startsInIgnoreAsciiCase( rLocale.Variant)) { if (rLocale.Variant.equalsIgnoreAsciiCase( pScriptEntry->getTagString())) return getLocale( pScriptEntry); // may override } } } else { // language is lower case in table OUString aLowerLang = rLocale.Language.toAsciiLowerCase(); // country is upper case in table OUString aUpperCountry = rLocale.Country.toAsciiUpperCase(); // Search in ISO lll-CC for (const IsoLanguageCountryEntry* pEntry = aImplIsoLangEntries; pEntry->mnLang != LANGUAGE_DONTKNOW; ++pEntry) { if (aLowerLang.equalsAscii( pEntry->maLanguage) && aUpperCountry.equalsAscii( pEntry->maCountry)) return getLocale( pEntry); // may override } } return lang::Locale(); } // static LanguageType MsLangId::Conversion::convertIsoNamesToLanguage( const OUString& rLang, const OUString& rCountry ) { // language is lower case in table OUString aLowerLang = rLang.toAsciiLowerCase(); // country is upper case in table OUString aUpperCountry = rCountry.toAsciiUpperCase(); // first look for exact match const IsoLanguageCountryEntry* pFirstLang = NULL; for (const IsoLanguageCountryEntry* pEntry = aImplIsoLangEntries; pEntry->mnLang != LANGUAGE_DONTKNOW; ++pEntry) { if ( aLowerLang.equalsAscii( pEntry->maLanguage ) ) { if ( aUpperCountry.isEmpty() || aUpperCountry.equalsAscii( pEntry->maCountry ) ) return pEntry->mnLang; if ( !pFirstLang ) pFirstLang = pEntry; else if ( !*pEntry->maCountry ) pFirstLang = pEntry; } } // some eng countries should be mapped to a specific english language if ( aLowerLang == "en" ) { for (const IsoLangEngEntry* pEngEntry = aImplIsoLangEngEntries; pEngEntry->mnLang != LANGUAGE_DONTKNOW; ++pEngEntry) { if ( aUpperCountry.equalsAscii( pEngEntry->maCountry ) ) return pEngEntry->mnLang; } } // test for specific languages which are not used standard ISO 3166 codes for (const IsoLangNoneStdEntry* pNoneStdEntry = aImplIsoNoneStdLangEntries; pNoneStdEntry->mnLang != LANGUAGE_DONTKNOW; ++pNoneStdEntry) { if ( aLowerLang.equalsAscii( pNoneStdEntry->maLanguage ) ) { // The countries in this table are not all in upper case if ( aUpperCountry.equalsIgnoreAsciiCaseAscii( pNoneStdEntry->maCountry ) ) return pNoneStdEntry->mnLang; } } for (const IsoLangNoneStdEntry* pNoneStdEntry2 = aImplIsoNoneStdLangEntries2; pNoneStdEntry2->mnLang != LANGUAGE_DONTKNOW; ++pNoneStdEntry2) { if ( aLowerLang.equalsAscii( pNoneStdEntry2->maLanguage ) ) { // The countries in this table are not all in upper case if ( aUpperCountry.equalsIgnoreAsciiCaseAscii( pNoneStdEntry2->maCountry ) ) return pNoneStdEntry2->mnLang; } } // If the language is correct, then we return the default language if ( pFirstLang ) return pFirstLang->mnLang; // if only the country is set, look for any entry matching the country // (to allow reading country and language in separate steps, in any order) if ( !rCountry.isEmpty() && rLang.isEmpty() ) { for (const IsoLanguageCountryEntry* pEntry2 = aImplIsoLangEntries; pEntry2->mnLang != LANGUAGE_DONTKNOW; ++pEntry2) { if ( aUpperCountry.equalsAscii( pEntry2->maCountry ) ) return pEntry2->mnLang; } aLowerLang = aUpperCountry.toAsciiLowerCase(); } // Look for privateuse definitions. LanguageType nLang = convertPrivateUseToLanguage( aLowerLang); if (nLang != LANGUAGE_DONTKNOW) return nLang; // Now look for all other definitions, which are not standard for (const IsoLangOtherEntry* pOtherEntry = aImplOtherEntries; pOtherEntry->mnLang != LANGUAGE_DONTKNOW; ++pOtherEntry) { if ( aLowerLang.equalsAscii( pOtherEntry->mpLanguage ) ) return pOtherEntry->mnLang; } return LANGUAGE_DONTKNOW; } // ----------------------------------------------------------------------- // static LanguageType MsLangId::Conversion::convertIsoNamesToLanguage( const OString& rLang, const OString& rCountry ) { OUString aLang = OStringToOUString( rLang, RTL_TEXTENCODING_ASCII_US); OUString aCountry = OStringToOUString( rCountry, RTL_TEXTENCODING_ASCII_US); return convertIsoNamesToLanguage( aLang, aCountry); } // ----------------------------------------------------------------------- struct IsoLangGLIBCModifiersEntry { LanguageType mnLang; sal_Char maLanguage[4]; sal_Char maCountry[3]; sal_Char maAtString[9]; }; static IsoLangGLIBCModifiersEntry const aImplIsoLangGLIBCModifiersEntries[] = { // MS-LANGID codes ISO639-1/2/3 ISO3166 glibc modifier { LANGUAGE_BOSNIAN_CYRILLIC_BOSNIA_HERZEGOVINA, "bs", "BA", "cyrillic" }, { LANGUAGE_USER_SERBIAN_LATIN_SERBIA, "sr", "RS", "latin" }, // Serbian Latin in Serbia { LANGUAGE_SERBIAN_LATIN_SAM, "sr", "CS", "latin" }, // Serbian Latin in Serbia and Montenegro { LANGUAGE_USER_SERBIAN_LATIN_MONTENEGRO, "sr", "ME", "latin" }, // Serbian Latin in Montenegro { LANGUAGE_SERBIAN_LATIN_LSO, "sr", "", "latin" }, { LANGUAGE_AZERI_CYRILLIC, "az", "AZ", "cyrillic" }, { LANGUAGE_UZBEK_CYRILLIC, "uz", "UZ", "cyrillic" }, { LANGUAGE_DONTKNOW, "", "", "" } // marks end of table }; // convert a unix locale string into LanguageType // static LanguageType MsLangId::convertUnxByteStringToLanguage( const OString& rString ) { OString aLang; OString aCountry; OString aAtString; sal_Int32 nLangSepPos = rString.indexOf( (sal_Char)'_' ); sal_Int32 nCountrySepPos = rString.indexOf( (sal_Char)'.' ); sal_Int32 nAtPos = rString.indexOf( (sal_Char)'@' ); if (nCountrySepPos < 0) nCountrySepPos = nAtPos; if (nCountrySepPos < 0) nCountrySepPos = rString.getLength(); if (nAtPos >= 0) aAtString = rString.copy( nAtPos+1 ); if (((nLangSepPos >= 0) && (nLangSepPos > nCountrySepPos)) || (nLangSepPos < 0)) { // eg. "el.sun_eu_greek", "tchinese", "es.ISO8859-15" aLang = rString.copy( 0, nCountrySepPos ); } else if ( nLangSepPos >= 0 ) { // well formed iso names like "en_US.UTF-8", "sh_BA.ISO8859-2@bosnia" aLang = rString.copy( 0, nLangSepPos ); aCountry = rString.copy( nLangSepPos+1, nCountrySepPos - nLangSepPos - 1); } // if there is a glibc modifier, first look for exact match in modifier table if (!aAtString.isEmpty()) { // language is lower case in table OString aLowerLang = aLang.toAsciiLowerCase(); // country is upper case in table OString aUpperCountry = aCountry.toAsciiUpperCase(); for (const IsoLangGLIBCModifiersEntry* pGLIBCModifiersEntry = aImplIsoLangGLIBCModifiersEntries; pGLIBCModifiersEntry->mnLang != LANGUAGE_DONTKNOW; ++pGLIBCModifiersEntry) { // avoid embedded \0 warning if (aLowerLang.equals( static_cast< const char* >( pGLIBCModifiersEntry->maLanguage )) && aAtString.equals( static_cast< const char* >( pGLIBCModifiersEntry->maAtString ))) { if (aUpperCountry.isEmpty() || aUpperCountry.equals( static_cast< const char* >( pGLIBCModifiersEntry->maCountry ))) { return pGLIBCModifiersEntry->mnLang; } } } } return Conversion::convertIsoNamesToLanguage( aLang, aCountry ); } // static ::std::vector< MsLangId::LanguagetagMapping > MsLangId::getDefinedLanguagetags() { ::std::vector< LanguagetagMapping > aVec; for (const Bcp47CountryEntry* pEntry = aImplBcp47CountryEntries; pEntry->mnLang != LANGUAGE_DONTKNOW; ++pEntry) { aVec.push_back( LanguagetagMapping( pEntry->getTagString(), pEntry->mnLang)); } for (const IsoLanguageScriptCountryEntry* pEntry = aImplIsoLangScriptEntries; pEntry->mnLang != LANGUAGE_DONTKNOW; ++pEntry) { aVec.push_back( LanguagetagMapping( pEntry->getTagString(), pEntry->mnLang)); } for (const IsoLanguageCountryEntry* pEntry = aImplIsoLangEntries; pEntry->mnLang != LANGUAGE_DONTKNOW; ++pEntry) { aVec.push_back( LanguagetagMapping( pEntry->getTagString(), pEntry->mnLang)); } return aVec; } /* vim:set shiftwidth=4 softtabstop=4 expandtab: */