languages/Language.php

   1 <?php
   2 /**
   3  * Internationalisation code
   4  *
   5  * @file
   6  * @ingroup Language
   7  */
   8
   9 /**
  10  * @defgroup Language Language
  11  */
  12
  13 if ( !defined( 'MEDIAWIKI' ) ) {
  14         echo "This file is part of MediaWiki, it is not a valid entry point.\n";
  15         exit( 1 );
  16 }
  17
  18 # Read language names
  19 global $wgLanguageNames;
  20 require_once( dirname( __FILE__ ) . '/Names.php' );
  21
  22 if ( function_exists( 'mb_strtoupper' ) ) {
  23         mb_internal_encoding( 'UTF-8' );
  24 }
  25
  26 /**
  27  * a fake language converter
  28  *
  29  * @ingroup Language
  30  */
  31 class FakeConverter {
  32         var $mLang;
  33         function __construct( $langobj ) { $this->mLang = $langobj; }
  34         function autoConvertToAllVariants( $text ) { return array( $this->mLang->getCode() => $text ); }
  35         function convert( $t ) { return $t; }
  36         function convertTitle( $t ) { return $t->getPrefixedText(); }
  37         function getVariants() { return array( $this->mLang->getCode() ); }
  38         function getPreferredVariant() { return $this->mLang->getCode(); }
  39         function getDefaultVariant() { return $this->mLang->getCode(); }
  40         function getURLVariant() { return ''; }
  41         function getConvRuleTitle() { return false; }
  42         function findVariantLink( &$l, &$n, $ignoreOtherCond = false ) { }
  43         function getExtraHashOptions() { return ''; }
  44         function getParsedTitle() { return ''; }
  45         function markNoConversion( $text, $noParse = false ) { return $text; }
  46         function convertCategoryKey( $key ) { return $key; }
  47         function convertLinkToAllVariants( $text ) { return $this->autoConvertToAllVariants( $text ); }
  48         function armourMath( $text ) { return $text; }
  49 }
  50
  51 /**
  52  * Internationalisation code
  53  * @ingroup Language
  54  */
  55 class Language {
  56
  57         /**
  58          * @var LanguageConverter
  59          */
  60         var $mConverter;
  61
  62         var $mVariants, $mCode, $mLoaded = false;
  63         var $mMagicExtensions = array(), $mMagicHookDone = false;
  64
  65         var $mNamespaceIds, $namespaceNames, $namespaceAliases;
  66         var $dateFormatStrings = array();
  67         var $mExtendedSpecialPageAliases;
  68
  69         /**
  70          * ReplacementArray object caches
  71          */
  72         var $transformData = array();
  73
  74         /**
  75          * @var LocalisationCache
  76          */
  77         static public $dataCache;
  78
  79         static public $mLangObjCache = array();
  80
  81         static public $mWeekdayMsgs = array(
  82                 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
  83                 'friday', 'saturday'
  84         );
  85
  86         static public $mWeekdayAbbrevMsgs = array(
  87                 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'
  88         );
  89
  90         static public $mMonthMsgs = array(
  91                 'january', 'february', 'march', 'april', 'may_long', 'june',
  92                 'july', 'august', 'september', 'october', 'november',
  93                 'december'
  94         );
  95         static public $mMonthGenMsgs = array(
  96                 'january-gen', 'february-gen', 'march-gen', 'april-gen', 'may-gen', 'june-gen',
  97                 'july-gen', 'august-gen', 'september-gen', 'october-gen', 'november-gen',
  98                 'december-gen'
  99         );
 100         static public $mMonthAbbrevMsgs = array(
 101                 'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
 102                 'sep', 'oct', 'nov', 'dec'
 103         );
 104
 105         static public $mIranianCalendarMonthMsgs = array(
 106                 'iranian-calendar-m1', 'iranian-calendar-m2', 'iranian-calendar-m3',
 107                 'iranian-calendar-m4', 'iranian-calendar-m5', 'iranian-calendar-m6',
 108                 'iranian-calendar-m7', 'iranian-calendar-m8', 'iranian-calendar-m9',
 109                 'iranian-calendar-m10', 'iranian-calendar-m11', 'iranian-calendar-m12'
 110         );
 111
 112         static public $mHebrewCalendarMonthMsgs = array(
 113                 'hebrew-calendar-m1', 'hebrew-calendar-m2', 'hebrew-calendar-m3',
 114                 'hebrew-calendar-m4', 'hebrew-calendar-m5', 'hebrew-calendar-m6',
 115                 'hebrew-calendar-m7', 'hebrew-calendar-m8', 'hebrew-calendar-m9',
 116                 'hebrew-calendar-m10', 'hebrew-calendar-m11', 'hebrew-calendar-m12',
 117                 'hebrew-calendar-m6a', 'hebrew-calendar-m6b'
 118         );
 119
 120         static public $mHebrewCalendarMonthGenMsgs = array(
 121                 'hebrew-calendar-m1-gen', 'hebrew-calendar-m2-gen', 'hebrew-calendar-m3-gen',
 122                 'hebrew-calendar-m4-gen', 'hebrew-calendar-m5-gen', 'hebrew-calendar-m6-gen',
 123                 'hebrew-calendar-m7-gen', 'hebrew-calendar-m8-gen', 'hebrew-calendar-m9-gen',
 124                 'hebrew-calendar-m10-gen', 'hebrew-calendar-m11-gen', 'hebrew-calendar-m12-gen',
 125                 'hebrew-calendar-m6a-gen', 'hebrew-calendar-m6b-gen'
 126         );
 127
 128         static public $mHijriCalendarMonthMsgs = array(
 129                 'hijri-calendar-m1', 'hijri-calendar-m2', 'hijri-calendar-m3',
 130                 'hijri-calendar-m4', 'hijri-calendar-m5', 'hijri-calendar-m6',
 131                 'hijri-calendar-m7', 'hijri-calendar-m8', 'hijri-calendar-m9',
 132                 'hijri-calendar-m10', 'hijri-calendar-m11', 'hijri-calendar-m12'
 133         );
 134
 135         /**
 136          * Get a cached language object for a given language code
 137          * @param $code String
 138          * @return Language
 139          */
 140         static function factory( $code ) {
 141                 if ( !isset( self::$mLangObjCache[$code] ) ) {
 142                         if ( count( self::$mLangObjCache ) > 10 ) {
 143                                 // Don't keep a billion objects around, that's stupid.
 144                                 self::$mLangObjCache = array();
 145                         }
 146                         self::$mLangObjCache[$code] = self::newFromCode( $code );
 147                 }
 148                 return self::$mLangObjCache[$code];
 149         }
 150
 151         /**
 152          * Create a language object for a given language code
 153          * @param $code String
 154          * @return Language
 155          */
 156         protected static function newFromCode( $code ) {
 157                 // Protect against path traversal below
 158                 if ( !Language::isValidCode( $code )
 159                         || strcspn( $code, ":/\\\000" ) !== strlen( $code ) )
 160                 {
 161                         throw new MWException( "Invalid language code \"$code\"" );
 162                 }
 163
 164                 if ( !Language::isValidBuiltInCode( $code ) ) {
 165                         // It's not possible to customise this code with class files, so
 166                         // just return a Language object. This is to support uselang= hacks.
 167                         $lang = new Language;
 168                         $lang->setCode( $code );
 169                         return $lang;
 170                 }
 171
 172                 // Check if there is a language class for the code
 173                 $class = self::classFromCode( $code );
 174                 self::preloadLanguageClass( $class );
 175                 if ( MWInit::classExists( $class ) ) {
 176                         $lang = new $class;
 177                         return $lang;
 178                 }
 179
 180                 // Keep trying the fallback list until we find an existing class
 181                 $fallbacks = Language::getFallbacksFor( $code );
 182                 foreach ( $fallbacks as $fallbackCode ) {
 183                         if ( !Language::isValidBuiltInCode( $fallbackCode ) ) {
 184                                 throw new MWException( "Invalid fallback '$fallbackCode' in fallback sequence for '$code'" );
 185                         }
 186
 187                         $class = self::classFromCode( $fallbackCode );
 188                         self::preloadLanguageClass( $class );
 189                         if ( MWInit::classExists( $class ) ) {
 190                                 $lang = Language::newFromCode( $fallbackCode );
 191                                 $lang->setCode( $code );
 192                                 return $lang;
 193                         }
 194                 }
 195
 196                 throw new MWException( "Invalid fallback sequence for language '$code'" );
 197         }
 198
 199         /**
 200          * Returns true if a language code string is of a valid form, whether or
 201          * not it exists. This includes codes which are used solely for
 202          * customisation via the MediaWiki namespace.
 203          *
 204          * @param $code string
 205          *
 206          * @return bool
 207          */
 208         public static function isValidCode( $code ) {
 209                 return
 210                         strcspn( $code, ":/\\\000" ) === strlen( $code )
 211                         && !preg_match( Title::getTitleInvalidRegex(), $code );
 212         }
 213
 214         /**
 215          * Returns true if a language code is of a valid form for the purposes of
 216          * internal customisation of MediaWiki, via Messages*.php.
 217          *
 218          * @param $code string
 219          *
 220          * @since 1.18
 221          * @return bool
 222          */
 223         public static function isValidBuiltInCode( $code ) {
 224                 return preg_match( '/^[a-z0-9-]+$/i', $code );
 225         }
 226
 227         /**
 228          * @param $code
 229          * @return String Name of the language class
 230          */
 231         public static function classFromCode( $code ) {
 232                 if ( $code == 'en' ) {
 233                         return 'Language';
 234                 } else {
 235                         return 'Language' . str_replace( '-', '_', ucfirst( $code ) );
 236                 }
 237         }
 238
 239         /**
 240          * Includes language class files
 241          *
 242          * @param $class Name of the language class
 243          */
 244         public static function preloadLanguageClass( $class ) {
 245                 global $IP;
 246
 247                 if ( $class === 'Language' ) {
 248                         return;
 249                 }
 250
 251                 if ( !defined( 'MW_COMPILED' ) ) {
 252                         // Preload base classes to work around APC/PHP5 bug
 253                         if ( file_exists( "$IP/languages/classes/$class.deps.php" ) ) {
 254                                 include_once( "$IP/languages/classes/$class.deps.php" );
 255                         }
 256                         if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
 257                                 include_once( "$IP/languages/classes/$class.php" );
 258                         }
 259                 }
 260         }
 261
 262         /**
 263          * Get the LocalisationCache instance
 264          *
 265          * @return LocalisationCache
 266          */
 267         public static function getLocalisationCache() {
 268                 if ( is_null( self::$dataCache ) ) {
 269                         global $wgLocalisationCacheConf;
 270                         $class = $wgLocalisationCacheConf['class'];
 271                         self::$dataCache = new $class( $wgLocalisationCacheConf );
 272                 }
 273                 return self::$dataCache;
 274         }
 275
 276         function __construct() {
 277                 $this->mConverter = new FakeConverter( $this );
 278                 // Set the code to the name of the descendant
 279                 if ( get_class( $this ) == 'Language' ) {
 280                         $this->mCode = 'en';
 281                 } else {
 282                         $this->mCode = str_replace( '_', '-', strtolower( substr( get_class( $this ), 8 ) ) );
 283                 }
 284                 self::getLocalisationCache();
 285         }
 286
 287         /**
 288          * Reduce memory usage
 289          */
 290         function __destruct() {
 291                 foreach ( $this as $name => $value ) {
 292                         unset( $this->$name );
 293                 }
 294         }
 295
 296         /**
 297          * Hook which will be called if this is the content language.
 298          * Descendants can use this to register hook functions or modify globals
 299          */
 300         function initContLang() { }
 301
 302         /**
 303          * Same as getFallbacksFor for current language.
 304          * @return array|bool
 305          * @deprecated in 1.19
 306          */
 307         function getFallbackLanguageCode() {
 308                 wfDeprecated( __METHOD__ );
 309                 return self::getFallbackFor( $this->mCode );
 310         }
 311
 312         /**
 313          * @return array
 314          * @since 1.19
 315          */
 316         function getFallbackLanguages() {
 317                 return self::getFallbacksFor( $this->mCode );
 318         }
 319
 320         /**
 321          * Exports $wgBookstoreListEn
 322          * @return array
 323          */
 324         function getBookstoreList() {
 325                 return self::$dataCache->getItem( $this->mCode, 'bookstoreList' );
 326         }
 327
 328         /**
 329          * @return array
 330          */
 331         function getNamespaces() {
 332                 if ( is_null( $this->namespaceNames ) ) {
 333                         global $wgMetaNamespace, $wgMetaNamespaceTalk, $wgExtraNamespaces;
 334
 335                         $this->namespaceNames = self::$dataCache->getItem( $this->mCode, 'namespaceNames' );
 336                         $validNamespaces = MWNamespace::getCanonicalNamespaces();
 337
 338                         $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames + $validNamespaces;
 339
 340                         $this->namespaceNames[NS_PROJECT] = $wgMetaNamespace;
 341                         if ( $wgMetaNamespaceTalk ) {
 342                                 $this->namespaceNames[NS_PROJECT_TALK] = $wgMetaNamespaceTalk;
 343                         } else {
 344                                 $talk = $this->namespaceNames[NS_PROJECT_TALK];
 345                                 $this->namespaceNames[NS_PROJECT_TALK] =
 346                                         $this->fixVariableInNamespace( $talk );
 347                         }
 348
 349                         # Sometimes a language will be localised but not actually exist on this wiki.
 350                         foreach ( $this->namespaceNames as $key => $text ) {
 351                                 if ( !isset( $validNamespaces[$key] ) ) {
 352                                         unset( $this->namespaceNames[$key] );
 353                                 }
 354                         }
 355
 356                         # The above mixing may leave namespaces out of canonical order.
 357                         # Re-order by namespace ID number...
 358                         ksort( $this->namespaceNames );
 359
 360                         wfRunHooks( 'LanguageGetNamespaces', array( &$this->namespaceNames ) );
 361                 }
 362                 return $this->namespaceNames;
 363         }
 364
 365         /**
 366          * A convenience function that returns the same thing as
 367          * getNamespaces() except with the array values changed to ' '
 368          * where it found '_', useful for producing output to be displayed
 369          * e.g. in <select> forms.
 370          *
 371          * @return array
 372          */
 373         function getFormattedNamespaces() {
 374                 $ns = $this->getNamespaces();
 375                 foreach ( $ns as $k => $v ) {
 376                         $ns[$k] = strtr( $v, '_', ' ' );
 377                 }
 378                 return $ns;
 379         }
 380
 381         /**
 382          * Get a namespace value by key
 383          * <code>
 384          * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
 385          * echo $mw_ns; // prints 'MediaWiki'
 386          * </code>
 387          *
 388          * @param $index Int: the array key of the namespace to return
 389          * @return mixed, string if the namespace value exists, otherwise false
 390          */
 391         function getNsText( $index ) {
 392                 $ns = $this->getNamespaces();
 393                 return isset( $ns[$index] ) ? $ns[$index] : false;
 394         }
 395
 396         /**
 397          * A convenience function that returns the same thing as
 398          * getNsText() except with '_' changed to ' ', useful for
 399          * producing output.
 400          *
 401          * @param $index string
 402          *
 403          * @return array
 404          */
 405         function getFormattedNsText( $index ) {
 406                 $ns = $this->getNsText( $index );
 407                 return strtr( $ns, '_', ' ' );
 408         }
 409
 410         /**
 411          * Returns gender-dependent namespace alias if available.
 412          * @param $index Int: namespace index
 413          * @param $gender String: gender key (male, female... )
 414          * @return String
 415          * @since 1.18
 416          */
 417         function getGenderNsText( $index, $gender ) {
 418                 global $wgExtraGenderNamespaces;
 419
 420                 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
 421                 return isset( $ns[$index][$gender] ) ? $ns[$index][$gender] : $this->getNsText( $index );
 422         }
 423
 424         /**
 425          * Whether this language makes distinguishes genders for example in
 426          * namespaces.
 427          * @return bool
 428          * @since 1.18
 429          */
 430         function needsGenderDistinction() {
 431                 global $wgExtraGenderNamespaces, $wgExtraNamespaces;
 432                 if ( count( $wgExtraGenderNamespaces ) > 0 ) {
 433                         // $wgExtraGenderNamespaces overrides everything
 434                         return true;
 435                 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
 436                         /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
 437                         // $wgExtraNamespaces overrides any gender aliases specified in i18n files
 438                         return false;
 439                 } else {
 440                         // Check what is in i18n files
 441                         $aliases = self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
 442                         return count( $aliases ) > 0;
 443                 }
 444         }
 445
 446         /**
 447          * Get a namespace key by value, case insensitive.
 448          * Only matches namespace names for the current language, not the
 449          * canonical ones defined in Namespace.php.
 450          *
 451          * @param $text String
 452          * @return mixed An integer if $text is a valid value otherwise false
 453          */
 454         function getLocalNsIndex( $text ) {
 455                 $lctext = $this->lc( $text );
 456                 $ids = $this->getNamespaceIds();
 457                 return isset( $ids[$lctext] ) ? $ids[$lctext] : false;
 458         }
 459
 460         /**
 461          * @return array
 462          */
 463         function getNamespaceAliases() {
 464                 if ( is_null( $this->namespaceAliases ) ) {
 465                         $aliases = self::$dataCache->getItem( $this->mCode, 'namespaceAliases' );
 466                         if ( !$aliases ) {
 467                                 $aliases = array();
 468                         } else {
 469                                 foreach ( $aliases as $name => $index ) {
 470                                         if ( $index === NS_PROJECT_TALK ) {
 471                                                 unset( $aliases[$name] );
 472                                                 $name = $this->fixVariableInNamespace( $name );
 473                                                 $aliases[$name] = $index;
 474                                         }
 475                                 }
 476                         }
 477
 478                         global $wgExtraGenderNamespaces;
 479                         $genders = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
 480                         foreach ( $genders as $index => $forms ) {
 481                                 foreach ( $forms as $alias ) {
 482                                         $aliases[$alias] = $index;
 483                                 }
 484                         }
 485
 486                         $this->namespaceAliases = $aliases;
 487                 }
 488                 return $this->namespaceAliases;
 489         }
 490
 491         /**
 492          * @return array
 493          */
 494         function getNamespaceIds() {
 495                 if ( is_null( $this->mNamespaceIds ) ) {
 496                         global $wgNamespaceAliases;
 497                         # Put namespace names and aliases into a hashtable.
 498                         # If this is too slow, then we should arrange it so that it is done
 499                         # before caching. The catch is that at pre-cache time, the above
 500                         # class-specific fixup hasn't been done.
 501                         $this->mNamespaceIds = array();
 502                         foreach ( $this->getNamespaces() as $index => $name ) {
 503                                 $this->mNamespaceIds[$this->lc( $name )] = $index;
 504                         }
 505                         foreach ( $this->getNamespaceAliases() as $name => $index ) {
 506                                 $this->mNamespaceIds[$this->lc( $name )] = $index;
 507                         }
 508                         if ( $wgNamespaceAliases ) {
 509                                 foreach ( $wgNamespaceAliases as $name => $index ) {
 510                                         $this->mNamespaceIds[$this->lc( $name )] = $index;
 511                                 }
 512                         }
 513                 }
 514                 return $this->mNamespaceIds;
 515         }
 516
 517         /**
 518          * Get a namespace key by value, case insensitive.  Canonical namespace
 519          * names override custom ones defined for the current language.
 520          *
 521          * @param $text String
 522          * @return mixed An integer if $text is a valid value otherwise false
 523          */
 524         function getNsIndex( $text ) {
 525                 $lctext = $this->lc( $text );
 526                 $ns = MWNamespace::getCanonicalIndex( $lctext );
 527                 if ( $ns !== null ) {
 528                         return $ns;
 529                 }
 530                 $ids = $this->getNamespaceIds();
 531                 return isset( $ids[$lctext] ) ? $ids[$lctext] : false;
 532         }
 533
 534         /**
 535          * short names for language variants used for language conversion links.
 536          *
 537          * @param $code String
 538          * @param $usemsg bool Use the "variantname-xyz" message if it exists
 539          * @return string
 540          */
 541         function getVariantname( $code, $usemsg = true ) {
 542                 $msg = "variantname-$code";
 543                 list( $rootCode ) = explode( '-', $code );
 544                 if ( $usemsg && wfMessage( $msg )->exists() ) {
 545                         return $this->getMessageFromDB( $msg );
 546                 }
 547                 $name = self::getLanguageName( $code );
 548                 if ( $name ) {
 549                         return $name; # if it's defined as a language name, show that
 550                 } else {
 551                         # otherwise, output the language code
 552                         return $code;
 553                 }
 554         }
 555
 556         /**
 557          * @param $name string
 558          * @return string
 559          */
 560         function specialPage( $name ) {
 561                 $aliases = $this->getSpecialPageAliases();
 562                 if ( isset( $aliases[$name][0] ) ) {
 563                         $name = $aliases[$name][0];
 564                 }
 565                 return $this->getNsText( NS_SPECIAL ) . ':' . $name;
 566         }
 567
 568         /**
 569          * @return array
 570          */
 571         function getQuickbarSettings() {
 572                 return array(
 573                         $this->getMessage( 'qbsettings-none' ),
 574                         $this->getMessage( 'qbsettings-fixedleft' ),
 575                         $this->getMessage( 'qbsettings-fixedright' ),
 576                         $this->getMessage( 'qbsettings-floatingleft' ),
 577                         $this->getMessage( 'qbsettings-floatingright' ),
 578                         $this->getMessage( 'qbsettings-directionality' )
 579                 );
 580         }
 581
 582         /**
 583          * @return array
 584          */
 585         function getDatePreferences() {
 586                 return self::$dataCache->getItem( $this->mCode, 'datePreferences' );
 587         }
 588
 589         /**
 590          * @return array
 591          */
 592         function getDateFormats() {
 593                 return self::$dataCache->getItem( $this->mCode, 'dateFormats' );
 594         }
 595
 596         /**
 597          * @return array|string
 598          */
 599         function getDefaultDateFormat() {
 600                 $df = self::$dataCache->getItem( $this->mCode, 'defaultDateFormat' );
 601                 if ( $df === 'dmy or mdy' ) {
 602                         global $wgAmericanDates;
 603                         return $wgAmericanDates ? 'mdy' : 'dmy';
 604                 } else {
 605                         return $df;
 606                 }
 607         }
 608
 609         /**
 610          * @return array
 611          */
 612         function getDatePreferenceMigrationMap() {
 613                 return self::$dataCache->getItem( $this->mCode, 'datePreferenceMigrationMap' );
 614         }
 615
 616         /**
 617          * @param  $image
 618          * @return array|null
 619          */
 620         function getImageFile( $image ) {
 621                 return self::$dataCache->getSubitem( $this->mCode, 'imageFiles', $image );
 622         }
 623
 624         /**
 625          * @return array
 626          */
 627         function getExtraUserToggles() {
 628                 return self::$dataCache->getItem( $this->mCode, 'extraUserToggles' );
 629         }
 630
 631         /**
 632          * @param  $tog
 633          * @return string
 634          */
 635         function getUserToggle( $tog ) {
 636                 return $this->getMessageFromDB( "tog-$tog" );
 637         }
 638
 639         /**
 640          * Get language names, indexed by code.
 641          * If $customisedOnly is true, only returns codes with a messages file
 642          *
 643          * @param $customisedOnly bool
 644          *
 645          * @return array
 646          */
 647         public static function getLanguageNames( $customisedOnly = false ) {
 648                 global $wgExtraLanguageNames;
 649                 static $coreLanguageNames;
 650
 651                 if ( $coreLanguageNames === null ) {
 652                         include( MWInit::compiledPath( 'languages/Names.php' ) );
 653                 }
 654
 655                 $allNames = $wgExtraLanguageNames + $coreLanguageNames;
 656                 if ( !$customisedOnly ) {
 657                         return $allNames;
 658                 }
 659
 660                 global $IP;
 661                 $names = array();
 662                 $dir = opendir( "$IP/languages/messages" );
 663                 while ( false !== ( $file = readdir( $dir ) ) ) {
 664                         $code = self::getCodeFromFileName( $file, 'Messages' );
 665                         if ( $code && isset( $allNames[$code] ) ) {
 666                                 $names[$code] = $allNames[$code];
 667                         }
 668                 }
 669                 closedir( $dir );
 670                 return $names;
 671         }
 672
 673         /**
 674          * Get translated language names. This is done on best effort and
 675          * by default this is exactly the same as Language::getLanguageNames.
 676          * The CLDR extension provides translated names.
 677          * @param $code String Language code.
 678          * @return Array language code => language name
 679          * @since 1.18.0
 680          */
 681         public static function getTranslatedLanguageNames( $code ) {
 682                 $names = array();
 683                 wfRunHooks( 'LanguageGetTranslatedLanguageNames', array( &$names, $code ) );
 684
 685                 foreach ( self::getLanguageNames() as $code => $name ) {
 686                         if ( !isset( $names[$code] ) ) $names[$code] = $name;
 687                 }
 688
 689                 return $names;
 690         }
 691
 692         /**
 693          * Get a message from the MediaWiki namespace.
 694          *
 695          * @param $msg String: message name
 696          * @return string
 697          */
 698         function getMessageFromDB( $msg ) {
 699                 return wfMsgExt( $msg, array( 'parsemag', 'language' => $this ) );
 700         }
 701
 702         /**
 703          * @param $code string
 704          * @return string
 705          */
 706         function getLanguageName( $code ) {
 707                 $names = self::getLanguageNames();
 708                 if ( !array_key_exists( $code, $names ) ) {
 709                         return '';
 710                 }
 711                 return $names[$code];
 712         }
 713
 714         /**
 715          * @param $key string
 716          * @return string
 717          */
 718         function getMonthName( $key ) {
 719                 return $this->getMessageFromDB( self::$mMonthMsgs[$key - 1] );
 720         }
 721
 722         /**
 723          * @return array
 724          */
 725         function getMonthNamesArray() {
 726                 $monthNames = array( '' );
 727                 for ( $i = 1; $i < 13; $i++ ) {
 728                         $monthNames[] = $this->getMonthName( $i );
 729                 }
 730                 return $monthNames;
 731         }
 732
 733         /**
 734          * @param $key string
 735          * @return string
 736          */
 737         function getMonthNameGen( $key ) {
 738                 return $this->getMessageFromDB( self::$mMonthGenMsgs[$key - 1] );
 739         }
 740
 741         /**
 742          * @param $key string
 743          * @return string
 744          */
 745         function getMonthAbbreviation( $key ) {
 746                 return $this->getMessageFromDB( self::$mMonthAbbrevMsgs[$key - 1] );
 747         }
 748
 749         /**
 750          * @return array
 751          */
 752         function getMonthAbbreviationsArray() {
 753                 $monthNames = array( '' );
 754                 for ( $i = 1; $i < 13; $i++ ) {
 755                         $monthNames[] = $this->getMonthAbbreviation( $i );
 756                 }
 757                 return $monthNames;
 758         }
 759
 760         /**
 761          * @param $key string
 762          * @return string
 763          */
 764         function getWeekdayName( $key ) {
 765                 return $this->getMessageFromDB( self::$mWeekdayMsgs[$key - 1] );
 766         }
 767
 768         /**
 769          * @param $key string
 770          * @return string
 771          */
 772         function getWeekdayAbbreviation( $key ) {
 773                 return $this->getMessageFromDB( self::$mWeekdayAbbrevMsgs[$key - 1] );
 774         }
 775
 776         /**
 777          * @param $key string
 778          * @return string
 779          */
 780         function getIranianCalendarMonthName( $key ) {
 781                 return $this->getMessageFromDB( self::$mIranianCalendarMonthMsgs[$key - 1] );
 782         }
 783
 784         /**
 785          * @param $key string
 786          * @return string
 787          */
 788         function getHebrewCalendarMonthName( $key ) {
 789                 return $this->getMessageFromDB( self::$mHebrewCalendarMonthMsgs[$key - 1] );
 790         }
 791
 792         /**
 793          * @param $key string
 794          * @return string
 795          */
 796         function getHebrewCalendarMonthNameGen( $key ) {
 797                 return $this->getMessageFromDB( self::$mHebrewCalendarMonthGenMsgs[$key - 1] );
 798         }
 799
 800         /**
 801          * @param $key string
 802          * @return string
 803          */
 804         function getHijriCalendarMonthName( $key ) {
 805                 return $this->getMessageFromDB( self::$mHijriCalendarMonthMsgs[$key - 1] );
 806         }
 807
 808         /**
 809          * Used by date() and time() to adjust the time output.
 810          *
 811          * @param $ts Int the time in date('YmdHis') format
 812          * @param $tz Mixed: adjust the time by this amount (default false, mean we
 813          *            get user timecorrection setting)
 814          * @return int
 815          */
 816         function userAdjust( $ts, $tz = false ) {
 817                 global $wgUser, $wgLocalTZoffset;
 818
 819                 if ( $tz === false ) {
 820                         $tz = $wgUser->getOption( 'timecorrection' );
 821                 }
 822
 823                 $data = explode( '|', $tz, 3 );
 824
 825                 if ( $data[0] == 'ZoneInfo' ) {
 826                         wfSuppressWarnings();
 827                         $userTZ = timezone_open( $data[2] );
 828                         wfRestoreWarnings();
 829                         if ( $userTZ !== false ) {
 830                                 $date = date_create( $ts, timezone_open( 'UTC' ) );
 831                                 date_timezone_set( $date, $userTZ );
 832                                 $date = date_format( $date, 'YmdHis' );
 833                                 return $date;
 834                         }
 835                         # Unrecognized timezone, default to 'Offset' with the stored offset.
 836                         $data[0] = 'Offset';
 837                 }
 838
 839                 $minDiff = 0;
 840                 if ( $data[0] == 'System' || $tz == '' ) {
 841                         #  Global offset in minutes.
 842                         if ( isset( $wgLocalTZoffset ) ) {
 843                                 $minDiff = $wgLocalTZoffset;
 844                         }
 845                 } elseif ( $data[0] == 'Offset' ) {
 846                         $minDiff = intval( $data[1] );
 847                 } else {
 848                         $data = explode( ':', $tz );
 849                         if ( count( $data ) == 2 ) {
 850                                 $data[0] = intval( $data[0] );
 851                                 $data[1] = intval( $data[1] );
 852                                 $minDiff = abs( $data[0] ) * 60 + $data[1];
 853                                 if ( $data[0] < 0 ) {
 854                                         $minDiff = -$minDiff;
 855                                 }
 856                         } else {
 857                                 $minDiff = intval( $data[0] ) * 60;
 858                         }
 859                 }
 860
 861                 # No difference ? Return time unchanged
 862                 if ( 0 == $minDiff ) {
 863                         return $ts;
 864                 }
 865
 866                 wfSuppressWarnings(); // E_STRICT system time bitching
 867                 # Generate an adjusted date; take advantage of the fact that mktime
 868                 # will normalize out-of-range values so we don't have to split $minDiff
 869                 # into hours and minutes.
 870                 $t = mktime( (
 871                   (int)substr( $ts, 8, 2 ) ), # Hours
 872                   (int)substr( $ts, 10, 2 ) + $minDiff, # Minutes
 873                   (int)substr( $ts, 12, 2 ), # Seconds
 874                   (int)substr( $ts, 4, 2 ), # Month
 875                   (int)substr( $ts, 6, 2 ), # Day
 876                   (int)substr( $ts, 0, 4 ) ); # Year
 877
 878                 $date = date( 'YmdHis', $t );
 879                 wfRestoreWarnings();
 880
 881                 return $date;
 882         }
 883
 884         /**
 885          * This is a workalike of PHP's date() function, but with better
 886          * internationalisation, a reduced set of format characters, and a better
 887          * escaping format.
 888          *
 889          * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
 890          * PHP manual for definitions. There are a number of extensions, which
 891          * start with "x":
 892          *
 893          *    xn   Do not translate digits of the next numeric format character
 894          *    xN   Toggle raw digit (xn) flag, stays set until explicitly unset
 895          *    xr   Use roman numerals for the next numeric format character
 896          *    xh   Use hebrew numerals for the next numeric format character
 897          *    xx   Literal x
 898          *    xg   Genitive month name
 899          *
 900          *    xij  j (day number) in Iranian calendar
 901          *    xiF  F (month name) in Iranian calendar
 902          *    xin  n (month number) in Iranian calendar
 903          *    xiY  Y (full year) in Iranian calendar
 904          *
 905          *    xjj  j (day number) in Hebrew calendar
 906          *    xjF  F (month name) in Hebrew calendar
 907          *    xjt  t (days in month) in Hebrew calendar
 908          *    xjx  xg (genitive month name) in Hebrew calendar
 909          *    xjn  n (month number) in Hebrew calendar
 910          *    xjY  Y (full year) in Hebrew calendar
 911          *
 912          *    xmj  j (day number) in Hijri calendar
 913          *    xmF  F (month name) in Hijri calendar
 914          *    xmn  n (month number) in Hijri calendar
 915          *    xmY  Y (full year) in Hijri calendar
 916          *
 917          *    xkY  Y (full year) in Thai solar calendar. Months and days are
 918          *                       identical to the Gregorian calendar
 919          *    xoY  Y (full year) in Minguo calendar or Juche year.
 920          *                       Months and days are identical to the
 921          *                       Gregorian calendar
 922          *    xtY  Y (full year) in Japanese nengo. Months and days are
 923          *                       identical to the Gregorian calendar
 924          *
 925          * Characters enclosed in double quotes will be considered literal (with
 926          * the quotes themselves removed). Unmatched quotes will be considered
 927          * literal quotes. Example:
 928          *
 929          * "The month is" F       => The month is January
 930          * i's"                   => 20'11"
 931          *
 932          * Backslash escaping is also supported.
 933          *
 934          * Input timestamp is assumed to be pre-normalized to the desired local
 935          * time zone, if any.
 936          *
 937          * @param $format String
 938          * @param $ts String: 14-character timestamp
 939          *      YYYYMMDDHHMMSS
 940          *      01234567890123
 941          * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
 942          *
 943          * @return string
 944          */
 945         function sprintfDate( $format, $ts ) {
 946                 $s = '';
 947                 $raw = false;
 948                 $roman = false;
 949                 $hebrewNum = false;
 950                 $unix = false;
 951                 $rawToggle = false;
 952                 $iranian = false;
 953                 $hebrew = false;
 954                 $hijri = false;
 955                 $thai = false;
 956                 $minguo = false;
 957                 $tenno = false;
 958                 for ( $p = 0; $p < strlen( $format ); $p++ ) {
 959                         $num = false;
 960                         $code = $format[$p];
 961                         if ( $code == 'x' && $p < strlen( $format ) - 1 ) {
 962                                 $code .= $format[++$p];
 963                         }
 964
 965                         if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
 966                                 $code .= $format[++$p];
 967                         }
 968
 969                         switch ( $code ) {
 970                                 case 'xx':
 971                                         $s .= 'x';
 972                                         break;
 973                                 case 'xn':
 974                                         $raw = true;
 975                                         break;
 976                                 case 'xN':
 977                                         $rawToggle = !$rawToggle;
 978                                         break;
 979                                 case 'xr':
 980                                         $roman = true;
 981                                         break;
 982                                 case 'xh':
 983                                         $hebrewNum = true;
 984                                         break;
 985                                 case 'xg':
 986                                         $s .= $this->getMonthNameGen( substr( $ts, 4, 2 ) );
 987                                         break;
 988                                 case 'xjx':
 989                                         if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
 990                                         $s .= $this->getHebrewCalendarMonthNameGen( $hebrew[1] );
 991                                         break;
 992                                 case 'd':
 993                                         $num = substr( $ts, 6, 2 );
 994                                         break;
 995                                 case 'D':
 996                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 997                                         $s .= $this->getWeekdayAbbreviation( gmdate( 'w', $unix ) + 1 );
 998                                         break;
 999                                 case 'j':
1000                                         $num = intval( substr( $ts, 6, 2 ) );
1001                                         break;
1002                                 case 'xij':
1003                                         if ( !$iranian ) {
1004                                                 $iranian = self::tsToIranian( $ts );
1005                                         }
1006                                         $num = $iranian[2];
1007                                         break;
1008                                 case 'xmj':
1009                                         if ( !$hijri ) {
1010                                                 $hijri = self::tsToHijri( $ts );
1011                                         }
1012                                         $num = $hijri[2];
1013                                         break;
1014                                 case 'xjj':
1015                                         if ( !$hebrew ) {
1016                                                 $hebrew = self::tsToHebrew( $ts );
1017                                         }
1018                                         $num = $hebrew[2];
1019                                         break;
1020                                 case 'l':
1021                                         if ( !$unix ) {
1022                                                 $unix = wfTimestamp( TS_UNIX, $ts );
1023                                         }
1024                                         $s .= $this->getWeekdayName( gmdate( 'w', $unix ) + 1 );
1025                                         break;
1026                                 case 'N':
1027                                         if ( !$unix ) {
1028                                                 $unix = wfTimestamp( TS_UNIX, $ts );
1029                                         }
1030                                         $w = gmdate( 'w', $unix );
1031                                         $num = $w ? $w : 7;
1032                                         break;
1033                                 case 'w':
1034                                         if ( !$unix ) {
1035                                                 $unix = wfTimestamp( TS_UNIX, $ts );
1036                                         }
1037                                         $num = gmdate( 'w', $unix );
1038                                         break;
1039                                 case 'z':
1040                                         if ( !$unix ) {
1041                                                 $unix = wfTimestamp( TS_UNIX, $ts );
1042                                         }
1043                                         $num = gmdate( 'z', $unix );
1044                                         break;
1045                                 case 'W':
1046                                         if ( !$unix ) {
1047                                                 $unix = wfTimestamp( TS_UNIX, $ts );
1048                                         }
1049                                         $num = gmdate( 'W', $unix );
1050                                         break;
1051                                 case 'F':
1052                                         $s .= $this->getMonthName( substr( $ts, 4, 2 ) );
1053                                         break;
1054                                 case 'xiF':
1055                                         if ( !$iranian ) {
1056                                                 $iranian = self::tsToIranian( $ts );
1057                                         }
1058                                         $s .= $this->getIranianCalendarMonthName( $iranian[1] );
1059                                         break;
1060                                 case 'xmF':
1061                                         if ( !$hijri ) {
1062                                                 $hijri = self::tsToHijri( $ts );
1063                                         }
1064                                         $s .= $this->getHijriCalendarMonthName( $hijri[1] );
1065                                         break;
1066                                 case 'xjF':
1067                                         if ( !$hebrew ) {
1068                                                 $hebrew = self::tsToHebrew( $ts );
1069                                         }
1070                                         $s .= $this->getHebrewCalendarMonthName( $hebrew[1] );
1071                                         break;
1072                                 case 'm':
1073                                         $num = substr( $ts, 4, 2 );
1074                                         break;
1075                                 case 'M':
1076                                         $s .= $this->getMonthAbbreviation( substr( $ts, 4, 2 ) );
1077                                         break;
1078                                 case 'n':
1079                                         $num = intval( substr( $ts, 4, 2 ) );
1080                                         break;
1081                                 case 'xin':
1082                                         if ( !$iranian ) {
1083                                                 $iranian = self::tsToIranian( $ts );
1084                                         }
1085                                         $num = $iranian[1];
1086                                         break;
1087                                 case 'xmn':
1088                                         if ( !$hijri ) {
1089                                                 $hijri = self::tsToHijri ( $ts );
1090                                         }
1091                                         $num = $hijri[1];
1092                                         break;
1093                                 case 'xjn':
1094                                         if ( !$hebrew ) {
1095                                                 $hebrew = self::tsToHebrew( $ts );
1096                                         }
1097                                         $num = $hebrew[1];
1098                                         break;
1099                                 case 't':
1100                                         if ( !$unix ) {
1101                                                 $unix = wfTimestamp( TS_UNIX, $ts );
1102                                         }
1103                                         $num = gmdate( 't', $unix );
1104                                         break;
1105                                 case 'xjt':
1106                                         if ( !$hebrew ) {
1107                                                 $hebrew = self::tsToHebrew( $ts );
1108                                         }
1109                                         $num = $hebrew[3];
1110                                         break;
1111                                 case 'L':
1112                                         if ( !$unix ) {
1113                                                 $unix = wfTimestamp( TS_UNIX, $ts );
1114                                         }
1115                                         $num = gmdate( 'L', $unix );
1116                                         break;
1117                                 case 'o':
1118                                         if ( !$unix ) {
1119                                                 $unix = wfTimestamp( TS_UNIX, $ts );
1120                                         }
1121                                         $num = date( 'o', $unix );
1122                                         break;
1123                                 case 'Y':
1124                                         $num = substr( $ts, 0, 4 );
1125                                         break;
1126                                 case 'xiY':
1127                                         if ( !$iranian ) {
1128                                                 $iranian = self::tsToIranian( $ts );
1129                                         }
1130                                         $num = $iranian[0];
1131                                         break;
1132                                 case 'xmY':
1133                                         if ( !$hijri ) {
1134                                                 $hijri = self::tsToHijri( $ts );
1135                                         }
1136                                         $num = $hijri[0];
1137                                         break;
1138                                 case 'xjY':
1139                                         if ( !$hebrew ) {
1140                                                 $hebrew = self::tsToHebrew( $ts );
1141                                         }
1142                                         $num = $hebrew[0];
1143                                         break;
1144                                 case 'xkY':
1145                                         if ( !$thai ) {
1146                                                 $thai = self::tsToYear( $ts, 'thai' );
1147                                         }
1148                                         $num = $thai[0];
1149                                         break;
1150                                 case 'xoY':
1151                                         if ( !$minguo ) {
1152                                                 $minguo = self::tsToYear( $ts, 'minguo' );
1153                                         }
1154                                         $num = $minguo[0];
1155                                         break;
1156                                 case 'xtY':
1157                                         if ( !$tenno ) {
1158                                                 $tenno = self::tsToYear( $ts, 'tenno' );
1159                                         }
1160                                         $num = $tenno[0];
1161                                         break;
1162                                 case 'y':
1163                                         $num = substr( $ts, 2, 2 );
1164                                         break;
1165                                 case 'a':
1166                                         $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'am' : 'pm';
1167                                         break;
1168                                 case 'A':
1169                                         $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'AM' : 'PM';
1170                                         break;
1171                                 case 'g':
1172                                         $h = substr( $ts, 8, 2 );
1173                                         $num = $h % 12 ? $h % 12 : 12;
1174                                         break;
1175                                 case 'G':
1176                                         $num = intval( substr( $ts, 8, 2 ) );
1177                                         break;
1178                                 case 'h':
1179                                         $h = substr( $ts, 8, 2 );
1180                                         $num = sprintf( '%02d', $h % 12 ? $h % 12 : 12 );
1181                                         break;
1182                                 case 'H':
1183                                         $num = substr( $ts, 8, 2 );
1184                                         break;
1185                                 case 'i':
1186                                         $num = substr( $ts, 10, 2 );
1187                                         break;
1188                                 case 's':
1189                                         $num = substr( $ts, 12, 2 );
1190                                         break;
1191                                 case 'c':
1192                                         if ( !$unix ) {
1193                                                 $unix = wfTimestamp( TS_UNIX, $ts );
1194                                         }
1195                                         $s .= gmdate( 'c', $unix );
1196                                         break;
1197                                 case 'r':
1198                                         if ( !$unix ) {
1199                                                 $unix = wfTimestamp( TS_UNIX, $ts );
1200                                         }
1201                                         $s .= gmdate( 'r', $unix );
1202                                         break;
1203                                 case 'U':
1204                                         if ( !$unix ) {
1205                                                 $unix = wfTimestamp( TS_UNIX, $ts );
1206                                         }
1207                                         $num = $unix;
1208                                         break;
1209                                 case '\\':
1210                                         # Backslash escaping
1211                                         if ( $p < strlen( $format ) - 1 ) {
1212                                                 $s .= $format[++$p];
1213                                         } else {
1214                                                 $s .= '\\';
1215                                         }
1216                                         break;
1217                                 case '"':
1218                                         # Quoted literal
1219                                         if ( $p < strlen( $format ) - 1 ) {
1220                                                 $endQuote = strpos( $format, '"', $p + 1 );
1221                                                 if ( $endQuote === false ) {
1222                                                         # No terminating quote, assume literal "
1223                                                         $s .= '"';
1224                                                 } else {
1225                                                         $s .= substr( $format, $p + 1, $endQuote - $p - 1 );
1226                                                         $p = $endQuote;
1227                                                 }
1228                                         } else {
1229                                                 # Quote at end of string, assume literal "
1230                                                 $s .= '"';
1231                                         }
1232                                         break;
1233                                 default:
1234                                         $s .= $format[$p];
1235                         }
1236                         if ( $num !== false ) {
1237                                 if ( $rawToggle || $raw ) {
1238                                         $s .= $num;
1239                                         $raw = false;
1240                                 } elseif ( $roman ) {
1241                                         $s .= self::romanNumeral( $num );
1242                                         $roman = false;
1243                                 } elseif ( $hebrewNum ) {
1244                                         $s .= self::hebrewNumeral( $num );
1245                                         $hebrewNum = false;
1246                                 } else {
1247                                         $s .= $this->formatNum( $num, true );
1248                                 }
1249                         }
1250                 }
1251                 return $s;
1252         }
1253
1254         private static $GREG_DAYS = array( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
1255         private static $IRANIAN_DAYS = array( 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29 );
1256
1257         /**
1258          * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1259          * Gregorian dates to Iranian dates. Originally written in C, it
1260          * is released under the terms of GNU Lesser General Public
1261          * License. Conversion to PHP was performed by Niklas Laxström.
1262          *
1263          * Link: http://www.farsiweb.info/jalali/jalali.c
1264          *
1265          * @param $ts string
1266          *
1267          * @return string
1268          */
1269         private static function tsToIranian( $ts ) {
1270                 $gy = substr( $ts, 0, 4 ) -1600;
1271                 $gm = substr( $ts, 4, 2 ) -1;
1272                 $gd = substr( $ts, 6, 2 ) -1;
1273
1274                 # Days passed from the beginning (including leap years)
1275                 $gDayNo = 365 * $gy
1276                         + floor( ( $gy + 3 ) / 4 )
1277                         - floor( ( $gy + 99 ) / 100 )
1278                         + floor( ( $gy + 399 ) / 400 );
1279
1280                 // Add days of the past months of this year
1281                 for ( $i = 0; $i < $gm; $i++ ) {
1282                         $gDayNo += self::$GREG_DAYS[$i];
1283                 }
1284
1285                 // Leap years
1286                 if ( $gm > 1 && ( ( $gy % 4 === 0 && $gy % 100 !== 0 || ( $gy % 400 == 0 ) ) ) ) {
1287                         $gDayNo++;
1288                 }
1289
1290                 // Days passed in current month
1291                 $gDayNo += $gd;
1292
1293                 $jDayNo = $gDayNo - 79;
1294
1295                 $jNp = floor( $jDayNo / 12053 );
1296                 $jDayNo %= 12053;
1297
1298                 $jy = 979 + 33 * $jNp + 4 * floor( $jDayNo / 1461 );
1299                 $jDayNo %= 1461;
1300
1301                 if ( $jDayNo >= 366 ) {
1302                         $jy += floor( ( $jDayNo - 1 ) / 365 );
1303                         $jDayNo = floor( ( $jDayNo - 1 ) % 365 );
1304                 }
1305
1306                 for ( $i = 0; $i < 11 && $jDayNo >= self::$IRANIAN_DAYS[$i]; $i++ ) {
1307                         $jDayNo -= self::$IRANIAN_DAYS[$i];
1308                 }
1309
1310                 $jm = $i + 1;
1311                 $jd = $jDayNo + 1;
1312
1313                 return array( $jy, $jm, $jd );
1314         }
1315
1316         /**
1317          * Converting Gregorian dates to Hijri dates.
1318          *
1319          * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1320          *
1321          * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1322          *
1323          * @param $ts string
1324          *
1325          * @return string
1326          */
1327         private static function tsToHijri( $ts ) {
1328                 $year = substr( $ts, 0, 4 );
1329                 $month = substr( $ts, 4, 2 );
1330                 $day = substr( $ts, 6, 2 );
1331
1332                 $zyr = $year;
1333                 $zd = $day;
1334                 $zm = $month;
1335                 $zy = $zyr;
1336
1337                 if (
1338                         ( $zy > 1582 ) || ( ( $zy == 1582 ) && ( $zm > 10 ) ) ||
1339                         ( ( $zy == 1582 ) && ( $zm == 10 ) && ( $zd > 14 ) )
1340                 )
1341                 {
1342                         $zjd = (int)( ( 1461 * ( $zy + 4800 + (int)( ( $zm - 14 ) / 12 ) ) ) / 4 ) +
1343                                         (int)( ( 367 * ( $zm - 2 - 12 * ( (int)( ( $zm - 14 ) / 12 ) ) ) ) / 12 ) -
1344                                         (int)( ( 3 * (int)( ( ( $zy + 4900 + (int)( ( $zm - 14 ) / 12 ) ) / 100 ) ) ) / 4 ) +
1345                                         $zd - 32075;
1346                 } else {
1347                         $zjd = 367 * $zy - (int)( ( 7 * ( $zy + 5001 + (int)( ( $zm - 9 ) / 7 ) ) ) / 4 ) +
1348                                                                 (int)( ( 275 * $zm ) / 9 ) + $zd + 1729777;
1349                 }
1350
1351                 $zl = $zjd -1948440 + 10632;
1352                 $zn = (int)( ( $zl - 1 ) / 10631 );
1353                 $zl = $zl - 10631 * $zn + 354;
1354                 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1355                 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1356                 $zm = (int)( ( 24 * $zl ) / 709 );
1357                 $zd = $zl - (int)( ( 709 * $zm ) / 24 );
1358                 $zy = 30 * $zn + $zj - 30;
1359
1360                 return array( $zy, $zm, $zd );
1361         }
1362
1363         /**
1364          * Converting Gregorian dates to Hebrew dates.
1365          *
1366          * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1367          * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1368          * to translate the relevant functions into PHP and release them under
1369          * GNU GPL.
1370          *
1371          * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1372          * and Adar II is 14. In a non-leap year, Adar is 6.
1373          *
1374          * @param $ts string
1375          *
1376          * @return string
1377          */
1378         private static function tsToHebrew( $ts ) {
1379                 # Parse date
1380                 $year = substr( $ts, 0, 4 );
1381                 $month = substr( $ts, 4, 2 );
1382                 $day = substr( $ts, 6, 2 );
1383
1384                 # Calculate Hebrew year
1385                 $hebrewYear = $year + 3760;
1386
1387                 # Month number when September = 1, August = 12
1388                 $month += 4;
1389                 if ( $month > 12 ) {
1390                         # Next year
1391                         $month -= 12;
1392                         $year++;
1393                         $hebrewYear++;
1394                 }
1395
1396                 # Calculate day of year from 1 September
1397                 $dayOfYear = $day;
1398                 for ( $i = 1; $i < $month; $i++ ) {
1399                         if ( $i == 6 ) {
1400                                 # February
1401                                 $dayOfYear += 28;
1402                                 # Check if the year is leap
1403                                 if ( $year % 400 == 0 || ( $year % 4 == 0 && $year % 100 > 0 ) ) {
1404                                         $dayOfYear++;
1405                                 }
1406                         } elseif ( $i == 8 || $i == 10 || $i == 1 || $i == 3 ) {
1407                                 $dayOfYear += 30;
1408                         } else {
1409                                 $dayOfYear += 31;
1410                         }
1411                 }
1412
1413                 # Calculate the start of the Hebrew year
1414                 $start = self::hebrewYearStart( $hebrewYear );
1415
1416                 # Calculate next year's start
1417                 if ( $dayOfYear <= $start ) {
1418                         # Day is before the start of the year - it is the previous year
1419                         # Next year's start
1420                         $nextStart = $start;
1421                         # Previous year
1422                         $year--;
1423                         $hebrewYear--;
1424                         # Add days since previous year's 1 September
1425                         $dayOfYear += 365;
1426                         if ( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
1427                                 # Leap year
1428                                 $dayOfYear++;
1429                         }
1430                         # Start of the new (previous) year
1431                         $start = self::hebrewYearStart( $hebrewYear );
1432                 } else {
1433                         # Next year's start
1434                         $nextStart = self::hebrewYearStart( $hebrewYear + 1 );
1435                 }
1436
1437                 # Calculate Hebrew day of year
1438                 $hebrewDayOfYear = $dayOfYear - $start;
1439
1440                 # Difference between year's days
1441                 $diff = $nextStart - $start;
1442                 # Add 12 (or 13 for leap years) days to ignore the difference between
1443                 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1444                 # difference is only about the year type
1445                 if ( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
1446                         $diff += 13;
1447                 } else {
1448                         $diff += 12;
1449                 }
1450
1451                 # Check the year pattern, and is leap year
1452                 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1453                 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1454                 # and non-leap years
1455                 $yearPattern = $diff % 30;
1456                 # Check if leap year
1457                 $isLeap = $diff >= 30;
1458
1459                 # Calculate day in the month from number of day in the Hebrew year
1460                 # Don't check Adar - if the day is not in Adar, we will stop before;
1461                 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1462                 $hebrewDay = $hebrewDayOfYear;
1463                 $hebrewMonth = 1;
1464                 $days = 0;
1465                 while ( $hebrewMonth <= 12 ) {
1466                         # Calculate days in this month
1467                         if ( $isLeap && $hebrewMonth == 6 ) {
1468                                 # Adar in a leap year
1469                                 if ( $isLeap ) {
1470                                         # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1471                                         $days = 30;
1472                                         if ( $hebrewDay <= $days ) {
1473                                                 # Day in Adar I
1474                                                 $hebrewMonth = 13;
1475                                         } else {
1476                                                 # Subtract the days of Adar I
1477                                                 $hebrewDay -= $days;
1478                                                 # Try Adar II
1479                                                 $days = 29;
1480                                                 if ( $hebrewDay <= $days ) {
1481                                                         # Day in Adar II
1482                                                         $hebrewMonth = 14;
1483                                                 }
1484                                         }
1485                                 }
1486                         } elseif ( $hebrewMonth == 2 && $yearPattern == 2 ) {
1487                                 # Cheshvan in a complete year (otherwise as the rule below)
1488                                 $days = 30;
1489                         } elseif ( $hebrewMonth == 3 && $yearPattern == 0 ) {
1490                                 # Kislev in an incomplete year (otherwise as the rule below)
1491                                 $days = 29;
1492                         } else {
1493                                 # Odd months have 30 days, even have 29
1494                                 $days = 30 - ( $hebrewMonth - 1 ) % 2;
1495                         }
1496                         if ( $hebrewDay <= $days ) {
1497                                 # In the current month
1498                                 break;
1499                         } else {
1500                                 # Subtract the days of the current month
1501                                 $hebrewDay -= $days;
1502                                 # Try in the next month
1503                                 $hebrewMonth++;
1504                         }
1505                 }
1506
1507                 return array( $hebrewYear, $hebrewMonth, $hebrewDay, $days );
1508         }
1509
1510         /**
1511          * This calculates the Hebrew year start, as days since 1 September.
1512          * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1513          * Used for Hebrew date.
1514          *
1515          * @param $year int
1516          *
1517          * @return string
1518          */
1519         private static function hebrewYearStart( $year ) {
1520                 $a = intval( ( 12 * ( $year - 1 ) + 17 ) % 19 );
1521                 $b = intval( ( $year - 1 ) % 4 );
1522                 $m = 32.044093161144 + 1.5542417966212 * $a +  $b / 4.0 - 0.0031777940220923 * ( $year - 1 );
1523                 if ( $m < 0 ) {
1524                         $m--;
1525                 }
1526                 $Mar = intval( $m );
1527                 if ( $m < 0 ) {
1528                         $m++;
1529                 }
1530                 $m -= $Mar;
1531
1532                 $c = intval( ( $Mar + 3 * ( $year - 1 ) + 5 * $b + 5 ) % 7 );
1533                 if ( $c == 0 && $a > 11 && $m >= 0.89772376543210 ) {
1534                         $Mar++;
1535                 } elseif ( $c == 1 && $a > 6 && $m >= 0.63287037037037 ) {
1536                         $Mar += 2;
1537                 } elseif ( $c == 2 || $c == 4 || $c == 6 ) {
1538                         $Mar++;
1539                 }
1540
1541                 $Mar += intval( ( $year - 3761 ) / 100 ) - intval( ( $year - 3761 ) / 400 ) - 24;
1542                 return $Mar;
1543         }
1544
1545         /**
1546          * Algorithm to convert Gregorian dates to Thai solar dates,
1547          * Minguo dates or Minguo dates.
1548          *
1549          * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1550          *       http://en.wikipedia.org/wiki/Minguo_calendar
1551          *       http://en.wikipedia.org/wiki/Japanese_era_name
1552          *
1553          * @param $ts String: 14-character timestamp
1554          * @param $cName String: calender name
1555          * @return Array: converted year, month, day
1556          */
1557         private static function tsToYear( $ts, $cName ) {
1558                 $gy = substr( $ts, 0, 4 );
1559                 $gm = substr( $ts, 4, 2 );
1560                 $gd = substr( $ts, 6, 2 );
1561
1562                 if ( !strcmp( $cName, 'thai' ) ) {
1563                         # Thai solar dates
1564                         # Add 543 years to the Gregorian calendar
1565                         # Months and days are identical
1566                         $gy_offset = $gy + 543;
1567                 } elseif ( ( !strcmp( $cName, 'minguo' ) ) || !strcmp( $cName, 'juche' ) ) {
1568                         # Minguo dates
1569                         # Deduct 1911 years from the Gregorian calendar
1570                         # Months and days are identical
1571                         $gy_offset = $gy - 1911;
1572                 } elseif ( !strcmp( $cName, 'tenno' ) ) {
1573                         # Nengō dates up to Meiji period
1574                         # Deduct years from the Gregorian calendar
1575                         # depending on the nengo periods
1576                         # Months and days are identical
1577                         if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1578                                 # Meiji period
1579                                 $gy_gannen = $gy - 1868 + 1;
1580                                 $gy_offset = $gy_gannen;
1581                                 if ( $gy_gannen == 1 ) {
1582                                         $gy_offset = '元';
1583                                 }
1584                                 $gy_offset = '明治' . $gy_offset;
1585                         } elseif (
1586                                 ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd == 31 ) ) ||
1587                                 ( ( $gy == 1912 ) && ( $gm >= 8 ) ) ||
1588                                 ( ( $gy > 1912 ) && ( $gy < 1926 ) ) ||
1589                                 ( ( $gy == 1926 ) && ( $gm < 12 ) ) ||
1590                                 ( ( $gy == 1926 ) && ( $gm == 12 ) && ( $gd < 26 ) )
1591                         )
1592                         {
1593                                 # Taishō period
1594                                 $gy_gannen = $gy - 1912 + 1;
1595                                 $gy_offset = $gy_gannen;
1596                                 if ( $gy_gannen == 1 ) {
1597                                         $gy_offset = '元';
1598                                 }
1599                                 $gy_offset = '大正' . $gy_offset;
1600                         } elseif (
1601                                 ( ( $gy == 1926 ) && ( $gm == 12 ) && ( $gd >= 26 ) ) ||
1602                                 ( ( $gy > 1926 ) && ( $gy < 1989 ) ) ||
1603                                 ( ( $gy == 1989 ) && ( $gm == 1 ) && ( $gd < 8 ) )
1604                         )
1605                         {
1606                                 # Shōwa period
1607                                 $gy_gannen = $gy - 1926 + 1;
1608                                 $gy_offset = $gy_gannen;
1609                                 if ( $gy_gannen == 1 ) {
1610                                         $gy_offset = '元';
1611                                 }
1612                                 $gy_offset = '昭和' . $gy_offset;
1613                         } else {
1614                                 # Heisei period
1615                                 $gy_gannen = $gy - 1989 + 1;
1616                                 $gy_offset = $gy_gannen;
1617                                 if ( $gy_gannen == 1 ) {
1618                                         $gy_offset = '元';
1619                                 }
1620                                 $gy_offset = '平成' . $gy_offset;
1621                         }
1622                 } else {
1623                         $gy_offset = $gy;
1624                 }
1625
1626                 return array( $gy_offset, $gm, $gd );
1627         }
1628
1629         /**
1630          * Roman number formatting up to 3000
1631          *
1632          * @param $num int
1633          *
1634          * @return string
1635          */
1636         static function romanNumeral( $num ) {
1637                 static $table = array(
1638                         array( '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X' ),
1639                         array( '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', 'C' ),
1640                         array( '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', 'M' ),
1641                         array( '', 'M', 'MM', 'MMM' )
1642                 );
1643
1644                 $num = intval( $num );
1645                 if ( $num > 3000 || $num <= 0 ) {
1646                         return $num;
1647                 }
1648
1649                 $s = '';
1650                 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1651                         if ( $num >= $pow10 ) {
1652                                 $s .= $table[$i][floor( $num / $pow10 )];
1653                         }
1654                         $num = $num % $pow10;
1655                 }
1656                 return $s;
1657         }
1658
1659         /**
1660          * Hebrew Gematria number formatting up to 9999
1661          *
1662          * @param $num int
1663          *
1664          * @return string
1665          */
1666         static function hebrewNumeral( $num ) {
1667                 static $table = array(
1668                         array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' ),
1669                         array( '', 'י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ', 'ק' ),
1670                         array( '', 'ק', 'ר', 'ש', 'ת', 'תק', 'תר', 'תש', 'תת', 'תתק', 'תתר' ),
1671                         array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' )
1672                 );
1673
1674                 $num = intval( $num );
1675                 if ( $num > 9999 || $num <= 0 ) {
1676                         return $num;
1677                 }
1678
1679                 $s = '';
1680                 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1681                         if ( $num >= $pow10 ) {
1682                                 if ( $num == 15 || $num == 16 ) {
1683                                         $s .= $table[0][9] . $table[0][$num - 9];
1684                                         $num = 0;
1685                                 } else {
1686                                         $s .= $table[$i][intval( ( $num / $pow10 ) )];
1687                                         if ( $pow10 == 1000 ) {
1688                                                 $s .= "'";
1689                                         }
1690                                 }
1691                         }
1692                         $num = $num % $pow10;
1693                 }
1694                 if ( strlen( $s ) == 2 ) {
1695                         $str = $s . "'";
1696                 } else  {
1697                         $str = substr( $s, 0, strlen( $s ) - 2 ) . '"';
1698                         $str .= substr( $s, strlen( $s ) - 2, 2 );
1699                 }
1700                 $start = substr( $str, 0, strlen( $str ) - 2 );
1701                 $end = substr( $str, strlen( $str ) - 2 );
1702                 switch( $end ) {
1703                         case 'כ':
1704                                 $str = $start . 'ך';
1705                                 break;
1706                         case 'מ':
1707                                 $str = $start . 'ם';
1708                                 break;
1709                         case 'נ':
1710                                 $str = $start . 'ן';
1711                                 break;
1712                         case 'פ':
1713                                 $str = $start . 'ף';
1714                                 break;
1715                         case 'צ':
1716                                 $str = $start . 'ץ';
1717                                 break;
1718                 }
1719                 return $str;
1720         }
1721
1722         /**
1723          * This is meant to be used by time(), date(), and timeanddate() to get
1724          * the date preference they're supposed to use, it should be used in
1725          * all children.
1726          *
1727          *<code>
1728          * function timeanddate([...], $format = true) {
1729          *      $datePreference = $this->dateFormat($format);
1730          * [...]
1731          * }
1732          *</code>
1733          *
1734          * @param $usePrefs Mixed: if true, the user's preference is used
1735          *                         if false, the site/language default is used
1736          *                         if int/string, assumed to be a format.
1737          * @return string
1738          */
1739         function dateFormat( $usePrefs = true ) {
1740                 global $wgUser;
1741
1742                 if ( is_bool( $usePrefs ) ) {
1743                         if ( $usePrefs ) {
1744                                 $datePreference = $wgUser->getDatePreference();
1745                         } else {
1746                                 $datePreference = (string)User::getDefaultOption( 'date' );
1747                         }
1748                 } else {
1749                         $datePreference = (string)$usePrefs;
1750                 }
1751
1752                 // return int
1753                 if ( $datePreference == '' ) {
1754                         return 'default';
1755                 }
1756
1757                 return $datePreference;
1758         }
1759
1760         /**
1761          * Get a format string for a given type and preference
1762          * @param $type string May be date, time or both
1763          * @param $pref string The format name as it appears in Messages*.php
1764          *
1765          * @return string
1766          */
1767         function getDateFormatString( $type, $pref ) {
1768                 if ( !isset( $this->dateFormatStrings[$type][$pref] ) ) {
1769                         if ( $pref == 'default' ) {
1770                                 $pref = $this->getDefaultDateFormat();
1771                                 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
1772                         } else {
1773                                 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
1774                                 if ( is_null( $df ) ) {
1775                                         $pref = $this->getDefaultDateFormat();
1776                                         $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
1777                                 }
1778                         }
1779                         $this->dateFormatStrings[$type][$pref] = $df;
1780                 }
1781                 return $this->dateFormatStrings[$type][$pref];
1782         }
1783
1784         /**
1785          * @param $ts Mixed: the time format which needs to be turned into a
1786          *            date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1787          * @param $adj Bool: whether to adjust the time output according to the
1788          *             user configured offset ($timecorrection)
1789          * @param $format Mixed: true to use user's date format preference
1790          * @param $timecorrection String|bool the time offset as returned by
1791          *                        validateTimeZone() in Special:Preferences
1792          * @return string
1793          */
1794         function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
1795                 $ts = wfTimestamp( TS_MW, $ts );
1796                 if ( $adj ) {
1797                         $ts = $this->userAdjust( $ts, $timecorrection );
1798                 }
1799                 $df = $this->getDateFormatString( 'date', $this->dateFormat( $format ) );
1800                 return $this->sprintfDate( $df, $ts );
1801         }
1802
1803         /**
1804          * @param $ts Mixed: the time format which needs to be turned into a
1805          *            date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1806          * @param $adj Bool: whether to adjust the time output according to the
1807          *             user configured offset ($timecorrection)
1808          * @param $format Mixed: true to use user's date format preference
1809          * @param $timecorrection String|bool the time offset as returned by
1810          *                        validateTimeZone() in Special:Preferences
1811          * @return string
1812          */
1813         function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
1814                 $ts = wfTimestamp( TS_MW, $ts );
1815                 if ( $adj ) {
1816                         $ts = $this->userAdjust( $ts, $timecorrection );
1817                 }
1818                 $df = $this->getDateFormatString( 'time', $this->dateFormat( $format ) );
1819                 return $this->sprintfDate( $df, $ts );
1820         }
1821
1822         /**
1823          * @param $ts Mixed: the time format which needs to be turned into a
1824          *            date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1825          * @param $adj Bool: whether to adjust the time output according to the
1826          *             user configured offset ($timecorrection)
1827          * @param $format Mixed: what format to return, if it's false output the
1828          *                default one (default true)
1829          * @param $timecorrection String|bool the time offset as returned by
1830          *                        validateTimeZone() in Special:Preferences
1831          * @return string
1832          */
1833         function timeanddate( $ts, $adj = false, $format = true, $timecorrection = false ) {
1834                 $ts = wfTimestamp( TS_MW, $ts );
1835                 if ( $adj ) {
1836                         $ts = $this->userAdjust( $ts, $timecorrection );
1837                 }
1838                 $df = $this->getDateFormatString( 'both', $this->dateFormat( $format ) );
1839                 return $this->sprintfDate( $df, $ts );
1840         }
1841
1842         /**
1843          * @param $key string
1844          * @return array|null
1845          */
1846         function getMessage( $key ) {
1847                 return self::$dataCache->getSubitem( $this->mCode, 'messages', $key );
1848         }
1849
1850         /**
1851          * @return array
1852          */
1853         function getAllMessages() {
1854                 return self::$dataCache->getItem( $this->mCode, 'messages' );
1855         }
1856
1857         /**
1858          * @param $in
1859          * @param $out
1860          * @param $string
1861          * @return string
1862          */
1863         function iconv( $in, $out, $string ) {
1864                 # This is a wrapper for iconv in all languages except esperanto,
1865                 # which does some nasty x-conversions beforehand
1866
1867                 # Even with //IGNORE iconv can whine about illegal characters in
1868                 # *input* string. We just ignore those too.
1869                 # REF: http://bugs.php.net/bug.php?id=37166
1870                 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1871                 wfSuppressWarnings();
1872                 $text = iconv( $in, $out . '//IGNORE', $string );
1873                 wfRestoreWarnings();
1874                 return $text;
1875         }
1876
1877         // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1878
1879         /**
1880          * @param $matches array
1881          * @return mixed|string
1882          */
1883         function ucwordbreaksCallbackAscii( $matches ) {
1884                 return $this->ucfirst( $matches[1] );
1885         }
1886
1887         /**
1888          * @param $matches array
1889          * @return string
1890          */
1891         function ucwordbreaksCallbackMB( $matches ) {
1892                 return mb_strtoupper( $matches[0] );
1893         }
1894
1895         /**
1896          * @param $matches array
1897          * @return string
1898          */
1899         function ucCallback( $matches ) {
1900                 list( $wikiUpperChars ) = self::getCaseMaps();
1901                 return strtr( $matches[1], $wikiUpperChars );
1902         }
1903
1904         /**
1905          * @param $matches array
1906          * @return string
1907          */
1908         function lcCallback( $matches ) {
1909                 list( , $wikiLowerChars ) = self::getCaseMaps();
1910                 return strtr( $matches[1], $wikiLowerChars );
1911         }
1912
1913         /**
1914          * @param $matches array
1915          * @return string
1916          */
1917         function ucwordsCallbackMB( $matches ) {
1918                 return mb_strtoupper( $matches[0] );
1919         }
1920
1921         /**
1922          * @param $matches array
1923          * @return string
1924          */
1925         function ucwordsCallbackWiki( $matches ) {
1926                 list( $wikiUpperChars ) = self::getCaseMaps();
1927                 return strtr( $matches[0], $wikiUpperChars );
1928         }
1929
1930         /**
1931          * Make a string's first character uppercase
1932          *
1933          * @param $str string
1934          *
1935          * @return string
1936          */
1937         function ucfirst( $str ) {
1938                 $o = ord( $str );
1939                 if ( $o < 96 ) { // if already uppercase...
1940                         return $str;
1941                 } elseif ( $o < 128 ) {
1942                         return ucfirst( $str ); // use PHP's ucfirst()
1943                 } else {
1944                         // fall back to more complex logic in case of multibyte strings
1945                         return $this->uc( $str, true );
1946                 }
1947         }
1948
1949         /**
1950          * Convert a string to uppercase
1951          *
1952          * @param $str string
1953          * @param $first bool
1954          *
1955          * @return string
1956          */
1957         function uc( $str, $first = false ) {
1958                 if ( function_exists( 'mb_strtoupper' ) ) {
1959                         if ( $first ) {
1960                                 if ( $this->isMultibyte( $str ) ) {
1961                                         return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1962                                 } else {
1963                                         return ucfirst( $str );
1964                                 }
1965                         } else {
1966                                 return $this->isMultibyte( $str ) ? mb_strtoupper( $str ) : strtoupper( $str );
1967                         }
1968                 } else {
1969                         if ( $this->isMultibyte( $str ) ) {
1970                                 $x = $first ? '^' : '';
1971                                 return preg_replace_callback(
1972                                         "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1973                                         array( $this, 'ucCallback' ),
1974                                         $str
1975                                 );
1976                         } else {
1977                                 return $first ? ucfirst( $str ) : strtoupper( $str );
1978                         }
1979                 }
1980         }
1981
1982         /**
1983          * @param $str string
1984          * @return mixed|string
1985          */
1986         function lcfirst( $str ) {
1987                 $o = ord( $str );
1988                 if ( !$o ) {
1989                         return strval( $str );
1990                 } elseif ( $o >= 128 ) {
1991                         return $this->lc( $str, true );
1992                 } elseif ( $o > 96 ) {
1993                         return $str;
1994                 } else {
1995                         $str[0] = strtolower( $str[0] );
1996                         return $str;
1997                 }
1998         }
1999
2000         /**
2001          * @param $str string
2002          * @param $first bool
2003          * @return mixed|string
2004          */
2005         function lc( $str, $first = false ) {
2006                 if ( function_exists( 'mb_strtolower' ) ) {
2007                         if ( $first ) {
2008                                 if ( $this->isMultibyte( $str ) ) {
2009                                         return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
2010                                 } else {
2011                                         return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
2012                                 }
2013                         } else {
2014                                 return $this->isMultibyte( $str ) ? mb_strtolower( $str ) : strtolower( $str );
2015                         }
2016                 } else {
2017                         if ( $this->isMultibyte( $str ) ) {
2018                                 $x = $first ? '^' : '';
2019                                 return preg_replace_callback(
2020                                         "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
2021                                         array( $this, 'lcCallback' ),
2022                                         $str
2023                                 );
2024                         } else {
2025                                 return $first ? strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
2026                         }
2027                 }
2028         }
2029
2030         /**
2031          * @param $str string
2032          * @return bool
2033          */
2034         function isMultibyte( $str ) {
2035                 return (bool)preg_match( '/[\x80-\xff]/', $str );
2036         }
2037
2038         /**
2039          * @param $str string
2040          * @return mixed|string
2041          */
2042         function ucwords( $str ) {
2043                 if ( $this->isMultibyte( $str ) ) {
2044                         $str = $this->lc( $str );
2045
2046                         // regexp to find first letter in each word (i.e. after each space)
2047                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2048
2049                         // function to use to capitalize a single char
2050                         if ( function_exists( 'mb_strtoupper' ) ) {
2051                                 return preg_replace_callback(
2052                                         $replaceRegexp,
2053                                         array( $this, 'ucwordsCallbackMB' ),
2054                                         $str
2055                                 );
2056                         } else {
2057                                 return preg_replace_callback(
2058                                         $replaceRegexp,
2059                                         array( $this, 'ucwordsCallbackWiki' ),
2060                                         $str
2061                                 );
2062                         }
2063                 } else {
2064                         return ucwords( strtolower( $str ) );
2065                 }
2066         }
2067
2068         /**
2069          * capitalize words at word breaks
2070          *
2071          * @param $str string
2072          * @return mixed
2073          */
2074         function ucwordbreaks( $str ) {
2075                 if ( $this->isMultibyte( $str ) ) {
2076                         $str = $this->lc( $str );
2077
2078                         // since \b doesn't work for UTF-8, we explicitely define word break chars
2079                         $breaks = "[ \-\(\)\}\{\.,\?!]";
2080
2081                         // find first letter after word break
2082                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2083
2084                         if ( function_exists( 'mb_strtoupper' ) ) {
2085                                 return preg_replace_callback(
2086                                         $replaceRegexp,
2087                                         array( $this, 'ucwordbreaksCallbackMB' ),
2088                                         $str
2089                                 );
2090                         } else {
2091                                 return preg_replace_callback(
2092                                         $replaceRegexp,
2093                                         array( $this, 'ucwordsCallbackWiki' ),
2094                                         $str
2095                                 );
2096                         }
2097                 } else {
2098                         return preg_replace_callback(
2099                                 '/\b([\w\x80-\xff]+)\b/',
2100                                 array( $this, 'ucwordbreaksCallbackAscii' ),
2101                                 $str
2102                         );
2103                 }
2104         }
2105
2106         /**
2107          * Return a case-folded representation of $s
2108          *
2109          * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2110          * and $s2 are the same except for the case of their characters. It is not
2111          * necessary for the value returned to make sense when displayed.
2112          *
2113          * Do *not* perform any other normalisation in this function. If a caller
2114          * uses this function when it should be using a more general normalisation
2115          * function, then fix the caller.
2116          *
2117          * @param $s string
2118          *
2119          * @return string
2120          */
2121         function caseFold( $s ) {
2122                 return $this->uc( $s );
2123         }
2124
2125         /**
2126          * @param $s string
2127          * @return string
2128          */
2129         function checkTitleEncoding( $s ) {
2130                 if ( is_array( $s ) ) {
2131                         wfDebugDieBacktrace( 'Given array to checkTitleEncoding.' );
2132                 }
2133                 # Check for non-UTF-8 URLs
2134                 $ishigh = preg_match( '/[\x80-\xff]/', $s );
2135                 if ( !$ishigh ) {
2136                         return $s;
2137                 }
2138
2139                 $isutf8 = preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
2140                                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
2141                 if ( $isutf8 ) {
2142                         return $s;
2143                 }
2144
2145                 return $this->iconv( $this->fallback8bitEncoding(), 'utf-8', $s );
2146         }
2147
2148         /**
2149          * @return array
2150          */
2151         function fallback8bitEncoding() {
2152                 return self::$dataCache->getItem( $this->mCode, 'fallback8bitEncoding' );
2153         }
2154
2155         /**
2156          * Most writing systems use whitespace to break up words.
2157          * Some languages such as Chinese don't conventionally do this,
2158          * which requires special handling when breaking up words for
2159          * searching etc.
2160          *
2161          * @return bool
2162          */
2163         function hasWordBreaks() {
2164                 return true;
2165         }
2166
2167         /**
2168          * Some languages such as Chinese require word segmentation,
2169          * Specify such segmentation when overridden in derived class.
2170          *
2171          * @param $string String
2172          * @return String
2173          */
2174         function segmentByWord( $string ) {
2175                 return $string;
2176         }
2177
2178         /**
2179          * Some languages have special punctuation need to be normalized.
2180          * Make such changes here.
2181          *
2182          * @param $string String
2183          * @return String
2184          */
2185         function normalizeForSearch( $string ) {
2186                 return self::convertDoubleWidth( $string );
2187         }
2188
2189         /**
2190          * convert double-width roman characters to single-width.
2191          * range: ff00-ff5f ~= 0020-007f
2192          *
2193          * @param $string string
2194          *
2195          * @return string
2196          */
2197         protected static function convertDoubleWidth( $string ) {
2198                 static $full = null;
2199                 static $half = null;
2200
2201                 if ( $full === null ) {
2202                         $fullWidth = "０１２３４５６７８９ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ";
2203                         $halfWidth = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
2204                         $full = str_split( $fullWidth, 3 );
2205                         $half = str_split( $halfWidth );
2206                 }
2207
2208                 $string = str_replace( $full, $half, $string );
2209                 return $string;
2210         }
2211
2212         /**
2213          * @param $string string
2214          * @param $pattern string
2215          * @return string
2216          */
2217         protected static function insertSpace( $string, $pattern ) {
2218                 $string = preg_replace( $pattern, " $1 ", $string );
2219                 $string = preg_replace( '/ +/', ' ', $string );
2220                 return $string;
2221         }
2222
2223         /**
2224          * @param $termsArray array
2225          * @return array
2226          */
2227         function convertForSearchResult( $termsArray ) {
2228                 # some languages, e.g. Chinese, need to do a conversion
2229                 # in order for search results to be displayed correctly
2230                 return $termsArray;
2231         }
2232
2233         /**
2234          * Get the first character of a string.
2235          *
2236          * @param $s string
2237          * @return string
2238          */
2239         function firstChar( $s ) {
2240                 $matches = array();
2241                 preg_match(
2242                         '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
2243                                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/',
2244                         $s,
2245                         $matches
2246                 );
2247
2248                 if ( isset( $matches[1] ) ) {
2249                         if ( strlen( $matches[1] ) != 3 ) {
2250                                 return $matches[1];
2251                         }
2252
2253                         // Break down Hangul syllables to grab the first jamo
2254                         $code = utf8ToCodepoint( $matches[1] );
2255                         if ( $code < 0xac00 || 0xd7a4 <= $code ) {
2256                                 return $matches[1];
2257                         } elseif ( $code < 0xb098 ) {
2258                                 return "\xe3\x84\xb1";
2259                         } elseif ( $code < 0xb2e4 ) {
2260                                 return "\xe3\x84\xb4";
2261                         } elseif ( $code < 0xb77c ) {
2262                                 return "\xe3\x84\xb7";
2263                         } elseif ( $code < 0xb9c8 ) {
2264                                 return "\xe3\x84\xb9";
2265                         } elseif ( $code < 0xbc14 ) {
2266                                 return "\xe3\x85\x81";
2267                         } elseif ( $code < 0xc0ac ) {
2268                                 return "\xe3\x85\x82";
2269                         } elseif ( $code < 0xc544 ) {
2270                                 return "\xe3\x85\x85";
2271                         } elseif ( $code < 0xc790 ) {
2272                                 return "\xe3\x85\x87";
2273                         } elseif ( $code < 0xcc28 ) {
2274                                 return "\xe3\x85\x88";
2275                         } elseif ( $code < 0xce74 ) {
2276                                 return "\xe3\x85\x8a";
2277                         } elseif ( $code < 0xd0c0 ) {
2278                                 return "\xe3\x85\x8b";
2279                         } elseif ( $code < 0xd30c ) {
2280                                 return "\xe3\x85\x8c";
2281                         } elseif ( $code < 0xd558 ) {
2282                                 return "\xe3\x85\x8d";
2283                         } else {
2284                                 return "\xe3\x85\x8e";
2285                         }
2286                 } else {
2287                         return '';
2288                 }
2289         }
2290
2291         function initEncoding() {
2292                 # Some languages may have an alternate char encoding option
2293                 # (Esperanto X-coding, Japanese furigana conversion, etc)
2294                 # If this language is used as the primary content language,
2295                 # an override to the defaults can be set here on startup.
2296         }
2297
2298         /**
2299          * @param $s string
2300          * @return string
2301          */
2302         function recodeForEdit( $s ) {
2303                 # For some languages we'll want to explicitly specify
2304                 # which characters make it into the edit box raw
2305                 # or are converted in some way or another.
2306                 global $wgEditEncoding;
2307                 if ( $wgEditEncoding == '' || $wgEditEncoding == 'UTF-8' ) {
2308                         return $s;
2309                 } else {
2310                         return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
2311                 }
2312         }
2313
2314         /**
2315          * @param $s string
2316          * @return string
2317          */
2318         function recodeInput( $s ) {
2319                 # Take the previous into account.
2320                 global $wgEditEncoding;
2321                 if ( $wgEditEncoding != '' ) {
2322                         $enc = $wgEditEncoding;
2323                 } else {
2324                         $enc = 'UTF-8';
2325                 }
2326                 if ( $enc == 'UTF-8' ) {
2327                         return $s;
2328                 } else {
2329                         return $this->iconv( $enc, 'UTF-8', $s );
2330                 }
2331         }
2332
2333         /**
2334          * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2335          * also cleans up certain backwards-compatible sequences, converting them
2336          * to the modern Unicode equivalent.
2337          *
2338          * This is language-specific for performance reasons only.
2339          *
2340          * @param $s string
2341          *
2342          * @return string
2343          */
2344         function normalize( $s ) {
2345                 global $wgAllUnicodeFixes;
2346                 $s = UtfNormal::cleanUp( $s );
2347                 if ( $wgAllUnicodeFixes ) {
2348                         $s = $this->transformUsingPairFile( 'normalize-ar.ser', $s );
2349                         $s = $this->transformUsingPairFile( 'normalize-ml.ser', $s );
2350                 }
2351
2352                 return $s;
2353         }
2354
2355         /**
2356          * Transform a string using serialized data stored in the given file (which
2357          * must be in the serialized subdirectory of $IP). The file contains pairs
2358          * mapping source characters to destination characters.
2359          *
2360          * The data is cached in process memory. This will go faster if you have the
2361          * FastStringSearch extension.
2362          *
2363          * @param $file string
2364          * @param $string string
2365          *
2366          * @return string
2367          */
2368         function transformUsingPairFile( $file, $string ) {
2369                 if ( !isset( $this->transformData[$file] ) ) {
2370                         $data = wfGetPrecompiledData( $file );
2371                         if ( $data === false ) {
2372                                 throw new MWException( __METHOD__ . ": The transformation file $file is missing" );
2373                         }
2374                         $this->transformData[$file] = new ReplacementArray( $data );
2375                 }
2376                 return $this->transformData[$file]->replace( $string );
2377         }
2378
2379         /**
2380          * For right-to-left language support
2381          *
2382          * @return bool
2383          */
2384         function isRTL() {
2385                 return self::$dataCache->getItem( $this->mCode, 'rtl' );
2386         }
2387
2388         /**
2389          * Return the correct HTML 'dir' attribute value for this language.
2390          * @return String
2391          */
2392         function getDir() {
2393                 return $this->isRTL() ? 'rtl' : 'ltr';
2394         }
2395
2396         /**
2397          * Return 'left' or 'right' as appropriate alignment for line-start
2398          * for this language's text direction.
2399          *
2400          * Should be equivalent to CSS3 'start' text-align value....
2401          *
2402          * @return String
2403          */
2404         function alignStart() {
2405                 return $this->isRTL() ? 'right' : 'left';
2406         }
2407
2408         /**
2409          * Return 'right' or 'left' as appropriate alignment for line-end
2410          * for this language's text direction.
2411          *
2412          * Should be equivalent to CSS3 'end' text-align value....
2413          *
2414          * @return String
2415          */
2416         function alignEnd() {
2417                 return $this->isRTL() ? 'left' : 'right';
2418         }
2419
2420         /**
2421          * A hidden direction mark (LRM or RLM), depending on the language direction
2422          *
2423          * @param $opposite Boolean Get the direction mark opposite to your language
2424          * @return string
2425          */
2426         function getDirMark( $opposite = false ) {
2427                 $rtl = "\xE2\x80\x8F";
2428                 $ltr = "\xE2\x80\x8E";
2429                 if ( $opposite ) { return $this->isRTL() ? $ltr : $rtl; }
2430                 return $this->isRTL() ? $rtl : $ltr;
2431         }
2432
2433         /**
2434          * @return array
2435          */
2436         function capitalizeAllNouns() {
2437                 return self::$dataCache->getItem( $this->mCode, 'capitalizeAllNouns' );
2438         }
2439
2440         /**
2441          * An arrow, depending on the language direction
2442          *
2443          * @return string
2444          */
2445         function getArrow() {
2446                 return $this->isRTL() ? '←' : '→';
2447         }
2448
2449         /**
2450          * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2451          *
2452          * @return bool
2453          */
2454         function linkPrefixExtension() {
2455                 return self::$dataCache->getItem( $this->mCode, 'linkPrefixExtension' );
2456         }
2457
2458         /**
2459          * @return array
2460          */
2461         function getMagicWords() {
2462                 return self::$dataCache->getItem( $this->mCode, 'magicWords' );
2463         }
2464
2465         protected function doMagicHook() {
2466                 if ( $this->mMagicHookDone ) {
2467                         return;
2468                 }
2469                 $this->mMagicHookDone = true;
2470                 wfProfileIn( 'LanguageGetMagic' );
2471                 wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
2472                 wfProfileOut( 'LanguageGetMagic' );
2473         }
2474
2475         /**
2476          * Fill a MagicWord object with data from here
2477          *
2478          * @param $mw
2479          */
2480         function getMagic( $mw ) {
2481                 $this->doMagicHook();
2482
2483                 if ( isset( $this->mMagicExtensions[$mw->mId] ) ) {
2484                         $rawEntry = $this->mMagicExtensions[$mw->mId];
2485                 } else {
2486                         $magicWords = $this->getMagicWords();
2487                         if ( isset( $magicWords[$mw->mId] ) ) {
2488                                 $rawEntry = $magicWords[$mw->mId];
2489                         } else {
2490                                 $rawEntry = false;
2491                         }
2492                 }
2493
2494                 if ( !is_array( $rawEntry ) ) {
2495                         error_log( "\"$rawEntry\" is not a valid magic word for \"$mw->mId\"" );
2496                 } else {
2497                         $mw->mCaseSensitive = $rawEntry[0];
2498                         $mw->mSynonyms = array_slice( $rawEntry, 1 );
2499                 }
2500         }
2501
2502         /**
2503          * Add magic words to the extension array
2504          *
2505          * @param $newWords array
2506          */
2507         function addMagicWordsByLang( $newWords ) {
2508                 $fallbackChain = $this->getFallbackLanguages();
2509                 $fallbackChain = array_reverse( $fallbackChain );
2510                 foreach ( $fallbackChain as $code ) {
2511                         if ( isset( $newWords[$code] ) ) {
2512                                 $this->mMagicExtensions = $newWords[$code] + $this->mMagicExtensions;
2513                         }
2514                 }
2515         }
2516
2517         /**
2518          * Get special page names, as an associative array
2519          *   case folded alias => real name
2520          */
2521         function getSpecialPageAliases() {
2522                 // Cache aliases because it may be slow to load them
2523                 if ( is_null( $this->mExtendedSpecialPageAliases ) ) {
2524                         // Initialise array
2525                         $this->mExtendedSpecialPageAliases =
2526                                 self::$dataCache->getItem( $this->mCode, 'specialPageAliases' );
2527                         wfRunHooks( 'LanguageGetSpecialPageAliases',
2528                                 array( &$this->mExtendedSpecialPageAliases, $this->getCode() ) );
2529                 }
2530
2531                 return $this->mExtendedSpecialPageAliases;
2532         }
2533
2534         /**
2535          * Italic is unsuitable for some languages
2536          *
2537          * @param $text String: the text to be emphasized.
2538          * @return string
2539          */
2540         function emphasize( $text ) {
2541                 return "<em>$text</em>";
2542         }
2543
2544          /**
2545           * Normally we output all numbers in plain en_US style, that is
2546           * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2547           * point twohundredthirtyfive. However this is not suitable for all
2548           * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2549           * Icelandic just want to use commas instead of dots, and dots instead
2550           * of commas like "293.291,235".
2551           *
2552           * An example of this function being called:
2553           * <code>
2554           * wfMsg( 'message', $wgLang->formatNum( $num ) )
2555           * </code>
2556           *
2557           * See LanguageGu.php for the Gujarati implementation and
2558           * $separatorTransformTable on MessageIs.php for
2559           * the , => . and . => , implementation.
2560           *
2561           * @todo check if it's viable to use localeconv() for the decimal
2562           *       separator thing.
2563           * @param $number Mixed: the string to be formatted, should be an integer
2564           *        or a floating point number.
2565           * @param $nocommafy Bool: set to true for special numbers like dates
2566           * @return string
2567           */
2568         function formatNum( $number, $nocommafy = false ) {
2569                 global $wgTranslateNumerals;
2570                 if ( !$nocommafy ) {
2571                         $number = $this->commafy( $number );
2572                         $s = $this->separatorTransformTable();
2573                         if ( $s ) {
2574                                 $number = strtr( $number, $s );
2575                         }
2576                 }
2577
2578                 if ( $wgTranslateNumerals ) {
2579                         $s = $this->digitTransformTable();
2580                         if ( $s ) {
2581                                 $number = strtr( $number, $s );
2582                         }
2583                 }
2584
2585                 return $number;
2586         }
2587
2588         /**
2589          * @param $number string
2590          * @return string
2591          */
2592         function parseFormattedNumber( $number ) {
2593                 $s = $this->digitTransformTable();
2594                 if ( $s ) {
2595                         $number = strtr( $number, array_flip( $s ) );
2596                 }
2597
2598                 $s = $this->separatorTransformTable();
2599                 if ( $s ) {
2600                         $number = strtr( $number, array_flip( $s ) );
2601                 }
2602
2603                 $number = strtr( $number, array( ',' => '' ) );
2604                 return $number;
2605         }
2606
2607         /**
2608          * Adds commas to a given number
2609          * @since 1.19
2610          * @param $_ mixed
2611          * @return string
2612          */
2613         function commafy( $_ ) {
2614                 $digitGroupingPattern = $this->digitGroupingPattern();
2615
2616                 if ( !$digitGroupingPattern || $digitGroupingPattern === "###,###,###" ) {
2617                         //default grouping is at thousands,  use the same for ###,###,### pattern too.
2618                         return strrev( (string)preg_replace( '/(\d{3})(?=\d)(?!\d*\.)/', '$1,', strrev( $_ ) ) );
2619                 }
2620                 else {
2621                         // Ref: http://cldr.unicode.org/translation/number-patterns
2622                         $numberpart = array();
2623                         $decimalpart = array();
2624                         $numMatches = preg_match_all( "/(#+)/", $digitGroupingPattern, $matches );
2625                         preg_match( "/\d+/", $_, $numberpart );
2626                         preg_match( "/\.\d*/", $_, $decimalpart );
2627                         $groupedNumber = ( count( $decimalpart ) > 0 ) ? $decimalpart[0]:"";
2628                         if ( $groupedNumber  === $_){
2629                             //the string does not have any number part. Eg: .12345
2630                             return $groupedNumber;
2631                         }
2632                         $start = $end = strlen( $numberpart[0] );
2633                         while ( $start > 0 )
2634                         {
2635                             $match = $matches[0][$numMatches -1] ;
2636                             $matchLen = strlen( $match );
2637                             $start = $end - $matchLen;
2638                             if ( $start < 0 ) {
2639                                 $start = 0;
2640                             }
2641                             $groupedNumber = substr( $_ , $start, $end -$start ) . $groupedNumber ;
2642                             $end = $start;
2643                             if ( $numMatches > 1 ) {
2644                                 // use the last pattern for the rest of the number
2645                                 $numMatches--;
2646                             }
2647                             if ( $start > 0 ) {
2648                                 $groupedNumber = "," . $groupedNumber;
2649                             }
2650                         }
2651                         return $groupedNumber;
2652                 }
2653         }
2654         /**
2655          * @return String
2656          */
2657         function digitGroupingPattern() {
2658                 return self::$dataCache->getItem( $this->mCode, 'digitGroupingPattern' );
2659         }
2660
2661         /**
2662          * @return array
2663          */
2664         function digitTransformTable() {
2665                 return self::$dataCache->getItem( $this->mCode, 'digitTransformTable' );
2666         }
2667
2668         /**
2669          * @return array
2670          */
2671         function separatorTransformTable() {
2672                 return self::$dataCache->getItem( $this->mCode, 'separatorTransformTable' );
2673         }
2674
2675         /**
2676          * Take a list of strings and build a locale-friendly comma-separated
2677          * list, using the local comma-separator message.
2678          * The last two strings are chained with an "and".
2679          *
2680          * @param $l Array
2681          * @return string
2682          */
2683         function listToText( $l ) {
2684                 $s = '';
2685                 $m = count( $l ) - 1;
2686                 if ( $m == 1 ) {
2687                         return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2688                 } else {
2689                         for ( $i = $m; $i >= 0; $i-- ) {
2690                                 if ( $i == $m ) {
2691                                         $s = $l[$i];
2692                                 } elseif ( $i == $m - 1 ) {
2693                                         $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2694                                 } else {
2695                                         $s = $l[$i] . $this->getMessageFromDB( 'comma-separator' ) . $s;
2696                                 }
2697                         }
2698                         return $s;
2699                 }
2700         }
2701
2702         /**
2703          * Take a list of strings and build a locale-friendly comma-separated
2704          * list, using the local comma-separator message.
2705          * @param $list array of strings to put in a comma list
2706          * @return string
2707          */
2708         function commaList( $list ) {
2709                 return implode(
2710                         $list,
2711                         wfMsgExt(
2712                                 'comma-separator',
2713                                 array( 'parsemag', 'escapenoentities', 'language' => $this )
2714                         )
2715                 );
2716         }
2717
2718         /**
2719          * Take a list of strings and build a locale-friendly semicolon-separated
2720          * list, using the local semicolon-separator message.
2721          * @param $list array of strings to put in a semicolon list
2722          * @return string
2723          */
2724         function semicolonList( $list ) {
2725                 return implode(
2726                         $list,
2727                         wfMsgExt(
2728                                 'semicolon-separator',
2729                                 array( 'parsemag', 'escapenoentities', 'language' => $this )
2730                         )
2731                 );
2732         }
2733
2734         /**
2735          * Same as commaList, but separate it with the pipe instead.
2736          * @param $list array of strings to put in a pipe list
2737          * @return string
2738          */
2739         function pipeList( $list ) {
2740                 return implode(
2741                         $list,
2742                         wfMsgExt(
2743                                 'pipe-separator',
2744                                 array( 'escapenoentities', 'language' => $this )
2745                         )
2746                 );
2747         }
2748
2749         /**
2750          * Truncate a string to a specified length in bytes, appending an optional
2751          * string (e.g. for ellipses)
2752          *
2753          * The database offers limited byte lengths for some columns in the database;
2754          * multi-byte character sets mean we need to ensure that only whole characters
2755          * are included, otherwise broken characters can be passed to the user
2756          *
2757          * If $length is negative, the string will be truncated from the beginning
2758          *
2759          * @param $string String to truncate
2760          * @param $length Int: maximum length (including ellipses)
2761          * @param $ellipsis String to append to the truncated text
2762          * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
2763          *      $adjustLength was introduced in 1.18, before that behaved as if false.
2764          * @return string
2765          */
2766         function truncate( $string, $length, $ellipsis = '...', $adjustLength = true ) {
2767                 # Use the localized ellipsis character
2768                 if ( $ellipsis == '...' ) {
2769                         $ellipsis = wfMsgExt( 'ellipsis', array( 'escapenoentities', 'language' => $this ) );
2770                 }
2771                 # Check if there is no need to truncate
2772                 if ( $length == 0 ) {
2773                         return $ellipsis; // convention
2774                 } elseif ( strlen( $string ) <= abs( $length ) ) {
2775                         return $string; // no need to truncate
2776                 }
2777                 $stringOriginal = $string;
2778                 # If ellipsis length is >= $length then we can't apply $adjustLength
2779                 if ( $adjustLength && strlen( $ellipsis ) >= abs( $length ) ) {
2780                         $string = $ellipsis; // this can be slightly unexpected
2781                 # Otherwise, truncate and add ellipsis...
2782                 } else {
2783                         $eLength = $adjustLength ? strlen( $ellipsis ) : 0;
2784                         if ( $length > 0 ) {
2785                                 $length -= $eLength;
2786                                 $string = substr( $string, 0, $length ); // xyz...
2787                                 $string = $this->removeBadCharLast( $string );
2788                                 $string = $string . $ellipsis;
2789                         } else {
2790                                 $length += $eLength;
2791                                 $string = substr( $string, $length ); // ...xyz
2792                                 $string = $this->removeBadCharFirst( $string );
2793                                 $string = $ellipsis . $string;
2794                         }
2795                 }
2796                 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
2797                 # This check is *not* redundant if $adjustLength, due to the single case where
2798                 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
2799                 if ( strlen( $string ) < strlen( $stringOriginal ) ) {
2800                         return $string;
2801                 } else {
2802                         return $stringOriginal;
2803                 }
2804         }
2805
2806         /**
2807          * Remove bytes that represent an incomplete Unicode character
2808          * at the end of string (e.g. bytes of the char are missing)
2809          *
2810          * @param $string String
2811          * @return string
2812          */
2813         protected function removeBadCharLast( $string ) {
2814                 if ( $string != '' ) {
2815                         $char = ord( $string[strlen( $string ) - 1] );
2816                         $m = array();
2817                         if ( $char >= 0xc0 ) {
2818                                 # We got the first byte only of a multibyte char; remove it.
2819                                 $string = substr( $string, 0, -1 );
2820                         } elseif ( $char >= 0x80 &&
2821                                   preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
2822                                                           '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) )
2823                         {
2824                                 # We chopped in the middle of a character; remove it
2825                                 $string = $m[1];
2826                         }
2827                 }
2828                 return $string;
2829         }
2830
2831         /**
2832          * Remove bytes that represent an incomplete Unicode character
2833          * at the start of string (e.g. bytes of the char are missing)
2834          *
2835          * @param $string String
2836          * @return string
2837          */
2838         protected function removeBadCharFirst( $string ) {
2839                 if ( $string != '' ) {
2840                         $char = ord( $string[0] );
2841                         if ( $char >= 0x80 && $char < 0xc0 ) {
2842                                 # We chopped in the middle of a character; remove the whole thing
2843                                 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
2844                         }
2845                 }
2846                 return $string;
2847         }
2848
2849         /**
2850          * Truncate a string of valid HTML to a specified length in bytes,
2851          * appending an optional string (e.g. for ellipses), and return valid HTML
2852          *
2853          * This is only intended for styled/linked text, such as HTML with
2854          * tags like <span> and <a>, were the tags are self-contained (valid HTML).
2855          * Also, this will not detect things like "display:none" CSS.
2856          *
2857          * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
2858          *
2859          * @param string $text HTML string to truncate
2860          * @param int $length (zero/positive) Maximum length (including ellipses)
2861          * @param string $ellipsis String to append to the truncated text
2862          * @return string
2863          */
2864         function truncateHtml( $text, $length, $ellipsis = '...' ) {
2865                 # Use the localized ellipsis character
2866                 if ( $ellipsis == '...' ) {
2867                         $ellipsis = wfMsgExt( 'ellipsis', array( 'escapenoentities', 'language' => $this ) );
2868                 }
2869                 # Check if there is clearly no need to truncate
2870                 if ( $length <= 0 ) {
2871                         return $ellipsis; // no text shown, nothing to format (convention)
2872                 } elseif ( strlen( $text ) <= $length ) {
2873                         return $text; // string short enough even *with* HTML (short-circuit)
2874                 }
2875
2876                 $dispLen = 0; // innerHTML legth so far
2877                 $testingEllipsis = false; // checking if ellipses will make string longer/equal?
2878                 $tagType = 0; // 0-open, 1-close
2879                 $bracketState = 0; // 1-tag start, 2-tag name, 0-neither
2880                 $entityState = 0; // 0-not entity, 1-entity
2881                 $tag = $ret = ''; // accumulated tag name, accumulated result string
2882                 $openTags = array(); // open tag stack
2883                 $maybeState = null; // possible truncation state
2884
2885                 $textLen = strlen( $text );
2886                 $neLength = max( 0, $length - strlen( $ellipsis ) ); // non-ellipsis len if truncated
2887                 for ( $pos = 0; true; ++$pos ) {
2888                         # Consider truncation once the display length has reached the maximim.
2889                         # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
2890                         # Check that we're not in the middle of a bracket/entity...
2891                         if ( $dispLen && $dispLen >= $neLength && $bracketState == 0 && !$entityState ) {
2892                                 if ( !$testingEllipsis ) {
2893                                         $testingEllipsis = true;
2894                                         # Save where we are; we will truncate here unless there turn out to
2895                                         # be so few remaining characters that truncation is not necessary.
2896                                         if ( !$maybeState ) { // already saved? ($neLength = 0 case)
2897                                                 $maybeState = array( $ret, $openTags ); // save state
2898                                         }
2899                                 } elseif ( $dispLen > $length && $dispLen > strlen( $ellipsis ) ) {
2900                                         # String in fact does need truncation, the truncation point was OK.
2901                                         list( $ret, $openTags ) = $maybeState; // reload state
2902                                         $ret = $this->removeBadCharLast( $ret ); // multi-byte char fix
2903                                         $ret .= $ellipsis; // add ellipsis
2904                                         break;
2905                                 }
2906                         }
2907                         if ( $pos >= $textLen ) break; // extra iteration just for above checks
2908
2909                         # Read the next char...
2910                         $ch = $text[$pos];
2911                         $lastCh = $pos ? $text[$pos - 1] : '';
2912                         $ret .= $ch; // add to result string
2913                         if ( $ch == '<' ) {
2914                                 $this->truncate_endBracket( $tag, $tagType, $lastCh, $openTags ); // for bad HTML
2915                                 $entityState = 0; // for bad HTML
2916                                 $bracketState = 1; // tag started (checking for backslash)
2917                         } elseif ( $ch == '>' ) {
2918                                 $this->truncate_endBracket( $tag, $tagType, $lastCh, $openTags );
2919                                 $entityState = 0; // for bad HTML
2920                                 $bracketState = 0; // out of brackets
2921                         } elseif ( $bracketState == 1 ) {
2922                                 if ( $ch == '/' ) {
2923                                         $tagType = 1; // close tag (e.g. "</span>")
2924                                 } else {
2925                                         $tagType = 0; // open tag (e.g. "<span>")
2926                                         $tag .= $ch;
2927                                 }
2928                                 $bracketState = 2; // building tag name
2929                         } elseif ( $bracketState == 2 ) {
2930                                 if ( $ch != ' ' ) {
2931                                         $tag .= $ch;
2932                                 } else {
2933                                         // Name found (e.g. "<a href=..."), add on tag attributes...
2934                                         $pos += $this->truncate_skip( $ret, $text, "<>", $pos + 1 );
2935                                 }
2936                         } elseif ( $bracketState == 0 ) {
2937                                 if ( $entityState ) {
2938                                         if ( $ch == ';' ) {
2939                                                 $entityState = 0;
2940                                                 $dispLen++; // entity is one displayed char
2941                                         }
2942                                 } else {
2943                                         if ( $neLength == 0 && !$maybeState ) {
2944                                                 // Save state without $ch. We want to *hit* the first
2945                                                 // display char (to get tags) but not *use* it if truncating.
2946                                                 $maybeState = array( substr( $ret, 0, -1 ), $openTags );
2947                                         }
2948                                         if ( $ch == '&' ) {
2949                                                 $entityState = 1; // entity found, (e.g. "&#160;")
2950                                         } else {
2951                                                 $dispLen++; // this char is displayed
2952                                                 // Add the next $max display text chars after this in one swoop...
2953                                                 $max = ( $testingEllipsis ? $length : $neLength ) - $dispLen;
2954                                                 $skipped = $this->truncate_skip( $ret, $text, "<>&", $pos + 1, $max );
2955                                                 $dispLen += $skipped;
2956                                                 $pos += $skipped;
2957                                         }
2958                                 }
2959                         }
2960                 }
2961                 // Close the last tag if left unclosed by bad HTML
2962                 $this->truncate_endBracket( $tag, $text[$textLen - 1], $tagType, $openTags );
2963                 while ( count( $openTags ) > 0 ) {
2964                         $ret .= '</' . array_pop( $openTags ) . '>'; // close open tags
2965                 }
2966                 return $ret;
2967         }
2968
2969         /**
2970          * truncateHtml() helper function
2971          * like strcspn() but adds the skipped chars to $ret
2972          *
2973          * @param $ret
2974          * @param $text
2975          * @param $search
2976          * @param $start
2977          * @param $len
2978          * @return int
2979          */
2980         private function truncate_skip( &$ret, $text, $search, $start, $len = null ) {
2981                 if ( $len === null ) {
2982                         $len = -1; // -1 means "no limit" for strcspn
2983                 } elseif ( $len < 0 ) {
2984                         $len = 0; // sanity
2985                 }
2986                 $skipCount = 0;
2987                 if ( $start < strlen( $text ) ) {
2988                         $skipCount = strcspn( $text, $search, $start, $len );
2989                         $ret .= substr( $text, $start, $skipCount );
2990                 }
2991                 return $skipCount;
2992         }
2993
2994         /**
2995          * truncateHtml() helper function
2996          * (a) push or pop $tag from $openTags as needed
2997          * (b) clear $tag value
2998          * @param String &$tag Current HTML tag name we are looking at
2999          * @param int $tagType (0-open tag, 1-close tag)
3000          * @param char $lastCh Character before the '>' that ended this tag
3001          * @param array &$openTags Open tag stack (not accounting for $tag)
3002          */
3003         private function truncate_endBracket( &$tag, $tagType, $lastCh, &$openTags ) {
3004                 $tag = ltrim( $tag );
3005                 if ( $tag != '' ) {
3006                         if ( $tagType == 0 && $lastCh != '/' ) {
3007                                 $openTags[] = $tag; // tag opened (didn't close itself)
3008                         } elseif ( $tagType == 1 ) {
3009                                 if ( $openTags && $tag == $openTags[count( $openTags ) - 1] ) {
3010                                         array_pop( $openTags ); // tag closed
3011                                 }
3012                         }
3013                         $tag = '';
3014                 }
3015         }
3016
3017         /**
3018          * Grammatical transformations, needed for inflected languages
3019          * Invoked by putting {{grammar:case|word}} in a message
3020          *
3021          * @param $word string
3022          * @param $case string
3023          * @return string
3024          */
3025         function convertGrammar( $word, $case ) {
3026                 global $wgGrammarForms;
3027                 if ( isset( $wgGrammarForms[$this->getCode()][$case][$word] ) ) {
3028                         return $wgGrammarForms[$this->getCode()][$case][$word];
3029                 }
3030                 return $word;
3031         }
3032
3033         /**
3034          * Provides an alternative text depending on specified gender.
3035          * Usage {{gender:username|masculine|feminine|neutral}}.
3036          * username is optional, in which case the gender of current user is used,
3037          * but only in (some) interface messages; otherwise default gender is used.
3038          * If second or third parameter are not specified, masculine is used.
3039          * These details may be overriden per language.
3040          *
3041          * @param $gender string
3042          * @param $forms array
3043          *
3044          * @return string
3045          */
3046         function gender( $gender, $forms ) {
3047                 if ( !count( $forms ) ) {
3048                         return '';
3049                 }
3050                 $forms = $this->preConvertPlural( $forms, 2 );
3051                 if ( $gender === 'male' ) {
3052                         return $forms[0];
3053                 }
3054                 if ( $gender === 'female' ) {
3055                         return $forms[1];
3056                 }
3057                 return isset( $forms[2] ) ? $forms[2] : $forms[0];
3058         }
3059
3060         /**
3061          * Plural form transformations, needed for some languages.
3062          * For example, there are 3 form of plural in Russian and Polish,
3063          * depending on "count mod 10". See [[w:Plural]]
3064          * For English it is pretty simple.
3065          *
3066          * Invoked by putting {{plural:count|wordform1|wordform2}}
3067          * or {{plural:count|wordform1|wordform2|wordform3}}
3068          *
3069          * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3070          *
3071          * @param $count Integer: non-localized number
3072          * @param $forms Array: different plural forms
3073          * @return string Correct form of plural for $count in this language
3074          */
3075         function convertPlural( $count, $forms ) {
3076                 if ( !count( $forms ) ) {
3077                         return '';
3078                 }
3079                 $forms = $this->preConvertPlural( $forms, 2 );
3080
3081                 return ( $count == 1 ) ? $forms[0] : $forms[1];
3082         }
3083
3084         /**
3085          * Checks that convertPlural was given an array and pads it to requested
3086          * amount of forms by copying the last one.
3087          *
3088          * @param $count Integer: How many forms should there be at least
3089          * @param $forms Array of forms given to convertPlural
3090          * @return array Padded array of forms or an exception if not an array
3091          */
3092         protected function preConvertPlural( /* Array */ $forms, $count ) {
3093                 while ( count( $forms ) < $count ) {
3094                         $forms[] = $forms[count( $forms ) - 1];
3095                 }
3096                 return $forms;
3097         }
3098
3099         /**
3100          * This translates the duration ("1 week", "4 days", etc)
3101          * as well as the expiry time (which is an absolute timestamp).
3102          * @param $str String: the validated block duration in English
3103          * @return Somehow translated block duration
3104          * @see LanguageFi.php for example implementation
3105          */
3106         function translateBlockExpiry( $str ) {
3107                 $duration = SpecialBlock::getSuggestedDurations( $this );
3108                 foreach ( $duration as $show => $value ) {
3109                         if ( strcmp( $str, $value ) == 0 ) {
3110                                 return htmlspecialchars( trim( $show ) );
3111                         }
3112                 }
3113
3114                 // Since usually only infinite or indefinite is only on list, so try
3115                 // equivalents if still here.
3116                 $indefs = array( 'infinite', 'infinity', 'indefinite' );
3117                 if ( in_array( $str, $indefs ) ) {
3118                         foreach ( $indefs as $val ) {
3119                                 $show = array_search( $val, $duration, true );
3120                                 if ( $show !== false ) {
3121                                         return htmlspecialchars( trim( $show ) );
3122                                 }
3123                         }
3124                 }
3125                 // If no duration is given, but a timestamp, display that
3126                 return ( strtotime( $str ) ? $this->timeanddate( strtotime( $str ) ) : $str );
3127         }
3128
3129         /**
3130          * languages like Chinese need to be segmented in order for the diff
3131          * to be of any use
3132          *
3133          * @param $text String
3134          * @return String
3135          */
3136         function segmentForDiff( $text ) {
3137                 return $text;
3138         }
3139
3140         /**
3141          * and unsegment to show the result
3142          *
3143          * @param $text String
3144          * @return String
3145          */
3146         function unsegmentForDiff( $text ) {
3147                 return $text;
3148         }
3149
3150         /**
3151          * convert text to all supported variants
3152          *
3153          * @param $text string
3154          * @return array
3155          */
3156         function autoConvertToAllVariants( $text ) {
3157                 return $this->mConverter->autoConvertToAllVariants( $text );
3158         }
3159
3160         /**
3161          * convert text to different variants of a language.
3162          *
3163          * @param $text string
3164          * @return string
3165          */
3166         function convert( $text ) {
3167                 return $this->mConverter->convert( $text );
3168         }
3169
3170
3171         /**
3172          * Convert a Title object to a string in the preferred variant
3173          *
3174          * @param $title Title
3175          * @return string
3176          */
3177         function convertTitle( $title ) {
3178                 return $this->mConverter->convertTitle( $title );
3179         }
3180
3181         /**
3182          * Check if this is a language with variants
3183          *
3184          * @return bool
3185          */
3186         function hasVariants() {
3187                 return sizeof( $this->getVariants() ) > 1;
3188         }
3189
3190         /**
3191          * Put custom tags (e.g. -{ }-) around math to prevent conversion
3192          *
3193          * @param $text string
3194          * @return string
3195          */
3196         function armourMath( $text ) {
3197                 return $this->mConverter->armourMath( $text );
3198         }
3199
3200         /**
3201          * Perform output conversion on a string, and encode for safe HTML output.
3202          * @param $text String text to be converted
3203          * @param $isTitle Bool whether this conversion is for the article title
3204          * @return string
3205          * @todo this should get integrated somewhere sane
3206          */
3207         function convertHtml( $text, $isTitle = false ) {
3208                 return htmlspecialchars( $this->convert( $text, $isTitle ) );
3209         }
3210
3211         /**
3212          * @param $key string
3213          * @return string
3214          */
3215         function convertCategoryKey( $key ) {
3216                 return $this->mConverter->convertCategoryKey( $key );
3217         }
3218
3219         /**
3220          * Get the list of variants supported by this language
3221          * see sample implementation in LanguageZh.php
3222          *
3223          * @return array an array of language codes
3224          */
3225         function getVariants() {
3226                 return $this->mConverter->getVariants();
3227         }
3228
3229         /**
3230          * @return string
3231          */
3232         function getPreferredVariant() {
3233                 return $this->mConverter->getPreferredVariant();
3234         }
3235
3236         /**
3237          * @return string
3238          */
3239         function getDefaultVariant() {
3240                 return $this->mConverter->getDefaultVariant();
3241         }
3242
3243         /**
3244          * @return string
3245          */
3246         function getURLVariant() {
3247                 return $this->mConverter->getURLVariant();
3248         }
3249
3250         /**
3251          * If a language supports multiple variants, it is
3252          * possible that non-existing link in one variant
3253          * actually exists in another variant. this function
3254          * tries to find it. See e.g. LanguageZh.php
3255          *
3256          * @param $link String: the name of the link
3257          * @param $nt Mixed: the title object of the link
3258          * @param $ignoreOtherCond Boolean: to disable other conditions when
3259          *      we need to transclude a template or update a category's link
3260          * @return null the input parameters may be modified upon return
3261          */
3262         function findVariantLink( &$link, &$nt, $ignoreOtherCond = false ) {
3263                 $this->mConverter->findVariantLink( $link, $nt, $ignoreOtherCond );
3264         }
3265
3266         /**
3267          * If a language supports multiple variants, converts text
3268          * into an array of all possible variants of the text:
3269          *  'variant' => text in that variant
3270          *
3271          * @deprecated since 1.17 Use autoConvertToAllVariants()
3272          *
3273          * @param $text string
3274          *
3275          * @return string
3276          */
3277         function convertLinkToAllVariants( $text ) {
3278                 return $this->mConverter->convertLinkToAllVariants( $text );
3279         }
3280
3281         /**
3282          * returns language specific options used by User::getPageRenderHash()
3283          * for example, the preferred language variant
3284          *
3285          * @return string
3286          */
3287         function getExtraHashOptions() {
3288                 return $this->mConverter->getExtraHashOptions();
3289         }
3290
3291         /**
3292          * For languages that support multiple variants, the title of an
3293          * article may be displayed differently in different variants. this
3294          * function returns the apporiate title defined in the body of the article.
3295          *
3296          * @return string
3297          */
3298         function getParsedTitle() {
3299                 return $this->mConverter->getParsedTitle();
3300         }
3301
3302         /**
3303          * Enclose a string with the "no conversion" tag. This is used by
3304          * various functions in the Parser
3305          *
3306          * @param $text String: text to be tagged for no conversion
3307          * @param $noParse bool
3308          * @return string the tagged text
3309          */
3310         function markNoConversion( $text, $noParse = false ) {
3311                 return $this->mConverter->markNoConversion( $text, $noParse );
3312         }
3313
3314         /**
3315          * A regular expression to match legal word-trailing characters
3316          * which should be merged onto a link of the form [[foo]]bar.
3317          *
3318          * @return string
3319          */
3320         function linkTrail() {
3321                 return self::$dataCache->getItem( $this->mCode, 'linkTrail' );
3322         }
3323
3324         /**
3325          * @return Language
3326          */
3327         function getLangObj() {
3328                 return $this;
3329         }
3330
3331         /**
3332          * Get the RFC 3066 code for this language object
3333          *
3334          * @return string
3335          */
3336         function getCode() {
3337                 return $this->mCode;
3338         }
3339
3340         /**
3341          * @param $code string
3342          */
3343         function setCode( $code ) {
3344                 $this->mCode = $code;
3345         }
3346
3347         /**
3348          * Get the name of a file for a certain language code
3349          * @param $prefix string Prepend this to the filename
3350          * @param $code string Language code
3351          * @param $suffix string Append this to the filename
3352          * @return string $prefix . $mangledCode . $suffix
3353          */
3354         static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
3355                 // Protect against path traversal
3356                 if ( !Language::isValidCode( $code )
3357                         || strcspn( $code, ":/\\\000" ) !== strlen( $code ) )
3358                 {
3359                         throw new MWException( "Invalid language code \"$code\"" );
3360                 }
3361
3362                 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
3363         }
3364
3365         /**
3366          * Get the language code from a file name. Inverse of getFileName()
3367          * @param $filename string $prefix . $languageCode . $suffix
3368          * @param $prefix string Prefix before the language code
3369          * @param $suffix string Suffix after the language code
3370          * @return string Language code, or false if $prefix or $suffix isn't found
3371          */
3372         static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3373                 $m = null;
3374                 preg_match( '/' . preg_quote( $prefix, '/' ) . '([A-Z][a-z_]+)' .
3375                         preg_quote( $suffix, '/' ) . '/', $filename, $m );
3376                 if ( !count( $m ) ) {
3377                         return false;
3378                 }
3379                 return str_replace( '_', '-', strtolower( $m[1] ) );
3380         }
3381
3382         /**
3383          * @param $code string
3384          * @return string
3385          */
3386         static function getMessagesFileName( $code ) {
3387                 global $IP;
3388                 return self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
3389         }
3390
3391         /**
3392          * @param $code string
3393          * @return string
3394          */
3395         static function getClassFileName( $code ) {
3396                 global $IP;
3397                 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
3398         }
3399
3400         /**
3401          * Get the first fallback for a given language.
3402          *
3403          * @param $code string
3404          *
3405          * @return false|string
3406          */
3407         static function getFallbackFor( $code ) {
3408                 if ( $code === 'en' || !Language::isValidBuiltInCode( $code ) ) {
3409                         return false;
3410                 } else {
3411                         $fallbacks = self::getFallbacksFor( $code );
3412                         $first = array_shift( $fallbacks );
3413                         return $first;
3414                 }
3415         }
3416
3417         /**
3418          * Get the ordered list of fallback languages.
3419          *
3420          * @since 1.19
3421          * @param $code string Language code
3422          * @return array
3423          */
3424         static function getFallbacksFor( $code ) {
3425                 if ( $code === 'en' || !Language::isValidBuiltInCode( $code ) ) {
3426                         return array();
3427                 } else {
3428                         $v = self::getLocalisationCache()->getItem( $code, 'fallback' );
3429                         $v = array_map( 'trim', explode( ',', $v ) );
3430                         if ( $v[count( $v ) - 1] !== 'en' ) {
3431                                 $v[] = 'en';
3432                         }
3433                         return $v;
3434                 }
3435         }
3436
3437         /**
3438          * Get all messages for a given language
3439          * WARNING: this may take a long time. If you just need all message *keys*
3440          * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3441          *
3442          * @param $code string
3443          *
3444          * @return array
3445          */
3446         static function getMessagesFor( $code ) {
3447                 return self::getLocalisationCache()->getItem( $code, 'messages' );
3448         }
3449
3450         /**
3451          * Get a message for a given language
3452          *
3453          * @param $key string
3454          * @param $code string
3455          *
3456          * @return string
3457          */
3458         static function getMessageFor( $key, $code ) {
3459                 return self::getLocalisationCache()->getSubitem( $code, 'messages', $key );
3460         }
3461
3462         /**
3463          * Get all message keys for a given language. This is a faster alternative to
3464          * array_keys( Language::getMessagesFor( $code ) )
3465          *
3466          * @since 1.19
3467          * @param $code string Language code
3468          * @return array of message keys (strings)
3469          */
3470         static function getMessageKeysFor( $code ) {
3471                 return self::getLocalisationCache()->getSubItemList( $code, 'messages' );
3472         }
3473
3474         /**
3475          * @param $talk
3476          * @return mixed
3477          */
3478         function fixVariableInNamespace( $talk ) {
3479                 if ( strpos( $talk, '$1' ) === false ) {
3480                         return $talk;
3481                 }
3482
3483                 global $wgMetaNamespace;
3484                 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
3485
3486                 # Allow grammar transformations
3487                 # Allowing full message-style parsing would make simple requests
3488                 # such as action=raw much more expensive than they need to be.
3489                 # This will hopefully cover most cases.
3490                 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
3491                         array( &$this, 'replaceGrammarInNamespace' ), $talk );
3492                 return str_replace( ' ', '_', $talk );
3493         }
3494
3495         /**
3496          * @param $m string
3497          * @return string
3498          */
3499         function replaceGrammarInNamespace( $m ) {
3500                 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
3501         }
3502
3503         /**
3504          * @throws MWException
3505          * @return array
3506          */
3507         static function getCaseMaps() {
3508                 static $wikiUpperChars, $wikiLowerChars;
3509                 if ( isset( $wikiUpperChars ) ) {
3510                         return array( $wikiUpperChars, $wikiLowerChars );
3511                 }
3512
3513                 wfProfileIn( __METHOD__ );
3514                 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
3515                 if ( $arr === false ) {
3516                         throw new MWException(
3517                                 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
3518                 }
3519                 $wikiUpperChars = $arr['wikiUpperChars'];
3520                 $wikiLowerChars = $arr['wikiLowerChars'];
3521                 wfProfileOut( __METHOD__ );
3522                 return array( $wikiUpperChars, $wikiLowerChars );
3523         }
3524
3525         /**
3526          * Decode an expiry (block, protection, etc) which has come from the DB
3527          *
3528          * @param $expiry String: Database expiry String
3529          * @param $format Bool|Int true to process using language functions, or TS_ constant
3530          *     to return the expiry in a given timestamp
3531          * @return String
3532          */
3533         public function formatExpiry( $expiry, $format = true ) {
3534                 static $infinity, $infinityMsg;
3535                 if ( $infinity === null ) {
3536                         $infinityMsg = wfMessage( 'infiniteblock' );
3537                         $infinity = wfGetDB( DB_SLAVE )->getInfinity();
3538                 }
3539
3540                 if ( $expiry == '' || $expiry == $infinity ) {
3541                         return $format === true
3542                                 ? $infinityMsg
3543                                 : $infinity;
3544                 } else {
3545                         return $format === true
3546                                 ? $this->timeanddate( $expiry )
3547                                 : wfTimestamp( $format, $expiry );
3548                 }
3549         }
3550
3551         /**
3552          * @todo Document
3553          * @param $seconds int|float
3554          * @param $format String Optional, one of ("avoidseconds","avoidminutes"):
3555          *              "avoidseconds" - don't mention seconds if $seconds >= 1 hour
3556          *              "avoidminutes" - don't mention seconds/minutes if $seconds > 48 hours
3557          * @return string
3558          */
3559         function formatTimePeriod( $seconds, $format = false ) {
3560                 if ( round( $seconds * 10 ) < 100 ) {
3561                         $s = $this->formatNum( sprintf( "%.1f", round( $seconds * 10 ) / 10 ) );
3562                         $s .= $this->getMessageFromDB( 'seconds-abbrev' );
3563                 } elseif ( round( $seconds ) < 60 ) {
3564                         $s = $this->formatNum( round( $seconds ) );
3565                         $s .= $this->getMessageFromDB( 'seconds-abbrev' );
3566                 } elseif ( round( $seconds ) < 3600 ) {
3567                         $minutes = floor( $seconds / 60 );
3568                         $secondsPart = round( fmod( $seconds, 60 ) );
3569                         if ( $secondsPart == 60 ) {
3570                                 $secondsPart = 0;
3571                                 $minutes++;
3572                         }
3573                         $s = $this->formatNum( $minutes ) . $this->getMessageFromDB( 'minutes-abbrev' );
3574                         $s .= ' ';
3575                         $s .= $this->formatNum( $secondsPart ) . $this->getMessageFromDB( 'seconds-abbrev' );
3576                 } elseif ( round( $seconds ) <= 2 * 86400 ) {
3577                         $hours = floor( $seconds / 3600 );
3578                         $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
3579                         $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
3580                         if ( $secondsPart == 60 ) {
3581                                 $secondsPart = 0;
3582                                 $minutes++;
3583                         }
3584                         if ( $minutes == 60 ) {
3585                                 $minutes = 0;
3586                                 $hours++;
3587                         }
3588                         $s = $this->formatNum( $hours ) . $this->getMessageFromDB( 'hours-abbrev' );
3589                         $s .= ' ';
3590                         $s .= $this->formatNum( $minutes ) . $this->getMessageFromDB( 'minutes-abbrev' );
3591                         if ( !in_array( $format, array( 'avoidseconds', 'avoidminutes' ) ) ) {
3592                                 $s .= ' ' . $this->formatNum( $secondsPart ) .
3593                                         $this->getMessageFromDB( 'seconds-abbrev' );
3594                         }
3595                 } else {
3596                         $days = floor( $seconds / 86400 );
3597                         if ( $format === 'avoidminutes' ) {
3598                                 $hours = round( ( $seconds - $days * 86400 ) / 3600 );
3599                                 if ( $hours == 24 ) {
3600                                         $hours = 0;
3601                                         $days++;
3602                                 }
3603                                 $s = $this->formatNum( $days ) . $this->getMessageFromDB( 'days-abbrev' );
3604                                 $s .= ' ';
3605                                 $s .= $this->formatNum( $hours ) . $this->getMessageFromDB( 'hours-abbrev' );
3606                         } elseif ( $format === 'avoidseconds' ) {
3607                                 $hours = floor( ( $seconds - $days * 86400 ) / 3600 );
3608                                 $minutes = round( ( $seconds - $days * 86400 - $hours * 3600 ) / 60 );
3609                                 if ( $minutes == 60 ) {
3610                                         $minutes = 0;
3611                                         $hours++;
3612                                 }
3613                                 if ( $hours == 24 ) {
3614                                         $hours = 0;
3615                                         $days++;
3616                                 }
3617                                 $s = $this->formatNum( $days ) . $this->getMessageFromDB( 'days-abbrev' );
3618                                 $s .= ' ';
3619                                 $s .= $this->formatNum( $hours ) . $this->getMessageFromDB( 'hours-abbrev' );
3620                                 $s .= ' ';
3621                                 $s .= $this->formatNum( $minutes ) . $this->getMessageFromDB( 'minutes-abbrev' );
3622                         } else {
3623                                 $s = $this->formatNum( $days ) . $this->getMessageFromDB( 'days-abbrev' );
3624                                 $s .= ' ';
3625                                 $s .= $this->formatTimePeriod( $seconds - $days * 86400, $format );
3626                         }
3627                 }
3628                 return $s;
3629         }
3630
3631         /**
3632          * @param $bps int
3633          * @return string
3634          */
3635         function formatBitrate( $bps ) {
3636                 $units = array( 'bps', 'kbps', 'Mbps', 'Gbps' );
3637                 if ( $bps <= 0 ) {
3638                         return $this->formatNum( $bps ) . $units[0];
3639                 }
3640                 $unitIndex = floor( log10( $bps ) / 3 );
3641                 $mantissa = $bps / pow( 1000, $unitIndex );
3642                 if ( $mantissa < 10 ) {
3643                         $mantissa = round( $mantissa, 1 );
3644                 } else {
3645                         $mantissa = round( $mantissa );
3646                 }
3647                 return $this->formatNum( $mantissa ) . $units[$unitIndex];
3648         }
3649
3650         /**
3651          * Format a size in bytes for output, using an appropriate
3652          * unit (B, KB, MB or GB) according to the magnitude in question
3653          *
3654          * @param $size int Size to format
3655          * @return string Plain text (not HTML)
3656          */
3657         function formatSize( $size ) {
3658                 // For small sizes no decimal places necessary
3659                 $round = 0;
3660                 if ( $size > 1024 ) {
3661                         $size = $size / 1024;
3662                         if ( $size > 1024 ) {
3663                                 $size = $size / 1024;
3664                                 // For MB and bigger two decimal places are smarter
3665                                 $round = 2;
3666                                 if ( $size > 1024 ) {
3667                                         $size = $size / 1024;
3668                                         $msg = 'size-gigabytes';
3669                                 } else {
3670                                         $msg = 'size-megabytes';
3671                                 }
3672                         } else {
3673                                 $msg = 'size-kilobytes';
3674                         }
3675                 } else {
3676                         $msg = 'size-bytes';
3677                 }
3678                 $size = round( $size, $round );
3679                 $text = $this->getMessageFromDB( $msg );
3680                 return str_replace( '$1', $this->formatNum( $size ), $text );
3681         }
3682
3683         /**
3684          * Get the conversion rule title, if any.
3685          *
3686          * @return string
3687          */
3688         function getConvRuleTitle() {
3689                 return $this->mConverter->getConvRuleTitle();
3690         }
3691 }