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                 if ( empty($str) ) return $str;
1513                 if ( ord($str[0]) < 128 ) return ucfirst($str);
1514                 else return self::uc($str,true); // fall back to more complex logic in case of multibyte strings
1515         }
1516
1517         function uc( $str, $first = false ) {
1518                 if ( function_exists( 'mb_strtoupper' ) ) {
1519                         if ( $first ) {
1520                                 if ( self::isMultibyte( $str ) ) {
1521                                         return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1522                                 } else {
1523                                         return ucfirst( $str );
1524                                 }
1525                         } else {
1526                                 return self::isMultibyte( $str ) ? mb_strtoupper( $str ) : strtoupper( $str );
1527                         }
1528                 } else {
1529                         if ( self::isMultibyte( $str ) ) {
1530                                 list( $wikiUpperChars ) = $this->getCaseMaps();
1531                                 $x = $first ? '^' : '';
1532                                 return preg_replace_callback(
1533                                         "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1534                                         array($this,"ucCallback"),
1535                                         $str
1536                                 );
1537                         } else {
1538                                 return $first ? ucfirst( $str ) : strtoupper( $str );
1539                         }
1540                 }
1541         }
1542
1543         function lcfirst( $str ) {
1544                 if ( empty($str) ) return $str;
1545                 if ( is_string( $str ) && ord($str[0]) < 128 ) {
1546                         // editing string in place = cool
1547                         $str[0]=strtolower($str[0]);
1548                         return $str;
1549                 }
1550                 else return self::lc( $str, true );
1551         }
1552
1553         function lc( $str, $first = false ) {
1554                 if ( function_exists( 'mb_strtolower' ) )
1555                         if ( $first )
1556                                 if ( self::isMultibyte( $str ) )
1557                                         return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1558                                 else
1559                                         return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
1560                         else
1561                                 return self::isMultibyte( $str ) ? mb_strtolower( $str ) : strtolower( $str );
1562                 else
1563                         if ( self::isMultibyte( $str ) ) {
1564                                 list( , $wikiLowerChars ) = self::getCaseMaps();
1565                                 $x = $first ? '^' : '';
1566                                 return preg_replace_callback(
1567                                         "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1568                                         array($this,"lcCallback"),
1569                                         $str
1570                                 );
1571                         } else
1572                                 return $first ? strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
1573         }
1574
1575         function isMultibyte( $str ) {
1576                 return (bool)preg_match( '/[\x80-\xff]/', $str );
1577         }
1578
1579         function ucwords($str) {
1580                 if ( self::isMultibyte( $str ) ) {
1581                         $str = self::lc($str);
1582
1583                         // regexp to find first letter in each word (i.e. after each space)
1584                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1585
1586                         // function to use to capitalize a single char
1587                         if ( function_exists( 'mb_strtoupper' ) )
1588                                 return preg_replace_callback(
1589                                         $replaceRegexp,
1590                                         array($this,"ucwordsCallbackMB"),
1591                                         $str
1592                                 );
1593                         else
1594                                 return preg_replace_callback(
1595                                         $replaceRegexp,
1596                                         array($this,"ucwordsCallbackWiki"),
1597                                         $str
1598                                 );
1599                 }
1600                 else
1601                         return ucwords( strtolower( $str ) );
1602         }
1603
1604   # capitalize words at word breaks
1605         function ucwordbreaks($str){
1606                 if (self::isMultibyte( $str ) ) {
1607                         $str = self::lc($str);
1608
1609                         // since \b doesn't work for UTF-8, we explicitely define word break chars
1610                         $breaks= "[ \-\(\)\}\{\.,\?!]";
1611
1612                         // find first letter after word break
1613                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1614
1615                         if ( function_exists( 'mb_strtoupper' ) )
1616                                 return preg_replace_callback(
1617                                         $replaceRegexp,
1618                                         array($this,"ucwordbreaksCallbackMB"),
1619                                         $str
1620                                 );
1621                         else
1622                                 return preg_replace_callback(
1623                                         $replaceRegexp,
1624                                         array($this,"ucwordsCallbackWiki"),
1625                                         $str
1626                                 );
1627                 }
1628                 else
1629                         return preg_replace_callback(
1630                         '/\b([\w\x80-\xff]+)\b/',
1631                         array($this,"ucwordbreaksCallbackAscii"),
1632                         $str );
1633         }
1634
1635         /**
1636          * Return a case-folded representation of $s
1637          *
1638          * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1639          * and $s2 are the same except for the case of their characters. It is not
1640          * necessary for the value returned to make sense when displayed.
1641          *
1642          * Do *not* perform any other normalisation in this function. If a caller
1643          * uses this function when it should be using a more general normalisation
1644          * function, then fix the caller.
1645          */
1646         function caseFold( $s ) {
1647                 return $this->uc( $s );
1648         }
1649
1650         function checkTitleEncoding( $s ) {
1651                 if( is_array( $s ) ) {
1652                         wfDebugDieBacktrace( 'Given array to checkTitleEncoding.' );
1653                 }
1654                 # Check for non-UTF-8 URLs
1655                 $ishigh = preg_match( '/[\x80-\xff]/', $s);
1656                 if(!$ishigh) return $s;
1657
1658                 $isutf8 = preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1659                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
1660                 if( $isutf8 ) return $s;
1661
1662                 return $this->iconv( $this->fallback8bitEncoding(), "utf-8", $s );
1663         }
1664
1665         function fallback8bitEncoding() {
1666                 return self::$dataCache->getItem( $this->mCode, 'fallback8bitEncoding' );
1667         }
1668
1669         /**
1670          * Most writing systems use whitespace to break up words.
1671          * Some languages such as Chinese don't conventionally do this,
1672          * which requires special handling when breaking up words for
1673          * searching etc.
1674          */
1675         function hasWordBreaks() {
1676                 return true;
1677         }
1678
1679         /**
1680          * Some languages have special punctuation to strip out
1681          * or characters which need to be converted for MySQL's
1682          * indexing to grok it correctly. Make such changes here.
1683          *
1684          * @param $string String
1685          * @return String
1686          */
1687         function stripForSearch( $string ) {
1688                 global $wgDBtype;
1689                 if ( $wgDBtype != 'mysql' ) {
1690                         return $string;
1691                 }
1692
1693
1694                 wfProfileIn( __METHOD__ );
1695
1696                 // MySQL fulltext index doesn't grok utf-8, so we
1697                 // need to fold cases and convert to hex
1698                 $out = preg_replace_callback(
1699                         "/([\\xc0-\\xff][\\x80-\\xbf]*)/",
1700                         array( $this, 'stripForSearchCallback' ),
1701                         $this->lc( $string ) );
1702
1703                 // And to add insult to injury, the default indexing
1704                 // ignores short words... Pad them so we can pass them
1705                 // through without reconfiguring the server...
1706                 $minLength = $this->minSearchLength();
1707                 if( $minLength > 1 ) {
1708                         $n = $minLength-1;
1709                         $out = preg_replace(
1710                                 "/\b(\w{1,$n})\b/",
1711                                 "$1u800",
1712                                 $out );
1713                 }
1714
1715                 // Periods within things like hostnames and IP addresses
1716                 // are also important -- we want a search for "example.com"
1717                 // or "192.168.1.1" to work sanely.
1718                 //
1719                 // MySQL's search seems to ignore them, so you'd match on
1720                 // "example.wikipedia.com" and "192.168.83.1" as well.
1721                 $out = preg_replace(
1722                         "/(\w)\.(\w|\*)/u",
1723                         "$1u82e$2",
1724                         $out );
1725
1726                 wfProfileOut( __METHOD__ );
1727                 return $out;
1728         }
1729
1730         /**
1731          * Armor a case-folded UTF-8 string to get through MySQL's
1732          * fulltext search without being mucked up by funny charset
1733          * settings or anything else of the sort.
1734          */
1735         protected function stripForSearchCallback( $matches ) {
1736                 return 'u8' . bin2hex( $matches[1] );
1737         }
1738
1739         /**
1740          * Check MySQL server's ft_min_word_len setting so we know
1741          * if we need to pad short words...
1742          */
1743         protected function minSearchLength() {
1744                 if( is_null( $this->minSearchLength ) ) {
1745                         $sql = "show global variables like 'ft\\_min\\_word\\_len'";
1746                         $dbr = wfGetDB( DB_SLAVE );
1747                         $result = $dbr->query( $sql );
1748                         $row = $result->fetchObject();
1749                         $result->free();
1750
1751                         if( $row && $row->Variable_name == 'ft_min_word_len' ) {
1752                                 $this->minSearchLength = intval( $row->Value );
1753                         } else {
1754                                 $this->minSearchLength = 0;
1755                         }
1756                 }
1757                 return $this->minSearchLength;
1758         }
1759
1760         function convertForSearchResult( $termsArray ) {
1761                 # some languages, e.g. Chinese, need to do a conversion
1762                 # in order for search results to be displayed correctly
1763                 return $termsArray;
1764         }
1765
1766         /**
1767          * Get the first character of a string.
1768          *
1769          * @param $s string
1770          * @return string
1771          */
1772         function firstChar( $s ) {
1773                 $matches = array();
1774                 preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1775                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/', $s, $matches);
1776
1777                 if ( isset( $matches[1] ) ) {
1778                         if ( strlen( $matches[1] ) != 3 ) {
1779                                 return $matches[1];
1780                         }
1781
1782                         // Break down Hangul syllables to grab the first jamo
1783                         $code = utf8ToCodepoint( $matches[1] );
1784                         if ( $code < 0xac00 || 0xd7a4 <= $code) {
1785                                 return $matches[1];
1786                         } elseif ( $code < 0xb098 ) {
1787                                 return "\xe3\x84\xb1";
1788                         } elseif ( $code < 0xb2e4 ) {
1789                                 return "\xe3\x84\xb4";
1790                         } elseif ( $code < 0xb77c ) {
1791                                 return "\xe3\x84\xb7";
1792                         } elseif ( $code < 0xb9c8 ) {
1793                                 return "\xe3\x84\xb9";
1794                         } elseif ( $code < 0xbc14 ) {
1795                                 return "\xe3\x85\x81";
1796                         } elseif ( $code < 0xc0ac ) {
1797                                 return "\xe3\x85\x82";
1798                         } elseif ( $code < 0xc544 ) {
1799                                 return "\xe3\x85\x85";
1800                         } elseif ( $code < 0xc790 ) {
1801                                 return "\xe3\x85\x87";
1802                         } elseif ( $code < 0xcc28 ) {
1803                                 return "\xe3\x85\x88";
1804                         } elseif ( $code < 0xce74 ) {
1805                                 return "\xe3\x85\x8a";
1806                         } elseif ( $code < 0xd0c0 ) {
1807                                 return "\xe3\x85\x8b";
1808                         } elseif ( $code < 0xd30c ) {
1809                                 return "\xe3\x85\x8c";
1810                         } elseif ( $code < 0xd558 ) {
1811                                 return "\xe3\x85\x8d";
1812                         } else {
1813                                 return "\xe3\x85\x8e";
1814                         }
1815                 } else {
1816                         return "";
1817                 }
1818         }
1819
1820         function initEncoding() {
1821                 # Some languages may have an alternate char encoding option
1822                 # (Esperanto X-coding, Japanese furigana conversion, etc)
1823                 # If this language is used as the primary content language,
1824                 # an override to the defaults can be set here on startup.
1825         }
1826
1827         function recodeForEdit( $s ) {
1828                 # For some languages we'll want to explicitly specify
1829                 # which characters make it into the edit box raw
1830                 # or are converted in some way or another.
1831                 # Note that if wgOutputEncoding is different from
1832                 # wgInputEncoding, this text will be further converted
1833                 # to wgOutputEncoding.
1834                 global $wgEditEncoding;
1835                 if( $wgEditEncoding == '' or
1836                   $wgEditEncoding == 'UTF-8' ) {
1837                         return $s;
1838                 } else {
1839                         return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
1840                 }
1841         }
1842
1843         function recodeInput( $s ) {
1844                 # Take the previous into account.
1845                 global $wgEditEncoding;
1846                 if($wgEditEncoding != "") {
1847                         $enc = $wgEditEncoding;
1848                 } else {
1849                         $enc = 'UTF-8';
1850                 }
1851                 if( $enc == 'UTF-8' ) {
1852                         return $s;
1853                 } else {
1854                         return $this->iconv( $enc, 'UTF-8', $s );
1855                 }
1856         }
1857
1858         /**
1859          * For right-to-left language support
1860          *
1861          * @return bool
1862          */
1863         function isRTL() {
1864                 return self::$dataCache->getItem( $this->mCode, 'rtl' );
1865         }
1866
1867         /**
1868          * A hidden direction mark (LRM or RLM), depending on the language direction
1869          *
1870          * @return string
1871          */
1872         function getDirMark() {
1873                 return $this->isRTL() ? "\xE2\x80\x8F" : "\xE2\x80\x8E";
1874         }
1875
1876         function capitalizeAllNouns() {
1877                 return self::$dataCache->getItem( $this->mCode, 'capitalizeAllNouns' );
1878         }
1879
1880         /**
1881          * An arrow, depending on the language direction
1882          *
1883          * @return string
1884          */
1885         function getArrow() {
1886                 return $this->isRTL() ? '←' : '→';
1887         }
1888
1889         /**
1890          * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
1891          *
1892          * @return bool
1893          */
1894         function linkPrefixExtension() {
1895                 return self::$dataCache->getItem( $this->mCode, 'linkPrefixExtension' );
1896         }
1897
1898         function getMagicWords() {
1899                 return self::$dataCache->getItem( $this->mCode, 'magicWords' );
1900         }
1901
1902         # Fill a MagicWord object with data from here
1903         function getMagic( $mw ) {
1904                 if ( !$this->mMagicHookDone ) {
1905                         $this->mMagicHookDone = true;
1906                         wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
1907                 }
1908                 if ( isset( $this->mMagicExtensions[$mw->mId] ) ) {
1909                         $rawEntry = $this->mMagicExtensions[$mw->mId];
1910                 } else {
1911                         $magicWords = $this->getMagicWords();
1912                         if ( isset( $magicWords[$mw->mId] ) ) {
1913                                 $rawEntry = $magicWords[$mw->mId];
1914                         } else {
1915                                 $rawEntry = false;
1916                         }
1917                 }
1918
1919                 if( !is_array( $rawEntry ) ) {
1920                         error_log( "\"$rawEntry\" is not a valid magic thingie for \"$mw->mId\"" );
1921                 } else {
1922                         $mw->mCaseSensitive = $rawEntry[0];
1923                         $mw->mSynonyms = array_slice( $rawEntry, 1 );
1924                 }
1925         }
1926
1927         /**
1928          * Add magic words to the extension array
1929          */
1930         function addMagicWordsByLang( $newWords ) {
1931                 $code = $this->getCode();
1932                 $fallbackChain = array();
1933                 while ( $code && !in_array( $code, $fallbackChain ) ) {
1934                         $fallbackChain[] = $code;
1935                         $code = self::getFallbackFor( $code );
1936                 }
1937                 if ( !in_array( 'en', $fallbackChain ) ) {
1938                         $fallbackChain[] = 'en';
1939                 }
1940                 $fallbackChain = array_reverse( $fallbackChain );
1941                 foreach ( $fallbackChain as $code ) {
1942                         if ( isset( $newWords[$code] ) ) {
1943                                 $this->mMagicExtensions = $newWords[$code] + $this->mMagicExtensions;
1944                         }
1945                 }
1946         }
1947
1948         /**
1949          * Get special page names, as an associative array
1950          *   case folded alias => real name
1951          */
1952         function getSpecialPageAliases() {
1953                 // Cache aliases because it may be slow to load them
1954                 if ( is_null( $this->mExtendedSpecialPageAliases ) ) {
1955                         // Initialise array
1956                         $this->mExtendedSpecialPageAliases =
1957                                 self::$dataCache->getItem( $this->mCode, 'specialPageAliases' );
1958                         wfRunHooks( 'LanguageGetSpecialPageAliases',
1959                                 array( &$this->mExtendedSpecialPageAliases, $this->getCode() ) );
1960                 }
1961
1962                 return $this->mExtendedSpecialPageAliases;
1963         }
1964
1965         /**
1966          * Italic is unsuitable for some languages
1967          *
1968          * @param $text String: the text to be emphasized.
1969          * @return string
1970          */
1971         function emphasize( $text ) {
1972                 return "<em>$text</em>";
1973         }
1974
1975          /**
1976           * Normally we output all numbers in plain en_US style, that is
1977           * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
1978           * point twohundredthirtyfive. However this is not sutable for all
1979           * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
1980           * Icelandic just want to use commas instead of dots, and dots instead
1981           * of commas like "293.291,235".
1982           *
1983           * An example of this function being called:
1984           * <code>
1985           * wfMsg( 'message', $wgLang->formatNum( $num ) )
1986           * </code>
1987           *
1988           * See LanguageGu.php for the Gujarati implementation and
1989           * $separatorTransformTable on MessageIs.php for
1990           * the , => . and . => , implementation.
1991           *
1992           * @todo check if it's viable to use localeconv() for the decimal
1993           *       separator thing.
1994           * @param $number Mixed: the string to be formatted, should be an integer
1995           *        or a floating point number.
1996           * @param $nocommafy Bool: set to true for special numbers like dates
1997           * @return string
1998           */
1999         function formatNum( $number, $nocommafy = false ) {
2000                 global $wgTranslateNumerals;
2001                 if (!$nocommafy) {
2002                         $number = $this->commafy($number);
2003                         $s = $this->separatorTransformTable();
2004                         if ($s) { $number = strtr($number, $s); }
2005                 }
2006
2007                 if ($wgTranslateNumerals) {
2008                         $s = $this->digitTransformTable();
2009                         if ($s) { $number = strtr($number, $s); }
2010                 }
2011
2012                 return $number;
2013         }
2014
2015         function parseFormattedNumber( $number ) {
2016                 $s = $this->digitTransformTable();
2017                 if ($s) { $number = strtr($number, array_flip($s)); }
2018
2019                 $s = $this->separatorTransformTable();
2020                 if ($s) { $number = strtr($number, array_flip($s)); }
2021
2022                 $number = strtr( $number, array (',' => '') );
2023                 return $number;
2024         }
2025
2026         /**
2027          * Adds commas to a given number
2028          *
2029          * @param $_ mixed
2030          * @return string
2031          */
2032         function commafy($_) {
2033                 return strrev((string)preg_replace('/(\d{3})(?=\d)(?!\d*\.)/','$1,',strrev($_)));
2034         }
2035
2036         function digitTransformTable() {
2037                 return self::$dataCache->getItem( $this->mCode, 'digitTransformTable' );
2038         }
2039
2040         function separatorTransformTable() {
2041                 return self::$dataCache->getItem( $this->mCode, 'separatorTransformTable' );
2042         }
2043
2044
2045         /**
2046          * Take a list of strings and build a locale-friendly comma-separated
2047          * list, using the local comma-separator message.
2048          * The last two strings are chained with an "and".
2049          *
2050          * @param $l Array
2051          * @return string
2052          */
2053         function listToText( $l ) {
2054                 $s = '';
2055                 $m = count( $l ) - 1;
2056                 if( $m == 1 ) {
2057                         return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2058                 }
2059                 else {
2060                         for ( $i = $m; $i >= 0; $i-- ) {
2061                                 if ( $i == $m ) {
2062                                         $s = $l[$i];
2063                                 } else if( $i == $m - 1 ) {
2064                                         $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2065                                 } else {
2066                                         $s = $l[$i] . $this->getMessageFromDB( 'comma-separator' ) . $s;
2067                                 }
2068                         }
2069                         return $s;
2070                 }
2071         }
2072
2073         /**
2074          * Take a list of strings and build a locale-friendly comma-separated
2075          * list, using the local comma-separator message.
2076          * @param $list array of strings to put in a comma list
2077          * @return string
2078          */
2079         function commaList( $list ) {
2080                 return implode(
2081                         $list,
2082                         wfMsgExt( 'comma-separator', array( 'parsemag', 'escapenoentities', 'language' => $this ) ) );
2083         }
2084
2085         /**
2086          * Take a list of strings and build a locale-friendly semicolon-separated
2087          * list, using the local semicolon-separator message.
2088          * @param $list array of strings to put in a semicolon list
2089          * @return string
2090          */
2091         function semicolonList( $list ) {
2092                 return implode(
2093                         $list,
2094                         wfMsgExt( 'semicolon-separator', array( 'parsemag', 'escapenoentities', 'language' => $this ) ) );
2095         }
2096
2097         /**
2098          * Same as commaList, but separate it with the pipe instead.
2099          * @param $list array of strings to put in a pipe list
2100          * @return string
2101          */
2102         function pipeList( $list ) {
2103                 return implode(
2104                         $list,
2105                         wfMsgExt( 'pipe-separator', array( 'escapenoentities', 'language' => $this ) ) );
2106         }
2107
2108         /**
2109          * Truncate a string to a specified length in bytes, appending an optional
2110          * string (e.g. for ellipses)
2111          *
2112          * The database offers limited byte lengths for some columns in the database;
2113          * multi-byte character sets mean we need to ensure that only whole characters
2114          * are included, otherwise broken characters can be passed to the user
2115          *
2116          * If $length is negative, the string will be truncated from the beginning
2117          *
2118          * @param $string String to truncate
2119          * @param $length Int: maximum length (excluding ellipses)
2120          * @param $ellipsis String to append to the truncated text
2121          * @return string
2122          */
2123         function truncate( $string, $length, $ellipsis = '...' ) {
2124                 # Use the localized ellipsis character
2125                 if( $ellipsis == '...' ) {
2126                         $ellipsis = wfMsgExt( 'ellipsis', array( 'escapenoentities', 'language' => $this ) );
2127                 }
2128
2129                 if( $length == 0 ) {
2130                         return $ellipsis;
2131                 }
2132                 if ( strlen( $string ) <= abs( $length ) ) {
2133                         return $string;
2134                 }
2135                 if( $length > 0 ) {
2136                         $string = substr( $string, 0, $length );
2137                         $char = ord( $string[strlen( $string ) - 1] );
2138                         $m = array();
2139                         if ($char >= 0xc0) {
2140                                 # We got the first byte only of a multibyte char; remove it.
2141                                 $string = substr( $string, 0, -1 );
2142                         } elseif( $char >= 0x80 &&
2143                                   preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
2144                                               '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
2145                                 # We chopped in the middle of a character; remove it
2146                                 $string = $m[1];
2147                         }
2148                         return $string . $ellipsis;
2149                 } else {
2150                         $string = substr( $string, $length );
2151                         $char = ord( $string[0] );
2152                         if( $char >= 0x80 && $char < 0xc0 ) {
2153                                 # We chopped in the middle of a character; remove the whole thing
2154                                 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
2155                         }
2156                         return $ellipsis . $string;
2157                 }
2158         }
2159
2160         /**
2161          * Grammatical transformations, needed for inflected languages
2162          * Invoked by putting {{grammar:case|word}} in a message
2163          *
2164          * @param $word string
2165          * @param $case string
2166          * @return string
2167          */
2168         function convertGrammar( $word, $case ) {
2169                 global $wgGrammarForms;
2170                 if ( isset($wgGrammarForms[$this->getCode()][$case][$word]) ) {
2171                         return $wgGrammarForms[$this->getCode()][$case][$word];
2172                 }
2173                 return $word;
2174         }
2175
2176         /**
2177          * Provides an alternative text depending on specified gender.
2178          * Usage {{gender:username|masculine|feminine|neutral}}.
2179          * username is optional, in which case the gender of current user is used,
2180          * but only in (some) interface messages; otherwise default gender is used.
2181          * If second or third parameter are not specified, masculine is used.
2182          * These details may be overriden per language.
2183          */
2184         function gender( $gender, $forms ) {
2185                 if ( !count($forms) ) { return ''; }
2186                 $forms = $this->preConvertPlural( $forms, 2 );
2187                 if ( $gender === 'male' ) return $forms[0];
2188                 if ( $gender === 'female' ) return $forms[1];
2189                 return isset($forms[2]) ? $forms[2] : $forms[0];
2190         }
2191
2192         /**
2193          * Plural form transformations, needed for some languages.
2194          * For example, there are 3 form of plural in Russian and Polish,
2195          * depending on "count mod 10". See [[w:Plural]]
2196          * For English it is pretty simple.
2197          *
2198          * Invoked by putting {{plural:count|wordform1|wordform2}}
2199          * or {{plural:count|wordform1|wordform2|wordform3}}
2200          *
2201          * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2202          *
2203          * @param $count Integer: non-localized number
2204          * @param $forms Array: different plural forms
2205          * @return string Correct form of plural for $count in this language
2206          */
2207         function convertPlural( $count, $forms ) {
2208                 if ( !count($forms) ) { return ''; }
2209                 $forms = $this->preConvertPlural( $forms, 2 );
2210
2211                 return ( $count == 1 ) ? $forms[0] : $forms[1];
2212         }
2213
2214         /**
2215          * Checks that convertPlural was given an array and pads it to requested
2216          * amound of forms by copying the last one.
2217          *
2218          * @param $count Integer: How many forms should there be at least
2219          * @param $forms Array of forms given to convertPlural
2220          * @return array Padded array of forms or an exception if not an array
2221          */
2222         protected function preConvertPlural( /* Array */ $forms, $count ) {
2223                 while ( count($forms) < $count ) {
2224                         $forms[] = $forms[count($forms)-1];
2225                 }
2226                 return $forms;
2227         }
2228
2229         /**
2230          * For translaing of expiry times
2231          * @param $str String: the validated block time in English
2232          * @return Somehow translated block time
2233          * @see LanguageFi.php for example implementation
2234          */
2235         function translateBlockExpiry( $str ) {
2236
2237                 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
2238
2239                 if ( $scBlockExpiryOptions == '-') {
2240                         return $str;
2241                 }
2242
2243                 foreach (explode(',', $scBlockExpiryOptions) as $option) {
2244                         if ( strpos($option, ":") === false )
2245                                 continue;
2246                         list($show, $value) = explode(":", $option);
2247                         if ( strcmp ( $str, $value) == 0 ) {
2248                                 return htmlspecialchars( trim( $show ) );
2249                         }
2250                 }
2251
2252                 return $str;
2253         }
2254
2255         /**
2256          * languages like Chinese need to be segmented in order for the diff
2257          * to be of any use
2258          *
2259          * @param $text String
2260          * @return String
2261          */
2262         function segmentForDiff( $text ) {
2263                 return $text;
2264         }
2265
2266         /**
2267          * and unsegment to show the result
2268          *
2269          * @param $text String
2270          * @return String
2271          */
2272         function unsegmentForDiff( $text ) {
2273                 return $text;
2274         }
2275
2276         # convert text to all supported variants
2277         function autoConvertToAllVariants($text) {
2278                 return $this->mConverter->autoConvertToAllVariants($text);
2279         }
2280
2281         # convert text to different variants of a language.
2282         function convert( $text, $isTitle = false) {
2283                 return $this->mConverter->convert($text, $isTitle);
2284         }
2285
2286         # Convert text from within Parser
2287         function parserConvert( $text, &$parser ) {
2288                 return $this->mConverter->parserConvert( $text, $parser );
2289         }
2290
2291         # Check if this is a language with variants
2292         function hasVariants(){
2293                 return sizeof($this->getVariants())>1;
2294         }
2295
2296         # Put custom tags (e.g. -{ }-) around math to prevent conversion
2297         function armourMath($text){
2298                 return $this->mConverter->armourMath($text);
2299         }
2300
2301
2302         /**
2303          * Perform output conversion on a string, and encode for safe HTML output.
2304          * @param $text String text to be converted
2305          * @param $isTitle Bool whether this conversion is for the article title
2306          * @return string
2307          * @todo this should get integrated somewhere sane
2308          */
2309         function convertHtml( $text, $isTitle = false ) {
2310                 return htmlspecialchars( $this->convert( $text, $isTitle ) );
2311         }
2312
2313         function convertCategoryKey( $key ) {
2314                 return $this->mConverter->convertCategoryKey( $key );
2315         }
2316
2317         /**
2318          * get the list of variants supported by this langauge
2319          * see sample implementation in LanguageZh.php
2320          *
2321          * @return array an array of language codes
2322          */
2323         function getVariants() {
2324                 return $this->mConverter->getVariants();
2325         }
2326
2327
2328         function getPreferredVariant( $fromUser = true ) {
2329                 return $this->mConverter->getPreferredVariant( $fromUser );
2330         }
2331
2332         /**
2333          * if a language supports multiple variants, it is
2334          * possible that non-existing link in one variant
2335          * actually exists in another variant. this function
2336          * tries to find it. See e.g. LanguageZh.php
2337          *
2338          * @param $link String: the name of the link
2339          * @param $nt Mixed: the title object of the link
2340          * @param boolean $ignoreOtherCond: to disable other conditions when
2341          *      we need to transclude a template or update a category's link
2342          * @return null the input parameters may be modified upon return
2343          */
2344         function findVariantLink( &$link, &$nt, $ignoreOtherCond = false ) {
2345                 $this->mConverter->findVariantLink( $link, $nt, $ignoreOtherCond );
2346         }
2347
2348         /**
2349          * If a language supports multiple variants, converts text
2350          * into an array of all possible variants of the text:
2351          *  'variant' => text in that variant
2352          */
2353         function convertLinkToAllVariants($text){
2354                 return $this->mConverter->convertLinkToAllVariants($text);
2355         }
2356
2357
2358         /**
2359          * returns language specific options used by User::getPageRenderHash()
2360          * for example, the preferred language variant
2361          *
2362          * @return string
2363          */
2364         function getExtraHashOptions() {
2365                 return $this->mConverter->getExtraHashOptions();
2366         }
2367
2368         /**
2369          * for languages that support multiple variants, the title of an
2370          * article may be displayed differently in different variants. this
2371          * function returns the apporiate title defined in the body of the article.
2372          *
2373          * @return string
2374          */
2375         function getParsedTitle() {
2376                 return $this->mConverter->getParsedTitle();
2377         }
2378
2379         /**
2380          * Enclose a string with the "no conversion" tag. This is used by
2381          * various functions in the Parser
2382          *
2383          * @param $text String: text to be tagged for no conversion
2384          * @param $noParse
2385          * @return string the tagged text
2386          */
2387         function markNoConversion( $text, $noParse=false ) {
2388                 return $this->mConverter->markNoConversion( $text, $noParse );
2389         }
2390
2391         /**
2392          * A regular expression to match legal word-trailing characters
2393          * which should be merged onto a link of the form [[foo]]bar.
2394          *
2395          * @return string
2396          */
2397         function linkTrail() {
2398                 return self::$dataCache->getItem( $this->mCode, 'linkTrail' );
2399         }
2400
2401         function getLangObj() {
2402                 return $this;
2403         }
2404
2405         /**
2406          * Get the RFC 3066 code for this language object
2407          */
2408         function getCode() {
2409                 return $this->mCode;
2410         }
2411
2412         function setCode( $code ) {
2413                 $this->mCode = $code;
2414         }
2415
2416         static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
2417                 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
2418         }
2419
2420         static function getMessagesFileName( $code ) {
2421                 global $IP;
2422                 return self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
2423         }
2424
2425         static function getClassFileName( $code ) {
2426                 global $IP;
2427                 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
2428         }
2429
2430         /**
2431          * Get the fallback for a given language
2432          */
2433         static function getFallbackFor( $code ) {
2434                 if ( $code === 'en' ) {
2435                         // Shortcut
2436                         return false;
2437                 } else {
2438                         return self::getLocalisationCache()->getItem( $code, 'fallback' );
2439                 }
2440         }
2441
2442         /**
2443          * Get all messages for a given language
2444          * WARNING: this may take a long time
2445          */
2446         static function getMessagesFor( $code ) {
2447                 return self::getLocalisationCache()->getItem( $code, 'messages' );
2448         }
2449
2450         /**
2451          * Get a message for a given language
2452          */
2453         static function getMessageFor( $key, $code ) {
2454                 return self::getLocalisationCache()->getSubitem( $code, 'messages', $key );
2455         }
2456
2457         function fixVariableInNamespace( $talk ) {
2458                 if ( strpos( $talk, '$1' ) === false ) return $talk;
2459
2460                 global $wgMetaNamespace;
2461                 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
2462
2463                 # Allow grammar transformations
2464                 # Allowing full message-style parsing would make simple requests
2465                 # such as action=raw much more expensive than they need to be.
2466                 # This will hopefully cover most cases.
2467                 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
2468                         array( &$this, 'replaceGrammarInNamespace' ), $talk );
2469                 return str_replace( ' ', '_', $talk );
2470         }
2471
2472         function replaceGrammarInNamespace( $m ) {
2473                 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
2474         }
2475
2476         static function getCaseMaps() {
2477                 static $wikiUpperChars, $wikiLowerChars;
2478                 if ( isset( $wikiUpperChars ) ) {
2479                         return array( $wikiUpperChars, $wikiLowerChars );
2480                 }
2481
2482                 wfProfileIn( __METHOD__ );
2483                 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
2484                 if ( $arr === false ) {
2485                         throw new MWException(
2486                                 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
2487                 }
2488                 extract( $arr );
2489                 wfProfileOut( __METHOD__ );
2490                 return array( $wikiUpperChars, $wikiLowerChars );
2491         }
2492
2493         function formatTimePeriod( $seconds ) {
2494                 if ( $seconds < 10 ) {
2495                         return $this->formatNum( sprintf( "%.1f", $seconds ) ) . wfMsg( 'seconds-abbrev' );
2496                 } elseif ( $seconds < 60 ) {
2497                         return $this->formatNum( round( $seconds ) ) . wfMsg( 'seconds-abbrev' );
2498                 } elseif ( $seconds < 3600 ) {
2499                         return $this->formatNum( floor( $seconds / 60 ) ) . wfMsg( 'minutes-abbrev' ) .
2500                                 $this->formatNum( round( fmod( $seconds, 60 ) ) ) . wfMsg( 'seconds-abbrev' );
2501                 } else {
2502                         $hours = floor( $seconds / 3600 );
2503                         $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
2504                         $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
2505                         return $this->formatNum( $hours ) . wfMsg( 'hours-abbrev' ) .
2506                                 $this->formatNum( $minutes ) . wfMsg( 'minutes-abbrev' ) .
2507                                 $this->formatNum( $secondsPart ) . wfMsg( 'seconds-abbrev' );
2508                 }
2509         }
2510
2511         function formatBitrate( $bps ) {
2512                 $units = array( 'bps', 'kbps', 'Mbps', 'Gbps' );
2513                 if ( $bps <= 0 ) {
2514                         return $this->formatNum( $bps ) . $units[0];
2515                 }
2516                 $unitIndex = floor( log10( $bps ) / 3 );
2517                 $mantissa = $bps / pow( 1000, $unitIndex );
2518                 if ( $mantissa < 10 ) {
2519                         $mantissa = round( $mantissa, 1 );
2520                 } else {
2521                         $mantissa = round( $mantissa );
2522                 }
2523                 return $this->formatNum( $mantissa ) . $units[$unitIndex];
2524         }
2525
2526         /**
2527          * Format a size in bytes for output, using an appropriate
2528          * unit (B, KB, MB or GB) according to the magnitude in question
2529          *
2530          * @param $size Size to format
2531          * @return string Plain text (not HTML)
2532          */
2533         function formatSize( $size ) {
2534                 // For small sizes no decimal places necessary
2535                 $round = 0;
2536                 if( $size > 1024 ) {
2537                         $size = $size / 1024;
2538                         if( $size > 1024 ) {
2539                                 $size = $size / 1024;
2540                                 // For MB and bigger two decimal places are smarter
2541                                 $round = 2;
2542                                 if( $size > 1024 ) {
2543                                         $size = $size / 1024;
2544                                         $msg = 'size-gigabytes';
2545                                 } else {
2546                                         $msg = 'size-megabytes';
2547                                 }
2548                         } else {
2549                                 $msg = 'size-kilobytes';
2550                         }
2551                 } else {
2552                         $msg = 'size-bytes';
2553                 }
2554                 $size = round( $size, $round );
2555                 $text = $this->getMessageFromDB( $msg );
2556                 return str_replace( '$1', $this->formatNum( $size ), $text );
2557         }
2558 }