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, $ignoreOtherCond = false) {}
  43         function getExtraHashOptions() {return '';}
  44         function getParsedTitle() {return '';}
  45         function markNoConversion($text, $noParse=false) {return $text;}
  46         function convertCategoryKey( $key ) {return $key; }
  47         function convertLinkToAllVariants($text){ return array( $this->mLang->getCode() => $text); }
  48         function armourMath($text){ return $text; }
  49 }
  50
  51 /**
  52  * Internationalisation code
  53  * @ingroup Language
  54  */
  55 class Language {
  56         var $mConverter, $mVariants, $mCode, $mLoaded = false;
  57         var $mMagicExtensions = array(), $mMagicHookDone = false;
  58
  59         static public $mLocalisationKeys = array(
  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          * Take a list of strings and build a locale-friendly semicolon-separated
1995          * list, using the local semicolon-separator message.
1996          * @param $list array of strings to put in a semicolon list
1997          * @return string
1998          */
1999         function semicolonList( $list ) {
2000                 return implode(
2001                         $list,
2002                         wfMsgExt( 'semicolon-separator', array( 'escapenoentities', 'language' => $this ) ) );
2003         }
2004
2005         /**
2006          * Same as commaList, but separate it with the pipe instead.
2007          * @param $list array of strings to put in a pipe list
2008          * @return string
2009          */
2010         function pipeList( $list ) {
2011                 return implode(
2012                         $list,
2013                         wfMsgExt( 'pipe-separator', array( 'escapenoentities', 'language' => $this ) ) );
2014         }
2015
2016         /**
2017          * Truncate a string to a specified length in bytes, appending an optional
2018          * string (e.g. for ellipses)
2019          *
2020          * The database offers limited byte lengths for some columns in the database;
2021          * multi-byte character sets mean we need to ensure that only whole characters
2022          * are included, otherwise broken characters can be passed to the user
2023          *
2024          * If $length is negative, the string will be truncated from the beginning
2025          *
2026          * @param $string String to truncate
2027          * @param $length Int: maximum length (excluding ellipses)
2028          * @param $ellipsis String to append to the truncated text
2029          * @return string
2030          */
2031         function truncate( $string, $length, $ellipsis = '...' ) {
2032                 # Use the localized ellipsis character
2033                 if( $ellipsis == '...' ) {
2034                         $ellipsis = wfMsgExt( 'ellipsis', array( 'escapenoentities', 'language' => $this ) );
2035                 }
2036
2037                 if( $length == 0 ) {
2038                         return $ellipsis;
2039                 }
2040                 if ( strlen( $string ) <= abs( $length ) ) {
2041                         return $string;
2042                 }
2043                 if( $length > 0 ) {
2044                         $string = substr( $string, 0, $length );
2045                         $char = ord( $string[strlen( $string ) - 1] );
2046                         $m = array();
2047                         if ($char >= 0xc0) {
2048                                 # We got the first byte only of a multibyte char; remove it.
2049                                 $string = substr( $string, 0, -1 );
2050                         } elseif( $char >= 0x80 &&
2051                                   preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
2052                                               '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
2053                                 # We chopped in the middle of a character; remove it
2054                                 $string = $m[1];
2055                         }
2056                         return $string . $ellipsis;
2057                 } else {
2058                         $string = substr( $string, $length );
2059                         $char = ord( $string[0] );
2060                         if( $char >= 0x80 && $char < 0xc0 ) {
2061                                 # We chopped in the middle of a character; remove the whole thing
2062                                 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
2063                         }
2064                         return $ellipsis . $string;
2065                 }
2066         }
2067
2068         /**
2069          * Grammatical transformations, needed for inflected languages
2070          * Invoked by putting {{grammar:case|word}} in a message
2071          *
2072          * @param $word string
2073          * @param $case string
2074          * @return string
2075          */
2076         function convertGrammar( $word, $case ) {
2077                 global $wgGrammarForms;
2078                 if ( isset($wgGrammarForms[$this->getCode()][$case][$word]) ) {
2079                         return $wgGrammarForms[$this->getCode()][$case][$word];
2080                 }
2081                 return $word;
2082         }
2083
2084         /**
2085          * Provides an alternative text depending on specified gender.
2086          * Usage {{gender:username|masculine|feminine|neutral}}.
2087          * username is optional, in which case the gender of current user is used,
2088          * but only in (some) interface messages; otherwise default gender is used.
2089          * If second or third parameter are not specified, masculine is used.
2090          * These details may be overriden per language.
2091          */
2092         function gender( $gender, $forms ) {
2093                 if ( !count($forms) ) { return ''; }
2094                 $forms = $this->preConvertPlural( $forms, 2 );
2095                 if ( $gender === 'male' ) return $forms[0];
2096                 if ( $gender === 'female' ) return $forms[1];
2097                 return isset($forms[2]) ? $forms[2] : $forms[0];
2098         }
2099
2100         /**
2101          * Plural form transformations, needed for some languages.
2102          * For example, there are 3 form of plural in Russian and Polish,
2103          * depending on "count mod 10". See [[w:Plural]]
2104          * For English it is pretty simple.
2105          *
2106          * Invoked by putting {{plural:count|wordform1|wordform2}}
2107          * or {{plural:count|wordform1|wordform2|wordform3}}
2108          *
2109          * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2110          *
2111          * @param $count Integer: non-localized number
2112          * @param $forms Array: different plural forms
2113          * @return string Correct form of plural for $count in this language
2114          */
2115         function convertPlural( $count, $forms ) {
2116                 if ( !count($forms) ) { return ''; }
2117                 $forms = $this->preConvertPlural( $forms, 2 );
2118
2119                 return ( $count == 1 ) ? $forms[0] : $forms[1];
2120         }
2121
2122         /**
2123          * Checks that convertPlural was given an array and pads it to requested
2124          * amound of forms by copying the last one.
2125          *
2126          * @param $count Integer: How many forms should there be at least
2127          * @param $forms Array of forms given to convertPlural
2128          * @return array Padded array of forms or an exception if not an array
2129          */
2130         protected function preConvertPlural( /* Array */ $forms, $count ) {
2131                 while ( count($forms) < $count ) {
2132                         $forms[] = $forms[count($forms)-1];
2133                 }
2134                 return $forms;
2135         }
2136
2137         /**
2138          * For translaing of expiry times
2139          * @param $str String: the validated block time in English
2140          * @return Somehow translated block time
2141          * @see LanguageFi.php for example implementation
2142          */
2143         function translateBlockExpiry( $str ) {
2144
2145                 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
2146
2147                 if ( $scBlockExpiryOptions == '-') {
2148                         return $str;
2149                 }
2150
2151                 foreach (explode(',', $scBlockExpiryOptions) as $option) {
2152                         if ( strpos($option, ":") === false )
2153                                 continue;
2154                         list($show, $value) = explode(":", $option);
2155                         if ( strcmp ( $str, $value) == 0 ) {
2156                                 return htmlspecialchars( trim( $show ) );
2157                         }
2158                 }
2159
2160                 return $str;
2161         }
2162
2163         /**
2164          * languages like Chinese need to be segmented in order for the diff
2165          * to be of any use
2166          *
2167          * @param $text String
2168          * @return String
2169          */
2170         function segmentForDiff( $text ) {
2171                 return $text;
2172         }
2173
2174         /**
2175          * and unsegment to show the result
2176          *
2177          * @param $text String
2178          * @return String
2179          */
2180         function unsegmentForDiff( $text ) {
2181                 return $text;
2182         }
2183
2184         # convert text to different variants of a language.
2185         function convert( $text, $isTitle = false) {
2186                 return $this->mConverter->convert($text, $isTitle);
2187         }
2188
2189         # Convert text from within Parser
2190         function parserConvert( $text, &$parser ) {
2191                 return $this->mConverter->parserConvert( $text, $parser );
2192         }
2193
2194         # Check if this is a language with variants
2195         function hasVariants(){
2196                 return sizeof($this->getVariants())>1;
2197         }
2198
2199         # Put custom tags (e.g. -{ }-) around math to prevent conversion
2200         function armourMath($text){
2201                 return $this->mConverter->armourMath($text);
2202         }
2203
2204
2205         /**
2206          * Perform output conversion on a string, and encode for safe HTML output.
2207          * @param $text String
2208          * @param $isTitle Bool -- wtf?
2209          * @return string
2210          * @todo this should get integrated somewhere sane
2211          */
2212         function convertHtml( $text, $isTitle = false ) {
2213                 return htmlspecialchars( $this->convert( $text, $isTitle ) );
2214         }
2215
2216         function convertCategoryKey( $key ) {
2217                 return $this->mConverter->convertCategoryKey( $key );
2218         }
2219
2220         /**
2221          * get the list of variants supported by this langauge
2222          * see sample implementation in LanguageZh.php
2223          *
2224          * @return array an array of language codes
2225          */
2226         function getVariants() {
2227                 return $this->mConverter->getVariants();
2228         }
2229
2230
2231         function getPreferredVariant( $fromUser = true ) {
2232                 return $this->mConverter->getPreferredVariant( $fromUser );
2233         }
2234
2235         /**
2236          * if a language supports multiple variants, it is
2237          * possible that non-existing link in one variant
2238          * actually exists in another variant. this function
2239          * tries to find it. See e.g. LanguageZh.php
2240          *
2241          * @param $link String: the name of the link
2242          * @param $nt Mixed: the title object of the link
2243          * @param boolean $ignoreOtherCond: to disable other conditions when
2244          *      we need to transclude a template or update a category's link
2245          * @return null the input parameters may be modified upon return
2246          */
2247         function findVariantLink( &$link, &$nt, $ignoreOtherCond = false ) {
2248                 $this->mConverter->findVariantLink( $link, $nt, $ignoreOtherCond );
2249         }
2250
2251         /**
2252          * If a language supports multiple variants, converts text
2253          * into an array of all possible variants of the text:
2254          *  'variant' => text in that variant
2255          */
2256         function convertLinkToAllVariants($text){
2257                 return $this->mConverter->convertLinkToAllVariants($text);
2258         }
2259
2260
2261         /**
2262          * returns language specific options used by User::getPageRenderHash()
2263          * for example, the preferred language variant
2264          *
2265          * @return string
2266          */
2267         function getExtraHashOptions() {
2268                 return $this->mConverter->getExtraHashOptions();
2269         }
2270
2271         /**
2272          * for languages that support multiple variants, the title of an
2273          * article may be displayed differently in different variants. this
2274          * function returns the apporiate title defined in the body of the article.
2275          *
2276          * @return string
2277          */
2278         function getParsedTitle() {
2279                 return $this->mConverter->getParsedTitle();
2280         }
2281
2282         /**
2283          * Enclose a string with the "no conversion" tag. This is used by
2284          * various functions in the Parser
2285          *
2286          * @param $text String: text to be tagged for no conversion
2287          * @param $noParse
2288          * @return string the tagged text
2289          */
2290         function markNoConversion( $text, $noParse=false ) {
2291                 return $this->mConverter->markNoConversion( $text, $noParse );
2292         }
2293
2294         /**
2295          * A regular expression to match legal word-trailing characters
2296          * which should be merged onto a link of the form [[foo]]bar.
2297          *
2298          * @return string
2299          */
2300         function linkTrail() {
2301                 $this->load();
2302                 return $this->linkTrail;
2303         }
2304
2305         function getLangObj() {
2306                 return $this;
2307         }
2308
2309         /**
2310          * Get the RFC 3066 code for this language object
2311          */
2312         function getCode() {
2313                 return $this->mCode;
2314         }
2315
2316         function setCode( $code ) {
2317                 $this->mCode = $code;
2318         }
2319
2320         static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
2321                 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
2322         }
2323
2324         static function getMessagesFileName( $code ) {
2325                 global $IP;
2326                 return self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
2327         }
2328
2329         static function getClassFileName( $code ) {
2330                 global $IP;
2331                 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
2332         }
2333
2334         static function getLocalisationArray( $code, $disableCache = false ) {
2335                 self::loadLocalisation( $code, $disableCache );
2336                 return self::$mLocalisationCache[$code];
2337         }
2338
2339         /**
2340          * Load localisation data for a given code into the static cache
2341          *
2342          * @return array Dependencies, map of filenames to mtimes
2343          */
2344         static function loadLocalisation( $code, $disableCache = false ) {
2345                 static $recursionGuard = array();
2346                 global $wgMemc, $wgEnableSerializedMessages, $wgCheckSerialized;
2347
2348                 if ( !$code ) {
2349                         throw new MWException( "Invalid language code requested" );
2350                 }
2351
2352                 if ( !$disableCache ) {
2353                         # Try the per-process cache
2354                         if ( isset( self::$mLocalisationCache[$code] ) ) {
2355                                 return self::$mLocalisationCache[$code]['deps'];
2356                         }
2357
2358                         wfProfileIn( __METHOD__ );
2359
2360                         # Try the serialized directory
2361                         if( $wgEnableSerializedMessages ) {
2362                                 $cache = wfGetPrecompiledData( self::getFileName( "Messages", $code, '.ser' ) );
2363                                 if ( $cache ) {
2364                                         if ( $wgCheckSerialized && self::isLocalisationOutOfDate( $cache ) ) {
2365                                                 $cache = false;
2366                                                 wfDebug( "Language::loadLocalisation(): precompiled data file for $code is out of date\n" );
2367                                         } else {
2368                                                 self::$mLocalisationCache[$code] = $cache;
2369                                                 wfDebug( "Language::loadLocalisation(): got localisation for $code from precompiled data file\n" );
2370                                                 wfProfileOut( __METHOD__ );
2371                                                 return self::$mLocalisationCache[$code]['deps'];
2372                                         }
2373                                 }
2374                         }
2375
2376                         # Try the global cache
2377                         $memcKey = wfMemcKey('localisation', $code );
2378                         $fbMemcKey = wfMemcKey('fallback', $cache['fallback'] );
2379                         $cache = $wgMemc->get( $memcKey );
2380                         if ( $cache ) {
2381                                 if ( self::isLocalisationOutOfDate( $cache ) ) {
2382                                         $wgMemc->delete( $memcKey );
2383                                         $wgMemc->delete( $fbMemcKey );
2384                                         $cache = false;
2385                                         wfDebug( "Language::loadLocalisation(): localisation cache for $code had expired\n" );
2386                                 } else {
2387                                         self::$mLocalisationCache[$code] = $cache;
2388                                         wfDebug( "Language::loadLocalisation(): got localisation for $code from cache\n" );
2389                                         wfProfileOut( __METHOD__ );
2390                                         return $cache['deps'];
2391                                 }
2392                         }
2393                 } else {
2394                         wfProfileIn( __METHOD__ );
2395                 }
2396
2397                 # Default fallback, may be overridden when the messages file is included
2398                 if ( $code != 'en' ) {
2399                         $fallback = 'en';
2400                 } else {
2401                         $fallback = false;
2402                 }
2403
2404                 # Load the primary localisation from the source file
2405                 $filename = self::getMessagesFileName( $code );
2406                 if ( !file_exists( $filename ) ) {
2407                         wfDebug( "Language::loadLocalisation(): no localisation file for $code, using implicit fallback to en\n" );
2408                         $cache = compact( self::$mLocalisationKeys ); // Set correct fallback
2409                         $deps = array();
2410                 } else {
2411                         $deps = array( $filename => filemtime( $filename ) );
2412                         require( $filename );
2413                         $cache = compact( self::$mLocalisationKeys );
2414                         wfDebug( "Language::loadLocalisation(): got localisation for $code from source\n" );
2415                 }
2416
2417                 # Load magic word source file
2418                 global $IP;
2419                 $filename = "$IP/includes/MagicWord.php";
2420                 $newDeps = array( $filename => filemtime( $filename ) );
2421                 $deps = array_merge( $deps, $newDeps );
2422
2423                 if ( !empty( $fallback ) ) {
2424                         # Load the fallback localisation, with a circular reference guard
2425                         if ( isset( $recursionGuard[$code] ) ) {
2426                                 throw new MWException( "Error: Circular fallback reference in language code $code" );
2427                         }
2428                         $recursionGuard[$code] = true;
2429                         $newDeps = self::loadLocalisation( $fallback, $disableCache );
2430                         unset( $recursionGuard[$code] );
2431
2432                         $secondary = self::$mLocalisationCache[$fallback];
2433                         $deps = array_merge( $deps, $newDeps );
2434
2435                         # Merge the fallback localisation with the current localisation
2436                         foreach ( self::$mLocalisationKeys as $key ) {
2437                                 if ( isset( $cache[$key] ) ) {
2438                                         if ( isset( $secondary[$key] ) ) {
2439                                                 if ( in_array( $key, self::$mMergeableMapKeys ) ) {
2440                                                         $cache[$key] = $cache[$key] + $secondary[$key];
2441                                                 } elseif ( in_array( $key, self::$mMergeableListKeys ) ) {
2442                                                         $cache[$key] = array_merge( $secondary[$key], $cache[$key] );
2443                                                 } elseif ( in_array( $key, self::$mMergeableAliasListKeys ) ) {
2444                                                         $cache[$key] = array_merge_recursive( $cache[$key], $secondary[$key] );
2445                                                 }
2446                                         }
2447                                 } else {
2448                                         $cache[$key] = $secondary[$key];
2449                                 }
2450                         }
2451
2452                         # Merge bookstore lists if requested
2453                         if ( !empty( $cache['bookstoreList']['inherit'] ) ) {
2454                                 $cache['bookstoreList'] = array_merge( $cache['bookstoreList'], $secondary['bookstoreList'] );
2455                         }
2456                         if ( isset( $cache['bookstoreList']['inherit'] ) ) {
2457                                 unset( $cache['bookstoreList']['inherit'] );
2458                         }
2459                 }
2460
2461                 # Add dependencies to the cache entry
2462                 $cache['deps'] = $deps;
2463
2464                 # Replace spaces with underscores in namespace names
2465                 $cache['namespaceNames'] = str_replace( ' ', '_', $cache['namespaceNames'] );
2466
2467                 # And do the same for specialpage aliases. $page is an array.
2468                 foreach ( $cache['specialPageAliases'] as &$page ) {
2469                         $page = str_replace( ' ', '_', $page );
2470                 }
2471                 # Decouple the reference to prevent accidental damage
2472                 unset($page);
2473
2474                 # Save to both caches
2475                 self::$mLocalisationCache[$code] = $cache;
2476                 if ( !$disableCache ) {
2477                         $wgMemc->set( $memcKey, $cache );
2478                         $wgMemc->set( $fbMemcKey, (string) $cache['fallback'] );
2479                 }
2480
2481                 wfProfileOut( __METHOD__ );
2482                 return $deps;
2483         }
2484
2485         /**
2486          * Test if a given localisation cache is out of date with respect to the
2487          * source Messages files. This is done automatically for the global cache
2488          * in $wgMemc, but is only done on certain occasions for the serialized
2489          * data file.
2490          *
2491          * @param $cache mixed Either a language code or a cache array
2492          */
2493         static function isLocalisationOutOfDate( $cache ) {
2494                 if ( !is_array( $cache ) ) {
2495                         self::loadLocalisation( $cache );
2496                         $cache = self::$mLocalisationCache[$cache];
2497                 }
2498                 // At least one language file and the MagicWord file needed
2499                 if( count($cache['deps']) < 2 ) {
2500                         return true;
2501                 }
2502                 $expired = false;
2503                 foreach ( $cache['deps'] as $file => $mtime ) {
2504                         if ( !file_exists( $file ) || filemtime( $file ) > $mtime ) {
2505                                 $expired = true;
2506                                 break;
2507                         }
2508                 }
2509                 return $expired;
2510         }
2511
2512         /**
2513          * Get the fallback for a given language
2514          */
2515         static function getFallbackFor( $code ) {
2516                 // Shortcut
2517                 if ( $code === 'en' ) return false;
2518
2519                 // Local cache
2520                 static $cache = array();
2521                 // Quick return
2522                 if ( isset($cache[$code]) ) return $cache[$code];
2523
2524                 // Try memcache
2525                 global $wgMemc;
2526                 $memcKey = wfMemcKey( 'fallback', $code );
2527                 $fbcode = $wgMemc->get( $memcKey );
2528
2529                 if ( is_string($fbcode) ) {
2530                         // False is stored as a string to detect failures in memcache properly
2531                         if ( $fbcode === '' ) $fbcode = false;
2532
2533                         // Update local cache and return
2534                         $cache[$code] = $fbcode;
2535                         return $fbcode;
2536                 }
2537
2538                 // Nothing in caches, load and and update both caches
2539                 self::loadLocalisation( $code );
2540                 $fbcode = self::$mLocalisationCache[$code]['fallback'];
2541
2542                 $cache[$code] = $fbcode;
2543                 $wgMemc->set( $memcKey, (string) $fbcode );
2544
2545                 return $fbcode;
2546         }
2547
2548         /**
2549          * Get all messages for a given language
2550          */
2551         static function getMessagesFor( $code ) {
2552                 self::loadLocalisation( $code );
2553                 return self::$mLocalisationCache[$code]['messages'];
2554         }
2555
2556         /**
2557          * Get a message for a given language
2558          */
2559         static function getMessageFor( $key, $code ) {
2560                 self::loadLocalisation( $code );
2561                 return isset( self::$mLocalisationCache[$code]['messages'][$key] ) ? self::$mLocalisationCache[$code]['messages'][$key] : null;
2562         }
2563
2564         /**
2565          * Load localisation data for this object
2566          */
2567         function load() {
2568                 if ( !$this->mLoaded ) {
2569                         self::loadLocalisation( $this->getCode() );
2570                         $cache =& self::$mLocalisationCache[$this->getCode()];
2571                         foreach ( self::$mLocalisationKeys as $key ) {
2572                                 $this->$key = $cache[$key];
2573                         }
2574                         $this->mLoaded = true;
2575
2576                         $this->fixUpSettings();
2577                 }
2578         }
2579
2580         /**
2581          * Do any necessary post-cache-load settings adjustment
2582          */
2583         function fixUpSettings() {
2584                 global $wgExtraNamespaces, $wgMetaNamespace, $wgMetaNamespaceTalk,
2585                         $wgNamespaceAliases, $wgAmericanDates;
2586                 wfProfileIn( __METHOD__ );
2587                 if ( $wgExtraNamespaces ) {
2588                         $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames;
2589                 }
2590
2591                 $this->namespaceNames[NS_PROJECT] = $wgMetaNamespace;
2592                 if ( $wgMetaNamespaceTalk ) {
2593                         $this->namespaceNames[NS_PROJECT_TALK] = $wgMetaNamespaceTalk;
2594                 } else {
2595                         $talk = $this->namespaceNames[NS_PROJECT_TALK];
2596                         $this->namespaceNames[NS_PROJECT_TALK] =
2597                                 $this->fixVariableInNamespace( $talk );
2598                 }
2599
2600                 # The above mixing may leave namespaces out of canonical order.
2601                 # Re-order by namespace ID number...
2602                 ksort( $this->namespaceNames );
2603
2604                 # Put namespace names and aliases into a hashtable.
2605                 # If this is too slow, then we should arrange it so that it is done
2606                 # before caching. The catch is that at pre-cache time, the above
2607                 # class-specific fixup hasn't been done.
2608                 $this->mNamespaceIds = array();
2609                 foreach ( $this->namespaceNames as $index => $name ) {
2610                         $this->mNamespaceIds[$this->lc($name)] = $index;
2611                 }
2612                 if ( $this->namespaceAliases ) {
2613                         foreach ( $this->namespaceAliases as $name => $index ) {
2614                                 if ( $index === NS_PROJECT_TALK ) {
2615                                         unset( $this->namespaceAliases[$name] );
2616                                         $name = $this->fixVariableInNamespace( $name );
2617                                         $this->namespaceAliases[$name] = $index;
2618                                 }
2619                                 $this->mNamespaceIds[$this->lc($name)] = $index;
2620                         }
2621                 }
2622                 if ( $wgNamespaceAliases ) {
2623                         foreach ( $wgNamespaceAliases as $name => $index ) {
2624                                 $this->mNamespaceIds[$this->lc($name)] = $index;
2625                         }
2626                 }
2627
2628                 if ( $this->defaultDateFormat == 'dmy or mdy' ) {
2629                         $this->defaultDateFormat = $wgAmericanDates ? 'mdy' : 'dmy';
2630                 }
2631                 wfProfileOut( __METHOD__ );
2632         }
2633
2634         function fixVariableInNamespace( $talk ) {
2635                 if ( strpos( $talk, '$1' ) === false ) return $talk;
2636
2637                 global $wgMetaNamespace;
2638                 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
2639
2640                 # Allow grammar transformations
2641                 # Allowing full message-style parsing would make simple requests
2642                 # such as action=raw much more expensive than they need to be.
2643                 # This will hopefully cover most cases.
2644                 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
2645                         array( &$this, 'replaceGrammarInNamespace' ), $talk );
2646                 return str_replace( ' ', '_', $talk );
2647         }
2648
2649         function replaceGrammarInNamespace( $m ) {
2650                 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
2651         }
2652
2653         static function getCaseMaps() {
2654                 static $wikiUpperChars, $wikiLowerChars;
2655                 if ( isset( $wikiUpperChars ) ) {
2656                         return array( $wikiUpperChars, $wikiLowerChars );
2657                 }
2658
2659                 wfProfileIn( __METHOD__ );
2660                 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
2661                 if ( $arr === false ) {
2662                         throw new MWException(
2663                                 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
2664                 }
2665                 extract( $arr );
2666                 wfProfileOut( __METHOD__ );
2667                 return array( $wikiUpperChars, $wikiLowerChars );
2668         }
2669
2670         function formatTimePeriod( $seconds ) {
2671                 if ( $seconds < 10 ) {
2672                         return $this->formatNum( sprintf( "%.1f", $seconds ) ) . wfMsg( 'seconds-abbrev' );
2673                 } elseif ( $seconds < 60 ) {
2674                         return $this->formatNum( round( $seconds ) ) . wfMsg( 'seconds-abbrev' );
2675                 } elseif ( $seconds < 3600 ) {
2676                         return $this->formatNum( floor( $seconds / 60 ) ) . wfMsg( 'minutes-abbrev' ) .
2677                                 $this->formatNum( round( fmod( $seconds, 60 ) ) ) . wfMsg( 'seconds-abbrev' );
2678                 } else {
2679                         $hours = floor( $seconds / 3600 );
2680                         $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
2681                         $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
2682                         return $this->formatNum( $hours ) . wfMsg( 'hours-abbrev' ) .
2683                                 $this->formatNum( $minutes ) . wfMsg( 'minutes-abbrev' ) .
2684                                 $this->formatNum( $secondsPart ) . wfMsg( 'seconds-abbrev' );
2685                 }
2686         }
2687
2688         function formatBitrate( $bps ) {
2689                 $units = array( 'bps', 'kbps', 'Mbps', 'Gbps' );
2690                 if ( $bps <= 0 ) {
2691                         return $this->formatNum( $bps ) . $units[0];
2692                 }
2693                 $unitIndex = floor( log10( $bps ) / 3 );
2694                 $mantissa = $bps / pow( 1000, $unitIndex );
2695                 if ( $mantissa < 10 ) {
2696                         $mantissa = round( $mantissa, 1 );
2697                 } else {
2698                         $mantissa = round( $mantissa );
2699                 }
2700                 return $this->formatNum( $mantissa ) . $units[$unitIndex];
2701         }
2702
2703         /**
2704          * Format a size in bytes for output, using an appropriate
2705          * unit (B, KB, MB or GB) according to the magnitude in question
2706          *
2707          * @param $size Size to format
2708          * @return string Plain text (not HTML)
2709          */
2710         function formatSize( $size ) {
2711                 // For small sizes no decimal places necessary
2712                 $round = 0;
2713                 if( $size > 1024 ) {
2714                         $size = $size / 1024;
2715                         if( $size > 1024 ) {
2716                                 $size = $size / 1024;
2717                                 // For MB and bigger two decimal places are smarter
2718                                 $round = 2;
2719                                 if( $size > 1024 ) {
2720                                         $size = $size / 1024;
2721                                         $msg = 'size-gigabytes';
2722                                 } else {
2723                                         $msg = 'size-megabytes';
2724                                 }
2725                         } else {
2726                                 $msg = 'size-kilobytes';
2727                         }
2728                 } else {
2729                         $msg = 'size-bytes';
2730                 }
2731                 $size = round( $size, $round );
2732                 $text = $this->getMessageFromDB( $msg );
2733                 return str_replace( '$1', $this->formatNum( $size ), $text );
2734         }
2735 }