languages/Language.php

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