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                 # For most languages, this is a wrapper for iconv
1471                 return iconv( $in, $out . '//IGNORE', $string );
1472         }
1473
1474         // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1475         function ucwordbreaksCallbackAscii($matches){
1476                 return $this->ucfirst($matches[1]);
1477         }
1478
1479         function ucwordbreaksCallbackMB($matches){
1480                 return mb_strtoupper($matches[0]);
1481         }
1482
1483         function ucCallback($matches){
1484                 list( $wikiUpperChars ) = self::getCaseMaps();
1485                 return strtr( $matches[1], $wikiUpperChars );
1486         }
1487
1488         function lcCallback($matches){
1489                 list( , $wikiLowerChars ) = self::getCaseMaps();
1490                 return strtr( $matches[1], $wikiLowerChars );
1491         }
1492
1493         function ucwordsCallbackMB($matches){
1494                 return mb_strtoupper($matches[0]);
1495         }
1496
1497         function ucwordsCallbackWiki($matches){
1498                 list( $wikiUpperChars ) = self::getCaseMaps();
1499                 return strtr( $matches[0], $wikiUpperChars );
1500         }
1501
1502         function ucfirst( $str ) {
1503                 if ( empty($str) ) return $str;
1504                 if ( ord($str[0]) < 128 ) return ucfirst($str);
1505                 else return self::uc($str,true); // fall back to more complex logic in case of multibyte strings
1506         }
1507
1508         function uc( $str, $first = false ) {
1509                 if ( function_exists( 'mb_strtoupper' ) ) {
1510                         if ( $first ) {
1511                                 if ( self::isMultibyte( $str ) ) {
1512                                         return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1513                                 } else {
1514                                         return ucfirst( $str );
1515                                 }
1516                         } else {
1517                                 return self::isMultibyte( $str ) ? mb_strtoupper( $str ) : strtoupper( $str );
1518                         }
1519                 } else {
1520                         if ( self::isMultibyte( $str ) ) {
1521                                 list( $wikiUpperChars ) = $this->getCaseMaps();
1522                                 $x = $first ? '^' : '';
1523                                 return preg_replace_callback(
1524                                         "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1525                                         array($this,"ucCallback"),
1526                                         $str
1527                                 );
1528                         } else {
1529                                 return $first ? ucfirst( $str ) : strtoupper( $str );
1530                         }
1531                 }
1532         }
1533
1534         function lcfirst( $str ) {
1535                 if ( empty($str) ) return $str;
1536                 if ( is_string( $str ) && ord($str[0]) < 128 ) {
1537                         // editing string in place = cool
1538                         $str[0]=strtolower($str[0]);
1539                         return $str;
1540                 }
1541                 else return self::lc( $str, true );
1542         }
1543
1544         function lc( $str, $first = false ) {
1545                 if ( function_exists( 'mb_strtolower' ) )
1546                         if ( $first )
1547                                 if ( self::isMultibyte( $str ) )
1548                                         return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1549                                 else
1550                                         return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
1551                         else
1552                                 return self::isMultibyte( $str ) ? mb_strtolower( $str ) : strtolower( $str );
1553                 else
1554                         if ( self::isMultibyte( $str ) ) {
1555                                 list( , $wikiLowerChars ) = self::getCaseMaps();
1556                                 $x = $first ? '^' : '';
1557                                 return preg_replace_callback(
1558                                         "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1559                                         array($this,"lcCallback"),
1560                                         $str
1561                                 );
1562                         } else
1563                                 return $first ? strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
1564         }
1565
1566         function isMultibyte( $str ) {
1567                 return (bool)preg_match( '/[\x80-\xff]/', $str );
1568         }
1569
1570         function ucwords($str) {
1571                 if ( self::isMultibyte( $str ) ) {
1572                         $str = self::lc($str);
1573
1574                         // regexp to find first letter in each word (i.e. after each space)
1575                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1576
1577                         // function to use to capitalize a single char
1578                         if ( function_exists( 'mb_strtoupper' ) )
1579                                 return preg_replace_callback(
1580                                         $replaceRegexp,
1581                                         array($this,"ucwordsCallbackMB"),
1582                                         $str
1583                                 );
1584                         else
1585                                 return preg_replace_callback(
1586                                         $replaceRegexp,
1587                                         array($this,"ucwordsCallbackWiki"),
1588                                         $str
1589                                 );
1590                 }
1591                 else
1592                         return ucwords( strtolower( $str ) );
1593         }
1594
1595   # capitalize words at word breaks
1596         function ucwordbreaks($str){
1597                 if (self::isMultibyte( $str ) ) {
1598                         $str = self::lc($str);
1599
1600                         // since \b doesn't work for UTF-8, we explicitely define word break chars
1601                         $breaks= "[ \-\(\)\}\{\.,\?!]";
1602
1603                         // find first letter after word break
1604                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1605
1606                         if ( function_exists( 'mb_strtoupper' ) )
1607                                 return preg_replace_callback(
1608                                         $replaceRegexp,
1609                                         array($this,"ucwordbreaksCallbackMB"),
1610                                         $str
1611                                 );
1612                         else
1613                                 return preg_replace_callback(
1614                                         $replaceRegexp,
1615                                         array($this,"ucwordsCallbackWiki"),
1616                                         $str
1617                                 );
1618                 }
1619                 else
1620                         return preg_replace_callback(
1621                         '/\b([\w\x80-\xff]+)\b/',
1622                         array($this,"ucwordbreaksCallbackAscii"),
1623                         $str );
1624         }
1625
1626         /**
1627          * Return a case-folded representation of $s
1628          *
1629          * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1630          * and $s2 are the same except for the case of their characters. It is not
1631          * necessary for the value returned to make sense when displayed.
1632          *
1633          * Do *not* perform any other normalisation in this function. If a caller
1634          * uses this function when it should be using a more general normalisation
1635          * function, then fix the caller.
1636          */
1637         function caseFold( $s ) {
1638                 return $this->uc( $s );
1639         }
1640
1641         function checkTitleEncoding( $s ) {
1642                 if( is_array( $s ) ) {
1643                         wfDebugDieBacktrace( 'Given array to checkTitleEncoding.' );
1644                 }
1645                 # Check for non-UTF-8 URLs
1646                 $ishigh = preg_match( '/[\x80-\xff]/', $s);
1647                 if(!$ishigh) return $s;
1648
1649                 $isutf8 = preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1650                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
1651                 if( $isutf8 ) return $s;
1652
1653                 return $this->iconv( $this->fallback8bitEncoding(), "utf-8", $s );
1654         }
1655
1656         function fallback8bitEncoding() {
1657                 return self::$dataCache->getItem( $this->mCode, 'fallback8bitEncoding' );
1658         }
1659
1660         /**
1661          * Most writing systems use whitespace to break up words.
1662          * Some languages such as Chinese don't conventionally do this,
1663          * which requires special handling when breaking up words for
1664          * searching etc.
1665          */
1666         function hasWordBreaks() {
1667                 return true;
1668         }
1669
1670         /**
1671          * Some languages have special punctuation to strip out
1672          * or characters which need to be converted for MySQL's
1673          * indexing to grok it correctly. Make such changes here.
1674          *
1675          * @param $string String
1676          * @return String
1677          */
1678         function stripForSearch( $string ) {
1679                 global $wgDBtype;
1680                 if ( $wgDBtype != 'mysql' ) {
1681                         return $string;
1682                 }
1683
1684
1685                 wfProfileIn( __METHOD__ );
1686
1687                 // MySQL fulltext index doesn't grok utf-8, so we
1688                 // need to fold cases and convert to hex
1689                 $out = preg_replace_callback(
1690                         "/([\\xc0-\\xff][\\x80-\\xbf]*)/",
1691                         array( $this, 'stripForSearchCallback' ),
1692                         $this->lc( $string ) );
1693
1694                 // And to add insult to injury, the default indexing
1695                 // ignores short words... Pad them so we can pass them
1696                 // through without reconfiguring the server...
1697                 $minLength = $this->minSearchLength();
1698                 if( $minLength > 1 ) {
1699                         $n = $minLength-1;
1700                         $out = preg_replace(
1701                                 "/\b(\w{1,$n})\b/",
1702                                 "$1u800",
1703                                 $out );
1704                 }
1705
1706                 // Periods within things like hostnames and IP addresses
1707                 // are also important -- we want a search for "example.com"
1708                 // or "192.168.1.1" to work sanely.
1709                 //
1710                 // MySQL's search seems to ignore them, so you'd match on
1711                 // "example.wikipedia.com" and "192.168.83.1" as well.
1712                 $out = preg_replace(
1713                         "/(\w)\.(\w|\*)/u",
1714                         "$1u82e$2",
1715                         $out );
1716
1717                 wfProfileOut( __METHOD__ );
1718                 return $out;
1719         }
1720
1721         /**
1722          * Armor a case-folded UTF-8 string to get through MySQL's
1723          * fulltext search without being mucked up by funny charset
1724          * settings or anything else of the sort.
1725          */
1726         protected function stripForSearchCallback( $matches ) {
1727                 return 'u8' . bin2hex( $matches[1] );
1728         }
1729
1730         /**
1731          * Check MySQL server's ft_min_word_len setting so we know
1732          * if we need to pad short words...
1733          */
1734         protected function minSearchLength() {
1735                 if( is_null( $this->minSearchLength ) ) {
1736                         $sql = "show global variables like 'ft\\_min\\_word\\_len'";
1737                         $dbr = wfGetDB( DB_SLAVE );
1738                         $result = $dbr->query( $sql );
1739                         $row = $result->fetchObject();
1740                         $result->free();
1741
1742                         if( $row && $row->Variable_name == 'ft_min_word_len' ) {
1743                                 $this->minSearchLength = intval( $row->Value );
1744                         } else {
1745                                 $this->minSearchLength = 0;
1746                         }
1747                 }
1748                 return $this->minSearchLength;
1749         }
1750
1751         function convertForSearchResult( $termsArray ) {
1752                 # some languages, e.g. Chinese, need to do a conversion
1753                 # in order for search results to be displayed correctly
1754                 return $termsArray;
1755         }
1756
1757         /**
1758          * Get the first character of a string.
1759          *
1760          * @param $s string
1761          * @return string
1762          */
1763         function firstChar( $s ) {
1764                 $matches = array();
1765                 preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1766                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/', $s, $matches);
1767
1768                 if ( isset( $matches[1] ) ) {
1769                         if ( strlen( $matches[1] ) != 3 ) {
1770                                 return $matches[1];
1771                         }
1772
1773                         // Break down Hangul syllables to grab the first jamo
1774                         $code = utf8ToCodepoint( $matches[1] );
1775                         if ( $code < 0xac00 || 0xd7a4 <= $code) {
1776                                 return $matches[1];
1777                         } elseif ( $code < 0xb098 ) {
1778                                 return "\xe3\x84\xb1";
1779                         } elseif ( $code < 0xb2e4 ) {
1780                                 return "\xe3\x84\xb4";
1781                         } elseif ( $code < 0xb77c ) {
1782                                 return "\xe3\x84\xb7";
1783                         } elseif ( $code < 0xb9c8 ) {
1784                                 return "\xe3\x84\xb9";
1785                         } elseif ( $code < 0xbc14 ) {
1786                                 return "\xe3\x85\x81";
1787                         } elseif ( $code < 0xc0ac ) {
1788                                 return "\xe3\x85\x82";
1789                         } elseif ( $code < 0xc544 ) {
1790                                 return "\xe3\x85\x85";
1791                         } elseif ( $code < 0xc790 ) {
1792                                 return "\xe3\x85\x87";
1793                         } elseif ( $code < 0xcc28 ) {
1794                                 return "\xe3\x85\x88";
1795                         } elseif ( $code < 0xce74 ) {
1796                                 return "\xe3\x85\x8a";
1797                         } elseif ( $code < 0xd0c0 ) {
1798                                 return "\xe3\x85\x8b";
1799                         } elseif ( $code < 0xd30c ) {
1800                                 return "\xe3\x85\x8c";
1801                         } elseif ( $code < 0xd558 ) {
1802                                 return "\xe3\x85\x8d";
1803                         } else {
1804                                 return "\xe3\x85\x8e";
1805                         }
1806                 } else {
1807                         return "";
1808                 }
1809         }
1810
1811         function initEncoding() {
1812                 # Some languages may have an alternate char encoding option
1813                 # (Esperanto X-coding, Japanese furigana conversion, etc)
1814                 # If this language is used as the primary content language,
1815                 # an override to the defaults can be set here on startup.
1816         }
1817
1818         function recodeForEdit( $s ) {
1819                 # For some languages we'll want to explicitly specify
1820                 # which characters make it into the edit box raw
1821                 # or are converted in some way or another.
1822                 # Note that if wgOutputEncoding is different from
1823                 # wgInputEncoding, this text will be further converted
1824                 # to wgOutputEncoding.
1825                 global $wgEditEncoding;
1826                 if( $wgEditEncoding == '' or
1827                   $wgEditEncoding == 'UTF-8' ) {
1828                         return $s;
1829                 } else {
1830                         return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
1831                 }
1832         }
1833
1834         function recodeInput( $s ) {
1835                 # Take the previous into account.
1836                 global $wgEditEncoding;
1837                 if($wgEditEncoding != "") {
1838                         $enc = $wgEditEncoding;
1839                 } else {
1840                         $enc = 'UTF-8';
1841                 }
1842                 if( $enc == 'UTF-8' ) {
1843                         return $s;
1844                 } else {
1845                         return $this->iconv( $enc, 'UTF-8', $s );
1846                 }
1847         }
1848
1849         /**
1850          * For right-to-left language support
1851          *
1852          * @return bool
1853          */
1854         function isRTL() {
1855                 return self::$dataCache->getItem( $this->mCode, 'rtl' );
1856         }
1857
1858         /**
1859          * A hidden direction mark (LRM or RLM), depending on the language direction
1860          *
1861          * @return string
1862          */
1863         function getDirMark() {
1864                 return $this->isRTL() ? "\xE2\x80\x8F" : "\xE2\x80\x8E";
1865         }
1866
1867         function capitalizeAllNouns() {
1868                 return self::$dataCache->getItem( $this->mCode, 'capitalizeAllNouns' );
1869         }
1870
1871         /**
1872          * An arrow, depending on the language direction
1873          *
1874          * @return string
1875          */
1876         function getArrow() {
1877                 return $this->isRTL() ? '←' : '→';
1878         }
1879
1880         /**
1881          * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
1882          *
1883          * @return bool
1884          */
1885         function linkPrefixExtension() {
1886                 return self::$dataCache->getItem( $this->mCode, 'linkPrefixExtension' );
1887         }
1888
1889         function getMagicWords() {
1890                 return self::$dataCache->getItem( $this->mCode, 'magicWords' );
1891         }
1892
1893         # Fill a MagicWord object with data from here
1894         function getMagic( &$mw ) {
1895                 if ( !$this->mMagicHookDone ) {
1896                         $this->mMagicHookDone = true;
1897                         wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
1898                 }
1899                 if ( isset( $this->mMagicExtensions[$mw->mId] ) ) {
1900                         $rawEntry = $this->mMagicExtensions[$mw->mId];
1901                 } else {
1902                         $magicWords = $this->getMagicWords();
1903                         if ( isset( $magicWords[$mw->mId] ) ) {
1904                                 $rawEntry = $magicWords[$mw->mId];
1905                         } else {
1906                                 $rawEntry = false;
1907                         }
1908                 }
1909
1910                 if( !is_array( $rawEntry ) ) {
1911                         error_log( "\"$rawEntry\" is not a valid magic thingie for \"$mw->mId\"" );
1912                 } else {
1913                         $mw->mCaseSensitive = $rawEntry[0];
1914                         $mw->mSynonyms = array_slice( $rawEntry, 1 );
1915                 }
1916         }
1917
1918         /**
1919          * Add magic words to the extension array
1920          */
1921         function addMagicWordsByLang( $newWords ) {
1922                 $code = $this->getCode();
1923                 $fallbackChain = array();
1924                 while ( $code && !in_array( $code, $fallbackChain ) ) {
1925                         $fallbackChain[] = $code;
1926                         $code = self::getFallbackFor( $code );
1927                 }
1928                 if ( !in_array( 'en', $fallbackChain ) ) {
1929                         $fallbackChain[] = 'en';
1930                 }
1931                 $fallbackChain = array_reverse( $fallbackChain );
1932                 foreach ( $fallbackChain as $code ) {
1933                         if ( isset( $newWords[$code] ) ) {
1934                                 $this->mMagicExtensions = $newWords[$code] + $this->mMagicExtensions;
1935                         }
1936                 }
1937         }
1938
1939         /**
1940          * Get special page names, as an associative array
1941          *   case folded alias => real name
1942          */
1943         function getSpecialPageAliases() {
1944                 // Cache aliases because it may be slow to load them
1945                 if ( is_null( $this->mExtendedSpecialPageAliases ) ) {
1946                         // Initialise array
1947                         $this->mExtendedSpecialPageAliases =
1948                                 self::$dataCache->getItem( $this->mCode, 'specialPageAliases' );
1949                         wfRunHooks( 'LanguageGetSpecialPageAliases',
1950                                 array( &$this->mExtendedSpecialPageAliases, $this->getCode() ) );
1951                 }
1952
1953                 return $this->mExtendedSpecialPageAliases;
1954         }
1955
1956         /**
1957          * Italic is unsuitable for some languages
1958          *
1959          * @param $text String: the text to be emphasized.
1960          * @return string
1961          */
1962         function emphasize( $text ) {
1963                 return "<em>$text</em>";
1964         }
1965
1966          /**
1967           * Normally we output all numbers in plain en_US style, that is
1968           * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
1969           * point twohundredthirtyfive. However this is not sutable for all
1970           * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
1971           * Icelandic just want to use commas instead of dots, and dots instead
1972           * of commas like "293.291,235".
1973           *
1974           * An example of this function being called:
1975           * <code>
1976           * wfMsg( 'message', $wgLang->formatNum( $num ) )
1977           * </code>
1978           *
1979           * See LanguageGu.php for the Gujarati implementation and
1980           * $separatorTransformTable on MessageIs.php for
1981           * the , => . and . => , implementation.
1982           *
1983           * @todo check if it's viable to use localeconv() for the decimal
1984           *       separator thing.
1985           * @param $number Mixed: the string to be formatted, should be an integer
1986           *        or a floating point number.
1987           * @param $nocommafy Bool: set to true for special numbers like dates
1988           * @return string
1989           */
1990         function formatNum( $number, $nocommafy = false ) {
1991                 global $wgTranslateNumerals;
1992                 if (!$nocommafy) {
1993                         $number = $this->commafy($number);
1994                         $s = $this->separatorTransformTable();
1995                         if ($s) { $number = strtr($number, $s); }
1996                 }
1997
1998                 if ($wgTranslateNumerals) {
1999                         $s = $this->digitTransformTable();
2000                         if ($s) { $number = strtr($number, $s); }
2001                 }
2002
2003                 return $number;
2004         }
2005
2006         function parseFormattedNumber( $number ) {
2007                 $s = $this->digitTransformTable();
2008                 if ($s) { $number = strtr($number, array_flip($s)); }
2009
2010                 $s = $this->separatorTransformTable();
2011                 if ($s) { $number = strtr($number, array_flip($s)); }
2012
2013                 $number = strtr( $number, array (',' => '') );
2014                 return $number;
2015         }
2016
2017         /**
2018          * Adds commas to a given number
2019          *
2020          * @param $_ mixed
2021          * @return string
2022          */
2023         function commafy($_) {
2024                 return strrev((string)preg_replace('/(\d{3})(?=\d)(?!\d*\.)/','$1,',strrev($_)));
2025         }
2026
2027         function digitTransformTable() {
2028                 return self::$dataCache->getItem( $this->mCode, 'digitTransformTable' );
2029         }
2030
2031         function separatorTransformTable() {
2032                 return self::$dataCache->getItem( $this->mCode, 'separatorTransformTable' );
2033         }
2034
2035
2036         /**
2037          * Take a list of strings and build a locale-friendly comma-separated
2038          * list, using the local comma-separator message.
2039          * The last two strings are chained with an "and".
2040          *
2041          * @param $l Array
2042          * @return string
2043          */
2044         function listToText( $l ) {
2045                 $s = '';
2046                 $m = count( $l ) - 1;
2047                 if( $m == 1 ) {
2048                         return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2049                 }
2050                 else {
2051                         for ( $i = $m; $i >= 0; $i-- ) {
2052                                 if ( $i == $m ) {
2053                                         $s = $l[$i];
2054                                 } else if( $i == $m - 1 ) {
2055                                         $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2056                                 } else {
2057                                         $s = $l[$i] . $this->getMessageFromDB( 'comma-separator' ) . $s;
2058                                 }
2059                         }
2060                         return $s;
2061                 }
2062         }
2063
2064         /**
2065          * Take a list of strings and build a locale-friendly comma-separated
2066          * list, using the local comma-separator message.
2067          * @param $list array of strings to put in a comma list
2068          * @return string
2069          */
2070         function commaList( $list ) {
2071                 return implode(
2072                         $list,
2073                         wfMsgExt( 'comma-separator', array( 'parsemag', 'escapenoentities', 'language' => $this ) ) );
2074         }
2075
2076         /**
2077          * Take a list of strings and build a locale-friendly semicolon-separated
2078          * list, using the local semicolon-separator message.
2079          * @param $list array of strings to put in a semicolon list
2080          * @return string
2081          */
2082         function semicolonList( $list ) {
2083                 return implode(
2084                         $list,
2085                         wfMsgExt( 'semicolon-separator', array( 'parsemag', 'escapenoentities', 'language' => $this ) ) );
2086         }
2087
2088         /**
2089          * Same as commaList, but separate it with the pipe instead.
2090          * @param $list array of strings to put in a pipe list
2091          * @return string
2092          */
2093         function pipeList( $list ) {
2094                 return implode(
2095                         $list,
2096                         wfMsgExt( 'pipe-separator', array( 'escapenoentities', 'language' => $this ) ) );
2097         }
2098
2099         /**
2100          * Truncate a string to a specified length in bytes, appending an optional
2101          * string (e.g. for ellipses)
2102          *
2103          * The database offers limited byte lengths for some columns in the database;
2104          * multi-byte character sets mean we need to ensure that only whole characters
2105          * are included, otherwise broken characters can be passed to the user
2106          *
2107          * If $length is negative, the string will be truncated from the beginning
2108          *
2109          * @param $string String to truncate
2110          * @param $length Int: maximum length (excluding ellipses)
2111          * @param $ellipsis String to append to the truncated text
2112          * @return string
2113          */
2114         function truncate( $string, $length, $ellipsis = '...' ) {
2115                 # Use the localized ellipsis character
2116                 if( $ellipsis == '...' ) {
2117                         $ellipsis = wfMsgExt( 'ellipsis', array( 'escapenoentities', 'language' => $this ) );
2118                 }
2119
2120                 if( $length == 0 ) {
2121                         return $ellipsis;
2122                 }
2123                 if ( strlen( $string ) <= abs( $length ) ) {
2124                         return $string;
2125                 }
2126                 if( $length > 0 ) {
2127                         $string = substr( $string, 0, $length );
2128                         $char = ord( $string[strlen( $string ) - 1] );
2129                         $m = array();
2130                         if ($char >= 0xc0) {
2131                                 # We got the first byte only of a multibyte char; remove it.
2132                                 $string = substr( $string, 0, -1 );
2133                         } elseif( $char >= 0x80 &&
2134                                   preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
2135                                               '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
2136                                 # We chopped in the middle of a character; remove it
2137                                 $string = $m[1];
2138                         }
2139                         return $string . $ellipsis;
2140                 } else {
2141                         $string = substr( $string, $length );
2142                         $char = ord( $string[0] );
2143                         if( $char >= 0x80 && $char < 0xc0 ) {
2144                                 # We chopped in the middle of a character; remove the whole thing
2145                                 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
2146                         }
2147                         return $ellipsis . $string;
2148                 }
2149         }
2150
2151         /**
2152          * Grammatical transformations, needed for inflected languages
2153          * Invoked by putting {{grammar:case|word}} in a message
2154          *
2155          * @param $word string
2156          * @param $case string
2157          * @return string
2158          */
2159         function convertGrammar( $word, $case ) {
2160                 global $wgGrammarForms;
2161                 if ( isset($wgGrammarForms[$this->getCode()][$case][$word]) ) {
2162                         return $wgGrammarForms[$this->getCode()][$case][$word];
2163                 }
2164                 return $word;
2165         }
2166
2167         /**
2168          * Provides an alternative text depending on specified gender.
2169          * Usage {{gender:username|masculine|feminine|neutral}}.
2170          * username is optional, in which case the gender of current user is used,
2171          * but only in (some) interface messages; otherwise default gender is used.
2172          * If second or third parameter are not specified, masculine is used.
2173          * These details may be overriden per language.
2174          */
2175         function gender( $gender, $forms ) {
2176                 if ( !count($forms) ) { return ''; }
2177                 $forms = $this->preConvertPlural( $forms, 2 );
2178                 if ( $gender === 'male' ) return $forms[0];
2179                 if ( $gender === 'female' ) return $forms[1];
2180                 return isset($forms[2]) ? $forms[2] : $forms[0];
2181         }
2182
2183         /**
2184          * Plural form transformations, needed for some languages.
2185          * For example, there are 3 form of plural in Russian and Polish,
2186          * depending on "count mod 10". See [[w:Plural]]
2187          * For English it is pretty simple.
2188          *
2189          * Invoked by putting {{plural:count|wordform1|wordform2}}
2190          * or {{plural:count|wordform1|wordform2|wordform3}}
2191          *
2192          * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2193          *
2194          * @param $count Integer: non-localized number
2195          * @param $forms Array: different plural forms
2196          * @return string Correct form of plural for $count in this language
2197          */
2198         function convertPlural( $count, $forms ) {
2199                 if ( !count($forms) ) { return ''; }
2200                 $forms = $this->preConvertPlural( $forms, 2 );
2201
2202                 return ( $count == 1 ) ? $forms[0] : $forms[1];
2203         }
2204
2205         /**
2206          * Checks that convertPlural was given an array and pads it to requested
2207          * amound of forms by copying the last one.
2208          *
2209          * @param $count Integer: How many forms should there be at least
2210          * @param $forms Array of forms given to convertPlural
2211          * @return array Padded array of forms or an exception if not an array
2212          */
2213         protected function preConvertPlural( /* Array */ $forms, $count ) {
2214                 while ( count($forms) < $count ) {
2215                         $forms[] = $forms[count($forms)-1];
2216                 }
2217                 return $forms;
2218         }
2219
2220         /**
2221          * For translaing of expiry times
2222          * @param $str String: the validated block time in English
2223          * @return Somehow translated block time
2224          * @see LanguageFi.php for example implementation
2225          */
2226         function translateBlockExpiry( $str ) {
2227
2228                 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
2229
2230                 if ( $scBlockExpiryOptions == '-') {
2231                         return $str;
2232                 }
2233
2234                 foreach (explode(',', $scBlockExpiryOptions) as $option) {
2235                         if ( strpos($option, ":") === false )
2236                                 continue;
2237                         list($show, $value) = explode(":", $option);
2238                         if ( strcmp ( $str, $value) == 0 ) {
2239                                 return htmlspecialchars( trim( $show ) );
2240                         }
2241                 }
2242
2243                 return $str;
2244         }
2245
2246         /**
2247          * languages like Chinese need to be segmented in order for the diff
2248          * to be of any use
2249          *
2250          * @param $text String
2251          * @return String
2252          */
2253         function segmentForDiff( $text ) {
2254                 return $text;
2255         }
2256
2257         /**
2258          * and unsegment to show the result
2259          *
2260          * @param $text String
2261          * @return String
2262          */
2263         function unsegmentForDiff( $text ) {
2264                 return $text;
2265         }
2266
2267         # convert text to all supported variants
2268         function autoConvertToAllVariants($text) {
2269                 return $this->mConverter->autoConvertToAllVariants($text);
2270         }
2271
2272         # convert text to different variants of a language.
2273         function convert( $text, $isTitle = false) {
2274                 return $this->mConverter->convert($text, $isTitle);
2275         }
2276
2277         # Convert text from within Parser
2278         function parserConvert( $text, &$parser ) {
2279                 return $this->mConverter->parserConvert( $text, $parser );
2280         }
2281
2282         # Check if this is a language with variants
2283         function hasVariants(){
2284                 return sizeof($this->getVariants())>1;
2285         }
2286
2287         # Put custom tags (e.g. -{ }-) around math to prevent conversion
2288         function armourMath($text){
2289                 return $this->mConverter->armourMath($text);
2290         }
2291
2292
2293         /**
2294          * Perform output conversion on a string, and encode for safe HTML output.
2295          * @param $text String
2296          * @param $isTitle Bool -- wtf?
2297          * @return string
2298          * @todo this should get integrated somewhere sane
2299          */
2300         function convertHtml( $text, $isTitle = false ) {
2301                 return htmlspecialchars( $this->convert( $text, $isTitle ) );
2302         }
2303
2304         function convertCategoryKey( $key ) {
2305                 return $this->mConverter->convertCategoryKey( $key );
2306         }
2307
2308         /**
2309          * get the list of variants supported by this langauge
2310          * see sample implementation in LanguageZh.php
2311          *
2312          * @return array an array of language codes
2313          */
2314         function getVariants() {
2315                 return $this->mConverter->getVariants();
2316         }
2317
2318
2319         function getPreferredVariant( $fromUser = true ) {
2320                 return $this->mConverter->getPreferredVariant( $fromUser );
2321         }
2322
2323         /**
2324          * if a language supports multiple variants, it is
2325          * possible that non-existing link in one variant
2326          * actually exists in another variant. this function
2327          * tries to find it. See e.g. LanguageZh.php
2328          *
2329          * @param $link String: the name of the link
2330          * @param $nt Mixed: the title object of the link
2331          * @param boolean $ignoreOtherCond: to disable other conditions when
2332          *      we need to transclude a template or update a category's link
2333          * @return null the input parameters may be modified upon return
2334          */
2335         function findVariantLink( &$link, &$nt, $ignoreOtherCond = false ) {
2336                 $this->mConverter->findVariantLink( $link, $nt, $ignoreOtherCond );
2337         }
2338
2339         /**
2340          * If a language supports multiple variants, converts text
2341          * into an array of all possible variants of the text:
2342          *  'variant' => text in that variant
2343          */
2344         function convertLinkToAllVariants($text){
2345                 return $this->mConverter->convertLinkToAllVariants($text);
2346         }
2347
2348
2349         /**
2350          * returns language specific options used by User::getPageRenderHash()
2351          * for example, the preferred language variant
2352          *
2353          * @return string
2354          */
2355         function getExtraHashOptions() {
2356                 return $this->mConverter->getExtraHashOptions();
2357         }
2358
2359         /**
2360          * for languages that support multiple variants, the title of an
2361          * article may be displayed differently in different variants. this
2362          * function returns the apporiate title defined in the body of the article.
2363          *
2364          * @return string
2365          */
2366         function getParsedTitle() {
2367                 return $this->mConverter->getParsedTitle();
2368         }
2369
2370         /**
2371          * Enclose a string with the "no conversion" tag. This is used by
2372          * various functions in the Parser
2373          *
2374          * @param $text String: text to be tagged for no conversion
2375          * @param $noParse
2376          * @return string the tagged text
2377          */
2378         function markNoConversion( $text, $noParse=false ) {
2379                 return $this->mConverter->markNoConversion( $text, $noParse );
2380         }
2381
2382         /**
2383          * A regular expression to match legal word-trailing characters
2384          * which should be merged onto a link of the form [[foo]]bar.
2385          *
2386          * @return string
2387          */
2388         function linkTrail() {
2389                 return self::$dataCache->getItem( $this->mCode, 'linkTrail' );
2390         }
2391
2392         function getLangObj() {
2393                 return $this;
2394         }
2395
2396         /**
2397          * Get the RFC 3066 code for this language object
2398          */
2399         function getCode() {
2400                 return $this->mCode;
2401         }
2402
2403         function setCode( $code ) {
2404                 $this->mCode = $code;
2405         }
2406
2407         static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
2408                 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
2409         }
2410
2411         static function getMessagesFileName( $code ) {
2412                 global $IP;
2413                 return self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
2414         }
2415
2416         static function getClassFileName( $code ) {
2417                 global $IP;
2418                 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
2419         }
2420
2421         /**
2422          * Get the fallback for a given language
2423          */
2424         static function getFallbackFor( $code ) {
2425                 if ( $code === 'en' ) {
2426                         // Shortcut
2427                         return false;
2428                 } else {
2429                         return self::getLocalisationCache()->getItem( $code, 'fallback' );
2430                 }
2431         }
2432
2433         /**
2434          * Get all messages for a given language
2435          * WARNING: this may take a long time
2436          */
2437         static function getMessagesFor( $code ) {
2438                 return self::getLocalisationCache()->getItem( $code, 'messages' );
2439         }
2440
2441         /**
2442          * Get a message for a given language
2443          */
2444         static function getMessageFor( $key, $code ) {
2445                 return self::getLocalisationCache()->getSubitem( $code, 'messages', $key );
2446         }
2447
2448         function fixVariableInNamespace( $talk ) {
2449                 if ( strpos( $talk, '$1' ) === false ) return $talk;
2450
2451                 global $wgMetaNamespace;
2452                 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
2453
2454                 # Allow grammar transformations
2455                 # Allowing full message-style parsing would make simple requests
2456                 # such as action=raw much more expensive than they need to be.
2457                 # This will hopefully cover most cases.
2458                 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
2459                         array( &$this, 'replaceGrammarInNamespace' ), $talk );
2460                 return str_replace( ' ', '_', $talk );
2461         }
2462
2463         function replaceGrammarInNamespace( $m ) {
2464                 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
2465         }
2466
2467         static function getCaseMaps() {
2468                 static $wikiUpperChars, $wikiLowerChars;
2469                 if ( isset( $wikiUpperChars ) ) {
2470                         return array( $wikiUpperChars, $wikiLowerChars );
2471                 }
2472
2473                 wfProfileIn( __METHOD__ );
2474                 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
2475                 if ( $arr === false ) {
2476                         throw new MWException(
2477                                 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
2478                 }
2479                 extract( $arr );
2480                 wfProfileOut( __METHOD__ );
2481                 return array( $wikiUpperChars, $wikiLowerChars );
2482         }
2483
2484         function formatTimePeriod( $seconds ) {
2485                 if ( $seconds < 10 ) {
2486                         return $this->formatNum( sprintf( "%.1f", $seconds ) ) . wfMsg( 'seconds-abbrev' );
2487                 } elseif ( $seconds < 60 ) {
2488                         return $this->formatNum( round( $seconds ) ) . wfMsg( 'seconds-abbrev' );
2489                 } elseif ( $seconds < 3600 ) {
2490                         return $this->formatNum( floor( $seconds / 60 ) ) . wfMsg( 'minutes-abbrev' ) .
2491                                 $this->formatNum( round( fmod( $seconds, 60 ) ) ) . wfMsg( 'seconds-abbrev' );
2492                 } else {
2493                         $hours = floor( $seconds / 3600 );
2494                         $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
2495                         $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
2496                         return $this->formatNum( $hours ) . wfMsg( 'hours-abbrev' ) .
2497                                 $this->formatNum( $minutes ) . wfMsg( 'minutes-abbrev' ) .
2498                                 $this->formatNum( $secondsPart ) . wfMsg( 'seconds-abbrev' );
2499                 }
2500         }
2501
2502         function formatBitrate( $bps ) {
2503                 $units = array( 'bps', 'kbps', 'Mbps', 'Gbps' );
2504                 if ( $bps <= 0 ) {
2505                         return $this->formatNum( $bps ) . $units[0];
2506                 }
2507                 $unitIndex = floor( log10( $bps ) / 3 );
2508                 $mantissa = $bps / pow( 1000, $unitIndex );
2509                 if ( $mantissa < 10 ) {
2510                         $mantissa = round( $mantissa, 1 );
2511                 } else {
2512                         $mantissa = round( $mantissa );
2513                 }
2514                 return $this->formatNum( $mantissa ) . $units[$unitIndex];
2515         }
2516
2517         /**
2518          * Format a size in bytes for output, using an appropriate
2519          * unit (B, KB, MB or GB) according to the magnitude in question
2520          *
2521          * @param $size Size to format
2522          * @return string Plain text (not HTML)
2523          */
2524         function formatSize( $size ) {
2525                 // For small sizes no decimal places necessary
2526                 $round = 0;
2527                 if( $size > 1024 ) {
2528                         $size = $size / 1024;
2529                         if( $size > 1024 ) {
2530                                 $size = $size / 1024;
2531                                 // For MB and bigger two decimal places are smarter
2532                                 $round = 2;
2533                                 if( $size > 1024 ) {
2534                                         $size = $size / 1024;
2535                                         $msg = 'size-gigabytes';
2536                                 } else {
2537                                         $msg = 'size-megabytes';
2538                                 }
2539                         } else {
2540                                 $msg = 'size-kilobytes';
2541                         }
2542                 } else {
2543                         $msg = 'size-bytes';
2544                 }
2545                 $size = round( $size, $round );
2546                 $text = $this->getMessageFromDB( $msg );
2547                 return str_replace( '$1', $this->formatNum( $size ), $text );
2548         }
2549 }