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