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           * LanguageIs.php for the , => . and . => , implementation.
1817           *
1818           * @todo check if it's viable to use localeconv() for the decimal
1819           *       separator thing.
1820           * @param $number Mixed: the string to be formatted, should be an integer
1821           *        or a floating point number.
1822           * @param $nocommafy Bool: set to true for special numbers like dates
1823           * @return string
1824           */
1825         function formatNum( $number, $nocommafy = false ) {
1826                 global $wgTranslateNumerals;
1827                 if (!$nocommafy) {
1828                         $number = $this->commafy($number);
1829                         $s = $this->separatorTransformTable();
1830                         if (!is_null($s)) { $number = strtr($number, $s); }
1831                 }
1832
1833                 if ($wgTranslateNumerals) {
1834                         $s = $this->digitTransformTable();
1835                         if (!is_null($s)) { $number = strtr($number, $s); }
1836                 }
1837
1838                 return $number;
1839         }
1840
1841         function parseFormattedNumber( $number ) {
1842                 $s = $this->digitTransformTable();
1843                 if (!is_null($s)) { $number = strtr($number, array_flip($s)); }
1844
1845                 $s = $this->separatorTransformTable();
1846                 if (!is_null($s)) { $number = strtr($number, array_flip($s)); }
1847
1848                 $number = strtr( $number, array (',' => '') );
1849                 return $number;
1850         }
1851
1852         /**
1853          * Adds commas to a given number
1854          *
1855          * @param $_ mixed
1856          * @return string
1857          */
1858         function commafy($_) {
1859                 return strrev((string)preg_replace('/(\d{3})(?=\d)(?!\d*\.)/','$1,',strrev($_)));
1860         }
1861
1862         function digitTransformTable() {
1863                 $this->load();
1864                 return $this->digitTransformTable;
1865         }
1866
1867         function separatorTransformTable() {
1868                 $this->load();
1869                 return $this->separatorTransformTable;
1870         }
1871
1872
1873         /**
1874          * For the credit list in includes/Credits.php (action=credits)
1875          *
1876          * @param $l Array
1877          * @return string
1878          */
1879         function listToText( $l ) {
1880                 $s = '';
1881                 $m = count($l) - 1;
1882                 for ($i = $m; $i >= 0; $i--) {
1883                         if ($i == $m) {
1884                                 $s = $l[$i];
1885                         } else if ($i == $m - 1) {
1886                                 $s = $l[$i] . ' ' . $this->getMessageFromDB( 'and' ) . ' ' . $s;
1887                         } else {
1888                                 $s = $l[$i] . ', ' . $s;
1889                         }
1890                 }
1891                 return $s;
1892         }
1893
1894         /**
1895          * Take a list of strings and build a locale-friendly comma-separated
1896          * list, using the local comma-separator message.
1897          * @param $list array of strings to put in a comma list
1898          * @return string
1899          */
1900         function commaList( $list, $forContent = false ) {
1901                 return implode(
1902                         $list,
1903                         wfMsgExt( 'comma-separator', array( 'escapenoentities', 'language' => $this ) ) );
1904         }
1905
1906         /**
1907          * Same as commaList, but separate it with the pipe instead.
1908          * @param $list array of strings to put in a pipe list
1909          * @return string
1910          */
1911         function pipeList( $list ) {
1912                 return implode(
1913                         $list,
1914                         wfMsgExt( 'pipe-separator', array( 'escapenoentities', 'language' => $this ) ) );
1915         }
1916
1917         /**
1918          * Truncate a string to a specified length in bytes, appending an optional
1919          * string (e.g. for ellipses)
1920          *
1921          * The database offers limited byte lengths for some columns in the database;
1922          * multi-byte character sets mean we need to ensure that only whole characters
1923          * are included, otherwise broken characters can be passed to the user
1924          *
1925          * If $length is negative, the string will be truncated from the beginning
1926          *
1927          * @param $string String to truncate
1928          * @param $length Int: maximum length (excluding ellipses)
1929          * @param $ellipsis String to append to the truncated text
1930          * @return string
1931          */
1932         function truncate( $string, $length, $ellipsis = "" ) {
1933                 if( $length == 0 ) {
1934                         return $ellipsis;
1935                 }
1936                 if ( strlen( $string ) <= abs( $length ) ) {
1937                         return $string;
1938                 }
1939                 if( $length > 0 ) {
1940                         $string = substr( $string, 0, $length );
1941                         $char = ord( $string[strlen( $string ) - 1] );
1942                         $m = array();
1943                         if ($char >= 0xc0) {
1944                                 # We got the first byte only of a multibyte char; remove it.
1945                                 $string = substr( $string, 0, -1 );
1946                         } elseif( $char >= 0x80 &&
1947                                   preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
1948                                               '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
1949                             # We chopped in the middle of a character; remove it
1950                                 $string = $m[1];
1951                         }
1952                         return $string . $ellipsis;
1953                 } else {
1954                         $string = substr( $string, $length );
1955                         $char = ord( $string[0] );
1956                         if( $char >= 0x80 && $char < 0xc0 ) {
1957                                 # We chopped in the middle of a character; remove the whole thing
1958                                 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
1959                         }
1960                         return $ellipsis . $string;
1961                 }
1962         }
1963
1964         /**
1965          * Grammatical transformations, needed for inflected languages
1966          * Invoked by putting {{grammar:case|word}} in a message
1967          *
1968          * @param $word string
1969          * @param $case string
1970          * @return string
1971          */
1972         function convertGrammar( $word, $case ) {
1973                 global $wgGrammarForms;
1974                 if ( isset($wgGrammarForms[$this->getCode()][$case][$word]) ) {
1975                         return $wgGrammarForms[$this->getCode()][$case][$word];
1976                 }
1977                 return $word;
1978         }
1979
1980         /**
1981          * Plural form transformations, needed for some languages.
1982          * For example, there are 3 form of plural in Russian and Polish,
1983          * depending on "count mod 10". See [[w:Plural]]
1984          * For English it is pretty simple.
1985          *
1986          * Invoked by putting {{plural:count|wordform1|wordform2}}
1987          * or {{plural:count|wordform1|wordform2|wordform3}}
1988          *
1989          * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
1990          *
1991          * @param $count Integer: non-localized number
1992          * @param $forms Array: different plural forms
1993          * @return string Correct form of plural for $count in this language
1994          */
1995         function convertPlural( $count, $forms ) {
1996                 if ( !count($forms) ) { return ''; }
1997                 $forms = $this->preConvertPlural( $forms, 2 );
1998
1999                 return ( $count == 1 ) ? $forms[0] : $forms[1];
2000         }
2001
2002         /**
2003          * Checks that convertPlural was given an array and pads it to requested
2004          * amound of forms by copying the last one.
2005          *
2006          * @param $count Integer: How many forms should there be at least
2007          * @param $forms Array of forms given to convertPlural
2008          * @return array Padded array of forms or an exception if not an array
2009          */
2010         protected function preConvertPlural( /* Array */ $forms, $count ) {
2011                 while ( count($forms) < $count ) {
2012                         $forms[] = $forms[count($forms)-1];
2013                 }
2014                 return $forms;
2015         }
2016
2017         /**
2018          * For translaing of expiry times
2019          * @param $str String: the validated block time in English
2020          * @return Somehow translated block time
2021          * @see LanguageFi.php for example implementation
2022          */
2023         function translateBlockExpiry( $str ) {
2024
2025                 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
2026
2027                 if ( $scBlockExpiryOptions == '-') {
2028                         return $str;
2029                 }
2030
2031                 foreach (explode(',', $scBlockExpiryOptions) as $option) {
2032                         if ( strpos($option, ":") === false )
2033                                 continue;
2034                         list($show, $value) = explode(":", $option);
2035                         if ( strcmp ( $str, $value) == 0 ) {
2036                                 return htmlspecialchars( trim( $show ) );
2037                         }
2038                 }
2039
2040                 return $str;
2041         }
2042
2043         /**
2044          * languages like Chinese need to be segmented in order for the diff
2045          * to be of any use
2046          *
2047          * @param $text String
2048          * @return String
2049          */
2050         function segmentForDiff( $text ) {
2051                 return $text;
2052         }
2053
2054         /**
2055          * and unsegment to show the result
2056          *
2057          * @param $text String
2058          * @return String
2059          */
2060         function unsegmentForDiff( $text ) {
2061                 return $text;
2062         }
2063
2064         # convert text to different variants of a language.
2065         function convert( $text, $isTitle = false) {
2066                 return $this->mConverter->convert($text, $isTitle);
2067         }
2068
2069         # Convert text from within Parser
2070         function parserConvert( $text, &$parser ) {
2071                 return $this->mConverter->parserConvert( $text, $parser );
2072         }
2073
2074         # Check if this is a language with variants
2075         function hasVariants(){
2076                 return sizeof($this->getVariants())>1;
2077         }
2078
2079         # Put custom tags (e.g. -{ }-) around math to prevent conversion
2080         function armourMath($text){
2081                 return $this->mConverter->armourMath($text);
2082         }
2083
2084
2085         /**
2086          * Perform output conversion on a string, and encode for safe HTML output.
2087          * @param $text String
2088          * @param $isTitle Bool -- wtf?
2089          * @return string
2090          * @todo this should get integrated somewhere sane
2091          */
2092         function convertHtml( $text, $isTitle = false ) {
2093                 return htmlspecialchars( $this->convert( $text, $isTitle ) );
2094         }
2095
2096         function convertCategoryKey( $key ) {
2097                 return $this->mConverter->convertCategoryKey( $key );
2098         }
2099
2100         /**
2101          * get the list of variants supported by this langauge
2102          * see sample implementation in LanguageZh.php
2103          *
2104          * @return array an array of language codes
2105          */
2106         function getVariants() {
2107                 return $this->mConverter->getVariants();
2108         }
2109
2110
2111         function getPreferredVariant( $fromUser = true ) {
2112                 return $this->mConverter->getPreferredVariant( $fromUser );
2113         }
2114
2115         /**
2116          * if a language supports multiple variants, it is
2117          * possible that non-existing link in one variant
2118          * actually exists in another variant. this function
2119          * tries to find it. See e.g. LanguageZh.php
2120          *
2121          * @param $link String: the name of the link
2122          * @param $nt Mixed: the title object of the link
2123          * @return null the input parameters may be modified upon return
2124          */
2125         function findVariantLink( &$link, &$nt, $forTemplate = false ) {
2126                 $this->mConverter->findVariantLink($link, $nt, $forTemplate );
2127         }
2128
2129         /**
2130          * If a language supports multiple variants, converts text
2131          * into an array of all possible variants of the text:
2132          *  'variant' => text in that variant
2133          */
2134
2135         function convertLinkToAllVariants($text){
2136                 return $this->mConverter->convertLinkToAllVariants($text);
2137         }
2138
2139
2140         /**
2141          * returns language specific options used by User::getPageRenderHash()
2142          * for example, the preferred language variant
2143          *
2144          * @return string
2145          */
2146         function getExtraHashOptions() {
2147                 return $this->mConverter->getExtraHashOptions();
2148         }
2149
2150         /**
2151          * for languages that support multiple variants, the title of an
2152          * article may be displayed differently in different variants. this
2153          * function returns the apporiate title defined in the body of the article.
2154          *
2155          * @return string
2156          */
2157         function getParsedTitle() {
2158                 return $this->mConverter->getParsedTitle();
2159         }
2160
2161         /**
2162          * Enclose a string with the "no conversion" tag. This is used by
2163          * various functions in the Parser
2164          *
2165          * @param $text String: text to be tagged for no conversion
2166          * @param $noParse
2167          * @return string the tagged text
2168          */
2169         function markNoConversion( $text, $noParse=false ) {
2170                 return $this->mConverter->markNoConversion( $text, $noParse );
2171         }
2172
2173         /**
2174          * A regular expression to match legal word-trailing characters
2175          * which should be merged onto a link of the form [[foo]]bar.
2176          *
2177          * @return string
2178          */
2179         function linkTrail() {
2180                 $this->load();
2181                 return $this->linkTrail;
2182         }
2183
2184         function getLangObj() {
2185                 return $this;
2186         }
2187
2188         /**
2189          * Get the RFC 3066 code for this language object
2190          */
2191         function getCode() {
2192                 return $this->mCode;
2193         }
2194
2195         function setCode( $code ) {
2196                 $this->mCode = $code;
2197         }
2198
2199         static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
2200                 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
2201         }
2202
2203         static function getMessagesFileName( $code ) {
2204                 global $IP;
2205                 return self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
2206         }
2207
2208         static function getClassFileName( $code ) {
2209                 global $IP;
2210                 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
2211         }
2212
2213         static function getLocalisationArray( $code, $disableCache = false ) {
2214                 self::loadLocalisation( $code, $disableCache );
2215                 return self::$mLocalisationCache[$code];
2216         }
2217
2218         /**
2219          * Load localisation data for a given code into the static cache
2220          *
2221          * @return array Dependencies, map of filenames to mtimes
2222          */
2223         static function loadLocalisation( $code, $disableCache = false ) {
2224                 static $recursionGuard = array();
2225                 global $wgMemc, $wgCheckSerialized;
2226
2227                 if ( !$code ) {
2228                         throw new MWException( "Invalid language code requested" );
2229                 }
2230
2231                 if ( !$disableCache ) {
2232                         # Try the per-process cache
2233                         if ( isset( self::$mLocalisationCache[$code] ) ) {
2234                                 return self::$mLocalisationCache[$code]['deps'];
2235                         }
2236
2237                         wfProfileIn( __METHOD__ );
2238
2239                         # Try the serialized directory
2240                         $cache = wfGetPrecompiledData( self::getFileName( "Messages", $code, '.ser' ) );
2241                         if ( $cache ) {
2242                                 if ( $wgCheckSerialized && self::isLocalisationOutOfDate( $cache ) ) {
2243                                         $cache = false;
2244                                         wfDebug( "Language::loadLocalisation(): precompiled data file for $code is out of date\n" );
2245                                 } else {
2246                                         self::$mLocalisationCache[$code] = $cache;
2247                                         wfDebug( "Language::loadLocalisation(): got localisation for $code from precompiled data file\n" );
2248                                         wfProfileOut( __METHOD__ );
2249                                         return self::$mLocalisationCache[$code]['deps'];
2250                                 }
2251                         }
2252
2253                         # Try the global cache
2254                         $memcKey = wfMemcKey('localisation', $code );
2255                         $fbMemcKey = wfMemcKey('fallback', $cache['fallback'] );
2256                         $cache = $wgMemc->get( $memcKey );
2257                         if ( $cache ) {
2258                                 if ( self::isLocalisationOutOfDate( $cache ) ) {
2259                                         $wgMemc->delete( $memcKey );
2260                                         $wgMemc->delete( $fbMemcKey );
2261                                         $cache = false;
2262                                         wfDebug( "Language::loadLocalisation(): localisation cache for $code had expired\n" );
2263                                 } else {
2264                                         self::$mLocalisationCache[$code] = $cache;
2265                                         wfDebug( "Language::loadLocalisation(): got localisation for $code from cache\n" );
2266                                         wfProfileOut( __METHOD__ );
2267                                         return $cache['deps'];
2268                                 }
2269                         }
2270                 } else {
2271                         wfProfileIn( __METHOD__ );
2272                 }
2273
2274                 # Default fallback, may be overridden when the messages file is included
2275                 if ( $code != 'en' ) {
2276                         $fallback = 'en';
2277                 } else {
2278                         $fallback = false;
2279                 }
2280
2281                 # Load the primary localisation from the source file
2282                 $filename = self::getMessagesFileName( $code );
2283                 if ( !file_exists( $filename ) ) {
2284                         wfDebug( "Language::loadLocalisation(): no localisation file for $code, using implicit fallback to en\n" );
2285                         $cache = compact( self::$mLocalisationKeys ); // Set correct fallback
2286                         $deps = array();
2287                 } else {
2288                         $deps = array( $filename => filemtime( $filename ) );
2289                         require( $filename );
2290                         $cache = compact( self::$mLocalisationKeys );
2291                         wfDebug( "Language::loadLocalisation(): got localisation for $code from source\n" );
2292                 }
2293
2294                 if ( !empty( $fallback ) ) {
2295                         # Load the fallback localisation, with a circular reference guard
2296                         if ( isset( $recursionGuard[$code] ) ) {
2297                                 throw new MWException( "Error: Circular fallback reference in language code $code" );
2298                         }
2299                         $recursionGuard[$code] = true;
2300                         $newDeps = self::loadLocalisation( $fallback, $disableCache );
2301                         unset( $recursionGuard[$code] );
2302
2303                         $secondary = self::$mLocalisationCache[$fallback];
2304                         $deps = array_merge( $deps, $newDeps );
2305
2306                         # Merge the fallback localisation with the current localisation
2307                         foreach ( self::$mLocalisationKeys as $key ) {
2308                                 if ( isset( $cache[$key] ) ) {
2309                                         if ( isset( $secondary[$key] ) ) {
2310                                                 if ( in_array( $key, self::$mMergeableMapKeys ) ) {
2311                                                         $cache[$key] = $cache[$key] + $secondary[$key];
2312                                                 } elseif ( in_array( $key, self::$mMergeableListKeys ) ) {
2313                                                         $cache[$key] = array_merge( $secondary[$key], $cache[$key] );
2314                                                 } elseif ( in_array( $key, self::$mMergeableAliasListKeys ) ) {
2315                                                         $cache[$key] = array_merge_recursive( $cache[$key], $secondary[$key] );
2316                                                 }
2317                                         }
2318                                 } else {
2319                                         $cache[$key] = $secondary[$key];
2320                                 }
2321                         }
2322
2323                         # Merge bookstore lists if requested
2324                         if ( !empty( $cache['bookstoreList']['inherit'] ) ) {
2325                                 $cache['bookstoreList'] = array_merge( $cache['bookstoreList'], $secondary['bookstoreList'] );
2326                         }
2327                         if ( isset( $cache['bookstoreList']['inherit'] ) ) {
2328                                 unset( $cache['bookstoreList']['inherit'] );
2329                         }
2330                 }
2331
2332                 # Add dependencies to the cache entry
2333                 $cache['deps'] = $deps;
2334
2335                 # Replace spaces with underscores in namespace names
2336                 $cache['namespaceNames'] = str_replace( ' ', '_', $cache['namespaceNames'] );
2337
2338                 # And do the same for specialpage aliases. $page is an array.
2339                 foreach ( $cache['specialPageAliases'] as &$page ) {
2340                         $page = str_replace( ' ', '_', $page );
2341                 }
2342                 # Decouple the reference to prevent accidental damage
2343                 unset($page);
2344
2345                 # Save to both caches
2346                 self::$mLocalisationCache[$code] = $cache;
2347                 if ( !$disableCache ) {
2348                         $wgMemc->set( $memcKey, $cache );
2349                         $wgMemc->set( $fbMemcKey, (string) $cache['fallback'] );
2350                 }
2351
2352                 wfProfileOut( __METHOD__ );
2353                 return $deps;
2354         }
2355
2356         /**
2357          * Test if a given localisation cache is out of date with respect to the
2358          * source Messages files. This is done automatically for the global cache
2359          * in $wgMemc, but is only done on certain occasions for the serialized
2360          * data file.
2361          *
2362          * @param $cache mixed Either a language code or a cache array
2363          */
2364         static function isLocalisationOutOfDate( $cache ) {
2365                 if ( !is_array( $cache ) ) {
2366                         self::loadLocalisation( $cache );
2367                         $cache = self::$mLocalisationCache[$cache];
2368                 }
2369                 $expired = false;
2370                 foreach ( $cache['deps'] as $file => $mtime ) {
2371                         if ( !file_exists( $file ) || filemtime( $file ) > $mtime ) {
2372                                 $expired = true;
2373                                 break;
2374                         }
2375                 }
2376                 return $expired;
2377         }
2378
2379         /**
2380          * Get the fallback for a given language
2381          */
2382         static function getFallbackFor( $code ) {
2383                 // Shortcut
2384                 if ( $code === 'en' ) return false;
2385
2386                 // Local cache
2387                 static $cache = array();
2388                 // Quick return
2389                 if ( isset($cache[$code]) ) return $cache[$code];
2390
2391                 // Try memcache
2392                 global $wgMemc;
2393                 $memcKey = wfMemcKey( 'fallback', $code );
2394                 $fbcode = $wgMemc->get( $memcKey );
2395
2396                 if ( is_string($fbcode) ) {
2397                         // False is stored as a string to detect failures in memcache properly
2398                         if ( $fbcode === '' ) $fbcode = false;
2399
2400                         // Update local cache and return
2401                         $cache[$code] = $fbcode;
2402                         return $fbcode;
2403                 }
2404
2405                 // Nothing in caches, load and and update both caches
2406                 self::loadLocalisation( $code );
2407                 $fbcode = self::$mLocalisationCache[$code]['fallback'];
2408
2409                 $cache[$code] = $fbcode;
2410                 $wgMemc->set( $memcKey, (string) $fbcode );
2411
2412                 return $fbcode;
2413         }
2414
2415         /**
2416          * Get all messages for a given language
2417          */
2418         static function getMessagesFor( $code ) {
2419                 self::loadLocalisation( $code );
2420                 return self::$mLocalisationCache[$code]['messages'];
2421         }
2422
2423         /**
2424          * Get a message for a given language
2425          */
2426         static function getMessageFor( $key, $code ) {
2427                 self::loadLocalisation( $code );
2428                 return isset( self::$mLocalisationCache[$code]['messages'][$key] ) ? self::$mLocalisationCache[$code]['messages'][$key] : null;
2429         }
2430
2431         /**
2432          * Load localisation data for this object
2433          */
2434         function load() {
2435                 if ( !$this->mLoaded ) {
2436                         self::loadLocalisation( $this->getCode() );
2437                         $cache =& self::$mLocalisationCache[$this->getCode()];
2438                         foreach ( self::$mLocalisationKeys as $key ) {
2439                                 $this->$key = $cache[$key];
2440                         }
2441                         $this->mLoaded = true;
2442
2443                         $this->fixUpSettings();
2444                 }
2445         }
2446
2447         /**
2448          * Do any necessary post-cache-load settings adjustment
2449          */
2450         function fixUpSettings() {
2451                 global $wgExtraNamespaces, $wgMetaNamespace, $wgMetaNamespaceTalk,
2452                         $wgNamespaceAliases, $wgAmericanDates;
2453                 wfProfileIn( __METHOD__ );
2454                 if ( $wgExtraNamespaces ) {
2455                         $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames;
2456                 }
2457
2458                 $this->namespaceNames[NS_PROJECT] = $wgMetaNamespace;
2459                 if ( $wgMetaNamespaceTalk ) {
2460                         $this->namespaceNames[NS_PROJECT_TALK] = $wgMetaNamespaceTalk;
2461                 } else {
2462                         $talk = $this->namespaceNames[NS_PROJECT_TALK];
2463                         $talk = str_replace( '$1', $wgMetaNamespace, $talk );
2464
2465                         # Allow grammar transformations
2466                         # Allowing full message-style parsing would make simple requests
2467                         # such as action=raw much more expensive than they need to be.
2468                         # This will hopefully cover most cases.
2469                         $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
2470                                 array( &$this, 'replaceGrammarInNamespace' ), $talk );
2471                         $talk = str_replace( ' ', '_', $talk );
2472                         $this->namespaceNames[NS_PROJECT_TALK] = $talk;
2473                 }
2474
2475                 # The above mixing may leave namespaces out of canonical order.
2476                 # Re-order by namespace ID number...
2477                 ksort( $this->namespaceNames );
2478
2479                 # Put namespace names and aliases into a hashtable.
2480                 # If this is too slow, then we should arrange it so that it is done
2481                 # before caching. The catch is that at pre-cache time, the above
2482                 # class-specific fixup hasn't been done.
2483                 $this->mNamespaceIds = array();
2484                 foreach ( $this->namespaceNames as $index => $name ) {
2485                         $this->mNamespaceIds[$this->lc($name)] = $index;
2486                 }
2487                 if ( $this->namespaceAliases ) {
2488                         foreach ( $this->namespaceAliases as $name => $index ) {
2489                                 $this->mNamespaceIds[$this->lc($name)] = $index;
2490                         }
2491                 }
2492                 if ( $wgNamespaceAliases ) {
2493                         foreach ( $wgNamespaceAliases as $name => $index ) {
2494                                 $this->mNamespaceIds[$this->lc($name)] = $index;
2495                         }
2496                 }
2497
2498                 if ( $this->defaultDateFormat == 'dmy or mdy' ) {
2499                         $this->defaultDateFormat = $wgAmericanDates ? 'mdy' : 'dmy';
2500                 }
2501                 wfProfileOut( __METHOD__ );
2502         }
2503
2504         function replaceGrammarInNamespace( $m ) {
2505                 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
2506         }
2507
2508         static function getCaseMaps() {
2509                 static $wikiUpperChars, $wikiLowerChars;
2510                 if ( isset( $wikiUpperChars ) ) {
2511                         return array( $wikiUpperChars, $wikiLowerChars );
2512                 }
2513
2514                 wfProfileIn( __METHOD__ );
2515                 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
2516                 if ( $arr === false ) {
2517                         throw new MWException(
2518                                 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
2519                 }
2520                 extract( $arr );
2521                 wfProfileOut( __METHOD__ );
2522                 return array( $wikiUpperChars, $wikiLowerChars );
2523         }
2524
2525         function formatTimePeriod( $seconds ) {
2526                 if ( $seconds < 10 ) {
2527                         return $this->formatNum( sprintf( "%.1f", $seconds ) ) . wfMsg( 'seconds-abbrev' );
2528                 } elseif ( $seconds < 60 ) {
2529                         return $this->formatNum( round( $seconds ) ) . wfMsg( 'seconds-abbrev' );
2530                 } elseif ( $seconds < 3600 ) {
2531                         return $this->formatNum( floor( $seconds / 60 ) ) . wfMsg( 'minutes-abbrev' ) .
2532                                 $this->formatNum( round( fmod( $seconds, 60 ) ) ) . wfMsg( 'seconds-abbrev' );
2533                 } else {
2534                         $hours = floor( $seconds / 3600 );
2535                         $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
2536                         $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
2537                         return $this->formatNum( $hours ) . wfMsg( 'hours-abbrev' ) .
2538                                 $this->formatNum( $minutes ) . wfMsg( 'minutes-abbrev' ) .
2539                                 $this->formatNum( $secondsPart ) . wfMsg( 'seconds-abbrev' );
2540                 }
2541         }
2542
2543         function formatBitrate( $bps ) {
2544                 $units = array( 'bps', 'kbps', 'Mbps', 'Gbps' );
2545                 if ( $bps <= 0 ) {
2546                         return $this->formatNum( $bps ) . $units[0];
2547                 }
2548                 $unitIndex = floor( log10( $bps ) / 3 );
2549                 $mantissa = $bps / pow( 1000, $unitIndex );
2550                 if ( $mantissa < 10 ) {
2551                         $mantissa = round( $mantissa, 1 );
2552                 } else {
2553                         $mantissa = round( $mantissa );
2554                 }
2555                 return $this->formatNum( $mantissa ) . $units[$unitIndex];
2556         }
2557
2558         /**
2559          * Format a size in bytes for output, using an appropriate
2560          * unit (B, KB, MB or GB) according to the magnitude in question
2561          *
2562          * @param $size Size to format
2563          * @return string Plain text (not HTML)
2564          */
2565         function formatSize( $size ) {
2566                 // For small sizes no decimal places necessary
2567                 $round = 0;
2568                 if( $size > 1024 ) {
2569                         $size = $size / 1024;
2570                         if( $size > 1024 ) {
2571                                 $size = $size / 1024;
2572                                 // For MB and bigger two decimal places are smarter
2573                                 $round = 2;
2574                                 if( $size > 1024 ) {
2575                                         $size = $size / 1024;
2576                                         $msg = 'size-gigabytes';
2577                                 } else {
2578                                         $msg = 'size-megabytes';
2579                                 }
2580                         } else {
2581                                 $msg = 'size-kilobytes';
2582                         }
2583                 } else {
2584                         $msg = 'size-bytes';
2585                 }
2586                 $size = round( $size, $round );
2587                 $text = $this->getMessageFromDB( $msg );
2588                 return str_replace( '$1', $this->formatNum( $size ), $text );
2589         }
2590 }