languages/Language.php

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