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  * @ingrouo 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
 178          * @return array
 179          */
 180         function getDefaultUserOptions() {
 181                 trigger_error( 'Use of ' . __METHOD__ . ' is deprecated', E_USER_NOTICE );
 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 int $index 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 string $text
 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 string $text
 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 string $code
 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          * @public
 443          * @param int   $ts the time in date('YmdHis') format
 444          * @param mixed $tz adjust the time by this amount (default false,
 445          *                  mean we 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 string $format
 540          * @param string $ts 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 string $ts 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 mixed $usePrefs: 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          * @public
1145          * @param mixed  $ts the time format which needs to be turned into a
1146          *               date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1147          * @param bool   $adj whether to adjust the time output according to the
1148          *               user configured offset ($timecorrection)
1149          * @param mixed  $format true to use user's date format preference
1150          * @param string $timecorrection the time offset as returned by
1151          *               validateTimeZone() in Special:Preferences
1152          * @return string
1153          */
1154         function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
1155                 $this->load();
1156                 if ( $adj ) {
1157                         $ts = $this->userAdjust( $ts, $timecorrection );
1158                 }
1159
1160                 $pref = $this->dateFormat( $format );
1161                 if( $pref == 'default' || !isset( $this->dateFormats["$pref date"] ) ) {
1162                         $pref = $this->defaultDateFormat;
1163                 }
1164                 return $this->sprintfDate( $this->dateFormats["$pref date"], $ts );
1165         }
1166
1167         /**
1168         * @public
1169         * @param mixed  $ts the time format which needs to be turned into a
1170         *               date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1171         * @param bool   $adj whether to adjust the time output according to the
1172         *               user configured offset ($timecorrection)
1173         * @param mixed  $format true to use user's date format preference
1174         * @param string $timecorrection the time offset as returned by
1175         *               validateTimeZone() in Special:Preferences
1176         * @return string
1177         */
1178         function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
1179                 $this->load();
1180                 if ( $adj ) {
1181                         $ts = $this->userAdjust( $ts, $timecorrection );
1182                 }
1183
1184                 $pref = $this->dateFormat( $format );
1185                 if( $pref == 'default' || !isset( $this->dateFormats["$pref time"] ) ) {
1186                         $pref = $this->defaultDateFormat;
1187                 }
1188                 return $this->sprintfDate( $this->dateFormats["$pref time"], $ts );
1189         }
1190
1191         /**
1192         * @public
1193         * @param mixed  $ts the time format which needs to be turned into a
1194         *               date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1195         * @param bool   $adj whether to adjust the time output according to the
1196         *               user configured offset ($timecorrection)
1197
1198         * @param mixed  $format what format to return, if it's false output the
1199         *               default one (default true)
1200         * @param string $timecorrection the time offset as returned by
1201         *               validateTimeZone() in Special:Preferences
1202         * @return string
1203         */
1204         function timeanddate( $ts, $adj = false, $format = true, $timecorrection = false) {
1205                 $this->load();
1206
1207                 $ts = wfTimestamp( TS_MW, $ts );
1208
1209                 if ( $adj ) {
1210                         $ts = $this->userAdjust( $ts, $timecorrection );
1211                 }
1212
1213                 $pref = $this->dateFormat( $format );
1214                 if( $pref == 'default' || !isset( $this->dateFormats["$pref both"] ) ) {
1215                         $pref = $this->defaultDateFormat;
1216                 }
1217
1218                 return $this->sprintfDate( $this->dateFormats["$pref both"], $ts );
1219         }
1220
1221         function getMessage( $key ) {
1222                 $this->load();
1223                 return isset( $this->messages[$key] ) ? $this->messages[$key] : null;
1224         }
1225
1226         function getAllMessages() {
1227                 $this->load();
1228                 return $this->messages;
1229         }
1230
1231         function iconv( $in, $out, $string ) {
1232                 # For most languages, this is a wrapper for iconv
1233                 return iconv( $in, $out . '//IGNORE', $string );
1234         }
1235
1236         // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1237         function ucwordbreaksCallbackAscii($matches){
1238                 return $this->ucfirst($matches[1]);
1239         }
1240
1241         function ucwordbreaksCallbackMB($matches){
1242                 return mb_strtoupper($matches[0]);
1243         }
1244
1245         function ucCallback($matches){
1246                 list( $wikiUpperChars ) = self::getCaseMaps();
1247                 return strtr( $matches[1], $wikiUpperChars );
1248         }
1249
1250         function lcCallback($matches){
1251                 list( , $wikiLowerChars ) = self::getCaseMaps();
1252                 return strtr( $matches[1], $wikiLowerChars );
1253         }
1254
1255         function ucwordsCallbackMB($matches){
1256                 return mb_strtoupper($matches[0]);
1257         }
1258
1259         function ucwordsCallbackWiki($matches){
1260                 list( $wikiUpperChars ) = self::getCaseMaps();
1261                 return strtr( $matches[0], $wikiUpperChars );
1262         }
1263
1264         function ucfirst( $str ) {
1265                 if ( empty($str) ) return $str;
1266                 if ( ord($str[0]) < 128 ) return ucfirst($str);
1267                 else return self::uc($str,true); // fall back to more complex logic in case of multibyte strings
1268         }
1269
1270         function uc( $str, $first = false ) {
1271                 if ( function_exists( 'mb_strtoupper' ) ) {
1272                         if ( $first ) {
1273                                 if ( self::isMultibyte( $str ) ) {
1274                                         return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1275                                 } else {
1276                                         return ucfirst( $str );
1277                                 }
1278                         } else {
1279                                 return self::isMultibyte( $str ) ? mb_strtoupper( $str ) : strtoupper( $str );
1280                         }
1281                 } else {
1282                         if ( self::isMultibyte( $str ) ) {
1283                                 list( $wikiUpperChars ) = $this->getCaseMaps();
1284                                 $x = $first ? '^' : '';
1285                                 return preg_replace_callback(
1286                                         "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1287                                         array($this,"ucCallback"),
1288                                         $str
1289                                 );
1290                         } else {
1291                                 return $first ? ucfirst( $str ) : strtoupper( $str );
1292                         }
1293                 }
1294         }
1295
1296         function lcfirst( $str ) {
1297                 if ( empty($str) ) return $str;
1298                 if ( is_string( $str ) && ord($str[0]) < 128 ) {
1299                         // editing string in place = cool
1300                         $str[0]=strtolower($str[0]);
1301                         return $str;
1302                 }
1303                 else return self::lc( $str, true );
1304         }
1305
1306         function lc( $str, $first = false ) {
1307                 if ( function_exists( 'mb_strtolower' ) )
1308                         if ( $first )
1309                                 if ( self::isMultibyte( $str ) )
1310                                         return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1311                                 else
1312                                         return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
1313                         else
1314                                 return self::isMultibyte( $str ) ? mb_strtolower( $str ) : strtolower( $str );
1315                 else
1316                         if ( self::isMultibyte( $str ) ) {
1317                                 list( , $wikiLowerChars ) = self::getCaseMaps();
1318                                 $x = $first ? '^' : '';
1319                                 return preg_replace_callback(
1320                                         "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1321                                         array($this,"lcCallback"),
1322                                         $str
1323                                 );
1324                         } else
1325                                 return $first ? strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
1326         }
1327
1328         function isMultibyte( $str ) {
1329                 return (bool)preg_match( '/[\x80-\xff]/', $str );
1330         }
1331
1332         function ucwords($str) {
1333                 if ( self::isMultibyte( $str ) ) {
1334                         $str = self::lc($str);
1335
1336                         // regexp to find first letter in each word (i.e. after each space)
1337                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1338
1339                         // function to use to capitalize a single char
1340                         if ( function_exists( 'mb_strtoupper' ) )
1341                                 return preg_replace_callback(
1342                                         $replaceRegexp,
1343                                         array($this,"ucwordsCallbackMB"),
1344                                         $str
1345                                 );
1346                         else
1347                                 return preg_replace_callback(
1348                                         $replaceRegexp,
1349                                         array($this,"ucwordsCallbackWiki"),
1350                                         $str
1351                                 );
1352                 }
1353                 else
1354                         return ucwords( strtolower( $str ) );
1355         }
1356
1357   # capitalize words at word breaks
1358         function ucwordbreaks($str){
1359                 if (self::isMultibyte( $str ) ) {
1360                         $str = self::lc($str);
1361
1362                         // since \b doesn't work for UTF-8, we explicitely define word break chars
1363                         $breaks= "[ \-\(\)\}\{\.,\?!]";
1364
1365                         // find first letter after word break
1366                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1367
1368                         if ( function_exists( 'mb_strtoupper' ) )
1369                                 return preg_replace_callback(
1370                                         $replaceRegexp,
1371                                         array($this,"ucwordbreaksCallbackMB"),
1372                                         $str
1373                                 );
1374                         else
1375                                 return preg_replace_callback(
1376                                         $replaceRegexp,
1377                                         array($this,"ucwordsCallbackWiki"),
1378                                         $str
1379                                 );
1380                 }
1381                 else
1382                         return preg_replace_callback(
1383                         '/\b([\w\x80-\xff]+)\b/',
1384                         array($this,"ucwordbreaksCallbackAscii"),
1385                         $str );
1386         }
1387
1388         /**
1389          * Return a case-folded representation of $s
1390          *
1391          * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1392          * and $s2 are the same except for the case of their characters. It is not
1393          * necessary for the value returned to make sense when displayed.
1394          *
1395          * Do *not* perform any other normalisation in this function. If a caller
1396          * uses this function when it should be using a more general normalisation
1397          * function, then fix the caller.
1398          */
1399         function caseFold( $s ) {
1400                 return $this->uc( $s );
1401         }
1402
1403         function checkTitleEncoding( $s ) {
1404                 if( is_array( $s ) ) {
1405                         wfDebugDieBacktrace( 'Given array to checkTitleEncoding.' );
1406                 }
1407                 # Check for non-UTF-8 URLs
1408                 $ishigh = preg_match( '/[\x80-\xff]/', $s);
1409                 if(!$ishigh) return $s;
1410
1411                 $isutf8 = preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1412                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
1413                 if( $isutf8 ) return $s;
1414
1415                 return $this->iconv( $this->fallback8bitEncoding(), "utf-8", $s );
1416         }
1417
1418         function fallback8bitEncoding() {
1419                 $this->load();
1420                 return $this->fallback8bitEncoding;
1421         }
1422
1423         /**
1424          * Some languages have special punctuation to strip out
1425          * or characters which need to be converted for MySQL's
1426          * indexing to grok it correctly. Make such changes here.
1427          *
1428          * @param string $in
1429          * @return string
1430          */
1431         function stripForSearch( $string ) {
1432                 global $wgDBtype;
1433                 if ( $wgDBtype != 'mysql' ) {
1434                         return $string;
1435                 }
1436
1437                 # MySQL fulltext index doesn't grok utf-8, so we
1438                 # need to fold cases and convert to hex
1439
1440                 wfProfileIn( __METHOD__ );
1441                 if( function_exists( 'mb_strtolower' ) ) {
1442                         $out = preg_replace(
1443                                 "/([\\xc0-\\xff][\\x80-\\xbf]*)/e",
1444                                 "'U8' . bin2hex( \"$1\" )",
1445                                 mb_strtolower( $string ) );
1446                 } else {
1447                         list( , $wikiLowerChars ) = self::getCaseMaps();
1448                         $out = preg_replace(
1449                                 "/([\\xc0-\\xff][\\x80-\\xbf]*)/e",
1450                                 "'U8' . bin2hex( strtr( \"\$1\", \$wikiLowerChars ) )",
1451                                 $string );
1452                 }
1453                 wfProfileOut( __METHOD__ );
1454                 return $out;
1455         }
1456
1457         function convertForSearchResult( $termsArray ) {
1458                 # some languages, e.g. Chinese, need to do a conversion
1459                 # in order for search results to be displayed correctly
1460                 return $termsArray;
1461         }
1462
1463         /**
1464          * Get the first character of a string.
1465          *
1466          * @param string $s
1467          * @return string
1468          */
1469         function firstChar( $s ) {
1470                 $matches = array();
1471                 preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1472                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/', $s, $matches);
1473
1474                 if ( isset( $matches[1] ) ) {
1475                         if ( strlen( $matches[1] ) != 3 ) {
1476                                 return $matches[1];
1477                         }
1478
1479                         // Break down Hangul syllables to grab the first jamo
1480                         $code = utf8ToCodepoint( $matches[1] );
1481                         if ( $code < 0xac00 || 0xd7a4 <= $code) {
1482                                 return $matches[1];
1483                         } elseif ( $code < 0xb098 ) {
1484                                 return "\xe3\x84\xb1";
1485                         } elseif ( $code < 0xb2e4 ) {
1486                                 return "\xe3\x84\xb4";
1487                         } elseif ( $code < 0xb77c ) {
1488                                 return "\xe3\x84\xb7";
1489                         } elseif ( $code < 0xb9c8 ) {
1490                                 return "\xe3\x84\xb9";
1491                         } elseif ( $code < 0xbc14 ) {
1492                                 return "\xe3\x85\x81";
1493                         } elseif ( $code < 0xc0ac ) {
1494                                 return "\xe3\x85\x82";
1495                         } elseif ( $code < 0xc544 ) {
1496                                 return "\xe3\x85\x85";
1497                         } elseif ( $code < 0xc790 ) {
1498                                 return "\xe3\x85\x87";
1499                         } elseif ( $code < 0xcc28 ) {
1500                                 return "\xe3\x85\x88";
1501                         } elseif ( $code < 0xce74 ) {
1502                                 return "\xe3\x85\x8a";
1503                         } elseif ( $code < 0xd0c0 ) {
1504                                 return "\xe3\x85\x8b";
1505                         } elseif ( $code < 0xd30c ) {
1506                                 return "\xe3\x85\x8c";
1507                         } elseif ( $code < 0xd558 ) {
1508                                 return "\xe3\x85\x8d";
1509                         } else {
1510                                 return "\xe3\x85\x8e";
1511                         }
1512                 } else {
1513                         return "";
1514                 }
1515         }
1516
1517         function initEncoding() {
1518                 # Some languages may have an alternate char encoding option
1519                 # (Esperanto X-coding, Japanese furigana conversion, etc)
1520                 # If this language is used as the primary content language,
1521                 # an override to the defaults can be set here on startup.
1522         }
1523
1524         function recodeForEdit( $s ) {
1525                 # For some languages we'll want to explicitly specify
1526                 # which characters make it into the edit box raw
1527                 # or are converted in some way or another.
1528                 # Note that if wgOutputEncoding is different from
1529                 # wgInputEncoding, this text will be further converted
1530                 # to wgOutputEncoding.
1531                 global $wgEditEncoding;
1532                 if( $wgEditEncoding == '' or
1533                   $wgEditEncoding == 'UTF-8' ) {
1534                         return $s;
1535                 } else {
1536                         return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
1537                 }
1538         }
1539
1540         function recodeInput( $s ) {
1541                 # Take the previous into account.
1542                 global $wgEditEncoding;
1543                 if($wgEditEncoding != "") {
1544                         $enc = $wgEditEncoding;
1545                 } else {
1546                         $enc = 'UTF-8';
1547                 }
1548                 if( $enc == 'UTF-8' ) {
1549                         return $s;
1550                 } else {
1551                         return $this->iconv( $enc, 'UTF-8', $s );
1552                 }
1553         }
1554
1555         /**
1556          * For right-to-left language support
1557          *
1558          * @return bool
1559          */
1560         function isRTL() {
1561                 $this->load();
1562                 return $this->rtl;
1563         }
1564
1565         /**
1566          * A hidden direction mark (LRM or RLM), depending on the language direction
1567          *
1568          * @return string
1569          */
1570         function getDirMark() {
1571                 return $this->isRTL() ? "\xE2\x80\x8F" : "\xE2\x80\x8E";
1572         }
1573
1574         /**
1575          * An arrow, depending on the language direction
1576          *
1577          * @return string
1578          */
1579         function getArrow() {
1580                 return $this->isRTL() ? '←' : '→';
1581         }
1582
1583         /**
1584          * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
1585          *
1586          * @return bool
1587          */
1588         function linkPrefixExtension() {
1589                 $this->load();
1590                 return $this->linkPrefixExtension;
1591         }
1592
1593         function &getMagicWords() {
1594                 $this->load();
1595                 return $this->magicWords;
1596         }
1597
1598         # Fill a MagicWord object with data from here
1599         function getMagic( &$mw ) {
1600                 if ( !$this->mMagicHookDone ) {
1601                         $this->mMagicHookDone = true;
1602                         wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
1603                 }
1604                 if ( isset( $this->mMagicExtensions[$mw->mId] ) ) {
1605                         $rawEntry = $this->mMagicExtensions[$mw->mId];
1606                 } else {
1607                         $magicWords =& $this->getMagicWords();
1608                         if ( isset( $magicWords[$mw->mId] ) ) {
1609                                 $rawEntry = $magicWords[$mw->mId];
1610                         } else {
1611                                 # Fall back to English if local list is incomplete
1612                                 $magicWords =& Language::getMagicWords();
1613                                 if ( !isset($magicWords[$mw->mId]) ) { throw new MWException("Magic word not found" ); }
1614                                 $rawEntry = $magicWords[$mw->mId];
1615                         }
1616                 }
1617
1618                 if( !is_array( $rawEntry ) ) {
1619                         error_log( "\"$rawEntry\" is not a valid magic thingie for \"$mw->mId\"" );
1620                 } else {
1621                         $mw->mCaseSensitive = $rawEntry[0];
1622                         $mw->mSynonyms = array_slice( $rawEntry, 1 );
1623                 }
1624         }
1625
1626         /**
1627          * Add magic words to the extension array
1628          */
1629         function addMagicWordsByLang( $newWords ) {
1630                 $code = $this->getCode();
1631                 $fallbackChain = array();
1632                 while ( $code && !in_array( $code, $fallbackChain ) ) {
1633                         $fallbackChain[] = $code;
1634                         $code = self::getFallbackFor( $code );
1635                 }
1636                 if ( !in_array( 'en', $fallbackChain ) ) {
1637                         $fallbackChain[] = 'en';
1638                 }
1639                 $fallbackChain = array_reverse( $fallbackChain );
1640                 foreach ( $fallbackChain as $code ) {
1641                         if ( isset( $newWords[$code] ) ) {
1642                                 $this->mMagicExtensions = $newWords[$code] + $this->mMagicExtensions;
1643                         }
1644                 }
1645         }
1646
1647         /**
1648          * Get special page names, as an associative array
1649          *   case folded alias => real name
1650          */
1651         function getSpecialPageAliases() {
1652                 $this->load();
1653                 if ( !isset( $this->mExtendedSpecialPageAliases ) ) {
1654                         $this->mExtendedSpecialPageAliases = $this->specialPageAliases;
1655                         wfRunHooks( 'LanguageGetSpecialPageAliases',
1656                                 array( &$this->mExtendedSpecialPageAliases, $this->getCode() ) );
1657                 }
1658                 return $this->mExtendedSpecialPageAliases;
1659         }
1660
1661         /**
1662          * Italic is unsuitable for some languages
1663          *
1664          * @public
1665          *
1666          * @param string $text The text to be emphasized.
1667          * @return string
1668          */
1669         function emphasize( $text ) {
1670                 return "<em>$text</em>";
1671         }
1672
1673          /**
1674          * Normally we output all numbers in plain en_US style, that is
1675          * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
1676          * point twohundredthirtyfive. However this is not sutable for all
1677          * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
1678          * Icelandic just want to use commas instead of dots, and dots instead
1679          * of commas like "293.291,235".
1680          *
1681          * An example of this function being called:
1682          * <code>
1683          * wfMsg( 'message', $wgLang->formatNum( $num ) )
1684          * </code>
1685          *
1686          * See LanguageGu.php for the Gujarati implementation and
1687          * LanguageIs.php for the , => . and . => , implementation.
1688          *
1689          * @todo check if it's viable to use localeconv() for the decimal
1690          *       seperator thing.
1691          * @public
1692          * @param mixed $number the string to be formatted, should be an integer or
1693          *        a floating point number.
1694          * @param bool $nocommafy Set to true for special numbers like dates
1695          * @return string
1696          */
1697         function formatNum( $number, $nocommafy = false ) {
1698                 global $wgTranslateNumerals;
1699                 if (!$nocommafy) {
1700                         $number = $this->commafy($number);
1701                         $s = $this->separatorTransformTable();
1702                         if (!is_null($s)) { $number = strtr($number, $s); }
1703                 }
1704
1705                 if ($wgTranslateNumerals) {
1706                         $s = $this->digitTransformTable();
1707                         if (!is_null($s)) { $number = strtr($number, $s); }
1708                 }
1709
1710                 return $number;
1711         }
1712
1713         function parseFormattedNumber( $number ) {
1714                 $s = $this->digitTransformTable();
1715                 if (!is_null($s)) { $number = strtr($number, array_flip($s)); }
1716
1717                 $s = $this->separatorTransformTable();
1718                 if (!is_null($s)) { $number = strtr($number, array_flip($s)); }
1719
1720                 $number = strtr( $number, array (',' => '') );
1721                 return $number;
1722         }
1723
1724         /**
1725          * Adds commas to a given number
1726          *
1727          * @param mixed $_
1728          * @return string
1729          */
1730         function commafy($_) {
1731                 return strrev((string)preg_replace('/(\d{3})(?=\d)(?!\d*\.)/','$1,',strrev($_)));
1732         }
1733
1734         function digitTransformTable() {
1735                 $this->load();
1736                 return $this->digitTransformTable;
1737         }
1738
1739         function separatorTransformTable() {
1740                 $this->load();
1741                 return $this->separatorTransformTable;
1742         }
1743
1744
1745         /**
1746          * For the credit list in includes/Credits.php (action=credits)
1747          *
1748          * @param array $l
1749          * @return string
1750          */
1751         function listToText( $l ) {
1752                 $s = '';
1753                 $m = count($l) - 1;
1754                 for ($i = $m; $i >= 0; $i--) {
1755                         if ($i == $m) {
1756                                 $s = $l[$i];
1757                         } else if ($i == $m - 1) {
1758                                 $s = $l[$i] . ' ' . $this->getMessageFromDB( 'and' ) . ' ' . $s;
1759                         } else {
1760                                 $s = $l[$i] . ', ' . $s;
1761                         }
1762                 }
1763                 return $s;
1764         }
1765
1766         /**
1767          * Truncate a string to a specified length in bytes, appending an optional
1768          * string (e.g. for ellipses)
1769          *
1770          * The database offers limited byte lengths for some columns in the database;
1771          * multi-byte character sets mean we need to ensure that only whole characters
1772          * are included, otherwise broken characters can be passed to the user
1773          *
1774          * If $length is negative, the string will be truncated from the beginning
1775          *
1776          * @param string $string String to truncate
1777          * @param int $length Maximum length (excluding ellipses)
1778          * @param string $ellipses String to append to the truncated text
1779          * @return string
1780          */
1781         function truncate( $string, $length, $ellipsis = "" ) {
1782                 if( $length == 0 ) {
1783                         return $ellipsis;
1784                 }
1785                 if ( strlen( $string ) <= abs( $length ) ) {
1786                         return $string;
1787                 }
1788                 if( $length > 0 ) {
1789                         $string = substr( $string, 0, $length );
1790                         $char = ord( $string[strlen( $string ) - 1] );
1791                         $m = array();
1792                         if ($char >= 0xc0) {
1793                                 # We got the first byte only of a multibyte char; remove it.
1794                                 $string = substr( $string, 0, -1 );
1795                         } elseif( $char >= 0x80 &&
1796                                   preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
1797                                               '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
1798                             # We chopped in the middle of a character; remove it
1799                                 $string = $m[1];
1800                         }
1801                         return $string . $ellipsis;
1802                 } else {
1803                         $string = substr( $string, $length );
1804                         $char = ord( $string[0] );
1805                         if( $char >= 0x80 && $char < 0xc0 ) {
1806                                 # We chopped in the middle of a character; remove the whole thing
1807                                 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
1808                         }
1809                         return $ellipsis . $string;
1810                 }
1811         }
1812
1813         /**
1814          * Grammatical transformations, needed for inflected languages
1815          * Invoked by putting {{grammar:case|word}} in a message
1816          *
1817          * @param string $word
1818          * @param string $case
1819          * @return string
1820          */
1821         function convertGrammar( $word, $case ) {
1822                 global $wgGrammarForms;
1823                 if ( isset($wgGrammarForms[$this->getCode()][$case][$word]) ) {
1824                         return $wgGrammarForms[$this->getCode()][$case][$word];
1825                 }
1826                 return $word;
1827         }
1828
1829         /**
1830          * Plural form transformations, needed for some languages.
1831          * For example, there are 3 form of plural in Russian and Polish,
1832          * depending on "count mod 10". See [[w:Plural]]
1833          * For English it is pretty simple.
1834          *
1835          * Invoked by putting {{plural:count|wordform1|wordform2}}
1836          * or {{plural:count|wordform1|wordform2|wordform3}}
1837          *
1838          * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
1839          *
1840          * @param integer $count Non-localized number
1841          * @param array $forms Different plural forms
1842          * @return string Correct form of plural for $count in this language
1843          */
1844         function convertPlural( $count, $forms ) {
1845                 if ( !count($forms) ) { return ''; }
1846                 $forms = $this->preConvertPlural( $forms, 2 );
1847
1848                 return ( abs($count) == 1 ) ? $forms[0] : $forms[1];
1849         }
1850
1851         /**
1852          * Checks that convertPlural was given an array and pads it to requested
1853          * amound of forms by copying the last one.
1854          *
1855          * @param integer $count How many forms should there be at least
1856          * @param array $forms Array of forms given to convertPlural
1857          * @return array Padded array of forms or an exception if not an array
1858          */
1859         protected function preConvertPlural( /* Array */ $forms, $count ) {
1860                 while ( count($forms) < $count ) {
1861                         $forms[] = $forms[count($forms)-1];
1862                 }
1863                 return $forms;
1864         }
1865
1866         /**
1867          * For translaing of expiry times
1868          * @param string The validated block time in English
1869          * @return Somehow translated block time
1870          * @see LanguageFi.php for example implementation
1871          */
1872         function translateBlockExpiry( $str ) {
1873
1874                 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
1875
1876                 if ( $scBlockExpiryOptions == '-') {
1877                         return $str;
1878                 }
1879
1880                 foreach (explode(',', $scBlockExpiryOptions) as $option) {
1881                         if ( strpos($option, ":") === false )
1882                                 continue;
1883                         list($show, $value) = explode(":", $option);
1884                         if ( strcmp ( $str, $value) == 0 ) {
1885                                 return htmlspecialchars( trim( $show ) );
1886                         }
1887                 }
1888
1889                 return $str;
1890         }
1891
1892         /**
1893          * languages like Chinese need to be segmented in order for the diff
1894          * to be of any use
1895          *
1896          * @param string $text
1897          * @return string
1898          */
1899         function segmentForDiff( $text ) {
1900                 return $text;
1901         }
1902
1903         /**
1904          * and unsegment to show the result
1905          *
1906          * @param string $text
1907          * @return string
1908          */
1909         function unsegmentForDiff( $text ) {
1910                 return $text;
1911         }
1912
1913         # convert text to different variants of a language.
1914         function convert( $text, $isTitle = false) {
1915                 return $this->mConverter->convert($text, $isTitle);
1916         }
1917
1918         # Convert text from within Parser
1919         function parserConvert( $text, &$parser ) {
1920                 return $this->mConverter->parserConvert( $text, $parser );
1921         }
1922
1923         # Check if this is a language with variants
1924         function hasVariants(){
1925                 return sizeof($this->getVariants())>1;
1926         }
1927
1928         # Put custom tags (e.g. -{ }-) around math to prevent conversion
1929         function armourMath($text){
1930                 return $this->mConverter->armourMath($text);
1931         }
1932
1933
1934         /**
1935          * Perform output conversion on a string, and encode for safe HTML output.
1936          * @param string $text
1937          * @param bool $isTitle -- wtf?
1938          * @return string
1939          * @todo this should get integrated somewhere sane
1940          */
1941         function convertHtml( $text, $isTitle = false ) {
1942                 return htmlspecialchars( $this->convert( $text, $isTitle ) );
1943         }
1944
1945         function convertCategoryKey( $key ) {
1946                 return $this->mConverter->convertCategoryKey( $key );
1947         }
1948
1949         /**
1950          * get the list of variants supported by this langauge
1951          * see sample implementation in LanguageZh.php
1952          *
1953          * @return array an array of language codes
1954          */
1955         function getVariants() {
1956                 return $this->mConverter->getVariants();
1957         }
1958
1959
1960         function getPreferredVariant( $fromUser = true ) {
1961                 return $this->mConverter->getPreferredVariant( $fromUser );
1962         }
1963
1964         /**
1965          * if a language supports multiple variants, it is
1966          * possible that non-existing link in one variant
1967          * actually exists in another variant. this function
1968          * tries to find it. See e.g. LanguageZh.php
1969          *
1970          * @param string $link the name of the link
1971          * @param mixed $nt the title object of the link
1972          * @return null the input parameters may be modified upon return
1973          */
1974         function findVariantLink( &$link, &$nt ) {
1975                 $this->mConverter->findVariantLink($link, $nt);
1976         }
1977
1978         /**
1979          * If a language supports multiple variants, converts text
1980          * into an array of all possible variants of the text:
1981          *  'variant' => text in that variant
1982          */
1983
1984         function convertLinkToAllVariants($text){
1985                 return $this->mConverter->convertLinkToAllVariants($text);
1986         }
1987
1988
1989         /**
1990          * returns language specific options used by User::getPageRenderHash()
1991          * for example, the preferred language variant
1992          *
1993          * @return string
1994          * @public
1995          */
1996         function getExtraHashOptions() {
1997                 return $this->mConverter->getExtraHashOptions();
1998         }
1999
2000         /**
2001          * for languages that support multiple variants, the title of an
2002          * article may be displayed differently in different variants. this
2003          * function returns the apporiate title defined in the body of the article.
2004          *
2005          * @return string
2006          */
2007         function getParsedTitle() {
2008                 return $this->mConverter->getParsedTitle();
2009         }
2010
2011         /**
2012          * Enclose a string with the "no conversion" tag. This is used by
2013          * various functions in the Parser
2014          *
2015          * @param string $text text to be tagged for no conversion
2016          * @return string the tagged text
2017         */
2018         function markNoConversion( $text, $noParse=false ) {
2019                 return $this->mConverter->markNoConversion( $text, $noParse );
2020         }
2021
2022         /**
2023          * A regular expression to match legal word-trailing characters
2024          * which should be merged onto a link of the form [[foo]]bar.
2025          *
2026          * @return string
2027          * @public
2028          */
2029         function linkTrail() {
2030                 $this->load();
2031                 return $this->linkTrail;
2032         }
2033
2034         function getLangObj() {
2035                 return $this;
2036         }
2037
2038         /**
2039          * Get the RFC 3066 code for this language object
2040          */
2041         function getCode() {
2042                 return $this->mCode;
2043         }
2044
2045         function setCode( $code ) {
2046                 $this->mCode = $code;
2047         }
2048
2049         static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
2050                 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
2051         }
2052
2053         static function getMessagesFileName( $code ) {
2054                 global $IP;
2055                 return self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
2056         }
2057
2058         static function getClassFileName( $code ) {
2059                 global $IP;
2060                 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
2061         }
2062
2063         static function getLocalisationArray( $code, $disableCache = false ) {
2064                 self::loadLocalisation( $code, $disableCache );
2065                 return self::$mLocalisationCache[$code];
2066         }
2067
2068         /**
2069          * Load localisation data for a given code into the static cache
2070          *
2071          * @return array Dependencies, map of filenames to mtimes
2072          */
2073         static function loadLocalisation( $code, $disableCache = false ) {
2074                 static $recursionGuard = array();
2075                 global $wgMemc, $wgCheckSerialized;
2076
2077                 if ( !$code ) {
2078                         throw new MWException( "Invalid language code requested" );
2079                 }
2080
2081                 if ( !$disableCache ) {
2082                         # Try the per-process cache
2083                         if ( isset( self::$mLocalisationCache[$code] ) ) {
2084                                 return self::$mLocalisationCache[$code]['deps'];
2085                         }
2086
2087                         wfProfileIn( __METHOD__ );
2088
2089                         # Try the serialized directory
2090                         $cache = wfGetPrecompiledData( self::getFileName( "Messages", $code, '.ser' ) );
2091                         if ( $cache ) {
2092                                 if ( $wgCheckSerialized && self::isLocalisationOutOfDate( $cache ) ) {
2093                                         $cache = false;
2094                                         wfDebug( "Language::loadLocalisation(): precompiled data file for $code is out of date\n" );
2095                                 } else {
2096                                         self::$mLocalisationCache[$code] = $cache;
2097                                         wfDebug( "Language::loadLocalisation(): got localisation for $code from precompiled data file\n" );
2098                                         wfProfileOut( __METHOD__ );
2099                                         return self::$mLocalisationCache[$code]['deps'];
2100                                 }
2101                         }
2102
2103                         # Try the global cache
2104                         $memcKey = wfMemcKey('localisation', $code );
2105                         $fbMemcKey = wfMemcKey('fallback', $cache['fallback'] );
2106                         $cache = $wgMemc->get( $memcKey );
2107                         if ( $cache ) {
2108                                 if ( self::isLocalisationOutOfDate( $cache ) ) {
2109                                         $wgMemc->delete( $memcKey );
2110                                         $wgMemc->delete( $fbMemcKey );
2111                                         $cache = false;
2112                                         wfDebug( "Language::loadLocalisation(): localisation cache for $code had expired\n" );
2113                                 } else {
2114                                         self::$mLocalisationCache[$code] = $cache;
2115                                         wfDebug( "Language::loadLocalisation(): got localisation for $code from cache\n" );
2116                                         wfProfileOut( __METHOD__ );
2117                                         return $cache['deps'];
2118                                 }
2119                         }
2120                 } else {
2121                         wfProfileIn( __METHOD__ );
2122                 }
2123
2124                 # Default fallback, may be overridden when the messages file is included
2125                 if ( $code != 'en' ) {
2126                         $fallback = 'en';
2127                 } else {
2128                         $fallback = false;
2129                 }
2130
2131                 # Load the primary localisation from the source file
2132                 $filename = self::getMessagesFileName( $code );
2133                 if ( !file_exists( $filename ) ) {
2134                         wfDebug( "Language::loadLocalisation(): no localisation file for $code, using implicit fallback to en\n" );
2135                         $cache = array();
2136                         $deps = array();
2137                 } else {
2138                         $deps = array( $filename => filemtime( $filename ) );
2139                         require( $filename );
2140                         $cache = compact( self::$mLocalisationKeys );
2141                         wfDebug( "Language::loadLocalisation(): got localisation for $code from source\n" );
2142                 }
2143
2144                 if ( !empty( $fallback ) ) {
2145                         # Load the fallback localisation, with a circular reference guard
2146                         if ( isset( $recursionGuard[$code] ) ) {
2147                                 throw new MWException( "Error: Circular fallback reference in language code $code" );
2148                         }
2149                         $recursionGuard[$code] = true;
2150                         $newDeps = self::loadLocalisation( $fallback, $disableCache );
2151                         unset( $recursionGuard[$code] );
2152
2153                         $secondary = self::$mLocalisationCache[$fallback];
2154                         $deps = array_merge( $deps, $newDeps );
2155
2156                         # Merge the fallback localisation with the current localisation
2157                         foreach ( self::$mLocalisationKeys as $key ) {
2158                                 if ( isset( $cache[$key] ) ) {
2159                                         if ( isset( $secondary[$key] ) ) {
2160                                                 if ( in_array( $key, self::$mMergeableMapKeys ) ) {
2161                                                         $cache[$key] = $cache[$key] + $secondary[$key];
2162                                                 } elseif ( in_array( $key, self::$mMergeableListKeys ) ) {
2163                                                         $cache[$key] = array_merge( $secondary[$key], $cache[$key] );
2164                                                 } elseif ( in_array( $key, self::$mMergeableAliasListKeys ) ) {
2165                                                         $cache[$key] = array_merge_recursive( $cache[$key], $secondary[$key] );
2166                                                 }
2167                                         }
2168                                 } else {
2169                                         $cache[$key] = $secondary[$key];
2170                                 }
2171                         }
2172
2173                         # Merge bookstore lists if requested
2174                         if ( !empty( $cache['bookstoreList']['inherit'] ) ) {
2175                                 $cache['bookstoreList'] = array_merge( $cache['bookstoreList'], $secondary['bookstoreList'] );
2176                         }
2177                         if ( isset( $cache['bookstoreList']['inherit'] ) ) {
2178                                 unset( $cache['bookstoreList']['inherit'] );
2179                         }
2180                 }
2181
2182                 # Add dependencies to the cache entry
2183                 $cache['deps'] = $deps;
2184
2185                 # Replace spaces with underscores in namespace names
2186                 $cache['namespaceNames'] = str_replace( ' ', '_', $cache['namespaceNames'] );
2187
2188                 # And do the same for specialpage aliases. $page is an array.
2189                 foreach ( $cache['specialPageAliases'] as &$page ) {
2190                         $page = str_replace( ' ', '_', $page );
2191                 }
2192                 # Decouple the reference to prevent accidental damage
2193                 unset($page);
2194
2195                 # Save to both caches
2196                 self::$mLocalisationCache[$code] = $cache;
2197                 if ( !$disableCache ) {
2198                         $wgMemc->set( $memcKey, $cache );
2199                         $wgMemc->set( $fbMemcKey, (string) $cache['fallback'] );
2200                 }
2201
2202                 wfProfileOut( __METHOD__ );
2203                 return $deps;
2204         }
2205
2206         /**
2207          * Test if a given localisation cache is out of date with respect to the
2208          * source Messages files. This is done automatically for the global cache
2209          * in $wgMemc, but is only done on certain occasions for the serialized
2210          * data file.
2211          *
2212          * @param $cache mixed Either a language code or a cache array
2213          */
2214         static function isLocalisationOutOfDate( $cache ) {
2215                 if ( !is_array( $cache ) ) {
2216                         self::loadLocalisation( $cache );
2217                         $cache = self::$mLocalisationCache[$cache];
2218                 }
2219                 $expired = false;
2220                 foreach ( $cache['deps'] as $file => $mtime ) {
2221                         if ( !file_exists( $file ) || filemtime( $file ) > $mtime ) {
2222                                 $expired = true;
2223                                 break;
2224                         }
2225                 }
2226                 return $expired;
2227         }
2228
2229         /**
2230          * Get the fallback for a given language
2231          */
2232         static function getFallbackFor( $code ) {
2233                 // Shortcut
2234                 if ( $code === 'en' ) return false;
2235
2236                 // Local cache
2237                 static $cache = array();
2238                 // Quick return
2239                 if ( isset($cache[$code]) ) return $cache[$code];
2240
2241                 // Try memcache
2242                 global $wgMemc;
2243                 $memcKey = wfMemcKey( 'fallback', $code );
2244                 $fbcode = $wgMemc->get( $memcKey );
2245
2246                 if ( is_string($fbcode) ) {
2247                         // False is stored as a string to detect failures in memcache properly
2248                         if ( $fbcode === '' ) $fbcode = false;
2249
2250                         // Update local cache and return
2251                         $cache[$code] = $fbcode;
2252                         return $fbcode;
2253                 }
2254
2255                 // Nothing in caches, load and and update both caches
2256                 self::loadLocalisation( $code );
2257                 $fbcode = self::$mLocalisationCache[$code]['fallback'];
2258
2259                 $cache[$code] = $fbcode;
2260                 $wgMemc->set( $memcKey, (string) $fbcode );
2261
2262                 return $fbcode;
2263         }
2264
2265         /**
2266          * Get all messages for a given language
2267          */
2268         static function getMessagesFor( $code ) {
2269                 self::loadLocalisation( $code );
2270                 return self::$mLocalisationCache[$code]['messages'];
2271         }
2272
2273         /**
2274          * Get a message for a given language
2275          */
2276         static function getMessageFor( $key, $code ) {
2277                 self::loadLocalisation( $code );
2278                 return isset( self::$mLocalisationCache[$code]['messages'][$key] ) ? self::$mLocalisationCache[$code]['messages'][$key] : null;
2279         }
2280
2281         /**
2282          * Load localisation data for this object
2283          */
2284         function load() {
2285                 if ( !$this->mLoaded ) {
2286                         self::loadLocalisation( $this->getCode() );
2287                         $cache =& self::$mLocalisationCache[$this->getCode()];
2288                         foreach ( self::$mLocalisationKeys as $key ) {
2289                                 $this->$key = $cache[$key];
2290                         }
2291                         $this->mLoaded = true;
2292
2293                         $this->fixUpSettings();
2294                 }
2295         }
2296
2297         /**
2298          * Do any necessary post-cache-load settings adjustment
2299          */
2300         function fixUpSettings() {
2301                 global $wgExtraNamespaces, $wgMetaNamespace, $wgMetaNamespaceTalk,
2302                         $wgNamespaceAliases, $wgAmericanDates;
2303                 wfProfileIn( __METHOD__ );
2304                 if ( $wgExtraNamespaces ) {
2305                         $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames;
2306                 }
2307
2308                 $this->namespaceNames[NS_PROJECT] = $wgMetaNamespace;
2309                 if ( $wgMetaNamespaceTalk ) {
2310                         $this->namespaceNames[NS_PROJECT_TALK] = $wgMetaNamespaceTalk;
2311                 } else {
2312                         $talk = $this->namespaceNames[NS_PROJECT_TALK];
2313                         $talk = str_replace( '$1', $wgMetaNamespace, $talk );
2314
2315                         # Allow grammar transformations
2316                         # Allowing full message-style parsing would make simple requests
2317                         # such as action=raw much more expensive than they need to be.
2318                         # This will hopefully cover most cases.
2319                         $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
2320                                 array( &$this, 'replaceGrammarInNamespace' ), $talk );
2321                         $talk = str_replace( ' ', '_', $talk );
2322                         $this->namespaceNames[NS_PROJECT_TALK] = $talk;
2323                 }
2324
2325                 # The above mixing may leave namespaces out of canonical order.
2326                 # Re-order by namespace ID number...
2327                 ksort( $this->namespaceNames );
2328
2329                 # Put namespace names and aliases into a hashtable.
2330                 # If this is too slow, then we should arrange it so that it is done
2331                 # before caching. The catch is that at pre-cache time, the above
2332                 # class-specific fixup hasn't been done.
2333                 $this->mNamespaceIds = array();
2334                 foreach ( $this->namespaceNames as $index => $name ) {
2335                         $this->mNamespaceIds[$this->lc($name)] = $index;
2336                 }
2337                 if ( $this->namespaceAliases ) {
2338                         foreach ( $this->namespaceAliases as $name => $index ) {
2339                                 $this->mNamespaceIds[$this->lc($name)] = $index;
2340                         }
2341                 }
2342                 if ( $wgNamespaceAliases ) {
2343                         foreach ( $wgNamespaceAliases as $name => $index ) {
2344                                 $this->mNamespaceIds[$this->lc($name)] = $index;
2345                         }
2346                 }
2347
2348                 if ( $this->defaultDateFormat == 'dmy or mdy' ) {
2349                         $this->defaultDateFormat = $wgAmericanDates ? 'mdy' : 'dmy';
2350                 }
2351                 wfProfileOut( __METHOD__ );
2352         }
2353
2354         function replaceGrammarInNamespace( $m ) {
2355                 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
2356         }
2357
2358         static function getCaseMaps() {
2359                 static $wikiUpperChars, $wikiLowerChars;
2360                 if ( isset( $wikiUpperChars ) ) {
2361                         return array( $wikiUpperChars, $wikiLowerChars );
2362                 }
2363
2364                 wfProfileIn( __METHOD__ );
2365                 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
2366                 if ( $arr === false ) {
2367                         throw new MWException(
2368                                 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
2369                 }
2370                 extract( $arr );
2371                 wfProfileOut( __METHOD__ );
2372                 return array( $wikiUpperChars, $wikiLowerChars );
2373         }
2374
2375         function formatTimePeriod( $seconds ) {
2376                 if ( $seconds < 10 ) {
2377                         return $this->formatNum( sprintf( "%.1f", $seconds ) ) . wfMsg( 'seconds-abbrev' );
2378                 } elseif ( $seconds < 60 ) {
2379                         return $this->formatNum( round( $seconds ) ) . wfMsg( 'seconds-abbrev' );
2380                 } elseif ( $seconds < 3600 ) {
2381                         return $this->formatNum( floor( $seconds / 60 ) ) . wfMsg( 'minutes-abbrev' ) .
2382                                 $this->formatNum( round( fmod( $seconds, 60 ) ) ) . wfMsg( 'seconds-abbrev' );
2383                 } else {
2384                         $hours = floor( $seconds / 3600 );
2385                         $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
2386                         $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
2387                         return $this->formatNum( $hours ) . wfMsg( 'hours-abbrev' ) .
2388                                 $this->formatNum( $minutes ) . wfMsg( 'minutes-abbrev' ) .
2389                                 $this->formatNum( $secondsPart ) . wfMsg( 'seconds-abbrev' );
2390                 }
2391         }
2392
2393         function formatBitrate( $bps ) {
2394                 $units = array( 'bps', 'kbps', 'Mbps', 'Gbps' );
2395                 if ( $bps <= 0 ) {
2396                         return $this->formatNum( $bps ) . $units[0];
2397                 }
2398                 $unitIndex = floor( log10( $bps ) / 3 );
2399                 $mantissa = $bps / pow( 1000, $unitIndex );
2400                 if ( $mantissa < 10 ) {
2401                         $mantissa = round( $mantissa, 1 );
2402                 } else {
2403                         $mantissa = round( $mantissa );
2404                 }
2405                 return $this->formatNum( $mantissa ) . $units[$unitIndex];
2406         }
2407
2408         /**
2409          * Format a size in bytes for output, using an appropriate
2410          * unit (B, KB, MB or GB) according to the magnitude in question
2411          *
2412          * @param $size Size to format
2413          * @return string Plain text (not HTML)
2414          */
2415         function formatSize( $size ) {
2416                 // For small sizes no decimal places necessary
2417                 $round = 0;
2418                 if( $size > 1024 ) {
2419                         $size = $size / 1024;
2420                         if( $size > 1024 ) {
2421                                 $size = $size / 1024;
2422                                 // For MB and bigger two decimal places are smarter
2423                                 $round = 2;
2424                                 if( $size > 1024 ) {
2425                                         $size = $size / 1024;
2426                                         $msg = 'size-gigabytes';
2427                                 } else {
2428                                         $msg = 'size-megabytes';
2429                                 }
2430                         } else {
2431                                 $msg = 'size-kilobytes';
2432                         }
2433                 } else {
2434                         $msg = 'size-bytes';
2435                 }
2436                 $size = round( $size, $round );
2437                 $text = $this->getMessageFromDB( $msg );
2438                 return str_replace( '$1', $this->formatNum( $size ), $text );
2439         }
2440 }