languages/Language.php

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