languages/Language.php

   1 <?php
   2 /**
   3  * @defgroup Language Language
   4  *
   5  * @file
   6  * @ingroup Language
   7  */
   8
   9 if( !defined( 'MEDIAWIKI' ) ) {
  10         echo "This file is part of MediaWiki, it is not a valid entry point.\n";
  11         exit( 1 );
  12 }
  13
  14 # Read language names
  15 global $wgLanguageNames;
  16 require_once( dirname(__FILE__) . '/Names.php' ) ;
  17
  18 global $wgInputEncoding, $wgOutputEncoding;
  19
  20 /**
  21  * These are always UTF-8, they exist only for backwards compatibility
  22  */
  23 $wgInputEncoding    = "UTF-8";
  24 $wgOutputEncoding       = "UTF-8";
  25
  26 if( function_exists( 'mb_strtoupper' ) ) {
  27         mb_internal_encoding('UTF-8');
  28 }
  29
  30 /**
  31  * a fake language converter
  32  *
  33  * @ingroup Language
  34  */
  35 class FakeConverter {
  36         var $mLang;
  37         function FakeConverter($langobj) {$this->mLang = $langobj;}
  38         function autoConvertToAllVariants($text) {return $text;}
  39         function convert($t, $i) {return $t;}
  40         function parserConvert($t, $p) {return $t;}
  41         function getVariants() { return array( $this->mLang->getCode() ); }
  42         function getPreferredVariant() {return $this->mLang->getCode(); }
  43         function findVariantLink(&$l, &$n, $ignoreOtherCond = false) {}
  44         function getExtraHashOptions() {return '';}
  45         function getParsedTitle() {return '';}
  46         function markNoConversion($text, $noParse=false) {return $text;}
  47         function convertCategoryKey( $key ) {return $key; }
  48         function convertLinkToAllVariants($text){ return array( $this->mLang->getCode() => $text); }
  49         function armourMath($text){ return $text; }
  50 }
  51
  52 /**
  53  * Internationalisation code
  54  * @ingroup Language
  55  */
  56 class Language {
  57         var $mConverter, $mVariants, $mCode, $mLoaded = false;
  58         var $mMagicExtensions = array(), $mMagicHookDone = false;
  59
  60         var $mNamespaceIds, $namespaceNames, $namespaceAliases;
  61         var $dateFormatStrings = array();
  62         var $minSearchLength;
  63         var $mExtendedSpecialPageAliases;
  64
  65         static public $dataCache;
  66         static public $mLangObjCache = array();
  67
  68         static public $mWeekdayMsgs = array(
  69                 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
  70                 'friday', 'saturday'
  71         );
  72
  73         static public $mWeekdayAbbrevMsgs = array(
  74                 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'
  75         );
  76
  77         static public $mMonthMsgs = array(
  78                 'january', 'february', 'march', 'april', 'may_long', 'june',
  79                 'july', 'august', 'september', 'october', 'november',
  80                 'december'
  81         );
  82         static public $mMonthGenMsgs = array(
  83                 'january-gen', 'february-gen', 'march-gen', 'april-gen', 'may-gen', 'june-gen',
  84                 'july-gen', 'august-gen', 'september-gen', 'october-gen', 'november-gen',
  85                 'december-gen'
  86         );
  87         static public $mMonthAbbrevMsgs = array(
  88                 'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
  89                 'sep', 'oct', 'nov', 'dec'
  90         );
  91
  92         static public $mIranianCalendarMonthMsgs = array(
  93                 'iranian-calendar-m1', 'iranian-calendar-m2', 'iranian-calendar-m3',
  94                 'iranian-calendar-m4', 'iranian-calendar-m5', 'iranian-calendar-m6',
  95                 'iranian-calendar-m7', 'iranian-calendar-m8', 'iranian-calendar-m9',
  96                 'iranian-calendar-m10', 'iranian-calendar-m11', 'iranian-calendar-m12'
  97         );
  98
  99         static public $mHebrewCalendarMonthMsgs = array(
 100                 'hebrew-calendar-m1', 'hebrew-calendar-m2', 'hebrew-calendar-m3',
 101                 'hebrew-calendar-m4', 'hebrew-calendar-m5', 'hebrew-calendar-m6',
 102                 'hebrew-calendar-m7', 'hebrew-calendar-m8', 'hebrew-calendar-m9',
 103                 'hebrew-calendar-m10', 'hebrew-calendar-m11', 'hebrew-calendar-m12',
 104                 'hebrew-calendar-m6a', 'hebrew-calendar-m6b'
 105         );
 106
 107         static public $mHebrewCalendarMonthGenMsgs = array(
 108                 'hebrew-calendar-m1-gen', 'hebrew-calendar-m2-gen', 'hebrew-calendar-m3-gen',
 109                 'hebrew-calendar-m4-gen', 'hebrew-calendar-m5-gen', 'hebrew-calendar-m6-gen',
 110                 'hebrew-calendar-m7-gen', 'hebrew-calendar-m8-gen', 'hebrew-calendar-m9-gen',
 111                 'hebrew-calendar-m10-gen', 'hebrew-calendar-m11-gen', 'hebrew-calendar-m12-gen',
 112                 'hebrew-calendar-m6a-gen', 'hebrew-calendar-m6b-gen'
 113         );
 114
 115         static public $mHijriCalendarMonthMsgs = array(
 116                 'hijri-calendar-m1', 'hijri-calendar-m2', 'hijri-calendar-m3',
 117                 'hijri-calendar-m4', 'hijri-calendar-m5', 'hijri-calendar-m6',
 118                 'hijri-calendar-m7', 'hijri-calendar-m8', 'hijri-calendar-m9',
 119                 'hijri-calendar-m10', 'hijri-calendar-m11', 'hijri-calendar-m12'
 120         );
 121
 122         /**
 123          * Get a cached language object for a given language code
 124          */
 125         static function factory( $code ) {
 126                 if ( !isset( self::$mLangObjCache[$code] ) ) {
 127                         if( count( self::$mLangObjCache ) > 10 ) {
 128                                 // Don't keep a billion objects around, that's stupid.
 129                                 self::$mLangObjCache = array();
 130                         }
 131                         self::$mLangObjCache[$code] = self::newFromCode( $code );
 132                 }
 133                 return self::$mLangObjCache[$code];
 134         }
 135
 136         /**
 137          * Create a language object for a given language code
 138          */
 139         protected static function newFromCode( $code ) {
 140                 global $IP;
 141                 static $recursionLevel = 0;
 142                 if ( $code == 'en' ) {
 143                         $class = 'Language';
 144                 } else {
 145                         $class = 'Language' . str_replace( '-', '_', ucfirst( $code ) );
 146                         // Preload base classes to work around APC/PHP5 bug
 147                         if ( file_exists( "$IP/languages/classes/$class.deps.php" ) ) {
 148                                 include_once("$IP/languages/classes/$class.deps.php");
 149                         }
 150                         if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
 151                                 include_once("$IP/languages/classes/$class.php");
 152                         }
 153                 }
 154
 155                 if ( $recursionLevel > 5 ) {
 156                         throw new MWException( "Language fallback loop detected when creating class $class\n" );
 157                 }
 158
 159                 if( ! class_exists( $class ) ) {
 160                         $fallback = Language::getFallbackFor( $code );
 161                         ++$recursionLevel;
 162                         $lang = Language::newFromCode( $fallback );
 163                         --$recursionLevel;
 164                         $lang->setCode( $code );
 165                 } else {
 166                         $lang = new $class;
 167                 }
 168                 return $lang;
 169         }
 170
 171         /**
 172          * Get the LocalisationCache instance
 173          */
 174         public static function getLocalisationCache() {
 175                 if ( is_null( self::$dataCache ) ) {
 176                         global $wgLocalisationCacheConf;
 177                         $class = $wgLocalisationCacheConf['class'];
 178                         self::$dataCache = new $class( $wgLocalisationCacheConf );
 179                 }
 180                 return self::$dataCache;
 181         }
 182
 183         function __construct() {
 184                 $this->mConverter = new FakeConverter($this);
 185                 // Set the code to the name of the descendant
 186                 if ( get_class( $this ) == 'Language' ) {
 187                         $this->mCode = 'en';
 188                 } else {
 189                         $this->mCode = str_replace( '_', '-', strtolower( substr( get_class( $this ), 8 ) ) );
 190                 }
 191                 self::getLocalisationCache();
 192         }
 193
 194         /**
 195          * Reduce memory usage
 196          */
 197         function __destruct() {
 198                 foreach ( $this as $name => $value ) {
 199                         unset( $this->$name );
 200                 }
 201         }
 202
 203         /**
 204          * Hook which will be called if this is the content language.
 205          * Descendants can use this to register hook functions or modify globals
 206          */
 207         function initContLang() {}
 208
 209         /**
 210          * @deprecated Use User::getDefaultOptions()
 211          * @return array
 212          */
 213         function getDefaultUserOptions() {
 214                 wfDeprecated( __METHOD__ );
 215                 return User::getDefaultOptions();
 216         }
 217
 218         function getFallbackLanguageCode() {
 219                 if ( $this->mCode === 'en' ) {
 220                         return false;
 221                 } else {
 222                         return self::$dataCache->getItem( $this->mCode, 'fallback' );
 223                 }
 224         }
 225
 226         /**
 227          * Exports $wgBookstoreListEn
 228          * @return array
 229          */
 230         function getBookstoreList() {
 231                 return self::$dataCache->getItem( $this->mCode, 'bookstoreList' );
 232         }
 233
 234         /**
 235          * @return array
 236          */
 237         function getNamespaces() {
 238                 if ( is_null( $this->namespaceNames ) ) {
 239                         global $wgExtraNamespaces, $wgMetaNamespace, $wgMetaNamespaceTalk;
 240
 241                         $this->namespaceNames = self::$dataCache->getItem( $this->mCode, 'namespaceNames' );
 242                         if ( $wgExtraNamespaces ) {
 243                                 $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames;
 244                         }
 245
 246                         $this->namespaceNames[NS_PROJECT] = $wgMetaNamespace;
 247                         if ( $wgMetaNamespaceTalk ) {
 248                                 $this->namespaceNames[NS_PROJECT_TALK] = $wgMetaNamespaceTalk;
 249                         } else {
 250                                 $talk = $this->namespaceNames[NS_PROJECT_TALK];
 251                                 $this->namespaceNames[NS_PROJECT_TALK] =
 252                                         $this->fixVariableInNamespace( $talk );
 253                         }
 254
 255                         # The above mixing may leave namespaces out of canonical order.
 256                         # Re-order by namespace ID number...
 257                         ksort( $this->namespaceNames );
 258                 }
 259                 return $this->namespaceNames;
 260         }
 261
 262         /**
 263          * A convenience function that returns the same thing as
 264          * getNamespaces() except with the array values changed to ' '
 265          * where it found '_', useful for producing output to be displayed
 266          * e.g. in <select> forms.
 267          *
 268          * @return array
 269          */
 270         function getFormattedNamespaces() {
 271                 $ns = $this->getNamespaces();
 272                 foreach($ns as $k => $v) {
 273                         $ns[$k] = strtr($v, '_', ' ');
 274                 }
 275                 return $ns;
 276         }
 277
 278         /**
 279          * Get a namespace value by key
 280          * <code>
 281          * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
 282          * echo $mw_ns; // prints 'MediaWiki'
 283          * </code>
 284          *
 285          * @param $index Int: the array key of the namespace to return
 286          * @return mixed, string if the namespace value exists, otherwise false
 287          */
 288         function getNsText( $index ) {
 289                 $ns = $this->getNamespaces();
 290                 return isset( $ns[$index] ) ? $ns[$index] : false;
 291         }
 292
 293         /**
 294          * A convenience function that returns the same thing as
 295          * getNsText() except with '_' changed to ' ', useful for
 296          * producing output.
 297          *
 298          * @return array
 299          */
 300         function getFormattedNsText( $index ) {
 301                 $ns = $this->getNsText( $index );
 302                 return strtr($ns, '_', ' ');
 303         }
 304
 305         /**
 306          * Get a namespace key by value, case insensitive.
 307          * Only matches namespace names for the current language, not the
 308          * canonical ones defined in Namespace.php.
 309          *
 310          * @param $text String
 311          * @return mixed An integer if $text is a valid value otherwise false
 312          */
 313         function getLocalNsIndex( $text ) {
 314                 $lctext = $this->lc($text);
 315                 $ids = $this->getNamespaceIds();
 316                 return isset( $ids[$lctext] ) ? $ids[$lctext] : false;
 317         }
 318
 319         function getNamespaceAliases() {
 320                 if ( is_null( $this->namespaceAliases ) ) {
 321                         $aliases = self::$dataCache->getItem( $this->mCode, 'namespaceAliases' );
 322                         if ( !$aliases ) {
 323                                 $aliases = array();
 324                         } else {
 325                                 foreach ( $aliases as $name => $index ) {
 326                                         if ( $index === NS_PROJECT_TALK ) {
 327                                                 unset( $aliases[$name] );
 328                                                 $name = $this->fixVariableInNamespace( $name );
 329                                                 $aliases[$name] = $index;
 330                                         }
 331                                 }
 332                         }
 333                         $this->namespaceAliases = $aliases;
 334                 }
 335                 return $this->namespaceAliases;
 336         }
 337
 338         function getNamespaceIds() {
 339                 if ( is_null( $this->mNamespaceIds ) ) {
 340                         global $wgNamespaceAliases;
 341                         # Put namespace names and aliases into a hashtable.
 342                         # If this is too slow, then we should arrange it so that it is done
 343                         # before caching. The catch is that at pre-cache time, the above
 344                         # class-specific fixup hasn't been done.
 345                         $this->mNamespaceIds = array();
 346                         foreach ( $this->getNamespaces() as $index => $name ) {
 347                                 $this->mNamespaceIds[$this->lc($name)] = $index;
 348                         }
 349                         foreach ( $this->getNamespaceAliases() as $name => $index ) {
 350                                 $this->mNamespaceIds[$this->lc($name)] = $index;
 351                         }
 352                         if ( $wgNamespaceAliases ) {
 353                                 foreach ( $wgNamespaceAliases as $name => $index ) {
 354                                         $this->mNamespaceIds[$this->lc($name)] = $index;
 355                                 }
 356                         }
 357                 }
 358                 return $this->mNamespaceIds;
 359         }
 360
 361
 362         /**
 363          * Get a namespace key by value, case insensitive.  Canonical namespace
 364          * names override custom ones defined for the current language.
 365          *
 366          * @param $text String
 367          * @return mixed An integer if $text is a valid value otherwise false
 368          */
 369         function getNsIndex( $text ) {
 370                 $lctext = $this->lc($text);
 371                 if ( ( $ns = MWNamespace::getCanonicalIndex( $lctext ) ) !== null ) {
 372                         return $ns;
 373                 }
 374                 $ids = $this->getNamespaceIds();
 375                 return isset( $ids[$lctext] ) ? $ids[$lctext] : false;
 376         }
 377
 378         /**
 379          * short names for language variants used for language conversion links.
 380          *
 381          * @param $code String
 382          * @return string
 383          */
 384         function getVariantname( $code ) {
 385                 return $this->getMessageFromDB( "variantname-$code" );
 386         }
 387
 388         function specialPage( $name ) {
 389                 $aliases = $this->getSpecialPageAliases();
 390                 if ( isset( $aliases[$name][0] ) ) {
 391                         $name = $aliases[$name][0];
 392                 }
 393                 return $this->getNsText( NS_SPECIAL ) . ':' . $name;
 394         }
 395
 396         function getQuickbarSettings() {
 397                 return array(
 398                         $this->getMessage( 'qbsettings-none' ),
 399                         $this->getMessage( 'qbsettings-fixedleft' ),
 400                         $this->getMessage( 'qbsettings-fixedright' ),
 401                         $this->getMessage( 'qbsettings-floatingleft' ),
 402                         $this->getMessage( 'qbsettings-floatingright' )
 403                 );
 404         }
 405
 406         function getMathNames() {
 407                 return self::$dataCache->getItem( $this->mCode, 'mathNames' );
 408         }
 409
 410         function getDatePreferences() {
 411                 return self::$dataCache->getItem( $this->mCode, 'datePreferences' );
 412         }
 413
 414         function getDateFormats() {
 415                 return self::$dataCache->getItem( $this->mCode, 'dateFormats' );
 416         }
 417
 418         function getDefaultDateFormat() {
 419                 $df = self::$dataCache->getItem( $this->mCode, 'defaultDateFormat' );
 420                 if ( $df === 'dmy or mdy' ) {
 421                         global $wgAmericanDates;
 422                         return $wgAmericanDates ? 'mdy' : 'dmy';
 423                 } else {
 424                         return $df;
 425                 }
 426         }
 427
 428         function getDatePreferenceMigrationMap() {
 429                 return self::$dataCache->getItem( $this->mCode, 'datePreferenceMigrationMap' );
 430         }
 431
 432         function getImageFile( $image ) {
 433                 return self::$dataCache->getSubitem( $this->mCode, 'imageFiles', $image );
 434         }
 435
 436         function getDefaultUserOptionOverrides() {
 437                 return self::$dataCache->getItem( $this->mCode, 'defaultUserOptionOverrides' );
 438         }
 439
 440         function getExtraUserToggles() {
 441                 return self::$dataCache->getItem( $this->mCode, 'extraUserToggles' );
 442         }
 443
 444         function getUserToggle( $tog ) {
 445                 return $this->getMessageFromDB( "tog-$tog" );
 446         }
 447
 448         /**
 449          * Get language names, indexed by code.
 450          * If $customisedOnly is true, only returns codes with a messages file
 451          */
 452         public static function getLanguageNames( $customisedOnly = false ) {
 453                 global $wgLanguageNames, $wgExtraLanguageNames;
 454                 $allNames = $wgExtraLanguageNames + $wgLanguageNames;
 455                 if ( !$customisedOnly ) {
 456                         return $allNames;
 457                 }
 458
 459                 global $IP;
 460                 $names = array();
 461                 $dir = opendir( "$IP/languages/messages" );
 462                 while( false !== ( $file = readdir( $dir ) ) ) {
 463                         $m = array();
 464                         if( preg_match( '/Messages([A-Z][a-z_]+)\.php$/', $file, $m ) ) {
 465                                 $code = str_replace( '_', '-', strtolower( $m[1] ) );
 466                                 if ( isset( $allNames[$code] ) ) {
 467                                         $names[$code] = $allNames[$code];
 468                                 }
 469                         }
 470                 }
 471                 closedir( $dir );
 472                 return $names;
 473         }
 474
 475         /**
 476          * Get a message from the MediaWiki namespace.
 477          *
 478          * @param $msg String: message name
 479          * @return string
 480          */
 481         function getMessageFromDB( $msg ) {
 482                 return wfMsgExt( $msg, array( 'parsemag', 'language' => $this ) );
 483         }
 484
 485         function getLanguageName( $code ) {
 486                 $names = self::getLanguageNames();
 487                 if ( !array_key_exists( $code, $names ) ) {
 488                         return '';
 489                 }
 490                 return $names[$code];
 491         }
 492
 493         function getMonthName( $key ) {
 494                 return $this->getMessageFromDB( self::$mMonthMsgs[$key-1] );
 495         }
 496
 497         function getMonthNameGen( $key ) {
 498                 return $this->getMessageFromDB( self::$mMonthGenMsgs[$key-1] );
 499         }
 500
 501         function getMonthAbbreviation( $key ) {
 502                 return $this->getMessageFromDB( self::$mMonthAbbrevMsgs[$key-1] );
 503         }
 504
 505         function getWeekdayName( $key ) {
 506                 return $this->getMessageFromDB( self::$mWeekdayMsgs[$key-1] );
 507         }
 508
 509         function getWeekdayAbbreviation( $key ) {
 510                 return $this->getMessageFromDB( self::$mWeekdayAbbrevMsgs[$key-1] );
 511         }
 512
 513         function getIranianCalendarMonthName( $key ) {
 514                 return $this->getMessageFromDB( self::$mIranianCalendarMonthMsgs[$key-1] );
 515         }
 516
 517         function getHebrewCalendarMonthName( $key ) {
 518                 return $this->getMessageFromDB( self::$mHebrewCalendarMonthMsgs[$key-1] );
 519         }
 520
 521         function getHebrewCalendarMonthNameGen( $key ) {
 522                 return $this->getMessageFromDB( self::$mHebrewCalendarMonthGenMsgs[$key-1] );
 523         }
 524
 525         function getHijriCalendarMonthName( $key ) {
 526                 return $this->getMessageFromDB( self::$mHijriCalendarMonthMsgs[$key-1] );
 527         }
 528
 529         /**
 530          * Used by date() and time() to adjust the time output.
 531          *
 532          * @param $ts Int the time in date('YmdHis') format
 533          * @param $tz Mixed: adjust the time by this amount (default false, mean we
 534          *            get user timecorrection setting)
 535          * @return int
 536          */
 537         function userAdjust( $ts, $tz = false ) {
 538                 global $wgUser, $wgLocalTZoffset;
 539
 540                 if ( $tz === false ) {
 541                         $tz = $wgUser->getOption( 'timecorrection' );
 542                 }
 543
 544                 $data = explode( '|', $tz, 3 );
 545
 546                 if ( $data[0] == 'ZoneInfo' ) {
 547                         if ( function_exists( 'timezone_open' ) && @timezone_open( $data[2] ) !== false ) {
 548                                 $date = date_create( $ts, timezone_open( 'UTC' ) );
 549                                 date_timezone_set( $date, timezone_open( $data[2] ) );
 550                                 $date = date_format( $date, 'YmdHis' );
 551                                 return $date;
 552                         }
 553                         # Unrecognized timezone, default to 'Offset' with the stored offset.
 554                         $data[0] = 'Offset';
 555                 }
 556
 557                 $minDiff = 0;
 558                 if ( $data[0] == 'System' || $tz == '' ) {
 559                         # Global offset in minutes.
 560                         if( isset($wgLocalTZoffset) ) $minDiff = $wgLocalTZoffset;
 561                 } else if ( $data[0] == 'Offset' ) {
 562                         $minDiff = intval( $data[1] );
 563                 } else {
 564                         $data = explode( ':', $tz );
 565                         if( count( $data ) == 2 ) {
 566                                 $data[0] = intval( $data[0] );
 567                                 $data[1] = intval( $data[1] );
 568                                 $minDiff = abs( $data[0] ) * 60 + $data[1];
 569                                 if ( $data[0] < 0 ) $minDiff = -$minDiff;
 570                         } else {
 571                                 $minDiff = intval( $data[0] ) * 60;
 572                         }
 573                 }
 574
 575                 # No difference ? Return time unchanged
 576                 if ( 0 == $minDiff ) return $ts;
 577
 578                 wfSuppressWarnings(); // E_STRICT system time bitching
 579                 # Generate an adjusted date; take advantage of the fact that mktime
 580                 # will normalize out-of-range values so we don't have to split $minDiff
 581                 # into hours and minutes.
 582                 $t = mktime( (
 583                   (int)substr( $ts, 8, 2) ), # Hours
 584                   (int)substr( $ts, 10, 2 ) + $minDiff, # Minutes
 585                   (int)substr( $ts, 12, 2 ), # Seconds
 586                   (int)substr( $ts, 4, 2 ), # Month
 587                   (int)substr( $ts, 6, 2 ), # Day
 588                   (int)substr( $ts, 0, 4 ) ); #Year
 589
 590                 $date = date( 'YmdHis', $t );
 591                 wfRestoreWarnings();
 592
 593                 return $date;
 594         }
 595
 596         /**
 597          * This is a workalike of PHP's date() function, but with better
 598          * internationalisation, a reduced set of format characters, and a better
 599          * escaping format.
 600          *
 601          * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
 602          * PHP manual for definitions. "o" format character is supported since
 603          * PHP 5.1.0, previous versions return literal o.
 604          * There are a number of extensions, which start with "x":
 605          *
 606          *    xn   Do not translate digits of the next numeric format character
 607          *    xN   Toggle raw digit (xn) flag, stays set until explicitly unset
 608          *    xr   Use roman numerals for the next numeric format character
 609          *    xh   Use hebrew numerals for the next numeric format character
 610          *    xx   Literal x
 611          *    xg   Genitive month name
 612          *
 613          *    xij  j (day number) in Iranian calendar
 614          *    xiF  F (month name) in Iranian calendar
 615          *    xin  n (month number) in Iranian calendar
 616          *    xiY  Y (full year) in Iranian calendar
 617          *
 618          *    xjj  j (day number) in Hebrew calendar
 619          *    xjF  F (month name) in Hebrew calendar
 620          *    xjt  t (days in month) in Hebrew calendar
 621          *    xjx  xg (genitive month name) in Hebrew calendar
 622          *    xjn  n (month number) in Hebrew calendar
 623          *    xjY  Y (full year) in Hebrew calendar
 624          *
 625          *    xmj  j (day number) in Hijri calendar
 626          *    xmF  F (month name) in Hijri calendar
 627          *    xmn  n (month number) in Hijri calendar
 628          *    xmY  Y (full year) in Hijri calendar
 629          *
 630          *    xkY  Y (full year) in Thai solar calendar. Months and days are
 631          *                       identical to the Gregorian calendar
 632          *    xoY  Y (full year) in Minguo calendar or Juche year.
 633          *                       Months and days are identical to the
 634          *                       Gregorian calendar
 635          *    xtY  Y (full year) in Japanese nengo. Months and days are
 636          *                       identical to the Gregorian calendar
 637          *
 638          * Characters enclosed in double quotes will be considered literal (with
 639          * the quotes themselves removed). Unmatched quotes will be considered
 640          * literal quotes. Example:
 641          *
 642          * "The month is" F       => The month is January
 643          * i's"                   => 20'11"
 644          *
 645          * Backslash escaping is also supported.
 646          *
 647          * Input timestamp is assumed to be pre-normalized to the desired local
 648          * time zone, if any.
 649          *
 650          * @param $format String
 651          * @param $ts String: 14-character timestamp
 652          *      YYYYMMDDHHMMSS
 653          *      01234567890123
 654          * @todo emulation of "o" format character for PHP pre 5.1.0
 655          * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
 656          */
 657         function sprintfDate( $format, $ts ) {
 658                 $s = '';
 659                 $raw = false;
 660                 $roman = false;
 661                 $hebrewNum = false;
 662                 $unix = false;
 663                 $rawToggle = false;
 664                 $iranian = false;
 665                 $hebrew = false;
 666                 $hijri = false;
 667                 $thai = false;
 668                 $minguo = false;
 669                 $tenno = false;
 670                 for ( $p = 0; $p < strlen( $format ); $p++ ) {
 671                         $num = false;
 672                         $code = $format[$p];
 673                         if ( $code == 'x' && $p < strlen( $format ) - 1 ) {
 674                                 $code .= $format[++$p];
 675                         }
 676
 677                         if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
 678                                 $code .= $format[++$p];
 679                         }
 680
 681                         switch ( $code ) {
 682                                 case 'xx':
 683                                         $s .= 'x';
 684                                         break;
 685                                 case 'xn':
 686                                         $raw = true;
 687                                         break;
 688                                 case 'xN':
 689                                         $rawToggle = !$rawToggle;
 690                                         break;
 691                                 case 'xr':
 692                                         $roman = true;
 693                                         break;
 694                                 case 'xh':
 695                                         $hebrewNum = true;
 696                                         break;
 697                                 case 'xg':
 698                                         $s .= $this->getMonthNameGen( substr( $ts, 4, 2 ) );
 699                                         break;
 700                                 case 'xjx':
 701                                         if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
 702                                         $s .= $this->getHebrewCalendarMonthNameGen( $hebrew[1] );
 703                                         break;
 704                                 case 'd':
 705                                         $num = substr( $ts, 6, 2 );
 706                                         break;
 707                                 case 'D':
 708                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 709                                         $s .= $this->getWeekdayAbbreviation( gmdate( 'w', $unix ) + 1 );
 710                                         break;
 711                                 case 'j':
 712                                         $num = intval( substr( $ts, 6, 2 ) );
 713                                         break;
 714                                 case 'xij':
 715                                         if ( !$iranian ) $iranian = self::tsToIranian( $ts );
 716                                         $num = $iranian[2];
 717                                         break;
 718                                 case 'xmj':
 719                                         if ( !$hijri ) $hijri = self::tsToHijri( $ts );
 720                                         $num = $hijri[2];
 721                                         break;
 722                                 case 'xjj':
 723                                         if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
 724                                         $num = $hebrew[2];
 725                                         break;
 726                                 case 'l':
 727                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 728                                         $s .= $this->getWeekdayName( gmdate( 'w', $unix ) + 1 );
 729                                         break;
 730                                 case 'N':
 731                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 732                                         $w = gmdate( 'w', $unix );
 733                                         $num = $w ? $w : 7;
 734                                         break;
 735                                 case 'w':
 736                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 737                                         $num = gmdate( 'w', $unix );
 738                                         break;
 739                                 case 'z':
 740                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 741                                         $num = gmdate( 'z', $unix );
 742                                         break;
 743                                 case 'W':
 744                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 745                                         $num = gmdate( 'W', $unix );
 746                                         break;
 747                                 case 'F':
 748                                         $s .= $this->getMonthName( substr( $ts, 4, 2 ) );
 749                                         break;
 750                                 case 'xiF':
 751                                         if ( !$iranian ) $iranian = self::tsToIranian( $ts );
 752                                         $s .= $this->getIranianCalendarMonthName( $iranian[1] );
 753                                         break;
 754                                 case 'xmF':
 755                                         if ( !$hijri ) $hijri = self::tsToHijri( $ts );
 756                                         $s .= $this->getHijriCalendarMonthName( $hijri[1] );
 757                                         break;
 758                                 case 'xjF':
 759                                         if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
 760                                         $s .= $this->getHebrewCalendarMonthName( $hebrew[1] );
 761                                         break;
 762                                 case 'm':
 763                                         $num = substr( $ts, 4, 2 );
 764                                         break;
 765                                 case 'M':
 766                                         $s .= $this->getMonthAbbreviation( substr( $ts, 4, 2 ) );
 767                                         break;
 768                                 case 'n':
 769                                         $num = intval( substr( $ts, 4, 2 ) );
 770                                         break;
 771                                 case 'xin':
 772                                         if ( !$iranian ) $iranian = self::tsToIranian( $ts );
 773                                         $num = $iranian[1];
 774                                         break;
 775                                 case 'xmn':
 776                                         if ( !$hijri ) $hijri = self::tsToHijri ( $ts );
 777                                         $num = $hijri[1];
 778                                         break;
 779                                 case 'xjn':
 780                                         if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
 781                                         $num = $hebrew[1];
 782                                         break;
 783                                 case 't':
 784                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 785                                         $num = gmdate( 't', $unix );
 786                                         break;
 787                                 case 'xjt':
 788                                         if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
 789                                         $num = $hebrew[3];
 790                                         break;
 791                                 case 'L':
 792                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 793                                         $num = gmdate( 'L', $unix );
 794                                         break;
 795                                 # 'o' is supported since PHP 5.1.0
 796                                 # return literal if not supported
 797                                 # TODO: emulation for pre 5.1.0 versions
 798                                 case 'o':
 799                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 800                                         if ( version_compare(PHP_VERSION, '5.1.0') === 1 )
 801                                                 $num = date( 'o', $unix );
 802                                         else
 803                                                 $s .= 'o';
 804                                         break;
 805                                 case 'Y':
 806                                         $num = substr( $ts, 0, 4 );
 807                                         break;
 808                                 case 'xiY':
 809                                         if ( !$iranian ) $iranian = self::tsToIranian( $ts );
 810                                         $num = $iranian[0];
 811                                         break;
 812                                 case 'xmY':
 813                                         if ( !$hijri ) $hijri = self::tsToHijri( $ts );
 814                                         $num = $hijri[0];
 815                                         break;
 816                                 case 'xjY':
 817                                         if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
 818                                         $num = $hebrew[0];
 819                                         break;
 820                                 case 'xkY':
 821                                         if ( !$thai ) $thai = self::tsToYear( $ts, 'thai' );
 822                                         $num = $thai[0];
 823                                         break;
 824                                 case 'xoY':
 825                                         if ( !$minguo ) $minguo = self::tsToYear( $ts, 'minguo' );
 826                                         $num = $minguo[0];
 827                                         break;
 828                                 case 'xtY':
 829                                         if ( !$tenno ) $tenno = self::tsToYear( $ts, 'tenno' );
 830                                         $num = $tenno[0];
 831                                         break;
 832                                 case 'y':
 833                                         $num = substr( $ts, 2, 2 );
 834                                         break;
 835                                 case 'a':
 836                                         $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'am' : 'pm';
 837                                         break;
 838                                 case 'A':
 839                                         $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'AM' : 'PM';
 840                                         break;
 841                                 case 'g':
 842                                         $h = substr( $ts, 8, 2 );
 843                                         $num = $h % 12 ? $h % 12 : 12;
 844                                         break;
 845                                 case 'G':
 846                                         $num = intval( substr( $ts, 8, 2 ) );
 847                                         break;
 848                                 case 'h':
 849                                         $h = substr( $ts, 8, 2 );
 850                                         $num = sprintf( '%02d', $h % 12 ? $h % 12 : 12 );
 851                                         break;
 852                                 case 'H':
 853                                         $num = substr( $ts, 8, 2 );
 854                                         break;
 855                                 case 'i':
 856                                         $num = substr( $ts, 10, 2 );
 857                                         break;
 858                                 case 's':
 859                                         $num = substr( $ts, 12, 2 );
 860                                         break;
 861                                 case 'c':
 862                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 863                                         $s .= gmdate( 'c', $unix );
 864                                         break;
 865                                 case 'r':
 866                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 867                                         $s .= gmdate( 'r', $unix );
 868                                         break;
 869                                 case 'U':
 870                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 871                                         $num = $unix;
 872                                         break;
 873                                 case '\\':
 874                                         # Backslash escaping
 875                                         if ( $p < strlen( $format ) - 1 ) {
 876                                                 $s .= $format[++$p];
 877                                         } else {
 878                                                 $s .= '\\';
 879                                         }
 880                                         break;
 881                                 case '"':
 882                                         # Quoted literal
 883                                         if ( $p < strlen( $format ) - 1 ) {
 884                                                 $endQuote = strpos( $format, '"', $p + 1 );
 885                                                 if ( $endQuote === false ) {
 886                                                         # No terminating quote, assume literal "
 887                                                         $s .= '"';
 888                                                 } else {
 889                                                         $s .= substr( $format, $p + 1, $endQuote - $p - 1 );
 890                                                         $p = $endQuote;
 891                                                 }
 892                                         } else {
 893                                                 # Quote at end of string, assume literal "
 894                                                 $s .= '"';
 895                                         }
 896                                         break;
 897                                 default:
 898                                         $s .= $format[$p];
 899                         }
 900                         if ( $num !== false ) {
 901                                 if ( $rawToggle || $raw ) {
 902                                         $s .= $num;
 903                                         $raw = false;
 904                                 } elseif ( $roman ) {
 905                                         $s .= self::romanNumeral( $num );
 906                                         $roman = false;
 907                                 } elseif( $hebrewNum ) {
 908                                         $s .= self::hebrewNumeral( $num );
 909                                         $hebrewNum = false;
 910                                 } else {
 911                                         $s .= $this->formatNum( $num, true );
 912                                 }
 913                                 $num = false;
 914                         }
 915                 }
 916                 return $s;
 917         }
 918
 919         private static $GREG_DAYS = array( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
 920         private static $IRANIAN_DAYS = array( 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29 );
 921         /**
 922          * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
 923          * Gregorian dates to Iranian dates. Originally written in C, it
 924          * is released under the terms of GNU Lesser General Public
 925          * License. Conversion to PHP was performed by Niklas Laxström.
 926          *
 927          * Link: http://www.farsiweb.info/jalali/jalali.c
 928          */
 929         private static function tsToIranian( $ts ) {
 930                 $gy = substr( $ts, 0, 4 ) -1600;
 931                 $gm = substr( $ts, 4, 2 ) -1;
 932                 $gd = substr( $ts, 6, 2 ) -1;
 933
 934                 # Days passed from the beginning (including leap years)
 935                 $gDayNo = 365*$gy
 936                         + floor(($gy+3) / 4)
 937                         - floor(($gy+99) / 100)
 938                         + floor(($gy+399) / 400);
 939
 940
 941                 // Add days of the past months of this year
 942                 for( $i = 0; $i < $gm; $i++ ) {
 943                         $gDayNo += self::$GREG_DAYS[$i];
 944                 }
 945
 946                 // Leap years
 947                 if ( $gm > 1 && (($gy%4===0 && $gy%100!==0 || ($gy%400==0)))) {
 948                         $gDayNo++;
 949                 }
 950
 951                 // Days passed in current month
 952                 $gDayNo += $gd;
 953
 954                 $jDayNo = $gDayNo - 79;
 955
 956                 $jNp = floor($jDayNo / 12053);
 957                 $jDayNo %= 12053;
 958
 959                 $jy = 979 + 33*$jNp + 4*floor($jDayNo/1461);
 960                 $jDayNo %= 1461;
 961
 962                 if ( $jDayNo >= 366 ) {
 963                         $jy += floor(($jDayNo-1)/365);
 964                         $jDayNo = floor(($jDayNo-1)%365);
 965                 }
 966
 967                 for ( $i = 0; $i < 11 && $jDayNo >= self::$IRANIAN_DAYS[$i]; $i++ ) {
 968                         $jDayNo -= self::$IRANIAN_DAYS[$i];
 969                 }
 970
 971                 $jm= $i+1;
 972                 $jd= $jDayNo+1;
 973
 974                 return array($jy, $jm, $jd);
 975         }
 976         /**
 977          * Converting Gregorian dates to Hijri dates.
 978          *
 979          * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
 980          *
 981          * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
 982          */
 983         private static function tsToHijri ( $ts ) {
 984                 $year = substr( $ts, 0, 4 );
 985                 $month = substr( $ts, 4, 2 );
 986                 $day = substr( $ts, 6, 2 );
 987
 988                 $zyr = $year;
 989                 $zd=$day;
 990                 $zm=$month;
 991                 $zy=$zyr;
 992
 993
 994
 995                 if (($zy>1582)||(($zy==1582)&&($zm>10))||(($zy==1582)&&($zm==10)&&($zd>14)))
 996                         {
 997
 998
 999                                     $zjd=(int)((1461*($zy + 4800 + (int)( ($zm-14) /12) ))/4) + (int)((367*($zm-2-12*((int)(($zm-14)/12))))/12)-(int)((3*(int)(( ($zy+4900+(int)(($zm-14)/12))/100)))/4)+$zd-32075;
1000                                     }
1001                  else
1002                         {
1003                                     $zjd = 367*$zy-(int)((7*($zy+5001+(int)(($zm-9)/7)))/4)+(int)((275*$zm)/9)+$zd+1729777;
1004                         }
1005
1006                 $zl=$zjd-1948440+10632;
1007                 $zn=(int)(($zl-1)/10631);
1008                 $zl=$zl-10631*$zn+354;
1009                 $zj=((int)((10985-$zl)/5316))*((int)((50*$zl)/17719))+((int)($zl/5670))*((int)((43*$zl)/15238));
1010                 $zl=$zl-((int)((30-$zj)/15))*((int)((17719*$zj)/50))-((int)($zj/16))*((int)((15238*$zj)/43))+29;
1011                 $zm=(int)((24*$zl)/709);
1012                 $zd=$zl-(int)((709*$zm)/24);
1013                 $zy=30*$zn+$zj-30;
1014
1015                 return array ($zy, $zm, $zd);
1016         }
1017
1018         /**
1019          * Converting Gregorian dates to Hebrew dates.
1020          *
1021          * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1022          * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1023          * to translate the relevant functions into PHP and release them under
1024          * GNU GPL.
1025          *
1026          * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1027          * and Adar II is 14. In a non-leap year, Adar is 6.
1028          */
1029         private static function tsToHebrew( $ts ) {
1030                 # Parse date
1031                 $year = substr( $ts, 0, 4 );
1032                 $month = substr( $ts, 4, 2 );
1033                 $day = substr( $ts, 6, 2 );
1034
1035                 # Calculate Hebrew year
1036                 $hebrewYear = $year + 3760;
1037
1038                 # Month number when September = 1, August = 12
1039                 $month += 4;
1040                 if( $month > 12 ) {
1041                         # Next year
1042                         $month -= 12;
1043                         $year++;
1044                         $hebrewYear++;
1045                 }
1046
1047                 # Calculate day of year from 1 September
1048                 $dayOfYear = $day;
1049                 for( $i = 1; $i < $month; $i++ ) {
1050                         if( $i == 6 ) {
1051                                 # February
1052                                 $dayOfYear += 28;
1053                                 # Check if the year is leap
1054                                 if( $year % 400 == 0 || ( $year % 4 == 0 && $year % 100 > 0 ) ) {
1055                                         $dayOfYear++;
1056                                 }
1057                         } elseif( $i == 8 || $i == 10 || $i == 1 || $i == 3 ) {
1058                                 $dayOfYear += 30;
1059                         } else {
1060                                 $dayOfYear += 31;
1061                         }
1062                 }
1063
1064                 # Calculate the start of the Hebrew year
1065                 $start = self::hebrewYearStart( $hebrewYear );
1066
1067                 # Calculate next year's start
1068                 if( $dayOfYear <= $start ) {
1069                         # Day is before the start of the year - it is the previous year
1070                         # Next year's start
1071                         $nextStart = $start;
1072                         # Previous year
1073                         $year--;
1074                         $hebrewYear--;
1075                         # Add days since previous year's 1 September
1076                         $dayOfYear += 365;
1077                         if( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
1078                                 # Leap year
1079                                 $dayOfYear++;
1080                         }
1081                         # Start of the new (previous) year
1082                         $start = self::hebrewYearStart( $hebrewYear );
1083                 } else {
1084                         # Next year's start
1085                         $nextStart = self::hebrewYearStart( $hebrewYear + 1 );
1086                 }
1087
1088                 # Calculate Hebrew day of year
1089                 $hebrewDayOfYear = $dayOfYear - $start;
1090
1091                 # Difference between year's days
1092                 $diff = $nextStart - $start;
1093                 # Add 12 (or 13 for leap years) days to ignore the difference between
1094                 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1095                 # difference is only about the year type
1096                 if( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
1097                         $diff += 13;
1098                 } else {
1099                         $diff += 12;
1100                 }
1101
1102                 # Check the year pattern, and is leap year
1103                 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1104                 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1105                 # and non-leap years
1106                 $yearPattern = $diff % 30;
1107                 # Check if leap year
1108                 $isLeap = $diff >= 30;
1109
1110                 # Calculate day in the month from number of day in the Hebrew year
1111                 # Don't check Adar - if the day is not in Adar, we will stop before;
1112                 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1113                 $hebrewDay = $hebrewDayOfYear;
1114                 $hebrewMonth = 1;
1115                 $days = 0;
1116                 while( $hebrewMonth <= 12 ) {
1117                         # Calculate days in this month
1118                         if( $isLeap && $hebrewMonth == 6 ) {
1119                                 # Adar in a leap year
1120                                 if( $isLeap ) {
1121                                         # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1122                                         $days = 30;
1123                                         if( $hebrewDay <= $days ) {
1124                                                 # Day in Adar I
1125                                                 $hebrewMonth = 13;
1126                                         } else {
1127                                                 # Subtract the days of Adar I
1128                                                 $hebrewDay -= $days;
1129                                                 # Try Adar II
1130                                                 $days = 29;
1131                                                 if( $hebrewDay <= $days ) {
1132                                                         # Day in Adar II
1133                                                         $hebrewMonth = 14;
1134                                                 }
1135                                         }
1136                                 }
1137                         } elseif( $hebrewMonth == 2 && $yearPattern == 2 ) {
1138                                 # Cheshvan in a complete year (otherwise as the rule below)
1139                                 $days = 30;
1140                         } elseif( $hebrewMonth == 3 && $yearPattern == 0 ) {
1141                                 # Kislev in an incomplete year (otherwise as the rule below)
1142                                 $days = 29;
1143                         } else {
1144                                 # Odd months have 30 days, even have 29
1145                                 $days = 30 - ( $hebrewMonth - 1 ) % 2;
1146                         }
1147                         if( $hebrewDay <= $days ) {
1148                                 # In the current month
1149                                 break;
1150                         } else {
1151                                 # Subtract the days of the current month
1152                                 $hebrewDay -= $days;
1153                                 # Try in the next month
1154                                 $hebrewMonth++;
1155                         }
1156                 }
1157
1158                 return array( $hebrewYear, $hebrewMonth, $hebrewDay, $days );
1159         }
1160
1161         /**
1162          * This calculates the Hebrew year start, as days since 1 September.
1163          * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1164          * Used for Hebrew date.
1165          */
1166         private static function hebrewYearStart( $year ) {
1167                 $a = intval( ( 12 * ( $year - 1 ) + 17 ) % 19 );
1168                 $b = intval( ( $year - 1 ) % 4 );
1169                 $m = 32.044093161144 + 1.5542417966212 * $a +  $b / 4.0 - 0.0031777940220923 * ( $year - 1 );
1170                 if( $m < 0 ) {
1171                         $m--;
1172                 }
1173                 $Mar = intval( $m );
1174                 if( $m < 0 ) {
1175                         $m++;
1176                 }
1177                 $m -= $Mar;
1178
1179                 $c = intval( ( $Mar + 3 * ( $year - 1 ) + 5 * $b + 5 ) % 7);
1180                 if( $c == 0 && $a > 11 && $m >= 0.89772376543210 ) {
1181                         $Mar++;
1182                 } else if( $c == 1 && $a > 6 && $m >= 0.63287037037037 ) {
1183                         $Mar += 2;
1184                 } else if( $c == 2 || $c == 4 || $c == 6 ) {
1185                         $Mar++;
1186                 }
1187
1188                 $Mar += intval( ( $year - 3761 ) / 100 ) - intval( ( $year - 3761 ) / 400 ) - 24;
1189                 return $Mar;
1190         }
1191
1192         /**
1193          * Algorithm to convert Gregorian dates to Thai solar dates,
1194          * Minguo dates or Minguo dates.
1195          *
1196          * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1197          *       http://en.wikipedia.org/wiki/Minguo_calendar
1198          *       http://en.wikipedia.org/wiki/Japanese_era_name
1199          *
1200          * @param $ts String: 14-character timestamp, calender name
1201          * @return array converted year, month, day
1202          */
1203         private static function tsToYear( $ts, $cName ) {
1204                 $gy = substr( $ts, 0, 4 );
1205                 $gm = substr( $ts, 4, 2 );
1206                 $gd = substr( $ts, 6, 2 );
1207
1208                 if (!strcmp($cName,'thai')) {
1209                         # Thai solar dates
1210                         # Add 543 years to the Gregorian calendar
1211                         # Months and days are identical
1212                         $gy_offset = $gy + 543;
1213                 } else if ((!strcmp($cName,'minguo')) || !strcmp($cName,'juche')) {
1214                         # Minguo dates
1215                         # Deduct 1911 years from the Gregorian calendar
1216                         # Months and days are identical
1217                         $gy_offset = $gy - 1911;
1218                 } else if (!strcmp($cName,'tenno')) {
1219                         # Nengō dates up to Meiji period
1220                         # Deduct years from the Gregorian calendar
1221                         # depending on the nengo periods
1222                         # Months and days are identical
1223                         if (($gy < 1912) || (($gy == 1912) && ($gm < 7)) || (($gy == 1912) && ($gm == 7) && ($gd < 31))) {
1224                                 # Meiji period
1225                                 $gy_gannen = $gy - 1868 + 1;
1226                                 $gy_offset = $gy_gannen;
1227                                 if ($gy_gannen == 1)
1228                                         $gy_offset = '元';
1229                                 $gy_offset = '明治'.$gy_offset;
1230                         } else if ((($gy == 1912) && ($gm == 7) && ($gd == 31)) || (($gy == 1912) && ($gm >= 8)) || (($gy > 1912) && ($gy < 1926)) || (($gy == 1926) && ($gm < 12)) || (($gy == 1926) && ($gm == 12) && ($gd < 26))) {
1231                                 # Taishō period
1232                                 $gy_gannen = $gy - 1912 + 1;
1233                                 $gy_offset = $gy_gannen;
1234                                 if ($gy_gannen == 1)
1235                                         $gy_offset = '元';
1236                                 $gy_offset = '大正'.$gy_offset;
1237                         } else if ((($gy == 1926) && ($gm == 12) && ($gd >= 26)) || (($gy > 1926) && ($gy < 1989)) || (($gy == 1989) && ($gm == 1) && ($gd < 8))) {
1238                                 # Shōwa period
1239                                 $gy_gannen = $gy - 1926 + 1;
1240                                 $gy_offset = $gy_gannen;
1241                                 if ($gy_gannen == 1)
1242                                         $gy_offset = '元';
1243                                 $gy_offset = '昭和'.$gy_offset;
1244                         } else {
1245                                 # Heisei period
1246                                 $gy_gannen = $gy - 1989 + 1;
1247                                 $gy_offset = $gy_gannen;
1248                                 if ($gy_gannen == 1)
1249                                         $gy_offset = '元';
1250                                 $gy_offset = '平成'.$gy_offset;
1251                         }
1252                 } else {
1253                         $gy_offset = $gy;
1254                 }
1255
1256                 return array( $gy_offset, $gm, $gd );
1257         }
1258
1259         /**
1260          * Roman number formatting up to 3000
1261          */
1262         static function romanNumeral( $num ) {
1263                 static $table = array(
1264                         array( '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X' ),
1265                         array( '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', 'C' ),
1266                         array( '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', 'M' ),
1267                         array( '', 'M', 'MM', 'MMM' )
1268                 );
1269
1270                 $num = intval( $num );
1271                 if ( $num > 3000 || $num <= 0 ) {
1272                         return $num;
1273                 }
1274
1275                 $s = '';
1276                 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1277                         if ( $num >= $pow10 ) {
1278                                 $s .= $table[$i][floor($num / $pow10)];
1279                         }
1280                         $num = $num % $pow10;
1281                 }
1282                 return $s;
1283         }
1284
1285         /**
1286          * Hebrew Gematria number formatting up to 9999
1287          */
1288         static function hebrewNumeral( $num ) {
1289                 static $table = array(
1290                         array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' ),
1291                         array( '', 'י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ', 'ק' ),
1292                         array( '', 'ק', 'ר', 'ש', 'ת', 'תק', 'תר', 'תש', 'תת', 'תתק', 'תתר' ),
1293                         array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' )
1294                 );
1295
1296                 $num = intval( $num );
1297                 if ( $num > 9999 || $num <= 0 ) {
1298                         return $num;
1299                 }
1300
1301                 $s = '';
1302                 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1303                         if ( $num >= $pow10 ) {
1304                                 if ( $num == 15 || $num == 16 ) {
1305                                         $s .= $table[0][9] . $table[0][$num - 9];
1306                                         $num = 0;
1307                                 } else {
1308                                         $s .= $table[$i][intval( ( $num / $pow10 ) )];
1309                                         if( $pow10 == 1000 ) {
1310                                                 $s .= "'";
1311                                         }
1312                                 }
1313                         }
1314                         $num = $num % $pow10;
1315                 }
1316                 if( strlen( $s ) == 2 ) {
1317                         $str = $s . "'";
1318                 } else  {
1319                         $str = substr( $s, 0, strlen( $s ) - 2 ) . '"';
1320                         $str .= substr( $s, strlen( $s ) - 2, 2 );
1321                 }
1322                 $start = substr( $str, 0, strlen( $str ) - 2 );
1323                 $end = substr( $str, strlen( $str ) - 2 );
1324                 switch( $end ) {
1325                         case 'כ':
1326                                 $str = $start . 'ך';
1327                                 break;
1328                         case 'מ':
1329                                 $str = $start . 'ם';
1330                                 break;
1331                         case 'נ':
1332                                 $str = $start . 'ן';
1333                                 break;
1334                         case 'פ':
1335                                 $str = $start . 'ף';
1336                                 break;
1337                         case 'צ':
1338                                 $str = $start . 'ץ';
1339                                 break;
1340                 }
1341                 return $str;
1342         }
1343
1344         /**
1345          * This is meant to be used by time(), date(), and timeanddate() to get
1346          * the date preference they're supposed to use, it should be used in
1347          * all children.
1348          *
1349          *<code>
1350          * function timeanddate([...], $format = true) {
1351          *      $datePreference = $this->dateFormat($format);
1352          * [...]
1353          * }
1354          *</code>
1355          *
1356          * @param $usePrefs Mixed: if true, the user's preference is used
1357          *                         if false, the site/language default is used
1358          *                         if int/string, assumed to be a format.
1359          * @return string
1360          */
1361         function dateFormat( $usePrefs = true ) {
1362                 global $wgUser;
1363
1364                 if( is_bool( $usePrefs ) ) {
1365                         if( $usePrefs ) {
1366                                 $datePreference = $wgUser->getDatePreference();
1367                         } else {
1368                                 $options = User::getDefaultOptions();
1369                                 $datePreference = (string)$options['date'];
1370                         }
1371                 } else {
1372                         $datePreference = (string)$usePrefs;
1373                 }
1374
1375                 // return int
1376                 if( $datePreference == '' ) {
1377                         return 'default';
1378                 }
1379
1380                 return $datePreference;
1381         }
1382
1383         /**
1384          * Get a format string for a given type and preference
1385          * @param $type May be date, time or both
1386          * @param $pref The format name as it appears in Messages*.php
1387          */
1388         function getDateFormatString( $type, $pref ) {
1389                 if ( !isset( $this->dateFormatStrings[$type][$pref] ) ) {
1390                         if ( $pref == 'default' ) {
1391                                 $pref = $this->getDefaultDateFormat();
1392                                 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
1393                         } else {
1394                                 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
1395                                 if ( is_null( $df ) ) {
1396                                         $pref = $this->getDefaultDateFormat();
1397                                         $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
1398                                 }
1399                         }
1400                         $this->dateFormatStrings[$type][$pref] = $df;
1401                 }
1402                 return $this->dateFormatStrings[$type][$pref];
1403         }
1404
1405         /**
1406          * @param $ts Mixed: the time format which needs to be turned into a
1407          *            date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1408          * @param $adj Bool: whether to adjust the time output according to the
1409          *             user configured offset ($timecorrection)
1410          * @param $format Mixed: true to use user's date format preference
1411          * @param $timecorrection String: the time offset as returned by
1412          *                        validateTimeZone() in Special:Preferences
1413          * @return string
1414          */
1415         function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
1416                 if ( $adj ) {
1417                         $ts = $this->userAdjust( $ts, $timecorrection );
1418                 }
1419                 $df = $this->getDateFormatString( 'date', $this->dateFormat( $format ) );
1420                 return $this->sprintfDate( $df, $ts );
1421         }
1422
1423         /**
1424          * @param $ts Mixed: the time format which needs to be turned into a
1425          *            date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1426          * @param $adj Bool: whether to adjust the time output according to the
1427          *             user configured offset ($timecorrection)
1428          * @param $format Mixed: true to use user's date format preference
1429          * @param $timecorrection String: the time offset as returned by
1430          *                        validateTimeZone() in Special:Preferences
1431          * @return string
1432          */
1433         function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
1434                 if ( $adj ) {
1435                         $ts = $this->userAdjust( $ts, $timecorrection );
1436                 }
1437                 $df = $this->getDateFormatString( 'time', $this->dateFormat( $format ) );
1438                 return $this->sprintfDate( $df, $ts );
1439         }
1440
1441         /**
1442          * @param $ts Mixed: the time format which needs to be turned into a
1443          *            date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1444          * @param $adj Bool: whether to adjust the time output according to the
1445          *             user configured offset ($timecorrection)
1446          * @param $format Mixed: what format to return, if it's false output the
1447          *                default one (default true)
1448          * @param $timecorrection String: the time offset as returned by
1449          *                        validateTimeZone() in Special:Preferences
1450          * @return string
1451          */
1452         function timeanddate( $ts, $adj = false, $format = true, $timecorrection = false) {
1453                 $ts = wfTimestamp( TS_MW, $ts );
1454                 if ( $adj ) {
1455                         $ts = $this->userAdjust( $ts, $timecorrection );
1456                 }
1457                 $df = $this->getDateFormatString( 'both', $this->dateFormat( $format ) );
1458                 return $this->sprintfDate( $df, $ts );
1459         }
1460
1461         function getMessage( $key ) {
1462                 return self::$dataCache->getSubitem( $this->mCode, 'messages', $key );
1463         }
1464
1465         function getAllMessages() {
1466                 return self::$dataCache->getItem( $this->mCode, 'messages' );
1467         }
1468
1469         function iconv( $in, $out, $string ) {
1470                 # This is a wrapper for iconv in all languages except esperanto,
1471                 # which does some nasty x-conversions beforehand
1472
1473                 # Even with //IGNORE iconv can whine about illegal characters in
1474                 # *input* string. We just ignore those too.
1475                 # REF: http://bugs.php.net/bug.php?id=37166
1476                 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1477                 wfSuppressWarnings();
1478                 $text = iconv( $in, $out . '//IGNORE', $string );
1479                 wfRestoreWarnings();
1480                 return $text;
1481         }
1482
1483         // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1484         function ucwordbreaksCallbackAscii($matches){
1485                 return $this->ucfirst($matches[1]);
1486         }
1487
1488         function ucwordbreaksCallbackMB($matches){
1489                 return mb_strtoupper($matches[0]);
1490         }
1491
1492         function ucCallback($matches){
1493                 list( $wikiUpperChars ) = self::getCaseMaps();
1494                 return strtr( $matches[1], $wikiUpperChars );
1495         }
1496
1497         function lcCallback($matches){
1498                 list( , $wikiLowerChars ) = self::getCaseMaps();
1499                 return strtr( $matches[1], $wikiLowerChars );
1500         }
1501
1502         function ucwordsCallbackMB($matches){
1503                 return mb_strtoupper($matches[0]);
1504         }
1505
1506         function ucwordsCallbackWiki($matches){
1507                 list( $wikiUpperChars ) = self::getCaseMaps();
1508                 return strtr( $matches[0], $wikiUpperChars );
1509         }
1510
1511         function ucfirst( $str ) {
1512                 $o = ord( $str );
1513                 if ( $o < 96 ) {
1514                         return $str;
1515                 } elseif ( $o < 128 ) {
1516                         return ucfirst($str);
1517                 } else {
1518                         // fall back to more complex logic in case of multibyte strings
1519                         return self::uc($str,true);
1520                 }
1521         }
1522
1523         function uc( $str, $first = false ) {
1524                 if ( function_exists( 'mb_strtoupper' ) ) {
1525                         if ( $first ) {
1526                                 if ( self::isMultibyte( $str ) ) {
1527                                         return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1528                                 } else {
1529                                         return ucfirst( $str );
1530                                 }
1531                         } else {
1532                                 return self::isMultibyte( $str ) ? mb_strtoupper( $str ) : strtoupper( $str );
1533                         }
1534                 } else {
1535                         if ( self::isMultibyte( $str ) ) {
1536                                 list( $wikiUpperChars ) = $this->getCaseMaps();
1537                                 $x = $first ? '^' : '';
1538                                 return preg_replace_callback(
1539                                         "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1540                                         array($this,"ucCallback"),
1541                                         $str
1542                                 );
1543                         } else {
1544                                 return $first ? ucfirst( $str ) : strtoupper( $str );
1545                         }
1546                 }
1547         }
1548
1549         function lcfirst( $str ) {
1550                 $o = ord( $str );
1551                 if ( !$o ) {
1552                         return strval( $str );
1553                 } elseif ( $o >= 128 ) {
1554                         return self::lc( $str, true );
1555                 } elseif ( $o > 96 ) {
1556                         return $str;
1557                 } else {
1558                         $str[0] = strtolower( $str[0] );
1559                         return $str;
1560                 }
1561         }
1562
1563         function lc( $str, $first = false ) {
1564                 if ( function_exists( 'mb_strtolower' ) )
1565                         if ( $first )
1566                                 if ( self::isMultibyte( $str ) )
1567                                         return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1568                                 else
1569                                         return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
1570                         else
1571                                 return self::isMultibyte( $str ) ? mb_strtolower( $str ) : strtolower( $str );
1572                 else
1573                         if ( self::isMultibyte( $str ) ) {
1574                                 list( , $wikiLowerChars ) = self::getCaseMaps();
1575                                 $x = $first ? '^' : '';
1576                                 return preg_replace_callback(
1577                                         "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1578                                         array($this,"lcCallback"),
1579                                         $str
1580                                 );
1581                         } else
1582                                 return $first ? strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
1583         }
1584
1585         function isMultibyte( $str ) {
1586                 return (bool)preg_match( '/[\x80-\xff]/', $str );
1587         }
1588
1589         function ucwords($str) {
1590                 if ( self::isMultibyte( $str ) ) {
1591                         $str = self::lc($str);
1592
1593                         // regexp to find first letter in each word (i.e. after each space)
1594                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1595
1596                         // function to use to capitalize a single char
1597                         if ( function_exists( 'mb_strtoupper' ) )
1598                                 return preg_replace_callback(
1599                                         $replaceRegexp,
1600                                         array($this,"ucwordsCallbackMB"),
1601                                         $str
1602                                 );
1603                         else
1604                                 return preg_replace_callback(
1605                                         $replaceRegexp,
1606                                         array($this,"ucwordsCallbackWiki"),
1607                                         $str
1608                                 );
1609                 }
1610                 else
1611                         return ucwords( strtolower( $str ) );
1612         }
1613
1614   # capitalize words at word breaks
1615         function ucwordbreaks($str){
1616                 if (self::isMultibyte( $str ) ) {
1617                         $str = self::lc($str);
1618
1619                         // since \b doesn't work for UTF-8, we explicitely define word break chars
1620                         $breaks= "[ \-\(\)\}\{\.,\?!]";
1621
1622                         // find first letter after word break
1623                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1624
1625                         if ( function_exists( 'mb_strtoupper' ) )
1626                                 return preg_replace_callback(
1627                                         $replaceRegexp,
1628                                         array($this,"ucwordbreaksCallbackMB"),
1629                                         $str
1630                                 );
1631                         else
1632                                 return preg_replace_callback(
1633                                         $replaceRegexp,
1634                                         array($this,"ucwordsCallbackWiki"),
1635                                         $str
1636                                 );
1637                 }
1638                 else
1639                         return preg_replace_callback(
1640                         '/\b([\w\x80-\xff]+)\b/',
1641                         array($this,"ucwordbreaksCallbackAscii"),
1642                         $str );
1643         }
1644
1645         /**
1646          * Return a case-folded representation of $s
1647          *
1648          * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1649          * and $s2 are the same except for the case of their characters. It is not
1650          * necessary for the value returned to make sense when displayed.
1651          *
1652          * Do *not* perform any other normalisation in this function. If a caller
1653          * uses this function when it should be using a more general normalisation
1654          * function, then fix the caller.
1655          */
1656         function caseFold( $s ) {
1657                 return $this->uc( $s );
1658         }
1659
1660         function checkTitleEncoding( $s ) {
1661                 if( is_array( $s ) ) {
1662                         wfDebugDieBacktrace( 'Given array to checkTitleEncoding.' );
1663                 }
1664                 # Check for non-UTF-8 URLs
1665                 $ishigh = preg_match( '/[\x80-\xff]/', $s);
1666                 if(!$ishigh) return $s;
1667
1668                 $isutf8 = preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1669                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
1670                 if( $isutf8 ) return $s;
1671
1672                 return $this->iconv( $this->fallback8bitEncoding(), "utf-8", $s );
1673         }
1674
1675         function fallback8bitEncoding() {
1676                 return self::$dataCache->getItem( $this->mCode, 'fallback8bitEncoding' );
1677         }
1678
1679         /**
1680          * Most writing systems use whitespace to break up words.
1681          * Some languages such as Chinese don't conventionally do this,
1682          * which requires special handling when breaking up words for
1683          * searching etc.
1684          */
1685         function hasWordBreaks() {
1686                 return true;
1687         }
1688
1689         /**
1690          * Some languages have special punctuation to strip out
1691          * or characters which need to be converted for MySQL's
1692          * indexing to grok it correctly. Make such changes here.
1693          *
1694          * @param $string String
1695          * @return String
1696          */
1697         function stripForSearch( $string ) {
1698                 global $wgDBtype;
1699                 if ( $wgDBtype != 'mysql' ) {
1700                         return $string;
1701                 }
1702
1703
1704                 wfProfileIn( __METHOD__ );
1705
1706                 // MySQL fulltext index doesn't grok utf-8, so we
1707                 // need to fold cases and convert to hex
1708                 $out = preg_replace_callback(
1709                         "/([\\xc0-\\xff][\\x80-\\xbf]*)/",
1710                         array( $this, 'stripForSearchCallback' ),
1711                         $this->lc( $string ) );
1712
1713                 // And to add insult to injury, the default indexing
1714                 // ignores short words... Pad them so we can pass them
1715                 // through without reconfiguring the server...
1716                 $minLength = $this->minSearchLength();
1717                 if( $minLength > 1 ) {
1718                         $n = $minLength-1;
1719                         $out = preg_replace(
1720                                 "/\b(\w{1,$n})\b/",
1721                                 "$1u800",
1722                                 $out );
1723                 }
1724
1725                 // Periods within things like hostnames and IP addresses
1726                 // are also important -- we want a search for "example.com"
1727                 // or "192.168.1.1" to work sanely.
1728                 //
1729                 // MySQL's search seems to ignore them, so you'd match on
1730                 // "example.wikipedia.com" and "192.168.83.1" as well.
1731                 $out = preg_replace(
1732                         "/(\w)\.(\w|\*)/u",
1733                         "$1u82e$2",
1734                         $out );
1735
1736                 wfProfileOut( __METHOD__ );
1737                 return $out;
1738         }
1739
1740         /**
1741          * Armor a case-folded UTF-8 string to get through MySQL's
1742          * fulltext search without being mucked up by funny charset
1743          * settings or anything else of the sort.
1744          */
1745         protected function stripForSearchCallback( $matches ) {
1746                 return 'u8' . bin2hex( $matches[1] );
1747         }
1748
1749         /**
1750          * Check MySQL server's ft_min_word_len setting so we know
1751          * if we need to pad short words...
1752          */
1753         protected function minSearchLength() {
1754                 if( is_null( $this->minSearchLength ) ) {
1755                         $sql = "show global variables like 'ft\\_min\\_word\\_len'";
1756                         $dbr = wfGetDB( DB_SLAVE );
1757                         $result = $dbr->query( $sql );
1758                         $row = $result->fetchObject();
1759                         $result->free();
1760
1761                         if( $row && $row->Variable_name == 'ft_min_word_len' ) {
1762                                 $this->minSearchLength = intval( $row->Value );
1763                         } else {
1764                                 $this->minSearchLength = 0;
1765                         }
1766                 }
1767                 return $this->minSearchLength;
1768         }
1769
1770         function convertForSearchResult( $termsArray ) {
1771                 # some languages, e.g. Chinese, need to do a conversion
1772                 # in order for search results to be displayed correctly
1773                 return $termsArray;
1774         }
1775
1776         /**
1777          * Get the first character of a string.
1778          *
1779          * @param $s string
1780          * @return string
1781          */
1782         function firstChar( $s ) {
1783                 $matches = array();
1784                 preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1785                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/', $s, $matches);
1786
1787                 if ( isset( $matches[1] ) ) {
1788                         if ( strlen( $matches[1] ) != 3 ) {
1789                                 return $matches[1];
1790                         }
1791
1792                         // Break down Hangul syllables to grab the first jamo
1793                         $code = utf8ToCodepoint( $matches[1] );
1794                         if ( $code < 0xac00 || 0xd7a4 <= $code) {
1795                                 return $matches[1];
1796                         } elseif ( $code < 0xb098 ) {
1797                                 return "\xe3\x84\xb1";
1798                         } elseif ( $code < 0xb2e4 ) {
1799                                 return "\xe3\x84\xb4";
1800                         } elseif ( $code < 0xb77c ) {
1801                                 return "\xe3\x84\xb7";
1802                         } elseif ( $code < 0xb9c8 ) {
1803                                 return "\xe3\x84\xb9";
1804                         } elseif ( $code < 0xbc14 ) {
1805                                 return "\xe3\x85\x81";
1806                         } elseif ( $code < 0xc0ac ) {
1807                                 return "\xe3\x85\x82";
1808                         } elseif ( $code < 0xc544 ) {
1809                                 return "\xe3\x85\x85";
1810                         } elseif ( $code < 0xc790 ) {
1811                                 return "\xe3\x85\x87";
1812                         } elseif ( $code < 0xcc28 ) {
1813                                 return "\xe3\x85\x88";
1814                         } elseif ( $code < 0xce74 ) {
1815                                 return "\xe3\x85\x8a";
1816                         } elseif ( $code < 0xd0c0 ) {
1817                                 return "\xe3\x85\x8b";
1818                         } elseif ( $code < 0xd30c ) {
1819                                 return "\xe3\x85\x8c";
1820                         } elseif ( $code < 0xd558 ) {
1821                                 return "\xe3\x85\x8d";
1822                         } else {
1823                                 return "\xe3\x85\x8e";
1824                         }
1825                 } else {
1826                         return "";
1827                 }
1828         }
1829
1830         function initEncoding() {
1831                 # Some languages may have an alternate char encoding option
1832                 # (Esperanto X-coding, Japanese furigana conversion, etc)
1833                 # If this language is used as the primary content language,
1834                 # an override to the defaults can be set here on startup.
1835         }
1836
1837         function recodeForEdit( $s ) {
1838                 # For some languages we'll want to explicitly specify
1839                 # which characters make it into the edit box raw
1840                 # or are converted in some way or another.
1841                 # Note that if wgOutputEncoding is different from
1842                 # wgInputEncoding, this text will be further converted
1843                 # to wgOutputEncoding.
1844                 global $wgEditEncoding;
1845                 if( $wgEditEncoding == '' or
1846                   $wgEditEncoding == 'UTF-8' ) {
1847                         return $s;
1848                 } else {
1849                         return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
1850                 }
1851         }
1852
1853         function recodeInput( $s ) {
1854                 # Take the previous into account.
1855                 global $wgEditEncoding;
1856                 if($wgEditEncoding != "") {
1857                         $enc = $wgEditEncoding;
1858                 } else {
1859                         $enc = 'UTF-8';
1860                 }
1861                 if( $enc == 'UTF-8' ) {
1862                         return $s;
1863                 } else {
1864                         return $this->iconv( $enc, 'UTF-8', $s );
1865                 }
1866         }
1867
1868         /**
1869          * For right-to-left language support
1870          *
1871          * @return bool
1872          */
1873         function isRTL() {
1874                 return self::$dataCache->getItem( $this->mCode, 'rtl' );
1875         }
1876
1877         /**
1878          * Return the correct HTML 'dir' attribute value for this language.
1879          * @return String
1880          */
1881         function getDir() {
1882                 return $this->isRTL() ? 'rtl' : 'ltr';
1883         }
1884
1885         /**
1886          * Return 'left' or 'right' as appropriate alignment for line-start
1887          * for this language's text direction.
1888          *
1889          * Should be equivalent to CSS3 'start' text-align value....
1890          *
1891          * @return String
1892          */
1893         function alignStart() {
1894                 return $this->isRTL() ? 'right' : 'left';
1895         }
1896
1897         /**
1898          * Return 'right' or 'left' as appropriate alignment for line-end
1899          * for this language's text direction.
1900          *
1901          * Should be equivalent to CSS3 'end' text-align value....
1902          *
1903          * @return String
1904          */
1905         function alignEnd() {
1906                 return $this->isRTL() ? 'left' : 'right';
1907         }
1908
1909         /**
1910          * A hidden direction mark (LRM or RLM), depending on the language direction
1911          *
1912          * @return string
1913          */
1914         function getDirMark() {
1915                 return $this->isRTL() ? "\xE2\x80\x8F" : "\xE2\x80\x8E";
1916         }
1917
1918         function capitalizeAllNouns() {
1919                 return self::$dataCache->getItem( $this->mCode, 'capitalizeAllNouns' );
1920         }
1921
1922         /**
1923          * An arrow, depending on the language direction
1924          *
1925          * @return string
1926          */
1927         function getArrow() {
1928                 return $this->isRTL() ? '←' : '→';
1929         }
1930
1931         /**
1932          * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
1933          *
1934          * @return bool
1935          */
1936         function linkPrefixExtension() {
1937                 return self::$dataCache->getItem( $this->mCode, 'linkPrefixExtension' );
1938         }
1939
1940         function getMagicWords() {
1941                 return self::$dataCache->getItem( $this->mCode, 'magicWords' );
1942         }
1943
1944         # Fill a MagicWord object with data from here
1945         function getMagic( $mw ) {
1946                 if ( !$this->mMagicHookDone ) {
1947                         $this->mMagicHookDone = true;
1948                         wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
1949                 }
1950                 if ( isset( $this->mMagicExtensions[$mw->mId] ) ) {
1951                         $rawEntry = $this->mMagicExtensions[$mw->mId];
1952                 } else {
1953                         $magicWords = $this->getMagicWords();
1954                         if ( isset( $magicWords[$mw->mId] ) ) {
1955                                 $rawEntry = $magicWords[$mw->mId];
1956                         } else {
1957                                 $rawEntry = false;
1958                         }
1959                 }
1960
1961                 if( !is_array( $rawEntry ) ) {
1962                         error_log( "\"$rawEntry\" is not a valid magic thingie for \"$mw->mId\"" );
1963                 } else {
1964                         $mw->mCaseSensitive = $rawEntry[0];
1965                         $mw->mSynonyms = array_slice( $rawEntry, 1 );
1966                 }
1967         }
1968
1969         /**
1970          * Add magic words to the extension array
1971          */
1972         function addMagicWordsByLang( $newWords ) {
1973                 $code = $this->getCode();
1974                 $fallbackChain = array();
1975                 while ( $code && !in_array( $code, $fallbackChain ) ) {
1976                         $fallbackChain[] = $code;
1977                         $code = self::getFallbackFor( $code );
1978                 }
1979                 if ( !in_array( 'en', $fallbackChain ) ) {
1980                         $fallbackChain[] = 'en';
1981                 }
1982                 $fallbackChain = array_reverse( $fallbackChain );
1983                 foreach ( $fallbackChain as $code ) {
1984                         if ( isset( $newWords[$code] ) ) {
1985                                 $this->mMagicExtensions = $newWords[$code] + $this->mMagicExtensions;
1986                         }
1987                 }
1988         }
1989
1990         /**
1991          * Get special page names, as an associative array
1992          *   case folded alias => real name
1993          */
1994         function getSpecialPageAliases() {
1995                 // Cache aliases because it may be slow to load them
1996                 if ( is_null( $this->mExtendedSpecialPageAliases ) ) {
1997                         // Initialise array
1998                         $this->mExtendedSpecialPageAliases =
1999                                 self::$dataCache->getItem( $this->mCode, 'specialPageAliases' );
2000                         wfRunHooks( 'LanguageGetSpecialPageAliases',
2001                                 array( &$this->mExtendedSpecialPageAliases, $this->getCode() ) );
2002                 }
2003
2004                 return $this->mExtendedSpecialPageAliases;
2005         }
2006
2007         /**
2008          * Italic is unsuitable for some languages
2009          *
2010          * @param $text String: the text to be emphasized.
2011          * @return string
2012          */
2013         function emphasize( $text ) {
2014                 return "<em>$text</em>";
2015         }
2016
2017          /**
2018           * Normally we output all numbers in plain en_US style, that is
2019           * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2020           * point twohundredthirtyfive. However this is not sutable for all
2021           * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2022           * Icelandic just want to use commas instead of dots, and dots instead
2023           * of commas like "293.291,235".
2024           *
2025           * An example of this function being called:
2026           * <code>
2027           * wfMsg( 'message', $wgLang->formatNum( $num ) )
2028           * </code>
2029           *
2030           * See LanguageGu.php for the Gujarati implementation and
2031           * $separatorTransformTable on MessageIs.php for
2032           * the , => . and . => , implementation.
2033           *
2034           * @todo check if it's viable to use localeconv() for the decimal
2035           *       separator thing.
2036           * @param $number Mixed: the string to be formatted, should be an integer
2037           *        or a floating point number.
2038           * @param $nocommafy Bool: set to true for special numbers like dates
2039           * @return string
2040           */
2041         function formatNum( $number, $nocommafy = false ) {
2042                 global $wgTranslateNumerals;
2043                 if (!$nocommafy) {
2044                         $number = $this->commafy($number);
2045                         $s = $this->separatorTransformTable();
2046                         if ($s) { $number = strtr($number, $s); }
2047                 }
2048
2049                 if ($wgTranslateNumerals) {
2050                         $s = $this->digitTransformTable();
2051                         if ($s) { $number = strtr($number, $s); }
2052                 }
2053
2054                 return $number;
2055         }
2056
2057         function parseFormattedNumber( $number ) {
2058                 $s = $this->digitTransformTable();
2059                 if ($s) { $number = strtr($number, array_flip($s)); }
2060
2061                 $s = $this->separatorTransformTable();
2062                 if ($s) { $number = strtr($number, array_flip($s)); }
2063
2064                 $number = strtr( $number, array (',' => '') );
2065                 return $number;
2066         }
2067
2068         /**
2069          * Adds commas to a given number
2070          *
2071          * @param $_ mixed
2072          * @return string
2073          */
2074         function commafy($_) {
2075                 return strrev((string)preg_replace('/(\d{3})(?=\d)(?!\d*\.)/','$1,',strrev($_)));
2076         }
2077
2078         function digitTransformTable() {
2079                 return self::$dataCache->getItem( $this->mCode, 'digitTransformTable' );
2080         }
2081
2082         function separatorTransformTable() {
2083                 return self::$dataCache->getItem( $this->mCode, 'separatorTransformTable' );
2084         }
2085
2086
2087         /**
2088          * Take a list of strings and build a locale-friendly comma-separated
2089          * list, using the local comma-separator message.
2090          * The last two strings are chained with an "and".
2091          *
2092          * @param $l Array
2093          * @return string
2094          */
2095         function listToText( $l ) {
2096                 $s = '';
2097                 $m = count( $l ) - 1;
2098                 if( $m == 1 ) {
2099                         return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2100                 }
2101                 else {
2102                         for ( $i = $m; $i >= 0; $i-- ) {
2103                                 if ( $i == $m ) {
2104                                         $s = $l[$i];
2105                                 } else if( $i == $m - 1 ) {
2106                                         $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2107                                 } else {
2108                                         $s = $l[$i] . $this->getMessageFromDB( 'comma-separator' ) . $s;
2109                                 }
2110                         }
2111                         return $s;
2112                 }
2113         }
2114
2115         /**
2116          * Take a list of strings and build a locale-friendly comma-separated
2117          * list, using the local comma-separator message.
2118          * @param $list array of strings to put in a comma list
2119          * @return string
2120          */
2121         function commaList( $list ) {
2122                 return implode(
2123                         $list,
2124                         wfMsgExt( 'comma-separator', array( 'parsemag', 'escapenoentities', 'language' => $this ) ) );
2125         }
2126
2127         /**
2128          * Take a list of strings and build a locale-friendly semicolon-separated
2129          * list, using the local semicolon-separator message.
2130          * @param $list array of strings to put in a semicolon list
2131          * @return string
2132          */
2133         function semicolonList( $list ) {
2134                 return implode(
2135                         $list,
2136                         wfMsgExt( 'semicolon-separator', array( 'parsemag', 'escapenoentities', 'language' => $this ) ) );
2137         }
2138
2139         /**
2140          * Same as commaList, but separate it with the pipe instead.
2141          * @param $list array of strings to put in a pipe list
2142          * @return string
2143          */
2144         function pipeList( $list ) {
2145                 return implode(
2146                         $list,
2147                         wfMsgExt( 'pipe-separator', array( 'escapenoentities', 'language' => $this ) ) );
2148         }
2149
2150         /**
2151          * Truncate a string to a specified length in bytes, appending an optional
2152          * string (e.g. for ellipses)
2153          *
2154          * The database offers limited byte lengths for some columns in the database;
2155          * multi-byte character sets mean we need to ensure that only whole characters
2156          * are included, otherwise broken characters can be passed to the user
2157          *
2158          * If $length is negative, the string will be truncated from the beginning
2159          *
2160          * @param $string String to truncate
2161          * @param $length Int: maximum length (excluding ellipses)
2162          * @param $ellipsis String to append to the truncated text
2163          * @return string
2164          */
2165         function truncate( $string, $length, $ellipsis = '...' ) {
2166                 # Use the localized ellipsis character
2167                 if( $ellipsis == '...' ) {
2168                         $ellipsis = wfMsgExt( 'ellipsis', array( 'escapenoentities', 'language' => $this ) );
2169                 }
2170
2171                 if( $length == 0 ) {
2172                         return $ellipsis;
2173                 }
2174                 if ( strlen( $string ) <= abs( $length ) ) {
2175                         return $string;
2176                 }
2177                 if( $length > 0 ) {
2178                         $string = substr( $string, 0, $length );
2179                         $char = ord( $string[strlen( $string ) - 1] );
2180                         $m = array();
2181                         if ($char >= 0xc0) {
2182                                 # We got the first byte only of a multibyte char; remove it.
2183                                 $string = substr( $string, 0, -1 );
2184                         } elseif( $char >= 0x80 &&
2185                                   preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
2186                                               '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
2187                                 # We chopped in the middle of a character; remove it
2188                                 $string = $m[1];
2189                         }
2190                         return $string . $ellipsis;
2191                 } else {
2192                         $string = substr( $string, $length );
2193                         $char = ord( $string[0] );
2194                         if( $char >= 0x80 && $char < 0xc0 ) {
2195                                 # We chopped in the middle of a character; remove the whole thing
2196                                 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
2197                         }
2198                         return $ellipsis . $string;
2199                 }
2200         }
2201
2202         /**
2203          * Grammatical transformations, needed for inflected languages
2204          * Invoked by putting {{grammar:case|word}} in a message
2205          *
2206          * @param $word string
2207          * @param $case string
2208          * @return string
2209          */
2210         function convertGrammar( $word, $case ) {
2211                 global $wgGrammarForms;
2212                 if ( isset($wgGrammarForms[$this->getCode()][$case][$word]) ) {
2213                         return $wgGrammarForms[$this->getCode()][$case][$word];
2214                 }
2215                 return $word;
2216         }
2217
2218         /**
2219          * Provides an alternative text depending on specified gender.
2220          * Usage {{gender:username|masculine|feminine|neutral}}.
2221          * username is optional, in which case the gender of current user is used,
2222          * but only in (some) interface messages; otherwise default gender is used.
2223          * If second or third parameter are not specified, masculine is used.
2224          * These details may be overriden per language.
2225          */
2226         function gender( $gender, $forms ) {
2227                 if ( !count($forms) ) { return ''; }
2228                 $forms = $this->preConvertPlural( $forms, 2 );
2229                 if ( $gender === 'male' ) return $forms[0];
2230                 if ( $gender === 'female' ) return $forms[1];
2231                 return isset($forms[2]) ? $forms[2] : $forms[0];
2232         }
2233
2234         /**
2235          * Plural form transformations, needed for some languages.
2236          * For example, there are 3 form of plural in Russian and Polish,
2237          * depending on "count mod 10". See [[w:Plural]]
2238          * For English it is pretty simple.
2239          *
2240          * Invoked by putting {{plural:count|wordform1|wordform2}}
2241          * or {{plural:count|wordform1|wordform2|wordform3}}
2242          *
2243          * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2244          *
2245          * @param $count Integer: non-localized number
2246          * @param $forms Array: different plural forms
2247          * @return string Correct form of plural for $count in this language
2248          */
2249         function convertPlural( $count, $forms ) {
2250                 if ( !count($forms) ) { return ''; }
2251                 $forms = $this->preConvertPlural( $forms, 2 );
2252
2253                 return ( $count == 1 ) ? $forms[0] : $forms[1];
2254         }
2255
2256         /**
2257          * Checks that convertPlural was given an array and pads it to requested
2258          * amound of forms by copying the last one.
2259          *
2260          * @param $count Integer: How many forms should there be at least
2261          * @param $forms Array of forms given to convertPlural
2262          * @return array Padded array of forms or an exception if not an array
2263          */
2264         protected function preConvertPlural( /* Array */ $forms, $count ) {
2265                 while ( count($forms) < $count ) {
2266                         $forms[] = $forms[count($forms)-1];
2267                 }
2268                 return $forms;
2269         }
2270
2271         /**
2272          * For translaing of expiry times
2273          * @param $str String: the validated block time in English
2274          * @return Somehow translated block time
2275          * @see LanguageFi.php for example implementation
2276          */
2277         function translateBlockExpiry( $str ) {
2278
2279                 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
2280
2281                 if ( $scBlockExpiryOptions == '-') {
2282                         return $str;
2283                 }
2284
2285                 foreach (explode(',', $scBlockExpiryOptions) as $option) {
2286                         if ( strpos($option, ":") === false )
2287                                 continue;
2288                         list($show, $value) = explode(":", $option);
2289                         if ( strcmp ( $str, $value) == 0 ) {
2290                                 return htmlspecialchars( trim( $show ) );
2291                         }
2292                 }
2293
2294                 return $str;
2295         }
2296
2297         /**
2298          * languages like Chinese need to be segmented in order for the diff
2299          * to be of any use
2300          *
2301          * @param $text String
2302          * @return String
2303          */
2304         function segmentForDiff( $text ) {
2305                 return $text;
2306         }
2307
2308         /**
2309          * and unsegment to show the result
2310          *
2311          * @param $text String
2312          * @return String
2313          */
2314         function unsegmentForDiff( $text ) {
2315                 return $text;
2316         }
2317
2318         # convert text to all supported variants
2319         function autoConvertToAllVariants($text) {
2320                 return $this->mConverter->autoConvertToAllVariants($text);
2321         }
2322
2323         # convert text to different variants of a language.
2324         function convert( $text, $isTitle = false) {
2325                 return $this->mConverter->convert($text, $isTitle);
2326         }
2327
2328         # Convert text from within Parser
2329         function parserConvert( $text, &$parser ) {
2330                 return $this->mConverter->parserConvert( $text, $parser );
2331         }
2332
2333         # Check if this is a language with variants
2334         function hasVariants(){
2335                 return sizeof($this->getVariants())>1;
2336         }
2337
2338         # Put custom tags (e.g. -{ }-) around math to prevent conversion
2339         function armourMath($text){
2340                 return $this->mConverter->armourMath($text);
2341         }
2342
2343
2344         /**
2345          * Perform output conversion on a string, and encode for safe HTML output.
2346          * @param $text String text to be converted
2347          * @param $isTitle Bool whether this conversion is for the article title
2348          * @return string
2349          * @todo this should get integrated somewhere sane
2350          */
2351         function convertHtml( $text, $isTitle = false ) {
2352                 return htmlspecialchars( $this->convert( $text, $isTitle ) );
2353         }
2354
2355         function convertCategoryKey( $key ) {
2356                 return $this->mConverter->convertCategoryKey( $key );
2357         }
2358
2359         /**
2360          * get the list of variants supported by this langauge
2361          * see sample implementation in LanguageZh.php
2362          *
2363          * @return array an array of language codes
2364          */
2365         function getVariants() {
2366                 return $this->mConverter->getVariants();
2367         }
2368
2369
2370         function getPreferredVariant( $fromUser = true ) {
2371                 return $this->mConverter->getPreferredVariant( $fromUser );
2372         }
2373
2374         /**
2375          * if a language supports multiple variants, it is
2376          * possible that non-existing link in one variant
2377          * actually exists in another variant. this function
2378          * tries to find it. See e.g. LanguageZh.php
2379          *
2380          * @param $link String: the name of the link
2381          * @param $nt Mixed: the title object of the link
2382          * @param boolean $ignoreOtherCond: to disable other conditions when
2383          *      we need to transclude a template or update a category's link
2384          * @return null the input parameters may be modified upon return
2385          */
2386         function findVariantLink( &$link, &$nt, $ignoreOtherCond = false ) {
2387                 $this->mConverter->findVariantLink( $link, $nt, $ignoreOtherCond );
2388         }
2389
2390         /**
2391          * If a language supports multiple variants, converts text
2392          * into an array of all possible variants of the text:
2393          *  'variant' => text in that variant
2394          */
2395         function convertLinkToAllVariants($text){
2396                 return $this->mConverter->convertLinkToAllVariants($text);
2397         }
2398
2399
2400         /**
2401          * returns language specific options used by User::getPageRenderHash()
2402          * for example, the preferred language variant
2403          *
2404          * @return string
2405          */
2406         function getExtraHashOptions() {
2407                 return $this->mConverter->getExtraHashOptions();
2408         }
2409
2410         /**
2411          * for languages that support multiple variants, the title of an
2412          * article may be displayed differently in different variants. this
2413          * function returns the apporiate title defined in the body of the article.
2414          *
2415          * @return string
2416          */
2417         function getParsedTitle() {
2418                 return $this->mConverter->getParsedTitle();
2419         }
2420
2421         /**
2422          * Enclose a string with the "no conversion" tag. This is used by
2423          * various functions in the Parser
2424          *
2425          * @param $text String: text to be tagged for no conversion
2426          * @param $noParse
2427          * @return string the tagged text
2428          */
2429         function markNoConversion( $text, $noParse=false ) {
2430                 return $this->mConverter->markNoConversion( $text, $noParse );
2431         }
2432
2433         /**
2434          * A regular expression to match legal word-trailing characters
2435          * which should be merged onto a link of the form [[foo]]bar.
2436          *
2437          * @return string
2438          */
2439         function linkTrail() {
2440                 return self::$dataCache->getItem( $this->mCode, 'linkTrail' );
2441         }
2442
2443         function getLangObj() {
2444                 return $this;
2445         }
2446
2447         /**
2448          * Get the RFC 3066 code for this language object
2449          */
2450         function getCode() {
2451                 return $this->mCode;
2452         }
2453
2454         function setCode( $code ) {
2455                 $this->mCode = $code;
2456         }
2457
2458         static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
2459                 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
2460         }
2461
2462         static function getMessagesFileName( $code ) {
2463                 global $IP;
2464                 return self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
2465         }
2466
2467         static function getClassFileName( $code ) {
2468                 global $IP;
2469                 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
2470         }
2471
2472         /**
2473          * Get the fallback for a given language
2474          */
2475         static function getFallbackFor( $code ) {
2476                 if ( $code === 'en' ) {
2477                         // Shortcut
2478                         return false;
2479                 } else {
2480                         return self::getLocalisationCache()->getItem( $code, 'fallback' );
2481                 }
2482         }
2483
2484         /**
2485          * Get all messages for a given language
2486          * WARNING: this may take a long time
2487          */
2488         static function getMessagesFor( $code ) {
2489                 return self::getLocalisationCache()->getItem( $code, 'messages' );
2490         }
2491
2492         /**
2493          * Get a message for a given language
2494          */
2495         static function getMessageFor( $key, $code ) {
2496                 return self::getLocalisationCache()->getSubitem( $code, 'messages', $key );
2497         }
2498
2499         function fixVariableInNamespace( $talk ) {
2500                 if ( strpos( $talk, '$1' ) === false ) return $talk;
2501
2502                 global $wgMetaNamespace;
2503                 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
2504
2505                 # Allow grammar transformations
2506                 # Allowing full message-style parsing would make simple requests
2507                 # such as action=raw much more expensive than they need to be.
2508                 # This will hopefully cover most cases.
2509                 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
2510                         array( &$this, 'replaceGrammarInNamespace' ), $talk );
2511                 return str_replace( ' ', '_', $talk );
2512         }
2513
2514         function replaceGrammarInNamespace( $m ) {
2515                 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
2516         }
2517
2518         static function getCaseMaps() {
2519                 static $wikiUpperChars, $wikiLowerChars;
2520                 if ( isset( $wikiUpperChars ) ) {
2521                         return array( $wikiUpperChars, $wikiLowerChars );
2522                 }
2523
2524                 wfProfileIn( __METHOD__ );
2525                 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
2526                 if ( $arr === false ) {
2527                         throw new MWException(
2528                                 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
2529                 }
2530                 extract( $arr );
2531                 wfProfileOut( __METHOD__ );
2532                 return array( $wikiUpperChars, $wikiLowerChars );
2533         }
2534
2535         function formatTimePeriod( $seconds ) {
2536                 if ( $seconds < 10 ) {
2537                         return $this->formatNum( sprintf( "%.1f", $seconds ) ) . wfMsg( 'seconds-abbrev' );
2538                 } elseif ( $seconds < 60 ) {
2539                         return $this->formatNum( round( $seconds ) ) . wfMsg( 'seconds-abbrev' );
2540                 } elseif ( $seconds < 3600 ) {
2541                         return $this->formatNum( floor( $seconds / 60 ) ) . wfMsg( 'minutes-abbrev' ) .
2542                                 $this->formatNum( round( fmod( $seconds, 60 ) ) ) . wfMsg( 'seconds-abbrev' );
2543                 } else {
2544                         $hours = floor( $seconds / 3600 );
2545                         $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
2546                         $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
2547                         return $this->formatNum( $hours ) . wfMsg( 'hours-abbrev' ) .
2548                                 $this->formatNum( $minutes ) . wfMsg( 'minutes-abbrev' ) .
2549                                 $this->formatNum( $secondsPart ) . wfMsg( 'seconds-abbrev' );
2550                 }
2551         }
2552
2553         function formatBitrate( $bps ) {
2554                 $units = array( 'bps', 'kbps', 'Mbps', 'Gbps' );
2555                 if ( $bps <= 0 ) {
2556                         return $this->formatNum( $bps ) . $units[0];
2557                 }
2558                 $unitIndex = floor( log10( $bps ) / 3 );
2559                 $mantissa = $bps / pow( 1000, $unitIndex );
2560                 if ( $mantissa < 10 ) {
2561                         $mantissa = round( $mantissa, 1 );
2562                 } else {
2563                         $mantissa = round( $mantissa );
2564                 }
2565                 return $this->formatNum( $mantissa ) . $units[$unitIndex];
2566         }
2567
2568         /**
2569          * Format a size in bytes for output, using an appropriate
2570          * unit (B, KB, MB or GB) according to the magnitude in question
2571          *
2572          * @param $size Size to format
2573          * @return string Plain text (not HTML)
2574          */
2575         function formatSize( $size ) {
2576                 // For small sizes no decimal places necessary
2577                 $round = 0;
2578                 if( $size > 1024 ) {
2579                         $size = $size / 1024;
2580                         if( $size > 1024 ) {
2581                                 $size = $size / 1024;
2582                                 // For MB and bigger two decimal places are smarter
2583                                 $round = 2;
2584                                 if( $size > 1024 ) {
2585                                         $size = $size / 1024;
2586                                         $msg = 'size-gigabytes';
2587                                 } else {
2588                                         $msg = 'size-megabytes';
2589                                 }
2590                         } else {
2591                                 $msg = 'size-kilobytes';
2592                         }
2593                 } else {
2594                         $msg = 'size-bytes';
2595                 }
2596                 $size = round( $size, $round );
2597                 $text = $this->getMessageFromDB( $msg );
2598                 return str_replace( '$1', $this->formatNum( $size ), $text );
2599         }
2600 }