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