languages/Language.php

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