3 * @defgroup Language Language
9 if( !defined( 'MEDIAWIKI' ) ) {
10 echo "This file is part of MediaWiki, it is not a valid entry point.\n";
15 global $wgLanguageNames;
16 require_once( dirname(__FILE__
) . '/Names.php' ) ;
18 global $wgInputEncoding, $wgOutputEncoding;
21 * These are always UTF-8, they exist only for backwards compatibility
23 $wgInputEncoding = "UTF-8";
24 $wgOutputEncoding = "UTF-8";
26 if( function_exists( 'mb_strtoupper' ) ) {
27 mb_internal_encoding('UTF-8');
31 * a fake language converter
37 function FakeConverter($langobj) {$this->mLang
= $langobj;}
38 function convert($t, $i) {return $t;}
39 function parserConvert($t, $p) {return $t;}
40 function getVariants() { return array( $this->mLang
->getCode() ); }
41 function getPreferredVariant() {return $this->mLang
->getCode(); }
42 function findVariantLink(&$l, &$n) {}
43 function getExtraHashOptions() {return '';}
44 function getParsedTitle() {return '';}
45 function markNoConversion($text, $noParse=false) {return $text;}
46 function convertCategoryKey( $key ) {return $key; }
47 function convertLinkToAllVariants($text){ return array( $this->mLang
->getCode() => $text); }
48 function armourMath($text){ return $text; }
52 * Internationalisation code
56 var $mConverter, $mVariants, $mCode, $mLoaded = false;
57 var $mMagicExtensions = array(), $mMagicHookDone = false;
59 static public $mLocalisationKeys = array( 'fallback', 'namespaceNames',
60 'skinNames', 'mathNames',
61 'bookstoreList', 'magicWords', 'messages', 'rtl', 'digitTransformTable',
62 'separatorTransformTable', 'fallback8bitEncoding', 'linkPrefixExtension',
63 'defaultUserOptionOverrides', 'linkTrail', 'namespaceAliases',
64 'dateFormats', 'datePreferences', 'datePreferenceMigrationMap',
65 'defaultDateFormat', 'extraUserToggles', 'specialPageAliases',
69 static public $mMergeableMapKeys = array( 'messages', 'namespaceNames', 'mathNames',
70 'dateFormats', 'defaultUserOptionOverrides', 'magicWords', 'imageFiles' );
72 static public $mMergeableListKeys = array( 'extraUserToggles' );
74 static public $mMergeableAliasListKeys = array( 'specialPageAliases' );
76 static public $mLocalisationCache = array();
78 static public $mWeekdayMsgs = array(
79 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
83 static public $mWeekdayAbbrevMsgs = array(
84 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'
87 static public $mMonthMsgs = array(
88 'january', 'february', 'march', 'april', 'may_long', 'june',
89 'july', 'august', 'september', 'october', 'november',
92 static public $mMonthGenMsgs = array(
93 'january-gen', 'february-gen', 'march-gen', 'april-gen', 'may-gen', 'june-gen',
94 'july-gen', 'august-gen', 'september-gen', 'october-gen', 'november-gen',
97 static public $mMonthAbbrevMsgs = array(
98 'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
99 'sep', 'oct', 'nov', 'dec'
102 static public $mIranianCalendarMonthMsgs = array(
103 'iranian-calendar-m1', 'iranian-calendar-m2', 'iranian-calendar-m3',
104 'iranian-calendar-m4', 'iranian-calendar-m5', 'iranian-calendar-m6',
105 'iranian-calendar-m7', 'iranian-calendar-m8', 'iranian-calendar-m9',
106 'iranian-calendar-m10', 'iranian-calendar-m11', 'iranian-calendar-m12'
109 static public $mHebrewCalendarMonthMsgs = array(
110 'hebrew-calendar-m1', 'hebrew-calendar-m2', 'hebrew-calendar-m3',
111 'hebrew-calendar-m4', 'hebrew-calendar-m5', 'hebrew-calendar-m6',
112 'hebrew-calendar-m7', 'hebrew-calendar-m8', 'hebrew-calendar-m9',
113 'hebrew-calendar-m10', 'hebrew-calendar-m11', 'hebrew-calendar-m12',
114 'hebrew-calendar-m6a', 'hebrew-calendar-m6b'
117 static public $mHebrewCalendarMonthGenMsgs = array(
118 'hebrew-calendar-m1-gen', 'hebrew-calendar-m2-gen', 'hebrew-calendar-m3-gen',
119 'hebrew-calendar-m4-gen', 'hebrew-calendar-m5-gen', 'hebrew-calendar-m6-gen',
120 'hebrew-calendar-m7-gen', 'hebrew-calendar-m8-gen', 'hebrew-calendar-m9-gen',
121 'hebrew-calendar-m10-gen', 'hebrew-calendar-m11-gen', 'hebrew-calendar-m12-gen',
122 'hebrew-calendar-m6a-gen', 'hebrew-calendar-m6b-gen'
125 static public $mHijriCalendarMonthMsgs = array(
126 'hijri-calendar-m1', 'hijri-calendar-m2', 'hijri-calendar-m3',
127 'hijri-calendar-m4', 'hijri-calendar-m5', 'hijri-calendar-m6',
128 'hijri-calendar-m7', 'hijri-calendar-m8', 'hijri-calendar-m9',
129 'hijri-calendar-m10', 'hijri-calendar-m11', 'hijri-calendar-m12'
133 * Create a language object for a given language code
135 static function factory( $code ) {
137 static $recursionLevel = 0;
139 if ( $code == 'en' ) {
142 $class = 'Language' . str_replace( '-', '_', ucfirst( $code ) );
143 // Preload base classes to work around APC/PHP5 bug
144 if ( file_exists( "$IP/languages/classes/$class.deps.php" ) ) {
145 include_once("$IP/languages/classes/$class.deps.php");
147 if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
148 include_once("$IP/languages/classes/$class.php");
152 if ( $recursionLevel > 5 ) {
153 throw new MWException( "Language fallback loop detected when creating class $class\n" );
156 if( ! class_exists( $class ) ) {
157 $fallback = Language
::getFallbackFor( $code );
159 $lang = Language
::factory( $fallback );
161 $lang->setCode( $code );
169 function __construct() {
170 $this->mConverter
= new FakeConverter($this);
171 // Set the code to the name of the descendant
172 if ( get_class( $this ) == 'Language' ) {
175 $this->mCode
= str_replace( '_', '-', strtolower( substr( get_class( $this ), 8 ) ) );
180 * Hook which will be called if this is the content language.
181 * Descendants can use this to register hook functions or modify globals
183 function initContLang() {}
186 * @deprecated Use User::getDefaultOptions()
189 function getDefaultUserOptions() {
190 wfDeprecated( __METHOD__
);
191 return User
::getDefaultOptions();
194 function getFallbackLanguageCode() {
195 return self
::getFallbackFor( $this->mCode
);
199 * Exports $wgBookstoreListEn
202 function getBookstoreList() {
204 return $this->bookstoreList
;
210 function getNamespaces() {
212 return $this->namespaceNames
;
216 * A convenience function that returns the same thing as
217 * getNamespaces() except with the array values changed to ' '
218 * where it found '_', useful for producing output to be displayed
219 * e.g. in <select> forms.
223 function getFormattedNamespaces() {
224 $ns = $this->getNamespaces();
225 foreach($ns as $k => $v) {
226 $ns[$k] = strtr($v, '_', ' ');
232 * Get a namespace value by key
234 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
235 * echo $mw_ns; // prints 'MediaWiki'
238 * @param $index Int: the array key of the namespace to return
239 * @return mixed, string if the namespace value exists, otherwise false
241 function getNsText( $index ) {
242 $ns = $this->getNamespaces();
243 return isset( $ns[$index] ) ?
$ns[$index] : false;
247 * A convenience function that returns the same thing as
248 * getNsText() except with '_' changed to ' ', useful for
253 function getFormattedNsText( $index ) {
254 $ns = $this->getNsText( $index );
255 return strtr($ns, '_', ' ');
259 * Get a namespace key by value, case insensitive.
260 * Only matches namespace names for the current language, not the
261 * canonical ones defined in Namespace.php.
263 * @param $text String
264 * @return mixed An integer if $text is a valid value otherwise false
266 function getLocalNsIndex( $text ) {
268 $lctext = $this->lc($text);
269 return isset( $this->mNamespaceIds
[$lctext] ) ?
$this->mNamespaceIds
[$lctext] : false;
273 * Get a namespace key by value, case insensitive. Canonical namespace
274 * names override custom ones defined for the current language.
276 * @param $text String
277 * @return mixed An integer if $text is a valid value otherwise false
279 function getNsIndex( $text ) {
281 $lctext = $this->lc($text);
282 if( ( $ns = MWNamespace
::getCanonicalIndex( $lctext ) ) !== null ) return $ns;
283 return isset( $this->mNamespaceIds
[$lctext] ) ?
$this->mNamespaceIds
[$lctext] : false;
287 * short names for language variants used for language conversion links.
289 * @param $code String
292 function getVariantname( $code ) {
293 return $this->getMessageFromDB( "variantname-$code" );
296 function specialPage( $name ) {
297 $aliases = $this->getSpecialPageAliases();
298 if ( isset( $aliases[$name][0] ) ) {
299 $name = $aliases[$name][0];
301 return $this->getNsText(NS_SPECIAL
) . ':' . $name;
304 function getQuickbarSettings() {
306 $this->getMessage( 'qbsettings-none' ),
307 $this->getMessage( 'qbsettings-fixedleft' ),
308 $this->getMessage( 'qbsettings-fixedright' ),
309 $this->getMessage( 'qbsettings-floatingleft' ),
310 $this->getMessage( 'qbsettings-floatingright' )
314 function getSkinNames() {
316 return $this->skinNames
;
319 function getMathNames() {
321 return $this->mathNames
;
324 function getDatePreferences() {
326 return $this->datePreferences
;
329 function getDateFormats() {
331 return $this->dateFormats
;
334 function getDefaultDateFormat() {
336 return $this->defaultDateFormat
;
339 function getDatePreferenceMigrationMap() {
341 return $this->datePreferenceMigrationMap
;
344 function getImageFile( $image ) {
346 return $this->imageFiles
[$image];
349 function getDefaultUserOptionOverrides() {
351 # XXX - apparently some languageas get empty arrays, didn't get to it yet -- midom
352 if (is_array($this->defaultUserOptionOverrides
)) {
353 return $this->defaultUserOptionOverrides
;
359 function getExtraUserToggles() {
361 return $this->extraUserToggles
;
364 function getUserToggle( $tog ) {
365 return $this->getMessageFromDB( "tog-$tog" );
369 * Get language names, indexed by code.
370 * If $customisedOnly is true, only returns codes with a messages file
372 public static function getLanguageNames( $customisedOnly = false ) {
373 global $wgLanguageNames, $wgExtraLanguageNames;
374 $allNames = $wgExtraLanguageNames +
$wgLanguageNames;
375 if ( !$customisedOnly ) {
381 $dir = opendir( "$IP/languages/messages" );
382 while( false !== ( $file = readdir( $dir ) ) ) {
384 if( preg_match( '/Messages([A-Z][a-z_]+)\.php$/', $file, $m ) ) {
385 $code = str_replace( '_', '-', strtolower( $m[1] ) );
386 if ( isset( $allNames[$code] ) ) {
387 $names[$code] = $allNames[$code];
396 * Ugly hack to get a message maybe from the MediaWiki namespace, if this
397 * language object is the content or user language.
399 function getMessageFromDB( $msg ) {
400 global $wgContLang, $wgLang;
401 if ( $wgContLang->getCode() == $this->getCode() ) {
403 return wfMsgForContent( $msg );
404 } elseif ( $wgLang->getCode() == $this->getCode() ) {
406 return wfMsg( $msg );
408 # Neither, get from localisation
409 return $this->getMessage( $msg );
413 function getLanguageName( $code ) {
414 $names = self
::getLanguageNames();
415 if ( !array_key_exists( $code, $names ) ) {
418 return $names[$code];
421 function getMonthName( $key ) {
422 return $this->getMessageFromDB( self
::$mMonthMsgs[$key-1] );
425 function getMonthNameGen( $key ) {
426 return $this->getMessageFromDB( self
::$mMonthGenMsgs[$key-1] );
429 function getMonthAbbreviation( $key ) {
430 return $this->getMessageFromDB( self
::$mMonthAbbrevMsgs[$key-1] );
433 function getWeekdayName( $key ) {
434 return $this->getMessageFromDB( self
::$mWeekdayMsgs[$key-1] );
437 function getWeekdayAbbreviation( $key ) {
438 return $this->getMessageFromDB( self
::$mWeekdayAbbrevMsgs[$key-1] );
441 function getIranianCalendarMonthName( $key ) {
442 return $this->getMessageFromDB( self
::$mIranianCalendarMonthMsgs[$key-1] );
445 function getHebrewCalendarMonthName( $key ) {
446 return $this->getMessageFromDB( self
::$mHebrewCalendarMonthMsgs[$key-1] );
449 function getHebrewCalendarMonthNameGen( $key ) {
450 return $this->getMessageFromDB( self
::$mHebrewCalendarMonthGenMsgs[$key-1] );
453 function getHijriCalendarMonthName( $key ) {
454 return $this->getMessageFromDB( self
::$mHijriCalendarMonthMsgs[$key-1] );
458 * Used by date() and time() to adjust the time output.
460 * @param $ts Int the time in date('YmdHis') format
461 * @param $tz Mixed: adjust the time by this amount (default false, mean we
462 * get user timecorrection setting)
465 function userAdjust( $ts, $tz = false ) {
466 global $wgUser, $wgLocalTZoffset;
469 $tz = $wgUser->getOption( 'timecorrection' );
472 # minutes and hours differences:
477 # Global offset in minutes.
478 if( isset($wgLocalTZoffset) ) {
479 if( $wgLocalTZoffset >= 0 ) {
480 $hrDiff = floor($wgLocalTZoffset / 60);
482 $hrDiff = ceil($wgLocalTZoffset / 60);
484 $minDiff = $wgLocalTZoffset %
60;
486 } elseif ( strpos( $tz, ':' ) !== false ) {
487 $tzArray = explode( ':', $tz );
488 $hrDiff = intval($tzArray[0]);
489 $minDiff = intval($hrDiff < 0 ?
-$tzArray[1] : $tzArray[1]);
491 $hrDiff = intval( $tz );
494 # No difference ? Return time unchanged
495 if ( 0 == $hrDiff && 0 == $minDiff ) { return $ts; }
497 wfSuppressWarnings(); // E_STRICT system time bitching
498 # Generate an adjusted date
500 (int)substr( $ts, 8, 2) ) +
$hrDiff, # Hours
501 (int)substr( $ts, 10, 2 ) +
$minDiff, # Minutes
502 (int)substr( $ts, 12, 2 ), # Seconds
503 (int)substr( $ts, 4, 2 ), # Month
504 (int)substr( $ts, 6, 2 ), # Day
505 (int)substr( $ts, 0, 4 ) ); #Year
507 $date = date( 'YmdHis', $t );
514 * This is a workalike of PHP's date() function, but with better
515 * internationalisation, a reduced set of format characters, and a better
518 * Supported format characters are dDjlNwzWFmMntLYyaAgGhHiscrU. See the
519 * PHP manual for definitions. There are a number of extensions, which
522 * xn Do not translate digits of the next numeric format character
523 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
524 * xr Use roman numerals for the next numeric format character
525 * xh Use hebrew numerals for the next numeric format character
527 * xg Genitive month name
529 * xij j (day number) in Iranian calendar
530 * xiF F (month name) in Iranian calendar
531 * xin n (month number) in Iranian calendar
532 * xiY Y (full year) in Iranian calendar
534 * xjj j (day number) in Hebrew calendar
535 * xjF F (month name) in Hebrew calendar
536 * xjt t (days in month) in Hebrew calendar
537 * xjx xg (genitive month name) in Hebrew calendar
538 * xjn n (month number) in Hebrew calendar
539 * xjY Y (full year) in Hebrew calendar
541 * xmj j (day number) in Hijri calendar
542 * xmF F (month name) in Hijri calendar
543 * xmn n (month number) in Hijri calendar
544 * xmY Y (full year) in Hijri calendar
546 * xkY Y (full year) in Thai solar calendar. Months and days are
547 * identical to the Gregorian calendar
549 * Characters enclosed in double quotes will be considered literal (with
550 * the quotes themselves removed). Unmatched quotes will be considered
551 * literal quotes. Example:
553 * "The month is" F => The month is January
556 * Backslash escaping is also supported.
558 * Input timestamp is assumed to be pre-normalized to the desired local
561 * @param $format String
562 * @param $ts String: 14-character timestamp
566 function sprintfDate( $format, $ts ) {
577 for ( $p = 0; $p < strlen( $format ); $p++
) {
580 if ( $code == 'x' && $p < strlen( $format ) - 1 ) {
581 $code .= $format[++
$p];
584 if ( ( $code === 'xi' ||
$code == 'xj' ||
$code == 'xk' ||
$code == 'xm' ) && $p < strlen( $format ) - 1 ) {
585 $code .= $format[++
$p];
596 $rawToggle = !$rawToggle;
605 $s .= $this->getMonthNameGen( substr( $ts, 4, 2 ) );
608 if ( !$hebrew ) $hebrew = self
::tsToHebrew( $ts );
609 $s .= $this->getHebrewCalendarMonthNameGen( $hebrew[1] );
612 $num = substr( $ts, 6, 2 );
615 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
616 $s .= $this->getWeekdayAbbreviation( gmdate( 'w', $unix ) +
1 );
619 $num = intval( substr( $ts, 6, 2 ) );
622 if ( !$iranian ) $iranian = self
::tsToIranian( $ts );
626 if ( !$hijri ) $hijri = self
::tsToHijri( $ts );
630 if ( !$hebrew ) $hebrew = self
::tsToHebrew( $ts );
634 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
635 $s .= $this->getWeekdayName( gmdate( 'w', $unix ) +
1 );
638 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
639 $w = gmdate( 'w', $unix );
643 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
644 $num = gmdate( 'w', $unix );
647 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
648 $num = gmdate( 'z', $unix );
651 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
652 $num = gmdate( 'W', $unix );
655 $s .= $this->getMonthName( substr( $ts, 4, 2 ) );
658 if ( !$iranian ) $iranian = self
::tsToIranian( $ts );
659 $s .= $this->getIranianCalendarMonthName( $iranian[1] );
662 if ( !$hijri ) $hijri = self
::tsToHijri( $ts );
663 $s .= $this->getHijriCalendarMonthName( $hijri[1] );
666 if ( !$hebrew ) $hebrew = self
::tsToHebrew( $ts );
667 $s .= $this->getHebrewCalendarMonthName( $hebrew[1] );
670 $num = substr( $ts, 4, 2 );
673 $s .= $this->getMonthAbbreviation( substr( $ts, 4, 2 ) );
676 $num = intval( substr( $ts, 4, 2 ) );
679 if ( !$iranian ) $iranian = self
::tsToIranian( $ts );
683 if ( !$hijri ) $hijri = self
::tsToHijri ( $ts );
687 if ( !$hebrew ) $hebrew = self
::tsToHebrew( $ts );
691 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
692 $num = gmdate( 't', $unix );
695 if ( !$hebrew ) $hebrew = self
::tsToHebrew( $ts );
699 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
700 $num = gmdate( 'L', $unix );
703 $num = substr( $ts, 0, 4 );
706 if ( !$iranian ) $iranian = self
::tsToIranian( $ts );
710 if ( !$hijri ) $hijri = self
::tsToHijri( $ts );
714 if ( !$hebrew ) $hebrew = self
::tsToHebrew( $ts );
718 if ( !$thai ) $thai = self
::tsToThai( $ts );
722 $num = substr( $ts, 2, 2 );
725 $s .= intval( substr( $ts, 8, 2 ) ) < 12 ?
'am' : 'pm';
728 $s .= intval( substr( $ts, 8, 2 ) ) < 12 ?
'AM' : 'PM';
731 $h = substr( $ts, 8, 2 );
732 $num = $h %
12 ?
$h %
12 : 12;
735 $num = intval( substr( $ts, 8, 2 ) );
738 $h = substr( $ts, 8, 2 );
739 $num = sprintf( '%02d', $h %
12 ?
$h %
12 : 12 );
742 $num = substr( $ts, 8, 2 );
745 $num = substr( $ts, 10, 2 );
748 $num = substr( $ts, 12, 2 );
751 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
752 $s .= gmdate( 'c', $unix );
755 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
756 $s .= gmdate( 'r', $unix );
759 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
764 if ( $p < strlen( $format ) - 1 ) {
772 if ( $p < strlen( $format ) - 1 ) {
773 $endQuote = strpos( $format, '"', $p +
1 );
774 if ( $endQuote === false ) {
775 # No terminating quote, assume literal "
778 $s .= substr( $format, $p +
1, $endQuote - $p - 1 );
782 # Quote at end of string, assume literal "
789 if ( $num !== false ) {
790 if ( $rawToggle ||
$raw ) {
793 } elseif ( $roman ) {
794 $s .= self
::romanNumeral( $num );
796 } elseif( $hebrewNum ) {
797 $s .= self
::hebrewNumeral( $num );
800 $s .= $this->formatNum( $num, true );
808 private static $GREG_DAYS = array( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
809 private static $IRANIAN_DAYS = array( 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29 );
811 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
812 * Gregorian dates to Iranian dates. Originally written in C, it
813 * is released under the terms of GNU Lesser General Public
814 * License. Conversion to PHP was performed by Niklas Laxström.
816 * Link: http://www.farsiweb.info/jalali/jalali.c
818 private static function tsToIranian( $ts ) {
819 $gy = substr( $ts, 0, 4 ) -1600;
820 $gm = substr( $ts, 4, 2 ) -1;
821 $gd = substr( $ts, 6, 2 ) -1;
823 # Days passed from the beginning (including leap years)
826 - floor(($gy+
99) / 100)
827 +
floor(($gy+
399) / 400);
830 // Add days of the past months of this year
831 for( $i = 0; $i < $gm; $i++
) {
832 $gDayNo +
= self
::$GREG_DAYS[$i];
836 if ( $gm > 1 && (($gy%4
===0 && $gy%100
!==0 ||
($gy%400
==0)))) {
840 // Days passed in current month
843 $jDayNo = $gDayNo - 79;
845 $jNp = floor($jDayNo / 12053);
848 $jy = 979 +
33*$jNp +
4*floor($jDayNo/1461);
851 if ( $jDayNo >= 366 ) {
852 $jy +
= floor(($jDayNo-1)/365);
853 $jDayNo = floor(($jDayNo-1)%365
);
856 for ( $i = 0; $i < 11 && $jDayNo >= self
::$IRANIAN_DAYS[$i]; $i++
) {
857 $jDayNo -= self
::$IRANIAN_DAYS[$i];
863 return array($jy, $jm, $jd);
866 * Converting Gregorian dates to Hijri dates.
868 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
870 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
872 private static function tsToHijri ( $ts ) {
873 $year = substr( $ts, 0, 4 );
874 $month = substr( $ts, 4, 2 );
875 $day = substr( $ts, 6, 2 );
884 if (($zy>1582)||
(($zy==1582)&&($zm>10))||
(($zy==1582)&&($zm==10)&&($zd>14)))
888 $zjd=(int)((1461*($zy +
4800 +
(int)( ($zm-14) /12) ))/4) +
(int)((367*($zm-2-12*((int)(($zm-14)/12))))/12)-(int)((3*(int)(( ($zy+
4900+
(int)(($zm-14)/12))/100)))/4)+
$zd-32075;
892 $zjd = 367*$zy-(int)((7*($zy+
5001+
(int)(($zm-9)/7)))/4)+
(int)((275*$zm)/9)+
$zd+
1729777;
895 $zl=$zjd-1948440+
10632;
896 $zn=(int)(($zl-1)/10631);
897 $zl=$zl-10631*$zn+
354;
898 $zj=((int)((10985-$zl)/5316))*((int)((50*$zl)/17719))+
((int)($zl/5670))*((int)((43*$zl)/15238));
899 $zl=$zl-((int)((30-$zj)/15))*((int)((17719*$zj)/50))-((int)($zj/16))*((int)((15238*$zj)/43))+
29;
900 $zm=(int)((24*$zl)/709);
901 $zd=$zl-(int)((709*$zm)/24);
904 return array ($zy, $zm, $zd);
908 * Converting Gregorian dates to Hebrew dates.
910 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
911 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
912 * to translate the relevant functions into PHP and release them under
915 private static function tsToHebrew( $ts ) {
917 $year = substr( $ts, 0, 4 );
918 $month = substr( $ts, 4, 2 );
919 $day = substr( $ts, 6, 2 );
921 # Calculate Hebrew year
922 $hebrewYear = $year +
3760;
924 # Month number when September = 1, August = 12
933 # Calculate day of year from 1 September
935 for( $i = 1; $i < $month; $i++
) {
939 # Check if the year is leap
940 if( $year %
400 == 0 ||
( $year %
4 == 0 && $year %
100 > 0 ) ) {
943 } elseif( $i == 8 ||
$i == 10 ||
$i == 1 ||
$i == 3 ) {
950 # Calculate the start of the Hebrew year
951 $start = self
::hebrewYearStart( $hebrewYear );
953 # Calculate next year's start
954 if( $dayOfYear <= $start ) {
955 # Day is before the start of the year - it is the previous year
961 # Add days since previous year's 1 September
963 if( ( $year %
400 == 0 ) ||
( $year %
100 != 0 && $year %
4 == 0 ) ) {
967 # Start of the new (previous) year
968 $start = self
::hebrewYearStart( $hebrewYear );
971 $nextStart = self
::hebrewYearStart( $hebrewYear +
1 );
974 # Calculate Hebrew day of year
975 $hebrewDayOfYear = $dayOfYear - $start;
977 # Difference between year's days
978 $diff = $nextStart - $start;
979 # Add 12 (or 13 for leap years) days to ignore the difference between
980 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
981 # difference is only about the year type
982 if( ( $year %
400 == 0 ) ||
( $year %
100 != 0 && $year %
4 == 0 ) ) {
988 # Check the year pattern, and is leap year
989 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
990 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
992 $yearPattern = $diff %
30;
994 $isLeap = $diff >= 30;
996 # Calculate day in the month from number of day in the Hebrew year
997 # Don't check Adar - if the day is not in Adar, we will stop before;
998 # if it is in Adar, we will use it to check if it is Adar I or Adar II
999 $hebrewDay = $hebrewDayOfYear;
1002 while( $hebrewMonth <= 12 ) {
1003 # Calculate days in this month
1004 if( $isLeap && $hebrewMonth == 6 ) {
1005 # Adar in a leap year
1007 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1009 if( $hebrewDay <= $days ) {
1013 # Subtract the days of Adar I
1014 $hebrewDay -= $days;
1017 if( $hebrewDay <= $days ) {
1023 } elseif( $hebrewMonth == 2 && $yearPattern == 2 ) {
1024 # Cheshvan in a complete year (otherwise as the rule below)
1026 } elseif( $hebrewMonth == 3 && $yearPattern == 0 ) {
1027 # Kislev in an incomplete year (otherwise as the rule below)
1030 # Odd months have 30 days, even have 29
1031 $days = 30 - ( $hebrewMonth - 1 ) %
2;
1033 if( $hebrewDay <= $days ) {
1034 # In the current month
1037 # Subtract the days of the current month
1038 $hebrewDay -= $days;
1039 # Try in the next month
1044 return array( $hebrewYear, $hebrewMonth, $hebrewDay, $days );
1048 * This calculates the Hebrew year start, as days since 1 September.
1049 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1050 * Used for Hebrew date.
1052 private static function hebrewYearStart( $year ) {
1053 $a = intval( ( 12 * ( $year - 1 ) +
17 ) %
19 );
1054 $b = intval( ( $year - 1 ) %
4 );
1055 $m = 32.044093161144 +
1.5542417966212 * $a +
$b / 4.0 - 0.0031777940220923 * ( $year - 1 );
1059 $Mar = intval( $m );
1065 $c = intval( ( $Mar +
3 * ( $year - 1 ) +
5 * $b +
5 ) %
7);
1066 if( $c == 0 && $a > 11 && $m >= 0.89772376543210 ) {
1068 } else if( $c == 1 && $a > 6 && $m >= 0.63287037037037 ) {
1070 } else if( $c == 2 ||
$c == 4 ||
$c == 6 ) {
1074 $Mar +
= intval( ( $year - 3761 ) / 100 ) - intval( ( $year - 3761 ) / 400 ) - 24;
1079 * Algorithm to convert Gregorian dates to Thai solar dates.
1081 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1083 * @param $ts String: 14-character timestamp
1084 * @return array converted year, month, day
1086 private static function tsToThai( $ts ) {
1087 $gy = substr( $ts, 0, 4 );
1088 $gm = substr( $ts, 4, 2 );
1089 $gd = substr( $ts, 6, 2 );
1091 # Add 543 years to the Gregorian calendar
1092 # Months and days are identical
1093 $gy_thai = $gy +
543;
1095 return array( $gy_thai, $gm, $gd );
1100 * Roman number formatting up to 3000
1102 static function romanNumeral( $num ) {
1103 static $table = array(
1104 array( '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X' ),
1105 array( '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', 'C' ),
1106 array( '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', 'M' ),
1107 array( '', 'M', 'MM', 'MMM' )
1110 $num = intval( $num );
1111 if ( $num > 3000 ||
$num <= 0 ) {
1116 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1117 if ( $num >= $pow10 ) {
1118 $s .= $table[$i][floor($num / $pow10)];
1120 $num = $num %
$pow10;
1126 * Hebrew Gematria number formatting up to 9999
1128 static function hebrewNumeral( $num ) {
1129 static $table = array(
1130 array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' ),
1131 array( '', 'י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ', 'ק' ),
1132 array( '', 'ק', 'ר', 'ש', 'ת', 'תק', 'תר', 'תש', 'תת', 'תתק', 'תתר' ),
1133 array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' )
1136 $num = intval( $num );
1137 if ( $num > 9999 ||
$num <= 0 ) {
1142 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1143 if ( $num >= $pow10 ) {
1144 if ( $num == 15 ||
$num == 16 ) {
1145 $s .= $table[0][9] . $table[0][$num - 9];
1148 $s .= $table[$i][intval( ( $num / $pow10 ) )];
1149 if( $pow10 == 1000 ) {
1154 $num = $num %
$pow10;
1156 if( strlen( $s ) == 2 ) {
1159 $str = substr( $s, 0, strlen( $s ) - 2 ) . '"';
1160 $str .= substr( $s, strlen( $s ) - 2, 2 );
1162 $start = substr( $str, 0, strlen( $str ) - 2 );
1163 $end = substr( $str, strlen( $str ) - 2 );
1166 $str = $start . 'ך';
1169 $str = $start . 'ם';
1172 $str = $start . 'ן';
1175 $str = $start . 'ף';
1178 $str = $start . 'ץ';
1185 * This is meant to be used by time(), date(), and timeanddate() to get
1186 * the date preference they're supposed to use, it should be used in
1190 * function timeanddate([...], $format = true) {
1191 * $datePreference = $this->dateFormat($format);
1196 * @param $usePrefs Mixed: if true, the user's preference is used
1197 * if false, the site/language default is used
1198 * if int/string, assumed to be a format.
1201 function dateFormat( $usePrefs = true ) {
1204 if( is_bool( $usePrefs ) ) {
1206 $datePreference = $wgUser->getDatePreference();
1208 $options = User
::getDefaultOptions();
1209 $datePreference = (string)$options['date'];
1212 $datePreference = (string)$usePrefs;
1216 if( $datePreference == '' ) {
1220 return $datePreference;
1224 * @param $ts Mixed: the time format which needs to be turned into a
1225 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1226 * @param $adj Bool: whether to adjust the time output according to the
1227 * user configured offset ($timecorrection)
1228 * @param $format Mixed: true to use user's date format preference
1229 * @param $timecorrection String: the time offset as returned by
1230 * validateTimeZone() in Special:Preferences
1233 function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
1236 $ts = $this->userAdjust( $ts, $timecorrection );
1239 $pref = $this->dateFormat( $format );
1240 if( $pref == 'default' ||
!isset( $this->dateFormats
["$pref date"] ) ) {
1241 $pref = $this->defaultDateFormat
;
1243 return $this->sprintfDate( $this->dateFormats
["$pref date"], $ts );
1247 * @param $ts Mixed: the time format which needs to be turned into a
1248 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1249 * @param $adj Bool: whether to adjust the time output according to the
1250 * user configured offset ($timecorrection)
1251 * @param $format Mixed: true to use user's date format preference
1252 * @param $timecorrection String: the time offset as returned by
1253 * validateTimeZone() in Special:Preferences
1256 function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
1259 $ts = $this->userAdjust( $ts, $timecorrection );
1262 $pref = $this->dateFormat( $format );
1263 if( $pref == 'default' ||
!isset( $this->dateFormats
["$pref time"] ) ) {
1264 $pref = $this->defaultDateFormat
;
1266 return $this->sprintfDate( $this->dateFormats
["$pref time"], $ts );
1270 * @param $ts Mixed: the time format which needs to be turned into a
1271 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1272 * @param $adj Bool: whether to adjust the time output according to the
1273 * user configured offset ($timecorrection)
1274 * @param $format Mixed: what format to return, if it's false output the
1275 * default one (default true)
1276 * @param $timecorrection String: the time offset as returned by
1277 * validateTimeZone() in Special:Preferences
1280 function timeanddate( $ts, $adj = false, $format = true, $timecorrection = false) {
1283 $ts = wfTimestamp( TS_MW
, $ts );
1286 $ts = $this->userAdjust( $ts, $timecorrection );
1289 $pref = $this->dateFormat( $format );
1290 if( $pref == 'default' ||
!isset( $this->dateFormats
["$pref both"] ) ) {
1291 $pref = $this->defaultDateFormat
;
1294 return $this->sprintfDate( $this->dateFormats
["$pref both"], $ts );
1297 function getMessage( $key ) {
1299 return isset( $this->messages
[$key] ) ?
$this->messages
[$key] : null;
1302 function getAllMessages() {
1304 return $this->messages
;
1307 function iconv( $in, $out, $string ) {
1308 # For most languages, this is a wrapper for iconv
1309 return iconv( $in, $out . '//IGNORE', $string );
1312 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1313 function ucwordbreaksCallbackAscii($matches){
1314 return $this->ucfirst($matches[1]);
1317 function ucwordbreaksCallbackMB($matches){
1318 return mb_strtoupper($matches[0]);
1321 function ucCallback($matches){
1322 list( $wikiUpperChars ) = self
::getCaseMaps();
1323 return strtr( $matches[1], $wikiUpperChars );
1326 function lcCallback($matches){
1327 list( , $wikiLowerChars ) = self
::getCaseMaps();
1328 return strtr( $matches[1], $wikiLowerChars );
1331 function ucwordsCallbackMB($matches){
1332 return mb_strtoupper($matches[0]);
1335 function ucwordsCallbackWiki($matches){
1336 list( $wikiUpperChars ) = self
::getCaseMaps();
1337 return strtr( $matches[0], $wikiUpperChars );
1340 function ucfirst( $str ) {
1341 if ( empty($str) ) return $str;
1342 if ( ord($str[0]) < 128 ) return ucfirst($str);
1343 else return self
::uc($str,true); // fall back to more complex logic in case of multibyte strings
1346 function uc( $str, $first = false ) {
1347 if ( function_exists( 'mb_strtoupper' ) ) {
1349 if ( self
::isMultibyte( $str ) ) {
1350 return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1352 return ucfirst( $str );
1355 return self
::isMultibyte( $str ) ?
mb_strtoupper( $str ) : strtoupper( $str );
1358 if ( self
::isMultibyte( $str ) ) {
1359 list( $wikiUpperChars ) = $this->getCaseMaps();
1360 $x = $first ?
'^' : '';
1361 return preg_replace_callback(
1362 "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1363 array($this,"ucCallback"),
1367 return $first ?
ucfirst( $str ) : strtoupper( $str );
1372 function lcfirst( $str ) {
1373 if ( empty($str) ) return $str;
1374 if ( is_string( $str ) && ord($str[0]) < 128 ) {
1375 // editing string in place = cool
1376 $str[0]=strtolower($str[0]);
1379 else return self
::lc( $str, true );
1382 function lc( $str, $first = false ) {
1383 if ( function_exists( 'mb_strtolower' ) )
1385 if ( self
::isMultibyte( $str ) )
1386 return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1388 return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
1390 return self
::isMultibyte( $str ) ?
mb_strtolower( $str ) : strtolower( $str );
1392 if ( self
::isMultibyte( $str ) ) {
1393 list( , $wikiLowerChars ) = self
::getCaseMaps();
1394 $x = $first ?
'^' : '';
1395 return preg_replace_callback(
1396 "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1397 array($this,"lcCallback"),
1401 return $first ?
strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
1404 function isMultibyte( $str ) {
1405 return (bool)preg_match( '/[\x80-\xff]/', $str );
1408 function ucwords($str) {
1409 if ( self
::isMultibyte( $str ) ) {
1410 $str = self
::lc($str);
1412 // regexp to find first letter in each word (i.e. after each space)
1413 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1415 // function to use to capitalize a single char
1416 if ( function_exists( 'mb_strtoupper' ) )
1417 return preg_replace_callback(
1419 array($this,"ucwordsCallbackMB"),
1423 return preg_replace_callback(
1425 array($this,"ucwordsCallbackWiki"),
1430 return ucwords( strtolower( $str ) );
1433 # capitalize words at word breaks
1434 function ucwordbreaks($str){
1435 if (self
::isMultibyte( $str ) ) {
1436 $str = self
::lc($str);
1438 // since \b doesn't work for UTF-8, we explicitely define word break chars
1439 $breaks= "[ \-\(\)\}\{\.,\?!]";
1441 // find first letter after word break
1442 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1444 if ( function_exists( 'mb_strtoupper' ) )
1445 return preg_replace_callback(
1447 array($this,"ucwordbreaksCallbackMB"),
1451 return preg_replace_callback(
1453 array($this,"ucwordsCallbackWiki"),
1458 return preg_replace_callback(
1459 '/\b([\w\x80-\xff]+)\b/',
1460 array($this,"ucwordbreaksCallbackAscii"),
1465 * Return a case-folded representation of $s
1467 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1468 * and $s2 are the same except for the case of their characters. It is not
1469 * necessary for the value returned to make sense when displayed.
1471 * Do *not* perform any other normalisation in this function. If a caller
1472 * uses this function when it should be using a more general normalisation
1473 * function, then fix the caller.
1475 function caseFold( $s ) {
1476 return $this->uc( $s );
1479 function checkTitleEncoding( $s ) {
1480 if( is_array( $s ) ) {
1481 wfDebugDieBacktrace( 'Given array to checkTitleEncoding.' );
1483 # Check for non-UTF-8 URLs
1484 $ishigh = preg_match( '/[\x80-\xff]/', $s);
1485 if(!$ishigh) return $s;
1487 $isutf8 = preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1488 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
1489 if( $isutf8 ) return $s;
1491 return $this->iconv( $this->fallback8bitEncoding(), "utf-8", $s );
1494 function fallback8bitEncoding() {
1496 return $this->fallback8bitEncoding
;
1500 * Some languages have special punctuation to strip out
1501 * or characters which need to be converted for MySQL's
1502 * indexing to grok it correctly. Make such changes here.
1504 * @param $string String
1507 function stripForSearch( $string ) {
1509 if ( $wgDBtype != 'mysql' ) {
1513 # MySQL fulltext index doesn't grok utf-8, so we
1514 # need to fold cases and convert to hex
1516 wfProfileIn( __METHOD__
);
1517 if( function_exists( 'mb_strtolower' ) ) {
1518 $out = preg_replace(
1519 "/([\\xc0-\\xff][\\x80-\\xbf]*)/e",
1520 "'U8' . bin2hex( \"$1\" )",
1521 mb_strtolower( $string ) );
1523 list( , $wikiLowerChars ) = self
::getCaseMaps();
1524 $out = preg_replace(
1525 "/([\\xc0-\\xff][\\x80-\\xbf]*)/e",
1526 "'U8' . bin2hex( strtr( \"\$1\", \$wikiLowerChars ) )",
1529 wfProfileOut( __METHOD__
);
1533 function convertForSearchResult( $termsArray ) {
1534 # some languages, e.g. Chinese, need to do a conversion
1535 # in order for search results to be displayed correctly
1540 * Get the first character of a string.
1545 function firstChar( $s ) {
1547 preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1548 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/', $s, $matches);
1550 if ( isset( $matches[1] ) ) {
1551 if ( strlen( $matches[1] ) != 3 ) {
1555 // Break down Hangul syllables to grab the first jamo
1556 $code = utf8ToCodepoint( $matches[1] );
1557 if ( $code < 0xac00 ||
0xd7a4 <= $code) {
1559 } elseif ( $code < 0xb098 ) {
1560 return "\xe3\x84\xb1";
1561 } elseif ( $code < 0xb2e4 ) {
1562 return "\xe3\x84\xb4";
1563 } elseif ( $code < 0xb77c ) {
1564 return "\xe3\x84\xb7";
1565 } elseif ( $code < 0xb9c8 ) {
1566 return "\xe3\x84\xb9";
1567 } elseif ( $code < 0xbc14 ) {
1568 return "\xe3\x85\x81";
1569 } elseif ( $code < 0xc0ac ) {
1570 return "\xe3\x85\x82";
1571 } elseif ( $code < 0xc544 ) {
1572 return "\xe3\x85\x85";
1573 } elseif ( $code < 0xc790 ) {
1574 return "\xe3\x85\x87";
1575 } elseif ( $code < 0xcc28 ) {
1576 return "\xe3\x85\x88";
1577 } elseif ( $code < 0xce74 ) {
1578 return "\xe3\x85\x8a";
1579 } elseif ( $code < 0xd0c0 ) {
1580 return "\xe3\x85\x8b";
1581 } elseif ( $code < 0xd30c ) {
1582 return "\xe3\x85\x8c";
1583 } elseif ( $code < 0xd558 ) {
1584 return "\xe3\x85\x8d";
1586 return "\xe3\x85\x8e";
1593 function initEncoding() {
1594 # Some languages may have an alternate char encoding option
1595 # (Esperanto X-coding, Japanese furigana conversion, etc)
1596 # If this language is used as the primary content language,
1597 # an override to the defaults can be set here on startup.
1600 function recodeForEdit( $s ) {
1601 # For some languages we'll want to explicitly specify
1602 # which characters make it into the edit box raw
1603 # or are converted in some way or another.
1604 # Note that if wgOutputEncoding is different from
1605 # wgInputEncoding, this text will be further converted
1606 # to wgOutputEncoding.
1607 global $wgEditEncoding;
1608 if( $wgEditEncoding == '' or
1609 $wgEditEncoding == 'UTF-8' ) {
1612 return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
1616 function recodeInput( $s ) {
1617 # Take the previous into account.
1618 global $wgEditEncoding;
1619 if($wgEditEncoding != "") {
1620 $enc = $wgEditEncoding;
1624 if( $enc == 'UTF-8' ) {
1627 return $this->iconv( $enc, 'UTF-8', $s );
1632 * For right-to-left language support
1642 * A hidden direction mark (LRM or RLM), depending on the language direction
1646 function getDirMark() {
1647 return $this->isRTL() ?
"\xE2\x80\x8F" : "\xE2\x80\x8E";
1651 * An arrow, depending on the language direction
1655 function getArrow() {
1656 return $this->isRTL() ?
'←' : '→';
1660 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
1664 function linkPrefixExtension() {
1666 return $this->linkPrefixExtension
;
1669 function &getMagicWords() {
1671 return $this->magicWords
;
1674 # Fill a MagicWord object with data from here
1675 function getMagic( &$mw ) {
1676 if ( !$this->mMagicHookDone
) {
1677 $this->mMagicHookDone
= true;
1678 wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions
, $this->getCode() ) );
1680 if ( isset( $this->mMagicExtensions
[$mw->mId
] ) ) {
1681 $rawEntry = $this->mMagicExtensions
[$mw->mId
];
1683 $magicWords =& $this->getMagicWords();
1684 if ( isset( $magicWords[$mw->mId
] ) ) {
1685 $rawEntry = $magicWords[$mw->mId
];
1687 # Fall back to English if local list is incomplete
1688 $magicWords =& Language
::getMagicWords();
1689 if ( !isset($magicWords[$mw->mId
]) ) { throw new MWException("Magic word not found" ); }
1690 $rawEntry = $magicWords[$mw->mId
];
1694 if( !is_array( $rawEntry ) ) {
1695 error_log( "\"$rawEntry\" is not a valid magic thingie for \"$mw->mId\"" );
1697 $mw->mCaseSensitive
= $rawEntry[0];
1698 $mw->mSynonyms
= array_slice( $rawEntry, 1 );
1703 * Add magic words to the extension array
1705 function addMagicWordsByLang( $newWords ) {
1706 $code = $this->getCode();
1707 $fallbackChain = array();
1708 while ( $code && !in_array( $code, $fallbackChain ) ) {
1709 $fallbackChain[] = $code;
1710 $code = self
::getFallbackFor( $code );
1712 if ( !in_array( 'en', $fallbackChain ) ) {
1713 $fallbackChain[] = 'en';
1715 $fallbackChain = array_reverse( $fallbackChain );
1716 foreach ( $fallbackChain as $code ) {
1717 if ( isset( $newWords[$code] ) ) {
1718 $this->mMagicExtensions
= $newWords[$code] +
$this->mMagicExtensions
;
1724 * Get special page names, as an associative array
1725 * case folded alias => real name
1727 function getSpecialPageAliases() {
1730 // Cache aliases because it may be slow to load them
1731 if ( !isset( $this->mExtendedSpecialPageAliases
) ) {
1734 $this->mExtendedSpecialPageAliases
= $this->specialPageAliases
;
1736 global $wgExtensionAliasesFiles;
1737 foreach ( $wgExtensionAliasesFiles as $file ) {
1740 if ( !file_exists($file) )
1741 throw new MWException( 'Aliases file does not exist' );
1746 // Check the availability of aliases
1747 if ( !isset($aliases['en']) )
1748 throw new MWException( 'Malformed aliases file' );
1750 // Merge all aliases in fallback chain
1751 $code = $this->getCode();
1753 if ( !isset($aliases[$code]) ) continue;
1755 $aliases[$code] = $this->fixSpecialPageAliases( $aliases[$code] );
1756 /* Merge the aliases, THIS will break if there is special page name
1757 * which looks like a numerical key, thanks to PHP...
1758 * See the comments for wfArrayMerge in GlobalSettings.php. */
1759 $this->mExtendedSpecialPageAliases
= array_merge_recursive(
1760 $this->mExtendedSpecialPageAliases
, $aliases[$code] );
1762 } while ( $code = self
::getFallbackFor( $code ) );
1765 wfRunHooks( 'LanguageGetSpecialPageAliases',
1766 array( &$this->mExtendedSpecialPageAliases
, $this->getCode() ) );
1769 return $this->mExtendedSpecialPageAliases
;
1773 * Function to fix special page aliases. Will convert the first letter to
1774 * upper case and spaces to underscores. Can be given a full aliases array,
1775 * in which case it will recursively fix all aliases.
1777 public function fixSpecialPageAliases( $mixed ) {
1778 // Work recursively until in string level
1779 if ( is_array($mixed) ) {
1780 $callback = array( $this, 'fixSpecialPageAliases' );
1781 return array_map( $callback, $mixed );
1783 return str_replace( ' ', '_', $this->ucfirst( $mixed ) );
1787 * Italic is unsuitable for some languages
1789 * @param $text String: the text to be emphasized.
1792 function emphasize( $text ) {
1793 return "<em>$text</em>";
1797 * Normally we output all numbers in plain en_US style, that is
1798 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
1799 * point twohundredthirtyfive. However this is not sutable for all
1800 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
1801 * Icelandic just want to use commas instead of dots, and dots instead
1802 * of commas like "293.291,235".
1804 * An example of this function being called:
1806 * wfMsg( 'message', $wgLang->formatNum( $num ) )
1809 * See LanguageGu.php for the Gujarati implementation and
1810 * LanguageIs.php for the , => . and . => , implementation.
1812 * @todo check if it's viable to use localeconv() for the decimal
1814 * @param $number Mixed: the string to be formatted, should be an integer
1815 * or a floating point number.
1816 * @param $nocommafy Bool: set to true for special numbers like dates
1819 function formatNum( $number, $nocommafy = false ) {
1820 global $wgTranslateNumerals;
1822 $number = $this->commafy($number);
1823 $s = $this->separatorTransformTable();
1824 if (!is_null($s)) { $number = strtr($number, $s); }
1827 if ($wgTranslateNumerals) {
1828 $s = $this->digitTransformTable();
1829 if (!is_null($s)) { $number = strtr($number, $s); }
1835 function parseFormattedNumber( $number ) {
1836 $s = $this->digitTransformTable();
1837 if (!is_null($s)) { $number = strtr($number, array_flip($s)); }
1839 $s = $this->separatorTransformTable();
1840 if (!is_null($s)) { $number = strtr($number, array_flip($s)); }
1842 $number = strtr( $number, array (',' => '') );
1847 * Adds commas to a given number
1852 function commafy($_) {
1853 return strrev((string)preg_replace('/(\d{3})(?=\d)(?!\d*\.)/','$1,',strrev($_)));
1856 function digitTransformTable() {
1858 return $this->digitTransformTable
;
1861 function separatorTransformTable() {
1863 return $this->separatorTransformTable
;
1868 * For the credit list in includes/Credits.php (action=credits)
1873 function listToText( $l ) {
1876 for ($i = $m; $i >= 0; $i--) {
1879 } else if ($i == $m - 1) {
1880 $s = $l[$i] . ' ' . $this->getMessageFromDB( 'and' ) . ' ' . $s;
1882 $s = $l[$i] . ', ' . $s;
1889 * Truncate a string to a specified length in bytes, appending an optional
1890 * string (e.g. for ellipses)
1892 * The database offers limited byte lengths for some columns in the database;
1893 * multi-byte character sets mean we need to ensure that only whole characters
1894 * are included, otherwise broken characters can be passed to the user
1896 * If $length is negative, the string will be truncated from the beginning
1898 * @param $string String to truncate
1899 * @param $length Int: maximum length (excluding ellipses)
1900 * @param $ellipsis String to append to the truncated text
1903 function truncate( $string, $length, $ellipsis = "" ) {
1904 if( $length == 0 ) {
1907 if ( strlen( $string ) <= abs( $length ) ) {
1911 $string = substr( $string, 0, $length );
1912 $char = ord( $string[strlen( $string ) - 1] );
1914 if ($char >= 0xc0) {
1915 # We got the first byte only of a multibyte char; remove it.
1916 $string = substr( $string, 0, -1 );
1917 } elseif( $char >= 0x80 &&
1918 preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
1919 '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
1920 # We chopped in the middle of a character; remove it
1923 return $string . $ellipsis;
1925 $string = substr( $string, $length );
1926 $char = ord( $string[0] );
1927 if( $char >= 0x80 && $char < 0xc0 ) {
1928 # We chopped in the middle of a character; remove the whole thing
1929 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
1931 return $ellipsis . $string;
1936 * Grammatical transformations, needed for inflected languages
1937 * Invoked by putting {{grammar:case|word}} in a message
1939 * @param $word string
1940 * @param $case string
1943 function convertGrammar( $word, $case ) {
1944 global $wgGrammarForms;
1945 if ( isset($wgGrammarForms[$this->getCode()][$case][$word]) ) {
1946 return $wgGrammarForms[$this->getCode()][$case][$word];
1952 * Plural form transformations, needed for some languages.
1953 * For example, there are 3 form of plural in Russian and Polish,
1954 * depending on "count mod 10". See [[w:Plural]]
1955 * For English it is pretty simple.
1957 * Invoked by putting {{plural:count|wordform1|wordform2}}
1958 * or {{plural:count|wordform1|wordform2|wordform3}}
1960 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
1962 * @param $count Integer: non-localized number
1963 * @param $forms Array: different plural forms
1964 * @return string Correct form of plural for $count in this language
1966 function convertPlural( $count, $forms ) {
1967 if ( !count($forms) ) { return ''; }
1968 $forms = $this->preConvertPlural( $forms, 2 );
1970 return ( abs($count) == 1 ) ?
$forms[0] : $forms[1];
1974 * Checks that convertPlural was given an array and pads it to requested
1975 * amound of forms by copying the last one.
1977 * @param $count Integer: How many forms should there be at least
1978 * @param $forms Array of forms given to convertPlural
1979 * @return array Padded array of forms or an exception if not an array
1981 protected function preConvertPlural( /* Array */ $forms, $count ) {
1982 while ( count($forms) < $count ) {
1983 $forms[] = $forms[count($forms)-1];
1989 * For translaing of expiry times
1990 * @param $str String: the validated block time in English
1991 * @return Somehow translated block time
1992 * @see LanguageFi.php for example implementation
1994 function translateBlockExpiry( $str ) {
1996 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
1998 if ( $scBlockExpiryOptions == '-') {
2002 foreach (explode(',', $scBlockExpiryOptions) as $option) {
2003 if ( strpos($option, ":") === false )
2005 list($show, $value) = explode(":", $option);
2006 if ( strcmp ( $str, $value) == 0 ) {
2007 return htmlspecialchars( trim( $show ) );
2015 * languages like Chinese need to be segmented in order for the diff
2018 * @param $text String
2021 function segmentForDiff( $text ) {
2026 * and unsegment to show the result
2028 * @param $text String
2031 function unsegmentForDiff( $text ) {
2035 # convert text to different variants of a language.
2036 function convert( $text, $isTitle = false) {
2037 return $this->mConverter
->convert($text, $isTitle);
2040 # Convert text from within Parser
2041 function parserConvert( $text, &$parser ) {
2042 return $this->mConverter
->parserConvert( $text, $parser );
2045 # Check if this is a language with variants
2046 function hasVariants(){
2047 return sizeof($this->getVariants())>1;
2050 # Put custom tags (e.g. -{ }-) around math to prevent conversion
2051 function armourMath($text){
2052 return $this->mConverter
->armourMath($text);
2057 * Perform output conversion on a string, and encode for safe HTML output.
2058 * @param $text String
2059 * @param $isTitle Bool -- wtf?
2061 * @todo this should get integrated somewhere sane
2063 function convertHtml( $text, $isTitle = false ) {
2064 return htmlspecialchars( $this->convert( $text, $isTitle ) );
2067 function convertCategoryKey( $key ) {
2068 return $this->mConverter
->convertCategoryKey( $key );
2072 * get the list of variants supported by this langauge
2073 * see sample implementation in LanguageZh.php
2075 * @return array an array of language codes
2077 function getVariants() {
2078 return $this->mConverter
->getVariants();
2082 function getPreferredVariant( $fromUser = true ) {
2083 return $this->mConverter
->getPreferredVariant( $fromUser );
2087 * if a language supports multiple variants, it is
2088 * possible that non-existing link in one variant
2089 * actually exists in another variant. this function
2090 * tries to find it. See e.g. LanguageZh.php
2092 * @param $link String: the name of the link
2093 * @param $nt Mixed: the title object of the link
2094 * @return null the input parameters may be modified upon return
2096 function findVariantLink( &$link, &$nt ) {
2097 $this->mConverter
->findVariantLink($link, $nt);
2101 * If a language supports multiple variants, converts text
2102 * into an array of all possible variants of the text:
2103 * 'variant' => text in that variant
2106 function convertLinkToAllVariants($text){
2107 return $this->mConverter
->convertLinkToAllVariants($text);
2112 * returns language specific options used by User::getPageRenderHash()
2113 * for example, the preferred language variant
2117 function getExtraHashOptions() {
2118 return $this->mConverter
->getExtraHashOptions();
2122 * for languages that support multiple variants, the title of an
2123 * article may be displayed differently in different variants. this
2124 * function returns the apporiate title defined in the body of the article.
2128 function getParsedTitle() {
2129 return $this->mConverter
->getParsedTitle();
2133 * Enclose a string with the "no conversion" tag. This is used by
2134 * various functions in the Parser
2136 * @param $text String: text to be tagged for no conversion
2138 * @return string the tagged text
2140 function markNoConversion( $text, $noParse=false ) {
2141 return $this->mConverter
->markNoConversion( $text, $noParse );
2145 * A regular expression to match legal word-trailing characters
2146 * which should be merged onto a link of the form [[foo]]bar.
2150 function linkTrail() {
2152 return $this->linkTrail
;
2155 function getLangObj() {
2160 * Get the RFC 3066 code for this language object
2162 function getCode() {
2163 return $this->mCode
;
2166 function setCode( $code ) {
2167 $this->mCode
= $code;
2170 static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
2171 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
2174 static function getMessagesFileName( $code ) {
2176 return self
::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
2179 static function getClassFileName( $code ) {
2181 return self
::getFileName( "$IP/languages/classes/Language", $code, '.php' );
2184 static function getLocalisationArray( $code, $disableCache = false ) {
2185 self
::loadLocalisation( $code, $disableCache );
2186 return self
::$mLocalisationCache[$code];
2190 * Load localisation data for a given code into the static cache
2192 * @return array Dependencies, map of filenames to mtimes
2194 static function loadLocalisation( $code, $disableCache = false ) {
2195 static $recursionGuard = array();
2196 global $wgMemc, $wgCheckSerialized;
2199 throw new MWException( "Invalid language code requested" );
2202 if ( !$disableCache ) {
2203 # Try the per-process cache
2204 if ( isset( self
::$mLocalisationCache[$code] ) ) {
2205 return self
::$mLocalisationCache[$code]['deps'];
2208 wfProfileIn( __METHOD__
);
2210 # Try the serialized directory
2211 $cache = wfGetPrecompiledData( self
::getFileName( "Messages", $code, '.ser' ) );
2213 if ( $wgCheckSerialized && self
::isLocalisationOutOfDate( $cache ) ) {
2215 wfDebug( "Language::loadLocalisation(): precompiled data file for $code is out of date\n" );
2217 self
::$mLocalisationCache[$code] = $cache;
2218 wfDebug( "Language::loadLocalisation(): got localisation for $code from precompiled data file\n" );
2219 wfProfileOut( __METHOD__
);
2220 return self
::$mLocalisationCache[$code]['deps'];
2224 # Try the global cache
2225 $memcKey = wfMemcKey('localisation', $code );
2226 $fbMemcKey = wfMemcKey('fallback', $cache['fallback'] );
2227 $cache = $wgMemc->get( $memcKey );
2229 if ( self
::isLocalisationOutOfDate( $cache ) ) {
2230 $wgMemc->delete( $memcKey );
2231 $wgMemc->delete( $fbMemcKey );
2233 wfDebug( "Language::loadLocalisation(): localisation cache for $code had expired\n" );
2235 self
::$mLocalisationCache[$code] = $cache;
2236 wfDebug( "Language::loadLocalisation(): got localisation for $code from cache\n" );
2237 wfProfileOut( __METHOD__
);
2238 return $cache['deps'];
2242 wfProfileIn( __METHOD__
);
2245 # Default fallback, may be overridden when the messages file is included
2246 if ( $code != 'en' ) {
2252 # Load the primary localisation from the source file
2253 $filename = self
::getMessagesFileName( $code );
2254 if ( !file_exists( $filename ) ) {
2255 wfDebug( "Language::loadLocalisation(): no localisation file for $code, using implicit fallback to en\n" );
2256 $cache = compact( self
::$mLocalisationKeys ); // Set correct fallback
2259 $deps = array( $filename => filemtime( $filename ) );
2260 require( $filename );
2261 $cache = compact( self
::$mLocalisationKeys );
2262 wfDebug( "Language::loadLocalisation(): got localisation for $code from source\n" );
2265 if ( !empty( $fallback ) ) {
2266 # Load the fallback localisation, with a circular reference guard
2267 if ( isset( $recursionGuard[$code] ) ) {
2268 throw new MWException( "Error: Circular fallback reference in language code $code" );
2270 $recursionGuard[$code] = true;
2271 $newDeps = self
::loadLocalisation( $fallback, $disableCache );
2272 unset( $recursionGuard[$code] );
2274 $secondary = self
::$mLocalisationCache[$fallback];
2275 $deps = array_merge( $deps, $newDeps );
2277 # Merge the fallback localisation with the current localisation
2278 foreach ( self
::$mLocalisationKeys as $key ) {
2279 if ( isset( $cache[$key] ) ) {
2280 if ( isset( $secondary[$key] ) ) {
2281 if ( in_array( $key, self
::$mMergeableMapKeys ) ) {
2282 $cache[$key] = $cache[$key] +
$secondary[$key];
2283 } elseif ( in_array( $key, self
::$mMergeableListKeys ) ) {
2284 $cache[$key] = array_merge( $secondary[$key], $cache[$key] );
2285 } elseif ( in_array( $key, self
::$mMergeableAliasListKeys ) ) {
2286 $cache[$key] = array_merge_recursive( $cache[$key], $secondary[$key] );
2290 $cache[$key] = $secondary[$key];
2294 # Merge bookstore lists if requested
2295 if ( !empty( $cache['bookstoreList']['inherit'] ) ) {
2296 $cache['bookstoreList'] = array_merge( $cache['bookstoreList'], $secondary['bookstoreList'] );
2298 if ( isset( $cache['bookstoreList']['inherit'] ) ) {
2299 unset( $cache['bookstoreList']['inherit'] );
2303 # Add dependencies to the cache entry
2304 $cache['deps'] = $deps;
2306 # Replace spaces with underscores in namespace names
2307 $cache['namespaceNames'] = str_replace( ' ', '_', $cache['namespaceNames'] );
2309 # And do the same for specialpage aliases. $page is an array.
2310 foreach ( $cache['specialPageAliases'] as &$page ) {
2311 $page = str_replace( ' ', '_', $page );
2313 # Decouple the reference to prevent accidental damage
2316 # Save to both caches
2317 self
::$mLocalisationCache[$code] = $cache;
2318 if ( !$disableCache ) {
2319 $wgMemc->set( $memcKey, $cache );
2320 $wgMemc->set( $fbMemcKey, (string) $cache['fallback'] );
2323 wfProfileOut( __METHOD__
);
2328 * Test if a given localisation cache is out of date with respect to the
2329 * source Messages files. This is done automatically for the global cache
2330 * in $wgMemc, but is only done on certain occasions for the serialized
2333 * @param $cache mixed Either a language code or a cache array
2335 static function isLocalisationOutOfDate( $cache ) {
2336 if ( !is_array( $cache ) ) {
2337 self
::loadLocalisation( $cache );
2338 $cache = self
::$mLocalisationCache[$cache];
2341 foreach ( $cache['deps'] as $file => $mtime ) {
2342 if ( !file_exists( $file ) ||
filemtime( $file ) > $mtime ) {
2351 * Get the fallback for a given language
2353 static function getFallbackFor( $code ) {
2355 if ( $code === 'en' ) return false;
2358 static $cache = array();
2360 if ( isset($cache[$code]) ) return $cache[$code];
2364 $memcKey = wfMemcKey( 'fallback', $code );
2365 $fbcode = $wgMemc->get( $memcKey );
2367 if ( is_string($fbcode) ) {
2368 // False is stored as a string to detect failures in memcache properly
2369 if ( $fbcode === '' ) $fbcode = false;
2371 // Update local cache and return
2372 $cache[$code] = $fbcode;
2376 // Nothing in caches, load and and update both caches
2377 self
::loadLocalisation( $code );
2378 $fbcode = self
::$mLocalisationCache[$code]['fallback'];
2380 $cache[$code] = $fbcode;
2381 $wgMemc->set( $memcKey, (string) $fbcode );
2387 * Get all messages for a given language
2389 static function getMessagesFor( $code ) {
2390 self
::loadLocalisation( $code );
2391 return self
::$mLocalisationCache[$code]['messages'];
2395 * Get a message for a given language
2397 static function getMessageFor( $key, $code ) {
2398 self
::loadLocalisation( $code );
2399 return isset( self
::$mLocalisationCache[$code]['messages'][$key] ) ? self
::$mLocalisationCache[$code]['messages'][$key] : null;
2403 * Load localisation data for this object
2406 if ( !$this->mLoaded
) {
2407 self
::loadLocalisation( $this->getCode() );
2408 $cache =& self
::$mLocalisationCache[$this->getCode()];
2409 foreach ( self
::$mLocalisationKeys as $key ) {
2410 $this->$key = $cache[$key];
2412 $this->mLoaded
= true;
2414 $this->fixUpSettings();
2419 * Do any necessary post-cache-load settings adjustment
2421 function fixUpSettings() {
2422 global $wgExtraNamespaces, $wgMetaNamespace, $wgMetaNamespaceTalk,
2423 $wgNamespaceAliases, $wgAmericanDates;
2424 wfProfileIn( __METHOD__
);
2425 if ( $wgExtraNamespaces ) {
2426 $this->namespaceNames
= $wgExtraNamespaces +
$this->namespaceNames
;
2429 $this->namespaceNames
[NS_PROJECT
] = $wgMetaNamespace;
2430 if ( $wgMetaNamespaceTalk ) {
2431 $this->namespaceNames
[NS_PROJECT_TALK
] = $wgMetaNamespaceTalk;
2433 $talk = $this->namespaceNames
[NS_PROJECT_TALK
];
2434 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
2436 # Allow grammar transformations
2437 # Allowing full message-style parsing would make simple requests
2438 # such as action=raw much more expensive than they need to be.
2439 # This will hopefully cover most cases.
2440 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
2441 array( &$this, 'replaceGrammarInNamespace' ), $talk );
2442 $talk = str_replace( ' ', '_', $talk );
2443 $this->namespaceNames
[NS_PROJECT_TALK
] = $talk;
2446 # The above mixing may leave namespaces out of canonical order.
2447 # Re-order by namespace ID number...
2448 ksort( $this->namespaceNames
);
2450 # Put namespace names and aliases into a hashtable.
2451 # If this is too slow, then we should arrange it so that it is done
2452 # before caching. The catch is that at pre-cache time, the above
2453 # class-specific fixup hasn't been done.
2454 $this->mNamespaceIds
= array();
2455 foreach ( $this->namespaceNames
as $index => $name ) {
2456 $this->mNamespaceIds
[$this->lc($name)] = $index;
2458 if ( $this->namespaceAliases
) {
2459 foreach ( $this->namespaceAliases
as $name => $index ) {
2460 $this->mNamespaceIds
[$this->lc($name)] = $index;
2463 if ( $wgNamespaceAliases ) {
2464 foreach ( $wgNamespaceAliases as $name => $index ) {
2465 $this->mNamespaceIds
[$this->lc($name)] = $index;
2469 if ( $this->defaultDateFormat
== 'dmy or mdy' ) {
2470 $this->defaultDateFormat
= $wgAmericanDates ?
'mdy' : 'dmy';
2472 wfProfileOut( __METHOD__
);
2475 function replaceGrammarInNamespace( $m ) {
2476 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
2479 static function getCaseMaps() {
2480 static $wikiUpperChars, $wikiLowerChars;
2481 if ( isset( $wikiUpperChars ) ) {
2482 return array( $wikiUpperChars, $wikiLowerChars );
2485 wfProfileIn( __METHOD__
);
2486 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
2487 if ( $arr === false ) {
2488 throw new MWException(
2489 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
2492 wfProfileOut( __METHOD__
);
2493 return array( $wikiUpperChars, $wikiLowerChars );
2496 function formatTimePeriod( $seconds ) {
2497 if ( $seconds < 10 ) {
2498 return $this->formatNum( sprintf( "%.1f", $seconds ) ) . wfMsg( 'seconds-abbrev' );
2499 } elseif ( $seconds < 60 ) {
2500 return $this->formatNum( round( $seconds ) ) . wfMsg( 'seconds-abbrev' );
2501 } elseif ( $seconds < 3600 ) {
2502 return $this->formatNum( floor( $seconds / 60 ) ) . wfMsg( 'minutes-abbrev' ) .
2503 $this->formatNum( round( fmod( $seconds, 60 ) ) ) . wfMsg( 'seconds-abbrev' );
2505 $hours = floor( $seconds / 3600 );
2506 $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
2507 $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
2508 return $this->formatNum( $hours ) . wfMsg( 'hours-abbrev' ) .
2509 $this->formatNum( $minutes ) . wfMsg( 'minutes-abbrev' ) .
2510 $this->formatNum( $secondsPart ) . wfMsg( 'seconds-abbrev' );
2514 function formatBitrate( $bps ) {
2515 $units = array( 'bps', 'kbps', 'Mbps', 'Gbps' );
2517 return $this->formatNum( $bps ) . $units[0];
2519 $unitIndex = floor( log10( $bps ) / 3 );
2520 $mantissa = $bps / pow( 1000, $unitIndex );
2521 if ( $mantissa < 10 ) {
2522 $mantissa = round( $mantissa, 1 );
2524 $mantissa = round( $mantissa );
2526 return $this->formatNum( $mantissa ) . $units[$unitIndex];
2530 * Format a size in bytes for output, using an appropriate
2531 * unit (B, KB, MB or GB) according to the magnitude in question
2533 * @param $size Size to format
2534 * @return string Plain text (not HTML)
2536 function formatSize( $size ) {
2537 // For small sizes no decimal places necessary
2539 if( $size > 1024 ) {
2540 $size = $size / 1024;
2541 if( $size > 1024 ) {
2542 $size = $size / 1024;
2543 // For MB and bigger two decimal places are smarter
2545 if( $size > 1024 ) {
2546 $size = $size / 1024;
2547 $msg = 'size-gigabytes';
2549 $msg = 'size-megabytes';
2552 $msg = 'size-kilobytes';
2555 $msg = 'size-bytes';
2557 $size = round( $size, $round );
2558 $text = $this->getMessageFromDB( $msg );
2559 return str_replace( '$1', $this->formatNum( $size ), $text );