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