languages/Language.php

   1 <?php
   2 /**
   3  * @package MediaWiki
   4  * @subpackage Language
   5  */
   6
   7 if( !defined( 'MEDIAWIKI' ) ) {
   8         echo "This file is part of MediaWiki, it is not a valid entry point.\n";
   9         exit( 1 );
  10 }
  11
  12 #
  13 # In general you should not make customizations in these language files
  14 # directly, but should use the MediaWiki: special namespace to customize
  15 # user interface messages through the wiki.
  16 # See http://meta.wikipedia.org/wiki/MediaWiki_namespace
  17 #
  18 # NOTE TO TRANSLATORS: Do not copy this whole file when making translations!
  19 # A lot of common constants and a base class with inheritable methods are
  20 # defined here, which should not be redefined. See the other LanguageXx.php
  21 # files for examples.
  22 #
  23
  24 # Read language names
  25 global $wgLanguageNames;
  26 require_once( 'Names.php' );
  27
  28 global $wgInputEncoding, $wgOutputEncoding;
  29
  30 /**
  31  * These are always UTF-8, they exist only for backwards compatibility
  32  */
  33 $wgInputEncoding    = "UTF-8";
  34 $wgOutputEncoding       = "UTF-8";
  35
  36 if( function_exists( 'mb_strtoupper' ) ) {
  37         mb_internal_encoding('UTF-8');
  38 }
  39
  40 /* a fake language converter */
  41 class FakeConverter {
  42         var $mLang;
  43         function FakeConverter($langobj) {$this->mLang = $langobj;}
  44         function convert($t, $i) {return $t;}
  45         function parserConvert($t, $p) {return $t;}
  46         function getVariants() { return array( $this->mLang->getCode() ); }
  47         function getPreferredVariant() {return $this->mLang->getCode(); }
  48         function findVariantLink(&$l, &$n) {}
  49         function getExtraHashOptions() {return '';}
  50         function getParsedTitle() {return '';}
  51         function markNoConversion($text, $noParse=false) {return $text;}
  52         function convertCategoryKey( $key ) {return $key; }
  53         function convertLinkToAllVariants($text){ return array( $this->mLang->getCode() => $text); }
  54         function armourMath($text){ return $text; }
  55 }
  56
  57 #--------------------------------------------------------------------------
  58 # Internationalisation code
  59 #--------------------------------------------------------------------------
  60
  61 class Language {
  62         var $mConverter, $mVariants, $mCode, $mLoaded = false;
  63
  64         static public $mLocalisationKeys = array( 'fallback', 'namespaceNames',
  65                 'quickbarSettings', 'skinNames', 'mathNames',
  66                 'bookstoreList', 'magicWords', 'messages', 'rtl', 'digitTransformTable',
  67                 'separatorTransformTable', 'fallback8bitEncoding', 'linkPrefixExtension',
  68                 'defaultUserOptionOverrides', 'linkTrail', 'namespaceAliases',
  69                 'dateFormats', 'datePreferences', 'datePreferenceMigrationMap',
  70                 'defaultDateFormat', 'extraUserToggles', 'specialPageAliases' );
  71
  72         static public $mMergeableMapKeys = array( 'messages', 'namespaceNames', 'mathNames',
  73                 'dateFormats', 'defaultUserOptionOverrides', 'magicWords' );
  74
  75         static public $mMergeableListKeys = array( 'extraUserToggles' );
  76
  77         static public $mMergeableAliasListKeys = array( 'specialPageAliases' );
  78
  79         static public $mLocalisationCache = array();
  80
  81         static public $mWeekdayMsgs = array(
  82                 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
  83                 'friday', 'saturday'
  84         );
  85
  86         static public $mWeekdayAbbrevMsgs = array(
  87                 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'
  88         );
  89
  90         static public $mMonthMsgs = array(
  91                 'january', 'february', 'march', 'april', 'may_long', 'june',
  92                 'july', 'august', 'september', 'october', 'november',
  93                 'december'
  94         );
  95         static public $mMonthGenMsgs = array(
  96                 'january-gen', 'february-gen', 'march-gen', 'april-gen', 'may-gen', 'june-gen',
  97                 'july-gen', 'august-gen', 'september-gen', 'october-gen', 'november-gen',
  98                 'december-gen'
  99         );
 100         static public $mMonthAbbrevMsgs = array(
 101                 'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
 102                 'sep', 'oct', 'nov', 'dec'
 103         );
 104
 105         /**
 106          * Create a language object for a given language code
 107          */
 108         static function factory( $code ) {
 109                 global $IP;
 110                 static $recursionLevel = 0;
 111
 112                 if ( $code == 'en' ) {
 113                         $class = 'Language';
 114                 } else {
 115                         $class = 'Language' . str_replace( '-', '_', ucfirst( $code ) );
 116                         // Preload base classes to work around APC/PHP5 bug
 117                         if ( file_exists( "$IP/languages/classes/$class.deps.php" ) ) {
 118                                 include_once("$IP/languages/classes/$class.deps.php");
 119                         }
 120                         if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
 121                                 include_once("$IP/languages/classes/$class.php");
 122                         }
 123                 }
 124
 125                 if ( $recursionLevel > 5 ) {
 126                         throw new MWException( "Language fallback loop detected when creating class $class\n" );
 127                 }
 128
 129                 if( ! class_exists( $class ) ) {
 130                         $fallback = Language::getFallbackFor( $code );
 131                         ++$recursionLevel;
 132                         $lang = Language::factory( $fallback );
 133                         --$recursionLevel;
 134                         $lang->setCode( $code );
 135                 } else {
 136                         $lang = new $class;
 137                 }
 138
 139                 return $lang;
 140         }
 141
 142         function __construct() {
 143                 $this->mConverter = new FakeConverter($this);
 144                 // Set the code to the name of the descendant
 145                 if ( get_class( $this ) == 'Language' ) {
 146                         $this->mCode = 'en';
 147                 } else {
 148                         $this->mCode = str_replace( '_', '-', strtolower( substr( get_class( $this ), 8 ) ) );
 149                 }
 150         }
 151
 152         /**
 153          * Hook which will be called if this is the content language.
 154          * Descendants can use this to register hook functions or modify globals
 155          */
 156         function initContLang() {}
 157
 158         /**
 159          * @deprecated
 160          * @return array
 161          */
 162         function getDefaultUserOptions() {
 163                 return User::getDefaultOptions();
 164         }
 165
 166         /**
 167          * Exports $wgBookstoreListEn
 168          * @return array
 169          */
 170         function getBookstoreList() {
 171                 $this->load();
 172                 return $this->bookstoreList;
 173         }
 174
 175         /**
 176          * @return array
 177          */
 178         function getNamespaces() {
 179                 $this->load();
 180                 return $this->namespaceNames;
 181         }
 182
 183         /**
 184          * A convenience function that returns the same thing as
 185          * getNamespaces() except with the array values changed to ' '
 186          * where it found '_', useful for producing output to be displayed
 187          * e.g. in <select> forms.
 188          *
 189          * @return array
 190          */
 191         function getFormattedNamespaces() {
 192                 $ns = $this->getNamespaces();
 193                 foreach($ns as $k => $v) {
 194                         $ns[$k] = strtr($v, '_', ' ');
 195                 }
 196                 return $ns;
 197         }
 198
 199         /**
 200          * Get a namespace value by key
 201          * <code>
 202          * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
 203          * echo $mw_ns; // prints 'MediaWiki'
 204          * </code>
 205          *
 206          * @param int $index the array key of the namespace to return
 207          * @return mixed, string if the namespace value exists, otherwise false
 208          */
 209         function getNsText( $index ) {
 210                 $ns = $this->getNamespaces();
 211                 return isset( $ns[$index] ) ? $ns[$index] : false;
 212         }
 213
 214         /**
 215          * A convenience function that returns the same thing as
 216          * getNsText() except with '_' changed to ' ', useful for
 217          * producing output.
 218          *
 219          * @return array
 220          */
 221         function getFormattedNsText( $index ) {
 222                 $ns = $this->getNsText( $index );
 223                 return strtr($ns, '_', ' ');
 224         }
 225
 226         /**
 227          * Get a namespace key by value, case insensetive.
 228          *
 229          * @param string $text
 230          * @return mixed An integer if $text is a valid value otherwise false
 231          */
 232         function getNsIndex( $text ) {
 233                 $this->load();
 234                 $lctext = $this->lc($text);
 235                 return isset( $this->mNamespaceIds[$lctext] ) ? $this->mNamespaceIds[$lctext] : false;
 236         }
 237
 238         /**
 239          * short names for language variants used for language conversion links.
 240          *
 241          * @param string $code
 242          * @return string
 243          */
 244         function getVariantname( $code ) {
 245                 return $this->getMessageFromDB( "variantname-$code" );
 246         }
 247
 248         function specialPage( $name ) {
 249                 $aliases = $this->getSpecialPageAliases();
 250                 if ( isset( $aliases[$name][0] ) ) {
 251                         $name = $aliases[$name][0];
 252                 }
 253                 return $this->getNsText(NS_SPECIAL) . ':' . $name;
 254         }
 255
 256         function getQuickbarSettings() {
 257                 $this->load();
 258                 return $this->quickbarSettings;
 259         }
 260
 261         function getSkinNames() {
 262                 $this->load();
 263                 return $this->skinNames;
 264         }
 265
 266         function getMathNames() {
 267                 $this->load();
 268                 return $this->mathNames;
 269         }
 270
 271         function getDatePreferences() {
 272                 $this->load();
 273                 return $this->datePreferences;
 274         }
 275
 276         function getDateFormats() {
 277                 $this->load();
 278                 return $this->dateFormats;
 279         }
 280
 281         function getDefaultDateFormat() {
 282                 $this->load();
 283                 return $this->defaultDateFormat;
 284         }
 285
 286         function getDatePreferenceMigrationMap() {
 287                 $this->load();
 288                 return $this->datePreferenceMigrationMap;
 289         }
 290
 291         function getDefaultUserOptionOverrides() {
 292                 $this->load();
 293                 return $this->defaultUserOptionOverrides;
 294         }
 295
 296         function getExtraUserToggles() {
 297                 $this->load();
 298                 return $this->extraUserToggles;
 299         }
 300
 301         function getUserToggle( $tog ) {
 302                 return $this->getMessageFromDB( "tog-$tog" );
 303         }
 304
 305         /**
 306          * Get language names, indexed by code.
 307          * If $customisedOnly is true, only returns codes with a messages file
 308          */
 309         public static function getLanguageNames( $customisedOnly = false ) {
 310                 global $wgLanguageNames;
 311                 if ( !$customisedOnly ) {
 312                         return $wgLanguageNames;
 313                 }
 314
 315                 global $IP;
 316                 $messageFiles = glob( "$IP/languages/messages/Messages*.php" );
 317                 $names = array();
 318                 foreach ( $messageFiles as $file ) {
 319                         if( preg_match( '/Messages([A-Z][a-z_]+)\.php$/', $file, $m ) ) {
 320                                 $code = str_replace( '_', '-', strtolower( $m[1] ) );
 321                                 if ( isset( $wgLanguageNames[$code] ) ) {
 322                                         $names[$code] = $wgLanguageNames[$code];
 323                                 }
 324                         }
 325                 }
 326                 return $names;
 327         }
 328
 329         /**
 330          * Ugly hack to get a message maybe from the MediaWiki namespace, if this
 331          * language object is the content or user language.
 332          */
 333         function getMessageFromDB( $msg ) {
 334                 global $wgContLang, $wgLang;
 335                 if ( $wgContLang->getCode() == $this->getCode() ) {
 336                         # Content language
 337                         return wfMsgForContent( $msg );
 338                 } elseif ( $wgLang->getCode() == $this->getCode() ) {
 339                         # User language
 340                         return wfMsg( $msg );
 341                 } else {
 342                         # Neither, get from localisation
 343                         return $this->getMessage( $msg );
 344                 }
 345         }
 346
 347         function getLanguageName( $code ) {
 348                 global $wgLanguageNames;
 349                 if ( ! array_key_exists( $code, $wgLanguageNames ) ) {
 350                         return '';
 351                 }
 352                 return $wgLanguageNames[$code];
 353         }
 354
 355         function getMonthName( $key ) {
 356                 return $this->getMessageFromDB( self::$mMonthMsgs[$key-1] );
 357         }
 358
 359         function getMonthNameGen( $key ) {
 360                 return $this->getMessageFromDB( self::$mMonthGenMsgs[$key-1] );
 361         }
 362
 363         function getMonthAbbreviation( $key ) {
 364                 return $this->getMessageFromDB( self::$mMonthAbbrevMsgs[$key-1] );
 365         }
 366
 367         function getWeekdayName( $key ) {
 368                 return $this->getMessageFromDB( self::$mWeekdayMsgs[$key-1] );
 369         }
 370
 371         function getWeekdayAbbreviation( $key ) {
 372                 return $this->getMessageFromDB( self::$mWeekdayAbbrevMsgs[$key-1] );
 373         }
 374
 375         /**
 376          * Used by date() and time() to adjust the time output.
 377          * @public
 378          * @param int   $ts the time in date('YmdHis') format
 379          * @param mixed $tz adjust the time by this amount (default false,
 380          *                  mean we get user timecorrection setting)
 381          * @return int
 382          */
 383         function userAdjust( $ts, $tz = false ) {
 384                 global $wgUser, $wgLocalTZoffset;
 385
 386                 if (!$tz) {
 387                         $tz = $wgUser->getOption( 'timecorrection' );
 388                 }
 389
 390                 # minutes and hours differences:
 391                 $minDiff = 0;
 392                 $hrDiff  = 0;
 393
 394                 if ( $tz === '' ) {
 395                         # Global offset in minutes.
 396                         if( isset($wgLocalTZoffset) ) {
 397                                 $hrDiff = $wgLocalTZoffset % 60;
 398                                 $minDiff = $wgLocalTZoffset - ($hrDiff * 60);
 399                         }
 400                 } elseif ( strpos( $tz, ':' ) !== false ) {
 401                         $tzArray = explode( ':', $tz );
 402                         $hrDiff = intval($tzArray[0]);
 403                         $minDiff = intval($hrDiff < 0 ? -$tzArray[1] : $tzArray[1]);
 404                 } else {
 405                         $hrDiff = intval( $tz );
 406                 }
 407
 408                 # No difference ? Return time unchanged
 409                 if ( 0 == $hrDiff && 0 == $minDiff ) { return $ts; }
 410
 411                 # Generate an adjusted date
 412                 $t = mktime( (
 413                   (int)substr( $ts, 8, 2) ) + $hrDiff, # Hours
 414                   (int)substr( $ts, 10, 2 ) + $minDiff, # Minutes
 415                   (int)substr( $ts, 12, 2 ), # Seconds
 416                   (int)substr( $ts, 4, 2 ), # Month
 417                   (int)substr( $ts, 6, 2 ), # Day
 418                   (int)substr( $ts, 0, 4 ) ); #Year
 419                 return date( 'YmdHis', $t );
 420         }
 421
 422         /**
 423          * This is a workalike of PHP's date() function, but with better
 424          * internationalisation, a reduced set of format characters, and a better
 425          * escaping format.
 426          *
 427          * Supported format characters are dDjlNwzWFmMntLYyaAgGhHiscrU. See the
 428          * PHP manual for definitions. There are a number of extensions, which
 429          * start with "x":
 430          *
 431          *    xn   Do not translate digits of the next numeric format character
 432          *    xN   Toggle raw digit (xn) flag, stays set until explicitly unset
 433          *    xr   Use roman numerals for the next numeric format character
 434          *    xx   Literal x
 435          *    xg   Genitive month name
 436          *
 437          * Characters enclosed in double quotes will be considered literal (with
 438          * the quotes themselves removed). Unmatched quotes will be considered
 439          * literal quotes. Example:
 440          *
 441          * "The month is" F       => The month is January
 442          * i's"                   => 20'11"
 443          *
 444          * Backslash escaping is also supported.
 445          *
 446          * @param string $format
 447          * @param string $ts 14-character timestamp
 448          *      YYYYMMDDHHMMSS
 449          *      01234567890123
 450          */
 451         function sprintfDate( $format, $ts ) {
 452                 $s = '';
 453                 $raw = false;
 454                 $roman = false;
 455                 $unix = false;
 456                 $rawToggle = false;
 457                 for ( $p = 0; $p < strlen( $format ); $p++ ) {
 458                         $num = false;
 459                         $code = $format[$p];
 460                         if ( $code == 'x' && $p < strlen( $format ) - 1 ) {
 461                                 $code .= $format[++$p];
 462                         }
 463
 464                         switch ( $code ) {
 465                                 case 'xx':
 466                                         $s .= 'x';
 467                                         break;
 468                                 case 'xn':
 469                                         $raw = true;
 470                                         break;
 471                                 case 'xN':
 472                                         $rawToggle = !$rawToggle;
 473                                         break;
 474                                 case 'xr':
 475                                         $roman = true;
 476                                         break;
 477                                 case 'xg':
 478                                         $s .= $this->getMonthNameGen( substr( $ts, 4, 2 ) );
 479                                         break;
 480                                 case 'd':
 481                                         $num = substr( $ts, 6, 2 );
 482                                         break;
 483                                 case 'D':
 484                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 485                                         $s .= $this->getWeekdayAbbreviation( date( 'w', $unix ) + 1 );
 486                                         break;
 487                                 case 'j':
 488                                         $num = intval( substr( $ts, 6, 2 ) );
 489                                         break;
 490                                 case 'l':
 491                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 492                                         $s .= $this->getWeekdayName( date( 'w', $unix ) + 1 );
 493                                         break;
 494                                 case 'N':
 495                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 496                                         $w = date( 'w', $unix );
 497                                         $num = $w ? $w : 7;
 498                                         break;
 499                                 case 'w':
 500                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 501                                         $num = date( 'w', $unix );
 502                                         break;
 503                                 case 'z':
 504                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 505                                         $num = date( 'z', $unix );
 506                                         break;
 507                                 case 'W':
 508                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 509                                         $num = date( 'W', $unix );
 510                                         break;
 511                                 case 'F':
 512                                         $s .= $this->getMonthName( substr( $ts, 4, 2 ) );
 513                                         break;
 514                                 case 'm':
 515                                         $num = substr( $ts, 4, 2 );
 516                                         break;
 517                                 case 'M':
 518                                         $s .= $this->getMonthAbbreviation( substr( $ts, 4, 2 ) );
 519                                         break;
 520                                 case 'n':
 521                                         $num = intval( substr( $ts, 4, 2 ) );
 522                                         break;
 523                                 case 't':
 524                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 525                                         $num = date( 't', $unix );
 526                                         break;
 527                                 case 'L':
 528                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 529                                         $num = date( 'L', $unix );
 530                                         break;
 531                                 case 'Y':
 532                                         $num = substr( $ts, 0, 4 );
 533                                         break;
 534                                 case 'y':
 535                                         $num = substr( $ts, 2, 2 );
 536                                         break;
 537                                 case 'a':
 538                                         $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'am' : 'pm';
 539                                         break;
 540                                 case 'A':
 541                                         $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'AM' : 'PM';
 542                                         break;
 543                                 case 'g':
 544                                         $h = substr( $ts, 8, 2 );
 545                                         $num = $h % 12 ? $h % 12 : 12;
 546                                         break;
 547                                 case 'G':
 548                                         $num = intval( substr( $ts, 8, 2 ) );
 549                                         break;
 550                                 case 'h':
 551                                         $h = substr( $ts, 8, 2 );
 552                                         $num = sprintf( '%02d', $h % 12 ? $h % 12 : 12 );
 553                                         break;
 554                                 case 'H':
 555                                         $num = substr( $ts, 8, 2 );
 556                                         break;
 557                                 case 'i':
 558                                         $num = substr( $ts, 10, 2 );
 559                                         break;
 560                                 case 's':
 561                                         $num = substr( $ts, 12, 2 );
 562                                         break;
 563                                 case 'c':
 564                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 565                                         $s .= date( 'c', $unix );
 566                                         break;
 567                                 case 'r':
 568                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 569                                         $s .= date( 'r', $unix );
 570                                         break;
 571                                 case 'U':
 572                                         if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
 573                                         $num = $unix;
 574                                         break;
 575                                 case '\\':
 576                                         # Backslash escaping
 577                                         if ( $p < strlen( $format ) - 1 ) {
 578                                                 $s .= $format[++$p];
 579                                         } else {
 580                                                 $s .= '\\';
 581                                         }
 582                                         break;
 583                                 case '"':
 584                                         # Quoted literal
 585                                         if ( $p < strlen( $format ) - 1 ) {
 586                                                 $endQuote = strpos( $format, '"', $p + 1 );
 587                                                 if ( $endQuote === false ) {
 588                                                         # No terminating quote, assume literal "
 589                                                         $s .= '"';
 590                                                 } else {
 591                                                         $s .= substr( $format, $p + 1, $endQuote - $p - 1 );
 592                                                         $p = $endQuote;
 593                                                 }
 594                                         } else {
 595                                                 # Quote at end of string, assume literal "
 596                                                 $s .= '"';
 597                                         }
 598                                         break;
 599                                 default:
 600                                         $s .= $format[$p];
 601                         }
 602                         if ( $num !== false ) {
 603                                 if ( $rawToggle || $raw ) {
 604                                         $s .= $num;
 605                                         $raw = false;
 606                                 } elseif ( $roman ) {
 607                                         $s .= self::romanNumeral( $num );
 608                                         $roman = false;
 609                                 } else {
 610                                         $s .= $this->formatNum( $num, true );
 611                                 }
 612                                 $num = false;
 613                         }
 614                 }
 615                 return $s;
 616         }
 617
 618         /**
 619          * Roman number formatting up to 3000
 620          */
 621         static function romanNumeral( $num ) {
 622                 static $table = array(
 623                         array( '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X' ),
 624                         array( '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', 'C' ),
 625                         array( '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', 'M' ),
 626                         array( '', 'M', 'MM', 'MMM' )
 627                 );
 628
 629                 $num = intval( $num );
 630                 if ( $num > 3000 || $num <= 0 ) {
 631                         return $num;
 632                 }
 633
 634                 $s = '';
 635                 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
 636                         if ( $num >= $pow10 ) {
 637                                 $s .= $table[$i][floor($num / $pow10)];
 638                         }
 639                         $num = $num % $pow10;
 640                 }
 641                 return $s;
 642         }
 643
 644         /**
 645          * This is meant to be used by time(), date(), and timeanddate() to get
 646          * the date preference they're supposed to use, it should be used in
 647          * all children.
 648          *
 649          *<code>
 650          * function timeanddate([...], $format = true) {
 651          *      $datePreference = $this->dateFormat($format);
 652          * [...]
 653          * }
 654          *</code>
 655          *
 656          * @param mixed $usePrefs: if true, the user's preference is used
 657          *                         if false, the site/language default is used
 658          *                         if int/string, assumed to be a format.
 659          * @return string
 660          */
 661         function dateFormat( $usePrefs = true ) {
 662                 global $wgUser;
 663
 664                 if( is_bool( $usePrefs ) ) {
 665                         if( $usePrefs ) {
 666                                 $datePreference = $wgUser->getDatePreference();
 667                         } else {
 668                                 $options = User::getDefaultOptions();
 669                                 $datePreference = (string)$options['date'];
 670                         }
 671                 } else {
 672                         $datePreference = (string)$usePrefs;
 673                 }
 674
 675                 // return int
 676                 if( $datePreference == '' ) {
 677                         return 'default';
 678                 }
 679
 680                 return $datePreference;
 681         }
 682
 683         /**
 684          * @public
 685          * @param mixed  $ts the time format which needs to be turned into a
 686          *               date('YmdHis') format with wfTimestamp(TS_MW,$ts)
 687          * @param bool   $adj whether to adjust the time output according to the
 688          *               user configured offset ($timecorrection)
 689          * @param mixed  $format true to use user's date format preference
 690          * @param string $timecorrection the time offset as returned by
 691          *               validateTimeZone() in Special:Preferences
 692          * @return string
 693          */
 694         function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
 695                 $this->load();
 696                 if ( $adj ) {
 697                         $ts = $this->userAdjust( $ts, $timecorrection );
 698                 }
 699
 700                 $pref = $this->dateFormat( $format );
 701                 if( $pref == 'default' || !isset( $this->dateFormats["$pref date"] ) ) {
 702                         $pref = $this->defaultDateFormat;
 703                 }
 704                 return $this->sprintfDate( $this->dateFormats["$pref date"], $ts );
 705         }
 706
 707         /**
 708         * @public
 709         * @param mixed  $ts the time format which needs to be turned into a
 710         *               date('YmdHis') format with wfTimestamp(TS_MW,$ts)
 711         * @param bool   $adj whether to adjust the time output according to the
 712         *               user configured offset ($timecorrection)
 713         * @param mixed  $format true to use user's date format preference
 714         * @param string $timecorrection the time offset as returned by
 715         *               validateTimeZone() in Special:Preferences
 716         * @return string
 717         */
 718         function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
 719                 $this->load();
 720                 if ( $adj ) {
 721                         $ts = $this->userAdjust( $ts, $timecorrection );
 722                 }
 723
 724                 $pref = $this->dateFormat( $format );
 725                 if( $pref == 'default' || !isset( $this->dateFormats["$pref time"] ) ) {
 726                         $pref = $this->defaultDateFormat;
 727                 }
 728                 return $this->sprintfDate( $this->dateFormats["$pref time"], $ts );
 729         }
 730
 731         /**
 732         * @public
 733         * @param mixed  $ts the time format which needs to be turned into a
 734         *               date('YmdHis') format with wfTimestamp(TS_MW,$ts)
 735         * @param bool   $adj whether to adjust the time output according to the
 736         *               user configured offset ($timecorrection)
 737
 738         * @param mixed  $format what format to return, if it's false output the
 739         *               default one (default true)
 740         * @param string $timecorrection the time offset as returned by
 741         *               validateTimeZone() in Special:Preferences
 742         * @return string
 743         */
 744         function timeanddate( $ts, $adj = false, $format = true, $timecorrection = false) {
 745                 $this->load();
 746                 if ( $adj ) {
 747                         $ts = $this->userAdjust( $ts, $timecorrection );
 748                 }
 749
 750                 $pref = $this->dateFormat( $format );
 751                 if( $pref == 'default' || !isset( $this->dateFormats["$pref both"] ) ) {
 752                         $pref = $this->defaultDateFormat;
 753                 }
 754
 755                 return $this->sprintfDate( $this->dateFormats["$pref both"], $ts );
 756         }
 757
 758         function getMessage( $key ) {
 759                 $this->load();
 760                 return isset( $this->messages[$key] ) ? $this->messages[$key] : null;
 761         }
 762
 763         function getAllMessages() {
 764                 $this->load();
 765                 return $this->messages;
 766         }
 767
 768         function iconv( $in, $out, $string ) {
 769                 # For most languages, this is a wrapper for iconv
 770                 return iconv( $in, $out, $string );
 771         }
 772
 773         // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
 774         function ucwordbreaksCallbackAscii($matches){
 775                 return $this->ucfirst($matches[1]);
 776         }
 777
 778         function ucwordbreaksCallbackMB($matches){
 779                 return mb_strtoupper($matches[0]);
 780         }
 781
 782         function ucCallback($matches){
 783                 list( $wikiUpperChars ) = self::getCaseMaps();
 784                 return strtr( $matches[1], $wikiUpperChars );
 785         }
 786
 787         function lcCallback($matches){
 788                 list( , $wikiLowerChars ) = self::getCaseMaps();
 789                 return strtr( $matches[1], $wikiLowerChars );
 790         }
 791
 792         function ucwordsCallbackMB($matches){
 793                 return mb_strtoupper($matches[0]);
 794         }
 795
 796         function ucwordsCallbackWiki($matches){
 797                 list( $wikiUpperChars ) = self::getCaseMaps();
 798                 return strtr( $matches[0], $wikiUpperChars );
 799         }
 800
 801         function ucfirst( $str ) {
 802                 return self::uc( $str, true );
 803         }
 804
 805         function uc( $str, $first = false ) {
 806                 if ( function_exists( 'mb_strtoupper' ) )
 807                         if ( $first )
 808                                 if ( self::isMultibyte( $str ) )
 809                                         return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
 810                                 else
 811                                         return ucfirst( $str );
 812                         else
 813                                 return self::isMultibyte( $str ) ? mb_strtoupper( $str ) : strtoupper( $str );
 814                 else
 815                         if ( self::isMultibyte( $str ) ) {
 816                                 list( $wikiUpperChars ) = $this->getCaseMaps();
 817                                 $x = $first ? '^' : '';
 818                                 return preg_replace_callback(
 819                                         "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
 820                                         array($this,"ucCallback"),
 821                                         $str
 822                                 );
 823                         } else
 824                                 return $first ? ucfirst( $str ) : strtoupper( $str );
 825         }
 826
 827         function lcfirst( $str ) {
 828                 return self::lc( $str, true );
 829         }
 830
 831         function lc( $str, $first = false ) {
 832                 if ( function_exists( 'mb_strtolower' ) )
 833                         if ( $first )
 834                                 if ( self::isMultibyte( $str ) )
 835                                         return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
 836                                 else
 837                                         return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
 838                         else
 839                                 return self::isMultibyte( $str ) ? mb_strtolower( $str ) : strtolower( $str );
 840                 else
 841                         if ( self::isMultibyte( $str ) ) {
 842                                 list( , $wikiLowerChars ) = self::getCaseMaps();
 843                                 $x = $first ? '^' : '';
 844                                 return preg_replace_callback(
 845                                         "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
 846                                         array($this,"lcCallback"),
 847                                         $str
 848                                 );
 849                         } else
 850                                 return $first ? strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
 851         }
 852
 853         function isMultibyte( $str ) {
 854                 return (bool)preg_match( '/[\x80-\xff]/', $str );
 855         }
 856
 857         function ucwords($str) {
 858                 if ( self::isMultibyte( $str ) ) {
 859                         $str = self::lc($str);
 860
 861                         // regexp to find first letter in each word (i.e. after each space)
 862                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
 863
 864                         // function to use to capitalize a single char
 865                         if ( function_exists( 'mb_strtoupper' ) )
 866                                 return preg_replace_callback(
 867                                         $replaceRegexp,
 868                                         array($this,"ucwordsCallbackMB"),
 869                                         $str
 870                                 );
 871                         else
 872                                 return preg_replace_callback(
 873                                         $replaceRegexp,
 874                                         array($this,"ucwordsCallbackWiki"),
 875                                         $str
 876                                 );
 877                 }
 878                 else
 879                         return ucwords( strtolower( $str ) );
 880         }
 881
 882   # capitalize words at word breaks
 883         function ucwordbreaks($str){
 884                 if (self::isMultibyte( $str ) ) {
 885                         $str = self::lc($str);
 886
 887                         // since \b doesn't work for UTF-8, we explicitely define word break chars
 888                         $breaks= "[ \-\(\)\}\{\.,\?!]";
 889
 890                         // find first letter after word break
 891                         $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
 892
 893                         if ( function_exists( 'mb_strtoupper' ) )
 894                                 return preg_replace_callback(
 895                                         $replaceRegexp,
 896                                         array($this,"ucwordbreaksCallbackMB"),
 897                                         $str
 898                                 );
 899                         else
 900                                 return preg_replace_callback(
 901                                         $replaceRegexp,
 902                                         array($this,"ucwordsCallbackWiki"),
 903                                         $str
 904                                 );
 905                 }
 906                 else
 907                         return preg_replace_callback(
 908                         '/\b([\w\x80-\xff]+)\b/',
 909                         array($this,"ucwordbreaksCallbackAscii"),
 910                         $str );
 911         }
 912
 913         /**
 914          * Return a case-folded representation of $s
 915          *
 916          * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
 917          * and $s2 are the same except for the case of their characters. It is not
 918          * necessary for the value returned to make sense when displayed.
 919          *
 920          * Do *not* perform any other normalisation in this function. If a caller
 921          * uses this function when it should be using a more general normalisation
 922          * function, then fix the caller.
 923          */
 924         function caseFold( $s ) {
 925                 return $this->uc( $s );
 926         }
 927
 928         function checkTitleEncoding( $s ) {
 929                 if( is_array( $s ) ) {
 930                         wfDebugDieBacktrace( 'Given array to checkTitleEncoding.' );
 931                 }
 932                 # Check for non-UTF-8 URLs
 933                 $ishigh = preg_match( '/[\x80-\xff]/', $s);
 934                 if(!$ishigh) return $s;
 935
 936                 $isutf8 = preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
 937                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
 938                 if( $isutf8 ) return $s;
 939
 940                 return $this->iconv( $this->fallback8bitEncoding(), "utf-8", $s );
 941         }
 942
 943         function fallback8bitEncoding() {
 944                 $this->load();
 945                 return $this->fallback8bitEncoding;
 946         }
 947
 948         /**
 949          * Some languages have special punctuation to strip out
 950          * or characters which need to be converted for MySQL's
 951          * indexing to grok it correctly. Make such changes here.
 952          *
 953          * @param string $in
 954          * @return string
 955          */
 956         function stripForSearch( $string ) {
 957                 # MySQL fulltext index doesn't grok utf-8, so we
 958                 # need to fold cases and convert to hex
 959
 960                 wfProfileIn( __METHOD__ );
 961                 if( function_exists( 'mb_strtolower' ) ) {
 962                         $out = preg_replace(
 963                                 "/([\\xc0-\\xff][\\x80-\\xbf]*)/e",
 964                                 "'U8' . bin2hex( \"$1\" )",
 965                                 mb_strtolower( $string ) );
 966                 } else {
 967                         list( , $wikiLowerChars ) = self::getCaseMaps();
 968                         $out = preg_replace(
 969                                 "/([\\xc0-\\xff][\\x80-\\xbf]*)/e",
 970                                 "'U8' . bin2hex( strtr( \"\$1\", \$wikiLowerChars ) )",
 971                                 $string );
 972                 }
 973                 wfProfileOut( __METHOD__ );
 974                 return $out;
 975         }
 976
 977         function convertForSearchResult( $termsArray ) {
 978                 # some languages, e.g. Chinese, need to do a conversion
 979                 # in order for search results to be displayed correctly
 980                 return $termsArray;
 981         }
 982
 983         /**
 984          * Get the first character of a string.
 985          *
 986          * @param string $s
 987          * @return string
 988          */
 989         function firstChar( $s ) {
 990                 preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
 991                 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/', $s, $matches);
 992
 993                 return isset( $matches[1] ) ? $matches[1] : "";
 994         }
 995
 996         function initEncoding() {
 997                 # Some languages may have an alternate char encoding option
 998                 # (Esperanto X-coding, Japanese furigana conversion, etc)
 999                 # If this language is used as the primary content language,
1000                 # an override to the defaults can be set here on startup.
1001         }
1002
1003         function recodeForEdit( $s ) {
1004                 # For some languages we'll want to explicitly specify
1005                 # which characters make it into the edit box raw
1006                 # or are converted in some way or another.
1007                 # Note that if wgOutputEncoding is different from
1008                 # wgInputEncoding, this text will be further converted
1009                 # to wgOutputEncoding.
1010                 global $wgEditEncoding;
1011                 if( $wgEditEncoding == '' or
1012                   $wgEditEncoding == 'UTF-8' ) {
1013                         return $s;
1014                 } else {
1015                         return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
1016                 }
1017         }
1018
1019         function recodeInput( $s ) {
1020                 # Take the previous into account.
1021                 global $wgEditEncoding;
1022                 if($wgEditEncoding != "") {
1023                         $enc = $wgEditEncoding;
1024                 } else {
1025                         $enc = 'UTF-8';
1026                 }
1027                 if( $enc == 'UTF-8' ) {
1028                         return $s;
1029                 } else {
1030                         return $this->iconv( $enc, 'UTF-8', $s );
1031                 }
1032         }
1033
1034         /**
1035          * For right-to-left language support
1036          *
1037          * @return bool
1038          */
1039         function isRTL() {
1040                 $this->load();
1041                 return $this->rtl;
1042         }
1043
1044         /**
1045          * A hidden direction mark (LRM or RLM), depending on the language direction
1046          *
1047          * @return string
1048          */
1049         function getDirMark() {
1050                 return $this->isRTL() ? "\xE2\x80\x8F" : "\xE2\x80\x8E";
1051         }
1052
1053         /**
1054          * An arrow, depending on the language direction
1055          *
1056          * @return string
1057          */
1058         function getArrow() {
1059                 return $this->isRTL() ? '←' : '→';
1060         }
1061
1062         /**
1063          * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
1064          *
1065          * @return bool
1066          */
1067         function linkPrefixExtension() {
1068                 $this->load();
1069                 return $this->linkPrefixExtension;
1070         }
1071
1072         function &getMagicWords() {
1073                 $this->load();
1074                 return $this->magicWords;
1075         }
1076
1077         # Fill a MagicWord object with data from here
1078         function getMagic( &$mw ) {
1079                 if ( !isset( $this->mMagicExtensions ) ) {
1080                         $this->mMagicExtensions = array();
1081                         wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
1082                 }
1083                 if ( isset( $this->mMagicExtensions[$mw->mId] ) ) {
1084                         $rawEntry = $this->mMagicExtensions[$mw->mId];
1085                 } else {
1086                         $magicWords =& $this->getMagicWords();
1087                         if ( isset( $magicWords[$mw->mId] ) ) {
1088                                 $rawEntry = $magicWords[$mw->mId];
1089                         } else {
1090                                 # Fall back to English if local list is incomplete
1091                                 $magicWords =& Language::getMagicWords();
1092                                 $rawEntry = $magicWords[$mw->mId];
1093                         }
1094                 }
1095
1096                 if( !is_array( $rawEntry ) ) {
1097                         error_log( "\"$rawEntry\" is not a valid magic thingie for \"$mw->mId\"" );
1098                 }
1099                 $mw->mCaseSensitive = $rawEntry[0];
1100                 $mw->mSynonyms = array_slice( $rawEntry, 1 );
1101         }
1102
1103         /**
1104          * Get special page names, as an associative array
1105          *   case folded alias => real name
1106          */
1107         function getSpecialPageAliases() {
1108                 $this->load();
1109                 if ( !isset( $this->mExtendedSpecialPageAliases ) ) {
1110                         $this->mExtendedSpecialPageAliases = $this->specialPageAliases;
1111                         wfRunHooks( 'LangugeGetSpecialPageAliases',
1112                                 array( &$this->mExtendedSpecialPageAliases, $this->getCode() ) );
1113                 }
1114                 return $this->mExtendedSpecialPageAliases;
1115         }
1116
1117         /**
1118          * Italic is unsuitable for some languages
1119          *
1120          * @public
1121          *
1122          * @param string $text The text to be emphasized.
1123          * @return string
1124          */
1125         function emphasize( $text ) {
1126                 return "<em>$text</em>";
1127         }
1128
1129          /**
1130          * Normally we output all numbers in plain en_US style, that is
1131          * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
1132          * point twohundredthirtyfive. However this is not sutable for all
1133          * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
1134          * Icelandic just want to use commas instead of dots, and dots instead
1135          * of commas like "293.291,235".
1136          *
1137          * An example of this function being called:
1138          * <code>
1139          * wfMsg( 'message', $wgLang->formatNum( $num ) )
1140          * </code>
1141          *
1142          * See LanguageGu.php for the Gujarati implementation and
1143          * LanguageIs.php for the , => . and . => , implementation.
1144          *
1145          * @todo check if it's viable to use localeconv() for the decimal
1146          *       seperator thing.
1147          * @public
1148          * @param mixed $number the string to be formatted, should be an integer or
1149          *        a floating point number.
1150          * @param bool $nocommafy Set to true for special numbers like dates
1151          * @return string
1152          */
1153         function formatNum( $number, $nocommafy = false ) {
1154                 global $wgTranslateNumerals;
1155                 if (!$nocommafy) {
1156                         $number = $this->commafy($number);
1157                         $s = $this->separatorTransformTable();
1158                         if (!is_null($s)) { $number = strtr($number, $s); }
1159                 }
1160
1161                 if ($wgTranslateNumerals) {
1162                         $s = $this->digitTransformTable();
1163                         if (!is_null($s)) { $number = strtr($number, $s); }
1164                 }
1165
1166                 return $number;
1167         }
1168
1169         function parseFormattedNumber( $number ) {
1170                 $s = $this->digitTransformTable();
1171                 if (!is_null($s)) { $number = strtr($number, array_flip($s)); }
1172
1173                 $s = $this->separatorTransformTable();
1174                 if (!is_null($s)) { $number = strtr($number, array_flip($s)); }
1175
1176                 $number = strtr( $number, array (',' => '') );
1177                 return $number;
1178         }
1179
1180         /**
1181          * Adds commas to a given number
1182          *
1183          * @param mixed $_
1184          * @return string
1185          */
1186         function commafy($_) {
1187                 return strrev((string)preg_replace('/(\d{3})(?=\d)(?!\d*\.)/','$1,',strrev($_)));
1188         }
1189
1190         function digitTransformTable() {
1191                 $this->load();
1192                 return $this->digitTransformTable;
1193         }
1194
1195         function separatorTransformTable() {
1196                 $this->load();
1197                 return $this->separatorTransformTable;
1198         }
1199
1200
1201         /**
1202          * For the credit list in includes/Credits.php (action=credits)
1203          *
1204          * @param array $l
1205          * @return string
1206          */
1207         function listToText( $l ) {
1208                 $s = '';
1209                 $m = count($l) - 1;
1210                 for ($i = $m; $i >= 0; $i--) {
1211                         if ($i == $m) {
1212                                 $s = $l[$i];
1213                         } else if ($i == $m - 1) {
1214                                 $s = $l[$i] . ' ' . $this->getMessageFromDB( 'and' ) . ' ' . $s;
1215                         } else {
1216                                 $s = $l[$i] . ', ' . $s;
1217                         }
1218                 }
1219                 return $s;
1220         }
1221
1222         # Crop a string from the beginning or end to a certain number of bytes.
1223         # (Bytes are used because our storage has limited byte lengths for some
1224         # columns in the database.) Multibyte charsets will need to make sure that
1225         # only whole characters are included!
1226         #
1227         # $length does not include the optional ellipsis.
1228         # If $length is negative, snip from the beginning
1229         function truncate( $string, $length, $ellipsis = "" ) {
1230                 if( $length == 0 ) {
1231                         return $ellipsis;
1232                 }
1233                 if ( strlen( $string ) <= abs( $length ) ) {
1234                         return $string;
1235                 }
1236                 if( $length > 0 ) {
1237                         $string = substr( $string, 0, $length );
1238                         $char = ord( $string[strlen( $string ) - 1] );
1239                         if ($char >= 0xc0) {
1240                                 # We got the first byte only of a multibyte char; remove it.
1241                                 $string = substr( $string, 0, -1 );
1242                         } elseif( $char >= 0x80 &&
1243                                   preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
1244                                               '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
1245                             # We chopped in the middle of a character; remove it
1246                                 $string = $m[1];
1247                         }
1248                         return $string . $ellipsis;
1249                 } else {
1250                         $string = substr( $string, $length );
1251                         $char = ord( $string[0] );
1252                         if( $char >= 0x80 && $char < 0xc0 ) {
1253                                 # We chopped in the middle of a character; remove the whole thing
1254                                 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
1255                         }
1256                         return $ellipsis . $string;
1257                 }
1258         }
1259
1260         /**
1261          * Grammatical transformations, needed for inflected languages
1262          * Invoked by putting {{grammar:case|word}} in a message
1263          *
1264          * @param string $word
1265          * @param string $case
1266          * @return string
1267          */
1268         function convertGrammar( $word, $case ) {
1269                 global $wgGrammarForms;
1270                 if ( isset($wgGrammarForms['en'][$case][$word]) ) {
1271                         return $wgGrammarForms['en'][$case][$word];
1272                 }
1273                 return $word;
1274         }
1275
1276         /**
1277          * Plural form transformations, needed for some languages.
1278          * For example, where are 3 form of plural in Russian and Polish,
1279          * depending on "count mod 10". See [[w:Plural]]
1280          * For English it is pretty simple.
1281          *
1282          * Invoked by putting {{plural:count|wordform1|wordform2}}
1283          * or {{plural:count|wordform1|wordform2|wordform3}}
1284          *
1285          * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
1286          *
1287          * @param integer $count
1288          * @param string $wordform1
1289          * @param string $wordform2
1290          * @param string $wordform3 (optional)
1291          * @param string $wordform4 (optional)
1292          * @param string $wordform5 (optional)
1293          * @return string
1294          */
1295         function convertPlural( $count, $w1, $w2, $w3, $w4, $w5) {
1296                 return $count == '1' ? $w1 : $w2;
1297         }
1298
1299         /**
1300          * For translaing of expiry times
1301          * @param string The validated block time in English
1302          * @return Somehow translated block time
1303          * @see LanguageFi.php for example implementation
1304          */
1305         function translateBlockExpiry( $str ) {
1306
1307                 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
1308
1309                 if ( $scBlockExpiryOptions == '-') {
1310                         return $str;
1311                 }
1312
1313                 foreach (explode(',', $scBlockExpiryOptions) as $option) {
1314                         if ( strpos($option, ":") === false )
1315                                 continue;
1316                         list($show, $value) = explode(":", $option);
1317                         if ( strcmp ( $str, $value) == 0 )
1318                                 return '<span title="' . htmlspecialchars($str). '">' .
1319                                         htmlspecialchars( trim( $show ) ) . '</span>';
1320                 }
1321
1322                 return $str;
1323         }
1324
1325         /**
1326          * languages like Chinese need to be segmented in order for the diff
1327          * to be of any use
1328          *
1329          * @param string $text
1330          * @return string
1331          */
1332         function segmentForDiff( $text ) {
1333                 return $text;
1334         }
1335
1336         /**
1337          * and unsegment to show the result
1338          *
1339          * @param string $text
1340          * @return string
1341          */
1342         function unsegmentForDiff( $text ) {
1343                 return $text;
1344         }
1345
1346         # convert text to different variants of a language.
1347         function convert( $text, $isTitle = false) {
1348                 return $this->mConverter->convert($text, $isTitle);
1349         }
1350
1351         # Convert text from within Parser
1352         function parserConvert( $text, &$parser ) {
1353                 return $this->mConverter->parserConvert( $text, $parser );
1354         }
1355
1356         # Check if this is a language with variants
1357         function hasVariants(){
1358                 return sizeof($this->getVariants())>1;
1359         }
1360
1361         # Put custom tags (e.g. -{ }-) around math to prevent conversion
1362         function armourMath($text){
1363                 return $this->mConverter->armourMath($text);
1364         }
1365
1366
1367         /**
1368          * Perform output conversion on a string, and encode for safe HTML output.
1369          * @param string $text
1370          * @param bool $isTitle -- wtf?
1371          * @return string
1372          * @todo this should get integrated somewhere sane
1373          */
1374         function convertHtml( $text, $isTitle = false ) {
1375                 return htmlspecialchars( $this->convert( $text, $isTitle ) );
1376         }
1377
1378         function convertCategoryKey( $key ) {
1379                 return $this->mConverter->convertCategoryKey( $key );
1380         }
1381
1382         /**
1383          * get the list of variants supported by this langauge
1384          * see sample implementation in LanguageZh.php
1385          *
1386          * @return array an array of language codes
1387          */
1388         function getVariants() {
1389                 return $this->mConverter->getVariants();
1390         }
1391
1392
1393         function getPreferredVariant( $fromUser = true ) {
1394                 return $this->mConverter->getPreferredVariant( $fromUser );
1395         }
1396
1397         /**
1398          * if a language supports multiple variants, it is
1399          * possible that non-existing link in one variant
1400          * actually exists in another variant. this function
1401          * tries to find it. See e.g. LanguageZh.php
1402          *
1403          * @param string $link the name of the link
1404          * @param mixed $nt the title object of the link
1405          * @return null the input parameters may be modified upon return
1406          */
1407         function findVariantLink( &$link, &$nt ) {
1408                 $this->mConverter->findVariantLink($link, $nt);
1409         }
1410
1411         /**
1412          * If a language supports multiple variants, converts text
1413          * into an array of all possible variants of the text:
1414          *  'variant' => text in that variant
1415          */
1416
1417         function convertLinkToAllVariants($text){
1418                 return $this->mConverter->convertLinkToAllVariants($text);
1419         }
1420
1421
1422         /**
1423          * returns language specific options used by User::getPageRenderHash()
1424          * for example, the preferred language variant
1425          *
1426          * @return string
1427          * @public
1428          */
1429         function getExtraHashOptions() {
1430                 return $this->mConverter->getExtraHashOptions();
1431         }
1432
1433         /**
1434          * for languages that support multiple variants, the title of an
1435          * article may be displayed differently in different variants. this
1436          * function returns the apporiate title defined in the body of the article.
1437          *
1438          * @return string
1439          */
1440         function getParsedTitle() {
1441                 return $this->mConverter->getParsedTitle();
1442         }
1443
1444         /**
1445          * Enclose a string with the "no conversion" tag. This is used by
1446          * various functions in the Parser
1447          *
1448          * @param string $text text to be tagged for no conversion
1449          * @return string the tagged text
1450         */
1451         function markNoConversion( $text, $noParse=false ) {
1452                 return $this->mConverter->markNoConversion( $text, $noParse );
1453         }
1454
1455         /**
1456          * A regular expression to match legal word-trailing characters
1457          * which should be merged onto a link of the form [[foo]]bar.
1458          *
1459          * @return string
1460          * @public
1461          */
1462         function linkTrail() {
1463                 $this->load();
1464                 return $this->linkTrail;
1465         }
1466
1467         function getLangObj() {
1468                 return $this;
1469         }
1470
1471         /**
1472          * Get the RFC 3066 code for this language object
1473          */
1474         function getCode() {
1475                 return $this->mCode;
1476         }
1477
1478         function setCode( $code ) {
1479                 $this->mCode = $code;
1480         }
1481
1482         static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
1483                 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
1484         }
1485
1486         static function getMessagesFileName( $code ) {
1487                 global $IP;
1488                 return self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
1489         }
1490
1491         static function getClassFileName( $code ) {
1492                 global $IP;
1493                 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
1494         }
1495
1496         static function getLocalisationArray( $code, $disableCache = false ) {
1497                 self::loadLocalisation( $code, $disableCache );
1498                 return self::$mLocalisationCache[$code];
1499         }
1500
1501         /**
1502          * Load localisation data for a given code into the static cache
1503          *
1504          * @return array Dependencies, map of filenames to mtimes
1505          */
1506         static function loadLocalisation( $code, $disableCache = false ) {
1507                 static $recursionGuard = array();
1508                 global $wgMemc;
1509
1510                 if ( !$code ) {
1511                         throw new MWException( "Invalid language code requested" );
1512                 }
1513
1514                 if ( !$disableCache ) {
1515                         # Try the per-process cache
1516                         if ( isset( self::$mLocalisationCache[$code] ) ) {
1517                                 return self::$mLocalisationCache[$code]['deps'];
1518                         }
1519
1520                         wfProfileIn( __METHOD__ );
1521
1522                         # Try the serialized directory
1523                         $cache = wfGetPrecompiledData( self::getFileName( "Messages", $code, '.ser' ) );
1524                         if ( $cache ) {
1525                                 self::$mLocalisationCache[$code] = $cache;
1526                                 wfDebug( "Got localisation for $code from precompiled data file\n" );
1527                                 wfProfileOut( __METHOD__ );
1528                                 return self::$mLocalisationCache[$code]['deps'];
1529                         }
1530
1531                         # Try the global cache
1532                         $memcKey = wfMemcKey('localisation', $code );
1533                         $cache = $wgMemc->get( $memcKey );
1534                         if ( $cache ) {
1535                                 $expired = false;
1536                                 # Check file modification times
1537                                 foreach ( $cache['deps'] as $file => $mtime ) {
1538                                         if ( !file_exists( $file ) || filemtime( $file ) > $mtime ) {
1539                                                 $expired = true;
1540                                                 break;
1541                                         }
1542                                 }
1543                                 if ( self::isLocalisationOutOfDate( $cache ) ) {
1544                                         $wgMemc->delete( $memcKey );
1545                                         $cache = false;
1546                                         wfDebug( "Localisation cache for $code had expired due to update of $file\n" );
1547                                 } else {
1548                                         self::$mLocalisationCache[$code] = $cache;
1549                                         wfDebug( "Got localisation for $code from cache\n" );
1550                                         wfProfileOut( __METHOD__ );
1551                                         return $cache['deps'];
1552                                 }
1553                         }
1554                 } else {
1555                         wfProfileIn( __METHOD__ );
1556                 }
1557
1558                 # Default fallback, may be overridden when the messages file is included
1559                 if ( $code != 'en' ) {
1560                         $fallback = 'en';
1561                 } else {
1562                         $fallback = false;
1563                 }
1564
1565                 # Load the primary localisation from the source file
1566                 $filename = self::getMessagesFileName( $code );
1567                 if ( !file_exists( $filename ) ) {
1568                         wfDebug( "No localisation file for $code, using implicit fallback to en\n" );
1569                         $cache = array();
1570                         $deps = array();
1571                 } else {
1572                         $deps = array( $filename => filemtime( $filename ) );
1573                         require( $filename );
1574                         $cache = compact( self::$mLocalisationKeys );
1575                         wfDebug( "Got localisation for $code from source\n" );
1576                 }
1577
1578                 if ( !empty( $fallback ) ) {
1579                         # Load the fallback localisation, with a circular reference guard
1580                         if ( isset( $recursionGuard[$code] ) ) {
1581                                 throw new MWException( "Error: Circular fallback reference in language code $code" );
1582                         }
1583                         $recursionGuard[$code] = true;
1584                         $newDeps = self::loadLocalisation( $fallback, $disableCache );
1585                         unset( $recursionGuard[$code] );
1586
1587                         $secondary = self::$mLocalisationCache[$fallback];
1588                         $deps = array_merge( $deps, $newDeps );
1589
1590                         # Merge the fallback localisation with the current localisation
1591                         foreach ( self::$mLocalisationKeys as $key ) {
1592                                 if ( isset( $cache[$key] ) ) {
1593                                         if ( isset( $secondary[$key] ) ) {
1594                                                 if ( in_array( $key, self::$mMergeableMapKeys ) ) {
1595                                                         $cache[$key] = $cache[$key] + $secondary[$key];
1596                                                 } elseif ( in_array( $key, self::$mMergeableListKeys ) ) {
1597                                                         $cache[$key] = array_merge( $secondary[$key], $cache[$key] );
1598                                                 } elseif ( in_array( $key, self::$mMergeableAliasListKeys ) ) {
1599                                                         $cache[$key] = array_merge_recursive( $cache[$key], $secondary[$key] );
1600                                                 }
1601                                         }
1602                                 } else {
1603                                         $cache[$key] = $secondary[$key];
1604                                 }
1605                         }
1606
1607                         # Merge bookstore lists if requested
1608                         if ( !empty( $cache['bookstoreList']['inherit'] ) ) {
1609                                 $cache['bookstoreList'] = array_merge( $cache['bookstoreList'], $secondary['bookstoreList'] );
1610                         }
1611                         if ( isset( $cache['bookstoreList']['inherit'] ) ) {
1612                                 unset( $cache['bookstoreList']['inherit'] );
1613                         }
1614                 }
1615
1616                 # Add dependencies to the cache entry
1617                 $cache['deps'] = $deps;
1618
1619                 # Replace spaces with underscores in namespace names
1620                 $cache['namespaceNames'] = str_replace( ' ', '_', $cache['namespaceNames'] );
1621
1622                 # Save to both caches
1623                 self::$mLocalisationCache[$code] = $cache;
1624                 if ( !$disableCache ) {
1625                         $wgMemc->set( $memcKey, $cache );
1626                 }
1627
1628                 wfProfileOut( __METHOD__ );
1629                 return $deps;
1630         }
1631
1632         /**
1633          * Test if a given localisation cache is out of date with respect to the
1634          * source Messages files. This is done automatically for the global cache
1635          * in $wgMemc, but is only done on certain occasions for the serialized
1636          * data file.
1637          *
1638          * @param $cache mixed Either a language code or a cache array
1639          */
1640         static function isLocalisationOutOfDate( $cache ) {
1641                 if ( !is_array( $cache ) ) {
1642                         self::loadLocalisation( $cache );
1643                         $cache = self::$mLocalisationCache[$cache];
1644                 }
1645                 $expired = false;
1646                 foreach ( $cache['deps'] as $file => $mtime ) {
1647                         if ( !file_exists( $file ) || filemtime( $file ) > $mtime ) {
1648                                 $expired = true;
1649                                 break;
1650                         }
1651                 }
1652                 return $expired;
1653         }
1654
1655         /**
1656          * Get the fallback for a given language
1657          */
1658         static function getFallbackFor( $code ) {
1659                 self::loadLocalisation( $code );
1660                 return self::$mLocalisationCache[$code]['fallback'];
1661         }
1662
1663         /**
1664          * Get all messages for a given language
1665          */
1666         static function getMessagesFor( $code ) {
1667                 self::loadLocalisation( $code );
1668                 return self::$mLocalisationCache[$code]['messages'];
1669         }
1670
1671         /**
1672          * Get a message for a given language
1673          */
1674         static function getMessageFor( $key, $code ) {
1675                 self::loadLocalisation( $code );
1676                 return isset( self::$mLocalisationCache[$code]['messages'][$key] ) ? self::$mLocalisationCache[$code]['messages'][$key] : null;
1677         }
1678
1679         /**
1680          * Load localisation data for this object
1681          */
1682         function load() {
1683                 if ( !$this->mLoaded ) {
1684                         self::loadLocalisation( $this->getCode() );
1685                         $cache =& self::$mLocalisationCache[$this->getCode()];
1686                         foreach ( self::$mLocalisationKeys as $key ) {
1687                                 $this->$key = $cache[$key];
1688                         }
1689                         $this->mLoaded = true;
1690
1691                         $this->fixUpSettings();
1692                 }
1693         }
1694
1695         /**
1696          * Do any necessary post-cache-load settings adjustment
1697          */
1698         function fixUpSettings() {
1699                 global $wgExtraNamespaces, $wgMetaNamespace, $wgMetaNamespaceTalk, $wgMessageCache,
1700                         $wgNamespaceAliases, $wgAmericanDates;
1701                 wfProfileIn( __METHOD__ );
1702                 if ( $wgExtraNamespaces ) {
1703                         $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames;
1704                 }
1705
1706                 $this->namespaceNames[NS_PROJECT] = $wgMetaNamespace;
1707                 if ( $wgMetaNamespaceTalk ) {
1708                         $this->namespaceNames[NS_PROJECT_TALK] = $wgMetaNamespaceTalk;
1709                 } else {
1710                         $talk = $this->namespaceNames[NS_PROJECT_TALK];
1711                         $talk = str_replace( '$1', $wgMetaNamespace, $talk );
1712
1713                         # Allow grammar transformations
1714                         # Allowing full message-style parsing would make simple requests
1715                         # such as action=raw much more expensive than they need to be.
1716                         # This will hopefully cover most cases.
1717                         $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
1718                                 array( &$this, 'replaceGrammarInNamespace' ), $talk );
1719                         $talk = str_replace( ' ', '_', $talk );
1720                         $this->namespaceNames[NS_PROJECT_TALK] = $talk;
1721                 }
1722
1723                 # The above mixing may leave namespaces out of canonical order.
1724                 # Re-order by namespace ID number...
1725                 ksort( $this->namespaceNames );
1726
1727                 # Put namespace names and aliases into a hashtable.
1728                 # If this is too slow, then we should arrange it so that it is done
1729                 # before caching. The catch is that at pre-cache time, the above
1730                 # class-specific fixup hasn't been done.
1731                 $this->mNamespaceIds = array();
1732                 foreach ( $this->namespaceNames as $index => $name ) {
1733                         $this->mNamespaceIds[$this->lc($name)] = $index;
1734                 }
1735                 if ( $this->namespaceAliases ) {
1736                         foreach ( $this->namespaceAliases as $name => $index ) {
1737                                 $this->mNamespaceIds[$this->lc($name)] = $index;
1738                         }
1739                 }
1740                 if ( $wgNamespaceAliases ) {
1741                         foreach ( $wgNamespaceAliases as $name => $index ) {
1742                                 $this->mNamespaceIds[$this->lc($name)] = $index;
1743                         }
1744                 }
1745
1746                 if ( $this->defaultDateFormat == 'dmy or mdy' ) {
1747                         $this->defaultDateFormat = $wgAmericanDates ? 'mdy' : 'dmy';
1748                 }
1749                 wfProfileOut( __METHOD__ );
1750         }
1751
1752         function replaceGrammarInNamespace( $m ) {
1753                 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
1754         }
1755
1756         static function getCaseMaps() {
1757                 static $wikiUpperChars, $wikiLowerChars;
1758                 if ( isset( $wikiUpperChars ) ) {
1759                         return array( $wikiUpperChars, $wikiLowerChars );
1760                 }
1761
1762                 wfProfileIn( __METHOD__ );
1763                 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
1764                 if ( $arr === false ) {
1765                         throw new MWException(
1766                                 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
1767                 }
1768                 extract( $arr );
1769                 wfProfileOut( __METHOD__ );
1770                 return array( $wikiUpperChars, $wikiLowerChars );
1771         }
1772 }
1773
1774 ?>