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