languages/Language.php

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