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 autoConvertToAllVariants($text) {return $text;}
39 function convert($t, $i) {return $t;}
40 function getVariants() { return array( $this->mLang
->getCode() ); }
41 function getPreferredVariant() { return $this->mLang
->getCode(); }
42 function getConvRuleTitle() { return false; }
43 function findVariantLink(&$l, &$n, $ignoreOtherCond = false) {}
44 function getExtraHashOptions() {return '';}
45 function getParsedTitle() {return '';}
46 function markNoConversion($text, $noParse=false) {return $text;}
47 function convertCategoryKey( $key ) {return $key; }
48 function convertLinkToAllVariants($text){ return array( $this->mLang
->getCode() => $text); }
49 function armourMath($text){ return $text; }
53 * Internationalisation code
57 var $mConverter, $mVariants, $mCode, $mLoaded = false;
58 var $mMagicExtensions = array(), $mMagicHookDone = false;
60 var $mNamespaceIds, $namespaceNames, $namespaceAliases;
61 var $dateFormatStrings = array();
62 var $mExtendedSpecialPageAliases;
65 * ReplacementArray object caches
67 var $transformData = array();
69 static public $dataCache;
70 static public $mLangObjCache = array();
72 static public $mWeekdayMsgs = array(
73 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
77 static public $mWeekdayAbbrevMsgs = array(
78 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'
81 static public $mMonthMsgs = array(
82 'january', 'february', 'march', 'april', 'may_long', 'june',
83 'july', 'august', 'september', 'october', 'november',
86 static public $mMonthGenMsgs = array(
87 'january-gen', 'february-gen', 'march-gen', 'april-gen', 'may-gen', 'june-gen',
88 'july-gen', 'august-gen', 'september-gen', 'october-gen', 'november-gen',
91 static public $mMonthAbbrevMsgs = array(
92 'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
93 'sep', 'oct', 'nov', 'dec'
96 static public $mIranianCalendarMonthMsgs = array(
97 'iranian-calendar-m1', 'iranian-calendar-m2', 'iranian-calendar-m3',
98 'iranian-calendar-m4', 'iranian-calendar-m5', 'iranian-calendar-m6',
99 'iranian-calendar-m7', 'iranian-calendar-m8', 'iranian-calendar-m9',
100 'iranian-calendar-m10', 'iranian-calendar-m11', 'iranian-calendar-m12'
103 static public $mHebrewCalendarMonthMsgs = array(
104 'hebrew-calendar-m1', 'hebrew-calendar-m2', 'hebrew-calendar-m3',
105 'hebrew-calendar-m4', 'hebrew-calendar-m5', 'hebrew-calendar-m6',
106 'hebrew-calendar-m7', 'hebrew-calendar-m8', 'hebrew-calendar-m9',
107 'hebrew-calendar-m10', 'hebrew-calendar-m11', 'hebrew-calendar-m12',
108 'hebrew-calendar-m6a', 'hebrew-calendar-m6b'
111 static public $mHebrewCalendarMonthGenMsgs = array(
112 'hebrew-calendar-m1-gen', 'hebrew-calendar-m2-gen', 'hebrew-calendar-m3-gen',
113 'hebrew-calendar-m4-gen', 'hebrew-calendar-m5-gen', 'hebrew-calendar-m6-gen',
114 'hebrew-calendar-m7-gen', 'hebrew-calendar-m8-gen', 'hebrew-calendar-m9-gen',
115 'hebrew-calendar-m10-gen', 'hebrew-calendar-m11-gen', 'hebrew-calendar-m12-gen',
116 'hebrew-calendar-m6a-gen', 'hebrew-calendar-m6b-gen'
119 static public $mHijriCalendarMonthMsgs = array(
120 'hijri-calendar-m1', 'hijri-calendar-m2', 'hijri-calendar-m3',
121 'hijri-calendar-m4', 'hijri-calendar-m5', 'hijri-calendar-m6',
122 'hijri-calendar-m7', 'hijri-calendar-m8', 'hijri-calendar-m9',
123 'hijri-calendar-m10', 'hijri-calendar-m11', 'hijri-calendar-m12'
127 * Get a cached language object for a given language code
129 static function factory( $code ) {
130 if ( !isset( self
::$mLangObjCache[$code] ) ) {
131 if( count( self
::$mLangObjCache ) > 10 ) {
132 // Don't keep a billion objects around, that's stupid.
133 self
::$mLangObjCache = array();
135 self
::$mLangObjCache[$code] = self
::newFromCode( $code );
137 return self
::$mLangObjCache[$code];
141 * Create a language object for a given language code
143 protected static function newFromCode( $code ) {
145 static $recursionLevel = 0;
146 if ( $code == 'en' ) {
149 $class = 'Language' . str_replace( '-', '_', ucfirst( $code ) );
150 // Preload base classes to work around APC/PHP5 bug
151 if ( file_exists( "$IP/languages/classes/$class.deps.php" ) ) {
152 include_once("$IP/languages/classes/$class.deps.php");
154 if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
155 include_once("$IP/languages/classes/$class.php");
159 if ( $recursionLevel > 5 ) {
160 throw new MWException( "Language fallback loop detected when creating class $class\n" );
163 if( ! class_exists( $class ) ) {
164 $fallback = Language
::getFallbackFor( $code );
166 $lang = Language
::newFromCode( $fallback );
168 $lang->setCode( $code );
176 * Get the LocalisationCache instance
178 public static function getLocalisationCache() {
179 if ( is_null( self
::$dataCache ) ) {
180 global $wgLocalisationCacheConf;
181 $class = $wgLocalisationCacheConf['class'];
182 self
::$dataCache = new $class( $wgLocalisationCacheConf );
184 return self
::$dataCache;
187 function __construct() {
188 $this->mConverter
= new FakeConverter($this);
189 // Set the code to the name of the descendant
190 if ( get_class( $this ) == 'Language' ) {
193 $this->mCode
= str_replace( '_', '-', strtolower( substr( get_class( $this ), 8 ) ) );
195 self
::getLocalisationCache();
199 * Reduce memory usage
201 function __destruct() {
202 foreach ( $this as $name => $value ) {
203 unset( $this->$name );
208 * Hook which will be called if this is the content language.
209 * Descendants can use this to register hook functions or modify globals
211 function initContLang() {}
214 * @deprecated Use User::getDefaultOptions()
217 function getDefaultUserOptions() {
218 wfDeprecated( __METHOD__
);
219 return User
::getDefaultOptions();
222 function getFallbackLanguageCode() {
223 if ( $this->mCode
=== 'en' ) {
226 return self
::$dataCache->getItem( $this->mCode
, 'fallback' );
231 * Exports $wgBookstoreListEn
234 function getBookstoreList() {
235 return self
::$dataCache->getItem( $this->mCode
, 'bookstoreList' );
241 function getNamespaces() {
242 if ( is_null( $this->namespaceNames
) ) {
243 global $wgExtraNamespaces, $wgMetaNamespace, $wgMetaNamespaceTalk;
245 $this->namespaceNames
= self
::$dataCache->getItem( $this->mCode
, 'namespaceNames' );
246 if ( $wgExtraNamespaces ) {
247 $this->namespaceNames
= $wgExtraNamespaces +
$this->namespaceNames
;
250 $this->namespaceNames
[NS_PROJECT
] = $wgMetaNamespace;
251 if ( $wgMetaNamespaceTalk ) {
252 $this->namespaceNames
[NS_PROJECT_TALK
] = $wgMetaNamespaceTalk;
254 $talk = $this->namespaceNames
[NS_PROJECT_TALK
];
255 $this->namespaceNames
[NS_PROJECT_TALK
] =
256 $this->fixVariableInNamespace( $talk );
259 # The above mixing may leave namespaces out of canonical order.
260 # Re-order by namespace ID number...
261 ksort( $this->namespaceNames
);
263 return $this->namespaceNames
;
267 * A convenience function that returns the same thing as
268 * getNamespaces() except with the array values changed to ' '
269 * where it found '_', useful for producing output to be displayed
270 * e.g. in <select> forms.
274 function getFormattedNamespaces() {
275 $ns = $this->getNamespaces();
276 foreach($ns as $k => $v) {
277 $ns[$k] = strtr($v, '_', ' ');
283 * Get a namespace value by key
285 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
286 * echo $mw_ns; // prints 'MediaWiki'
289 * @param $index Int: the array key of the namespace to return
290 * @return mixed, string if the namespace value exists, otherwise false
292 function getNsText( $index ) {
293 $ns = $this->getNamespaces();
294 return isset( $ns[$index] ) ?
$ns[$index] : false;
298 * A convenience function that returns the same thing as
299 * getNsText() except with '_' changed to ' ', useful for
304 function getFormattedNsText( $index ) {
305 $ns = $this->getNsText( $index );
306 return strtr($ns, '_', ' ');
310 * Get a namespace key by value, case insensitive.
311 * Only matches namespace names for the current language, not the
312 * canonical ones defined in Namespace.php.
314 * @param $text String
315 * @return mixed An integer if $text is a valid value otherwise false
317 function getLocalNsIndex( $text ) {
318 $lctext = $this->lc($text);
319 $ids = $this->getNamespaceIds();
320 return isset( $ids[$lctext] ) ?
$ids[$lctext] : false;
323 function getNamespaceAliases() {
324 if ( is_null( $this->namespaceAliases
) ) {
325 $aliases = self
::$dataCache->getItem( $this->mCode
, 'namespaceAliases' );
329 foreach ( $aliases as $name => $index ) {
330 if ( $index === NS_PROJECT_TALK
) {
331 unset( $aliases[$name] );
332 $name = $this->fixVariableInNamespace( $name );
333 $aliases[$name] = $index;
337 $this->namespaceAliases
= $aliases;
339 return $this->namespaceAliases
;
342 function getNamespaceIds() {
343 if ( is_null( $this->mNamespaceIds
) ) {
344 global $wgNamespaceAliases;
345 # Put namespace names and aliases into a hashtable.
346 # If this is too slow, then we should arrange it so that it is done
347 # before caching. The catch is that at pre-cache time, the above
348 # class-specific fixup hasn't been done.
349 $this->mNamespaceIds
= array();
350 foreach ( $this->getNamespaces() as $index => $name ) {
351 $this->mNamespaceIds
[$this->lc($name)] = $index;
353 foreach ( $this->getNamespaceAliases() as $name => $index ) {
354 $this->mNamespaceIds
[$this->lc($name)] = $index;
356 if ( $wgNamespaceAliases ) {
357 foreach ( $wgNamespaceAliases as $name => $index ) {
358 $this->mNamespaceIds
[$this->lc($name)] = $index;
362 return $this->mNamespaceIds
;
367 * Get a namespace key by value, case insensitive. Canonical namespace
368 * names override custom ones defined for the current language.
370 * @param $text String
371 * @return mixed An integer if $text is a valid value otherwise false
373 function getNsIndex( $text ) {
374 $lctext = $this->lc($text);
375 if ( ( $ns = MWNamespace
::getCanonicalIndex( $lctext ) ) !== null ) {
378 $ids = $this->getNamespaceIds();
379 return isset( $ids[$lctext] ) ?
$ids[$lctext] : false;
383 * short names for language variants used for language conversion links.
385 * @param $code String
388 function getVariantname( $code ) {
389 return $this->getMessageFromDB( "variantname-$code" );
392 function specialPage( $name ) {
393 $aliases = $this->getSpecialPageAliases();
394 if ( isset( $aliases[$name][0] ) ) {
395 $name = $aliases[$name][0];
397 return $this->getNsText( NS_SPECIAL
) . ':' . $name;
400 function getQuickbarSettings() {
402 $this->getMessage( 'qbsettings-none' ),
403 $this->getMessage( 'qbsettings-fixedleft' ),
404 $this->getMessage( 'qbsettings-fixedright' ),
405 $this->getMessage( 'qbsettings-floatingleft' ),
406 $this->getMessage( 'qbsettings-floatingright' )
410 function getMathNames() {
411 return self
::$dataCache->getItem( $this->mCode
, 'mathNames' );
414 function getDatePreferences() {
415 return self
::$dataCache->getItem( $this->mCode
, 'datePreferences' );
418 function getDateFormats() {
419 return self
::$dataCache->getItem( $this->mCode
, 'dateFormats' );
422 function getDefaultDateFormat() {
423 $df = self
::$dataCache->getItem( $this->mCode
, 'defaultDateFormat' );
424 if ( $df === 'dmy or mdy' ) {
425 global $wgAmericanDates;
426 return $wgAmericanDates ?
'mdy' : 'dmy';
432 function getDatePreferenceMigrationMap() {
433 return self
::$dataCache->getItem( $this->mCode
, 'datePreferenceMigrationMap' );
436 function getImageFile( $image ) {
437 return self
::$dataCache->getSubitem( $this->mCode
, 'imageFiles', $image );
440 function getDefaultUserOptionOverrides() {
441 return self
::$dataCache->getItem( $this->mCode
, 'defaultUserOptionOverrides' );
444 function getExtraUserToggles() {
445 return self
::$dataCache->getItem( $this->mCode
, 'extraUserToggles' );
448 function getUserToggle( $tog ) {
449 return $this->getMessageFromDB( "tog-$tog" );
453 * Get language names, indexed by code.
454 * If $customisedOnly is true, only returns codes with a messages file
456 public static function getLanguageNames( $customisedOnly = false ) {
457 global $wgLanguageNames, $wgExtraLanguageNames;
458 $allNames = $wgExtraLanguageNames +
$wgLanguageNames;
459 if ( !$customisedOnly ) {
465 $dir = opendir( "$IP/languages/messages" );
466 while( false !== ( $file = readdir( $dir ) ) ) {
467 $code = self
::getCodeFromFileName( $file, 'Messages' );
468 if ( $code && isset( $allNames[$code] ) ) {
469 $names[$code] = $allNames[$code];
477 * Get a message from the MediaWiki namespace.
479 * @param $msg String: message name
482 function getMessageFromDB( $msg ) {
483 return wfMsgExt( $msg, array( 'parsemag', 'language' => $this ) );
486 function getLanguageName( $code ) {
487 $names = self
::getLanguageNames();
488 if ( !array_key_exists( $code, $names ) ) {
491 return $names[$code];
494 function getMonthName( $key ) {
495 return $this->getMessageFromDB( self
::$mMonthMsgs[$key-1] );
498 function getMonthNameGen( $key ) {
499 return $this->getMessageFromDB( self
::$mMonthGenMsgs[$key-1] );
502 function getMonthAbbreviation( $key ) {
503 return $this->getMessageFromDB( self
::$mMonthAbbrevMsgs[$key-1] );
506 function getWeekdayName( $key ) {
507 return $this->getMessageFromDB( self
::$mWeekdayMsgs[$key-1] );
510 function getWeekdayAbbreviation( $key ) {
511 return $this->getMessageFromDB( self
::$mWeekdayAbbrevMsgs[$key-1] );
514 function getIranianCalendarMonthName( $key ) {
515 return $this->getMessageFromDB( self
::$mIranianCalendarMonthMsgs[$key-1] );
518 function getHebrewCalendarMonthName( $key ) {
519 return $this->getMessageFromDB( self
::$mHebrewCalendarMonthMsgs[$key-1] );
522 function getHebrewCalendarMonthNameGen( $key ) {
523 return $this->getMessageFromDB( self
::$mHebrewCalendarMonthGenMsgs[$key-1] );
526 function getHijriCalendarMonthName( $key ) {
527 return $this->getMessageFromDB( self
::$mHijriCalendarMonthMsgs[$key-1] );
531 * Used by date() and time() to adjust the time output.
533 * @param $ts Int the time in date('YmdHis') format
534 * @param $tz Mixed: adjust the time by this amount (default false, mean we
535 * get user timecorrection setting)
538 function userAdjust( $ts, $tz = false ) {
539 global $wgUser, $wgLocalTZoffset;
541 if ( $tz === false ) {
542 $tz = $wgUser->getOption( 'timecorrection' );
545 $data = explode( '|', $tz, 3 );
547 if ( $data[0] == 'ZoneInfo' ) {
548 if ( function_exists( 'timezone_open' ) && @timezone_open
( $data[2] ) !== false ) {
549 $date = date_create( $ts, timezone_open( 'UTC' ) );
550 date_timezone_set( $date, timezone_open( $data[2] ) );
551 $date = date_format( $date, 'YmdHis' );
554 # Unrecognized timezone, default to 'Offset' with the stored offset.
559 if ( $data[0] == 'System' ||
$tz == '' ) {
560 # Global offset in minutes.
561 if( isset($wgLocalTZoffset) ) $minDiff = $wgLocalTZoffset;
562 } else if ( $data[0] == 'Offset' ) {
563 $minDiff = intval( $data[1] );
565 $data = explode( ':', $tz );
566 if( count( $data ) == 2 ) {
567 $data[0] = intval( $data[0] );
568 $data[1] = intval( $data[1] );
569 $minDiff = abs( $data[0] ) * 60 +
$data[1];
570 if ( $data[0] < 0 ) $minDiff = -$minDiff;
572 $minDiff = intval( $data[0] ) * 60;
576 # No difference ? Return time unchanged
577 if ( 0 == $minDiff ) return $ts;
579 wfSuppressWarnings(); // E_STRICT system time bitching
580 # Generate an adjusted date; take advantage of the fact that mktime
581 # will normalize out-of-range values so we don't have to split $minDiff
582 # into hours and minutes.
584 (int)substr( $ts, 8, 2) ), # Hours
585 (int)substr( $ts, 10, 2 ) +
$minDiff, # Minutes
586 (int)substr( $ts, 12, 2 ), # Seconds
587 (int)substr( $ts, 4, 2 ), # Month
588 (int)substr( $ts, 6, 2 ), # Day
589 (int)substr( $ts, 0, 4 ) ); #Year
591 $date = date( 'YmdHis', $t );
598 * This is a workalike of PHP's date() function, but with better
599 * internationalisation, a reduced set of format characters, and a better
602 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
603 * PHP manual for definitions. "o" format character is supported since
604 * PHP 5.1.0, previous versions return literal o.
605 * There are a number of extensions, which start with "x":
607 * xn Do not translate digits of the next numeric format character
608 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
609 * xr Use roman numerals for the next numeric format character
610 * xh Use hebrew numerals for the next numeric format character
612 * xg Genitive month name
614 * xij j (day number) in Iranian calendar
615 * xiF F (month name) in Iranian calendar
616 * xin n (month number) in Iranian calendar
617 * xiY Y (full year) in Iranian calendar
619 * xjj j (day number) in Hebrew calendar
620 * xjF F (month name) in Hebrew calendar
621 * xjt t (days in month) in Hebrew calendar
622 * xjx xg (genitive month name) in Hebrew calendar
623 * xjn n (month number) in Hebrew calendar
624 * xjY Y (full year) in Hebrew calendar
626 * xmj j (day number) in Hijri calendar
627 * xmF F (month name) in Hijri calendar
628 * xmn n (month number) in Hijri calendar
629 * xmY Y (full year) in Hijri calendar
631 * xkY Y (full year) in Thai solar calendar. Months and days are
632 * identical to the Gregorian calendar
633 * xoY Y (full year) in Minguo calendar or Juche year.
634 * Months and days are identical to the
636 * xtY Y (full year) in Japanese nengo. Months and days are
637 * identical to the Gregorian calendar
639 * Characters enclosed in double quotes will be considered literal (with
640 * the quotes themselves removed). Unmatched quotes will be considered
641 * literal quotes. Example:
643 * "The month is" F => The month is January
646 * Backslash escaping is also supported.
648 * Input timestamp is assumed to be pre-normalized to the desired local
651 * @param $format String
652 * @param $ts String: 14-character timestamp
655 * @todo emulation of "o" format character for PHP pre 5.1.0
656 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
658 function sprintfDate( $format, $ts ) {
671 for ( $p = 0; $p < strlen( $format ); $p++
) {
674 if ( $code == 'x' && $p < strlen( $format ) - 1 ) {
675 $code .= $format[++
$p];
678 if ( ( $code === 'xi' ||
$code == 'xj' ||
$code == 'xk' ||
$code == 'xm' ||
$code == 'xo' ||
$code == 'xt' ) && $p < strlen( $format ) - 1 ) {
679 $code .= $format[++
$p];
690 $rawToggle = !$rawToggle;
699 $s .= $this->getMonthNameGen( substr( $ts, 4, 2 ) );
702 if ( !$hebrew ) $hebrew = self
::tsToHebrew( $ts );
703 $s .= $this->getHebrewCalendarMonthNameGen( $hebrew[1] );
706 $num = substr( $ts, 6, 2 );
709 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
710 $s .= $this->getWeekdayAbbreviation( gmdate( 'w', $unix ) +
1 );
713 $num = intval( substr( $ts, 6, 2 ) );
716 if ( !$iranian ) $iranian = self
::tsToIranian( $ts );
720 if ( !$hijri ) $hijri = self
::tsToHijri( $ts );
724 if ( !$hebrew ) $hebrew = self
::tsToHebrew( $ts );
728 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
729 $s .= $this->getWeekdayName( gmdate( 'w', $unix ) +
1 );
732 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
733 $w = gmdate( 'w', $unix );
737 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
738 $num = gmdate( 'w', $unix );
741 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
742 $num = gmdate( 'z', $unix );
745 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
746 $num = gmdate( 'W', $unix );
749 $s .= $this->getMonthName( substr( $ts, 4, 2 ) );
752 if ( !$iranian ) $iranian = self
::tsToIranian( $ts );
753 $s .= $this->getIranianCalendarMonthName( $iranian[1] );
756 if ( !$hijri ) $hijri = self
::tsToHijri( $ts );
757 $s .= $this->getHijriCalendarMonthName( $hijri[1] );
760 if ( !$hebrew ) $hebrew = self
::tsToHebrew( $ts );
761 $s .= $this->getHebrewCalendarMonthName( $hebrew[1] );
764 $num = substr( $ts, 4, 2 );
767 $s .= $this->getMonthAbbreviation( substr( $ts, 4, 2 ) );
770 $num = intval( substr( $ts, 4, 2 ) );
773 if ( !$iranian ) $iranian = self
::tsToIranian( $ts );
777 if ( !$hijri ) $hijri = self
::tsToHijri ( $ts );
781 if ( !$hebrew ) $hebrew = self
::tsToHebrew( $ts );
785 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
786 $num = gmdate( 't', $unix );
789 if ( !$hebrew ) $hebrew = self
::tsToHebrew( $ts );
793 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
794 $num = gmdate( 'L', $unix );
796 # 'o' is supported since PHP 5.1.0
797 # return literal if not supported
798 # TODO: emulation for pre 5.1.0 versions
800 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
801 if ( version_compare(PHP_VERSION
, '5.1.0') === 1 )
802 $num = date( 'o', $unix );
807 $num = substr( $ts, 0, 4 );
810 if ( !$iranian ) $iranian = self
::tsToIranian( $ts );
814 if ( !$hijri ) $hijri = self
::tsToHijri( $ts );
818 if ( !$hebrew ) $hebrew = self
::tsToHebrew( $ts );
822 if ( !$thai ) $thai = self
::tsToYear( $ts, 'thai' );
826 if ( !$minguo ) $minguo = self
::tsToYear( $ts, 'minguo' );
830 if ( !$tenno ) $tenno = self
::tsToYear( $ts, 'tenno' );
834 $num = substr( $ts, 2, 2 );
837 $s .= intval( substr( $ts, 8, 2 ) ) < 12 ?
'am' : 'pm';
840 $s .= intval( substr( $ts, 8, 2 ) ) < 12 ?
'AM' : 'PM';
843 $h = substr( $ts, 8, 2 );
844 $num = $h %
12 ?
$h %
12 : 12;
847 $num = intval( substr( $ts, 8, 2 ) );
850 $h = substr( $ts, 8, 2 );
851 $num = sprintf( '%02d', $h %
12 ?
$h %
12 : 12 );
854 $num = substr( $ts, 8, 2 );
857 $num = substr( $ts, 10, 2 );
860 $num = substr( $ts, 12, 2 );
863 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
864 $s .= gmdate( 'c', $unix );
867 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
868 $s .= gmdate( 'r', $unix );
871 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
876 if ( $p < strlen( $format ) - 1 ) {
884 if ( $p < strlen( $format ) - 1 ) {
885 $endQuote = strpos( $format, '"', $p +
1 );
886 if ( $endQuote === false ) {
887 # No terminating quote, assume literal "
890 $s .= substr( $format, $p +
1, $endQuote - $p - 1 );
894 # Quote at end of string, assume literal "
901 if ( $num !== false ) {
902 if ( $rawToggle ||
$raw ) {
905 } elseif ( $roman ) {
906 $s .= self
::romanNumeral( $num );
908 } elseif( $hebrewNum ) {
909 $s .= self
::hebrewNumeral( $num );
912 $s .= $this->formatNum( $num, true );
920 private static $GREG_DAYS = array( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
921 private static $IRANIAN_DAYS = array( 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29 );
923 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
924 * Gregorian dates to Iranian dates. Originally written in C, it
925 * is released under the terms of GNU Lesser General Public
926 * License. Conversion to PHP was performed by Niklas Laxström.
928 * Link: http://www.farsiweb.info/jalali/jalali.c
930 private static function tsToIranian( $ts ) {
931 $gy = substr( $ts, 0, 4 ) -1600;
932 $gm = substr( $ts, 4, 2 ) -1;
933 $gd = substr( $ts, 6, 2 ) -1;
935 # Days passed from the beginning (including leap years)
938 - floor(($gy+
99) / 100)
939 +
floor(($gy+
399) / 400);
942 // Add days of the past months of this year
943 for( $i = 0; $i < $gm; $i++
) {
944 $gDayNo +
= self
::$GREG_DAYS[$i];
948 if ( $gm > 1 && (($gy%4
===0 && $gy%100
!==0 ||
($gy%400
==0)))) {
952 // Days passed in current month
955 $jDayNo = $gDayNo - 79;
957 $jNp = floor($jDayNo / 12053);
960 $jy = 979 +
33*$jNp +
4*floor($jDayNo/1461);
963 if ( $jDayNo >= 366 ) {
964 $jy +
= floor(($jDayNo-1)/365);
965 $jDayNo = floor(($jDayNo-1)%365
);
968 for ( $i = 0; $i < 11 && $jDayNo >= self
::$IRANIAN_DAYS[$i]; $i++
) {
969 $jDayNo -= self
::$IRANIAN_DAYS[$i];
975 return array($jy, $jm, $jd);
978 * Converting Gregorian dates to Hijri dates.
980 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
982 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
984 private static function tsToHijri ( $ts ) {
985 $year = substr( $ts, 0, 4 );
986 $month = substr( $ts, 4, 2 );
987 $day = substr( $ts, 6, 2 );
996 if (($zy>1582)||
(($zy==1582)&&($zm>10))||
(($zy==1582)&&($zm==10)&&($zd>14)))
1000 $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;
1004 $zjd = 367*$zy-(int)((7*($zy+
5001+
(int)(($zm-9)/7)))/4)+
(int)((275*$zm)/9)+
$zd+
1729777;
1007 $zl=$zjd-1948440+
10632;
1008 $zn=(int)(($zl-1)/10631);
1009 $zl=$zl-10631*$zn+
354;
1010 $zj=((int)((10985-$zl)/5316))*((int)((50*$zl)/17719))+
((int)($zl/5670))*((int)((43*$zl)/15238));
1011 $zl=$zl-((int)((30-$zj)/15))*((int)((17719*$zj)/50))-((int)($zj/16))*((int)((15238*$zj)/43))+
29;
1012 $zm=(int)((24*$zl)/709);
1013 $zd=$zl-(int)((709*$zm)/24);
1016 return array ($zy, $zm, $zd);
1020 * Converting Gregorian dates to Hebrew dates.
1022 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1023 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1024 * to translate the relevant functions into PHP and release them under
1027 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1028 * and Adar II is 14. In a non-leap year, Adar is 6.
1030 private static function tsToHebrew( $ts ) {
1032 $year = substr( $ts, 0, 4 );
1033 $month = substr( $ts, 4, 2 );
1034 $day = substr( $ts, 6, 2 );
1036 # Calculate Hebrew year
1037 $hebrewYear = $year +
3760;
1039 # Month number when September = 1, August = 12
1048 # Calculate day of year from 1 September
1050 for( $i = 1; $i < $month; $i++
) {
1054 # Check if the year is leap
1055 if( $year %
400 == 0 ||
( $year %
4 == 0 && $year %
100 > 0 ) ) {
1058 } elseif( $i == 8 ||
$i == 10 ||
$i == 1 ||
$i == 3 ) {
1065 # Calculate the start of the Hebrew year
1066 $start = self
::hebrewYearStart( $hebrewYear );
1068 # Calculate next year's start
1069 if( $dayOfYear <= $start ) {
1070 # Day is before the start of the year - it is the previous year
1072 $nextStart = $start;
1076 # Add days since previous year's 1 September
1078 if( ( $year %
400 == 0 ) ||
( $year %
100 != 0 && $year %
4 == 0 ) ) {
1082 # Start of the new (previous) year
1083 $start = self
::hebrewYearStart( $hebrewYear );
1086 $nextStart = self
::hebrewYearStart( $hebrewYear +
1 );
1089 # Calculate Hebrew day of year
1090 $hebrewDayOfYear = $dayOfYear - $start;
1092 # Difference between year's days
1093 $diff = $nextStart - $start;
1094 # Add 12 (or 13 for leap years) days to ignore the difference between
1095 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1096 # difference is only about the year type
1097 if( ( $year %
400 == 0 ) ||
( $year %
100 != 0 && $year %
4 == 0 ) ) {
1103 # Check the year pattern, and is leap year
1104 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1105 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1106 # and non-leap years
1107 $yearPattern = $diff %
30;
1108 # Check if leap year
1109 $isLeap = $diff >= 30;
1111 # Calculate day in the month from number of day in the Hebrew year
1112 # Don't check Adar - if the day is not in Adar, we will stop before;
1113 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1114 $hebrewDay = $hebrewDayOfYear;
1117 while( $hebrewMonth <= 12 ) {
1118 # Calculate days in this month
1119 if( $isLeap && $hebrewMonth == 6 ) {
1120 # Adar in a leap year
1122 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1124 if( $hebrewDay <= $days ) {
1128 # Subtract the days of Adar I
1129 $hebrewDay -= $days;
1132 if( $hebrewDay <= $days ) {
1138 } elseif( $hebrewMonth == 2 && $yearPattern == 2 ) {
1139 # Cheshvan in a complete year (otherwise as the rule below)
1141 } elseif( $hebrewMonth == 3 && $yearPattern == 0 ) {
1142 # Kislev in an incomplete year (otherwise as the rule below)
1145 # Odd months have 30 days, even have 29
1146 $days = 30 - ( $hebrewMonth - 1 ) %
2;
1148 if( $hebrewDay <= $days ) {
1149 # In the current month
1152 # Subtract the days of the current month
1153 $hebrewDay -= $days;
1154 # Try in the next month
1159 return array( $hebrewYear, $hebrewMonth, $hebrewDay, $days );
1163 * This calculates the Hebrew year start, as days since 1 September.
1164 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1165 * Used for Hebrew date.
1167 private static function hebrewYearStart( $year ) {
1168 $a = intval( ( 12 * ( $year - 1 ) +
17 ) %
19 );
1169 $b = intval( ( $year - 1 ) %
4 );
1170 $m = 32.044093161144 +
1.5542417966212 * $a +
$b / 4.0 - 0.0031777940220923 * ( $year - 1 );
1174 $Mar = intval( $m );
1180 $c = intval( ( $Mar +
3 * ( $year - 1 ) +
5 * $b +
5 ) %
7);
1181 if( $c == 0 && $a > 11 && $m >= 0.89772376543210 ) {
1183 } else if( $c == 1 && $a > 6 && $m >= 0.63287037037037 ) {
1185 } else if( $c == 2 ||
$c == 4 ||
$c == 6 ) {
1189 $Mar +
= intval( ( $year - 3761 ) / 100 ) - intval( ( $year - 3761 ) / 400 ) - 24;
1194 * Algorithm to convert Gregorian dates to Thai solar dates,
1195 * Minguo dates or Minguo dates.
1197 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1198 * http://en.wikipedia.org/wiki/Minguo_calendar
1199 * http://en.wikipedia.org/wiki/Japanese_era_name
1201 * @param $ts String: 14-character timestamp
1202 * @param $cName String: calender name
1203 * @return Array: converted year, month, day
1205 private static function tsToYear( $ts, $cName ) {
1206 $gy = substr( $ts, 0, 4 );
1207 $gm = substr( $ts, 4, 2 );
1208 $gd = substr( $ts, 6, 2 );
1210 if (!strcmp($cName,'thai')) {
1212 # Add 543 years to the Gregorian calendar
1213 # Months and days are identical
1214 $gy_offset = $gy +
543;
1215 } else if ((!strcmp($cName,'minguo')) ||
!strcmp($cName,'juche')) {
1217 # Deduct 1911 years from the Gregorian calendar
1218 # Months and days are identical
1219 $gy_offset = $gy - 1911;
1220 } else if (!strcmp($cName,'tenno')) {
1221 # Nengō dates up to Meiji period
1222 # Deduct years from the Gregorian calendar
1223 # depending on the nengo periods
1224 # Months and days are identical
1225 if (($gy < 1912) ||
(($gy == 1912) && ($gm < 7)) ||
(($gy == 1912) && ($gm == 7) && ($gd < 31))) {
1227 $gy_gannen = $gy - 1868 +
1;
1228 $gy_offset = $gy_gannen;
1229 if ($gy_gannen == 1)
1231 $gy_offset = '明治'.$gy_offset;
1232 } else if ((($gy == 1912) && ($gm == 7) && ($gd == 31)) ||
(($gy == 1912) && ($gm >= 8)) ||
(($gy > 1912) && ($gy < 1926)) ||
(($gy == 1926) && ($gm < 12)) ||
(($gy == 1926) && ($gm == 12) && ($gd < 26))) {
1234 $gy_gannen = $gy - 1912 +
1;
1235 $gy_offset = $gy_gannen;
1236 if ($gy_gannen == 1)
1238 $gy_offset = '大正'.$gy_offset;
1239 } else if ((($gy == 1926) && ($gm == 12) && ($gd >= 26)) ||
(($gy > 1926) && ($gy < 1989)) ||
(($gy == 1989) && ($gm == 1) && ($gd < 8))) {
1241 $gy_gannen = $gy - 1926 +
1;
1242 $gy_offset = $gy_gannen;
1243 if ($gy_gannen == 1)
1245 $gy_offset = '昭和'.$gy_offset;
1248 $gy_gannen = $gy - 1989 +
1;
1249 $gy_offset = $gy_gannen;
1250 if ($gy_gannen == 1)
1252 $gy_offset = '平成'.$gy_offset;
1258 return array( $gy_offset, $gm, $gd );
1262 * Roman number formatting up to 3000
1264 static function romanNumeral( $num ) {
1265 static $table = array(
1266 array( '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X' ),
1267 array( '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', 'C' ),
1268 array( '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', 'M' ),
1269 array( '', 'M', 'MM', 'MMM' )
1272 $num = intval( $num );
1273 if ( $num > 3000 ||
$num <= 0 ) {
1278 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1279 if ( $num >= $pow10 ) {
1280 $s .= $table[$i][floor($num / $pow10)];
1282 $num = $num %
$pow10;
1288 * Hebrew Gematria number formatting up to 9999
1290 static function hebrewNumeral( $num ) {
1291 static $table = array(
1292 array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' ),
1293 array( '', 'י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ', 'ק' ),
1294 array( '', 'ק', 'ר', 'ש', 'ת', 'תק', 'תר', 'תש', 'תת', 'תתק', 'תתר' ),
1295 array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' )
1298 $num = intval( $num );
1299 if ( $num > 9999 ||
$num <= 0 ) {
1304 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1305 if ( $num >= $pow10 ) {
1306 if ( $num == 15 ||
$num == 16 ) {
1307 $s .= $table[0][9] . $table[0][$num - 9];
1310 $s .= $table[$i][intval( ( $num / $pow10 ) )];
1311 if( $pow10 == 1000 ) {
1316 $num = $num %
$pow10;
1318 if( strlen( $s ) == 2 ) {
1321 $str = substr( $s, 0, strlen( $s ) - 2 ) . '"';
1322 $str .= substr( $s, strlen( $s ) - 2, 2 );
1324 $start = substr( $str, 0, strlen( $str ) - 2 );
1325 $end = substr( $str, strlen( $str ) - 2 );
1328 $str = $start . 'ך';
1331 $str = $start . 'ם';
1334 $str = $start . 'ן';
1337 $str = $start . 'ף';
1340 $str = $start . 'ץ';
1347 * This is meant to be used by time(), date(), and timeanddate() to get
1348 * the date preference they're supposed to use, it should be used in
1352 * function timeanddate([...], $format = true) {
1353 * $datePreference = $this->dateFormat($format);
1358 * @param $usePrefs Mixed: if true, the user's preference is used
1359 * if false, the site/language default is used
1360 * if int/string, assumed to be a format.
1363 function dateFormat( $usePrefs = true ) {
1366 if( is_bool( $usePrefs ) ) {
1368 $datePreference = $wgUser->getDatePreference();
1370 $options = User
::getDefaultOptions();
1371 $datePreference = (string)$options['date'];
1374 $datePreference = (string)$usePrefs;
1378 if( $datePreference == '' ) {
1382 return $datePreference;
1386 * Get a format string for a given type and preference
1387 * @param $type May be date, time or both
1388 * @param $pref The format name as it appears in Messages*.php
1390 function getDateFormatString( $type, $pref ) {
1391 if ( !isset( $this->dateFormatStrings
[$type][$pref] ) ) {
1392 if ( $pref == 'default' ) {
1393 $pref = $this->getDefaultDateFormat();
1394 $df = self
::$dataCache->getSubitem( $this->mCode
, 'dateFormats', "$pref $type" );
1396 $df = self
::$dataCache->getSubitem( $this->mCode
, 'dateFormats', "$pref $type" );
1397 if ( is_null( $df ) ) {
1398 $pref = $this->getDefaultDateFormat();
1399 $df = self
::$dataCache->getSubitem( $this->mCode
, 'dateFormats', "$pref $type" );
1402 $this->dateFormatStrings
[$type][$pref] = $df;
1404 return $this->dateFormatStrings
[$type][$pref];
1408 * @param $ts Mixed: the time format which needs to be turned into a
1409 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1410 * @param $adj Bool: whether to adjust the time output according to the
1411 * user configured offset ($timecorrection)
1412 * @param $format Mixed: true to use user's date format preference
1413 * @param $timecorrection String: the time offset as returned by
1414 * validateTimeZone() in Special:Preferences
1417 function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
1419 $ts = $this->userAdjust( $ts, $timecorrection );
1421 $df = $this->getDateFormatString( 'date', $this->dateFormat( $format ) );
1422 return $this->sprintfDate( $df, $ts );
1426 * @param $ts Mixed: the time format which needs to be turned into a
1427 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1428 * @param $adj Bool: whether to adjust the time output according to the
1429 * user configured offset ($timecorrection)
1430 * @param $format Mixed: true to use user's date format preference
1431 * @param $timecorrection String: the time offset as returned by
1432 * validateTimeZone() in Special:Preferences
1435 function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
1437 $ts = $this->userAdjust( $ts, $timecorrection );
1439 $df = $this->getDateFormatString( 'time', $this->dateFormat( $format ) );
1440 return $this->sprintfDate( $df, $ts );
1444 * @param $ts Mixed: the time format which needs to be turned into a
1445 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1446 * @param $adj Bool: whether to adjust the time output according to the
1447 * user configured offset ($timecorrection)
1448 * @param $format Mixed: what format to return, if it's false output the
1449 * default one (default true)
1450 * @param $timecorrection String: the time offset as returned by
1451 * validateTimeZone() in Special:Preferences
1454 function timeanddate( $ts, $adj = false, $format = true, $timecorrection = false) {
1455 $ts = wfTimestamp( TS_MW
, $ts );
1457 $ts = $this->userAdjust( $ts, $timecorrection );
1459 $df = $this->getDateFormatString( 'both', $this->dateFormat( $format ) );
1460 return $this->sprintfDate( $df, $ts );
1463 function getMessage( $key ) {
1464 return self
::$dataCache->getSubitem( $this->mCode
, 'messages', $key );
1467 function getAllMessages() {
1468 return self
::$dataCache->getItem( $this->mCode
, 'messages' );
1471 function iconv( $in, $out, $string ) {
1472 # This is a wrapper for iconv in all languages except esperanto,
1473 # which does some nasty x-conversions beforehand
1475 # Even with //IGNORE iconv can whine about illegal characters in
1476 # *input* string. We just ignore those too.
1477 # REF: http://bugs.php.net/bug.php?id=37166
1478 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1479 wfSuppressWarnings();
1480 $text = iconv( $in, $out . '//IGNORE', $string );
1481 wfRestoreWarnings();
1485 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1486 function ucwordbreaksCallbackAscii($matches){
1487 return $this->ucfirst($matches[1]);
1490 function ucwordbreaksCallbackMB($matches){
1491 return mb_strtoupper($matches[0]);
1494 function ucCallback($matches){
1495 list( $wikiUpperChars ) = self
::getCaseMaps();
1496 return strtr( $matches[1], $wikiUpperChars );
1499 function lcCallback($matches){
1500 list( , $wikiLowerChars ) = self
::getCaseMaps();
1501 return strtr( $matches[1], $wikiLowerChars );
1504 function ucwordsCallbackMB($matches){
1505 return mb_strtoupper($matches[0]);
1508 function ucwordsCallbackWiki($matches){
1509 list( $wikiUpperChars ) = self
::getCaseMaps();
1510 return strtr( $matches[0], $wikiUpperChars );
1513 function ucfirst( $str ) {
1517 } elseif ( $o < 128 ) {
1518 return ucfirst($str);
1520 // fall back to more complex logic in case of multibyte strings
1521 return self
::uc($str,true);
1525 function uc( $str, $first = false ) {
1526 if ( function_exists( 'mb_strtoupper' ) ) {
1528 if ( self
::isMultibyte( $str ) ) {
1529 return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1531 return ucfirst( $str );
1534 return self
::isMultibyte( $str ) ?
mb_strtoupper( $str ) : strtoupper( $str );
1537 if ( self
::isMultibyte( $str ) ) {
1538 list( $wikiUpperChars ) = $this->getCaseMaps();
1539 $x = $first ?
'^' : '';
1540 return preg_replace_callback(
1541 "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1542 array($this,"ucCallback"),
1546 return $first ?
ucfirst( $str ) : strtoupper( $str );
1551 function lcfirst( $str ) {
1554 return strval( $str );
1555 } elseif ( $o >= 128 ) {
1556 return self
::lc( $str, true );
1557 } elseif ( $o > 96 ) {
1560 $str[0] = strtolower( $str[0] );
1565 function lc( $str, $first = false ) {
1566 if ( function_exists( 'mb_strtolower' ) )
1568 if ( self
::isMultibyte( $str ) )
1569 return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1571 return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
1573 return self
::isMultibyte( $str ) ?
mb_strtolower( $str ) : strtolower( $str );
1575 if ( self
::isMultibyte( $str ) ) {
1576 list( , $wikiLowerChars ) = self
::getCaseMaps();
1577 $x = $first ?
'^' : '';
1578 return preg_replace_callback(
1579 "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1580 array($this,"lcCallback"),
1584 return $first ?
strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
1587 function isMultibyte( $str ) {
1588 return (bool)preg_match( '/[\x80-\xff]/', $str );
1591 function ucwords($str) {
1592 if ( self
::isMultibyte( $str ) ) {
1593 $str = self
::lc($str);
1595 // regexp to find first letter in each word (i.e. after each space)
1596 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1598 // function to use to capitalize a single char
1599 if ( function_exists( 'mb_strtoupper' ) )
1600 return preg_replace_callback(
1602 array($this,"ucwordsCallbackMB"),
1606 return preg_replace_callback(
1608 array($this,"ucwordsCallbackWiki"),
1613 return ucwords( strtolower( $str ) );
1616 # capitalize words at word breaks
1617 function ucwordbreaks($str){
1618 if (self
::isMultibyte( $str ) ) {
1619 $str = self
::lc($str);
1621 // since \b doesn't work for UTF-8, we explicitely define word break chars
1622 $breaks= "[ \-\(\)\}\{\.,\?!]";
1624 // find first letter after word break
1625 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1627 if ( function_exists( 'mb_strtoupper' ) )
1628 return preg_replace_callback(
1630 array($this,"ucwordbreaksCallbackMB"),
1634 return preg_replace_callback(
1636 array($this,"ucwordsCallbackWiki"),
1641 return preg_replace_callback(
1642 '/\b([\w\x80-\xff]+)\b/',
1643 array($this,"ucwordbreaksCallbackAscii"),
1648 * Return a case-folded representation of $s
1650 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1651 * and $s2 are the same except for the case of their characters. It is not
1652 * necessary for the value returned to make sense when displayed.
1654 * Do *not* perform any other normalisation in this function. If a caller
1655 * uses this function when it should be using a more general normalisation
1656 * function, then fix the caller.
1658 function caseFold( $s ) {
1659 return $this->uc( $s );
1662 function checkTitleEncoding( $s ) {
1663 if( is_array( $s ) ) {
1664 wfDebugDieBacktrace( 'Given array to checkTitleEncoding.' );
1666 # Check for non-UTF-8 URLs
1667 $ishigh = preg_match( '/[\x80-\xff]/', $s);
1668 if(!$ishigh) return $s;
1670 $isutf8 = preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1671 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
1672 if( $isutf8 ) return $s;
1674 return $this->iconv( $this->fallback8bitEncoding(), "utf-8", $s );
1677 function fallback8bitEncoding() {
1678 return self
::$dataCache->getItem( $this->mCode
, 'fallback8bitEncoding' );
1682 * Most writing systems use whitespace to break up words.
1683 * Some languages such as Chinese don't conventionally do this,
1684 * which requires special handling when breaking up words for
1687 function hasWordBreaks() {
1692 * Some languages such as Chinese require word segmentation,
1693 * Specify such segmentation when overridden in derived class.
1695 * @param $string String
1698 function wordSegmentation( $string ) {
1703 * Some languages have special punctuation need to be normalized.
1704 * Make such changes here.
1706 * @param $string String
1709 function normalizeForSearch( $string ) {
1714 * convert double-width roman characters to single-width.
1715 * range: ff00-ff5f ~= 0020-007f
1717 protected static function convertDoubleWidth( $string ) {
1718 $string = preg_replace( '/\xef\xbc([\x80-\xbf])/e', 'chr((ord("$1") & 0x3f) + 0x20)', $string );
1719 $string = preg_replace( '/\xef\xbd([\x80-\x99])/e', 'chr((ord("$1") & 0x3f) + 0x60)', $string );
1723 protected static function insertSpace( $string, $pattern ) {
1724 $string = preg_replace( $pattern, " $1 ", $string );
1725 $string = preg_replace( '/ +/', ' ', $string );
1729 function convertForSearchResult( $termsArray ) {
1730 # some languages, e.g. Chinese, need to do a conversion
1731 # in order for search results to be displayed correctly
1736 * Get the first character of a string.
1741 function firstChar( $s ) {
1743 preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1744 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/', $s, $matches);
1746 if ( isset( $matches[1] ) ) {
1747 if ( strlen( $matches[1] ) != 3 ) {
1751 // Break down Hangul syllables to grab the first jamo
1752 $code = utf8ToCodepoint( $matches[1] );
1753 if ( $code < 0xac00 ||
0xd7a4 <= $code) {
1755 } elseif ( $code < 0xb098 ) {
1756 return "\xe3\x84\xb1";
1757 } elseif ( $code < 0xb2e4 ) {
1758 return "\xe3\x84\xb4";
1759 } elseif ( $code < 0xb77c ) {
1760 return "\xe3\x84\xb7";
1761 } elseif ( $code < 0xb9c8 ) {
1762 return "\xe3\x84\xb9";
1763 } elseif ( $code < 0xbc14 ) {
1764 return "\xe3\x85\x81";
1765 } elseif ( $code < 0xc0ac ) {
1766 return "\xe3\x85\x82";
1767 } elseif ( $code < 0xc544 ) {
1768 return "\xe3\x85\x85";
1769 } elseif ( $code < 0xc790 ) {
1770 return "\xe3\x85\x87";
1771 } elseif ( $code < 0xcc28 ) {
1772 return "\xe3\x85\x88";
1773 } elseif ( $code < 0xce74 ) {
1774 return "\xe3\x85\x8a";
1775 } elseif ( $code < 0xd0c0 ) {
1776 return "\xe3\x85\x8b";
1777 } elseif ( $code < 0xd30c ) {
1778 return "\xe3\x85\x8c";
1779 } elseif ( $code < 0xd558 ) {
1780 return "\xe3\x85\x8d";
1782 return "\xe3\x85\x8e";
1789 function initEncoding() {
1790 # Some languages may have an alternate char encoding option
1791 # (Esperanto X-coding, Japanese furigana conversion, etc)
1792 # If this language is used as the primary content language,
1793 # an override to the defaults can be set here on startup.
1796 function recodeForEdit( $s ) {
1797 # For some languages we'll want to explicitly specify
1798 # which characters make it into the edit box raw
1799 # or are converted in some way or another.
1800 # Note that if wgOutputEncoding is different from
1801 # wgInputEncoding, this text will be further converted
1802 # to wgOutputEncoding.
1803 global $wgEditEncoding;
1804 if( $wgEditEncoding == '' or
1805 $wgEditEncoding == 'UTF-8' ) {
1808 return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
1812 function recodeInput( $s ) {
1813 # Take the previous into account.
1814 global $wgEditEncoding;
1815 if($wgEditEncoding != "") {
1816 $enc = $wgEditEncoding;
1820 if( $enc == 'UTF-8' ) {
1823 return $this->iconv( $enc, 'UTF-8', $s );
1828 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
1829 * also cleans up certain backwards-compatible sequences, converting them
1830 * to the modern Unicode equivalent.
1832 * This is language-specific for performance reasons only.
1834 function normalize( $s ) {
1835 return UtfNormal
::cleanUp( $s );
1839 * Transform a string using serialized data stored in the given file (which
1840 * must be in the serialized subdirectory of $IP). The file contains pairs
1841 * mapping source characters to destination characters.
1843 * The data is cached in process memory. This will go faster if you have the
1844 * FastStringSearch extension.
1846 function transformUsingPairFile( $file, $string ) {
1847 if ( !isset( $this->transformData
[$file] ) ) {
1848 $data = wfGetPrecompiledData( $file );
1849 if ( $data === false ) {
1850 throw new MWException( __METHOD__
.": The transformation file $file is missing" );
1852 $this->transformData
[$file] = new ReplacementArray( $data );
1854 return $this->transformData
[$file]->replace( $string );
1858 * For right-to-left language support
1863 return self
::$dataCache->getItem( $this->mCode
, 'rtl' );
1867 * Return the correct HTML 'dir' attribute value for this language.
1871 return $this->isRTL() ?
'rtl' : 'ltr';
1875 * Return 'left' or 'right' as appropriate alignment for line-start
1876 * for this language's text direction.
1878 * Should be equivalent to CSS3 'start' text-align value....
1882 function alignStart() {
1883 return $this->isRTL() ?
'right' : 'left';
1887 * Return 'right' or 'left' as appropriate alignment for line-end
1888 * for this language's text direction.
1890 * Should be equivalent to CSS3 'end' text-align value....
1894 function alignEnd() {
1895 return $this->isRTL() ?
'left' : 'right';
1899 * A hidden direction mark (LRM or RLM), depending on the language direction
1903 function getDirMark() {
1904 return $this->isRTL() ?
"\xE2\x80\x8F" : "\xE2\x80\x8E";
1907 function capitalizeAllNouns() {
1908 return self
::$dataCache->getItem( $this->mCode
, 'capitalizeAllNouns' );
1912 * An arrow, depending on the language direction
1916 function getArrow() {
1917 return $this->isRTL() ?
'←' : '→';
1921 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
1925 function linkPrefixExtension() {
1926 return self
::$dataCache->getItem( $this->mCode
, 'linkPrefixExtension' );
1929 function getMagicWords() {
1930 return self
::$dataCache->getItem( $this->mCode
, 'magicWords' );
1933 # Fill a MagicWord object with data from here
1934 function getMagic( $mw ) {
1935 if ( !$this->mMagicHookDone
) {
1936 $this->mMagicHookDone
= true;
1937 wfProfileIn( 'LanguageGetMagic' );
1938 wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions
, $this->getCode() ) );
1939 wfProfileOut( 'LanguageGetMagic' );
1941 if ( isset( $this->mMagicExtensions
[$mw->mId
] ) ) {
1942 $rawEntry = $this->mMagicExtensions
[$mw->mId
];
1944 $magicWords = $this->getMagicWords();
1945 if ( isset( $magicWords[$mw->mId
] ) ) {
1946 $rawEntry = $magicWords[$mw->mId
];
1952 if( !is_array( $rawEntry ) ) {
1953 error_log( "\"$rawEntry\" is not a valid magic thingie for \"$mw->mId\"" );
1955 $mw->mCaseSensitive
= $rawEntry[0];
1956 $mw->mSynonyms
= array_slice( $rawEntry, 1 );
1961 * Add magic words to the extension array
1963 function addMagicWordsByLang( $newWords ) {
1964 $code = $this->getCode();
1965 $fallbackChain = array();
1966 while ( $code && !in_array( $code, $fallbackChain ) ) {
1967 $fallbackChain[] = $code;
1968 $code = self
::getFallbackFor( $code );
1970 if ( !in_array( 'en', $fallbackChain ) ) {
1971 $fallbackChain[] = 'en';
1973 $fallbackChain = array_reverse( $fallbackChain );
1974 foreach ( $fallbackChain as $code ) {
1975 if ( isset( $newWords[$code] ) ) {
1976 $this->mMagicExtensions
= $newWords[$code] +
$this->mMagicExtensions
;
1982 * Get special page names, as an associative array
1983 * case folded alias => real name
1985 function getSpecialPageAliases() {
1986 // Cache aliases because it may be slow to load them
1987 if ( is_null( $this->mExtendedSpecialPageAliases
) ) {
1989 $this->mExtendedSpecialPageAliases
=
1990 self
::$dataCache->getItem( $this->mCode
, 'specialPageAliases' );
1991 wfRunHooks( 'LanguageGetSpecialPageAliases',
1992 array( &$this->mExtendedSpecialPageAliases
, $this->getCode() ) );
1995 return $this->mExtendedSpecialPageAliases
;
1999 * Italic is unsuitable for some languages
2001 * @param $text String: the text to be emphasized.
2004 function emphasize( $text ) {
2005 return "<em>$text</em>";
2009 * Normally we output all numbers in plain en_US style, that is
2010 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2011 * point twohundredthirtyfive. However this is not sutable for all
2012 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2013 * Icelandic just want to use commas instead of dots, and dots instead
2014 * of commas like "293.291,235".
2016 * An example of this function being called:
2018 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2021 * See LanguageGu.php for the Gujarati implementation and
2022 * $separatorTransformTable on MessageIs.php for
2023 * the , => . and . => , implementation.
2025 * @todo check if it's viable to use localeconv() for the decimal
2027 * @param $number Mixed: the string to be formatted, should be an integer
2028 * or a floating point number.
2029 * @param $nocommafy Bool: set to true for special numbers like dates
2032 function formatNum( $number, $nocommafy = false ) {
2033 global $wgTranslateNumerals;
2035 $number = $this->commafy($number);
2036 $s = $this->separatorTransformTable();
2037 if ($s) { $number = strtr($number, $s); }
2040 if ($wgTranslateNumerals) {
2041 $s = $this->digitTransformTable();
2042 if ($s) { $number = strtr($number, $s); }
2048 function parseFormattedNumber( $number ) {
2049 $s = $this->digitTransformTable();
2050 if ($s) { $number = strtr($number, array_flip($s)); }
2052 $s = $this->separatorTransformTable();
2053 if ($s) { $number = strtr($number, array_flip($s)); }
2055 $number = strtr( $number, array (',' => '') );
2060 * Adds commas to a given number
2065 function commafy($_) {
2066 return strrev((string)preg_replace('/(\d{3})(?=\d)(?!\d*\.)/','$1,',strrev($_)));
2069 function digitTransformTable() {
2070 return self
::$dataCache->getItem( $this->mCode
, 'digitTransformTable' );
2073 function separatorTransformTable() {
2074 return self
::$dataCache->getItem( $this->mCode
, 'separatorTransformTable' );
2079 * Take a list of strings and build a locale-friendly comma-separated
2080 * list, using the local comma-separator message.
2081 * The last two strings are chained with an "and".
2086 function listToText( $l ) {
2088 $m = count( $l ) - 1;
2090 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2093 for ( $i = $m; $i >= 0; $i-- ) {
2096 } else if( $i == $m - 1 ) {
2097 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2099 $s = $l[$i] . $this->getMessageFromDB( 'comma-separator' ) . $s;
2107 * Take a list of strings and build a locale-friendly comma-separated
2108 * list, using the local comma-separator message.
2109 * @param $list array of strings to put in a comma list
2112 function commaList( $list ) {
2115 wfMsgExt( 'comma-separator', array( 'parsemag', 'escapenoentities', 'language' => $this ) ) );
2119 * Take a list of strings and build a locale-friendly semicolon-separated
2120 * list, using the local semicolon-separator message.
2121 * @param $list array of strings to put in a semicolon list
2124 function semicolonList( $list ) {
2127 wfMsgExt( 'semicolon-separator', array( 'parsemag', 'escapenoentities', 'language' => $this ) ) );
2131 * Same as commaList, but separate it with the pipe instead.
2132 * @param $list array of strings to put in a pipe list
2135 function pipeList( $list ) {
2138 wfMsgExt( 'pipe-separator', array( 'escapenoentities', 'language' => $this ) ) );
2142 * Truncate a string to a specified length in bytes, appending an optional
2143 * string (e.g. for ellipses)
2145 * The database offers limited byte lengths for some columns in the database;
2146 * multi-byte character sets mean we need to ensure that only whole characters
2147 * are included, otherwise broken characters can be passed to the user
2149 * If $length is negative, the string will be truncated from the beginning
2151 * @param $string String to truncate
2152 * @param $length Int: maximum length (excluding ellipses)
2153 * @param $ellipsis String to append to the truncated text
2156 function truncate( $string, $length, $ellipsis = '...' ) {
2157 # Use the localized ellipsis character
2158 if( $ellipsis == '...' ) {
2159 $ellipsis = wfMsgExt( 'ellipsis', array( 'escapenoentities', 'language' => $this ) );
2162 if( $length == 0 ) {
2165 if ( strlen( $string ) <= abs( $length ) ) {
2168 $stringOriginal = $string;
2170 $string = substr( $string, 0, $length );
2171 $char = ord( $string[strlen( $string ) - 1] );
2173 if ($char >= 0xc0) {
2174 # We got the first byte only of a multibyte char; remove it.
2175 $string = substr( $string, 0, -1 );
2176 } elseif( $char >= 0x80 &&
2177 preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
2178 '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
2179 # We chopped in the middle of a character; remove it
2182 $string = $string . $ellipsis;
2185 $string = substr( $string, $length );
2186 $char = ord( $string[0] );
2187 if( $char >= 0x80 && $char < 0xc0 ) {
2188 # We chopped in the middle of a character; remove the whole thing
2189 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
2191 $string = $ellipsis . $string;
2193 # Do not truncate if the ellipsis actually make the string longer. Bug 22181
2194 if ( strlen( $string ) < strlen( $stringOriginal ) ) {
2197 return $stringOriginal;
2202 * Grammatical transformations, needed for inflected languages
2203 * Invoked by putting {{grammar:case|word}} in a message
2205 * @param $word string
2206 * @param $case string
2209 function convertGrammar( $word, $case ) {
2210 global $wgGrammarForms;
2211 if ( isset($wgGrammarForms[$this->getCode()][$case][$word]) ) {
2212 return $wgGrammarForms[$this->getCode()][$case][$word];
2218 * Provides an alternative text depending on specified gender.
2219 * Usage {{gender:username|masculine|feminine|neutral}}.
2220 * username is optional, in which case the gender of current user is used,
2221 * but only in (some) interface messages; otherwise default gender is used.
2222 * If second or third parameter are not specified, masculine is used.
2223 * These details may be overriden per language.
2225 function gender( $gender, $forms ) {
2226 if ( !count($forms) ) { return ''; }
2227 $forms = $this->preConvertPlural( $forms, 2 );
2228 if ( $gender === 'male' ) return $forms[0];
2229 if ( $gender === 'female' ) return $forms[1];
2230 return isset($forms[2]) ?
$forms[2] : $forms[0];
2234 * Plural form transformations, needed for some languages.
2235 * For example, there are 3 form of plural in Russian and Polish,
2236 * depending on "count mod 10". See [[w:Plural]]
2237 * For English it is pretty simple.
2239 * Invoked by putting {{plural:count|wordform1|wordform2}}
2240 * or {{plural:count|wordform1|wordform2|wordform3}}
2242 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2244 * @param $count Integer: non-localized number
2245 * @param $forms Array: different plural forms
2246 * @return string Correct form of plural for $count in this language
2248 function convertPlural( $count, $forms ) {
2249 if ( !count($forms) ) { return ''; }
2250 $forms = $this->preConvertPlural( $forms, 2 );
2252 return ( $count == 1 ) ?
$forms[0] : $forms[1];
2256 * Checks that convertPlural was given an array and pads it to requested
2257 * amound of forms by copying the last one.
2259 * @param $count Integer: How many forms should there be at least
2260 * @param $forms Array of forms given to convertPlural
2261 * @return array Padded array of forms or an exception if not an array
2263 protected function preConvertPlural( /* Array */ $forms, $count ) {
2264 while ( count($forms) < $count ) {
2265 $forms[] = $forms[count($forms)-1];
2271 * For translaing of expiry times
2272 * @param $str String: the validated block time in English
2273 * @return Somehow translated block time
2274 * @see LanguageFi.php for example implementation
2276 function translateBlockExpiry( $str ) {
2278 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
2280 if ( $scBlockExpiryOptions == '-') {
2284 foreach (explode(',', $scBlockExpiryOptions) as $option) {
2285 if ( strpos($option, ":") === false )
2287 list($show, $value) = explode(":", $option);
2288 if ( strcmp ( $str, $value) == 0 ) {
2289 return htmlspecialchars( trim( $show ) );
2297 * languages like Chinese need to be segmented in order for the diff
2300 * @param $text String
2303 function segmentForDiff( $text ) {
2308 * and unsegment to show the result
2310 * @param $text String
2313 function unsegmentForDiff( $text ) {
2317 # convert text to all supported variants
2318 function autoConvertToAllVariants($text) {
2319 return $this->mConverter
->autoConvertToAllVariants($text);
2322 # convert text to different variants of a language.
2323 function convert( $text, $isTitle = false) {
2324 return $this->mConverter
->convert($text, $isTitle);
2327 # Check if this is a language with variants
2328 function hasVariants(){
2329 return sizeof($this->getVariants())>1;
2332 # Put custom tags (e.g. -{ }-) around math to prevent conversion
2333 function armourMath($text){
2334 return $this->mConverter
->armourMath($text);
2339 * Perform output conversion on a string, and encode for safe HTML output.
2340 * @param $text String text to be converted
2341 * @param $isTitle Bool whether this conversion is for the article title
2343 * @todo this should get integrated somewhere sane
2345 function convertHtml( $text, $isTitle = false ) {
2346 return htmlspecialchars( $this->convert( $text, $isTitle ) );
2349 function convertCategoryKey( $key ) {
2350 return $this->mConverter
->convertCategoryKey( $key );
2354 * get the list of variants supported by this langauge
2355 * see sample implementation in LanguageZh.php
2357 * @return array an array of language codes
2359 function getVariants() {
2360 return $this->mConverter
->getVariants();
2364 function getPreferredVariant( $fromUser = true, $fromHeader = false ) {
2365 return $this->mConverter
->getPreferredVariant( $fromUser, $fromHeader );
2369 * if a language supports multiple variants, it is
2370 * possible that non-existing link in one variant
2371 * actually exists in another variant. this function
2372 * tries to find it. See e.g. LanguageZh.php
2374 * @param $link String: the name of the link
2375 * @param $nt Mixed: the title object of the link
2376 * @param $ignoreOtherCond Boolean: to disable other conditions when
2377 * we need to transclude a template or update a category's link
2378 * @return null the input parameters may be modified upon return
2380 function findVariantLink( &$link, &$nt, $ignoreOtherCond = false ) {
2381 $this->mConverter
->findVariantLink( $link, $nt, $ignoreOtherCond );
2385 * If a language supports multiple variants, converts text
2386 * into an array of all possible variants of the text:
2387 * 'variant' => text in that variant
2389 function convertLinkToAllVariants($text){
2390 return $this->mConverter
->convertLinkToAllVariants($text);
2395 * returns language specific options used by User::getPageRenderHash()
2396 * for example, the preferred language variant
2400 function getExtraHashOptions() {
2401 return $this->mConverter
->getExtraHashOptions();
2405 * for languages that support multiple variants, the title of an
2406 * article may be displayed differently in different variants. this
2407 * function returns the apporiate title defined in the body of the article.
2411 function getParsedTitle() {
2412 return $this->mConverter
->getParsedTitle();
2416 * Enclose a string with the "no conversion" tag. This is used by
2417 * various functions in the Parser
2419 * @param $text String: text to be tagged for no conversion
2421 * @return string the tagged text
2423 function markNoConversion( $text, $noParse=false ) {
2424 return $this->mConverter
->markNoConversion( $text, $noParse );
2428 * A regular expression to match legal word-trailing characters
2429 * which should be merged onto a link of the form [[foo]]bar.
2433 function linkTrail() {
2434 return self
::$dataCache->getItem( $this->mCode
, 'linkTrail' );
2437 function getLangObj() {
2442 * Get the RFC 3066 code for this language object
2444 function getCode() {
2445 return $this->mCode
;
2448 function setCode( $code ) {
2449 $this->mCode
= $code;
2453 * Get the name of a file for a certain language code
2454 * @param $prefix string Prepend this to the filename
2455 * @param $code string Language code
2456 * @param $suffix string Append this to the filename
2457 * @return string $prefix . $mangledCode . $suffix
2459 static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
2460 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
2464 * Get the language code from a file name. Inverse of getFileName()
2465 * @param $filename string $prefix . $languageCode . $suffix
2466 * @param $prefix string Prefix before the language code
2467 * @param $suffix string Suffix after the language code
2468 * @return Language code, or false if $prefix or $suffix isn't found
2470 static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
2472 preg_match( '/' . preg_quote( $prefix, '/' ) . '([A-Z][a-z_]+)' .
2473 preg_quote( $suffix, '/' ) . '/', $filename, $m );
2474 if ( !count( $m ) ) {
2477 return str_replace( '_', '-', strtolower( $m[1] ) );
2480 static function getMessagesFileName( $code ) {
2482 return self
::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
2485 static function getClassFileName( $code ) {
2487 return self
::getFileName( "$IP/languages/classes/Language", $code, '.php' );
2491 * Get the fallback for a given language
2493 static function getFallbackFor( $code ) {
2494 if ( $code === 'en' ) {
2498 return self
::getLocalisationCache()->getItem( $code, 'fallback' );
2503 * Get all messages for a given language
2504 * WARNING: this may take a long time
2506 static function getMessagesFor( $code ) {
2507 return self
::getLocalisationCache()->getItem( $code, 'messages' );
2511 * Get a message for a given language
2513 static function getMessageFor( $key, $code ) {
2514 return self
::getLocalisationCache()->getSubitem( $code, 'messages', $key );
2517 function fixVariableInNamespace( $talk ) {
2518 if ( strpos( $talk, '$1' ) === false ) return $talk;
2520 global $wgMetaNamespace;
2521 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
2523 # Allow grammar transformations
2524 # Allowing full message-style parsing would make simple requests
2525 # such as action=raw much more expensive than they need to be.
2526 # This will hopefully cover most cases.
2527 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
2528 array( &$this, 'replaceGrammarInNamespace' ), $talk );
2529 return str_replace( ' ', '_', $talk );
2532 function replaceGrammarInNamespace( $m ) {
2533 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
2536 static function getCaseMaps() {
2537 static $wikiUpperChars, $wikiLowerChars;
2538 if ( isset( $wikiUpperChars ) ) {
2539 return array( $wikiUpperChars, $wikiLowerChars );
2542 wfProfileIn( __METHOD__
);
2543 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
2544 if ( $arr === false ) {
2545 throw new MWException(
2546 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
2549 wfProfileOut( __METHOD__
);
2550 return array( $wikiUpperChars, $wikiLowerChars );
2553 function formatTimePeriod( $seconds ) {
2554 if ( $seconds < 10 ) {
2555 return $this->formatNum( sprintf( "%.1f", $seconds ) ) . wfMsg( 'seconds-abbrev' );
2556 } elseif ( $seconds < 60 ) {
2557 return $this->formatNum( round( $seconds ) ) . wfMsg( 'seconds-abbrev' );
2558 } elseif ( $seconds < 3600 ) {
2559 return $this->formatNum( floor( $seconds / 60 ) ) . wfMsg( 'minutes-abbrev' ) .
2560 $this->formatNum( round( fmod( $seconds, 60 ) ) ) . wfMsg( 'seconds-abbrev' );
2562 $hours = floor( $seconds / 3600 );
2563 $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
2564 $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
2565 return $this->formatNum( $hours ) . wfMsg( 'hours-abbrev' ) .
2566 $this->formatNum( $minutes ) . wfMsg( 'minutes-abbrev' ) .
2567 $this->formatNum( $secondsPart ) . wfMsg( 'seconds-abbrev' );
2571 function formatBitrate( $bps ) {
2572 $units = array( 'bps', 'kbps', 'Mbps', 'Gbps' );
2574 return $this->formatNum( $bps ) . $units[0];
2576 $unitIndex = floor( log10( $bps ) / 3 );
2577 $mantissa = $bps / pow( 1000, $unitIndex );
2578 if ( $mantissa < 10 ) {
2579 $mantissa = round( $mantissa, 1 );
2581 $mantissa = round( $mantissa );
2583 return $this->formatNum( $mantissa ) . $units[$unitIndex];
2587 * Format a size in bytes for output, using an appropriate
2588 * unit (B, KB, MB or GB) according to the magnitude in question
2590 * @param $size Size to format
2591 * @return string Plain text (not HTML)
2593 function formatSize( $size ) {
2594 // For small sizes no decimal places necessary
2596 if( $size > 1024 ) {
2597 $size = $size / 1024;
2598 if( $size > 1024 ) {
2599 $size = $size / 1024;
2600 // For MB and bigger two decimal places are smarter
2602 if( $size > 1024 ) {
2603 $size = $size / 1024;
2604 $msg = 'size-gigabytes';
2606 $msg = 'size-megabytes';
2609 $msg = 'size-kilobytes';
2612 $msg = 'size-bytes';
2614 $size = round( $size, $round );
2615 $text = $this->getMessageFromDB( $msg );
2616 return str_replace( '$1', $this->formatNum( $size ), $text );
2620 * Get the conversion rule title, if any.
2622 function getConvRuleTitle() {
2623 return $this->mConverter
->getConvRuleTitle();