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