languages/Language.php

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