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