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