languages/Language.php

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