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