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