languages/Language.php

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