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          * For the credit list in includes/Credits.php (action=credits)
1942          *
1943          * @param $l Array
1944          * @return string
1945          */
1946         function listToText( $l ) {
1947                 $s = '';
1948                 $m = count($l) - 1;
1949                 for ($i = $m; $i >= 0; $i--) {
1950                         if ($i == $m) {
1951                                 $s = $l[$i];
1952                         } else if ($i == $m - 1) {
1953                                 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
1954                         } else {
1955                                 $s = $l[$i] . $this->getMessageFromDB( 'comma-separator' ) . $s;
1956                         }
1957                 }
1958                 return $s;
1959         }
1960
1961         /**
1962          * Take a list of strings and build a locale-friendly comma-separated
1963          * list, using the local comma-separator message.
1964          * @param $list array of strings to put in a comma list
1965          * @return string
1966          */
1967         function commaList( $list, $forContent = false ) {
1968                 return implode(
1969                         $list,
1970                         wfMsgExt( 'comma-separator', array( 'escapenoentities', 'language' => $this ) ) );
1971         }
1972
1973         /**
1974          * Same as commaList, but separate it with the pipe instead.
1975          * @param $list array of strings to put in a pipe list
1976          * @return string
1977          */
1978         function pipeList( $list ) {
1979                 return implode(
1980                         $list,
1981                         wfMsgExt( 'pipe-separator', array( 'escapenoentities', 'language' => $this ) ) );
1982         }
1983
1984         /**
1985          * Truncate a string to a specified length in bytes, appending an optional
1986          * string (e.g. for ellipses)
1987          *
1988          * The database offers limited byte lengths for some columns in the database;
1989          * multi-byte character sets mean we need to ensure that only whole characters
1990          * are included, otherwise broken characters can be passed to the user
1991          *
1992          * If $length is negative, the string will be truncated from the beginning
1993          *
1994          * @param $string String to truncate
1995          * @param $length Int: maximum length (excluding ellipses)
1996          * @param $ellipsis String to append to the truncated text
1997          * @return string
1998          */
1999         function truncate( $string, $length, $ellipsis = "" ) {
2000                 if( $length == 0 ) {
2001                         return $ellipsis;
2002                 }
2003                 if ( strlen( $string ) <= abs( $length ) ) {
2004                         return $string;
2005                 }
2006                 if( $length > 0 ) {
2007                         $string = substr( $string, 0, $length );
2008                         $char = ord( $string[strlen( $string ) - 1] );
2009                         $m = array();
2010                         if ($char >= 0xc0) {
2011                                 # We got the first byte only of a multibyte char; remove it.
2012                                 $string = substr( $string, 0, -1 );
2013                         } elseif( $char >= 0x80 &&
2014                                   preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
2015                                               '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
2016                             # We chopped in the middle of a character; remove it
2017                                 $string = $m[1];
2018                         }
2019                         return $string . $ellipsis;
2020                 } else {
2021                         $string = substr( $string, $length );
2022                         $char = ord( $string[0] );
2023                         if( $char >= 0x80 && $char < 0xc0 ) {
2024                                 # We chopped in the middle of a character; remove the whole thing
2025                                 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
2026                         }
2027                         return $ellipsis . $string;
2028                 }
2029         }
2030
2031         /**
2032          * Grammatical transformations, needed for inflected languages
2033          * Invoked by putting {{grammar:case|word}} in a message
2034          *
2035          * @param $word string
2036          * @param $case string
2037          * @return string
2038          */
2039         function convertGrammar( $word, $case ) {
2040                 global $wgGrammarForms;
2041                 if ( isset($wgGrammarForms[$this->getCode()][$case][$word]) ) {
2042                         return $wgGrammarForms[$this->getCode()][$case][$word];
2043                 }
2044                 return $word;
2045         }
2046
2047         /**
2048          * Plural form transformations, needed for some languages.
2049          * For example, there are 3 form of plural in Russian and Polish,
2050          * depending on "count mod 10". See [[w:Plural]]
2051          * For English it is pretty simple.
2052          *
2053          * Invoked by putting {{plural:count|wordform1|wordform2}}
2054          * or {{plural:count|wordform1|wordform2|wordform3}}
2055          *
2056          * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2057          *
2058          * @param $count Integer: non-localized number
2059          * @param $forms Array: different plural forms
2060          * @return string Correct form of plural for $count in this language
2061          */
2062         function convertPlural( $count, $forms ) {
2063                 if ( !count($forms) ) { return ''; }
2064                 $forms = $this->preConvertPlural( $forms, 2 );
2065
2066                 return ( $count == 1 ) ? $forms[0] : $forms[1];
2067         }
2068
2069         /**
2070          * Checks that convertPlural was given an array and pads it to requested
2071          * amound of forms by copying the last one.
2072          *
2073          * @param $count Integer: How many forms should there be at least
2074          * @param $forms Array of forms given to convertPlural
2075          * @return array Padded array of forms or an exception if not an array
2076          */
2077         protected function preConvertPlural( /* Array */ $forms, $count ) {
2078                 while ( count($forms) < $count ) {
2079                         $forms[] = $forms[count($forms)-1];
2080                 }
2081                 return $forms;
2082         }
2083
2084         /**
2085          * For translaing of expiry times
2086          * @param $str String: the validated block time in English
2087          * @return Somehow translated block time
2088          * @see LanguageFi.php for example implementation
2089          */
2090         function translateBlockExpiry( $str ) {
2091
2092                 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
2093
2094                 if ( $scBlockExpiryOptions == '-') {
2095                         return $str;
2096                 }
2097
2098                 foreach (explode(',', $scBlockExpiryOptions) as $option) {
2099                         if ( strpos($option, ":") === false )
2100                                 continue;
2101                         list($show, $value) = explode(":", $option);
2102                         if ( strcmp ( $str, $value) == 0 ) {
2103                                 return htmlspecialchars( trim( $show ) );
2104                         }
2105                 }
2106
2107                 return $str;
2108         }
2109
2110         /**
2111          * languages like Chinese need to be segmented in order for the diff
2112          * to be of any use
2113          *
2114          * @param $text String
2115          * @return String
2116          */
2117         function segmentForDiff( $text ) {
2118                 return $text;
2119         }
2120
2121         /**
2122          * and unsegment to show the result
2123          *
2124          * @param $text String
2125          * @return String
2126          */
2127         function unsegmentForDiff( $text ) {
2128                 return $text;
2129         }
2130
2131         # convert text to different variants of a language.
2132         function convert( $text, $isTitle = false) {
2133                 return $this->mConverter->convert($text, $isTitle);
2134         }
2135
2136         # Convert text from within Parser
2137         function parserConvert( $text, &$parser ) {
2138                 return $this->mConverter->parserConvert( $text, $parser );
2139         }
2140
2141         # Check if this is a language with variants
2142         function hasVariants(){
2143                 return sizeof($this->getVariants())>1;
2144         }
2145
2146         # Put custom tags (e.g. -{ }-) around math to prevent conversion
2147         function armourMath($text){
2148                 return $this->mConverter->armourMath($text);
2149         }
2150
2151
2152         /**
2153          * Perform output conversion on a string, and encode for safe HTML output.
2154          * @param $text String
2155          * @param $isTitle Bool -- wtf?
2156          * @return string
2157          * @todo this should get integrated somewhere sane
2158          */
2159         function convertHtml( $text, $isTitle = false ) {
2160                 return htmlspecialchars( $this->convert( $text, $isTitle ) );
2161         }
2162
2163         function convertCategoryKey( $key ) {
2164                 return $this->mConverter->convertCategoryKey( $key );
2165         }
2166
2167         /**
2168          * get the list of variants supported by this langauge
2169          * see sample implementation in LanguageZh.php
2170          *
2171          * @return array an array of language codes
2172          */
2173         function getVariants() {
2174                 return $this->mConverter->getVariants();
2175         }
2176
2177
2178         function getPreferredVariant( $fromUser = true ) {
2179                 return $this->mConverter->getPreferredVariant( $fromUser );
2180         }
2181
2182         /**
2183          * if a language supports multiple variants, it is
2184          * possible that non-existing link in one variant
2185          * actually exists in another variant. this function
2186          * tries to find it. See e.g. LanguageZh.php
2187          *
2188          * @param $link String: the name of the link
2189          * @param $nt Mixed: the title object of the link
2190          * @return null the input parameters may be modified upon return
2191          */
2192         function findVariantLink( &$link, &$nt, $forTemplate = false ) {
2193                 $this->mConverter->findVariantLink($link, $nt, $forTemplate );
2194         }
2195
2196         /**
2197          * If a language supports multiple variants, converts text
2198          * into an array of all possible variants of the text:
2199          *  'variant' => text in that variant
2200          */
2201
2202         function convertLinkToAllVariants($text){
2203                 return $this->mConverter->convertLinkToAllVariants($text);
2204         }
2205
2206
2207         /**
2208          * returns language specific options used by User::getPageRenderHash()
2209          * for example, the preferred language variant
2210          *
2211          * @return string
2212          */
2213         function getExtraHashOptions() {
2214                 return $this->mConverter->getExtraHashOptions();
2215         }
2216
2217         /**
2218          * for languages that support multiple variants, the title of an
2219          * article may be displayed differently in different variants. this
2220          * function returns the apporiate title defined in the body of the article.
2221          *
2222          * @return string
2223          */
2224         function getParsedTitle() {
2225                 return $this->mConverter->getParsedTitle();
2226         }
2227
2228         /**
2229          * Enclose a string with the "no conversion" tag. This is used by
2230          * various functions in the Parser
2231          *
2232          * @param $text String: text to be tagged for no conversion
2233          * @param $noParse
2234          * @return string the tagged text
2235          */
2236         function markNoConversion( $text, $noParse=false ) {
2237                 return $this->mConverter->markNoConversion( $text, $noParse );
2238         }
2239
2240         /**
2241          * A regular expression to match legal word-trailing characters
2242          * which should be merged onto a link of the form [[foo]]bar.
2243          *
2244          * @return string
2245          */
2246         function linkTrail() {
2247                 $this->load();
2248                 return $this->linkTrail;
2249         }
2250
2251         function getLangObj() {
2252                 return $this;
2253         }
2254
2255         /**
2256          * Get the RFC 3066 code for this language object
2257          */
2258         function getCode() {
2259                 return $this->mCode;
2260         }
2261
2262         function setCode( $code ) {
2263                 $this->mCode = $code;
2264         }
2265
2266         static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
2267                 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
2268         }
2269
2270         static function getMessagesFileName( $code ) {
2271                 global $IP;
2272                 return self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
2273         }
2274
2275         static function getClassFileName( $code ) {
2276                 global $IP;
2277                 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
2278         }
2279
2280         static function getLocalisationArray( $code, $disableCache = false ) {
2281                 self::loadLocalisation( $code, $disableCache );
2282                 return self::$mLocalisationCache[$code];
2283         }
2284
2285         /**
2286          * Load localisation data for a given code into the static cache
2287          *
2288          * @return array Dependencies, map of filenames to mtimes
2289          */
2290         static function loadLocalisation( $code, $disableCache = false ) {
2291                 static $recursionGuard = array();
2292                 global $wgMemc, $wgEnableSerializedMessages, $wgCheckSerialized;
2293
2294                 if ( !$code ) {
2295                         throw new MWException( "Invalid language code requested" );
2296                 }
2297
2298                 if ( !$disableCache ) {
2299                         # Try the per-process cache
2300                         if ( isset( self::$mLocalisationCache[$code] ) ) {
2301                                 return self::$mLocalisationCache[$code]['deps'];
2302                         }
2303
2304                         wfProfileIn( __METHOD__ );
2305
2306                         # Try the serialized directory
2307                         if( $wgEnableSerializedMessages ) {
2308                                 $cache = wfGetPrecompiledData( self::getFileName( "Messages", $code, '.ser' ) );
2309                                 if ( $cache ) {
2310                                         if ( $wgCheckSerialized && self::isLocalisationOutOfDate( $cache ) ) {
2311                                                 $cache = false;
2312                                                 wfDebug( "Language::loadLocalisation(): precompiled data file for $code is out of date\n" );
2313                                         } else {
2314                                                 self::$mLocalisationCache[$code] = $cache;
2315                                                 wfDebug( "Language::loadLocalisation(): got localisation for $code from precompiled data file\n" );
2316                                                 wfProfileOut( __METHOD__ );
2317                                                 return self::$mLocalisationCache[$code]['deps'];
2318                                         }
2319                                 }
2320                         }
2321
2322                         # Try the global cache
2323                         $memcKey = wfMemcKey('localisation', $code );
2324                         $fbMemcKey = wfMemcKey('fallback', $cache['fallback'] );
2325                         $cache = $wgMemc->get( $memcKey );
2326                         if ( $cache ) {
2327                                 if ( self::isLocalisationOutOfDate( $cache ) ) {
2328                                         $wgMemc->delete( $memcKey );
2329                                         $wgMemc->delete( $fbMemcKey );
2330                                         $cache = false;
2331                                         wfDebug( "Language::loadLocalisation(): localisation cache for $code had expired\n" );
2332                                 } else {
2333                                         self::$mLocalisationCache[$code] = $cache;
2334                                         wfDebug( "Language::loadLocalisation(): got localisation for $code from cache\n" );
2335                                         wfProfileOut( __METHOD__ );
2336                                         return $cache['deps'];
2337                                 }
2338                         }
2339                 } else {
2340                         wfProfileIn( __METHOD__ );
2341                 }
2342
2343                 # Default fallback, may be overridden when the messages file is included
2344                 if ( $code != 'en' ) {
2345                         $fallback = 'en';
2346                 } else {
2347                         $fallback = false;
2348                 }
2349
2350                 # Load the primary localisation from the source file
2351                 $filename = self::getMessagesFileName( $code );
2352                 if ( !file_exists( $filename ) ) {
2353                         wfDebug( "Language::loadLocalisation(): no localisation file for $code, using implicit fallback to en\n" );
2354                         $cache = compact( self::$mLocalisationKeys ); // Set correct fallback
2355                         $deps = array();
2356                 } else {
2357                         $deps = array( $filename => filemtime( $filename ) );
2358                         require( $filename );
2359                         $cache = compact( self::$mLocalisationKeys );
2360                         wfDebug( "Language::loadLocalisation(): got localisation for $code from source\n" );
2361                 }
2362
2363                 if ( !empty( $fallback ) ) {
2364                         # Load the fallback localisation, with a circular reference guard
2365                         if ( isset( $recursionGuard[$code] ) ) {
2366                                 throw new MWException( "Error: Circular fallback reference in language code $code" );
2367                         }
2368                         $recursionGuard[$code] = true;
2369                         $newDeps = self::loadLocalisation( $fallback, $disableCache );
2370                         unset( $recursionGuard[$code] );
2371
2372                         $secondary = self::$mLocalisationCache[$fallback];
2373                         $deps = array_merge( $deps, $newDeps );
2374
2375                         # Merge the fallback localisation with the current localisation
2376                         foreach ( self::$mLocalisationKeys as $key ) {
2377                                 if ( isset( $cache[$key] ) ) {
2378                                         if ( isset( $secondary[$key] ) ) {
2379                                                 if ( in_array( $key, self::$mMergeableMapKeys ) ) {
2380                                                         $cache[$key] = $cache[$key] + $secondary[$key];
2381                                                 } elseif ( in_array( $key, self::$mMergeableListKeys ) ) {
2382                                                         $cache[$key] = array_merge( $secondary[$key], $cache[$key] );
2383                                                 } elseif ( in_array( $key, self::$mMergeableAliasListKeys ) ) {
2384                                                         $cache[$key] = array_merge_recursive( $cache[$key], $secondary[$key] );
2385                                                 }
2386                                         }
2387                                 } else {
2388                                         $cache[$key] = $secondary[$key];
2389                                 }
2390                         }
2391
2392                         # Merge bookstore lists if requested
2393                         if ( !empty( $cache['bookstoreList']['inherit'] ) ) {
2394                                 $cache['bookstoreList'] = array_merge( $cache['bookstoreList'], $secondary['bookstoreList'] );
2395                         }
2396                         if ( isset( $cache['bookstoreList']['inherit'] ) ) {
2397                                 unset( $cache['bookstoreList']['inherit'] );
2398                         }
2399                 }
2400
2401                 # Add dependencies to the cache entry
2402                 $cache['deps'] = $deps;
2403
2404                 # Replace spaces with underscores in namespace names
2405                 $cache['namespaceNames'] = str_replace( ' ', '_', $cache['namespaceNames'] );
2406
2407                 # And do the same for specialpage aliases. $page is an array.
2408                 foreach ( $cache['specialPageAliases'] as &$page ) {
2409                         $page = str_replace( ' ', '_', $page );
2410                 }
2411                 # Decouple the reference to prevent accidental damage
2412                 unset($page);
2413
2414                 # Save to both caches
2415                 self::$mLocalisationCache[$code] = $cache;
2416                 if ( !$disableCache ) {
2417                         $wgMemc->set( $memcKey, $cache );
2418                         $wgMemc->set( $fbMemcKey, (string) $cache['fallback'] );
2419                 }
2420
2421                 wfProfileOut( __METHOD__ );
2422                 return $deps;
2423         }
2424
2425         /**
2426          * Test if a given localisation cache is out of date with respect to the
2427          * source Messages files. This is done automatically for the global cache
2428          * in $wgMemc, but is only done on certain occasions for the serialized
2429          * data file.
2430          *
2431          * @param $cache mixed Either a language code or a cache array
2432          */
2433         static function isLocalisationOutOfDate( $cache ) {
2434                 if ( !is_array( $cache ) ) {
2435                         self::loadLocalisation( $cache );
2436                         $cache = self::$mLocalisationCache[$cache];
2437                 }
2438                 $expired = false;
2439                 foreach ( $cache['deps'] as $file => $mtime ) {
2440                         if ( !file_exists( $file ) || filemtime( $file ) > $mtime ) {
2441                                 $expired = true;
2442                                 break;
2443                         }
2444                 }
2445                 return $expired;
2446         }
2447
2448         /**
2449          * Get the fallback for a given language
2450          */
2451         static function getFallbackFor( $code ) {
2452                 // Shortcut
2453                 if ( $code === 'en' ) return false;
2454
2455                 // Local cache
2456                 static $cache = array();
2457                 // Quick return
2458                 if ( isset($cache[$code]) ) return $cache[$code];
2459
2460                 // Try memcache
2461                 global $wgMemc;
2462                 $memcKey = wfMemcKey( 'fallback', $code );
2463                 $fbcode = $wgMemc->get( $memcKey );
2464
2465                 if ( is_string($fbcode) ) {
2466                         // False is stored as a string to detect failures in memcache properly
2467                         if ( $fbcode === '' ) $fbcode = false;
2468
2469                         // Update local cache and return
2470                         $cache[$code] = $fbcode;
2471                         return $fbcode;
2472                 }
2473
2474                 // Nothing in caches, load and and update both caches
2475                 self::loadLocalisation( $code );
2476                 $fbcode = self::$mLocalisationCache[$code]['fallback'];
2477
2478                 $cache[$code] = $fbcode;
2479                 $wgMemc->set( $memcKey, (string) $fbcode );
2480
2481                 return $fbcode;
2482         }
2483
2484         /**
2485          * Get all messages for a given language
2486          */
2487         static function getMessagesFor( $code ) {
2488                 self::loadLocalisation( $code );
2489                 return self::$mLocalisationCache[$code]['messages'];
2490         }
2491
2492         /**
2493          * Get a message for a given language
2494          */
2495         static function getMessageFor( $key, $code ) {
2496                 self::loadLocalisation( $code );
2497                 return isset( self::$mLocalisationCache[$code]['messages'][$key] ) ? self::$mLocalisationCache[$code]['messages'][$key] : null;
2498         }
2499
2500         /**
2501          * Load localisation data for this object
2502          */
2503         function load() {
2504                 if ( !$this->mLoaded ) {
2505                         self::loadLocalisation( $this->getCode() );
2506                         $cache =& self::$mLocalisationCache[$this->getCode()];
2507                         foreach ( self::$mLocalisationKeys as $key ) {
2508                                 $this->$key = $cache[$key];
2509                         }
2510                         $this->mLoaded = true;
2511
2512                         $this->fixUpSettings();
2513                 }
2514         }
2515
2516         /**
2517          * Do any necessary post-cache-load settings adjustment
2518          */
2519         function fixUpSettings() {
2520                 global $wgExtraNamespaces, $wgMetaNamespace, $wgMetaNamespaceTalk,
2521                         $wgNamespaceAliases, $wgAmericanDates;
2522                 wfProfileIn( __METHOD__ );
2523                 if ( $wgExtraNamespaces ) {
2524                         $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames;
2525                 }
2526
2527                 $this->namespaceNames[NS_PROJECT] = $wgMetaNamespace;
2528                 if ( $wgMetaNamespaceTalk ) {
2529                         $this->namespaceNames[NS_PROJECT_TALK] = $wgMetaNamespaceTalk;
2530                 } else {
2531                         $talk = $this->namespaceNames[NS_PROJECT_TALK];
2532                         $talk = str_replace( '$1', $wgMetaNamespace, $talk );
2533
2534                         # Allow grammar transformations
2535                         # Allowing full message-style parsing would make simple requests
2536                         # such as action=raw much more expensive than they need to be.
2537                         # This will hopefully cover most cases.
2538                         $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
2539                                 array( &$this, 'replaceGrammarInNamespace' ), $talk );
2540                         $talk = str_replace( ' ', '_', $talk );
2541                         $this->namespaceNames[NS_PROJECT_TALK] = $talk;
2542                 }
2543
2544                 # The above mixing may leave namespaces out of canonical order.
2545                 # Re-order by namespace ID number...
2546                 ksort( $this->namespaceNames );
2547
2548                 # Put namespace names and aliases into a hashtable.
2549                 # If this is too slow, then we should arrange it so that it is done
2550                 # before caching. The catch is that at pre-cache time, the above
2551                 # class-specific fixup hasn't been done.
2552                 $this->mNamespaceIds = array();
2553                 foreach ( $this->namespaceNames as $index => $name ) {
2554                         $this->mNamespaceIds[$this->lc($name)] = $index;
2555                 }
2556                 if ( $this->namespaceAliases ) {
2557                         foreach ( $this->namespaceAliases as $name => $index ) {
2558                                 $this->mNamespaceIds[$this->lc($name)] = $index;
2559                         }
2560                 }
2561                 if ( $wgNamespaceAliases ) {
2562                         foreach ( $wgNamespaceAliases as $name => $index ) {
2563                                 $this->mNamespaceIds[$this->lc($name)] = $index;
2564                         }
2565                 }
2566
2567                 if ( $this->defaultDateFormat == 'dmy or mdy' ) {
2568                         $this->defaultDateFormat = $wgAmericanDates ? 'mdy' : 'dmy';
2569                 }
2570                 wfProfileOut( __METHOD__ );
2571         }
2572
2573         function replaceGrammarInNamespace( $m ) {
2574                 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
2575         }
2576
2577         static function getCaseMaps() {
2578                 static $wikiUpperChars, $wikiLowerChars;
2579                 if ( isset( $wikiUpperChars ) ) {
2580                         return array( $wikiUpperChars, $wikiLowerChars );
2581                 }
2582
2583                 wfProfileIn( __METHOD__ );
2584                 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
2585                 if ( $arr === false ) {
2586                         throw new MWException(
2587                                 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
2588                 }
2589                 extract( $arr );
2590                 wfProfileOut( __METHOD__ );
2591                 return array( $wikiUpperChars, $wikiLowerChars );
2592         }
2593
2594         function formatTimePeriod( $seconds ) {
2595                 if ( $seconds < 10 ) {
2596                         return $this->formatNum( sprintf( "%.1f", $seconds ) ) . wfMsg( 'seconds-abbrev' );
2597                 } elseif ( $seconds < 60 ) {
2598                         return $this->formatNum( round( $seconds ) ) . wfMsg( 'seconds-abbrev' );
2599                 } elseif ( $seconds < 3600 ) {
2600                         return $this->formatNum( floor( $seconds / 60 ) ) . wfMsg( 'minutes-abbrev' ) .
2601                                 $this->formatNum( round( fmod( $seconds, 60 ) ) ) . wfMsg( 'seconds-abbrev' );
2602                 } else {
2603                         $hours = floor( $seconds / 3600 );
2604                         $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
2605                         $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
2606                         return $this->formatNum( $hours ) . wfMsg( 'hours-abbrev' ) .
2607                                 $this->formatNum( $minutes ) . wfMsg( 'minutes-abbrev' ) .
2608                                 $this->formatNum( $secondsPart ) . wfMsg( 'seconds-abbrev' );
2609                 }
2610         }
2611
2612         function formatBitrate( $bps ) {
2613                 $units = array( 'bps', 'kbps', 'Mbps', 'Gbps' );
2614                 if ( $bps <= 0 ) {
2615                         return $this->formatNum( $bps ) . $units[0];
2616                 }
2617                 $unitIndex = floor( log10( $bps ) / 3 );
2618                 $mantissa = $bps / pow( 1000, $unitIndex );
2619                 if ( $mantissa < 10 ) {
2620                         $mantissa = round( $mantissa, 1 );
2621                 } else {
2622                         $mantissa = round( $mantissa );
2623                 }
2624                 return $this->formatNum( $mantissa ) . $units[$unitIndex];
2625         }
2626
2627         /**
2628          * Format a size in bytes for output, using an appropriate
2629          * unit (B, KB, MB or GB) according to the magnitude in question
2630          *
2631          * @param $size Size to format
2632          * @return string Plain text (not HTML)
2633          */
2634         function formatSize( $size ) {
2635                 // For small sizes no decimal places necessary
2636                 $round = 0;
2637                 if( $size > 1024 ) {
2638                         $size = $size / 1024;
2639                         if( $size > 1024 ) {
2640                                 $size = $size / 1024;
2641                                 // For MB and bigger two decimal places are smarter
2642                                 $round = 2;
2643                                 if( $size > 1024 ) {
2644                                         $size = $size / 1024;
2645                                         $msg = 'size-gigabytes';
2646                                 } else {
2647                                         $msg = 'size-megabytes';
2648                                 }
2649                         } else {
2650                                 $msg = 'size-kilobytes';
2651                         }
2652                 } else {
2653                         $msg = 'size-bytes';
2654                 }
2655                 $size = round( $size, $round );
2656                 $text = $this->getMessageFromDB( $msg );
2657                 return str_replace( '$1', $this->formatNum( $size ), $text );
2658         }
2659 }