languages/Language.php

   1 <?php
   2 /**
   3  * Internationalisation code.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  * @ingroup Language
  22  */
  23
  24 /**
  25  * @defgroup Language Language
  26  */
  27
  28 if ( !defined( 'MEDIAWIKI' ) ) {
  29         echo "This file is part of MediaWiki, it is not a valid entry point.\n";
  30         exit( 1 );
  31 }
  32
  33 if ( function_exists( 'mb_strtoupper' ) ) {
  34         mb_internal_encoding( 'UTF-8' );
  35 }
  36
  37 /**
  38  * Internationalisation code
  39  * @ingroup Language
  40  */
  41 class Language {
  42         /**
  43          * @var LanguageConverter
  44          */
  45         public $mConverter;
  46
  47         public $mVariants, $mCode, $mLoaded = false;
  48         public $mMagicExtensions = array(), $mMagicHookDone = false;
  49         private $mHtmlCode = null, $mParentLanguage = false;
  50
  51         public $dateFormatStrings = array();
  52         public $mExtendedSpecialPageAliases;
  53
  54         protected $namespaceNames, $mNamespaceIds, $namespaceAliases;
  55
  56         /**
  57          * ReplacementArray object caches
  58          */
  59         public $transformData = array();
  60
  61         /**
  62          * @var LocalisationCache
  63          */
  64         static public $dataCache;
  65
  66         static public $mLangObjCache = array();
  67
  68         static public $mWeekdayMsgs = array(
  69                 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
  70                 'friday', 'saturday'
  71         );
  72
  73         static public $mWeekdayAbbrevMsgs = array(
  74                 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'
  75         );
  76
  77         static public $mMonthMsgs = array(
  78                 'january', 'february', 'march', 'april', 'may_long', 'june',
  79                 'july', 'august', 'september', 'october', 'november',
  80                 'december'
  81         );
  82         static public $mMonthGenMsgs = array(
  83                 'january-gen', 'february-gen', 'march-gen', 'april-gen', 'may-gen', 'june-gen',
  84                 'july-gen', 'august-gen', 'september-gen', 'october-gen', 'november-gen',
  85                 'december-gen'
  86         );
  87         static public $mMonthAbbrevMsgs = array(
  88                 'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
  89                 'sep', 'oct', 'nov', 'dec'
  90         );
  91
  92         static public $mIranianCalendarMonthMsgs = array(
  93                 'iranian-calendar-m1', 'iranian-calendar-m2', 'iranian-calendar-m3',
  94                 'iranian-calendar-m4', 'iranian-calendar-m5', 'iranian-calendar-m6',
  95                 'iranian-calendar-m7', 'iranian-calendar-m8', 'iranian-calendar-m9',
  96                 'iranian-calendar-m10', 'iranian-calendar-m11', 'iranian-calendar-m12'
  97         );
  98
  99         static public $mHebrewCalendarMonthMsgs = array(
 100                 'hebrew-calendar-m1', 'hebrew-calendar-m2', 'hebrew-calendar-m3',
 101                 'hebrew-calendar-m4', 'hebrew-calendar-m5', 'hebrew-calendar-m6',
 102                 'hebrew-calendar-m7', 'hebrew-calendar-m8', 'hebrew-calendar-m9',
 103                 'hebrew-calendar-m10', 'hebrew-calendar-m11', 'hebrew-calendar-m12',
 104                 'hebrew-calendar-m6a', 'hebrew-calendar-m6b'
 105         );
 106
 107         static public $mHebrewCalendarMonthGenMsgs = array(
 108                 'hebrew-calendar-m1-gen', 'hebrew-calendar-m2-gen', 'hebrew-calendar-m3-gen',
 109                 'hebrew-calendar-m4-gen', 'hebrew-calendar-m5-gen', 'hebrew-calendar-m6-gen',
 110                 'hebrew-calendar-m7-gen', 'hebrew-calendar-m8-gen', 'hebrew-calendar-m9-gen',
 111                 'hebrew-calendar-m10-gen', 'hebrew-calendar-m11-gen', 'hebrew-calendar-m12-gen',
 112                 'hebrew-calendar-m6a-gen', 'hebrew-calendar-m6b-gen'
 113         );
 114
 115         static public $mHijriCalendarMonthMsgs = array(
 116                 'hijri-calendar-m1', 'hijri-calendar-m2', 'hijri-calendar-m3',
 117                 'hijri-calendar-m4', 'hijri-calendar-m5', 'hijri-calendar-m6',
 118                 'hijri-calendar-m7', 'hijri-calendar-m8', 'hijri-calendar-m9',
 119                 'hijri-calendar-m10', 'hijri-calendar-m11', 'hijri-calendar-m12'
 120         );
 121
 122         /**
 123          * @since 1.20
 124          * @var array
 125          */
 126         static public $durationIntervals = array(
 127                 'millennia' => 31556952000,
 128                 'centuries' => 3155695200,
 129                 'decades' => 315569520,
 130                 'years' => 31556952, // 86400 * ( 365 + ( 24 * 3 + 25 ) / 400 )
 131                 'weeks' => 604800,
 132                 'days' => 86400,
 133                 'hours' => 3600,
 134                 'minutes' => 60,
 135                 'seconds' => 1,
 136         );
 137
 138         /**
 139          * Cache for language fallbacks.
 140          * @see Language::getFallbacksIncludingSiteLanguage
 141          * @since 1.21
 142          * @var array
 143          */
 144         static private $fallbackLanguageCache = array();
 145
 146         /**
 147          * Cache for language names
 148          * @var MapCacheLRU|null
 149          */
 150         static private $languageNameCache;
 151
 152         /**
 153          * Unicode directional formatting characters, for embedBidi()
 154          */
 155         static private $lre = "\xE2\x80\xAA"; // U+202A LEFT-TO-RIGHT EMBEDDING
 156         static private $rle = "\xE2\x80\xAB"; // U+202B RIGHT-TO-LEFT EMBEDDING
 157         static private $pdf = "\xE2\x80\xAC"; // U+202C POP DIRECTIONAL FORMATTING
 158
 159         /**
 160          * Directionality test regex for embedBidi(). Matches the first strong directionality codepoint:
 161          * - in group 1 if it is LTR
 162          * - in group 2 if it is RTL
 163          * Does not match if there is no strong directionality codepoint.
 164          *
 165          * The form is '/(?:([strong ltr codepoint])|([strong rtl codepoint]))/u' .
 166          *
 167          * Generated by UnicodeJS (see tools/strongDir) from the UCD; see
 168          * https://git.wikimedia.org/summary/unicodejs.git .
 169          */
 170         // @codingStandardsIgnoreStart
 171         // @codeCoverageIgnoreStart
 172         static private $strongDirRegex = '/(?:([\x{41}-\x{5a}\x{61}-\x{7a}\x{aa}\x{b5}\x{ba}\x{c0}-\x{d6}\x{d8}-\x{f6}\x{f8}-\x{2b8}\x{2bb}-\x{2c1}\x{2d0}\x{2d1}\x{2e0}-\x{2e4}\x{2ee}\x{370}-\x{373}\x{376}\x{377}\x{37a}-\x{37d}\x{37f}\x{386}\x{388}-\x{38a}\x{38c}\x{38e}-\x{3a1}\x{3a3}-\x{3f5}\x{3f7}-\x{482}\x{48a}-\x{52f}\x{531}-\x{556}\x{559}-\x{55f}\x{561}-\x{587}\x{589}\x{903}-\x{939}\x{93b}\x{93d}-\x{940}\x{949}-\x{94c}\x{94e}-\x{950}\x{958}-\x{961}\x{964}-\x{980}\x{982}\x{983}\x{985}-\x{98c}\x{98f}\x{990}\x{993}-\x{9a8}\x{9aa}-\x{9b0}\x{9b2}\x{9b6}-\x{9b9}\x{9bd}-\x{9c0}\x{9c7}\x{9c8}\x{9cb}\x{9cc}\x{9ce}\x{9d7}\x{9dc}\x{9dd}\x{9df}-\x{9e1}\x{9e6}-\x{9f1}\x{9f4}-\x{9fa}\x{a03}\x{a05}-\x{a0a}\x{a0f}\x{a10}\x{a13}-\x{a28}\x{a2a}-\x{a30}\x{a32}\x{a33}\x{a35}\x{a36}\x{a38}\x{a39}\x{a3e}-\x{a40}\x{a59}-\x{a5c}\x{a5e}\x{a66}-\x{a6f}\x{a72}-\x{a74}\x{a83}\x{a85}-\x{a8d}\x{a8f}-\x{a91}\x{a93}-\x{aa8}\x{aaa}-\x{ab0}\x{ab2}\x{ab3}\x{ab5}-\x{ab9}\x{abd}-\x{ac0}\x{ac9}\x{acb}\x{acc}\x{ad0}\x{ae0}\x{ae1}\x{ae6}-\x{af0}\x{af9}\x{b02}\x{b03}\x{b05}-\x{b0c}\x{b0f}\x{b10}\x{b13}-\x{b28}\x{b2a}-\x{b30}\x{b32}\x{b33}\x{b35}-\x{b39}\x{b3d}\x{b3e}\x{b40}\x{b47}\x{b48}\x{b4b}\x{b4c}\x{b57}\x{b5c}\x{b5d}\x{b5f}-\x{b61}\x{b66}-\x{b77}\x{b83}\x{b85}-\x{b8a}\x{b8e}-\x{b90}\x{b92}-\x{b95}\x{b99}\x{b9a}\x{b9c}\x{b9e}\x{b9f}\x{ba3}\x{ba4}\x{ba8}-\x{baa}\x{bae}-\x{bb9}\x{bbe}\x{bbf}\x{bc1}\x{bc2}\x{bc6}-\x{bc8}\x{bca}-\x{bcc}\x{bd0}\x{bd7}\x{be6}-\x{bf2}\x{c01}-\x{c03}\x{c05}-\x{c0c}\x{c0e}-\x{c10}\x{c12}-\x{c28}\x{c2a}-\x{c39}\x{c3d}\x{c41}-\x{c44}\x{c58}-\x{c5a}\x{c60}\x{c61}\x{c66}-\x{c6f}\x{c7f}\x{c82}\x{c83}\x{c85}-\x{c8c}\x{c8e}-\x{c90}\x{c92}-\x{ca8}\x{caa}-\x{cb3}\x{cb5}-\x{cb9}\x{cbd}-\x{cc4}\x{cc6}-\x{cc8}\x{cca}\x{ccb}\x{cd5}\x{cd6}\x{cde}\x{ce0}\x{ce1}\x{ce6}-\x{cef}\x{cf1}\x{cf2}\x{d02}\x{d03}\x{d05}-\x{d0c}\x{d0e}-\x{d10}\x{d12}-\x{d3a}\x{d3d}-\x{d40}\x{d46}-\x{d48}\x{d4a}-\x{d4c}\x{d4e}\x{d57}\x{d5f}-\x{d61}\x{d66}-\x{d75}\x{d79}-\x{d7f}\x{d82}\x{d83}\x{d85}-\x{d96}\x{d9a}-\x{db1}\x{db3}-\x{dbb}\x{dbd}\x{dc0}-\x{dc6}\x{dcf}-\x{dd1}\x{dd8}-\x{ddf}\x{de6}-\x{def}\x{df2}-\x{df4}\x{e01}-\x{e30}\x{e32}\x{e33}\x{e40}-\x{e46}\x{e4f}-\x{e5b}\x{e81}\x{e82}\x{e84}\x{e87}\x{e88}\x{e8a}\x{e8d}\x{e94}-\x{e97}\x{e99}-\x{e9f}\x{ea1}-\x{ea3}\x{ea5}\x{ea7}\x{eaa}\x{eab}\x{ead}-\x{eb0}\x{eb2}\x{eb3}\x{ebd}\x{ec0}-\x{ec4}\x{ec6}\x{ed0}-\x{ed9}\x{edc}-\x{edf}\x{f00}-\x{f17}\x{f1a}-\x{f34}\x{f36}\x{f38}\x{f3e}-\x{f47}\x{f49}-\x{f6c}\x{f7f}\x{f85}\x{f88}-\x{f8c}\x{fbe}-\x{fc5}\x{fc7}-\x{fcc}\x{fce}-\x{fda}\x{1000}-\x{102c}\x{1031}\x{1038}\x{103b}\x{103c}\x{103f}-\x{1057}\x{105a}-\x{105d}\x{1061}-\x{1070}\x{1075}-\x{1081}\x{1083}\x{1084}\x{1087}-\x{108c}\x{108e}-\x{109c}\x{109e}-\x{10c5}\x{10c7}\x{10cd}\x{10d0}-\x{1248}\x{124a}-\x{124d}\x{1250}-\x{1256}\x{1258}\x{125a}-\x{125d}\x{1260}-\x{1288}\x{128a}-\x{128d}\x{1290}-\x{12b0}\x{12b2}-\x{12b5}\x{12b8}-\x{12be}\x{12c0}\x{12c2}-\x{12c5}\x{12c8}-\x{12d6}\x{12d8}-\x{1310}\x{1312}-\x{1315}\x{1318}-\x{135a}\x{1360}-\x{137c}\x{1380}-\x{138f}\x{13a0}-\x{13f5}\x{13f8}-\x{13fd}\x{1401}-\x{167f}\x{1681}-\x{169a}\x{16a0}-\x{16f8}\x{1700}-\x{170c}\x{170e}-\x{1711}\x{1720}-\x{1731}\x{1735}\x{1736}\x{1740}-\x{1751}\x{1760}-\x{176c}\x{176e}-\x{1770}\x{1780}-\x{17b3}\x{17b6}\x{17be}-\x{17c5}\x{17c7}\x{17c8}\x{17d4}-\x{17da}\x{17dc}\x{17e0}-\x{17e9}\x{1810}-\x{1819}\x{1820}-\x{1877}\x{1880}-\x{18a8}\x{18aa}\x{18b0}-\x{18f5}\x{1900}-\x{191e}\x{1923}-\x{1926}\x{1929}-\x{192b}\x{1930}\x{1931}\x{1933}-\x{1938}\x{1946}-\x{196d}\x{1970}-\x{1974}\x{1980}-\x{19ab}\x{19b0}-\x{19c9}\x{19d0}-\x{19da}\x{1a00}-\x{1a16}\x{1a19}\x{1a1a}\x{1a1e}-\x{1a55}\x{1a57}\x{1a61}\x{1a63}\x{1a64}\x{1a6d}-\x{1a72}\x{1a80}-\x{1a89}\x{1a90}-\x{1a99}\x{1aa0}-\x{1aad}\x{1b04}-\x{1b33}\x{1b35}\x{1b3b}\x{1b3d}-\x{1b41}\x{1b43}-\x{1b4b}\x{1b50}-\x{1b6a}\x{1b74}-\x{1b7c}\x{1b82}-\x{1ba1}\x{1ba6}\x{1ba7}\x{1baa}\x{1bae}-\x{1be5}\x{1be7}\x{1bea}-\x{1bec}\x{1bee}\x{1bf2}\x{1bf3}\x{1bfc}-\x{1c2b}\x{1c34}\x{1c35}\x{1c3b}-\x{1c49}\x{1c4d}-\x{1c7f}\x{1cc0}-\x{1cc7}\x{1cd3}\x{1ce1}\x{1ce9}-\x{1cec}\x{1cee}-\x{1cf3}\x{1cf5}\x{1cf6}\x{1d00}-\x{1dbf}\x{1e00}-\x{1f15}\x{1f18}-\x{1f1d}\x{1f20}-\x{1f45}\x{1f48}-\x{1f4d}\x{1f50}-\x{1f57}\x{1f59}\x{1f5b}\x{1f5d}\x{1f5f}-\x{1f7d}\x{1f80}-\x{1fb4}\x{1fb6}-\x{1fbc}\x{1fbe}\x{1fc2}-\x{1fc4}\x{1fc6}-\x{1fcc}\x{1fd0}-\x{1fd3}\x{1fd6}-\x{1fdb}\x{1fe0}-\x{1fec}\x{1ff2}-\x{1ff4}\x{1ff6}-\x{1ffc}\x{200e}\x{2071}\x{207f}\x{2090}-\x{209c}\x{2102}\x{2107}\x{210a}-\x{2113}\x{2115}\x{2119}-\x{211d}\x{2124}\x{2126}\x{2128}\x{212a}-\x{212d}\x{212f}-\x{2139}\x{213c}-\x{213f}\x{2145}-\x{2149}\x{214e}\x{214f}\x{2160}-\x{2188}\x{2336}-\x{237a}\x{2395}\x{249c}-\x{24e9}\x{26ac}\x{2800}-\x{28ff}\x{2c00}-\x{2c2e}\x{2c30}-\x{2c5e}\x{2c60}-\x{2ce4}\x{2ceb}-\x{2cee}\x{2cf2}\x{2cf3}\x{2d00}-\x{2d25}\x{2d27}\x{2d2d}\x{2d30}-\x{2d67}\x{2d6f}\x{2d70}\x{2d80}-\x{2d96}\x{2da0}-\x{2da6}\x{2da8}-\x{2dae}\x{2db0}-\x{2db6}\x{2db8}-\x{2dbe}\x{2dc0}-\x{2dc6}\x{2dc8}-\x{2dce}\x{2dd0}-\x{2dd6}\x{2dd8}-\x{2dde}\x{3005}-\x{3007}\x{3021}-\x{3029}\x{302e}\x{302f}\x{3031}-\x{3035}\x{3038}-\x{303c}\x{3041}-\x{3096}\x{309d}-\x{309f}\x{30a1}-\x{30fa}\x{30fc}-\x{30ff}\x{3105}-\x{312d}\x{3131}-\x{318e}\x{3190}-\x{31ba}\x{31f0}-\x{321c}\x{3220}-\x{324f}\x{3260}-\x{327b}\x{327f}-\x{32b0}\x{32c0}-\x{32cb}\x{32d0}-\x{32fe}\x{3300}-\x{3376}\x{337b}-\x{33dd}\x{33e0}-\x{33fe}\x{3400}-\x{4db5}\x{4e00}-\x{9fd5}\x{a000}-\x{a48c}\x{a4d0}-\x{a60c}\x{a610}-\x{a62b}\x{a640}-\x{a66e}\x{a680}-\x{a69d}\x{a6a0}-\x{a6ef}\x{a6f2}-\x{a6f7}\x{a722}-\x{a787}\x{a789}-\x{a7ad}\x{a7b0}-\x{a7b7}\x{a7f7}-\x{a801}\x{a803}-\x{a805}\x{a807}-\x{a80a}\x{a80c}-\x{a824}\x{a827}\x{a830}-\x{a837}\x{a840}-\x{a873}\x{a880}-\x{a8c3}\x{a8ce}-\x{a8d9}\x{a8f2}-\x{a8fd}\x{a900}-\x{a925}\x{a92e}-\x{a946}\x{a952}\x{a953}\x{a95f}-\x{a97c}\x{a983}-\x{a9b2}\x{a9b4}\x{a9b5}\x{a9ba}\x{a9bb}\x{a9bd}-\x{a9cd}\x{a9cf}-\x{a9d9}\x{a9de}-\x{a9e4}\x{a9e6}-\x{a9fe}\x{aa00}-\x{aa28}\x{aa2f}\x{aa30}\x{aa33}\x{aa34}\x{aa40}-\x{aa42}\x{aa44}-\x{aa4b}\x{aa4d}\x{aa50}-\x{aa59}\x{aa5c}-\x{aa7b}\x{aa7d}-\x{aaaf}\x{aab1}\x{aab5}\x{aab6}\x{aab9}-\x{aabd}\x{aac0}\x{aac2}\x{aadb}-\x{aaeb}\x{aaee}-\x{aaf5}\x{ab01}-\x{ab06}\x{ab09}-\x{ab0e}\x{ab11}-\x{ab16}\x{ab20}-\x{ab26}\x{ab28}-\x{ab2e}\x{ab30}-\x{ab65}\x{ab70}-\x{abe4}\x{abe6}\x{abe7}\x{abe9}-\x{abec}\x{abf0}-\x{abf9}\x{ac00}-\x{d7a3}\x{d7b0}-\x{d7c6}\x{d7cb}-\x{d7fb}\x{e000}-\x{fa6d}\x{fa70}-\x{fad9}\x{fb00}-\x{fb06}\x{fb13}-\x{fb17}\x{ff21}-\x{ff3a}\x{ff41}-\x{ff5a}\x{ff66}-\x{ffbe}\x{ffc2}-\x{ffc7}\x{ffca}-\x{ffcf}\x{ffd2}-\x{ffd7}\x{ffda}-\x{ffdc}\x{10000}-\x{1000b}\x{1000d}-\x{10026}\x{10028}-\x{1003a}\x{1003c}\x{1003d}\x{1003f}-\x{1004d}\x{10050}-\x{1005d}\x{10080}-\x{100fa}\x{10100}\x{10102}\x{10107}-\x{10133}\x{10137}-\x{1013f}\x{101d0}-\x{101fc}\x{10280}-\x{1029c}\x{102a0}-\x{102d0}\x{10300}-\x{10323}\x{10330}-\x{1034a}\x{10350}-\x{10375}\x{10380}-\x{1039d}\x{1039f}-\x{103c3}\x{103c8}-\x{103d5}\x{10400}-\x{1049d}\x{104a0}-\x{104a9}\x{10500}-\x{10527}\x{10530}-\x{10563}\x{1056f}\x{10600}-\x{10736}\x{10740}-\x{10755}\x{10760}-\x{10767}\x{11000}\x{11002}-\x{11037}\x{11047}-\x{1104d}\x{11066}-\x{1106f}\x{11082}-\x{110b2}\x{110b7}\x{110b8}\x{110bb}-\x{110c1}\x{110d0}-\x{110e8}\x{110f0}-\x{110f9}\x{11103}-\x{11126}\x{1112c}\x{11136}-\x{11143}\x{11150}-\x{11172}\x{11174}-\x{11176}\x{11182}-\x{111b5}\x{111bf}-\x{111c9}\x{111cd}\x{111d0}-\x{111df}\x{111e1}-\x{111f4}\x{11200}-\x{11211}\x{11213}-\x{1122e}\x{11232}\x{11233}\x{11235}\x{11238}-\x{1123d}\x{11280}-\x{11286}\x{11288}\x{1128a}-\x{1128d}\x{1128f}-\x{1129d}\x{1129f}-\x{112a9}\x{112b0}-\x{112de}\x{112e0}-\x{112e2}\x{112f0}-\x{112f9}\x{11302}\x{11303}\x{11305}-\x{1130c}\x{1130f}\x{11310}\x{11313}-\x{11328}\x{1132a}-\x{11330}\x{11332}\x{11333}\x{11335}-\x{11339}\x{1133d}-\x{1133f}\x{11341}-\x{11344}\x{11347}\x{11348}\x{1134b}-\x{1134d}\x{11350}\x{11357}\x{1135d}-\x{11363}\x{11480}-\x{114b2}\x{114b9}\x{114bb}-\x{114be}\x{114c1}\x{114c4}-\x{114c7}\x{114d0}-\x{114d9}\x{11580}-\x{115b1}\x{115b8}-\x{115bb}\x{115be}\x{115c1}-\x{115db}\x{11600}-\x{11632}\x{1163b}\x{1163c}\x{1163e}\x{11641}-\x{11644}\x{11650}-\x{11659}\x{11680}-\x{116aa}\x{116ac}\x{116ae}\x{116af}\x{116b6}\x{116c0}-\x{116c9}\x{11700}-\x{11719}\x{11720}\x{11721}\x{11726}\x{11730}-\x{1173f}\x{118a0}-\x{118f2}\x{118ff}\x{11ac0}-\x{11af8}\x{12000}-\x{12399}\x{12400}-\x{1246e}\x{12470}-\x{12474}\x{12480}-\x{12543}\x{13000}-\x{1342e}\x{14400}-\x{14646}\x{16800}-\x{16a38}\x{16a40}-\x{16a5e}\x{16a60}-\x{16a69}\x{16a6e}\x{16a6f}\x{16ad0}-\x{16aed}\x{16af5}\x{16b00}-\x{16b2f}\x{16b37}-\x{16b45}\x{16b50}-\x{16b59}\x{16b5b}-\x{16b61}\x{16b63}-\x{16b77}\x{16b7d}-\x{16b8f}\x{16f00}-\x{16f44}\x{16f50}-\x{16f7e}\x{16f93}-\x{16f9f}\x{1b000}\x{1b001}\x{1bc00}-\x{1bc6a}\x{1bc70}-\x{1bc7c}\x{1bc80}-\x{1bc88}\x{1bc90}-\x{1bc99}\x{1bc9c}\x{1bc9f}\x{1d000}-\x{1d0f5}\x{1d100}-\x{1d126}\x{1d129}-\x{1d166}\x{1d16a}-\x{1d172}\x{1d183}\x{1d184}\x{1d18c}-\x{1d1a9}\x{1d1ae}-\x{1d1e8}\x{1d360}-\x{1d371}\x{1d400}-\x{1d454}\x{1d456}-\x{1d49c}\x{1d49e}\x{1d49f}\x{1d4a2}\x{1d4a5}\x{1d4a6}\x{1d4a9}-\x{1d4ac}\x{1d4ae}-\x{1d4b9}\x{1d4bb}\x{1d4bd}-\x{1d4c3}\x{1d4c5}-\x{1d505}\x{1d507}-\x{1d50a}\x{1d50d}-\x{1d514}\x{1d516}-\x{1d51c}\x{1d51e}-\x{1d539}\x{1d53b}-\x{1d53e}\x{1d540}-\x{1d544}\x{1d546}\x{1d54a}-\x{1d550}\x{1d552}-\x{1d6a5}\x{1d6a8}-\x{1d6da}\x{1d6dc}-\x{1d714}\x{1d716}-\x{1d74e}\x{1d750}-\x{1d788}\x{1d78a}-\x{1d7c2}\x{1d7c4}-\x{1d7cb}\x{1d800}-\x{1d9ff}\x{1da37}-\x{1da3a}\x{1da6d}-\x{1da74}\x{1da76}-\x{1da83}\x{1da85}-\x{1da8b}\x{1f110}-\x{1f12e}\x{1f130}-\x{1f169}\x{1f170}-\x{1f19a}\x{1f1e6}-\x{1f202}\x{1f210}-\x{1f23a}\x{1f240}-\x{1f248}\x{1f250}\x{1f251}\x{20000}-\x{2a6d6}\x{2a700}-\x{2b734}\x{2b740}-\x{2b81d}\x{2b820}-\x{2cea1}\x{2f800}-\x{2fa1d}\x{f0000}-\x{ffffd}\x{100000}-\x{10fffd}])|([\x{590}\x{5be}\x{5c0}\x{5c3}\x{5c6}\x{5c8}-\x{5ff}\x{7c0}-\x{7ea}\x{7f4}\x{7f5}\x{7fa}-\x{815}\x{81a}\x{824}\x{828}\x{82e}-\x{858}\x{85c}-\x{89f}\x{200f}\x{fb1d}\x{fb1f}-\x{fb28}\x{fb2a}-\x{fb4f}\x{10800}-\x{1091e}\x{10920}-\x{10a00}\x{10a04}\x{10a07}-\x{10a0b}\x{10a10}-\x{10a37}\x{10a3b}-\x{10a3e}\x{10a40}-\x{10ae4}\x{10ae7}-\x{10b38}\x{10b40}-\x{10e5f}\x{10e7f}-\x{10fff}\x{1e800}-\x{1e8cf}\x{1e8d7}-\x{1edff}\x{1ef00}-\x{1efff}\x{608}\x{60b}\x{60d}\x{61b}-\x{64a}\x{66d}-\x{66f}\x{671}-\x{6d5}\x{6e5}\x{6e6}\x{6ee}\x{6ef}\x{6fa}-\x{710}\x{712}-\x{72f}\x{74b}-\x{7a5}\x{7b1}-\x{7bf}\x{8a0}-\x{8e2}\x{fb50}-\x{fd3d}\x{fd40}-\x{fdcf}\x{fdf0}-\x{fdfc}\x{fdfe}\x{fdff}\x{fe70}-\x{fefe}\x{1ee00}-\x{1eeef}\x{1eef2}-\x{1eeff}]))/u';
 173         // @codeCoverageIgnoreEnd
 174         // @codingStandardsIgnoreEnd
 175
 176         /**
 177          * Get a cached or new language object for a given language code
 178          * @param string $code
 179          * @return Language
 180          */
 181         static function factory( $code ) {
 182                 global $wgDummyLanguageCodes, $wgLangObjCacheSize;
 183
 184                 if ( isset( $wgDummyLanguageCodes[$code] ) ) {
 185                         $code = $wgDummyLanguageCodes[$code];
 186                 }
 187
 188                 // get the language object to process
 189                 $langObj = isset( self::$mLangObjCache[$code] )
 190                         ? self::$mLangObjCache[$code]
 191                         : self::newFromCode( $code );
 192
 193                 // merge the language object in to get it up front in the cache
 194                 self::$mLangObjCache = array_merge( array( $code => $langObj ), self::$mLangObjCache );
 195                 // get rid of the oldest ones in case we have an overflow
 196                 self::$mLangObjCache = array_slice( self::$mLangObjCache, 0, $wgLangObjCacheSize, true );
 197
 198                 return $langObj;
 199         }
 200
 201         /**
 202          * Create a language object for a given language code
 203          * @param string $code
 204          * @throws MWException
 205          * @return Language
 206          */
 207         protected static function newFromCode( $code ) {
 208                 // Protect against path traversal below
 209                 if ( !Language::isValidCode( $code )
 210                         || strcspn( $code, ":/\\\000" ) !== strlen( $code )
 211                 ) {
 212                         throw new MWException( "Invalid language code \"$code\"" );
 213                 }
 214
 215                 if ( !Language::isValidBuiltInCode( $code ) ) {
 216                         // It's not possible to customise this code with class files, so
 217                         // just return a Language object. This is to support uselang= hacks.
 218                         $lang = new Language;
 219                         $lang->setCode( $code );
 220                         return $lang;
 221                 }
 222
 223                 // Check if there is a language class for the code
 224                 $class = self::classFromCode( $code );
 225                 self::preloadLanguageClass( $class );
 226                 if ( class_exists( $class ) ) {
 227                         $lang = new $class;
 228                         return $lang;
 229                 }
 230
 231                 // Keep trying the fallback list until we find an existing class
 232                 $fallbacks = Language::getFallbacksFor( $code );
 233                 foreach ( $fallbacks as $fallbackCode ) {
 234                         if ( !Language::isValidBuiltInCode( $fallbackCode ) ) {
 235                                 throw new MWException( "Invalid fallback '$fallbackCode' in fallback sequence for '$code'" );
 236                         }
 237
 238                         $class = self::classFromCode( $fallbackCode );
 239                         self::preloadLanguageClass( $class );
 240                         if ( class_exists( $class ) ) {
 241                                 $lang = Language::newFromCode( $fallbackCode );
 242                                 $lang->setCode( $code );
 243                                 return $lang;
 244                         }
 245                 }
 246
 247                 throw new MWException( "Invalid fallback sequence for language '$code'" );
 248         }
 249
 250         /**
 251          * Checks whether any localisation is available for that language tag
 252          * in MediaWiki (MessagesXx.php exists).
 253          *
 254          * @param string $code Language tag (in lower case)
 255          * @return bool Whether language is supported
 256          * @since 1.21
 257          */
 258         public static function isSupportedLanguage( $code ) {
 259                 if ( !self::isValidBuiltInCode( $code ) ) {
 260                         return false;
 261                 }
 262
 263                 if ( $code === 'qqq' ) {
 264                         return false;
 265                 }
 266
 267                 return is_readable( self::getMessagesFileName( $code ) ) ||
 268                         is_readable( self::getJsonMessagesFileName( $code ) );
 269         }
 270
 271         /**
 272          * Returns true if a language code string is a well-formed language tag
 273          * according to RFC 5646.
 274          * This function only checks well-formedness; it doesn't check that
 275          * language, script or variant codes actually exist in the repositories.
 276          *
 277          * Based on regexes by Mark Davis of the Unicode Consortium:
 278          * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
 279          *
 280          * @param string $code
 281          * @param bool $lenient Whether to allow '_' as separator. The default is only '-'.
 282          *
 283          * @return bool
 284          * @since 1.21
 285          */
 286         public static function isWellFormedLanguageTag( $code, $lenient = false ) {
 287                 $alpha = '[a-z]';
 288                 $digit = '[0-9]';
 289                 $alphanum = '[a-z0-9]';
 290                 $x = 'x'; # private use singleton
 291                 $singleton = '[a-wy-z]'; # other singleton
 292                 $s = $lenient ? '[-_]' : '-';
 293
 294                 $language = "$alpha{2,8}|$alpha{2,3}$s$alpha{3}";
 295                 $script = "$alpha{4}"; # ISO 15924
 296                 $region = "(?:$alpha{2}|$digit{3})"; # ISO 3166-1 alpha-2 or UN M.49
 297                 $variant = "(?:$alphanum{5,8}|$digit$alphanum{3})";
 298                 $extension = "$singleton(?:$s$alphanum{2,8})+";
 299                 $privateUse = "$x(?:$s$alphanum{1,8})+";
 300
 301                 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
 302                 # Since these are limited, this is safe even later changes to the registry --
 303                 # the only oddity is that it might change the type of the tag, and thus
 304                 # the results from the capturing groups.
 305                 # http://www.iana.org/assignments/language-subtag-registry
 306
 307                 $grandfathered = "en{$s}GB{$s}oed"
 308                         . "|i{$s}(?:ami|bnn|default|enochian|hak|klingon|lux|mingo|navajo|pwn|tao|tay|tsu)"
 309                         . "|no{$s}(?:bok|nyn)"
 310                         . "|sgn{$s}(?:BE{$s}(?:fr|nl)|CH{$s}de)"
 311                         . "|zh{$s}min{$s}nan";
 312
 313                 $variantList = "$variant(?:$s$variant)*";
 314                 $extensionList = "$extension(?:$s$extension)*";
 315
 316                 $langtag = "(?:($language)"
 317                         . "(?:$s$script)?"
 318                         . "(?:$s$region)?"
 319                         . "(?:$s$variantList)?"
 320                         . "(?:$s$extensionList)?"
 321                         . "(?:$s$privateUse)?)";
 322
 323                 # The final breakdown, with capturing groups for each of these components
 324                 # The variants, extensions, grandfathered, and private-use may have interior '-'
 325
 326                 $root = "^(?:$langtag|$privateUse|$grandfathered)$";
 327
 328                 return (bool)preg_match( "/$root/", strtolower( $code ) );
 329         }
 330
 331         /**
 332          * Returns true if a language code string is of a valid form, whether or
 333          * not it exists. This includes codes which are used solely for
 334          * customisation via the MediaWiki namespace.
 335          *
 336          * @param string $code
 337          *
 338          * @return bool
 339          */
 340         public static function isValidCode( $code ) {
 341                 static $cache = array();
 342                 if ( isset( $cache[$code] ) ) {
 343                         return $cache[$code];
 344                 }
 345                 // People think language codes are html safe, so enforce it.
 346                 // Ideally we should only allow a-zA-Z0-9-
 347                 // but, .+ and other chars are often used for {{int:}} hacks
 348                 // see bugs 37564, 37587, 36938
 349                 $cache[$code] =
 350                         strcspn( $code, ":/\\\000&<>'\"" ) === strlen( $code )
 351                         && !preg_match( MediaWikiTitleCodec::getTitleInvalidRegex(), $code );
 352
 353                 return $cache[$code];
 354         }
 355
 356         /**
 357          * Returns true if a language code is of a valid form for the purposes of
 358          * internal customisation of MediaWiki, via Messages*.php or *.json.
 359          *
 360          * @param string $code
 361          *
 362          * @throws MWException
 363          * @since 1.18
 364          * @return bool
 365          */
 366         public static function isValidBuiltInCode( $code ) {
 367
 368                 if ( !is_string( $code ) ) {
 369                         if ( is_object( $code ) ) {
 370                                 $addmsg = " of class " . get_class( $code );
 371                         } else {
 372                                 $addmsg = '';
 373                         }
 374                         $type = gettype( $code );
 375                         throw new MWException( __METHOD__ . " must be passed a string, $type given$addmsg" );
 376                 }
 377
 378                 return (bool)preg_match( '/^[a-z0-9-]{2,}$/', $code );
 379         }
 380
 381         /**
 382          * Returns true if a language code is an IETF tag known to MediaWiki.
 383          *
 384          * @param string $tag
 385          *
 386          * @since 1.21
 387          * @return bool
 388          */
 389         public static function isKnownLanguageTag( $tag ) {
 390                 static $coreLanguageNames;
 391
 392                 // Quick escape for invalid input to avoid exceptions down the line
 393                 // when code tries to process tags which are not valid at all.
 394                 if ( !self::isValidBuiltInCode( $tag ) ) {
 395                         return false;
 396                 }
 397
 398                 if ( $coreLanguageNames === null ) {
 399                         global $IP;
 400                         include "$IP/languages/Names.php";
 401                 }
 402
 403                 if ( isset( $coreLanguageNames[$tag] )
 404                         || self::fetchLanguageName( $tag, $tag ) !== ''
 405                 ) {
 406                         return true;
 407                 }
 408
 409                 return false;
 410         }
 411
 412         /**
 413          * @param string $code
 414          * @return string Name of the language class
 415          */
 416         public static function classFromCode( $code ) {
 417                 if ( $code == 'en' ) {
 418                         return 'Language';
 419                 } else {
 420                         return 'Language' . str_replace( '-', '_', ucfirst( $code ) );
 421                 }
 422         }
 423
 424         /**
 425          * Includes language class files
 426          *
 427          * @param string $class Name of the language class
 428          */
 429         public static function preloadLanguageClass( $class ) {
 430                 global $IP;
 431
 432                 if ( $class === 'Language' ) {
 433                         return;
 434                 }
 435
 436                 if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
 437                         include_once "$IP/languages/classes/$class.php";
 438                 }
 439         }
 440
 441         /**
 442          * Get the LocalisationCache instance
 443          *
 444          * @return LocalisationCache
 445          */
 446         public static function getLocalisationCache() {
 447                 if ( is_null( self::$dataCache ) ) {
 448                         global $wgLocalisationCacheConf;
 449                         $class = $wgLocalisationCacheConf['class'];
 450                         self::$dataCache = new $class( $wgLocalisationCacheConf );
 451                 }
 452                 return self::$dataCache;
 453         }
 454
 455         function __construct() {
 456                 $this->mConverter = new FakeConverter( $this );
 457                 // Set the code to the name of the descendant
 458                 if ( get_class( $this ) == 'Language' ) {
 459                         $this->mCode = 'en';
 460                 } else {
 461                         $this->mCode = str_replace( '_', '-', strtolower( substr( get_class( $this ), 8 ) ) );
 462                 }
 463                 self::getLocalisationCache();
 464         }
 465
 466         /**
 467          * Reduce memory usage
 468          */
 469         function __destruct() {
 470                 foreach ( $this as $name => $value ) {
 471                         unset( $this->$name );
 472                 }
 473         }
 474
 475         /**
 476          * Hook which will be called if this is the content language.
 477          * Descendants can use this to register hook functions or modify globals
 478          */
 479         function initContLang() {
 480         }
 481
 482         /**
 483          * @return array
 484          * @since 1.19
 485          */
 486         function getFallbackLanguages() {
 487                 return self::getFallbacksFor( $this->mCode );
 488         }
 489
 490         /**
 491          * Exports $wgBookstoreListEn
 492          * @return array
 493          */
 494         function getBookstoreList() {
 495                 return self::$dataCache->getItem( $this->mCode, 'bookstoreList' );
 496         }
 497
 498         /**
 499          * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
 500          * available in localised form, it will be included in English.
 501          *
 502          * @return array
 503          */
 504         public function getNamespaces() {
 505                 if ( is_null( $this->namespaceNames ) ) {
 506                         global $wgMetaNamespace, $wgMetaNamespaceTalk, $wgExtraNamespaces;
 507
 508                         $this->namespaceNames = self::$dataCache->getItem( $this->mCode, 'namespaceNames' );
 509                         $validNamespaces = MWNamespace::getCanonicalNamespaces();
 510
 511                         $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames + $validNamespaces;
 512
 513                         $this->namespaceNames[NS_PROJECT] = $wgMetaNamespace;
 514                         if ( $wgMetaNamespaceTalk ) {
 515                                 $this->namespaceNames[NS_PROJECT_TALK] = $wgMetaNamespaceTalk;
 516                         } else {
 517                                 $talk = $this->namespaceNames[NS_PROJECT_TALK];
 518                                 $this->namespaceNames[NS_PROJECT_TALK] =
 519                                         $this->fixVariableInNamespace( $talk );
 520                         }
 521
 522                         # Sometimes a language will be localised but not actually exist on this wiki.
 523                         foreach ( $this->namespaceNames as $key => $text ) {
 524                                 if ( !isset( $validNamespaces[$key] ) ) {
 525                                         unset( $this->namespaceNames[$key] );
 526                                 }
 527                         }
 528
 529                         # The above mixing may leave namespaces out of canonical order.
 530                         # Re-order by namespace ID number...
 531                         ksort( $this->namespaceNames );
 532
 533                         Hooks::run( 'LanguageGetNamespaces', array( &$this->namespaceNames ) );
 534                 }
 535
 536                 return $this->namespaceNames;
 537         }
 538
 539         /**
 540          * Arbitrarily set all of the namespace names at once. Mainly used for testing
 541          * @param array $namespaces Array of namespaces (id => name)
 542          */
 543         public function setNamespaces( array $namespaces ) {
 544                 $this->namespaceNames = $namespaces;
 545                 $this->mNamespaceIds = null;
 546         }
 547
 548         /**
 549          * Resets all of the namespace caches. Mainly used for testing
 550          */
 551         public function resetNamespaces() {
 552                 $this->namespaceNames = null;
 553                 $this->mNamespaceIds = null;
 554                 $this->namespaceAliases = null;
 555         }
 556
 557         /**
 558          * A convenience function that returns getNamespaces() with spaces instead of underscores
 559          * in values. Useful for producing output to be displayed e.g. in `<select>` forms.
 560          *
 561          * @return array
 562          */
 563         function getFormattedNamespaces() {
 564                 $ns = $this->getNamespaces();
 565                 foreach ( $ns as $k => $v ) {
 566                         $ns[$k] = strtr( $v, '_', ' ' );
 567                 }
 568                 return $ns;
 569         }
 570
 571         /**
 572          * Get a namespace value by key
 573          *
 574          * <code>
 575          * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
 576          * echo $mw_ns; // prints 'MediaWiki'
 577          * </code>
 578          *
 579          * @param int $index The array key of the namespace to return
 580          * @return string|bool String if the namespace value exists, otherwise false
 581          */
 582         function getNsText( $index ) {
 583                 $ns = $this->getNamespaces();
 584                 return isset( $ns[$index] ) ? $ns[$index] : false;
 585         }
 586
 587         /**
 588          * A convenience function that returns the same thing as
 589          * getNsText() except with '_' changed to ' ', useful for
 590          * producing output.
 591          *
 592          * <code>
 593          * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
 594          * echo $mw_ns; // prints 'MediaWiki talk'
 595          * </code>
 596          *
 597          * @param int $index The array key of the namespace to return
 598          * @return string Namespace name without underscores (empty string if namespace does not exist)
 599          */
 600         function getFormattedNsText( $index ) {
 601                 $ns = $this->getNsText( $index );
 602                 return strtr( $ns, '_', ' ' );
 603         }
 604
 605         /**
 606          * Returns gender-dependent namespace alias if available.
 607          * See https://www.mediawiki.org/wiki/Manual:$wgExtraGenderNamespaces
 608          * @param int $index Namespace index
 609          * @param string $gender Gender key (male, female... )
 610          * @return string
 611          * @since 1.18
 612          */
 613         function getGenderNsText( $index, $gender ) {
 614                 global $wgExtraGenderNamespaces;
 615
 616                 $ns = $wgExtraGenderNamespaces +
 617                         (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
 618
 619                 return isset( $ns[$index][$gender] ) ? $ns[$index][$gender] : $this->getNsText( $index );
 620         }
 621
 622         /**
 623          * Whether this language uses gender-dependent namespace aliases.
 624          * See https://www.mediawiki.org/wiki/Manual:$wgExtraGenderNamespaces
 625          * @return bool
 626          * @since 1.18
 627          */
 628         function needsGenderDistinction() {
 629                 global $wgExtraGenderNamespaces, $wgExtraNamespaces;
 630                 if ( count( $wgExtraGenderNamespaces ) > 0 ) {
 631                         // $wgExtraGenderNamespaces overrides everything
 632                         return true;
 633                 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
 634                         /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
 635                         // $wgExtraNamespaces overrides any gender aliases specified in i18n files
 636                         return false;
 637                 } else {
 638                         // Check what is in i18n files
 639                         $aliases = self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
 640                         return count( $aliases ) > 0;
 641                 }
 642         }
 643
 644         /**
 645          * Get a namespace key by value, case insensitive.
 646          * Only matches namespace names for the current language, not the
 647          * canonical ones defined in Namespace.php.
 648          *
 649          * @param string $text
 650          * @return int|bool An integer if $text is a valid value otherwise false
 651          */
 652         function getLocalNsIndex( $text ) {
 653                 $lctext = $this->lc( $text );
 654                 $ids = $this->getNamespaceIds();
 655                 return isset( $ids[$lctext] ) ? $ids[$lctext] : false;
 656         }
 657
 658         /**
 659          * @return array
 660          */
 661         function getNamespaceAliases() {
 662                 if ( is_null( $this->namespaceAliases ) ) {
 663                         $aliases = self::$dataCache->getItem( $this->mCode, 'namespaceAliases' );
 664                         if ( !$aliases ) {
 665                                 $aliases = array();
 666                         } else {
 667                                 foreach ( $aliases as $name => $index ) {
 668                                         if ( $index === NS_PROJECT_TALK ) {
 669                                                 unset( $aliases[$name] );
 670                                                 $name = $this->fixVariableInNamespace( $name );
 671                                                 $aliases[$name] = $index;
 672                                         }
 673                                 }
 674                         }
 675
 676                         global $wgExtraGenderNamespaces;
 677                         $genders = $wgExtraGenderNamespaces +
 678                                 (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
 679                         foreach ( $genders as $index => $forms ) {
 680                                 foreach ( $forms as $alias ) {
 681                                         $aliases[$alias] = $index;
 682                                 }
 683                         }
 684
 685                         # Also add converted namespace names as aliases, to avoid confusion.
 686                         $convertedNames = array();
 687                         foreach ( $this->getVariants() as $variant ) {
 688                                 if ( $variant === $this->mCode ) {
 689                                         continue;
 690                                 }
 691                                 foreach ( $this->getNamespaces() as $ns => $_ ) {
 692                                         $convertedNames[$this->getConverter()->convertNamespace( $ns, $variant )] = $ns;
 693                                 }
 694                         }
 695
 696                         $this->namespaceAliases = $aliases + $convertedNames;
 697                 }
 698
 699                 return $this->namespaceAliases;
 700         }
 701
 702         /**
 703          * @return array
 704          */
 705         function getNamespaceIds() {
 706                 if ( is_null( $this->mNamespaceIds ) ) {
 707                         global $wgNamespaceAliases;
 708                         # Put namespace names and aliases into a hashtable.
 709                         # If this is too slow, then we should arrange it so that it is done
 710                         # before caching. The catch is that at pre-cache time, the above
 711                         # class-specific fixup hasn't been done.
 712                         $this->mNamespaceIds = array();
 713                         foreach ( $this->getNamespaces() as $index => $name ) {
 714                                 $this->mNamespaceIds[$this->lc( $name )] = $index;
 715                         }
 716                         foreach ( $this->getNamespaceAliases() as $name => $index ) {
 717                                 $this->mNamespaceIds[$this->lc( $name )] = $index;
 718                         }
 719                         if ( $wgNamespaceAliases ) {
 720                                 foreach ( $wgNamespaceAliases as $name => $index ) {
 721                                         $this->mNamespaceIds[$this->lc( $name )] = $index;
 722                                 }
 723                         }
 724                 }
 725                 return $this->mNamespaceIds;
 726         }
 727
 728         /**
 729          * Get a namespace key by value, case insensitive.  Canonical namespace
 730          * names override custom ones defined for the current language.
 731          *
 732          * @param string $text
 733          * @return int|bool An integer if $text is a valid value otherwise false
 734          */
 735         function getNsIndex( $text ) {
 736                 $lctext = $this->lc( $text );
 737                 $ns = MWNamespace::getCanonicalIndex( $lctext );
 738                 if ( $ns !== null ) {
 739                         return $ns;
 740                 }
 741                 $ids = $this->getNamespaceIds();
 742                 return isset( $ids[$lctext] ) ? $ids[$lctext] : false;
 743         }
 744
 745         /**
 746          * short names for language variants used for language conversion links.
 747          *
 748          * @param string $code
 749          * @param bool $usemsg Use the "variantname-xyz" message if it exists
 750          * @return string
 751          */
 752         function getVariantname( $code, $usemsg = true ) {
 753                 $msg = "variantname-$code";
 754                 if ( $usemsg && wfMessage( $msg )->exists() ) {
 755                         return $this->getMessageFromDB( $msg );
 756                 }
 757                 $name = self::fetchLanguageName( $code );
 758                 if ( $name ) {
 759                         return $name; # if it's defined as a language name, show that
 760                 } else {
 761                         # otherwise, output the language code
 762                         return $code;
 763                 }
 764         }
 765
 766         /**
 767          * @deprecated since 1.24, doesn't handle conflicting aliases. Use
 768          *   SpecialPageFactory::getLocalNameFor instead.
 769          * @param string $name
 770          * @return string
 771          */
 772         function specialPage( $name ) {
 773                 $aliases = $this->getSpecialPageAliases();
 774                 if ( isset( $aliases[$name][0] ) ) {
 775                         $name = $aliases[$name][0];
 776                 }
 777                 return $this->getNsText( NS_SPECIAL ) . ':' . $name;
 778         }
 779
 780         /**
 781          * @return array
 782          */
 783         function getDatePreferences() {
 784                 return self::$dataCache->getItem( $this->mCode, 'datePreferences' );
 785         }
 786
 787         /**
 788          * @return array
 789          */
 790         function getDateFormats() {
 791                 return self::$dataCache->getItem( $this->mCode, 'dateFormats' );
 792         }
 793
 794         /**
 795          * @return array|string
 796          */
 797         function getDefaultDateFormat() {
 798                 $df = self::$dataCache->getItem( $this->mCode, 'defaultDateFormat' );
 799                 if ( $df === 'dmy or mdy' ) {
 800                         global $wgAmericanDates;
 801                         return $wgAmericanDates ? 'mdy' : 'dmy';
 802                 } else {
 803                         return $df;
 804                 }
 805         }
 806
 807         /**
 808          * @return array
 809          */
 810         function getDatePreferenceMigrationMap() {
 811                 return self::$dataCache->getItem( $this->mCode, 'datePreferenceMigrationMap' );
 812         }
 813
 814         /**
 815          * @param string $image
 816          * @return array|null
 817          */
 818         function getImageFile( $image ) {
 819                 return self::$dataCache->getSubitem( $this->mCode, 'imageFiles', $image );
 820         }
 821
 822         /**
 823          * @return array
 824          * @since 1.24
 825          */
 826         function getImageFiles() {
 827                 return self::$dataCache->getItem( $this->mCode, 'imageFiles' );
 828         }
 829
 830         /**
 831          * @return array
 832          */
 833         function getExtraUserToggles() {
 834                 return (array)self::$dataCache->getItem( $this->mCode, 'extraUserToggles' );
 835         }
 836
 837         /**
 838          * @param string $tog
 839          * @return string
 840          */
 841         function getUserToggle( $tog ) {
 842                 return $this->getMessageFromDB( "tog-$tog" );
 843         }
 844
 845         /**
 846          * Get native language names, indexed by code.
 847          * Only those defined in MediaWiki, no other data like CLDR.
 848          * If $customisedOnly is true, only returns codes with a messages file
 849          *
 850          * @param bool $customisedOnly
 851          *
 852          * @return array
 853          * @deprecated since 1.20, use fetchLanguageNames()
 854          */
 855         public static function getLanguageNames( $customisedOnly = false ) {
 856                 return self::fetchLanguageNames( null, $customisedOnly ? 'mwfile' : 'mw' );
 857         }
 858
 859         /**
 860          * Get translated language names. This is done on best effort and
 861          * by default this is exactly the same as Language::getLanguageNames.
 862          * The CLDR extension provides translated names.
 863          * @param string $code Language code.
 864          * @return array Language code => language name
 865          * @since 1.18.0
 866          * @deprecated since 1.20, use fetchLanguageNames()
 867          */
 868         public static function getTranslatedLanguageNames( $code ) {
 869                 return self::fetchLanguageNames( $code, 'all' );
 870         }
 871
 872         /**
 873          * Get an array of language names, indexed by code.
 874          * @param null|string $inLanguage Code of language in which to return the names
 875          *              Use null for autonyms (native names)
 876          * @param string $include One of:
 877          *              'all' all available languages
 878          *              'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
 879          *              'mwfile' only if the language is in 'mw' *and* has a message file
 880          * @return array Language code => language name
 881          * @since 1.20
 882          */
 883         public static function fetchLanguageNames( $inLanguage = null, $include = 'mw' ) {
 884                 $cacheKey = $inLanguage === null ? 'null' : $inLanguage;
 885                 $cacheKey .= ":$include";
 886                 if ( self::$languageNameCache === null ) {
 887                         self::$languageNameCache = new MapCacheLRU( 20 );
 888                 }
 889                 if ( self::$languageNameCache->has( $cacheKey ) ) {
 890                         $ret = self::$languageNameCache->get( $cacheKey );
 891                 } else {
 892                         $ret = self::fetchLanguageNamesUncached( $inLanguage, $include );
 893                         self::$languageNameCache->set( $cacheKey, $ret );
 894                 }
 895                 return $ret;
 896         }
 897
 898         /**
 899          * Uncached helper for fetchLanguageNames
 900          * @param null|string $inLanguage Code of language in which to return the names
 901          *              Use null for autonyms (native names)
 902          * @param string $include One of:
 903          *              'all' all available languages
 904          *              'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
 905          *              'mwfile' only if the language is in 'mw' *and* has a message file
 906          * @return array Language code => language name
 907          */
 908         private static function fetchLanguageNamesUncached( $inLanguage = null, $include = 'mw' ) {
 909                 global $wgExtraLanguageNames;
 910                 static $coreLanguageNames;
 911
 912                 if ( $coreLanguageNames === null ) {
 913                         global $IP;
 914                         include "$IP/languages/Names.php";
 915                 }
 916
 917                 // If passed an invalid language code to use, fallback to en
 918                 if ( $inLanguage !== null && !Language::isValidCode( $inLanguage ) ) {
 919                         $inLanguage = 'en';
 920                 }
 921
 922                 $names = array();
 923
 924                 if ( $inLanguage ) {
 925                         # TODO: also include when $inLanguage is null, when this code is more efficient
 926                         Hooks::run( 'LanguageGetTranslatedLanguageNames', array( &$names, $inLanguage ) );
 927                 }
 928
 929                 $mwNames = $wgExtraLanguageNames + $coreLanguageNames;
 930                 foreach ( $mwNames as $mwCode => $mwName ) {
 931                         # - Prefer own MediaWiki native name when not using the hook
 932                         # - For other names just add if not added through the hook
 933                         if ( $mwCode === $inLanguage || !isset( $names[$mwCode] ) ) {
 934                                 $names[$mwCode] = $mwName;
 935                         }
 936                 }
 937
 938                 if ( $include === 'all' ) {
 939                         ksort( $names );
 940                         return $names;
 941                 }
 942
 943                 $returnMw = array();
 944                 $coreCodes = array_keys( $mwNames );
 945                 foreach ( $coreCodes as $coreCode ) {
 946                         $returnMw[$coreCode] = $names[$coreCode];
 947                 }
 948
 949                 if ( $include === 'mwfile' ) {
 950                         $namesMwFile = array();
 951                         # We do this using a foreach over the codes instead of a directory
 952                         # loop so that messages files in extensions will work correctly.
 953                         foreach ( $returnMw as $code => $value ) {
 954                                 if ( is_readable( self::getMessagesFileName( $code ) )
 955                                         || is_readable( self::getJsonMessagesFileName( $code ) )
 956                                 ) {
 957                                         $namesMwFile[$code] = $names[$code];
 958                                 }
 959                         }
 960
 961                         ksort( $namesMwFile );
 962                         return $namesMwFile;
 963                 }
 964
 965                 ksort( $returnMw );
 966                 # 'mw' option; default if it's not one of the other two options (all/mwfile)
 967                 return $returnMw;
 968         }
 969
 970         /**
 971          * @param string $code The code of the language for which to get the name
 972          * @param null|string $inLanguage Code of language in which to return the name (null for autonyms)
 973          * @param string $include 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
 974          * @return string Language name or empty
 975          * @since 1.20
 976          */
 977         public static function fetchLanguageName( $code, $inLanguage = null, $include = 'all' ) {
 978                 $code = strtolower( $code );
 979                 $array = self::fetchLanguageNames( $inLanguage, $include );
 980                 return !array_key_exists( $code, $array ) ? '' : $array[$code];
 981         }
 982
 983         /**
 984          * Get a message from the MediaWiki namespace.
 985          *
 986          * @param string $msg Message name
 987          * @return string
 988          */
 989         function getMessageFromDB( $msg ) {
 990                 return $this->msg( $msg )->text();
 991         }
 992
 993         /**
 994          * Get message object in this language. Only for use inside this class.
 995          *
 996          * @param string $msg Message name
 997          * @return Message
 998          */
 999         protected function msg( $msg ) {
1000                 return wfMessage( $msg )->inLanguage( $this );
1001         }
1002
1003         /**
1004          * Get the native language name of $code.
1005          * Only if defined in MediaWiki, no other data like CLDR.
1006          * @param string $code
1007          * @return string
1008          * @deprecated since 1.20, use fetchLanguageName()
1009          */
1010         function getLanguageName( $code ) {
1011                 return self::fetchLanguageName( $code );
1012         }
1013
1014         /**
1015          * @param string $key
1016          * @return string
1017          */
1018         function getMonthName( $key ) {
1019                 return $this->getMessageFromDB( self::$mMonthMsgs[$key - 1] );
1020         }
1021
1022         /**
1023          * @return array
1024          */
1025         function getMonthNamesArray() {
1026                 $monthNames = array( '' );
1027                 for ( $i = 1; $i < 13; $i++ ) {
1028                         $monthNames[] = $this->getMonthName( $i );
1029                 }
1030                 return $monthNames;
1031         }
1032
1033         /**
1034          * @param string $key
1035          * @return string
1036          */
1037         function getMonthNameGen( $key ) {
1038                 return $this->getMessageFromDB( self::$mMonthGenMsgs[$key - 1] );
1039         }
1040
1041         /**
1042          * @param string $key
1043          * @return string
1044          */
1045         function getMonthAbbreviation( $key ) {
1046                 return $this->getMessageFromDB( self::$mMonthAbbrevMsgs[$key - 1] );
1047         }
1048
1049         /**
1050          * @return array
1051          */
1052         function getMonthAbbreviationsArray() {
1053                 $monthNames = array( '' );
1054                 for ( $i = 1; $i < 13; $i++ ) {
1055                         $monthNames[] = $this->getMonthAbbreviation( $i );
1056                 }
1057                 return $monthNames;
1058         }
1059
1060         /**
1061          * @param string $key
1062          * @return string
1063          */
1064         function getWeekdayName( $key ) {
1065                 return $this->getMessageFromDB( self::$mWeekdayMsgs[$key - 1] );
1066         }
1067
1068         /**
1069          * @param string $key
1070          * @return string
1071          */
1072         function getWeekdayAbbreviation( $key ) {
1073                 return $this->getMessageFromDB( self::$mWeekdayAbbrevMsgs[$key - 1] );
1074         }
1075
1076         /**
1077          * @param string $key
1078          * @return string
1079          */
1080         function getIranianCalendarMonthName( $key ) {
1081                 return $this->getMessageFromDB( self::$mIranianCalendarMonthMsgs[$key - 1] );
1082         }
1083
1084         /**
1085          * @param string $key
1086          * @return string
1087          */
1088         function getHebrewCalendarMonthName( $key ) {
1089                 return $this->getMessageFromDB( self::$mHebrewCalendarMonthMsgs[$key - 1] );
1090         }
1091
1092         /**
1093          * @param string $key
1094          * @return string
1095          */
1096         function getHebrewCalendarMonthNameGen( $key ) {
1097                 return $this->getMessageFromDB( self::$mHebrewCalendarMonthGenMsgs[$key - 1] );
1098         }
1099
1100         /**
1101          * @param string $key
1102          * @return string
1103          */
1104         function getHijriCalendarMonthName( $key ) {
1105                 return $this->getMessageFromDB( self::$mHijriCalendarMonthMsgs[$key - 1] );
1106         }
1107
1108         /**
1109          * Pass through result from $dateTimeObj->format()
1110          * @param DateTime|bool|null &$dateTimeObj
1111          * @param string $ts
1112          * @param DateTimeZone|bool|null $zone
1113          * @param string $code
1114          * @return string
1115          */
1116         private static function dateTimeObjFormat( &$dateTimeObj, $ts, $zone, $code ) {
1117                 if ( !$dateTimeObj ) {
1118                         $dateTimeObj = DateTime::createFromFormat(
1119                                 'YmdHis', $ts, $zone ?: new DateTimeZone( 'UTC' )
1120                         );
1121                 }
1122                 return $dateTimeObj->format( $code );
1123         }
1124
1125         /**
1126          * This is a workalike of PHP's date() function, but with better
1127          * internationalisation, a reduced set of format characters, and a better
1128          * escaping format.
1129          *
1130          * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1131          * the PHP manual for definitions. There are a number of extensions, which
1132          * start with "x":
1133          *
1134          *    xn   Do not translate digits of the next numeric format character
1135          *    xN   Toggle raw digit (xn) flag, stays set until explicitly unset
1136          *    xr   Use roman numerals for the next numeric format character
1137          *    xh   Use hebrew numerals for the next numeric format character
1138          *    xx   Literal x
1139          *    xg   Genitive month name
1140          *
1141          *    xij  j (day number) in Iranian calendar
1142          *    xiF  F (month name) in Iranian calendar
1143          *    xin  n (month number) in Iranian calendar
1144          *    xiy  y (two digit year) in Iranian calendar
1145          *    xiY  Y (full year) in Iranian calendar
1146          *
1147          *    xjj  j (day number) in Hebrew calendar
1148          *    xjF  F (month name) in Hebrew calendar
1149          *    xjt  t (days in month) in Hebrew calendar
1150          *    xjx  xg (genitive month name) in Hebrew calendar
1151          *    xjn  n (month number) in Hebrew calendar
1152          *    xjY  Y (full year) in Hebrew calendar
1153          *
1154          *    xmj  j (day number) in Hijri calendar
1155          *    xmF  F (month name) in Hijri calendar
1156          *    xmn  n (month number) in Hijri calendar
1157          *    xmY  Y (full year) in Hijri calendar
1158          *
1159          *    xkY  Y (full year) in Thai solar calendar. Months and days are
1160          *                       identical to the Gregorian calendar
1161          *    xoY  Y (full year) in Minguo calendar or Juche year.
1162          *                       Months and days are identical to the
1163          *                       Gregorian calendar
1164          *    xtY  Y (full year) in Japanese nengo. Months and days are
1165          *                       identical to the Gregorian calendar
1166          *
1167          * Characters enclosed in double quotes will be considered literal (with
1168          * the quotes themselves removed). Unmatched quotes will be considered
1169          * literal quotes. Example:
1170          *
1171          * "The month is" F       => The month is January
1172          * i's"                   => 20'11"
1173          *
1174          * Backslash escaping is also supported.
1175          *
1176          * Input timestamp is assumed to be pre-normalized to the desired local
1177          * time zone, if any. Note that the format characters crUeIOPTZ will assume
1178          * $ts is UTC if $zone is not given.
1179          *
1180          * @param string $format
1181          * @param string $ts 14-character timestamp
1182          *      YYYYMMDDHHMMSS
1183          *      01234567890123
1184          * @param DateTimeZone $zone Timezone of $ts
1185          * @param[out] int $ttl The amount of time (in seconds) the output may be cached for.
1186          * Only makes sense if $ts is the current time.
1187          * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1188          *
1189          * @throws MWException
1190          * @return string
1191          */
1192         function sprintfDate( $format, $ts, DateTimeZone $zone = null, &$ttl = null ) {
1193                 $s = '';
1194                 $raw = false;
1195                 $roman = false;
1196                 $hebrewNum = false;
1197                 $dateTimeObj = false;
1198                 $rawToggle = false;
1199                 $iranian = false;
1200                 $hebrew = false;
1201                 $hijri = false;
1202                 $thai = false;
1203                 $minguo = false;
1204                 $tenno = false;
1205
1206                 $usedSecond = false;
1207                 $usedMinute = false;
1208                 $usedHour = false;
1209                 $usedAMPM = false;
1210                 $usedDay = false;
1211                 $usedWeek = false;
1212                 $usedMonth = false;
1213                 $usedYear = false;
1214                 $usedISOYear = false;
1215                 $usedIsLeapYear = false;
1216
1217                 $usedHebrewMonth = false;
1218                 $usedIranianMonth = false;
1219                 $usedHijriMonth = false;
1220                 $usedHebrewYear = false;
1221                 $usedIranianYear = false;
1222                 $usedHijriYear = false;
1223                 $usedTennoYear = false;
1224
1225                 if ( strlen( $ts ) !== 14 ) {
1226                         throw new MWException( __METHOD__ . ": The timestamp $ts should have 14 characters" );
1227                 }
1228
1229                 if ( !ctype_digit( $ts ) ) {
1230                         throw new MWException( __METHOD__ . ": The timestamp $ts should be a number" );
1231                 }
1232
1233                 $formatLength = strlen( $format );
1234                 for ( $p = 0; $p < $formatLength; $p++ ) {
1235                         $num = false;
1236                         $code = $format[$p];
1237                         if ( $code == 'x' && $p < $formatLength - 1 ) {
1238                                 $code .= $format[++$p];
1239                         }
1240
1241                         if ( ( $code === 'xi'
1242                                         || $code === 'xj'
1243                                         || $code === 'xk'
1244                                         || $code === 'xm'
1245                                         || $code === 'xo'
1246                                         || $code === 'xt' )
1247                                 && $p < $formatLength - 1 ) {
1248                                 $code .= $format[++$p];
1249                         }
1250
1251                         switch ( $code ) {
1252                                 case 'xx':
1253                                         $s .= 'x';
1254                                         break;
1255                                 case 'xn':
1256                                         $raw = true;
1257                                         break;
1258                                 case 'xN':
1259                                         $rawToggle = !$rawToggle;
1260                                         break;
1261                                 case 'xr':
1262                                         $roman = true;
1263                                         break;
1264                                 case 'xh':
1265                                         $hebrewNum = true;
1266                                         break;
1267                                 case 'xg':
1268                                         $usedMonth = true;
1269                                         $s .= $this->getMonthNameGen( substr( $ts, 4, 2 ) );
1270                                         break;
1271                                 case 'xjx':
1272                                         $usedHebrewMonth = true;
1273                                         if ( !$hebrew ) {
1274                                                 $hebrew = self::tsToHebrew( $ts );
1275                                         }
1276                                         $s .= $this->getHebrewCalendarMonthNameGen( $hebrew[1] );
1277                                         break;
1278                                 case 'd':
1279                                         $usedDay = true;
1280                                         $num = substr( $ts, 6, 2 );
1281                                         break;
1282                                 case 'D':
1283                                         $usedDay = true;
1284                                         $s .= $this->getWeekdayAbbreviation(
1285                                                 Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1
1286                                         );
1287                                         break;
1288                                 case 'j':
1289                                         $usedDay = true;
1290                                         $num = intval( substr( $ts, 6, 2 ) );
1291                                         break;
1292                                 case 'xij':
1293                                         $usedDay = true;
1294                                         if ( !$iranian ) {
1295                                                 $iranian = self::tsToIranian( $ts );
1296                                         }
1297                                         $num = $iranian[2];
1298                                         break;
1299                                 case 'xmj':
1300                                         $usedDay = true;
1301                                         if ( !$hijri ) {
1302                                                 $hijri = self::tsToHijri( $ts );
1303                                         }
1304                                         $num = $hijri[2];
1305                                         break;
1306                                 case 'xjj':
1307                                         $usedDay = true;
1308                                         if ( !$hebrew ) {
1309                                                 $hebrew = self::tsToHebrew( $ts );
1310                                         }
1311                                         $num = $hebrew[2];
1312                                         break;
1313                                 case 'l':
1314                                         $usedDay = true;
1315                                         $s .= $this->getWeekdayName(
1316                                                 Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1
1317                                         );
1318                                         break;
1319                                 case 'F':
1320                                         $usedMonth = true;
1321                                         $s .= $this->getMonthName( substr( $ts, 4, 2 ) );
1322                                         break;
1323                                 case 'xiF':
1324                                         $usedIranianMonth = true;
1325                                         if ( !$iranian ) {
1326                                                 $iranian = self::tsToIranian( $ts );
1327                                         }
1328                                         $s .= $this->getIranianCalendarMonthName( $iranian[1] );
1329                                         break;
1330                                 case 'xmF':
1331                                         $usedHijriMonth = true;
1332                                         if ( !$hijri ) {
1333                                                 $hijri = self::tsToHijri( $ts );
1334                                         }
1335                                         $s .= $this->getHijriCalendarMonthName( $hijri[1] );
1336                                         break;
1337                                 case 'xjF':
1338                                         $usedHebrewMonth = true;
1339                                         if ( !$hebrew ) {
1340                                                 $hebrew = self::tsToHebrew( $ts );
1341                                         }
1342                                         $s .= $this->getHebrewCalendarMonthName( $hebrew[1] );
1343                                         break;
1344                                 case 'm':
1345                                         $usedMonth = true;
1346                                         $num = substr( $ts, 4, 2 );
1347                                         break;
1348                                 case 'M':
1349                                         $usedMonth = true;
1350                                         $s .= $this->getMonthAbbreviation( substr( $ts, 4, 2 ) );
1351                                         break;
1352                                 case 'n':
1353                                         $usedMonth = true;
1354                                         $num = intval( substr( $ts, 4, 2 ) );
1355                                         break;
1356                                 case 'xin':
1357                                         $usedIranianMonth = true;
1358                                         if ( !$iranian ) {
1359                                                 $iranian = self::tsToIranian( $ts );
1360                                         }
1361                                         $num = $iranian[1];
1362                                         break;
1363                                 case 'xmn':
1364                                         $usedHijriMonth = true;
1365                                         if ( !$hijri ) {
1366                                                 $hijri = self::tsToHijri( $ts );
1367                                         }
1368                                         $num = $hijri[1];
1369                                         break;
1370                                 case 'xjn':
1371                                         $usedHebrewMonth = true;
1372                                         if ( !$hebrew ) {
1373                                                 $hebrew = self::tsToHebrew( $ts );
1374                                         }
1375                                         $num = $hebrew[1];
1376                                         break;
1377                                 case 'xjt':
1378                                         $usedHebrewMonth = true;
1379                                         if ( !$hebrew ) {
1380                                                 $hebrew = self::tsToHebrew( $ts );
1381                                         }
1382                                         $num = $hebrew[3];
1383                                         break;
1384                                 case 'Y':
1385                                         $usedYear = true;
1386                                         $num = substr( $ts, 0, 4 );
1387                                         break;
1388                                 case 'xiY':
1389                                         $usedIranianYear = true;
1390                                         if ( !$iranian ) {
1391                                                 $iranian = self::tsToIranian( $ts );
1392                                         }
1393                                         $num = $iranian[0];
1394                                         break;
1395                                 case 'xmY':
1396                                         $usedHijriYear = true;
1397                                         if ( !$hijri ) {
1398                                                 $hijri = self::tsToHijri( $ts );
1399                                         }
1400                                         $num = $hijri[0];
1401                                         break;
1402                                 case 'xjY':
1403                                         $usedHebrewYear = true;
1404                                         if ( !$hebrew ) {
1405                                                 $hebrew = self::tsToHebrew( $ts );
1406                                         }
1407                                         $num = $hebrew[0];
1408                                         break;
1409                                 case 'xkY':
1410                                         $usedYear = true;
1411                                         if ( !$thai ) {
1412                                                 $thai = self::tsToYear( $ts, 'thai' );
1413                                         }
1414                                         $num = $thai[0];
1415                                         break;
1416                                 case 'xoY':
1417                                         $usedYear = true;
1418                                         if ( !$minguo ) {
1419                                                 $minguo = self::tsToYear( $ts, 'minguo' );
1420                                         }
1421                                         $num = $minguo[0];
1422                                         break;
1423                                 case 'xtY':
1424                                         $usedTennoYear = true;
1425                                         if ( !$tenno ) {
1426                                                 $tenno = self::tsToYear( $ts, 'tenno' );
1427                                         }
1428                                         $num = $tenno[0];
1429                                         break;
1430                                 case 'y':
1431                                         $usedYear = true;
1432                                         $num = substr( $ts, 2, 2 );
1433                                         break;
1434                                 case 'xiy':
1435                                         $usedIranianYear = true;
1436                                         if ( !$iranian ) {
1437                                                 $iranian = self::tsToIranian( $ts );
1438                                         }
1439                                         $num = substr( $iranian[0], -2 );
1440                                         break;
1441                                 case 'a':
1442                                         $usedAMPM = true;
1443                                         $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'am' : 'pm';
1444                                         break;
1445                                 case 'A':
1446                                         $usedAMPM = true;
1447                                         $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'AM' : 'PM';
1448                                         break;
1449                                 case 'g':
1450                                         $usedHour = true;
1451                                         $h = substr( $ts, 8, 2 );
1452                                         $num = $h % 12 ? $h % 12 : 12;
1453                                         break;
1454                                 case 'G':
1455                                         $usedHour = true;
1456                                         $num = intval( substr( $ts, 8, 2 ) );
1457                                         break;
1458                                 case 'h':
1459                                         $usedHour = true;
1460                                         $h = substr( $ts, 8, 2 );
1461                                         $num = sprintf( '%02d', $h % 12 ? $h % 12 : 12 );
1462                                         break;
1463                                 case 'H':
1464                                         $usedHour = true;
1465                                         $num = substr( $ts, 8, 2 );
1466                                         break;
1467                                 case 'i':
1468                                         $usedMinute = true;
1469                                         $num = substr( $ts, 10, 2 );
1470                                         break;
1471                                 case 's':
1472                                         $usedSecond = true;
1473                                         $num = substr( $ts, 12, 2 );
1474                                         break;
1475                                 case 'c':
1476                                 case 'r':
1477                                         $usedSecond = true;
1478                                         // fall through
1479                                 case 'e':
1480                                 case 'O':
1481                                 case 'P':
1482                                 case 'T':
1483                                         $s .= Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, $code );
1484                                         break;
1485                                 case 'w':
1486                                 case 'N':
1487                                 case 'z':
1488                                         $usedDay = true;
1489                                         $num = Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, $code );
1490                                         break;
1491                                 case 'W':
1492                                         $usedWeek = true;
1493                                         $num = Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, $code );
1494                                         break;
1495                                 case 't':
1496                                         $usedMonth = true;
1497                                         $num = Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, $code );
1498                                         break;
1499                                 case 'L':
1500                                         $usedIsLeapYear = true;
1501                                         $num = Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, $code );
1502                                         break;
1503                                 case 'o':
1504                                         $usedISOYear = true;
1505                                         $num = Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, $code );
1506                                         break;
1507                                 case 'U':
1508                                         $usedSecond = true;
1509                                         // fall through
1510                                 case 'I':
1511                                 case 'Z':
1512                                         $num = Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, $code );
1513                                         break;
1514                                 case '\\':
1515                                         # Backslash escaping
1516                                         if ( $p < $formatLength - 1 ) {
1517                                                 $s .= $format[++$p];
1518                                         } else {
1519                                                 $s .= '\\';
1520                                         }
1521                                         break;
1522                                 case '"':
1523                                         # Quoted literal
1524                                         if ( $p < $formatLength - 1 ) {
1525                                                 $endQuote = strpos( $format, '"', $p + 1 );
1526                                                 if ( $endQuote === false ) {
1527                                                         # No terminating quote, assume literal "
1528                                                         $s .= '"';
1529                                                 } else {
1530                                                         $s .= substr( $format, $p + 1, $endQuote - $p - 1 );
1531                                                         $p = $endQuote;
1532                                                 }
1533                                         } else {
1534                                                 # Quote at end of string, assume literal "
1535                                                 $s .= '"';
1536                                         }
1537                                         break;
1538                                 default:
1539                                         $s .= $format[$p];
1540                         }
1541                         if ( $num !== false ) {
1542                                 if ( $rawToggle || $raw ) {
1543                                         $s .= $num;
1544                                         $raw = false;
1545                                 } elseif ( $roman ) {
1546                                         $s .= Language::romanNumeral( $num );
1547                                         $roman = false;
1548                                 } elseif ( $hebrewNum ) {
1549                                         $s .= self::hebrewNumeral( $num );
1550                                         $hebrewNum = false;
1551                                 } else {
1552                                         $s .= $this->formatNum( $num, true );
1553                                 }
1554                         }
1555                 }
1556
1557                 if ( $usedSecond ) {
1558                         $ttl = 1;
1559                 } elseif ( $usedMinute ) {
1560                         $ttl = 60 - substr( $ts, 12, 2 );
1561                 } elseif ( $usedHour ) {
1562                         $ttl = 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1563                 } elseif ( $usedAMPM ) {
1564                         $ttl = 43200 - ( substr( $ts, 8, 2 ) % 12 ) * 3600 -
1565                                 substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1566                 } elseif (
1567                         $usedDay ||
1568                         $usedHebrewMonth ||
1569                         $usedIranianMonth ||
1570                         $usedHijriMonth ||
1571                         $usedHebrewYear ||
1572                         $usedIranianYear ||
1573                         $usedHijriYear ||
1574                         $usedTennoYear
1575                 ) {
1576                         // @todo Someone who understands the non-Gregorian calendars
1577                         // should write proper logic for them so that they don't need purged every day.
1578                         $ttl = 86400 - substr( $ts, 8, 2 ) * 3600 -
1579                                 substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1580                 } else {
1581                         $possibleTtls = array();
1582                         $timeRemainingInDay = 86400 - substr( $ts, 8, 2 ) * 3600 -
1583                                 substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1584                         if ( $usedWeek ) {
1585                                 $possibleTtls[] =
1586                                         ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 +
1587                                         $timeRemainingInDay;
1588                         } elseif ( $usedISOYear ) {
1589                                 // December 28th falls on the last ISO week of the year, every year.
1590                                 // The last ISO week of a year can be 52 or 53.
1591                                 $lastWeekOfISOYear = DateTime::createFromFormat(
1592                                         'Ymd',
1593                                         substr( $ts, 0, 4 ) . '1228',
1594                                         $zone ?: new DateTimeZone( 'UTC' )
1595                                 )->format( 'W' );
1596                                 $currentISOWeek = Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'W' );
1597                                 $weeksRemaining = $lastWeekOfISOYear - $currentISOWeek;
1598                                 $timeRemainingInWeek =
1599                                         ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400
1600                                         + $timeRemainingInDay;
1601                                 $possibleTtls[] = $weeksRemaining * 604800 + $timeRemainingInWeek;
1602                         }
1603
1604                         if ( $usedMonth ) {
1605                                 $possibleTtls[] =
1606                                         ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 't' ) -
1607                                                 substr( $ts, 6, 2 ) ) * 86400
1608                                         + $timeRemainingInDay;
1609                         } elseif ( $usedYear ) {
1610                                 $possibleTtls[] =
1611                                         ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 -
1612                                                 Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1613                                         + $timeRemainingInDay;
1614                         } elseif ( $usedIsLeapYear ) {
1615                                 $year = substr( $ts, 0, 4 );
1616                                 $timeRemainingInYear =
1617                                         ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 -
1618                                                 Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1619                                         + $timeRemainingInDay;
1620                                 $mod = $year % 4;
1621                                 if ( $mod || ( !( $year % 100 ) && $year % 400 ) ) {
1622                                         // this isn't a leap year. see when the next one starts
1623                                         $nextCandidate = $year - $mod + 4;
1624                                         if ( $nextCandidate % 100 || !( $nextCandidate % 400 ) ) {
1625                                                 $possibleTtls[] = ( $nextCandidate - $year - 1 ) * 365 * 86400 +
1626                                                         $timeRemainingInYear;
1627                                         } else {
1628                                                 $possibleTtls[] = ( $nextCandidate - $year + 3 ) * 365 * 86400 +
1629                                                         $timeRemainingInYear;
1630                                         }
1631                                 } else {
1632                                         // this is a leap year, so the next year isn't
1633                                         $possibleTtls[] = $timeRemainingInYear;
1634                                 }
1635                         }
1636
1637                         if ( $possibleTtls ) {
1638                                 $ttl = min( $possibleTtls );
1639                         }
1640                 }
1641
1642                 return $s;
1643         }
1644
1645         private static $GREG_DAYS = array( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
1646         private static $IRANIAN_DAYS = array( 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29 );
1647
1648         /**
1649          * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1650          * Gregorian dates to Iranian dates. Originally written in C, it
1651          * is released under the terms of GNU Lesser General Public
1652          * License. Conversion to PHP was performed by Niklas Laxström.
1653          *
1654          * Link: http://www.farsiweb.info/jalali/jalali.c
1655          *
1656          * @param string $ts
1657          *
1658          * @return string
1659          */
1660         private static function tsToIranian( $ts ) {
1661                 $gy = substr( $ts, 0, 4 ) -1600;
1662                 $gm = substr( $ts, 4, 2 ) -1;
1663                 $gd = substr( $ts, 6, 2 ) -1;
1664
1665                 # Days passed from the beginning (including leap years)
1666                 $gDayNo = 365 * $gy
1667                         + floor( ( $gy + 3 ) / 4 )
1668                         - floor( ( $gy + 99 ) / 100 )
1669                         + floor( ( $gy + 399 ) / 400 );
1670
1671                 // Add days of the past months of this year
1672                 for ( $i = 0; $i < $gm; $i++ ) {
1673                         $gDayNo += self::$GREG_DAYS[$i];
1674                 }
1675
1676                 // Leap years
1677                 if ( $gm > 1 && ( ( $gy % 4 === 0 && $gy % 100 !== 0 || ( $gy % 400 == 0 ) ) ) ) {
1678                         $gDayNo++;
1679                 }
1680
1681                 // Days passed in current month
1682                 $gDayNo += (int)$gd;
1683
1684                 $jDayNo = $gDayNo - 79;
1685
1686                 $jNp = floor( $jDayNo / 12053 );
1687                 $jDayNo %= 12053;
1688
1689                 $jy = 979 + 33 * $jNp + 4 * floor( $jDayNo / 1461 );
1690                 $jDayNo %= 1461;
1691
1692                 if ( $jDayNo >= 366 ) {
1693                         $jy += floor( ( $jDayNo - 1 ) / 365 );
1694                         $jDayNo = floor( ( $jDayNo - 1 ) % 365 );
1695                 }
1696
1697                 for ( $i = 0; $i < 11 && $jDayNo >= self::$IRANIAN_DAYS[$i]; $i++ ) {
1698                         $jDayNo -= self::$IRANIAN_DAYS[$i];
1699                 }
1700
1701                 $jm = $i + 1;
1702                 $jd = $jDayNo + 1;
1703
1704                 return array( $jy, $jm, $jd );
1705         }
1706
1707         /**
1708          * Converting Gregorian dates to Hijri dates.
1709          *
1710          * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1711          *
1712          * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1713          *
1714          * @param string $ts
1715          *
1716          * @return string
1717          */
1718         private static function tsToHijri( $ts ) {
1719                 $year = substr( $ts, 0, 4 );
1720                 $month = substr( $ts, 4, 2 );
1721                 $day = substr( $ts, 6, 2 );
1722
1723                 $zyr = $year;
1724                 $zd = $day;
1725                 $zm = $month;
1726                 $zy = $zyr;
1727
1728                 if (
1729                         ( $zy > 1582 ) || ( ( $zy == 1582 ) && ( $zm > 10 ) ) ||
1730                         ( ( $zy == 1582 ) && ( $zm == 10 ) && ( $zd > 14 ) )
1731                 ) {
1732                         $zjd = (int)( ( 1461 * ( $zy + 4800 + (int)( ( $zm - 14 ) / 12 ) ) ) / 4 ) +
1733                                         (int)( ( 367 * ( $zm - 2 - 12 * ( (int)( ( $zm - 14 ) / 12 ) ) ) ) / 12 ) -
1734                                         (int)( ( 3 * (int)( ( ( $zy + 4900 + (int)( ( $zm - 14 ) / 12 ) ) / 100 ) ) ) / 4 ) +
1735                                         $zd - 32075;
1736                 } else {
1737                         $zjd = 367 * $zy - (int)( ( 7 * ( $zy + 5001 + (int)( ( $zm - 9 ) / 7 ) ) ) / 4 ) +
1738                                                                 (int)( ( 275 * $zm ) / 9 ) + $zd + 1729777;
1739                 }
1740
1741                 $zl = $zjd -1948440 + 10632;
1742                 $zn = (int)( ( $zl - 1 ) / 10631 );
1743                 $zl = $zl - 10631 * $zn + 354;
1744                 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) +
1745                         ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1746                 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) -
1747                         ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1748                 $zm = (int)( ( 24 * $zl ) / 709 );
1749                 $zd = $zl - (int)( ( 709 * $zm ) / 24 );
1750                 $zy = 30 * $zn + $zj - 30;
1751
1752                 return array( $zy, $zm, $zd );
1753         }
1754
1755         /**
1756          * Converting Gregorian dates to Hebrew dates.
1757          *
1758          * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1759          * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1760          * to translate the relevant functions into PHP and release them under
1761          * GNU GPL.
1762          *
1763          * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1764          * and Adar II is 14. In a non-leap year, Adar is 6.
1765          *
1766          * @param string $ts
1767          *
1768          * @return string
1769          */
1770         private static function tsToHebrew( $ts ) {
1771                 # Parse date
1772                 $year = substr( $ts, 0, 4 );
1773                 $month = substr( $ts, 4, 2 );
1774                 $day = substr( $ts, 6, 2 );
1775
1776                 # Calculate Hebrew year
1777                 $hebrewYear = $year + 3760;
1778
1779                 # Month number when September = 1, August = 12
1780                 $month += 4;
1781                 if ( $month > 12 ) {
1782                         # Next year
1783                         $month -= 12;
1784                         $year++;
1785                         $hebrewYear++;
1786                 }
1787
1788                 # Calculate day of year from 1 September
1789                 $dayOfYear = $day;
1790                 for ( $i = 1; $i < $month; $i++ ) {
1791                         if ( $i == 6 ) {
1792                                 # February
1793                                 $dayOfYear += 28;
1794                                 # Check if the year is leap
1795                                 if ( $year % 400 == 0 || ( $year % 4 == 0 && $year % 100 > 0 ) ) {
1796                                         $dayOfYear++;
1797                                 }
1798                         } elseif ( $i == 8 || $i == 10 || $i == 1 || $i == 3 ) {
1799                                 $dayOfYear += 30;
1800                         } else {
1801                                 $dayOfYear += 31;
1802                         }
1803                 }
1804
1805                 # Calculate the start of the Hebrew year
1806                 $start = self::hebrewYearStart( $hebrewYear );
1807
1808                 # Calculate next year's start
1809                 if ( $dayOfYear <= $start ) {
1810                         # Day is before the start of the year - it is the previous year
1811                         # Next year's start
1812                         $nextStart = $start;
1813                         # Previous year
1814                         $year--;
1815                         $hebrewYear--;
1816                         # Add days since previous year's 1 September
1817                         $dayOfYear += 365;
1818                         if ( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
1819                                 # Leap year
1820                                 $dayOfYear++;
1821                         }
1822                         # Start of the new (previous) year
1823                         $start = self::hebrewYearStart( $hebrewYear );
1824                 } else {
1825                         # Next year's start
1826                         $nextStart = self::hebrewYearStart( $hebrewYear + 1 );
1827                 }
1828
1829                 # Calculate Hebrew day of year
1830                 $hebrewDayOfYear = $dayOfYear - $start;
1831
1832                 # Difference between year's days
1833                 $diff = $nextStart - $start;
1834                 # Add 12 (or 13 for leap years) days to ignore the difference between
1835                 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1836                 # difference is only about the year type
1837                 if ( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
1838                         $diff += 13;
1839                 } else {
1840                         $diff += 12;
1841                 }
1842
1843                 # Check the year pattern, and is leap year
1844                 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1845                 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1846                 # and non-leap years
1847                 $yearPattern = $diff % 30;
1848                 # Check if leap year
1849                 $isLeap = $diff >= 30;
1850
1851                 # Calculate day in the month from number of day in the Hebrew year
1852                 # Don't check Adar - if the day is not in Adar, we will stop before;
1853                 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1854                 $hebrewDay = $hebrewDayOfYear;
1855                 $hebrewMonth = 1;
1856                 $days = 0;
1857                 while ( $hebrewMonth <= 12 ) {
1858                         # Calculate days in this month
1859                         if ( $isLeap && $hebrewMonth == 6 ) {
1860                                 # Adar in a leap year
1861                                 if ( $isLeap ) {
1862                                         # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1863                                         $days = 30;
1864                                         if ( $hebrewDay <= $days ) {
1865                                                 # Day in Adar I
1866                                                 $hebrewMonth = 13;
1867                                         } else {
1868                                                 # Subtract the days of Adar I
1869                                                 $hebrewDay -= $days;
1870                                                 # Try Adar II
1871                                                 $days = 29;
1872                                                 if ( $hebrewDay <= $days ) {
1873                                                         # Day in Adar II
1874                                                         $hebrewMonth = 14;
1875                                                 }
1876                                         }
1877                                 }
1878                         } elseif ( $hebrewMonth == 2 && $yearPattern == 2 ) {
1879                                 # Cheshvan in a complete year (otherwise as the rule below)
1880                                 $days = 30;
1881                         } elseif ( $hebrewMonth == 3 && $yearPattern == 0 ) {
1882                                 # Kislev in an incomplete year (otherwise as the rule below)
1883                                 $days = 29;
1884                         } else {
1885                                 # Odd months have 30 days, even have 29
1886                                 $days = 30 - ( $hebrewMonth - 1 ) % 2;
1887                         }
1888                         if ( $hebrewDay <= $days ) {
1889                                 # In the current month
1890                                 break;
1891                         } else {
1892                                 # Subtract the days of the current month
1893                                 $hebrewDay -= $days;
1894                                 # Try in the next month
1895                                 $hebrewMonth++;
1896                         }
1897                 }
1898
1899                 return array( $hebrewYear, $hebrewMonth, $hebrewDay, $days );
1900         }
1901
1902         /**
1903          * This calculates the Hebrew year start, as days since 1 September.
1904          * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1905          * Used for Hebrew date.
1906          *
1907          * @param int $year
1908          *
1909          * @return string
1910          */
1911         private static function hebrewYearStart( $year ) {
1912                 $a = intval( ( 12 * ( $year - 1 ) + 17 ) % 19 );
1913                 $b = intval( ( $year - 1 ) % 4 );
1914                 $m = 32.044093161144 + 1.5542417966212 * $a + $b / 4.0 - 0.0031777940220923 * ( $year - 1 );
1915                 if ( $m < 0 ) {
1916                         $m--;
1917                 }
1918                 $Mar = intval( $m );
1919                 if ( $m < 0 ) {
1920                         $m++;
1921                 }
1922                 $m -= $Mar;
1923
1924                 $c = intval( ( $Mar + 3 * ( $year - 1 ) + 5 * $b + 5 ) % 7 );
1925                 if ( $c == 0 && $a > 11 && $m >= 0.89772376543210 ) {
1926                         $Mar++;
1927                 } elseif ( $c == 1 && $a > 6 && $m >= 0.63287037037037 ) {
1928                         $Mar += 2;
1929                 } elseif ( $c == 2 || $c == 4 || $c == 6 ) {
1930                         $Mar++;
1931                 }
1932
1933                 $Mar += intval( ( $year - 3761 ) / 100 ) - intval( ( $year - 3761 ) / 400 ) - 24;
1934                 return $Mar;
1935         }
1936
1937         /**
1938          * Algorithm to convert Gregorian dates to Thai solar dates,
1939          * Minguo dates or Minguo dates.
1940          *
1941          * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1942          *       http://en.wikipedia.org/wiki/Minguo_calendar
1943          *       http://en.wikipedia.org/wiki/Japanese_era_name
1944          *
1945          * @param string $ts 14-character timestamp
1946          * @param string $cName Calender name
1947          * @return array Converted year, month, day
1948          */
1949         private static function tsToYear( $ts, $cName ) {
1950                 $gy = substr( $ts, 0, 4 );
1951                 $gm = substr( $ts, 4, 2 );
1952                 $gd = substr( $ts, 6, 2 );
1953
1954                 if ( !strcmp( $cName, 'thai' ) ) {
1955                         # Thai solar dates
1956                         # Add 543 years to the Gregorian calendar
1957                         # Months and days are identical
1958                         $gy_offset = $gy + 543;
1959                 } elseif ( ( !strcmp( $cName, 'minguo' ) ) || !strcmp( $cName, 'juche' ) ) {
1960                         # Minguo dates
1961                         # Deduct 1911 years from the Gregorian calendar
1962                         # Months and days are identical
1963                         $gy_offset = $gy - 1911;
1964                 } elseif ( !strcmp( $cName, 'tenno' ) ) {
1965                         # Nengō dates up to Meiji period
1966                         # Deduct years from the Gregorian calendar
1967                         # depending on the nengo periods
1968                         # Months and days are identical
1969                         if ( ( $gy < 1912 )
1970                                 || ( ( $gy == 1912 ) && ( $gm < 7 ) )
1971                                 || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) )
1972                         ) {
1973                                 # Meiji period
1974                                 $gy_gannen = $gy - 1868 + 1;
1975                                 $gy_offset = $gy_gannen;
1976                                 if ( $gy_gannen == 1 ) {
1977                                         $gy_offset = '元';
1978                                 }
1979                                 $gy_offset = '明治' . $gy_offset;
1980                         } elseif (
1981                                 ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd == 31 ) ) ||
1982                                 ( ( $gy == 1912 ) && ( $gm >= 8 ) ) ||
1983                                 ( ( $gy > 1912 ) && ( $gy < 1926 ) ) ||
1984                                 ( ( $gy == 1926 ) && ( $gm < 12 ) ) ||
1985                                 ( ( $gy == 1926 ) && ( $gm == 12 ) && ( $gd < 26 ) )
1986                         ) {
1987                                 # Taishō period
1988                                 $gy_gannen = $gy - 1912 + 1;
1989                                 $gy_offset = $gy_gannen;
1990                                 if ( $gy_gannen == 1 ) {
1991                                         $gy_offset = '元';
1992                                 }
1993                                 $gy_offset = '大正' . $gy_offset;
1994                         } elseif (
1995                                 ( ( $gy == 1926 ) && ( $gm == 12 ) && ( $gd >= 26 ) ) ||
1996                                 ( ( $gy > 1926 ) && ( $gy < 1989 ) ) ||
1997                                 ( ( $gy == 1989 ) && ( $gm == 1 ) && ( $gd < 8 ) )
1998                         ) {
1999                                 # Shōwa period
2000                                 $gy_gannen = $gy - 1926 + 1;
2001                                 $gy_offset = $gy_gannen;
2002                                 if ( $gy_gannen == 1 ) {
2003                                         $gy_offset = '元';
2004                                 }
2005                                 $gy_offset = '昭和' . $gy_offset;
2006                         } else {
2007                                 # Heisei period
2008                                 $gy_gannen = $gy - 1989 + 1;
2009                                 $gy_offset = $gy_gannen;
2010                                 if ( $gy_gannen == 1 ) {
2011                                         $gy_offset = '元';
2012                                 }
2013                                 $gy_offset = '平成' . $gy_offset;
2014                         }
2015                 } else {
2016                         $gy_offset = $gy;
2017                 }
2018
2019                 return array( $gy_offset, $gm, $gd );
2020         }
2021
2022         /**
2023          * Gets directionality of the first strongly directional codepoint, for embedBidi()
2024          *
2025          * This is the rule the BIDI algorithm uses to determine the directionality of
2026          * paragraphs ( http://unicode.org/reports/tr9/#The_Paragraph_Level ) and
2027          * FSI isolates ( http://unicode.org/reports/tr9/#Explicit_Directional_Isolates ).
2028          *
2029          * TODO: Does not handle BIDI control characters inside the text.
2030          * TODO: Does not handle unallocated characters.
2031          *
2032          * @param string $text Text to test
2033          * @return null|string Directionality ('ltr' or 'rtl') or null
2034          */
2035         private static function strongDirFromContent( $text = '' ) {
2036                 if ( !preg_match( self::$strongDirRegex, $text, $matches ) ) {
2037                         return null;
2038                 }
2039                 if ( $matches[1] === '' ) {
2040                         return 'rtl';
2041                 }
2042                 return 'ltr';
2043         }
2044
2045         /**
2046          * Roman number formatting up to 10000
2047          *
2048          * @param int $num
2049          *
2050          * @return string
2051          */
2052         static function romanNumeral( $num ) {
2053                 static $table = array(
2054                         array( '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X' ),
2055                         array( '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', 'C' ),
2056                         array( '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', 'M' ),
2057                         array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM',
2058                                 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
2059                 );
2060
2061                 $num = intval( $num );
2062                 if ( $num > 10000 || $num <= 0 ) {
2063                         return $num;
2064                 }
2065
2066                 $s = '';
2067                 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
2068                         if ( $num >= $pow10 ) {
2069                                 $s .= $table[$i][(int)floor( $num / $pow10 )];
2070                         }
2071                         $num = $num % $pow10;
2072                 }
2073                 return $s;
2074         }
2075
2076         /**
2077          * Hebrew Gematria number formatting up to 9999
2078          *
2079          * @param int $num
2080          *
2081          * @return string
2082          */
2083         static function hebrewNumeral( $num ) {
2084                 static $table = array(
2085                         array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' ),
2086                         array( '', 'י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ', 'ק' ),
2087                         array( '',
2088                                 array( 'ק' ),
2089                                 array( 'ר' ),
2090                                 array( 'ש' ),
2091                                 array( 'ת' ),
2092                                 array( 'ת', 'ק' ),
2093                                 array( 'ת', 'ר' ),
2094                                 array( 'ת', 'ש' ),
2095                                 array( 'ת', 'ת' ),
2096                                 array( 'ת', 'ת', 'ק' ),
2097                                 array( 'ת', 'ת', 'ר' ),
2098                         ),
2099                         array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' )
2100                 );
2101
2102                 $num = intval( $num );
2103                 if ( $num > 9999 || $num <= 0 ) {
2104                         return $num;
2105                 }
2106
2107                 // Round thousands have special notations
2108                 if ( $num === 1000 ) {
2109                         return "א' אלף";
2110                 } elseif ( $num % 1000 === 0 ) {
2111                         return $table[0][$num / 1000] . "' אלפים";
2112                 }
2113
2114                 $letters = array();
2115
2116                 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
2117                         if ( $num >= $pow10 ) {
2118                                 if ( $num === 15 || $num === 16 ) {
2119                                         $letters[] = $table[0][9];
2120                                         $letters[] = $table[0][$num - 9];
2121                                         $num = 0;
2122                                 } else {
2123                                         $letters = array_merge(
2124                                                 $letters,
2125                                                 (array)$table[$i][intval( $num / $pow10 )]
2126                                         );
2127
2128                                         if ( $pow10 === 1000 ) {
2129                                                 $letters[] = "'";
2130                                         }
2131                                 }
2132                         }
2133
2134                         $num = $num % $pow10;
2135                 }
2136
2137                 $preTransformLength = count( $letters );
2138                 if ( $preTransformLength === 1 ) {
2139                         // Add geresh (single quote) to one-letter numbers
2140                         $letters[] = "'";
2141                 } else {
2142                         $lastIndex = $preTransformLength - 1;
2143                         $letters[$lastIndex] = str_replace(
2144                                 array( 'כ', 'מ', 'נ', 'פ', 'צ' ),
2145                                 array( 'ך', 'ם', 'ן', 'ף', 'ץ' ),
2146                                 $letters[$lastIndex]
2147                         );
2148
2149                         // Add gershayim (double quote) to multiple-letter numbers,
2150                         // but exclude numbers with only one letter after the thousands
2151                         // (1001-1009, 1020, 1030, 2001-2009, etc.)
2152                         if ( $letters[1] === "'" && $preTransformLength === 3 ) {
2153                                 $letters[] = "'";
2154                         } else {
2155                                 array_splice( $letters, -1, 0, '"' );
2156                         }
2157                 }
2158
2159                 return implode( $letters );
2160         }
2161
2162         /**
2163          * Used by date() and time() to adjust the time output.
2164          *
2165          * @param string $ts The time in date('YmdHis') format
2166          * @param mixed $tz Adjust the time by this amount (default false, mean we
2167          *   get user timecorrection setting)
2168          * @return int
2169          */
2170         function userAdjust( $ts, $tz = false ) {
2171                 global $wgUser, $wgLocalTZoffset;
2172
2173                 if ( $tz === false ) {
2174                         $tz = $wgUser->getOption( 'timecorrection' );
2175                 }
2176
2177                 $data = explode( '|', $tz, 3 );
2178
2179                 if ( $data[0] == 'ZoneInfo' ) {
2180                         MediaWiki\suppressWarnings();
2181                         $userTZ = timezone_open( $data[2] );
2182                         MediaWiki\restoreWarnings();
2183                         if ( $userTZ !== false ) {
2184                                 $date = date_create( $ts, timezone_open( 'UTC' ) );
2185                                 date_timezone_set( $date, $userTZ );
2186                                 $date = date_format( $date, 'YmdHis' );
2187                                 return $date;
2188                         }
2189                         # Unrecognized timezone, default to 'Offset' with the stored offset.
2190                         $data[0] = 'Offset';
2191                 }
2192
2193                 if ( $data[0] == 'System' || $tz == '' ) {
2194                         # Global offset in minutes.
2195                         $minDiff = $wgLocalTZoffset;
2196                 } elseif ( $data[0] == 'Offset' ) {
2197                         $minDiff = intval( $data[1] );
2198                 } else {
2199                         $data = explode( ':', $tz );
2200                         if ( count( $data ) == 2 ) {
2201                                 $data[0] = intval( $data[0] );
2202                                 $data[1] = intval( $data[1] );
2203                                 $minDiff = abs( $data[0] ) * 60 + $data[1];
2204                                 if ( $data[0] < 0 ) {
2205                                         $minDiff = -$minDiff;
2206                                 }
2207                         } else {
2208                                 $minDiff = intval( $data[0] ) * 60;
2209                         }
2210                 }
2211
2212                 # No difference ? Return time unchanged
2213                 if ( 0 == $minDiff ) {
2214                         return $ts;
2215                 }
2216
2217                 MediaWiki\suppressWarnings(); // E_STRICT system time bitching
2218                 # Generate an adjusted date; take advantage of the fact that mktime
2219                 # will normalize out-of-range values so we don't have to split $minDiff
2220                 # into hours and minutes.
2221                 $t = mktime( (
2222                         (int)substr( $ts, 8, 2 ) ), # Hours
2223                         (int)substr( $ts, 10, 2 ) + $minDiff, # Minutes
2224                         (int)substr( $ts, 12, 2 ), # Seconds
2225                         (int)substr( $ts, 4, 2 ), # Month
2226                         (int)substr( $ts, 6, 2 ), # Day
2227                         (int)substr( $ts, 0, 4 ) ); # Year
2228
2229                 $date = date( 'YmdHis', $t );
2230                 MediaWiki\restoreWarnings();
2231
2232                 return $date;
2233         }
2234
2235         /**
2236          * This is meant to be used by time(), date(), and timeanddate() to get
2237          * the date preference they're supposed to use, it should be used in
2238          * all children.
2239          *
2240          *<code>
2241          * function timeanddate([...], $format = true) {
2242          *      $datePreference = $this->dateFormat($format);
2243          * [...]
2244          * }
2245          *</code>
2246          *
2247          * @param int|string|bool $usePrefs If true, the user's preference is used
2248          *   if false, the site/language default is used
2249          *   if int/string, assumed to be a format.
2250          * @return string
2251          */
2252         function dateFormat( $usePrefs = true ) {
2253                 global $wgUser;
2254
2255                 if ( is_bool( $usePrefs ) ) {
2256                         if ( $usePrefs ) {
2257                                 $datePreference = $wgUser->getDatePreference();
2258                         } else {
2259                                 $datePreference = (string)User::getDefaultOption( 'date' );
2260                         }
2261                 } else {
2262                         $datePreference = (string)$usePrefs;
2263                 }
2264
2265                 // return int
2266                 if ( $datePreference == '' ) {
2267                         return 'default';
2268                 }
2269
2270                 return $datePreference;
2271         }
2272
2273         /**
2274          * Get a format string for a given type and preference
2275          * @param string $type May be 'date', 'time', 'both', or 'pretty'.
2276          * @param string $pref The format name as it appears in Messages*.php under
2277          *  $datePreferences.
2278          *
2279          * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2280          *
2281          * @return string
2282          */
2283         function getDateFormatString( $type, $pref ) {
2284                 $wasDefault = false;
2285                 if ( $pref == 'default' ) {
2286                         $wasDefault = true;
2287                         $pref = $this->getDefaultDateFormat();
2288                 }
2289
2290                 if ( !isset( $this->dateFormatStrings[$type][$pref] ) ) {
2291                         $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
2292
2293                         if ( $type === 'pretty' && $df === null ) {
2294                                 $df = $this->getDateFormatString( 'date', $pref );
2295                         }
2296
2297                         if ( !$wasDefault && $df === null ) {
2298                                 $pref = $this->getDefaultDateFormat();
2299                                 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
2300                         }
2301
2302                         $this->dateFormatStrings[$type][$pref] = $df;
2303                 }
2304                 return $this->dateFormatStrings[$type][$pref];
2305         }
2306
2307         /**
2308          * @param string $ts The time format which needs to be turned into a
2309          *   date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2310          * @param bool $adj Whether to adjust the time output according to the
2311          *   user configured offset ($timecorrection)
2312          * @param mixed $format True to use user's date format preference
2313          * @param string|bool $timecorrection The time offset as returned by
2314          *   validateTimeZone() in Special:Preferences
2315          * @return string
2316          */
2317         function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
2318                 $ts = wfTimestamp( TS_MW, $ts );
2319                 if ( $adj ) {
2320                         $ts = $this->userAdjust( $ts, $timecorrection );
2321                 }
2322                 $df = $this->getDateFormatString( 'date', $this->dateFormat( $format ) );
2323                 return $this->sprintfDate( $df, $ts );
2324         }
2325
2326         /**
2327          * @param string $ts The time format which needs to be turned into a
2328          *   date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2329          * @param bool $adj Whether to adjust the time output according to the
2330          *   user configured offset ($timecorrection)
2331          * @param mixed $format True to use user's date format preference
2332          * @param string|bool $timecorrection The time offset as returned by
2333          *   validateTimeZone() in Special:Preferences
2334          * @return string
2335          */
2336         function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
2337                 $ts = wfTimestamp( TS_MW, $ts );
2338                 if ( $adj ) {
2339                         $ts = $this->userAdjust( $ts, $timecorrection );
2340                 }
2341                 $df = $this->getDateFormatString( 'time', $this->dateFormat( $format ) );
2342                 return $this->sprintfDate( $df, $ts );
2343         }
2344
2345         /**
2346          * @param string $ts The time format which needs to be turned into a
2347          *   date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2348          * @param bool $adj Whether to adjust the time output according to the
2349          *   user configured offset ($timecorrection)
2350          * @param mixed $format What format to return, if it's false output the
2351          *   default one (default true)
2352          * @param string|bool $timecorrection The time offset as returned by
2353          *   validateTimeZone() in Special:Preferences
2354          * @return string
2355          */
2356         function timeanddate( $ts, $adj = false, $format = true, $timecorrection = false ) {
2357                 $ts = wfTimestamp( TS_MW, $ts );
2358                 if ( $adj ) {
2359                         $ts = $this->userAdjust( $ts, $timecorrection );
2360                 }
2361                 $df = $this->getDateFormatString( 'both', $this->dateFormat( $format ) );
2362                 return $this->sprintfDate( $df, $ts );
2363         }
2364
2365         /**
2366          * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2367          *
2368          * @since 1.20
2369          *
2370          * @param int $seconds The amount of seconds.
2371          * @param array $chosenIntervals The intervals to enable.
2372          *
2373          * @return string
2374          */
2375         public function formatDuration( $seconds, array $chosenIntervals = array() ) {
2376                 $intervals = $this->getDurationIntervals( $seconds, $chosenIntervals );
2377
2378                 $segments = array();
2379
2380                 foreach ( $intervals as $intervalName => $intervalValue ) {
2381                         // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2382                         // duration-years, duration-decades, duration-centuries, duration-millennia
2383                         $message = wfMessage( 'duration-' . $intervalName )->numParams( $intervalValue );
2384                         $segments[] = $message->inLanguage( $this )->escaped();
2385                 }
2386
2387                 return $this->listToText( $segments );
2388         }
2389
2390         /**
2391          * Takes a number of seconds and returns an array with a set of corresponding intervals.
2392          * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2393          *
2394          * @since 1.20
2395          *
2396          * @param int $seconds The amount of seconds.
2397          * @param array $chosenIntervals The intervals to enable.
2398          *
2399          * @return array
2400          */
2401         public function getDurationIntervals( $seconds, array $chosenIntervals = array() ) {
2402                 if ( empty( $chosenIntervals ) ) {
2403                         $chosenIntervals = array(
2404                                 'millennia',
2405                                 'centuries',
2406                                 'decades',
2407                                 'years',
2408                                 'days',
2409                                 'hours',
2410                                 'minutes',
2411                                 'seconds'
2412                         );
2413                 }
2414
2415                 $intervals = array_intersect_key( self::$durationIntervals, array_flip( $chosenIntervals ) );
2416                 $sortedNames = array_keys( $intervals );
2417                 $smallestInterval = array_pop( $sortedNames );
2418
2419                 $segments = array();
2420
2421                 foreach ( $intervals as $name => $length ) {
2422                         $value = floor( $seconds / $length );
2423
2424                         if ( $value > 0 || ( $name == $smallestInterval && empty( $segments ) ) ) {
2425                                 $seconds -= $value * $length;
2426                                 $segments[$name] = $value;
2427                         }
2428                 }
2429
2430                 return $segments;
2431         }
2432
2433         /**
2434          * Internal helper function for userDate(), userTime() and userTimeAndDate()
2435          *
2436          * @param string $type Can be 'date', 'time' or 'both'
2437          * @param string $ts The time format which needs to be turned into a
2438          *   date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2439          * @param User $user User object used to get preferences for timezone and format
2440          * @param array $options Array, can contain the following keys:
2441          *   - 'timecorrection': time correction, can have the following values:
2442          *     - true: use user's preference
2443          *     - false: don't use time correction
2444          *     - int: value of time correction in minutes
2445          *   - 'format': format to use, can have the following values:
2446          *     - true: use user's preference
2447          *     - false: use default preference
2448          *     - string: format to use
2449          * @since 1.19
2450          * @return string
2451          */
2452         private function internalUserTimeAndDate( $type, $ts, User $user, array $options ) {
2453                 $ts = wfTimestamp( TS_MW, $ts );
2454                 $options += array( 'timecorrection' => true, 'format' => true );
2455                 if ( $options['timecorrection'] !== false ) {
2456                         if ( $options['timecorrection'] === true ) {
2457                                 $offset = $user->getOption( 'timecorrection' );
2458                         } else {
2459                                 $offset = $options['timecorrection'];
2460                         }
2461                         $ts = $this->userAdjust( $ts, $offset );
2462                 }
2463                 if ( $options['format'] === true ) {
2464                         $format = $user->getDatePreference();
2465                 } else {
2466                         $format = $options['format'];
2467                 }
2468                 $df = $this->getDateFormatString( $type, $this->dateFormat( $format ) );
2469                 return $this->sprintfDate( $df, $ts );
2470         }
2471
2472         /**
2473          * Get the formatted date for the given timestamp and formatted for
2474          * the given user.
2475          *
2476          * @param mixed $ts Mixed: the time format which needs to be turned into a
2477          *   date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2478          * @param User $user User object used to get preferences for timezone and format
2479          * @param array $options Array, can contain the following keys:
2480          *   - 'timecorrection': time correction, can have the following values:
2481          *     - true: use user's preference
2482          *     - false: don't use time correction
2483          *     - int: value of time correction in minutes
2484          *   - 'format': format to use, can have the following values:
2485          *     - true: use user's preference
2486          *     - false: use default preference
2487          *     - string: format to use
2488          * @since 1.19
2489          * @return string
2490          */
2491         public function userDate( $ts, User $user, array $options = array() ) {
2492                 return $this->internalUserTimeAndDate( 'date', $ts, $user, $options );
2493         }
2494
2495         /**
2496          * Get the formatted time for the given timestamp and formatted for
2497          * the given user.
2498          *
2499          * @param mixed $ts The time format which needs to be turned into a
2500          *   date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2501          * @param User $user User object used to get preferences for timezone and format
2502          * @param array $options Array, can contain the following keys:
2503          *   - 'timecorrection': time correction, can have the following values:
2504          *     - true: use user's preference
2505          *     - false: don't use time correction
2506          *     - int: value of time correction in minutes
2507          *   - 'format': format to use, can have the following values:
2508          *     - true: use user's preference
2509          *     - false: use default preference
2510          *     - string: format to use
2511          * @since 1.19
2512          * @return string
2513          */
2514         public function userTime( $ts, User $user, array $options = array() ) {
2515                 return $this->internalUserTimeAndDate( 'time', $ts, $user, $options );
2516         }
2517
2518         /**
2519          * Get the formatted date and time for the given timestamp and formatted for
2520          * the given user.
2521          *
2522          * @param mixed $ts The time format which needs to be turned into a
2523          *   date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2524          * @param User $user User object used to get preferences for timezone and format
2525          * @param array $options Array, can contain the following keys:
2526          *   - 'timecorrection': time correction, can have the following values:
2527          *     - true: use user's preference
2528          *     - false: don't use time correction
2529          *     - int: value of time correction in minutes
2530          *   - 'format': format to use, can have the following values:
2531          *     - true: use user's preference
2532          *     - false: use default preference
2533          *     - string: format to use
2534          * @since 1.19
2535          * @return string
2536          */
2537         public function userTimeAndDate( $ts, User $user, array $options = array() ) {
2538                 return $this->internalUserTimeAndDate( 'both', $ts, $user, $options );
2539         }
2540
2541         /**
2542          * Get the timestamp in a human-friendly relative format, e.g., "3 days ago".
2543          *
2544          * Determine the difference between the timestamp and the current time, and
2545          * generate a readable timestamp by returning "<N> <units> ago", where the
2546          * largest possible unit is used.
2547          *
2548          * @since 1.26 (Prior to 1.26 method existed but was not meant to be used directly)
2549          *
2550          * @param MWTimestamp $time
2551          * @param MWTimestamp|null $relativeTo The base timestamp to compare to (defaults to now)
2552          * @param User|null $user User the timestamp is being generated for (or null to use main context's user)
2553          * @return string Formatted timestamp
2554          */
2555         public function getHumanTimestamp( MWTimestamp $time, MWTimestamp $relativeTo = null, User $user = null ) {
2556                 if ( $relativeTo === null ) {
2557                         $relativeTo = new MWTimestamp();
2558                 }
2559                 if ( $user === null ) {
2560                         $user = RequestContext::getMain()->getUser();
2561                 }
2562
2563                 // Adjust for the user's timezone.
2564                 $offsetThis = $time->offsetForUser( $user );
2565                 $offsetRel = $relativeTo->offsetForUser( $user );
2566
2567                 $ts = '';
2568                 if ( Hooks::run( 'GetHumanTimestamp', array( &$ts, $time, $relativeTo, $user, $this ) ) ) {
2569                         $ts = $this->getHumanTimestampInternal( $time, $relativeTo, $user );
2570                 }
2571
2572                 // Reset the timezone on the objects.
2573                 $time->timestamp->sub( $offsetThis );
2574                 $relativeTo->timestamp->sub( $offsetRel );
2575
2576                 return $ts;
2577         }
2578
2579         /**
2580          * Convert an MWTimestamp into a pretty human-readable timestamp using
2581          * the given user preferences and relative base time.
2582          *
2583          * @see Language::getHumanTimestamp
2584          * @param MWTimestamp $ts Timestamp to prettify
2585          * @param MWTimestamp $relativeTo Base timestamp
2586          * @param User $user User preferences to use
2587          * @return string Human timestamp
2588          * @since 1.26
2589          */
2590         private function getHumanTimestampInternal( MWTimestamp $ts, MWTimestamp $relativeTo, User $user ) {
2591                 $diff = $ts->diff( $relativeTo );
2592                 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) -
2593                         (int)$relativeTo->timestamp->format( 'w' ) );
2594                 $days = $diff->days ?: (int)$diffDay;
2595                 if ( $diff->invert || $days > 5
2596                         && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' )
2597                 ) {
2598                         // Timestamps are in different years: use full timestamp
2599                         // Also do full timestamp for future dates
2600                         /**
2601                          * @todo FIXME: Add better handling of future timestamps.
2602                          */
2603                         $format = $this->getDateFormatString( 'both', $user->getDatePreference() ?: 'default' );
2604                         $ts = $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) );
2605                 } elseif ( $days > 5 ) {
2606                         // Timestamps are in same year,  but more than 5 days ago: show day and month only.
2607                         $format = $this->getDateFormatString( 'pretty', $user->getDatePreference() ?: 'default' );
2608                         $ts = $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) );
2609                 } elseif ( $days > 1 ) {
2610                         // Timestamp within the past week: show the day of the week and time
2611                         $format = $this->getDateFormatString( 'time', $user->getDatePreference() ?: 'default' );
2612                         $weekday = self::$mWeekdayMsgs[$ts->timestamp->format( 'w' )];
2613                         // Messages:
2614                         // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2615                         $ts = wfMessage( "$weekday-at" )
2616                                 ->inLanguage( $this )
2617                                 ->params( $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) ) )
2618                                 ->text();
2619                 } elseif ( $days == 1 ) {
2620                         // Timestamp was yesterday: say 'yesterday' and the time.
2621                         $format = $this->getDateFormatString( 'time', $user->getDatePreference() ?: 'default' );
2622                         $ts = wfMessage( 'yesterday-at' )
2623                                 ->inLanguage( $this )
2624                                 ->params( $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) ) )
2625                                 ->text();
2626                 } elseif ( $diff->h > 1 || $diff->h == 1 && $diff->i > 30 ) {
2627                         // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2628                         $format = $this->getDateFormatString( 'time', $user->getDatePreference() ?: 'default' );
2629                         $ts = wfMessage( 'today-at' )
2630                                 ->inLanguage( $this )
2631                                 ->params( $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) ) )
2632                                 ->text();
2633
2634                 // From here on in, the timestamp was soon enough ago so that we can simply say
2635                 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2636                 } elseif ( $diff->h == 1 ) {
2637                         // Less than 90 minutes, but more than an hour ago.
2638                         $ts = wfMessage( 'hours-ago' )->inLanguage( $this )->numParams( 1 )->text();
2639                 } elseif ( $diff->i >= 1 ) {
2640                         // A few minutes ago.
2641                         $ts = wfMessage( 'minutes-ago' )->inLanguage( $this )->numParams( $diff->i )->text();
2642                 } elseif ( $diff->s >= 30 ) {
2643                         // Less than a minute, but more than 30 sec ago.
2644                         $ts = wfMessage( 'seconds-ago' )->inLanguage( $this )->numParams( $diff->s )->text();
2645                 } else {
2646                         // Less than 30 seconds ago.
2647                         $ts = wfMessage( 'just-now' )->text();
2648                 }
2649
2650                 return $ts;
2651         }
2652
2653         /**
2654          * @param string $key
2655          * @return array|null
2656          */
2657         function getMessage( $key ) {
2658                 return self::$dataCache->getSubitem( $this->mCode, 'messages', $key );
2659         }
2660
2661         /**
2662          * @return array
2663          */
2664         function getAllMessages() {
2665                 return self::$dataCache->getItem( $this->mCode, 'messages' );
2666         }
2667
2668         /**
2669          * @param string $in
2670          * @param string $out
2671          * @param string $string
2672          * @return string
2673          */
2674         function iconv( $in, $out, $string ) {
2675                 # This is a wrapper for iconv in all languages except esperanto,
2676                 # which does some nasty x-conversions beforehand
2677
2678                 # Even with //IGNORE iconv can whine about illegal characters in
2679                 # *input* string. We just ignore those too.
2680                 # REF: http://bugs.php.net/bug.php?id=37166
2681                 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2682                 MediaWiki\suppressWarnings();
2683                 $text = iconv( $in, $out . '//IGNORE', $string );
2684                 MediaWiki\restoreWarnings();
2685                 return $text;
2686         }
2687
2688         // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2689
2690         /**
2691          * @param array $matches
2692          * @return mixed|string
2693          */
2694         function ucwordbreaksCallbackAscii( $matches ) {
2695                 return $this->ucfirst( $matches[1] );
2696         }
2697
2698         /**
2699          * @param array $matches
2700          * @return string
2701          */
2702         function ucwordbreaksCallbackMB( $matches ) {
2703                 return mb_strtoupper( $matches[0] );
2704         }
2705
2706         /**
2707          * @param array $matches
2708          * @return string
2709          */
2710         function ucCallback( $matches ) {
2711                 list( $wikiUpperChars ) = self::getCaseMaps();
2712                 return strtr( $matches[1], $wikiUpperChars );
2713         }
2714
2715         /**
2716          * @param array $matches
2717          * @return string
2718          */
2719         function lcCallback( $matches ) {
2720                 list( , $wikiLowerChars ) = self::getCaseMaps();
2721                 return strtr( $matches[1], $wikiLowerChars );
2722         }
2723
2724         /**
2725          * @param array $matches
2726          * @return string
2727          */
2728         function ucwordsCallbackMB( $matches ) {
2729                 return mb_strtoupper( $matches[0] );
2730         }
2731
2732         /**
2733          * @param array $matches
2734          * @return string
2735          */
2736         function ucwordsCallbackWiki( $matches ) {
2737                 list( $wikiUpperChars ) = self::getCaseMaps();
2738                 return strtr( $matches[0], $wikiUpperChars );
2739         }
2740
2741         /**
2742          * Make a string's first character uppercase
2743          *
2744          * @param string $str
2745          *
2746          * @return string
2747          */
2748         function ucfirst( $str ) {
2749                 $o = ord( $str );
2750                 if ( $o < 96 ) { // if already uppercase...
2751                         return $str;
2752                 } elseif ( $o < 128 ) {
2753                         return ucfirst( $str ); // use PHP's ucfirst()
2754                 } else {
2755                         // fall back to more complex logic in case of multibyte strings
2756                         return $this->uc( $str, true );
2757                 }
2758         }
2759
2760         /**
2761          * Convert a string to uppercase
2762          *
2763          * @param string $str
2764          * @param bool $first
2765          *
2766          * @return string
2767          */
2768         function uc( $str, $first = false ) {
2769                 if ( function_exists( 'mb_strtoupper' ) ) {
2770                         if ( $first ) {
2771                                 if ( $this->isMultibyte( $str ) ) {
2772                                         return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
2773                                 } else {
2774                                         return ucfirst( $str );
2775                                 }
2776                         } else {
2777                                 return $this->isMultibyte( $str ) ? mb_strtoupper( $str ) : strtoupper( $str );
2778                         }
2779                 } else {
2780                         if ( $this->isMultibyte( $str ) ) {
2781                                 $x = $first ? '^' : '';
2782                                 return preg_replace_callback(
2783                                         "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
2784                                         array( $this, 'ucCallback' ),
2785                                         $str
2786                                 );
2787                         } else {
2788                                 return $first ? ucfirst( $str ) : strtoupper( $str );
2789                         }
2790                 }
2791         }
2792
2793         /**
2794          * @param string $str
2795          * @return mixed|string
2796          */
2797         function lcfirst( $str ) {
2798                 $o = ord( $str );
2799                 if ( !$o ) {
2800                         return strval( $str );
2801                 } elseif ( $o >= 128 ) {
2802                         return $this->lc( $str, true );
2803                 } elseif ( $o > 96 ) {
2804                         return $str;
2805                 } else {
2806                         $str[0] = strtolower( $str[0] );
2807                         return $str;
2808                 }
2809         }
2810
2811         /**
2812          * @param string $str
2813          * @param bool $first
2814          * @return mixed|string
2815          */
2816         function lc( $str, $first = false ) {
2817                 if ( function_exists( 'mb_strtolower' ) ) {
2818                         if ( $first ) {
2819                                 if ( $this->isMultibyte( $str ) ) {
2820                                         return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
2821                                 } else {
2822                                         return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
2823                                 }
2824                         } else {
2825                                 return $this->isMultibyte( $str ) ? mb_strtolower( $str ) : strtolower( $str );
2826                         }
2827                 } else {
2828                         if ( $this->isMultibyte( $str ) ) {
2829                                 $x = $first ? '^' : '';
2830                                 return preg_replace_callback(
2831                                         "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
2832                                         array( $this, 'lcCallback' ),
2833                                         $str
2834                                 );
2835                         } else {
2836                                 return $first ? strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
2837                         }
2838                 }
2839         }
2840
2841         /**
2842          * @param string $str
2843          * @return bool
2844          */
2845         function isMultibyte( $str ) {
2846                 return strlen( $str ) !== mb_strlen( $str );
2847         }
2848
2849         /**
2850          * @param string $str
2851          * @return mixed|string
2852          */
2853         function ucwords( $str ) {
2854                 if ( $this->isMultibyte( $str ) ) {
2855                         $str = $this->lc( $str );
2856
2857                         // regexp to find first letter in each word (i.e. after each space)
2858                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2859
2860                         // function to use to capitalize a single char
2861                         if ( function_exists( 'mb_strtoupper' ) ) {
2862                                 return preg_replace_callback(
2863                                         $replaceRegexp,
2864                                         array( $this, 'ucwordsCallbackMB' ),
2865                                         $str
2866                                 );
2867                         } else {
2868                                 return preg_replace_callback(
2869                                         $replaceRegexp,
2870                                         array( $this, 'ucwordsCallbackWiki' ),
2871                                         $str
2872                                 );
2873                         }
2874                 } else {
2875                         return ucwords( strtolower( $str ) );
2876                 }
2877         }
2878
2879         /**
2880          * capitalize words at word breaks
2881          *
2882          * @param string $str
2883          * @return mixed
2884          */
2885         function ucwordbreaks( $str ) {
2886                 if ( $this->isMultibyte( $str ) ) {
2887                         $str = $this->lc( $str );
2888
2889                         // since \b doesn't work for UTF-8, we explicitely define word break chars
2890                         $breaks = "[ \-\(\)\}\{\.,\?!]";
2891
2892                         // find first letter after word break
2893                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|" .
2894                                 "$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2895
2896                         if ( function_exists( 'mb_strtoupper' ) ) {
2897                                 return preg_replace_callback(
2898                                         $replaceRegexp,
2899                                         array( $this, 'ucwordbreaksCallbackMB' ),
2900                                         $str
2901                                 );
2902                         } else {
2903                                 return preg_replace_callback(
2904                                         $replaceRegexp,
2905                                         array( $this, 'ucwordsCallbackWiki' ),
2906                                         $str
2907                                 );
2908                         }
2909                 } else {
2910                         return preg_replace_callback(
2911                                 '/\b([\w\x80-\xff]+)\b/',
2912                                 array( $this, 'ucwordbreaksCallbackAscii' ),
2913                                 $str
2914                         );
2915                 }
2916         }
2917
2918         /**
2919          * Return a case-folded representation of $s
2920          *
2921          * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2922          * and $s2 are the same except for the case of their characters. It is not
2923          * necessary for the value returned to make sense when displayed.
2924          *
2925          * Do *not* perform any other normalisation in this function. If a caller
2926          * uses this function when it should be using a more general normalisation
2927          * function, then fix the caller.
2928          *
2929          * @param string $s
2930          *
2931          * @return string
2932          */
2933         function caseFold( $s ) {
2934                 return $this->uc( $s );
2935         }
2936
2937         /**
2938          * @param string $s
2939          * @return string
2940          */
2941         function checkTitleEncoding( $s ) {
2942                 if ( is_array( $s ) ) {
2943                         throw new MWException( 'Given array to checkTitleEncoding.' );
2944                 }
2945                 if ( StringUtils::isUtf8( $s ) ) {
2946                         return $s;
2947                 }
2948
2949                 return $this->iconv( $this->fallback8bitEncoding(), 'utf-8', $s );
2950         }
2951
2952         /**
2953          * @return array
2954          */
2955         function fallback8bitEncoding() {
2956                 return self::$dataCache->getItem( $this->mCode, 'fallback8bitEncoding' );
2957         }
2958
2959         /**
2960          * Most writing systems use whitespace to break up words.
2961          * Some languages such as Chinese don't conventionally do this,
2962          * which requires special handling when breaking up words for
2963          * searching etc.
2964          *
2965          * @return bool
2966          */
2967         function hasWordBreaks() {
2968                 return true;
2969         }
2970
2971         /**
2972          * Some languages such as Chinese require word segmentation,
2973          * Specify such segmentation when overridden in derived class.
2974          *
2975          * @param string $string
2976          * @return string
2977          */
2978         function segmentByWord( $string ) {
2979                 return $string;
2980         }
2981
2982         /**
2983          * Some languages have special punctuation need to be normalized.
2984          * Make such changes here.
2985          *
2986          * @param string $string
2987          * @return string
2988          */
2989         function normalizeForSearch( $string ) {
2990                 return self::convertDoubleWidth( $string );
2991         }
2992
2993         /**
2994          * convert double-width roman characters to single-width.
2995          * range: ff00-ff5f ~= 0020-007f
2996          *
2997          * @param string $string
2998          *
2999          * @return string
3000          */
3001         protected static function convertDoubleWidth( $string ) {
3002                 static $full = null;
3003                 static $half = null;
3004
3005                 if ( $full === null ) {
3006                         $fullWidth = "０１２３４５６７８９ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ";
3007                         $halfWidth = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
3008                         $full = str_split( $fullWidth, 3 );
3009                         $half = str_split( $halfWidth );
3010                 }
3011
3012                 $string = str_replace( $full, $half, $string );
3013                 return $string;
3014         }
3015
3016         /**
3017          * @param string $string
3018          * @param string $pattern
3019          * @return string
3020          */
3021         protected static function insertSpace( $string, $pattern ) {
3022                 $string = preg_replace( $pattern, " $1 ", $string );
3023                 $string = preg_replace( '/ +/', ' ', $string );
3024                 return $string;
3025         }
3026
3027         /**
3028          * @param array $termsArray
3029          * @return array
3030          */
3031         function convertForSearchResult( $termsArray ) {
3032                 # some languages, e.g. Chinese, need to do a conversion
3033                 # in order for search results to be displayed correctly
3034                 return $termsArray;
3035         }
3036
3037         /**
3038          * Get the first character of a string.
3039          *
3040          * @param string $s
3041          * @return string
3042          */
3043         function firstChar( $s ) {
3044                 $matches = array();
3045                 preg_match(
3046                         '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
3047                                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/',
3048                         $s,
3049                         $matches
3050                 );
3051
3052                 if ( isset( $matches[1] ) ) {
3053                         if ( strlen( $matches[1] ) != 3 ) {
3054                                 return $matches[1];
3055                         }
3056
3057                         // Break down Hangul syllables to grab the first jamo
3058                         $code = UtfNormal\Utils::utf8ToCodepoint( $matches[1] );
3059                         if ( $code < 0xac00 || 0xd7a4 <= $code ) {
3060                                 return $matches[1];
3061                         } elseif ( $code < 0xb098 ) {
3062                                 return "\xe3\x84\xb1";
3063                         } elseif ( $code < 0xb2e4 ) {
3064                                 return "\xe3\x84\xb4";
3065                         } elseif ( $code < 0xb77c ) {
3066                                 return "\xe3\x84\xb7";
3067                         } elseif ( $code < 0xb9c8 ) {
3068                                 return "\xe3\x84\xb9";
3069                         } elseif ( $code < 0xbc14 ) {
3070                                 return "\xe3\x85\x81";
3071                         } elseif ( $code < 0xc0ac ) {
3072                                 return "\xe3\x85\x82";
3073                         } elseif ( $code < 0xc544 ) {
3074                                 return "\xe3\x85\x85";
3075                         } elseif ( $code < 0xc790 ) {
3076                                 return "\xe3\x85\x87";
3077                         } elseif ( $code < 0xcc28 ) {
3078                                 return "\xe3\x85\x88";
3079                         } elseif ( $code < 0xce74 ) {
3080                                 return "\xe3\x85\x8a";
3081                         } elseif ( $code < 0xd0c0 ) {
3082                                 return "\xe3\x85\x8b";
3083                         } elseif ( $code < 0xd30c ) {
3084                                 return "\xe3\x85\x8c";
3085                         } elseif ( $code < 0xd558 ) {
3086                                 return "\xe3\x85\x8d";
3087                         } else {
3088                                 return "\xe3\x85\x8e";
3089                         }
3090                 } else {
3091                         return '';
3092                 }
3093         }
3094
3095         function initEncoding() {
3096                 # Some languages may have an alternate char encoding option
3097                 # (Esperanto X-coding, Japanese furigana conversion, etc)
3098                 # If this language is used as the primary content language,
3099                 # an override to the defaults can be set here on startup.
3100         }
3101
3102         /**
3103          * @param string $s
3104          * @return string
3105          */
3106         function recodeForEdit( $s ) {
3107                 # For some languages we'll want to explicitly specify
3108                 # which characters make it into the edit box raw
3109                 # or are converted in some way or another.
3110                 global $wgEditEncoding;
3111                 if ( $wgEditEncoding == '' || $wgEditEncoding == 'UTF-8' ) {
3112                         return $s;
3113                 } else {
3114                         return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
3115                 }
3116         }
3117
3118         /**
3119          * @param string $s
3120          * @return string
3121          */
3122         function recodeInput( $s ) {
3123                 # Take the previous into account.
3124                 global $wgEditEncoding;
3125                 if ( $wgEditEncoding != '' ) {
3126                         $enc = $wgEditEncoding;
3127                 } else {
3128                         $enc = 'UTF-8';
3129                 }
3130                 if ( $enc == 'UTF-8' ) {
3131                         return $s;
3132                 } else {
3133                         return $this->iconv( $enc, 'UTF-8', $s );
3134                 }
3135         }
3136
3137         /**
3138          * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
3139          * also cleans up certain backwards-compatible sequences, converting them
3140          * to the modern Unicode equivalent.
3141          *
3142          * This is language-specific for performance reasons only.
3143          *
3144          * @param string $s
3145          *
3146          * @return string
3147          */
3148         function normalize( $s ) {
3149                 global $wgAllUnicodeFixes;
3150                 $s = UtfNormal\Validator::cleanUp( $s );
3151                 if ( $wgAllUnicodeFixes ) {
3152                         $s = $this->transformUsingPairFile( 'normalize-ar.ser', $s );
3153                         $s = $this->transformUsingPairFile( 'normalize-ml.ser', $s );
3154                 }
3155
3156                 return $s;
3157         }
3158
3159         /**
3160          * Transform a string using serialized data stored in the given file (which
3161          * must be in the serialized subdirectory of $IP). The file contains pairs
3162          * mapping source characters to destination characters.
3163          *
3164          * The data is cached in process memory. This will go faster if you have the
3165          * FastStringSearch extension.
3166          *
3167          * @param string $file
3168          * @param string $string
3169          *
3170          * @throws MWException
3171          * @return string
3172          */
3173         function transformUsingPairFile( $file, $string ) {
3174                 if ( !isset( $this->transformData[$file] ) ) {
3175                         $data = wfGetPrecompiledData( $file );
3176                         if ( $data === false ) {
3177                                 throw new MWException( __METHOD__ . ": The transformation file $file is missing" );
3178                         }
3179                         $this->transformData[$file] = new ReplacementArray( $data );
3180                 }
3181                 return $this->transformData[$file]->replace( $string );
3182         }
3183
3184         /**
3185          * For right-to-left language support
3186          *
3187          * @return bool
3188          */
3189         function isRTL() {
3190                 return self::$dataCache->getItem( $this->mCode, 'rtl' );
3191         }
3192
3193         /**
3194          * Return the correct HTML 'dir' attribute value for this language.
3195          * @return string
3196          */
3197         function getDir() {
3198                 return $this->isRTL() ? 'rtl' : 'ltr';
3199         }
3200
3201         /**
3202          * Return 'left' or 'right' as appropriate alignment for line-start
3203          * for this language's text direction.
3204          *
3205          * Should be equivalent to CSS3 'start' text-align value....
3206          *
3207          * @return string
3208          */
3209         function alignStart() {
3210                 return $this->isRTL() ? 'right' : 'left';
3211         }
3212
3213         /**
3214          * Return 'right' or 'left' as appropriate alignment for line-end
3215          * for this language's text direction.
3216          *
3217          * Should be equivalent to CSS3 'end' text-align value....
3218          *
3219          * @return string
3220          */
3221         function alignEnd() {
3222                 return $this->isRTL() ? 'left' : 'right';
3223         }
3224
3225         /**
3226          * A hidden direction mark (LRM or RLM), depending on the language direction.
3227          * Unlike getDirMark(), this function returns the character as an HTML entity.
3228          * This function should be used when the output is guaranteed to be HTML,
3229          * because it makes the output HTML source code more readable. When
3230          * the output is plain text or can be escaped, getDirMark() should be used.
3231          *
3232          * @param bool $opposite Get the direction mark opposite to your language
3233          * @return string
3234          * @since 1.20
3235          */
3236         function getDirMarkEntity( $opposite = false ) {
3237                 if ( $opposite ) {
3238                         return $this->isRTL() ? '&lrm;' : '&rlm;';
3239                 }
3240                 return $this->isRTL() ? '&rlm;' : '&lrm;';
3241         }
3242
3243         /**
3244          * A hidden direction mark (LRM or RLM), depending on the language direction.
3245          * This function produces them as invisible Unicode characters and
3246          * the output may be hard to read and debug, so it should only be used
3247          * when the output is plain text or can be escaped. When the output is
3248          * HTML, use getDirMarkEntity() instead.
3249          *
3250          * @param bool $opposite Get the direction mark opposite to your language
3251          * @return string
3252          */
3253         function getDirMark( $opposite = false ) {
3254                 $lrm = "\xE2\x80\x8E"; # LEFT-TO-RIGHT MARK, commonly abbreviated LRM
3255                 $rlm = "\xE2\x80\x8F"; # RIGHT-TO-LEFT MARK, commonly abbreviated RLM
3256                 if ( $opposite ) {
3257                         return $this->isRTL() ? $lrm : $rlm;
3258                 }
3259                 return $this->isRTL() ? $rlm : $lrm;
3260         }
3261
3262         /**
3263          * @return array
3264          */
3265         function capitalizeAllNouns() {
3266                 return self::$dataCache->getItem( $this->mCode, 'capitalizeAllNouns' );
3267         }
3268
3269         /**
3270          * An arrow, depending on the language direction.
3271          *
3272          * @param string $direction The direction of the arrow: forwards (default),
3273          *   backwards, left, right, up, down.
3274          * @return string
3275          */
3276         function getArrow( $direction = 'forwards' ) {
3277                 switch ( $direction ) {
3278                 case 'forwards':
3279                         return $this->isRTL() ? '←' : '→';
3280                 case 'backwards':
3281                         return $this->isRTL() ? '→' : '←';
3282                 case 'left':
3283                         return '←';
3284                 case 'right':
3285                         return '→';
3286                 case 'up':
3287                         return '↑';
3288                 case 'down':
3289                         return '↓';
3290                 }
3291         }
3292
3293         /**
3294          * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
3295          *
3296          * @return bool
3297          */
3298         function linkPrefixExtension() {
3299                 return self::$dataCache->getItem( $this->mCode, 'linkPrefixExtension' );
3300         }
3301
3302         /**
3303          * Get all magic words from cache.
3304          * @return array
3305          */
3306         function getMagicWords() {
3307                 return self::$dataCache->getItem( $this->mCode, 'magicWords' );
3308         }
3309
3310         /**
3311          * Run the LanguageGetMagic hook once.
3312          */
3313         protected function doMagicHook() {
3314                 if ( $this->mMagicHookDone ) {
3315                         return;
3316                 }
3317                 $this->mMagicHookDone = true;
3318                 Hooks::run( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
3319         }
3320
3321         /**
3322          * Fill a MagicWord object with data from here
3323          *
3324          * @param MagicWord $mw
3325          */
3326         function getMagic( $mw ) {
3327                 // Saves a function call
3328                 if ( !$this->mMagicHookDone ) {
3329                         $this->doMagicHook();
3330                 }
3331
3332                 if ( isset( $this->mMagicExtensions[$mw->mId] ) ) {
3333                         $rawEntry = $this->mMagicExtensions[$mw->mId];
3334                 } else {
3335                         $rawEntry = self::$dataCache->getSubitem(
3336                                 $this->mCode, 'magicWords', $mw->mId );
3337                 }
3338
3339                 if ( !is_array( $rawEntry ) ) {
3340                         wfWarn( "\"$rawEntry\" is not a valid magic word for \"$mw->mId\"" );
3341                 } else {
3342                         $mw->mCaseSensitive = $rawEntry[0];
3343                         $mw->mSynonyms = array_slice( $rawEntry, 1 );
3344                 }
3345         }
3346
3347         /**
3348          * Add magic words to the extension array
3349          *
3350          * @param array $newWords
3351          */
3352         function addMagicWordsByLang( $newWords ) {
3353                 $fallbackChain = $this->getFallbackLanguages();
3354                 $fallbackChain = array_reverse( $fallbackChain );
3355                 foreach ( $fallbackChain as $code ) {
3356                         if ( isset( $newWords[$code] ) ) {
3357                                 $this->mMagicExtensions = $newWords[$code] + $this->mMagicExtensions;
3358                         }
3359                 }
3360         }
3361
3362         /**
3363          * Get special page names, as an associative array
3364          *   canonical name => array of valid names, including aliases
3365          * @return array
3366          */
3367         function getSpecialPageAliases() {
3368                 // Cache aliases because it may be slow to load them
3369                 if ( is_null( $this->mExtendedSpecialPageAliases ) ) {
3370                         // Initialise array
3371                         $this->mExtendedSpecialPageAliases =
3372                                 self::$dataCache->getItem( $this->mCode, 'specialPageAliases' );
3373                         Hooks::run( 'LanguageGetSpecialPageAliases',
3374                                 array( &$this->mExtendedSpecialPageAliases, $this->getCode() ) );
3375                 }
3376
3377                 return $this->mExtendedSpecialPageAliases;
3378         }
3379
3380         /**
3381          * Italic is unsuitable for some languages
3382          *
3383          * @param string $text The text to be emphasized.
3384          * @return string
3385          */
3386         function emphasize( $text ) {
3387                 return "<em>$text</em>";
3388         }
3389
3390         /**
3391          * Normally we output all numbers in plain en_US style, that is
3392          * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3393          * point twohundredthirtyfive. However this is not suitable for all
3394          * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3395          * Icelandic just want to use commas instead of dots, and dots instead
3396          * of commas like "293.291,235".
3397          *
3398          * An example of this function being called:
3399          * <code>
3400          * wfMessage( 'message' )->numParams( $num )->text()
3401          * </code>
3402          *
3403          * See $separatorTransformTable on MessageIs.php for
3404          * the , => . and . => , implementation.
3405          *
3406          * @todo check if it's viable to use localeconv() for the decimal separator thing.
3407          * @param int|float $number The string to be formatted, should be an integer
3408          *   or a floating point number.
3409          * @param bool $nocommafy Set to true for special numbers like dates
3410          * @return string
3411          */
3412         public function formatNum( $number, $nocommafy = false ) {
3413                 global $wgTranslateNumerals;
3414                 if ( !$nocommafy ) {
3415                         $number = $this->commafy( $number );
3416                         $s = $this->separatorTransformTable();
3417                         if ( $s ) {
3418                                 $number = strtr( $number, $s );
3419                         }
3420                 }
3421
3422                 if ( $wgTranslateNumerals ) {
3423                         $s = $this->digitTransformTable();
3424                         if ( $s ) {
3425                                 $number = strtr( $number, $s );
3426                         }
3427                 }
3428
3429                 return $number;
3430         }
3431
3432         /**
3433          * Front-end for non-commafied formatNum
3434          *
3435          * @param int|float $number The string to be formatted, should be an integer
3436          *        or a floating point number.
3437          * @since 1.21
3438          * @return string
3439          */
3440         public function formatNumNoSeparators( $number ) {
3441                 return $this->formatNum( $number, true );
3442         }
3443
3444         /**
3445          * @param string $number
3446          * @return string
3447          */
3448         public function parseFormattedNumber( $number ) {
3449                 $s = $this->digitTransformTable();
3450                 if ( $s ) {
3451                         // eliminate empty array values such as ''. (bug 64347)
3452                         $s = array_filter( $s );
3453                         $number = strtr( $number, array_flip( $s ) );
3454                 }
3455
3456                 $s = $this->separatorTransformTable();
3457                 if ( $s ) {
3458                         // eliminate empty array values such as ''. (bug 64347)
3459                         $s = array_filter( $s );
3460                         $number = strtr( $number, array_flip( $s ) );
3461                 }
3462
3463                 $number = strtr( $number, array( ',' => '' ) );
3464                 return $number;
3465         }
3466
3467         /**
3468          * Adds commas to a given number
3469          * @since 1.19
3470          * @param mixed $number
3471          * @return string
3472          */
3473         function commafy( $number ) {
3474                 $digitGroupingPattern = $this->digitGroupingPattern();
3475                 if ( $number === null ) {
3476                         return '';
3477                 }
3478
3479                 if ( !$digitGroupingPattern || $digitGroupingPattern === "###,###,###" ) {
3480                         // default grouping is at thousands,  use the same for ###,###,### pattern too.
3481                         return strrev( (string)preg_replace( '/(\d{3})(?=\d)(?!\d*\.)/', '$1,', strrev( $number ) ) );
3482                 } else {
3483                         // Ref: http://cldr.unicode.org/translation/number-patterns
3484                         $sign = "";
3485                         if ( intval( $number ) < 0 ) {
3486                                 // For negative numbers apply the algorithm like positive number and add sign.
3487                                 $sign = "-";
3488                                 $number = substr( $number, 1 );
3489                         }
3490                         $integerPart = array();
3491                         $decimalPart = array();
3492                         $numMatches = preg_match_all( "/(#+)/", $digitGroupingPattern, $matches );
3493                         preg_match( "/\d+/", $number, $integerPart );
3494                         preg_match( "/\.\d*/", $number, $decimalPart );
3495                         $groupedNumber = ( count( $decimalPart ) > 0 ) ? $decimalPart[0] : "";
3496                         if ( $groupedNumber === $number ) {
3497                                 // the string does not have any number part. Eg: .12345
3498                                 return $sign . $groupedNumber;
3499                         }
3500                         $start = $end = ( $integerPart ) ? strlen( $integerPart[0] ) : 0;
3501                         while ( $start > 0 ) {
3502                                 $match = $matches[0][$numMatches - 1];
3503                                 $matchLen = strlen( $match );
3504                                 $start = $end - $matchLen;
3505                                 if ( $start < 0 ) {
3506                                         $start = 0;
3507                                 }
3508                                 $groupedNumber = substr( $number, $start, $end -$start ) . $groupedNumber;
3509                                 $end = $start;
3510                                 if ( $numMatches > 1 ) {
3511                                         // use the last pattern for the rest of the number
3512                                         $numMatches--;
3513                                 }
3514                                 if ( $start > 0 ) {
3515                                         $groupedNumber = "," . $groupedNumber;
3516                                 }
3517                         }
3518                         return $sign . $groupedNumber;
3519                 }
3520         }
3521
3522         /**
3523          * @return string
3524          */
3525         function digitGroupingPattern() {
3526                 return self::$dataCache->getItem( $this->mCode, 'digitGroupingPattern' );
3527         }
3528
3529         /**
3530          * @return array
3531          */
3532         function digitTransformTable() {
3533                 return self::$dataCache->getItem( $this->mCode, 'digitTransformTable' );
3534         }
3535
3536         /**
3537          * @return array
3538          */
3539         function separatorTransformTable() {
3540                 return self::$dataCache->getItem( $this->mCode, 'separatorTransformTable' );
3541         }
3542
3543         /**
3544          * Take a list of strings and build a locale-friendly comma-separated
3545          * list, using the local comma-separator message.
3546          * The last two strings are chained with an "and".
3547          * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3548          *
3549          * @param string[] $l
3550          * @return string
3551          */
3552         function listToText( array $l ) {
3553                 $m = count( $l ) - 1;
3554                 if ( $m < 0 ) {
3555                         return '';
3556                 }
3557                 if ( $m > 0 ) {
3558                         $and = $this->msg( 'and' )->escaped();
3559                         $space = $this->msg( 'word-separator' )->escaped();
3560                         if ( $m > 1 ) {
3561                                 $comma = $this->msg( 'comma-separator' )->escaped();
3562                         }
3563                 }
3564                 $s = $l[$m];
3565                 for ( $i = $m - 1; $i >= 0; $i-- ) {
3566                         if ( $i == $m - 1 ) {
3567                                 $s = $l[$i] . $and . $space . $s;
3568                         } else {
3569                                 $s = $l[$i] . $comma . $s;
3570                         }
3571                 }
3572                 return $s;
3573         }
3574
3575         /**
3576          * Take a list of strings and build a locale-friendly comma-separated
3577          * list, using the local comma-separator message.
3578          * @param string[] $list Array of strings to put in a comma list
3579          * @return string
3580          */
3581         function commaList( array $list ) {
3582                 return implode(
3583                         wfMessage( 'comma-separator' )->inLanguage( $this )->escaped(),
3584                         $list
3585                 );
3586         }
3587
3588         /**
3589          * Take a list of strings and build a locale-friendly semicolon-separated
3590          * list, using the local semicolon-separator message.
3591          * @param string[] $list Array of strings to put in a semicolon list
3592          * @return string
3593          */
3594         function semicolonList( array $list ) {
3595                 return implode(
3596                         wfMessage( 'semicolon-separator' )->inLanguage( $this )->escaped(),
3597                         $list
3598                 );
3599         }
3600
3601         /**
3602          * Same as commaList, but separate it with the pipe instead.
3603          * @param string[] $list Array of strings to put in a pipe list
3604          * @return string
3605          */
3606         function pipeList( array $list ) {
3607                 return implode(
3608                         wfMessage( 'pipe-separator' )->inLanguage( $this )->escaped(),
3609                         $list
3610                 );
3611         }
3612
3613         /**
3614          * Truncate a string to a specified length in bytes, appending an optional
3615          * string (e.g. for ellipses)
3616          *
3617          * The database offers limited byte lengths for some columns in the database;
3618          * multi-byte character sets mean we need to ensure that only whole characters
3619          * are included, otherwise broken characters can be passed to the user
3620          *
3621          * If $length is negative, the string will be truncated from the beginning
3622          *
3623          * @param string $string String to truncate
3624          * @param int $length Maximum length (including ellipses)
3625          * @param string $ellipsis String to append to the truncated text
3626          * @param bool $adjustLength Subtract length of ellipsis from $length.
3627          *      $adjustLength was introduced in 1.18, before that behaved as if false.
3628          * @return string
3629          */
3630         function truncate( $string, $length, $ellipsis = '...', $adjustLength = true ) {
3631                 # Use the localized ellipsis character
3632                 if ( $ellipsis == '...' ) {
3633                         $ellipsis = wfMessage( 'ellipsis' )->inLanguage( $this )->escaped();
3634                 }
3635                 # Check if there is no need to truncate
3636                 if ( $length == 0 ) {
3637                         return $ellipsis; // convention
3638                 } elseif ( strlen( $string ) <= abs( $length ) ) {
3639                         return $string; // no need to truncate
3640                 }
3641                 $stringOriginal = $string;
3642                 # If ellipsis length is >= $length then we can't apply $adjustLength
3643                 if ( $adjustLength && strlen( $ellipsis ) >= abs( $length ) ) {
3644                         $string = $ellipsis; // this can be slightly unexpected
3645                 # Otherwise, truncate and add ellipsis...
3646                 } else {
3647                         $eLength = $adjustLength ? strlen( $ellipsis ) : 0;
3648                         if ( $length > 0 ) {
3649                                 $length -= $eLength;
3650                                 $string = substr( $string, 0, $length ); // xyz...
3651                                 $string = $this->removeBadCharLast( $string );
3652                                 $string = rtrim( $string );
3653                                 $string = $string . $ellipsis;
3654                         } else {
3655                                 $length += $eLength;
3656                                 $string = substr( $string, $length ); // ...xyz
3657                                 $string = $this->removeBadCharFirst( $string );
3658                                 $string = ltrim( $string );
3659                                 $string = $ellipsis . $string;
3660                         }
3661                 }
3662                 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3663                 # This check is *not* redundant if $adjustLength, due to the single case where
3664                 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3665                 if ( strlen( $string ) < strlen( $stringOriginal ) ) {
3666                         return $string;
3667                 } else {
3668                         return $stringOriginal;
3669                 }
3670         }
3671
3672         /**
3673          * Remove bytes that represent an incomplete Unicode character
3674          * at the end of string (e.g. bytes of the char are missing)
3675          *
3676          * @param string $string
3677          * @return string
3678          */
3679         protected function removeBadCharLast( $string ) {
3680                 if ( $string != '' ) {
3681                         $char = ord( $string[strlen( $string ) - 1] );
3682                         $m = array();
3683                         if ( $char >= 0xc0 ) {
3684                                 # We got the first byte only of a multibyte char; remove it.
3685                                 $string = substr( $string, 0, -1 );
3686                         } elseif ( $char >= 0x80 &&
3687                                 preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
3688                                         '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m )
3689                         ) {
3690                                 # We chopped in the middle of a character; remove it
3691                                 $string = $m[1];
3692                         }
3693                 }
3694                 return $string;
3695         }
3696
3697         /**
3698          * Remove bytes that represent an incomplete Unicode character
3699          * at the start of string (e.g. bytes of the char are missing)
3700          *
3701          * @param string $string
3702          * @return string
3703          */
3704         protected function removeBadCharFirst( $string ) {
3705                 if ( $string != '' ) {
3706                         $char = ord( $string[0] );
3707                         if ( $char >= 0x80 && $char < 0xc0 ) {
3708                                 # We chopped in the middle of a character; remove the whole thing
3709                                 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
3710                         }
3711                 }
3712                 return $string;
3713         }
3714
3715         /**
3716          * Truncate a string of valid HTML to a specified length in bytes,
3717          * appending an optional string (e.g. for ellipses), and return valid HTML
3718          *
3719          * This is only intended for styled/linked text, such as HTML with
3720          * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3721          * Also, this will not detect things like "display:none" CSS.
3722          *
3723          * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3724          *
3725          * @param string $text HTML string to truncate
3726          * @param int $length (zero/positive) Maximum length (including ellipses)
3727          * @param string $ellipsis String to append to the truncated text
3728          * @return string
3729          */
3730         function truncateHtml( $text, $length, $ellipsis = '...' ) {
3731                 # Use the localized ellipsis character
3732                 if ( $ellipsis == '...' ) {
3733                         $ellipsis = wfMessage( 'ellipsis' )->inLanguage( $this )->escaped();
3734                 }
3735                 # Check if there is clearly no need to truncate
3736                 if ( $length <= 0 ) {
3737                         return $ellipsis; // no text shown, nothing to format (convention)
3738                 } elseif ( strlen( $text ) <= $length ) {
3739                         return $text; // string short enough even *with* HTML (short-circuit)
3740                 }
3741
3742                 $dispLen = 0; // innerHTML legth so far
3743                 $testingEllipsis = false; // checking if ellipses will make string longer/equal?
3744                 $tagType = 0; // 0-open, 1-close
3745                 $bracketState = 0; // 1-tag start, 2-tag name, 0-neither
3746                 $entityState = 0; // 0-not entity, 1-entity
3747                 $tag = $ret = ''; // accumulated tag name, accumulated result string
3748                 $openTags = array(); // open tag stack
3749                 $maybeState = null; // possible truncation state
3750
3751                 $textLen = strlen( $text );
3752                 $neLength = max( 0, $length - strlen( $ellipsis ) ); // non-ellipsis len if truncated
3753                 for ( $pos = 0; true; ++$pos ) {
3754                         # Consider truncation once the display length has reached the maximim.
3755                         # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3756                         # Check that we're not in the middle of a bracket/entity...
3757                         if ( $dispLen && $dispLen >= $neLength && $bracketState == 0 && !$entityState ) {
3758                                 if ( !$testingEllipsis ) {
3759                                         $testingEllipsis = true;
3760                                         # Save where we are; we will truncate here unless there turn out to
3761                                         # be so few remaining characters that truncation is not necessary.
3762                                         if ( !$maybeState ) { // already saved? ($neLength = 0 case)
3763                                                 $maybeState = array( $ret, $openTags ); // save state
3764                                         }
3765                                 } elseif ( $dispLen > $length && $dispLen > strlen( $ellipsis ) ) {
3766                                         # String in fact does need truncation, the truncation point was OK.
3767                                         list( $ret, $openTags ) = $maybeState; // reload state
3768                                         $ret = $this->removeBadCharLast( $ret ); // multi-byte char fix
3769                                         $ret .= $ellipsis; // add ellipsis
3770                                         break;
3771                                 }
3772                         }
3773                         if ( $pos >= $textLen ) {
3774                                 break; // extra iteration just for above checks
3775                         }
3776
3777                         # Read the next char...
3778                         $ch = $text[$pos];
3779                         $lastCh = $pos ? $text[$pos - 1] : '';
3780                         $ret .= $ch; // add to result string
3781                         if ( $ch == '<' ) {
3782                                 $this->truncate_endBracket( $tag, $tagType, $lastCh, $openTags ); // for bad HTML
3783                                 $entityState = 0; // for bad HTML
3784                                 $bracketState = 1; // tag started (checking for backslash)
3785                         } elseif ( $ch == '>' ) {
3786                                 $this->truncate_endBracket( $tag, $tagType, $lastCh, $openTags );
3787                                 $entityState = 0; // for bad HTML
3788                                 $bracketState = 0; // out of brackets
3789                         } elseif ( $bracketState == 1 ) {
3790                                 if ( $ch == '/' ) {
3791                                         $tagType = 1; // close tag (e.g. "</span>")
3792                                 } else {
3793                                         $tagType = 0; // open tag (e.g. "<span>")
3794                                         $tag .= $ch;
3795                                 }
3796                                 $bracketState = 2; // building tag name
3797                         } elseif ( $bracketState == 2 ) {
3798                                 if ( $ch != ' ' ) {
3799                                         $tag .= $ch;
3800                                 } else {
3801                                         // Name found (e.g. "<a href=..."), add on tag attributes...
3802                                         $pos += $this->truncate_skip( $ret, $text, "<>", $pos + 1 );
3803                                 }
3804                         } elseif ( $bracketState == 0 ) {
3805                                 if ( $entityState ) {
3806                                         if ( $ch == ';' ) {
3807                                                 $entityState = 0;
3808                                                 $dispLen++; // entity is one displayed char
3809                                         }
3810                                 } else {
3811                                         if ( $neLength == 0 && !$maybeState ) {
3812                                                 // Save state without $ch. We want to *hit* the first
3813                                                 // display char (to get tags) but not *use* it if truncating.
3814                                                 $maybeState = array( substr( $ret, 0, -1 ), $openTags );
3815                                         }
3816                                         if ( $ch == '&' ) {
3817                                                 $entityState = 1; // entity found, (e.g. "&#160;")
3818                                         } else {
3819                                                 $dispLen++; // this char is displayed
3820                                                 // Add the next $max display text chars after this in one swoop...
3821                                                 $max = ( $testingEllipsis ? $length : $neLength ) - $dispLen;
3822                                                 $skipped = $this->truncate_skip( $ret, $text, "<>&", $pos + 1, $max );
3823                                                 $dispLen += $skipped;
3824                                                 $pos += $skipped;
3825                                         }
3826                                 }
3827                         }
3828                 }
3829                 // Close the last tag if left unclosed by bad HTML
3830                 $this->truncate_endBracket( $tag, $text[$textLen - 1], $tagType, $openTags );
3831                 while ( count( $openTags ) > 0 ) {
3832                         $ret .= '</' . array_pop( $openTags ) . '>'; // close open tags
3833                 }
3834                 return $ret;
3835         }
3836
3837         /**
3838          * truncateHtml() helper function
3839          * like strcspn() but adds the skipped chars to $ret
3840          *
3841          * @param string $ret
3842          * @param string $text
3843          * @param string $search
3844          * @param int $start
3845          * @param null|int $len
3846          * @return int
3847          */
3848         private function truncate_skip( &$ret, $text, $search, $start, $len = null ) {
3849                 if ( $len === null ) {
3850                         $len = -1; // -1 means "no limit" for strcspn
3851                 } elseif ( $len < 0 ) {
3852                         $len = 0; // sanity
3853                 }
3854                 $skipCount = 0;
3855                 if ( $start < strlen( $text ) ) {
3856                         $skipCount = strcspn( $text, $search, $start, $len );
3857                         $ret .= substr( $text, $start, $skipCount );
3858                 }
3859                 return $skipCount;
3860         }
3861
3862         /**
3863          * truncateHtml() helper function
3864          * (a) push or pop $tag from $openTags as needed
3865          * (b) clear $tag value
3866          * @param string &$tag Current HTML tag name we are looking at
3867          * @param int $tagType (0-open tag, 1-close tag)
3868          * @param string $lastCh Character before the '>' that ended this tag
3869          * @param array &$openTags Open tag stack (not accounting for $tag)
3870          */
3871         private function truncate_endBracket( &$tag, $tagType, $lastCh, &$openTags ) {
3872                 $tag = ltrim( $tag );
3873                 if ( $tag != '' ) {
3874                         if ( $tagType == 0 && $lastCh != '/' ) {
3875                                 $openTags[] = $tag; // tag opened (didn't close itself)
3876                         } elseif ( $tagType == 1 ) {
3877                                 if ( $openTags && $tag == $openTags[count( $openTags ) - 1] ) {
3878                                         array_pop( $openTags ); // tag closed
3879                                 }
3880                         }
3881                         $tag = '';
3882                 }
3883         }
3884
3885         /**
3886          * Grammatical transformations, needed for inflected languages
3887          * Invoked by putting {{grammar:case|word}} in a message
3888          *
3889          * @param string $word
3890          * @param string $case
3891          * @return string
3892          */
3893         function convertGrammar( $word, $case ) {
3894                 global $wgGrammarForms;
3895                 if ( isset( $wgGrammarForms[$this->getCode()][$case][$word] ) ) {
3896                         return $wgGrammarForms[$this->getCode()][$case][$word];
3897                 }
3898
3899                 return $word;
3900         }
3901         /**
3902          * Get the grammar forms for the content language
3903          * @return array Array of grammar forms
3904          * @since 1.20
3905          */
3906         function getGrammarForms() {
3907                 global $wgGrammarForms;
3908                 if ( isset( $wgGrammarForms[$this->getCode()] )
3909                         && is_array( $wgGrammarForms[$this->getCode()] )
3910                 ) {
3911                         return $wgGrammarForms[$this->getCode()];
3912                 }
3913
3914                 return array();
3915         }
3916         /**
3917          * Provides an alternative text depending on specified gender.
3918          * Usage {{gender:username|masculine|feminine|unknown}}.
3919          * username is optional, in which case the gender of current user is used,
3920          * but only in (some) interface messages; otherwise default gender is used.
3921          *
3922          * If no forms are given, an empty string is returned. If only one form is
3923          * given, it will be returned unconditionally. These details are implied by
3924          * the caller and cannot be overridden in subclasses.
3925          *
3926          * If three forms are given, the default is to use the third (unknown) form.
3927          * If fewer than three forms are given, the default is to use the first (masculine) form.
3928          * These details can be overridden in subclasses.
3929          *
3930          * @param string $gender
3931          * @param array $forms
3932          *
3933          * @return string
3934          */
3935         function gender( $gender, $forms ) {
3936                 if ( !count( $forms ) ) {
3937                         return '';
3938                 }
3939                 $forms = $this->preConvertPlural( $forms, 2 );
3940                 if ( $gender === 'male' ) {
3941                         return $forms[0];
3942                 }
3943                 if ( $gender === 'female' ) {
3944                         return $forms[1];
3945                 }
3946                 return isset( $forms[2] ) ? $forms[2] : $forms[0];
3947         }
3948
3949         /**
3950          * Plural form transformations, needed for some languages.
3951          * For example, there are 3 form of plural in Russian and Polish,
3952          * depending on "count mod 10". See [[w:Plural]]
3953          * For English it is pretty simple.
3954          *
3955          * Invoked by putting {{plural:count|wordform1|wordform2}}
3956          * or {{plural:count|wordform1|wordform2|wordform3}}
3957          *
3958          * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3959          *
3960          * @param int $count Non-localized number
3961          * @param array $forms Different plural forms
3962          * @return string Correct form of plural for $count in this language
3963          */
3964         function convertPlural( $count, $forms ) {
3965                 // Handle explicit n=pluralform cases
3966                 $forms = $this->handleExplicitPluralForms( $count, $forms );
3967                 if ( is_string( $forms ) ) {
3968                         return $forms;
3969                 }
3970                 if ( !count( $forms ) ) {
3971                         return '';
3972                 }
3973
3974                 $pluralForm = $this->getPluralRuleIndexNumber( $count );
3975                 $pluralForm = min( $pluralForm, count( $forms ) - 1 );
3976                 return $forms[$pluralForm];
3977         }
3978
3979         /**
3980          * Handles explicit plural forms for Language::convertPlural()
3981          *
3982          * In {{PLURAL:$1|0=nothing|one|many}}, 0=nothing will be returned if $1 equals zero.
3983          * If an explicitly defined plural form matches the $count, then
3984          * string value returned, otherwise array returned for further consideration
3985          * by CLDR rules or overridden convertPlural().
3986          *
3987          * @since 1.23
3988          *
3989          * @param int $count Non-localized number
3990          * @param array $forms Different plural forms
3991          *
3992          * @return array|string
3993          */
3994         protected function handleExplicitPluralForms( $count, array $forms ) {
3995                 foreach ( $forms as $index => $form ) {
3996                         if ( preg_match( '/\d+=/i', $form ) ) {
3997                                 $pos = strpos( $form, '=' );
3998                                 if ( substr( $form, 0, $pos ) === (string)$count ) {
3999                                         return substr( $form, $pos + 1 );
4000                                 }
4001                                 unset( $forms[$index] );
4002                         }
4003                 }
4004                 return array_values( $forms );
4005         }
4006
4007         /**
4008          * Checks that convertPlural was given an array and pads it to requested
4009          * amount of forms by copying the last one.
4010          *
4011          * @param array $forms Array of forms given to convertPlural
4012          * @param int $count How many forms should there be at least
4013          * @return array Padded array of forms or an exception if not an array
4014          */
4015         protected function preConvertPlural( /* Array */ $forms, $count ) {
4016                 while ( count( $forms ) < $count ) {
4017                         $forms[] = $forms[count( $forms ) - 1];
4018                 }
4019                 return $forms;
4020         }
4021
4022         /**
4023          * Wraps argument with unicode control characters for directionality safety
4024          *
4025          * This solves the problem where directionality-neutral characters at the edge of
4026          * the argument string get interpreted with the wrong directionality from the
4027          * enclosing context, giving renderings that look corrupted like "(Ben_(WMF".
4028          *
4029          * The wrapping is LRE...PDF or RLE...PDF, depending on the detected
4030          * directionality of the argument string, using the BIDI algorithm's own "First
4031          * strong directional codepoint" rule. Essentially, this works round the fact that
4032          * there is no embedding equivalent of U+2068 FSI (isolation with heuristic
4033          * direction inference). The latter is cleaner but still not widely supported.
4034          *
4035          * @param string $text Text to wrap
4036          * @return string Text, wrapped in LRE...PDF or RLE...PDF or nothing
4037          */
4038         public function embedBidi( $text = '' ) {
4039                 $dir = Language::strongDirFromContent( $text );
4040                 if ( $dir === 'ltr' ) {
4041                         // Wrap in LEFT-TO-RIGHT EMBEDDING ... POP DIRECTIONAL FORMATTING
4042                         return self::$lre . $text . self::$pdf;
4043                 }
4044                 if ( $dir === 'rtl' ) {
4045                         // Wrap in RIGHT-TO-LEFT EMBEDDING ... POP DIRECTIONAL FORMATTING
4046                         return self::$rle . $text . self::$pdf;
4047                 }
4048                 // No strong directionality: do not wrap
4049                 return $text;
4050         }
4051
4052         /**
4053          * @todo Maybe translate block durations.  Note that this function is somewhat misnamed: it
4054          * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
4055          * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
4056          * on old expiry lengths recorded in log entries. You'd need to provide the start date to
4057          * match up with it.
4058          *
4059          * @param string $str The validated block duration in English
4060          * @return string Somehow translated block duration
4061          * @see LanguageFi.php for example implementation
4062          */
4063         function translateBlockExpiry( $str ) {
4064                 $duration = SpecialBlock::getSuggestedDurations( $this );
4065                 foreach ( $duration as $show => $value ) {
4066                         if ( strcmp( $str, $value ) == 0 ) {
4067                                 return htmlspecialchars( trim( $show ) );
4068                         }
4069                 }
4070
4071                 if ( wfIsInfinity( $str ) ) {
4072                         foreach ( $duration as $show => $value ) {
4073                                 if ( wfIsInfinity( $value ) ) {
4074                                         return htmlspecialchars( trim( $show ) );
4075                                 }
4076                         }
4077                 }
4078
4079                 // If all else fails, return a standard duration or timestamp description.
4080                 $time = strtotime( $str, 0 );
4081                 if ( $time === false ) { // Unknown format. Return it as-is in case.
4082                         return $str;
4083                 } elseif ( $time !== strtotime( $str, 1 ) ) { // It's a relative timestamp.
4084                         // $time is relative to 0 so it's a duration length.
4085                         return $this->formatDuration( $time );
4086                 } else { // It's an absolute timestamp.
4087                         if ( $time === 0 ) {
4088                                 // wfTimestamp() handles 0 as current time instead of epoch.
4089                                 return $this->timeanddate( '19700101000000' );
4090                         } else {
4091                                 return $this->timeanddate( $time );
4092                         }
4093                 }
4094         }
4095
4096         /**
4097          * languages like Chinese need to be segmented in order for the diff
4098          * to be of any use
4099          *
4100          * @param string $text
4101          * @return string
4102          */
4103         public function segmentForDiff( $text ) {
4104                 return $text;
4105         }
4106
4107         /**
4108          * and unsegment to show the result
4109          *
4110          * @param string $text
4111          * @return string
4112          */
4113         public function unsegmentForDiff( $text ) {
4114                 return $text;
4115         }
4116
4117         /**
4118          * Return the LanguageConverter used in the Language
4119          *
4120          * @since 1.19
4121          * @return LanguageConverter
4122          */
4123         public function getConverter() {
4124                 return $this->mConverter;
4125         }
4126
4127         /**
4128          * convert text to all supported variants
4129          *
4130          * @param string $text
4131          * @return array
4132          */
4133         public function autoConvertToAllVariants( $text ) {
4134                 return $this->mConverter->autoConvertToAllVariants( $text );
4135         }
4136
4137         /**
4138          * convert text to different variants of a language.
4139          *
4140          * @param string $text
4141          * @return string
4142          */
4143         public function convert( $text ) {
4144                 return $this->mConverter->convert( $text );
4145         }
4146
4147         /**
4148          * Convert a Title object to a string in the preferred variant
4149          *
4150          * @param Title $title
4151          * @return string
4152          */
4153         public function convertTitle( $title ) {
4154                 return $this->mConverter->convertTitle( $title );
4155         }
4156
4157         /**
4158          * Convert a namespace index to a string in the preferred variant
4159          *
4160          * @param int $ns
4161          * @return string
4162          */
4163         public function convertNamespace( $ns ) {
4164                 return $this->mConverter->convertNamespace( $ns );
4165         }
4166
4167         /**
4168          * Check if this is a language with variants
4169          *
4170          * @return bool
4171          */
4172         public function hasVariants() {
4173                 return count( $this->getVariants() ) > 1;
4174         }
4175
4176         /**
4177          * Check if the language has the specific variant
4178          *
4179          * @since 1.19
4180          * @param string $variant
4181          * @return bool
4182          */
4183         public function hasVariant( $variant ) {
4184                 return (bool)$this->mConverter->validateVariant( $variant );
4185         }
4186
4187         /**
4188          * Put custom tags (e.g. -{ }-) around math to prevent conversion
4189          *
4190          * @param string $text
4191          * @return string
4192          * @deprecated since 1.22 is no longer used
4193          */
4194         public function armourMath( $text ) {
4195                 return $this->mConverter->armourMath( $text );
4196         }
4197
4198         /**
4199          * Perform output conversion on a string, and encode for safe HTML output.
4200          * @param string $text Text to be converted
4201          * @param bool $isTitle Whether this conversion is for the article title
4202          * @return string
4203          * @todo this should get integrated somewhere sane
4204          */
4205         public function convertHtml( $text, $isTitle = false ) {
4206                 return htmlspecialchars( $this->convert( $text, $isTitle ) );
4207         }
4208
4209         /**
4210          * @param string $key
4211          * @return string
4212          */
4213         public function convertCategoryKey( $key ) {
4214                 return $this->mConverter->convertCategoryKey( $key );
4215         }
4216
4217         /**
4218          * Get the list of variants supported by this language
4219          * see sample implementation in LanguageZh.php
4220          *
4221          * @return array An array of language codes
4222          */
4223         public function getVariants() {
4224                 return $this->mConverter->getVariants();
4225         }
4226
4227         /**
4228          * @return string
4229          */
4230         public function getPreferredVariant() {
4231                 return $this->mConverter->getPreferredVariant();
4232         }
4233
4234         /**
4235          * @return string
4236          */
4237         public function getDefaultVariant() {
4238                 return $this->mConverter->getDefaultVariant();
4239         }
4240
4241         /**
4242          * @return string
4243          */
4244         public function getURLVariant() {
4245                 return $this->mConverter->getURLVariant();
4246         }
4247
4248         /**
4249          * If a language supports multiple variants, it is
4250          * possible that non-existing link in one variant
4251          * actually exists in another variant. this function
4252          * tries to find it. See e.g. LanguageZh.php
4253          * The input parameters may be modified upon return
4254          *
4255          * @param string &$link The name of the link
4256          * @param Title &$nt The title object of the link
4257          * @param bool $ignoreOtherCond To disable other conditions when
4258          *   we need to transclude a template or update a category's link
4259          */
4260         public function findVariantLink( &$link, &$nt, $ignoreOtherCond = false ) {
4261                 $this->mConverter->findVariantLink( $link, $nt, $ignoreOtherCond );
4262         }
4263
4264         /**
4265          * returns language specific options used by User::getPageRenderHash()
4266          * for example, the preferred language variant
4267          *
4268          * @return string
4269          */
4270         function getExtraHashOptions() {
4271                 return $this->mConverter->getExtraHashOptions();
4272         }
4273
4274         /**
4275          * For languages that support multiple variants, the title of an
4276          * article may be displayed differently in different variants. this
4277          * function returns the apporiate title defined in the body of the article.
4278          *
4279          * @return string
4280          */
4281         public function getParsedTitle() {
4282                 return $this->mConverter->getParsedTitle();
4283         }
4284
4285         /**
4286          * Prepare external link text for conversion. When the text is
4287          * a URL, it shouldn't be converted, and it'll be wrapped in
4288          * the "raw" tag (-{R| }-) to prevent conversion.
4289          *
4290          * This function is called "markNoConversion" for historical
4291          * reasons.
4292          *
4293          * @param string $text Text to be used for external link
4294          * @param bool $noParse Wrap it without confirming it's a real URL first
4295          * @return string The tagged text
4296          */
4297         public function markNoConversion( $text, $noParse = false ) {
4298                 // Excluding protocal-relative URLs may avoid many false positives.
4299                 if ( $noParse || preg_match( '/^(?:' . wfUrlProtocolsWithoutProtRel() . ')/', $text ) ) {
4300                         return $this->mConverter->markNoConversion( $text );
4301                 } else {
4302                         return $text;
4303                 }
4304         }
4305
4306         /**
4307          * A regular expression to match legal word-trailing characters
4308          * which should be merged onto a link of the form [[foo]]bar.
4309          *
4310          * @return string
4311          */
4312         public function linkTrail() {
4313                 return self::$dataCache->getItem( $this->mCode, 'linkTrail' );
4314         }
4315
4316         /**
4317          * A regular expression character set to match legal word-prefixing
4318          * characters which should be merged onto a link of the form foo[[bar]].
4319          *
4320          * @return string
4321          */
4322         public function linkPrefixCharset() {
4323                 return self::$dataCache->getItem( $this->mCode, 'linkPrefixCharset' );
4324         }
4325
4326         /**
4327          * @deprecated since 1.24, will be removed in 1.25
4328          * @return Language
4329          */
4330         function getLangObj() {
4331                 wfDeprecated( __METHOD__, '1.24' );
4332                 return $this;
4333         }
4334
4335         /**
4336          * Get the "parent" language which has a converter to convert a "compatible" language
4337          * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
4338          *
4339          * @return Language|null
4340          * @since 1.22
4341          */
4342         public function getParentLanguage() {
4343                 if ( $this->mParentLanguage !== false ) {
4344                         return $this->mParentLanguage;
4345                 }
4346
4347                 $pieces = explode( '-', $this->getCode() );
4348                 $code = $pieces[0];
4349                 if ( !in_array( $code, LanguageConverter::$languagesWithVariants ) ) {
4350                         $this->mParentLanguage = null;
4351                         return null;
4352                 }
4353                 $lang = Language::factory( $code );
4354                 if ( !$lang->hasVariant( $this->getCode() ) ) {
4355                         $this->mParentLanguage = null;
4356                         return null;
4357                 }
4358
4359                 $this->mParentLanguage = $lang;
4360                 return $lang;
4361         }
4362
4363         /**
4364          * Get the RFC 3066 code for this language object
4365          *
4366          * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4367          * htmlspecialchars() or similar
4368          *
4369          * @return string
4370          */
4371         public function getCode() {
4372                 return $this->mCode;
4373         }
4374
4375         /**
4376          * Get the code in Bcp47 format which we can use
4377          * inside of html lang="" tags.
4378          *
4379          * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4380          * htmlspecialchars() or similar.
4381          *
4382          * @since 1.19
4383          * @return string
4384          */
4385         public function getHtmlCode() {
4386                 if ( is_null( $this->mHtmlCode ) ) {
4387                         $this->mHtmlCode = wfBCP47( $this->getCode() );
4388                 }
4389                 return $this->mHtmlCode;
4390         }
4391
4392         /**
4393          * @param string $code
4394          */
4395         public function setCode( $code ) {
4396                 $this->mCode = $code;
4397                 // Ensure we don't leave incorrect cached data lying around
4398                 $this->mHtmlCode = null;
4399                 $this->mParentLanguage = false;
4400         }
4401
4402         /**
4403          * Get the name of a file for a certain language code
4404          * @param string $prefix Prepend this to the filename
4405          * @param string $code Language code
4406          * @param string $suffix Append this to the filename
4407          * @throws MWException
4408          * @return string $prefix . $mangledCode . $suffix
4409          */
4410         public static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
4411                 if ( !self::isValidBuiltInCode( $code ) ) {
4412                         throw new MWException( "Invalid language code \"$code\"" );
4413                 }
4414
4415                 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
4416         }
4417
4418         /**
4419          * Get the language code from a file name. Inverse of getFileName()
4420          * @param string $filename $prefix . $languageCode . $suffix
4421          * @param string $prefix Prefix before the language code
4422          * @param string $suffix Suffix after the language code
4423          * @return string Language code, or false if $prefix or $suffix isn't found
4424          */
4425         public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4426                 $m = null;
4427                 preg_match( '/' . preg_quote( $prefix, '/' ) . '([A-Z][a-z_]+)' .
4428                         preg_quote( $suffix, '/' ) . '/', $filename, $m );
4429                 if ( !count( $m ) ) {
4430                         return false;
4431                 }
4432                 return str_replace( '_', '-', strtolower( $m[1] ) );
4433         }
4434
4435         /**
4436          * @param string $code
4437          * @return string
4438          */
4439         public static function getMessagesFileName( $code ) {
4440                 global $IP;
4441                 $file = self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
4442                 Hooks::run( 'Language::getMessagesFileName', array( $code, &$file ) );
4443                 return $file;
4444         }
4445
4446         /**
4447          * @param string $code
4448          * @return string
4449          * @since 1.23
4450          */
4451         public static function getJsonMessagesFileName( $code ) {
4452                 global $IP;
4453
4454                 if ( !self::isValidBuiltInCode( $code ) ) {
4455                         throw new MWException( "Invalid language code \"$code\"" );
4456                 }
4457
4458                 return "$IP/languages/i18n/$code.json";
4459         }
4460
4461         /**
4462          * @param string $code
4463          * @return string
4464          */
4465         public static function getClassFileName( $code ) {
4466                 global $IP;
4467                 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
4468         }
4469
4470         /**
4471          * Get the first fallback for a given language.
4472          *
4473          * @param string $code
4474          *
4475          * @return bool|string
4476          */
4477         public static function getFallbackFor( $code ) {
4478                 if ( $code === 'en' || !Language::isValidBuiltInCode( $code ) ) {
4479                         return false;
4480                 } else {
4481                         $fallbacks = self::getFallbacksFor( $code );
4482                         return $fallbacks[0];
4483                 }
4484         }
4485
4486         /**
4487          * Get the ordered list of fallback languages.
4488          *
4489          * @since 1.19
4490          * @param string $code Language code
4491          * @return array Non-empty array, ending in "en"
4492          */
4493         public static function getFallbacksFor( $code ) {
4494                 if ( $code === 'en' || !Language::isValidBuiltInCode( $code ) ) {
4495                         return array();
4496                 }
4497                 // For unknown languages, fallbackSequence returns an empty array,
4498                 // hardcode fallback to 'en' in that case.
4499                 return self::getLocalisationCache()->getItem( $code, 'fallbackSequence' ) ?: array( 'en' );
4500         }
4501
4502         /**
4503          * Get the ordered list of fallback languages, ending with the fallback
4504          * language chain for the site language.
4505          *
4506          * @since 1.22
4507          * @param string $code Language code
4508          * @return array Array( fallbacks, site fallbacks )
4509          */
4510         public static function getFallbacksIncludingSiteLanguage( $code ) {
4511                 global $wgLanguageCode;
4512
4513                 // Usually, we will only store a tiny number of fallback chains, so we
4514                 // keep them in static memory.
4515                 $cacheKey = "{$code}-{$wgLanguageCode}";
4516
4517                 if ( !array_key_exists( $cacheKey, self::$fallbackLanguageCache ) ) {
4518                         $fallbacks = self::getFallbacksFor( $code );
4519
4520                         // Append the site's fallback chain, including the site language itself
4521                         $siteFallbacks = self::getFallbacksFor( $wgLanguageCode );
4522                         array_unshift( $siteFallbacks, $wgLanguageCode );
4523
4524                         // Eliminate any languages already included in the chain
4525                         $siteFallbacks = array_diff( $siteFallbacks, $fallbacks );
4526
4527                         self::$fallbackLanguageCache[$cacheKey] = array( $fallbacks, $siteFallbacks );
4528                 }
4529                 return self::$fallbackLanguageCache[$cacheKey];
4530         }
4531
4532         /**
4533          * Get all messages for a given language
4534          * WARNING: this may take a long time. If you just need all message *keys*
4535          * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4536          *
4537          * @param string $code
4538          *
4539          * @return array
4540          */
4541         public static function getMessagesFor( $code ) {
4542                 return self::getLocalisationCache()->getItem( $code, 'messages' );
4543         }
4544
4545         /**
4546          * Get a message for a given language
4547          *
4548          * @param string $key
4549          * @param string $code
4550          *
4551          * @return string
4552          */
4553         public static function getMessageFor( $key, $code ) {
4554                 return self::getLocalisationCache()->getSubitem( $code, 'messages', $key );
4555         }
4556
4557         /**
4558          * Get all message keys for a given language. This is a faster alternative to
4559          * array_keys( Language::getMessagesFor( $code ) )
4560          *
4561          * @since 1.19
4562          * @param string $code Language code
4563          * @return array Array of message keys (strings)
4564          */
4565         public static function getMessageKeysFor( $code ) {
4566                 return self::getLocalisationCache()->getSubItemList( $code, 'messages' );
4567         }
4568
4569         /**
4570          * @param string $talk
4571          * @return mixed
4572          */
4573         function fixVariableInNamespace( $talk ) {
4574                 if ( strpos( $talk, '$1' ) === false ) {
4575                         return $talk;
4576                 }
4577
4578                 global $wgMetaNamespace;
4579                 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
4580
4581                 # Allow grammar transformations
4582                 # Allowing full message-style parsing would make simple requests
4583                 # such as action=raw much more expensive than they need to be.
4584                 # This will hopefully cover most cases.
4585                 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
4586                         array( &$this, 'replaceGrammarInNamespace' ), $talk );
4587                 return str_replace( ' ', '_', $talk );
4588         }
4589
4590         /**
4591          * @param string $m
4592          * @return string
4593          */
4594         function replaceGrammarInNamespace( $m ) {
4595                 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
4596         }
4597
4598         /**
4599          * @throws MWException
4600          * @return array
4601          */
4602         static function getCaseMaps() {
4603                 static $wikiUpperChars, $wikiLowerChars;
4604                 if ( isset( $wikiUpperChars ) ) {
4605                         return array( $wikiUpperChars, $wikiLowerChars );
4606                 }
4607
4608                 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
4609                 if ( $arr === false ) {
4610                         throw new MWException(
4611                                 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
4612                 }
4613                 $wikiUpperChars = $arr['wikiUpperChars'];
4614                 $wikiLowerChars = $arr['wikiLowerChars'];
4615                 return array( $wikiUpperChars, $wikiLowerChars );
4616         }
4617
4618         /**
4619          * Decode an expiry (block, protection, etc) which has come from the DB
4620          *
4621          * @param string $expiry Database expiry String
4622          * @param bool|int $format True to process using language functions, or TS_ constant
4623          *     to return the expiry in a given timestamp
4624          * @param string $inifinity If $format is not true, use this string for infinite expiry
4625          * @return string
4626          * @since 1.18
4627          */
4628         public function formatExpiry( $expiry, $format = true, $infinity = 'infinity' ) {
4629                 static $dbInfinity;
4630                 if ( $dbInfinity === null ) {
4631                         $dbInfinity = wfGetDB( DB_SLAVE )->getInfinity();
4632                 }
4633
4634                 if ( $expiry == '' || $expiry === 'infinity' || $expiry == $dbInfinity ) {
4635                         return $format === true
4636                                 ? $this->getMessageFromDB( 'infiniteblock' )
4637                                 : $infinity;
4638                 } else {
4639                         return $format === true
4640                                 ? $this->timeanddate( $expiry, /* User preference timezone */ true )
4641                                 : wfTimestamp( $format, $expiry );
4642                 }
4643         }
4644
4645         /**
4646          * @todo Document
4647          * @param int|float $seconds
4648          * @param array $format Optional
4649          *   If $format['avoid'] === 'avoidseconds': don't mention seconds if $seconds >= 1 hour.
4650          *   If $format['avoid'] === 'avoidminutes': don't mention seconds/minutes if $seconds > 48 hours.
4651          *   If $format['noabbrevs'] is true: use 'seconds' and friends instead of 'seconds-abbrev'
4652          *     and friends.
4653          *   For backwards compatibility, $format may also be one of the strings 'avoidseconds'
4654          *     or 'avoidminutes'.
4655          * @return string
4656          */
4657         function formatTimePeriod( $seconds, $format = array() ) {
4658                 if ( !is_array( $format ) ) {
4659                         $format = array( 'avoid' => $format ); // For backwards compatibility
4660                 }
4661                 if ( !isset( $format['avoid'] ) ) {
4662                         $format['avoid'] = false;
4663                 }
4664                 if ( !isset( $format['noabbrevs'] ) ) {
4665                         $format['noabbrevs'] = false;
4666                 }
4667                 $secondsMsg = wfMessage(
4668                         $format['noabbrevs'] ? 'seconds' : 'seconds-abbrev' )->inLanguage( $this );
4669                 $minutesMsg = wfMessage(
4670                         $format['noabbrevs'] ? 'minutes' : 'minutes-abbrev' )->inLanguage( $this );
4671                 $hoursMsg = wfMessage(
4672                         $format['noabbrevs'] ? 'hours' : 'hours-abbrev' )->inLanguage( $this );
4673                 $daysMsg = wfMessage(
4674                         $format['noabbrevs'] ? 'days' : 'days-abbrev' )->inLanguage( $this );
4675
4676                 if ( round( $seconds * 10 ) < 100 ) {
4677                         $s = $this->formatNum( sprintf( "%.1f", round( $seconds * 10 ) / 10 ) );
4678                         $s = $secondsMsg->params( $s )->text();
4679                 } elseif ( round( $seconds ) < 60 ) {
4680                         $s = $this->formatNum( round( $seconds ) );
4681                         $s = $secondsMsg->params( $s )->text();
4682                 } elseif ( round( $seconds ) < 3600 ) {
4683                         $minutes = floor( $seconds / 60 );
4684                         $secondsPart = round( fmod( $seconds, 60 ) );
4685                         if ( $secondsPart == 60 ) {
4686                                 $secondsPart = 0;
4687                                 $minutes++;
4688                         }
4689                         $s = $minutesMsg->params( $this->formatNum( $minutes ) )->text();
4690                         $s .= ' ';
4691                         $s .= $secondsMsg->params( $this->formatNum( $secondsPart ) )->text();
4692                 } elseif ( round( $seconds ) <= 2 * 86400 ) {
4693                         $hours = floor( $seconds / 3600 );
4694                         $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
4695                         $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
4696                         if ( $secondsPart == 60 ) {
4697                                 $secondsPart = 0;
4698                                 $minutes++;
4699                         }
4700                         if ( $minutes == 60 ) {
4701                                 $minutes = 0;
4702                                 $hours++;
4703                         }
4704                         $s = $hoursMsg->params( $this->formatNum( $hours ) )->text();
4705                         $s .= ' ';
4706                         $s .= $minutesMsg->params( $this->formatNum( $minutes ) )->text();
4707                         if ( !in_array( $format['avoid'], array( 'avoidseconds', 'avoidminutes' ) ) ) {
4708                                 $s .= ' ' . $secondsMsg->params( $this->formatNum( $secondsPart ) )->text();
4709                         }
4710                 } else {
4711                         $days = floor( $seconds / 86400 );
4712                         if ( $format['avoid'] === 'avoidminutes' ) {
4713                                 $hours = round( ( $seconds - $days * 86400 ) / 3600 );
4714                                 if ( $hours == 24 ) {
4715                                         $hours = 0;
4716                                         $days++;
4717                                 }
4718                                 $s = $daysMsg->params( $this->formatNum( $days ) )->text();
4719                                 $s .= ' ';
4720                                 $s .= $hoursMsg->params( $this->formatNum( $hours ) )->text();
4721                         } elseif ( $format['avoid'] === 'avoidseconds' ) {
4722                                 $hours = floor( ( $seconds - $days * 86400 ) / 3600 );
4723                                 $minutes = round( ( $seconds - $days * 86400 - $hours * 3600 ) / 60 );
4724                                 if ( $minutes == 60 ) {
4725                                         $minutes = 0;
4726                                         $hours++;
4727                                 }
4728                                 if ( $hours == 24 ) {
4729                                         $hours = 0;
4730                                         $days++;
4731                                 }
4732                                 $s = $daysMsg->params( $this->formatNum( $days ) )->text();
4733                                 $s .= ' ';
4734                                 $s .= $hoursMsg->params( $this->formatNum( $hours ) )->text();
4735                                 $s .= ' ';
4736                                 $s .= $minutesMsg->params( $this->formatNum( $minutes ) )->text();
4737                         } else {
4738                                 $s = $daysMsg->params( $this->formatNum( $days ) )->text();
4739                                 $s .= ' ';
4740                                 $s .= $this->formatTimePeriod( $seconds - $days * 86400, $format );
4741                         }
4742                 }
4743                 return $s;
4744         }
4745
4746         /**
4747          * Format a bitrate for output, using an appropriate
4748          * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to
4749          *   the magnitude in question.
4750          *
4751          * This use base 1000. For base 1024 use formatSize(), for another base
4752          * see formatComputingNumbers().
4753          *
4754          * @param int $bps
4755          * @return string
4756          */
4757         function formatBitrate( $bps ) {
4758                 return $this->formatComputingNumbers( $bps, 1000, "bitrate-$1bits" );
4759         }
4760
4761         /**
4762          * @param int $size Size of the unit
4763          * @param int $boundary Size boundary (1000, or 1024 in most cases)
4764          * @param string $messageKey Message key to be uesd
4765          * @return string
4766          */
4767         function formatComputingNumbers( $size, $boundary, $messageKey ) {
4768                 if ( $size <= 0 ) {
4769                         return str_replace( '$1', $this->formatNum( $size ),
4770                                 $this->getMessageFromDB( str_replace( '$1', '', $messageKey ) )
4771                         );
4772                 }
4773                 $sizes = array( '', 'kilo', 'mega', 'giga', 'tera', 'peta', 'exa', 'zeta', 'yotta' );
4774                 $index = 0;
4775
4776                 $maxIndex = count( $sizes ) - 1;
4777                 while ( $size >= $boundary && $index < $maxIndex ) {
4778                         $index++;
4779                         $size /= $boundary;
4780                 }
4781
4782                 // For small sizes no decimal places necessary
4783                 $round = 0;
4784                 if ( $index > 1 ) {
4785                         // For MB and bigger two decimal places are smarter
4786                         $round = 2;
4787                 }
4788                 $msg = str_replace( '$1', $sizes[$index], $messageKey );
4789
4790                 $size = round( $size, $round );
4791                 $text = $this->getMessageFromDB( $msg );
4792                 return str_replace( '$1', $this->formatNum( $size ), $text );
4793         }
4794
4795         /**
4796          * Format a size in bytes for output, using an appropriate
4797          * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4798          *
4799          * This method use base 1024. For base 1000 use formatBitrate(), for
4800          * another base see formatComputingNumbers()
4801          *
4802          * @param int $size Size to format
4803          * @return string Plain text (not HTML)
4804          */
4805         function formatSize( $size ) {
4806                 return $this->formatComputingNumbers( $size, 1024, "size-$1bytes" );
4807         }
4808
4809         /**
4810          * Make a list item, used by various special pages
4811          *
4812          * @param string $page Page link
4813          * @param string $details HTML safe text between brackets
4814          * @param bool $oppositedm Add the direction mark opposite to your
4815          *   language, to display text properly
4816          * @return HTML escaped string
4817          */
4818         function specialList( $page, $details, $oppositedm = true ) {
4819                 if ( !$details ) {
4820                         return $page;
4821                 }
4822
4823                 $dirmark = ( $oppositedm ? $this->getDirMark( true ) : '' ) . $this->getDirMark();
4824                 return
4825                         $page .
4826                         $dirmark .
4827                         $this->msg( 'word-separator' )->escaped() .
4828                         $this->msg( 'parentheses' )->rawParams( $details )->escaped();
4829         }
4830
4831         /**
4832          * Generate (prev x| next x) (20|50|100...) type links for paging
4833          *
4834          * @param Title $title Title object to link
4835          * @param int $offset
4836          * @param int $limit
4837          * @param array $query Optional URL query parameter string
4838          * @param bool $atend Optional param for specified if this is the last page
4839          * @return string
4840          */
4841         public function viewPrevNext( Title $title, $offset, $limit,
4842                 array $query = array(), $atend = false
4843         ) {
4844                 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4845
4846                 # Make 'previous' link
4847                 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4848                 if ( $offset > 0 ) {
4849                         $plink = $this->numLink( $title, max( $offset - $limit, 0 ), $limit,
4850                                 $query, $prev, 'prevn-title', 'mw-prevlink' );
4851                 } else {
4852                         $plink = htmlspecialchars( $prev );
4853                 }
4854
4855                 # Make 'next' link
4856                 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4857                 if ( $atend ) {
4858                         $nlink = htmlspecialchars( $next );
4859                 } else {
4860                         $nlink = $this->numLink( $title, $offset + $limit, $limit,
4861                                 $query, $next, 'nextn-title', 'mw-nextlink' );
4862                 }
4863
4864                 # Make links to set number of items per page
4865                 $numLinks = array();
4866                 foreach ( array( 20, 50, 100, 250, 500 ) as $num ) {
4867                         $numLinks[] = $this->numLink( $title, $offset, $num,
4868                                 $query, $this->formatNum( $num ), 'shown-title', 'mw-numlink' );
4869                 }
4870
4871                 return wfMessage( 'viewprevnext' )->inLanguage( $this )->title( $title
4872                         )->rawParams( $plink, $nlink, $this->pipeList( $numLinks ) )->escaped();
4873         }
4874
4875         /**
4876          * Helper function for viewPrevNext() that generates links
4877          *
4878          * @param Title $title Title object to link
4879          * @param int $offset
4880          * @param int $limit
4881          * @param array $query Extra query parameters
4882          * @param string $link Text to use for the link; will be escaped
4883          * @param string $tooltipMsg Name of the message to use as tooltip
4884          * @param string $class Value of the "class" attribute of the link
4885          * @return string HTML fragment
4886          */
4887         private function numLink( Title $title, $offset, $limit, array $query, $link,
4888                 $tooltipMsg, $class
4889         ) {
4890                 $query = array( 'limit' => $limit, 'offset' => $offset ) + $query;
4891                 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )
4892                         ->numParams( $limit )->text();
4893
4894                 return Html::element( 'a', array( 'href' => $title->getLocalURL( $query ),
4895                         'title' => $tooltip, 'class' => $class ), $link );
4896         }
4897
4898         /**
4899          * Get the conversion rule title, if any.
4900          *
4901          * @return string
4902          */
4903         public function getConvRuleTitle() {
4904                 return $this->mConverter->getConvRuleTitle();
4905         }
4906
4907         /**
4908          * Get the compiled plural rules for the language
4909          * @since 1.20
4910          * @return array Associative array with plural form, and plural rule as key-value pairs
4911          */
4912         public function getCompiledPluralRules() {
4913                 $pluralRules = self::$dataCache->getItem( strtolower( $this->mCode ), 'compiledPluralRules' );
4914                 $fallbacks = Language::getFallbacksFor( $this->mCode );
4915                 if ( !$pluralRules ) {
4916                         foreach ( $fallbacks as $fallbackCode ) {
4917                                 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4918                                 if ( $pluralRules ) {
4919                                         break;
4920                                 }
4921                         }
4922                 }
4923                 return $pluralRules;
4924         }
4925
4926         /**
4927          * Get the plural rules for the language
4928          * @since 1.20
4929          * @return array Associative array with plural form number and plural rule as key-value pairs
4930          */
4931         public function getPluralRules() {
4932                 $pluralRules = self::$dataCache->getItem( strtolower( $this->mCode ), 'pluralRules' );
4933                 $fallbacks = Language::getFallbacksFor( $this->mCode );
4934                 if ( !$pluralRules ) {
4935                         foreach ( $fallbacks as $fallbackCode ) {
4936                                 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRules' );
4937                                 if ( $pluralRules ) {
4938                                         break;
4939                                 }
4940                         }
4941                 }
4942                 return $pluralRules;
4943         }
4944
4945         /**
4946          * Get the plural rule types for the language
4947          * @since 1.22
4948          * @return array Associative array with plural form number and plural rule type as key-value pairs
4949          */
4950         public function getPluralRuleTypes() {
4951                 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $this->mCode ), 'pluralRuleTypes' );
4952                 $fallbacks = Language::getFallbacksFor( $this->mCode );
4953                 if ( !$pluralRuleTypes ) {
4954                         foreach ( $fallbacks as $fallbackCode ) {
4955                                 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4956                                 if ( $pluralRuleTypes ) {
4957                                         break;
4958                                 }
4959                         }
4960                 }
4961                 return $pluralRuleTypes;
4962         }
4963
4964         /**
4965          * Find the index number of the plural rule appropriate for the given number
4966          * @param int $number
4967          * @return int The index number of the plural rule
4968          */
4969         public function getPluralRuleIndexNumber( $number ) {
4970                 $pluralRules = $this->getCompiledPluralRules();
4971                 $form = CLDRPluralRuleEvaluator::evaluateCompiled( $number, $pluralRules );
4972                 return $form;
4973         }
4974
4975         /**
4976          * Find the plural rule type appropriate for the given number
4977          * For example, if the language is set to Arabic, getPluralType(5) should
4978          * return 'few'.
4979          * @since 1.22
4980          * @param int $number
4981          * @return string The name of the plural rule type, e.g. one, two, few, many
4982          */
4983         public function getPluralRuleType( $number ) {
4984                 $index = $this->getPluralRuleIndexNumber( $number );
4985                 $pluralRuleTypes = $this->getPluralRuleTypes();
4986                 if ( isset( $pluralRuleTypes[$index] ) ) {
4987                         return $pluralRuleTypes[$index];
4988                 } else {
4989                         return 'other';
4990                 }
4991         }
4992 }