languages/Language.php

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