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