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 setNoTitleConvert(){}
  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         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         /**
1170          * Adds commas to a given number
1171          *
1172          * @param mixed $_
1173          * @return string
1174          */
1175         function commafy($_) {
1176                 return strrev((string)preg_replace('/(\d{3})(?=\d)(?!\d*\.)/','$1,',strrev($_)));
1177         }
1178
1179         function digitTransformTable() {
1180                 $this->load();
1181                 return $this->digitTransformTable;
1182         }
1183
1184         function separatorTransformTable() {
1185                 $this->load();
1186                 return $this->separatorTransformTable;
1187         }
1188
1189
1190         /**
1191          * For the credit list in includes/Credits.php (action=credits)
1192          *
1193          * @param array $l
1194          * @return string
1195          */
1196         function listToText( $l ) {
1197                 $s = '';
1198                 $m = count($l) - 1;
1199                 for ($i = $m; $i >= 0; $i--) {
1200                         if ($i == $m) {
1201                                 $s = $l[$i];
1202                         } else if ($i == $m - 1) {
1203                                 $s = $l[$i] . ' ' . $this->getMessageFromDB( 'and' ) . ' ' . $s;
1204                         } else {
1205                                 $s = $l[$i] . ', ' . $s;
1206                         }
1207                 }
1208                 return $s;
1209         }
1210
1211         # Crop a string from the beginning or end to a certain number of bytes.
1212         # (Bytes are used because our storage has limited byte lengths for some
1213         # columns in the database.) Multibyte charsets will need to make sure that
1214         # only whole characters are included!
1215         #
1216         # $length does not include the optional ellipsis.
1217         # If $length is negative, snip from the beginning
1218         function truncate( $string, $length, $ellipsis = "" ) {
1219                 if( $length == 0 ) {
1220                         return $ellipsis;
1221                 }
1222                 if ( strlen( $string ) <= abs( $length ) ) {
1223                         return $string;
1224                 }
1225                 if( $length > 0 ) {
1226                         $string = substr( $string, 0, $length );
1227                         $char = ord( $string[strlen( $string ) - 1] );
1228                         if ($char >= 0xc0) {
1229                                 # We got the first byte only of a multibyte char; remove it.
1230                                 $string = substr( $string, 0, -1 );
1231                         } elseif( $char >= 0x80 &&
1232                                   preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
1233                                               '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
1234                             # We chopped in the middle of a character; remove it
1235                                 $string = $m[1];
1236                         }
1237                         return $string . $ellipsis;
1238                 } else {
1239                         $string = substr( $string, $length );
1240                         $char = ord( $string[0] );
1241                         if( $char >= 0x80 && $char < 0xc0 ) {
1242                                 # We chopped in the middle of a character; remove the whole thing
1243                                 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
1244                         }
1245                         return $ellipsis . $string;
1246                 }
1247         }
1248
1249         /**
1250          * Grammatical transformations, needed for inflected languages
1251          * Invoked by putting {{grammar:case|word}} in a message
1252          *
1253          * @param string $word
1254          * @param string $case
1255          * @return string
1256          */
1257         function convertGrammar( $word, $case ) {
1258                 global $wgGrammarForms;
1259                 if ( isset($wgGrammarForms['en'][$case][$word]) ) {
1260                         return $wgGrammarForms['en'][$case][$word];
1261                 }
1262                 return $word;
1263         }
1264
1265         /**
1266          * Plural form transformations, needed for some languages.
1267          * For example, where are 3 form of plural in Russian and Polish,
1268          * depending on "count mod 10". See [[w:Plural]]
1269          * For English it is pretty simple.
1270          *
1271          * Invoked by putting {{plural:count|wordform1|wordform2}}
1272          * or {{plural:count|wordform1|wordform2|wordform3}}
1273          *
1274          * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
1275          *
1276          * @param integer $count
1277          * @param string $wordform1
1278          * @param string $wordform2
1279          * @param string $wordform3 (optional)
1280          * @return string
1281          */
1282         function convertPlural( $count, $w1, $w2, $w3) {
1283                 return $count == '1' ? $w1 : $w2;
1284         }
1285
1286         /**
1287          * For translaing of expiry times
1288          * @param string The validated block time in English
1289          * @return Somehow translated block time
1290          * @see LanguageFi.php for example implementation
1291          */
1292         function translateBlockExpiry( $str ) {
1293
1294                 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
1295
1296                 if ( $scBlockExpiryOptions == '-') {
1297                         return $str;
1298                 }
1299
1300                 foreach (explode(',', $scBlockExpiryOptions) as $option) {
1301                         if ( strpos($option, ":") === false )
1302                                 continue;
1303                         list($show, $value) = explode(":", $option);
1304                         if ( strcmp ( $str, $value) == 0 )
1305                                 return '<span title="' . htmlspecialchars($str). '">' .
1306                                         htmlspecialchars( trim( $show ) ) . '</span>';
1307                 }
1308
1309                 return $str;
1310         }
1311
1312         /**
1313          * languages like Chinese need to be segmented in order for the diff
1314          * to be of any use
1315          *
1316          * @param string $text
1317          * @return string
1318          */
1319         function segmentForDiff( $text ) {
1320                 return $text;
1321         }
1322
1323         /**
1324          * and unsegment to show the result
1325          *
1326          * @param string $text
1327          * @return string
1328          */
1329         function unsegmentForDiff( $text ) {
1330                 return $text;
1331         }
1332
1333         # convert text to different variants of a language.
1334         function convert( $text, $isTitle = false) {
1335                 return $this->mConverter->convert($text, $isTitle);
1336         }
1337
1338         # Convert text from within Parser
1339         function parserConvert( $text, &$parser ) {
1340                 return $this->mConverter->parserConvert( $text, $parser );
1341         }
1342
1343         # Tell the converter that it shouldn't convert titles
1344         function setNoTitleConvert(){
1345                 $this->mConverter->setNotitleConvert();
1346         }
1347
1348         # Check if this is a language with variants
1349         function hasVariants(){
1350                 return sizeof($this->getVariants())>1;
1351         }
1352
1353
1354         /**
1355          * Perform output conversion on a string, and encode for safe HTML output.
1356          * @param string $text
1357          * @param bool $isTitle -- wtf?
1358          * @return string
1359          * @todo this should get integrated somewhere sane
1360          */
1361         function convertHtml( $text, $isTitle = false ) {
1362                 return htmlspecialchars( $this->convert( $text, $isTitle ) );
1363         }
1364
1365         function convertCategoryKey( $key ) {
1366                 return $this->mConverter->convertCategoryKey( $key );
1367         }
1368
1369         /**
1370          * get the list of variants supported by this langauge
1371          * see sample implementation in LanguageZh.php
1372          *
1373          * @return array an array of language codes
1374          */
1375         function getVariants() {
1376                 return $this->mConverter->getVariants();
1377         }
1378
1379
1380         function getPreferredVariant( $fromUser = true ) {
1381                 return $this->mConverter->getPreferredVariant( $fromUser );
1382         }
1383
1384         /**
1385          * if a language supports multiple variants, it is
1386          * possible that non-existing link in one variant
1387          * actually exists in another variant. this function
1388          * tries to find it. See e.g. LanguageZh.php
1389          *
1390          * @param string $link the name of the link
1391          * @param mixed $nt the title object of the link
1392          * @return null the input parameters may be modified upon return
1393          */
1394         function findVariantLink( &$link, &$nt ) {
1395                 $this->mConverter->findVariantLink($link, $nt);
1396         }
1397
1398         /**
1399          * If a language supports multiple variants, converts text
1400          * into an array of all possible variants of the text:
1401          *  'variant' => text in that variant
1402          */
1403
1404         function convertLinkToAllVariants($text){
1405                 return $this->mConverter->convertLinkToAllVariants($text);
1406         }
1407
1408
1409         /**
1410          * returns language specific options used by User::getPageRenderHash()
1411          * for example, the preferred language variant
1412          *
1413          * @return string
1414          * @public
1415          */
1416         function getExtraHashOptions() {
1417                 return $this->mConverter->getExtraHashOptions();
1418         }
1419
1420         /**
1421          * for languages that support multiple variants, the title of an
1422          * article may be displayed differently in different variants. this
1423          * function returns the apporiate title defined in the body of the article.
1424          *
1425          * @return string
1426          */
1427         function getParsedTitle() {
1428                 return $this->mConverter->getParsedTitle();
1429         }
1430
1431         /**
1432          * Enclose a string with the "no conversion" tag. This is used by
1433          * various functions in the Parser
1434          *
1435          * @param string $text text to be tagged for no conversion
1436          * @return string the tagged text
1437         */
1438         function markNoConversion( $text, $noParse=false ) {
1439                 return $this->mConverter->markNoConversion( $text, $noParse );
1440         }
1441
1442         /**
1443          * A regular expression to match legal word-trailing characters
1444          * which should be merged onto a link of the form [[foo]]bar.
1445          *
1446          * @return string
1447          * @public
1448          */
1449         function linkTrail() {
1450                 $this->load();
1451                 return $this->linkTrail;
1452         }
1453
1454         function getLangObj() {
1455                 return $this;
1456         }
1457
1458         /**
1459          * Get the RFC 3066 code for this language object
1460          */
1461         function getCode() {
1462                 return $this->mCode;
1463         }
1464
1465         function setCode( $code ) {
1466                 $this->mCode = $code;
1467         }
1468
1469         static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
1470                 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
1471         }
1472
1473         static function getMessagesFileName( $code ) {
1474                 global $IP;
1475                 return self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
1476         }
1477
1478         static function getClassFileName( $code ) {
1479                 global $IP;
1480                 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
1481         }
1482
1483         static function getLocalisationArray( $code, $disableCache = false ) {
1484                 self::loadLocalisation( $code, $disableCache );
1485                 return self::$mLocalisationCache[$code];
1486         }
1487
1488         /**
1489          * Load localisation data for a given code into the static cache
1490          *
1491          * @return array Dependencies, map of filenames to mtimes
1492          */
1493         static function loadLocalisation( $code, $disableCache = false ) {
1494                 static $recursionGuard = array();
1495                 global $wgMemc;
1496
1497                 if ( !$code ) {
1498                         throw new MWException( "Invalid language code requested" );
1499                 }
1500
1501                 if ( !$disableCache ) {
1502                         # Try the per-process cache
1503                         if ( isset( self::$mLocalisationCache[$code] ) ) {
1504                                 return self::$mLocalisationCache[$code]['deps'];
1505                         }
1506
1507                         wfProfileIn( __METHOD__ );
1508
1509                         # Try the serialized directory
1510                         $cache = wfGetPrecompiledData( self::getFileName( "Messages", $code, '.ser' ) );
1511                         if ( $cache ) {
1512                                 self::$mLocalisationCache[$code] = $cache;
1513                                 wfDebug( "Got localisation for $code from precompiled data file\n" );
1514                                 wfProfileOut( __METHOD__ );
1515                                 return self::$mLocalisationCache[$code]['deps'];
1516                         }
1517
1518                         # Try the global cache
1519                         $memcKey = wfMemcKey('localisation', $code );
1520                         $cache = $wgMemc->get( $memcKey );
1521                         if ( $cache ) {
1522                                 $expired = false;
1523                                 # Check file modification times
1524                                 foreach ( $cache['deps'] as $file => $mtime ) {
1525                                         if ( !file_exists( $file ) || filemtime( $file ) > $mtime ) {
1526                                                 $expired = true;
1527                                                 break;
1528                                         }
1529                                 }
1530                                 if ( self::isLocalisationOutOfDate( $cache ) ) {
1531                                         $wgMemc->delete( $memcKey );
1532                                         $cache = false;
1533                                         wfDebug( "Localisation cache for $code had expired due to update of $file\n" );
1534                                 } else {
1535                                         self::$mLocalisationCache[$code] = $cache;
1536                                         wfDebug( "Got localisation for $code from cache\n" );
1537                                         wfProfileOut( __METHOD__ );
1538                                         return $cache['deps'];
1539                                 }
1540                         }
1541                 } else {
1542                         wfProfileIn( __METHOD__ );
1543                 }
1544
1545                 # Default fallback, may be overridden when the messages file is included
1546                 if ( $code != 'en' ) {
1547                         $fallback = 'en';
1548                 } else {
1549                         $fallback = false;
1550                 }
1551
1552                 # Load the primary localisation from the source file
1553                 $filename = self::getMessagesFileName( $code );
1554                 if ( !file_exists( $filename ) ) {
1555                         wfDebug( "No localisation file for $code, using implicit fallback to en\n" );
1556                         $cache = array();
1557                         $deps = array();
1558                 } else {
1559                         $deps = array( $filename => filemtime( $filename ) );
1560                         require( $filename );
1561                         $cache = compact( self::$mLocalisationKeys );
1562                         wfDebug( "Got localisation for $code from source\n" );
1563                 }
1564
1565                 if ( !empty( $fallback ) ) {
1566                         # Load the fallback localisation, with a circular reference guard
1567                         if ( isset( $recursionGuard[$code] ) ) {
1568                                 throw new MWException( "Error: Circular fallback reference in language code $code" );
1569                         }
1570                         $recursionGuard[$code] = true;
1571                         $newDeps = self::loadLocalisation( $fallback, $disableCache );
1572                         unset( $recursionGuard[$code] );
1573
1574                         $secondary = self::$mLocalisationCache[$fallback];
1575                         $deps = array_merge( $deps, $newDeps );
1576
1577                         # Merge the fallback localisation with the current localisation
1578                         foreach ( self::$mLocalisationKeys as $key ) {
1579                                 if ( isset( $cache[$key] ) ) {
1580                                         if ( isset( $secondary[$key] ) ) {
1581                                                 if ( in_array( $key, self::$mMergeableMapKeys ) ) {
1582                                                         $cache[$key] = $cache[$key] + $secondary[$key];
1583                                                 } elseif ( in_array( $key, self::$mMergeableListKeys ) ) {
1584                                                         $cache[$key] = array_merge( $secondary[$key], $cache[$key] );
1585                                                 } elseif ( in_array( $key, self::$mMergeableAliasListKeys ) ) {
1586                                                         $cache[$key] = array_merge_recursive( $cache[$key], $secondary[$key] );
1587                                                 }
1588                                         }
1589                                 } else {
1590                                         $cache[$key] = $secondary[$key];
1591                                 }
1592                         }
1593
1594                         # Merge bookstore lists if requested
1595                         if ( !empty( $cache['bookstoreList']['inherit'] ) ) {
1596                                 $cache['bookstoreList'] = array_merge( $cache['bookstoreList'], $secondary['bookstoreList'] );
1597                         }
1598                         if ( isset( $cache['bookstoreList']['inherit'] ) ) {
1599                                 unset( $cache['bookstoreList']['inherit'] );
1600                         }
1601                 }
1602
1603                 # Add dependencies to the cache entry
1604                 $cache['deps'] = $deps;
1605
1606                 # Replace spaces with underscores in namespace names
1607                 $cache['namespaceNames'] = str_replace( ' ', '_', $cache['namespaceNames'] );
1608
1609                 # Save to both caches
1610                 self::$mLocalisationCache[$code] = $cache;
1611                 if ( !$disableCache ) {
1612                         $wgMemc->set( $memcKey, $cache );
1613                 }
1614
1615                 wfProfileOut( __METHOD__ );
1616                 return $deps;
1617         }
1618
1619         /**
1620          * Test if a given localisation cache is out of date with respect to the
1621          * source Messages files. This is done automatically for the global cache
1622          * in $wgMemc, but is only done on certain occasions for the serialized
1623          * data file.
1624          *
1625          * @param $cache mixed Either a language code or a cache array
1626          */
1627         static function isLocalisationOutOfDate( $cache ) {
1628                 if ( !is_array( $cache ) ) {
1629                         self::loadLocalisation( $cache );
1630                         $cache = self::$mLocalisationCache[$cache];
1631                 }
1632                 $expired = false;
1633                 foreach ( $cache['deps'] as $file => $mtime ) {
1634                         if ( !file_exists( $file ) || filemtime( $file ) > $mtime ) {
1635                                 $expired = true;
1636                                 break;
1637                         }
1638                 }
1639                 return $expired;
1640         }
1641
1642         /**
1643          * Get the fallback for a given language
1644          */
1645         static function getFallbackFor( $code ) {
1646                 self::loadLocalisation( $code );
1647                 return self::$mLocalisationCache[$code]['fallback'];
1648         }
1649
1650         /**
1651          * Get all messages for a given language
1652          */
1653         static function getMessagesFor( $code ) {
1654                 self::loadLocalisation( $code );
1655                 return self::$mLocalisationCache[$code]['messages'];
1656         }
1657
1658         /**
1659          * Get a message for a given language
1660          */
1661         static function getMessageFor( $key, $code ) {
1662                 self::loadLocalisation( $code );
1663                 return isset( self::$mLocalisationCache[$code]['messages'][$key] ) ? self::$mLocalisationCache[$code]['messages'][$key] : null;
1664         }
1665
1666         /**
1667          * Load localisation data for this object
1668          */
1669         function load() {
1670                 if ( !$this->mLoaded ) {
1671                         self::loadLocalisation( $this->getCode() );
1672                         $cache =& self::$mLocalisationCache[$this->getCode()];
1673                         foreach ( self::$mLocalisationKeys as $key ) {
1674                                 $this->$key = $cache[$key];
1675                         }
1676                         $this->mLoaded = true;
1677
1678                         $this->fixUpSettings();
1679                 }
1680         }
1681
1682         /**
1683          * Do any necessary post-cache-load settings adjustment
1684          */
1685         function fixUpSettings() {
1686                 global $wgExtraNamespaces, $wgMetaNamespace, $wgMetaNamespaceTalk, $wgMessageCache,
1687                         $wgNamespaceAliases, $wgAmericanDates;
1688                 wfProfileIn( __METHOD__ );
1689                 if ( $wgExtraNamespaces ) {
1690                         $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames;
1691                 }
1692
1693                 $this->namespaceNames[NS_PROJECT] = $wgMetaNamespace;
1694                 if ( $wgMetaNamespaceTalk ) {
1695                         $this->namespaceNames[NS_PROJECT_TALK] = $wgMetaNamespaceTalk;
1696                 } else {
1697                         $talk = $this->namespaceNames[NS_PROJECT_TALK];
1698                         $talk = str_replace( '$1', $wgMetaNamespace, $talk );
1699
1700                         # Allow grammar transformations
1701                         # Allowing full message-style parsing would make simple requests
1702                         # such as action=raw much more expensive than they need to be.
1703                         # This will hopefully cover most cases.
1704                         $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
1705                                 array( &$this, 'replaceGrammarInNamespace' ), $talk );
1706                         $talk = str_replace( ' ', '_', $talk );
1707                         $this->namespaceNames[NS_PROJECT_TALK] = $talk;
1708                 }
1709
1710                 # The above mixing may leave namespaces out of canonical order.
1711                 # Re-order by namespace ID number...
1712                 ksort( $this->namespaceNames );
1713
1714                 # Put namespace names and aliases into a hashtable.
1715                 # If this is too slow, then we should arrange it so that it is done
1716                 # before caching. The catch is that at pre-cache time, the above
1717                 # class-specific fixup hasn't been done.
1718                 $this->mNamespaceIds = array();
1719                 foreach ( $this->namespaceNames as $index => $name ) {
1720                         $this->mNamespaceIds[$this->lc($name)] = $index;
1721                 }
1722                 if ( $this->namespaceAliases ) {
1723                         foreach ( $this->namespaceAliases as $name => $index ) {
1724                                 $this->mNamespaceIds[$this->lc($name)] = $index;
1725                         }
1726                 }
1727                 if ( $wgNamespaceAliases ) {
1728                         foreach ( $wgNamespaceAliases as $name => $index ) {
1729                                 $this->mNamespaceIds[$this->lc($name)] = $index;
1730                         }
1731                 }
1732
1733                 if ( $this->defaultDateFormat == 'dmy or mdy' ) {
1734                         $this->defaultDateFormat = $wgAmericanDates ? 'mdy' : 'dmy';
1735                 }
1736                 wfProfileOut( __METHOD__ );
1737         }
1738
1739         function replaceGrammarInNamespace( $m ) {
1740                 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
1741         }
1742
1743         static function getCaseMaps() {
1744                 static $wikiUpperChars, $wikiLowerChars;
1745                 if ( isset( $wikiUpperChars ) ) {
1746                         return array( $wikiUpperChars, $wikiLowerChars );
1747                 }
1748
1749                 wfProfileIn( __METHOD__ );
1750                 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
1751                 if ( $arr === false ) {
1752                         throw new MWException(
1753                                 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
1754                 }
1755                 extract( $arr );
1756                 wfProfileOut( __METHOD__ );
1757                 return array( $wikiUpperChars, $wikiLowerChars );
1758         }
1759 }
1760
1761 ?>