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