DifferenceEngine cleanup
[mediawiki.git] / languages / Language.php
blob6bbd8bf56eb72a8a05f32e476676717cb19f1090
1 <?php
2 /**
3 * Internationalisation code.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
20 * @file
21 * @ingroup Language
24 /**
25 * @defgroup Language Language
28 if ( !defined( 'MEDIAWIKI' ) ) {
29 echo "This file is part of MediaWiki, it is not a valid entry point.\n";
30 exit( 1 );
33 if ( function_exists( 'mb_strtoupper' ) ) {
34 mb_internal_encoding( 'UTF-8' );
37 /**
38 * a fake language converter
40 * @ingroup Language
42 class FakeConverter {
43 /**
44 * @var Language
46 public $mLang;
47 function __construct( $langobj ) { $this->mLang = $langobj; }
48 function autoConvert( $text, $variant = false ) { return $text; }
49 function autoConvertToAllVariants( $text ) { return array( $this->mLang->getCode() => $text ); }
50 function convert( $t ) { return $t; }
51 function convertTo( $text, $variant ) { return $text; }
52 function convertTitle( $t ) { return $t->getPrefixedText(); }
53 function convertNamespace( $ns ) { return $this->mLang->getFormattedNsText( $ns ); }
54 function getVariants() { return array( $this->mLang->getCode() ); }
55 function getVariantFallbacks( $variant ) { return $this->mLang->getCode(); }
56 function getPreferredVariant() { return $this->mLang->getCode(); }
57 function getDefaultVariant() { return $this->mLang->getCode(); }
58 function getURLVariant() { return ''; }
59 function getConvRuleTitle() { return false; }
60 function findVariantLink( &$l, &$n, $ignoreOtherCond = false ) { }
61 function getExtraHashOptions() { return ''; }
62 function getParsedTitle() { return ''; }
63 function markNoConversion( $text, $noParse = false ) { return $text; }
64 function convertCategoryKey( $key ) { return $key; }
65 function convertLinkToAllVariants( $text ) { return $this->autoConvertToAllVariants( $text ); }
66 /** @deprecated since 1.22 is no longer used */
67 function armourMath( $text ) { return $text; }
68 function validateVariant( $variant = null ) { return $variant === $this->mLang->getCode() ? $variant : null; }
69 function translate( $text, $variant ) { return $text; }
72 /**
73 * Internationalisation code
74 * @ingroup Language
76 class Language {
78 /**
79 * @var LanguageConverter
81 public $mConverter;
83 public $mVariants, $mCode, $mLoaded = false;
84 public $mMagicExtensions = array(), $mMagicHookDone = false;
85 private $mHtmlCode = null, $mParentLanguage = false;
87 public $dateFormatStrings = array();
88 public $mExtendedSpecialPageAliases;
90 protected $namespaceNames, $mNamespaceIds, $namespaceAliases;
92 /**
93 * ReplacementArray object caches
95 public $transformData = array();
97 /**
98 * @var LocalisationCache
100 static public $dataCache;
102 static public $mLangObjCache = array();
104 static public $mWeekdayMsgs = array(
105 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
106 'friday', 'saturday'
109 static public $mWeekdayAbbrevMsgs = array(
110 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'
113 static public $mMonthMsgs = array(
114 'january', 'february', 'march', 'april', 'may_long', 'june',
115 'july', 'august', 'september', 'october', 'november',
116 'december'
118 static public $mMonthGenMsgs = array(
119 'january-gen', 'february-gen', 'march-gen', 'april-gen', 'may-gen', 'june-gen',
120 'july-gen', 'august-gen', 'september-gen', 'october-gen', 'november-gen',
121 'december-gen'
123 static public $mMonthAbbrevMsgs = array(
124 'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
125 'sep', 'oct', 'nov', 'dec'
128 static public $mIranianCalendarMonthMsgs = array(
129 'iranian-calendar-m1', 'iranian-calendar-m2', 'iranian-calendar-m3',
130 'iranian-calendar-m4', 'iranian-calendar-m5', 'iranian-calendar-m6',
131 'iranian-calendar-m7', 'iranian-calendar-m8', 'iranian-calendar-m9',
132 'iranian-calendar-m10', 'iranian-calendar-m11', 'iranian-calendar-m12'
135 static public $mHebrewCalendarMonthMsgs = array(
136 'hebrew-calendar-m1', 'hebrew-calendar-m2', 'hebrew-calendar-m3',
137 'hebrew-calendar-m4', 'hebrew-calendar-m5', 'hebrew-calendar-m6',
138 'hebrew-calendar-m7', 'hebrew-calendar-m8', 'hebrew-calendar-m9',
139 'hebrew-calendar-m10', 'hebrew-calendar-m11', 'hebrew-calendar-m12',
140 'hebrew-calendar-m6a', 'hebrew-calendar-m6b'
143 static public $mHebrewCalendarMonthGenMsgs = array(
144 'hebrew-calendar-m1-gen', 'hebrew-calendar-m2-gen', 'hebrew-calendar-m3-gen',
145 'hebrew-calendar-m4-gen', 'hebrew-calendar-m5-gen', 'hebrew-calendar-m6-gen',
146 'hebrew-calendar-m7-gen', 'hebrew-calendar-m8-gen', 'hebrew-calendar-m9-gen',
147 'hebrew-calendar-m10-gen', 'hebrew-calendar-m11-gen', 'hebrew-calendar-m12-gen',
148 'hebrew-calendar-m6a-gen', 'hebrew-calendar-m6b-gen'
151 static public $mHijriCalendarMonthMsgs = array(
152 'hijri-calendar-m1', 'hijri-calendar-m2', 'hijri-calendar-m3',
153 'hijri-calendar-m4', 'hijri-calendar-m5', 'hijri-calendar-m6',
154 'hijri-calendar-m7', 'hijri-calendar-m8', 'hijri-calendar-m9',
155 'hijri-calendar-m10', 'hijri-calendar-m11', 'hijri-calendar-m12'
159 * @since 1.20
160 * @var array
162 static public $durationIntervals = array(
163 'millennia' => 31556952000,
164 'centuries' => 3155695200,
165 'decades' => 315569520,
166 'years' => 31556952, // 86400 * ( 365 + ( 24 * 3 + 25 ) / 400 )
167 'weeks' => 604800,
168 'days' => 86400,
169 'hours' => 3600,
170 'minutes' => 60,
171 'seconds' => 1,
175 * Cache for language fallbacks.
176 * @see Language::getFallbacksIncludingSiteLanguage
177 * @since 1.21
178 * @var array
180 static private $fallbackLanguageCache = array();
183 * Get a cached or new language object for a given language code
184 * @param $code String
185 * @return Language
187 static function factory( $code ) {
188 global $wgDummyLanguageCodes, $wgLangObjCacheSize;
190 if ( isset( $wgDummyLanguageCodes[$code] ) ) {
191 $code = $wgDummyLanguageCodes[$code];
194 // get the language object to process
195 $langObj = isset( self::$mLangObjCache[$code] )
196 ? self::$mLangObjCache[$code]
197 : self::newFromCode( $code );
199 // merge the language object in to get it up front in the cache
200 self::$mLangObjCache = array_merge( array( $code => $langObj ), self::$mLangObjCache );
201 // get rid of the oldest ones in case we have an overflow
202 self::$mLangObjCache = array_slice( self::$mLangObjCache, 0, $wgLangObjCacheSize, true );
204 return $langObj;
208 * Create a language object for a given language code
209 * @param $code String
210 * @throws MWException
211 * @return Language
213 protected static function newFromCode( $code ) {
214 // Protect against path traversal below
215 if ( !Language::isValidCode( $code )
216 || strcspn( $code, ":/\\\000" ) !== strlen( $code ) )
218 throw new MWException( "Invalid language code \"$code\"" );
221 if ( !Language::isValidBuiltInCode( $code ) ) {
222 // It's not possible to customise this code with class files, so
223 // just return a Language object. This is to support uselang= hacks.
224 $lang = new Language;
225 $lang->setCode( $code );
226 return $lang;
229 // Check if there is a language class for the code
230 $class = self::classFromCode( $code );
231 self::preloadLanguageClass( $class );
232 if ( class_exists( $class ) ) {
233 $lang = new $class;
234 return $lang;
237 // Keep trying the fallback list until we find an existing class
238 $fallbacks = Language::getFallbacksFor( $code );
239 foreach ( $fallbacks as $fallbackCode ) {
240 if ( !Language::isValidBuiltInCode( $fallbackCode ) ) {
241 throw new MWException( "Invalid fallback '$fallbackCode' in fallback sequence for '$code'" );
244 $class = self::classFromCode( $fallbackCode );
245 self::preloadLanguageClass( $class );
246 if ( class_exists( $class ) ) {
247 $lang = Language::newFromCode( $fallbackCode );
248 $lang->setCode( $code );
249 return $lang;
253 throw new MWException( "Invalid fallback sequence for language '$code'" );
257 * Checks whether any localisation is available for that language tag
258 * in MediaWiki (MessagesXx.php exists).
260 * @param string $code Language tag (in lower case)
261 * @return bool Whether language is supported
262 * @since 1.21
264 public static function isSupportedLanguage( $code ) {
265 return $code === strtolower( $code ) && is_readable( self::getMessagesFileName( $code ) );
269 * Returns true if a language code string is a well-formed language tag
270 * according to RFC 5646.
271 * This function only checks well-formedness; it doesn't check that
272 * language, script or variant codes actually exist in the repositories.
274 * Based on regexes by Mark Davis of the Unicode Consortium:
275 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
277 * @param $code string
278 * @param $lenient boolean Whether to allow '_' as separator. The default is only '-'.
280 * @return bool
281 * @since 1.21
283 public static function isWellFormedLanguageTag( $code, $lenient = false ) {
284 $alpha = '[a-z]';
285 $digit = '[0-9]';
286 $alphanum = '[a-z0-9]';
287 $x = 'x'; # private use singleton
288 $singleton = '[a-wy-z]'; # other singleton
289 $s = $lenient ? '[-_]' : '-';
291 $language = "$alpha{2,8}|$alpha{2,3}$s$alpha{3}";
292 $script = "$alpha{4}"; # ISO 15924
293 $region = "(?:$alpha{2}|$digit{3})"; # ISO 3166-1 alpha-2 or UN M.49
294 $variant = "(?:$alphanum{5,8}|$digit$alphanum{3})";
295 $extension = "$singleton(?:$s$alphanum{2,8})+";
296 $privateUse = "$x(?:$s$alphanum{1,8})+";
298 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
299 # Since these are limited, this is safe even later changes to the registry --
300 # the only oddity is that it might change the type of the tag, and thus
301 # the results from the capturing groups.
302 # http://www.iana.org/assignments/language-subtag-registry
304 $grandfathered = "en{$s}GB{$s}oed"
305 . "|i{$s}(?:ami|bnn|default|enochian|hak|klingon|lux|mingo|navajo|pwn|tao|tay|tsu)"
306 . "|no{$s}(?:bok|nyn)"
307 . "|sgn{$s}(?:BE{$s}(?:fr|nl)|CH{$s}de)"
308 . "|zh{$s}min{$s}nan";
310 $variantList = "$variant(?:$s$variant)*";
311 $extensionList = "$extension(?:$s$extension)*";
313 $langtag = "(?:($language)"
314 . "(?:$s$script)?"
315 . "(?:$s$region)?"
316 . "(?:$s$variantList)?"
317 . "(?:$s$extensionList)?"
318 . "(?:$s$privateUse)?)";
320 # The final breakdown, with capturing groups for each of these components
321 # The variants, extensions, grandfathered, and private-use may have interior '-'
323 $root = "^(?:$langtag|$privateUse|$grandfathered)$";
325 return (bool)preg_match( "/$root/", strtolower( $code ) );
329 * Returns true if a language code string is of a valid form, whether or
330 * not it exists. This includes codes which are used solely for
331 * customisation via the MediaWiki namespace.
333 * @param $code string
335 * @return bool
337 public static function isValidCode( $code ) {
338 static $cache = array();
339 if ( isset( $cache[$code] ) ) {
340 return $cache[$code];
342 // People think language codes are html safe, so enforce it.
343 // Ideally we should only allow a-zA-Z0-9-
344 // but, .+ and other chars are often used for {{int:}} hacks
345 // see bugs 37564, 37587, 36938
346 $cache[$code] =
347 strcspn( $code, ":/\\\000&<>'\"" ) === strlen( $code )
348 && !preg_match( Title::getTitleInvalidRegex(), $code );
350 return $cache[$code];
354 * Returns true if a language code is of a valid form for the purposes of
355 * internal customisation of MediaWiki, via Messages*.php.
357 * @param $code string
359 * @throws MWException
360 * @since 1.18
361 * @return bool
363 public static function isValidBuiltInCode( $code ) {
365 if ( !is_string( $code ) ) {
366 if ( is_object( $code ) ) {
367 $addmsg = " of class " . get_class( $code );
368 } else {
369 $addmsg = '';
371 $type = gettype( $code );
372 throw new MWException( __METHOD__ . " must be passed a string, $type given$addmsg" );
375 return (bool)preg_match( '/^[a-z0-9-]{2,}$/i', $code );
379 * Returns true if a language code is an IETF tag known to MediaWiki.
381 * @param $code string
383 * @since 1.21
384 * @return bool
386 public static function isKnownLanguageTag( $tag ) {
387 static $coreLanguageNames;
389 // Quick escape for invalid input to avoid exceptions down the line
390 // when code tries to process tags which are not valid at all.
391 if ( !self::isValidBuiltInCode( $tag ) ) {
392 return false;
395 if ( $coreLanguageNames === null ) {
396 global $IP;
397 include "$IP/languages/Names.php";
400 if ( isset( $coreLanguageNames[$tag] )
401 || self::fetchLanguageName( $tag, $tag ) !== ''
403 return true;
406 return false;
410 * @param $code
411 * @return String Name of the language class
413 public static function classFromCode( $code ) {
414 if ( $code == 'en' ) {
415 return 'Language';
416 } else {
417 return 'Language' . str_replace( '-', '_', ucfirst( $code ) );
422 * Includes language class files
424 * @param $class string Name of the language class
426 public static function preloadLanguageClass( $class ) {
427 global $IP;
429 if ( $class === 'Language' ) {
430 return;
433 if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
434 include_once "$IP/languages/classes/$class.php";
439 * Get the LocalisationCache instance
441 * @return LocalisationCache
443 public static function getLocalisationCache() {
444 if ( is_null( self::$dataCache ) ) {
445 global $wgLocalisationCacheConf;
446 $class = $wgLocalisationCacheConf['class'];
447 self::$dataCache = new $class( $wgLocalisationCacheConf );
449 return self::$dataCache;
452 function __construct() {
453 $this->mConverter = new FakeConverter( $this );
454 // Set the code to the name of the descendant
455 if ( get_class( $this ) == 'Language' ) {
456 $this->mCode = 'en';
457 } else {
458 $this->mCode = str_replace( '_', '-', strtolower( substr( get_class( $this ), 8 ) ) );
460 self::getLocalisationCache();
464 * Reduce memory usage
466 function __destruct() {
467 foreach ( $this as $name => $value ) {
468 unset( $this->$name );
473 * Hook which will be called if this is the content language.
474 * Descendants can use this to register hook functions or modify globals
476 function initContLang() { }
479 * Same as getFallbacksFor for current language.
480 * @return array|bool
481 * @deprecated in 1.19
483 function getFallbackLanguageCode() {
484 wfDeprecated( __METHOD__, '1.19' );
485 return self::getFallbackFor( $this->mCode );
489 * @return array
490 * @since 1.19
492 function getFallbackLanguages() {
493 return self::getFallbacksFor( $this->mCode );
497 * Exports $wgBookstoreListEn
498 * @return array
500 function getBookstoreList() {
501 return self::$dataCache->getItem( $this->mCode, 'bookstoreList' );
505 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
506 * available in localised form, it will be included in English.
508 * @return array
510 public function getNamespaces() {
511 if ( is_null( $this->namespaceNames ) ) {
512 global $wgMetaNamespace, $wgMetaNamespaceTalk, $wgExtraNamespaces;
514 $this->namespaceNames = self::$dataCache->getItem( $this->mCode, 'namespaceNames' );
515 $validNamespaces = MWNamespace::getCanonicalNamespaces();
517 $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames + $validNamespaces;
519 $this->namespaceNames[NS_PROJECT] = $wgMetaNamespace;
520 if ( $wgMetaNamespaceTalk ) {
521 $this->namespaceNames[NS_PROJECT_TALK] = $wgMetaNamespaceTalk;
522 } else {
523 $talk = $this->namespaceNames[NS_PROJECT_TALK];
524 $this->namespaceNames[NS_PROJECT_TALK] =
525 $this->fixVariableInNamespace( $talk );
528 # Sometimes a language will be localised but not actually exist on this wiki.
529 foreach ( $this->namespaceNames as $key => $text ) {
530 if ( !isset( $validNamespaces[$key] ) ) {
531 unset( $this->namespaceNames[$key] );
535 # The above mixing may leave namespaces out of canonical order.
536 # Re-order by namespace ID number...
537 ksort( $this->namespaceNames );
539 wfRunHooks( 'LanguageGetNamespaces', array( &$this->namespaceNames ) );
541 return $this->namespaceNames;
545 * Arbitrarily set all of the namespace names at once. Mainly used for testing
546 * @param $namespaces Array of namespaces (id => name)
548 public function setNamespaces( array $namespaces ) {
549 $this->namespaceNames = $namespaces;
550 $this->mNamespaceIds = null;
554 * Resets all of the namespace caches. Mainly used for testing
556 public function resetNamespaces() {
557 $this->namespaceNames = null;
558 $this->mNamespaceIds = null;
559 $this->namespaceAliases = null;
563 * A convenience function that returns the same thing as
564 * getNamespaces() except with the array values changed to ' '
565 * where it found '_', useful for producing output to be displayed
566 * e.g. in <select> forms.
568 * @return array
570 function getFormattedNamespaces() {
571 $ns = $this->getNamespaces();
572 foreach ( $ns as $k => $v ) {
573 $ns[$k] = strtr( $v, '_', ' ' );
575 return $ns;
579 * Get a namespace value by key
580 * <code>
581 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
582 * echo $mw_ns; // prints 'MediaWiki'
583 * </code>
585 * @param $index Int: the array key of the namespace to return
586 * @return mixed, string if the namespace value exists, otherwise false
588 function getNsText( $index ) {
589 $ns = $this->getNamespaces();
590 return isset( $ns[$index] ) ? $ns[$index] : false;
594 * A convenience function that returns the same thing as
595 * getNsText() except with '_' changed to ' ', useful for
596 * producing output.
598 * <code>
599 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
600 * echo $mw_ns; // prints 'MediaWiki talk'
601 * </code>
603 * @param int $index The array key of the namespace to return
604 * @return string Namespace name without underscores (empty string if namespace does not exist)
606 function getFormattedNsText( $index ) {
607 $ns = $this->getNsText( $index );
608 return strtr( $ns, '_', ' ' );
612 * Returns gender-dependent namespace alias if available.
613 * @param $index Int: namespace index
614 * @param $gender String: gender key (male, female... )
615 * @return String
616 * @since 1.18
618 function getGenderNsText( $index, $gender ) {
619 global $wgExtraGenderNamespaces;
621 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
622 return isset( $ns[$index][$gender] ) ? $ns[$index][$gender] : $this->getNsText( $index );
626 * Whether this language makes distinguishes genders for example in
627 * namespaces.
628 * @return bool
629 * @since 1.18
631 function needsGenderDistinction() {
632 global $wgExtraGenderNamespaces, $wgExtraNamespaces;
633 if ( count( $wgExtraGenderNamespaces ) > 0 ) {
634 // $wgExtraGenderNamespaces overrides everything
635 return true;
636 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
637 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
638 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
639 return false;
640 } else {
641 // Check what is in i18n files
642 $aliases = self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
643 return count( $aliases ) > 0;
648 * Get a namespace key by value, case insensitive.
649 * Only matches namespace names for the current language, not the
650 * canonical ones defined in Namespace.php.
652 * @param $text String
653 * @return mixed An integer if $text is a valid value otherwise false
655 function getLocalNsIndex( $text ) {
656 $lctext = $this->lc( $text );
657 $ids = $this->getNamespaceIds();
658 return isset( $ids[$lctext] ) ? $ids[$lctext] : false;
662 * @return array
664 function getNamespaceAliases() {
665 if ( is_null( $this->namespaceAliases ) ) {
666 $aliases = self::$dataCache->getItem( $this->mCode, 'namespaceAliases' );
667 if ( !$aliases ) {
668 $aliases = array();
669 } else {
670 foreach ( $aliases as $name => $index ) {
671 if ( $index === NS_PROJECT_TALK ) {
672 unset( $aliases[$name] );
673 $name = $this->fixVariableInNamespace( $name );
674 $aliases[$name] = $index;
679 global $wgExtraGenderNamespaces;
680 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
681 foreach ( $genders as $index => $forms ) {
682 foreach ( $forms as $alias ) {
683 $aliases[$alias] = $index;
687 # Also add converted namespace names as aliases, to avoid confusion.
688 $convertedNames = array();
689 foreach ( $this->getVariants() as $variant ) {
690 if ( $variant === $this->mCode ) {
691 continue;
693 foreach ( $this->getNamespaces() as $ns => $_ ) {
694 $convertedNames[$this->getConverter()->convertNamespace( $ns, $variant )] = $ns;
698 $this->namespaceAliases = $aliases + $convertedNames;
700 return $this->namespaceAliases;
704 * @return array
706 function getNamespaceIds() {
707 if ( is_null( $this->mNamespaceIds ) ) {
708 global $wgNamespaceAliases;
709 # Put namespace names and aliases into a hashtable.
710 # If this is too slow, then we should arrange it so that it is done
711 # before caching. The catch is that at pre-cache time, the above
712 # class-specific fixup hasn't been done.
713 $this->mNamespaceIds = array();
714 foreach ( $this->getNamespaces() as $index => $name ) {
715 $this->mNamespaceIds[$this->lc( $name )] = $index;
717 foreach ( $this->getNamespaceAliases() as $name => $index ) {
718 $this->mNamespaceIds[$this->lc( $name )] = $index;
720 if ( $wgNamespaceAliases ) {
721 foreach ( $wgNamespaceAliases as $name => $index ) {
722 $this->mNamespaceIds[$this->lc( $name )] = $index;
726 return $this->mNamespaceIds;
730 * Get a namespace key by value, case insensitive. Canonical namespace
731 * names override custom ones defined for the current language.
733 * @param $text String
734 * @return mixed An integer if $text is a valid value otherwise false
736 function getNsIndex( $text ) {
737 $lctext = $this->lc( $text );
738 $ns = MWNamespace::getCanonicalIndex( $lctext );
739 if ( $ns !== null ) {
740 return $ns;
742 $ids = $this->getNamespaceIds();
743 return isset( $ids[$lctext] ) ? $ids[$lctext] : false;
747 * short names for language variants used for language conversion links.
749 * @param $code String
750 * @param $usemsg bool Use the "variantname-xyz" message if it exists
751 * @return string
753 function getVariantname( $code, $usemsg = true ) {
754 $msg = "variantname-$code";
755 if ( $usemsg && wfMessage( $msg )->exists() ) {
756 return $this->getMessageFromDB( $msg );
758 $name = self::fetchLanguageName( $code );
759 if ( $name ) {
760 return $name; # if it's defined as a language name, show that
761 } else {
762 # otherwise, output the language code
763 return $code;
768 * @param $name string
769 * @return string
771 function specialPage( $name ) {
772 $aliases = $this->getSpecialPageAliases();
773 if ( isset( $aliases[$name][0] ) ) {
774 $name = $aliases[$name][0];
776 return $this->getNsText( NS_SPECIAL ) . ':' . $name;
780 * @return array
782 function getDatePreferences() {
783 return self::$dataCache->getItem( $this->mCode, 'datePreferences' );
787 * @return array
789 function getDateFormats() {
790 return self::$dataCache->getItem( $this->mCode, 'dateFormats' );
794 * @return array|string
796 function getDefaultDateFormat() {
797 $df = self::$dataCache->getItem( $this->mCode, 'defaultDateFormat' );
798 if ( $df === 'dmy or mdy' ) {
799 global $wgAmericanDates;
800 return $wgAmericanDates ? 'mdy' : 'dmy';
801 } else {
802 return $df;
807 * @return array
809 function getDatePreferenceMigrationMap() {
810 return self::$dataCache->getItem( $this->mCode, 'datePreferenceMigrationMap' );
814 * @param $image
815 * @return array|null
817 function getImageFile( $image ) {
818 return self::$dataCache->getSubitem( $this->mCode, 'imageFiles', $image );
822 * @return array
824 function getExtraUserToggles() {
825 return (array)self::$dataCache->getItem( $this->mCode, 'extraUserToggles' );
829 * @param $tog
830 * @return string
832 function getUserToggle( $tog ) {
833 return $this->getMessageFromDB( "tog-$tog" );
837 * Get native language names, indexed by code.
838 * Only those defined in MediaWiki, no other data like CLDR.
839 * If $customisedOnly is true, only returns codes with a messages file
841 * @param $customisedOnly bool
843 * @return array
844 * @deprecated in 1.20, use fetchLanguageNames()
846 public static function getLanguageNames( $customisedOnly = false ) {
847 return self::fetchLanguageNames( null, $customisedOnly ? 'mwfile' : 'mw' );
851 * Get translated language names. This is done on best effort and
852 * by default this is exactly the same as Language::getLanguageNames.
853 * The CLDR extension provides translated names.
854 * @param $code String Language code.
855 * @return Array language code => language name
856 * @since 1.18.0
857 * @deprecated in 1.20, use fetchLanguageNames()
859 public static function getTranslatedLanguageNames( $code ) {
860 return self::fetchLanguageNames( $code, 'all' );
864 * Get an array of language names, indexed by code.
865 * @param $inLanguage null|string: Code of language in which to return the names
866 * Use null for autonyms (native names)
867 * @param $include string:
868 * 'all' all available languages
869 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
870 * 'mwfile' only if the language is in 'mw' *and* has a message file
871 * @return array: language code => language name
872 * @since 1.20
874 public static function fetchLanguageNames( $inLanguage = null, $include = 'mw' ) {
875 global $wgExtraLanguageNames;
876 static $coreLanguageNames;
878 if ( $coreLanguageNames === null ) {
879 global $IP;
880 include "$IP/languages/Names.php";
883 $names = array();
885 if ( $inLanguage ) {
886 # TODO: also include when $inLanguage is null, when this code is more efficient
887 wfRunHooks( 'LanguageGetTranslatedLanguageNames', array( &$names, $inLanguage ) );
890 $mwNames = $wgExtraLanguageNames + $coreLanguageNames;
891 foreach ( $mwNames as $mwCode => $mwName ) {
892 # - Prefer own MediaWiki native name when not using the hook
893 # - For other names just add if not added through the hook
894 if ( $mwCode === $inLanguage || !isset( $names[$mwCode] ) ) {
895 $names[$mwCode] = $mwName;
899 if ( $include === 'all' ) {
900 return $names;
903 $returnMw = array();
904 $coreCodes = array_keys( $mwNames );
905 foreach ( $coreCodes as $coreCode ) {
906 $returnMw[$coreCode] = $names[$coreCode];
909 if ( $include === 'mwfile' ) {
910 $namesMwFile = array();
911 # We do this using a foreach over the codes instead of a directory
912 # loop so that messages files in extensions will work correctly.
913 foreach ( $returnMw as $code => $value ) {
914 if ( is_readable( self::getMessagesFileName( $code ) ) ) {
915 $namesMwFile[$code] = $names[$code];
918 return $namesMwFile;
920 # 'mw' option; default if it's not one of the other two options (all/mwfile)
921 return $returnMw;
925 * @param $code string: The code of the language for which to get the name
926 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
927 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
928 * @return string: Language name or empty
929 * @since 1.20
931 public static function fetchLanguageName( $code, $inLanguage = null, $include = 'all' ) {
932 $array = self::fetchLanguageNames( $inLanguage, $include );
933 return !array_key_exists( $code, $array ) ? '' : $array[$code];
937 * Get a message from the MediaWiki namespace.
939 * @param $msg String: message name
940 * @return string
942 function getMessageFromDB( $msg ) {
943 return wfMessage( $msg )->inLanguage( $this )->text();
947 * Get the native language name of $code.
948 * Only if defined in MediaWiki, no other data like CLDR.
949 * @param $code string
950 * @return string
951 * @deprecated in 1.20, use fetchLanguageName()
953 function getLanguageName( $code ) {
954 return self::fetchLanguageName( $code );
958 * @param $key string
959 * @return string
961 function getMonthName( $key ) {
962 return $this->getMessageFromDB( self::$mMonthMsgs[$key - 1] );
966 * @return array
968 function getMonthNamesArray() {
969 $monthNames = array( '' );
970 for ( $i = 1; $i < 13; $i++ ) {
971 $monthNames[] = $this->getMonthName( $i );
973 return $monthNames;
977 * @param $key string
978 * @return string
980 function getMonthNameGen( $key ) {
981 return $this->getMessageFromDB( self::$mMonthGenMsgs[$key - 1] );
985 * @param $key string
986 * @return string
988 function getMonthAbbreviation( $key ) {
989 return $this->getMessageFromDB( self::$mMonthAbbrevMsgs[$key - 1] );
993 * @return array
995 function getMonthAbbreviationsArray() {
996 $monthNames = array( '' );
997 for ( $i = 1; $i < 13; $i++ ) {
998 $monthNames[] = $this->getMonthAbbreviation( $i );
1000 return $monthNames;
1004 * @param $key string
1005 * @return string
1007 function getWeekdayName( $key ) {
1008 return $this->getMessageFromDB( self::$mWeekdayMsgs[$key - 1] );
1012 * @param $key string
1013 * @return string
1015 function getWeekdayAbbreviation( $key ) {
1016 return $this->getMessageFromDB( self::$mWeekdayAbbrevMsgs[$key - 1] );
1020 * @param $key string
1021 * @return string
1023 function getIranianCalendarMonthName( $key ) {
1024 return $this->getMessageFromDB( self::$mIranianCalendarMonthMsgs[$key - 1] );
1028 * @param $key string
1029 * @return string
1031 function getHebrewCalendarMonthName( $key ) {
1032 return $this->getMessageFromDB( self::$mHebrewCalendarMonthMsgs[$key - 1] );
1036 * @param $key string
1037 * @return string
1039 function getHebrewCalendarMonthNameGen( $key ) {
1040 return $this->getMessageFromDB( self::$mHebrewCalendarMonthGenMsgs[$key - 1] );
1044 * @param $key string
1045 * @return string
1047 function getHijriCalendarMonthName( $key ) {
1048 return $this->getMessageFromDB( self::$mHijriCalendarMonthMsgs[$key - 1] );
1052 * This is a workalike of PHP's date() function, but with better
1053 * internationalisation, a reduced set of format characters, and a better
1054 * escaping format.
1056 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1057 * the PHP manual for definitions. There are a number of extensions, which
1058 * start with "x":
1060 * xn Do not translate digits of the next numeric format character
1061 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1062 * xr Use roman numerals for the next numeric format character
1063 * xh Use hebrew numerals for the next numeric format character
1064 * xx Literal x
1065 * xg Genitive month name
1067 * xij j (day number) in Iranian calendar
1068 * xiF F (month name) in Iranian calendar
1069 * xin n (month number) in Iranian calendar
1070 * xiy y (two digit year) in Iranian calendar
1071 * xiY Y (full year) in Iranian calendar
1073 * xjj j (day number) in Hebrew calendar
1074 * xjF F (month name) in Hebrew calendar
1075 * xjt t (days in month) in Hebrew calendar
1076 * xjx xg (genitive month name) in Hebrew calendar
1077 * xjn n (month number) in Hebrew calendar
1078 * xjY Y (full year) in Hebrew calendar
1080 * xmj j (day number) in Hijri calendar
1081 * xmF F (month name) in Hijri calendar
1082 * xmn n (month number) in Hijri calendar
1083 * xmY Y (full year) in Hijri calendar
1085 * xkY Y (full year) in Thai solar calendar. Months and days are
1086 * identical to the Gregorian calendar
1087 * xoY Y (full year) in Minguo calendar or Juche year.
1088 * Months and days are identical to the
1089 * Gregorian calendar
1090 * xtY Y (full year) in Japanese nengo. Months and days are
1091 * identical to the Gregorian calendar
1093 * Characters enclosed in double quotes will be considered literal (with
1094 * the quotes themselves removed). Unmatched quotes will be considered
1095 * literal quotes. Example:
1097 * "The month is" F => The month is January
1098 * i's" => 20'11"
1100 * Backslash escaping is also supported.
1102 * Input timestamp is assumed to be pre-normalized to the desired local
1103 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1104 * $ts is UTC if $zone is not given.
1106 * @param $format String
1107 * @param $ts String: 14-character timestamp
1108 * YYYYMMDDHHMMSS
1109 * 01234567890123
1110 * @param $zone DateTimeZone: Timezone of $ts
1111 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1113 * @throws MWException
1114 * @return string
1116 function sprintfDate( $format, $ts, DateTimeZone $zone = null ) {
1117 $s = '';
1118 $raw = false;
1119 $roman = false;
1120 $hebrewNum = false;
1121 $dateTimeObj = false;
1122 $rawToggle = false;
1123 $iranian = false;
1124 $hebrew = false;
1125 $hijri = false;
1126 $thai = false;
1127 $minguo = false;
1128 $tenno = false;
1130 if ( strlen( $ts ) !== 14 ) {
1131 throw new MWException( __METHOD__ . ": The timestamp $ts should have 14 characters" );
1134 if ( !ctype_digit( $ts ) ) {
1135 throw new MWException( __METHOD__ . ": The timestamp $ts should be a number" );
1138 for ( $p = 0; $p < strlen( $format ); $p++ ) {
1139 $num = false;
1140 $code = $format[$p];
1141 if ( $code == 'x' && $p < strlen( $format ) - 1 ) {
1142 $code .= $format[++$p];
1145 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1146 $code .= $format[++$p];
1149 switch ( $code ) {
1150 case 'xx':
1151 $s .= 'x';
1152 break;
1153 case 'xn':
1154 $raw = true;
1155 break;
1156 case 'xN':
1157 $rawToggle = !$rawToggle;
1158 break;
1159 case 'xr':
1160 $roman = true;
1161 break;
1162 case 'xh':
1163 $hebrewNum = true;
1164 break;
1165 case 'xg':
1166 $s .= $this->getMonthNameGen( substr( $ts, 4, 2 ) );
1167 break;
1168 case 'xjx':
1169 if ( !$hebrew ) {
1170 $hebrew = self::tsToHebrew( $ts );
1172 $s .= $this->getHebrewCalendarMonthNameGen( $hebrew[1] );
1173 break;
1174 case 'd':
1175 $num = substr( $ts, 6, 2 );
1176 break;
1177 case 'D':
1178 if ( !$dateTimeObj ) {
1179 $dateTimeObj = DateTime::createFromFormat(
1180 'YmdHis', $ts, $zone ?: new DateTimeZone( 'UTC' )
1183 $s .= $this->getWeekdayAbbreviation( $dateTimeObj->format( 'w' ) + 1 );
1184 break;
1185 case 'j':
1186 $num = intval( substr( $ts, 6, 2 ) );
1187 break;
1188 case 'xij':
1189 if ( !$iranian ) {
1190 $iranian = self::tsToIranian( $ts );
1192 $num = $iranian[2];
1193 break;
1194 case 'xmj':
1195 if ( !$hijri ) {
1196 $hijri = self::tsToHijri( $ts );
1198 $num = $hijri[2];
1199 break;
1200 case 'xjj':
1201 if ( !$hebrew ) {
1202 $hebrew = self::tsToHebrew( $ts );
1204 $num = $hebrew[2];
1205 break;
1206 case 'l':
1207 if ( !$dateTimeObj ) {
1208 $dateTimeObj = DateTime::createFromFormat(
1209 'YmdHis', $ts, $zone ?: new DateTimeZone( 'UTC' )
1212 $s .= $this->getWeekdayName( $dateTimeObj->format( 'w' ) + 1 );
1213 break;
1214 case 'F':
1215 $s .= $this->getMonthName( substr( $ts, 4, 2 ) );
1216 break;
1217 case 'xiF':
1218 if ( !$iranian ) {
1219 $iranian = self::tsToIranian( $ts );
1221 $s .= $this->getIranianCalendarMonthName( $iranian[1] );
1222 break;
1223 case 'xmF':
1224 if ( !$hijri ) {
1225 $hijri = self::tsToHijri( $ts );
1227 $s .= $this->getHijriCalendarMonthName( $hijri[1] );
1228 break;
1229 case 'xjF':
1230 if ( !$hebrew ) {
1231 $hebrew = self::tsToHebrew( $ts );
1233 $s .= $this->getHebrewCalendarMonthName( $hebrew[1] );
1234 break;
1235 case 'm':
1236 $num = substr( $ts, 4, 2 );
1237 break;
1238 case 'M':
1239 $s .= $this->getMonthAbbreviation( substr( $ts, 4, 2 ) );
1240 break;
1241 case 'n':
1242 $num = intval( substr( $ts, 4, 2 ) );
1243 break;
1244 case 'xin':
1245 if ( !$iranian ) {
1246 $iranian = self::tsToIranian( $ts );
1248 $num = $iranian[1];
1249 break;
1250 case 'xmn':
1251 if ( !$hijri ) {
1252 $hijri = self::tsToHijri ( $ts );
1254 $num = $hijri[1];
1255 break;
1256 case 'xjn':
1257 if ( !$hebrew ) {
1258 $hebrew = self::tsToHebrew( $ts );
1260 $num = $hebrew[1];
1261 break;
1262 case 'xjt':
1263 if ( !$hebrew ) {
1264 $hebrew = self::tsToHebrew( $ts );
1266 $num = $hebrew[3];
1267 break;
1268 case 'Y':
1269 $num = substr( $ts, 0, 4 );
1270 break;
1271 case 'xiY':
1272 if ( !$iranian ) {
1273 $iranian = self::tsToIranian( $ts );
1275 $num = $iranian[0];
1276 break;
1277 case 'xmY':
1278 if ( !$hijri ) {
1279 $hijri = self::tsToHijri( $ts );
1281 $num = $hijri[0];
1282 break;
1283 case 'xjY':
1284 if ( !$hebrew ) {
1285 $hebrew = self::tsToHebrew( $ts );
1287 $num = $hebrew[0];
1288 break;
1289 case 'xkY':
1290 if ( !$thai ) {
1291 $thai = self::tsToYear( $ts, 'thai' );
1293 $num = $thai[0];
1294 break;
1295 case 'xoY':
1296 if ( !$minguo ) {
1297 $minguo = self::tsToYear( $ts, 'minguo' );
1299 $num = $minguo[0];
1300 break;
1301 case 'xtY':
1302 if ( !$tenno ) {
1303 $tenno = self::tsToYear( $ts, 'tenno' );
1305 $num = $tenno[0];
1306 break;
1307 case 'y':
1308 $num = substr( $ts, 2, 2 );
1309 break;
1310 case 'xiy':
1311 if ( !$iranian ) {
1312 $iranian = self::tsToIranian( $ts );
1314 $num = substr( $iranian[0], -2 );
1315 break;
1316 case 'a':
1317 $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'am' : 'pm';
1318 break;
1319 case 'A':
1320 $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'AM' : 'PM';
1321 break;
1322 case 'g':
1323 $h = substr( $ts, 8, 2 );
1324 $num = $h % 12 ? $h % 12 : 12;
1325 break;
1326 case 'G':
1327 $num = intval( substr( $ts, 8, 2 ) );
1328 break;
1329 case 'h':
1330 $h = substr( $ts, 8, 2 );
1331 $num = sprintf( '%02d', $h % 12 ? $h % 12 : 12 );
1332 break;
1333 case 'H':
1334 $num = substr( $ts, 8, 2 );
1335 break;
1336 case 'i':
1337 $num = substr( $ts, 10, 2 );
1338 break;
1339 case 's':
1340 $num = substr( $ts, 12, 2 );
1341 break;
1342 case 'c':
1343 case 'r':
1344 case 'e':
1345 case 'O':
1346 case 'P':
1347 case 'T':
1348 // Pass through string from $dateTimeObj->format()
1349 if ( !$dateTimeObj ) {
1350 $dateTimeObj = DateTime::createFromFormat(
1351 'YmdHis', $ts, $zone ?: new DateTimeZone( 'UTC' )
1354 $s .= $dateTimeObj->format( $code );
1355 break;
1356 case 'w':
1357 case 'N':
1358 case 'z':
1359 case 'W':
1360 case 't':
1361 case 'L':
1362 case 'o':
1363 case 'U':
1364 case 'I':
1365 case 'Z':
1366 // Pass through number from $dateTimeObj->format()
1367 if ( !$dateTimeObj ) {
1368 $dateTimeObj = DateTime::createFromFormat(
1369 'YmdHis', $ts, $zone ?: new DateTimeZone( 'UTC' )
1372 $num = $dateTimeObj->format( $code );
1373 break;
1374 case '\\':
1375 # Backslash escaping
1376 if ( $p < strlen( $format ) - 1 ) {
1377 $s .= $format[++$p];
1378 } else {
1379 $s .= '\\';
1381 break;
1382 case '"':
1383 # Quoted literal
1384 if ( $p < strlen( $format ) - 1 ) {
1385 $endQuote = strpos( $format, '"', $p + 1 );
1386 if ( $endQuote === false ) {
1387 # No terminating quote, assume literal "
1388 $s .= '"';
1389 } else {
1390 $s .= substr( $format, $p + 1, $endQuote - $p - 1 );
1391 $p = $endQuote;
1393 } else {
1394 # Quote at end of string, assume literal "
1395 $s .= '"';
1397 break;
1398 default:
1399 $s .= $format[$p];
1401 if ( $num !== false ) {
1402 if ( $rawToggle || $raw ) {
1403 $s .= $num;
1404 $raw = false;
1405 } elseif ( $roman ) {
1406 $s .= Language::romanNumeral( $num );
1407 $roman = false;
1408 } elseif ( $hebrewNum ) {
1409 $s .= self::hebrewNumeral( $num );
1410 $hebrewNum = false;
1411 } else {
1412 $s .= $this->formatNum( $num, true );
1416 return $s;
1419 private static $GREG_DAYS = array( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
1420 private static $IRANIAN_DAYS = array( 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29 );
1423 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1424 * Gregorian dates to Iranian dates. Originally written in C, it
1425 * is released under the terms of GNU Lesser General Public
1426 * License. Conversion to PHP was performed by Niklas Laxström.
1428 * Link: http://www.farsiweb.info/jalali/jalali.c
1430 * @param $ts string
1432 * @return string
1434 private static function tsToIranian( $ts ) {
1435 $gy = substr( $ts, 0, 4 ) -1600;
1436 $gm = substr( $ts, 4, 2 ) -1;
1437 $gd = substr( $ts, 6, 2 ) -1;
1439 # Days passed from the beginning (including leap years)
1440 $gDayNo = 365 * $gy
1441 + floor( ( $gy + 3 ) / 4 )
1442 - floor( ( $gy + 99 ) / 100 )
1443 + floor( ( $gy + 399 ) / 400 );
1445 // Add days of the past months of this year
1446 for ( $i = 0; $i < $gm; $i++ ) {
1447 $gDayNo += self::$GREG_DAYS[$i];
1450 // Leap years
1451 if ( $gm > 1 && ( ( $gy % 4 === 0 && $gy % 100 !== 0 || ( $gy % 400 == 0 ) ) ) ) {
1452 $gDayNo++;
1455 // Days passed in current month
1456 $gDayNo += (int)$gd;
1458 $jDayNo = $gDayNo - 79;
1460 $jNp = floor( $jDayNo / 12053 );
1461 $jDayNo %= 12053;
1463 $jy = 979 + 33 * $jNp + 4 * floor( $jDayNo / 1461 );
1464 $jDayNo %= 1461;
1466 if ( $jDayNo >= 366 ) {
1467 $jy += floor( ( $jDayNo - 1 ) / 365 );
1468 $jDayNo = floor( ( $jDayNo - 1 ) % 365 );
1471 for ( $i = 0; $i < 11 && $jDayNo >= self::$IRANIAN_DAYS[$i]; $i++ ) {
1472 $jDayNo -= self::$IRANIAN_DAYS[$i];
1475 $jm = $i + 1;
1476 $jd = $jDayNo + 1;
1478 return array( $jy, $jm, $jd );
1482 * Converting Gregorian dates to Hijri dates.
1484 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1486 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1488 * @param $ts string
1490 * @return string
1492 private static function tsToHijri( $ts ) {
1493 $year = substr( $ts, 0, 4 );
1494 $month = substr( $ts, 4, 2 );
1495 $day = substr( $ts, 6, 2 );
1497 $zyr = $year;
1498 $zd = $day;
1499 $zm = $month;
1500 $zy = $zyr;
1502 if (
1503 ( $zy > 1582 ) || ( ( $zy == 1582 ) && ( $zm > 10 ) ) ||
1504 ( ( $zy == 1582 ) && ( $zm == 10 ) && ( $zd > 14 ) )
1507 $zjd = (int)( ( 1461 * ( $zy + 4800 + (int)( ( $zm - 14 ) / 12 ) ) ) / 4 ) +
1508 (int)( ( 367 * ( $zm - 2 - 12 * ( (int)( ( $zm - 14 ) / 12 ) ) ) ) / 12 ) -
1509 (int)( ( 3 * (int)( ( ( $zy + 4900 + (int)( ( $zm - 14 ) / 12 ) ) / 100 ) ) ) / 4 ) +
1510 $zd - 32075;
1511 } else {
1512 $zjd = 367 * $zy - (int)( ( 7 * ( $zy + 5001 + (int)( ( $zm - 9 ) / 7 ) ) ) / 4 ) +
1513 (int)( ( 275 * $zm ) / 9 ) + $zd + 1729777;
1516 $zl = $zjd -1948440 + 10632;
1517 $zn = (int)( ( $zl - 1 ) / 10631 );
1518 $zl = $zl - 10631 * $zn + 354;
1519 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1520 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1521 $zm = (int)( ( 24 * $zl ) / 709 );
1522 $zd = $zl - (int)( ( 709 * $zm ) / 24 );
1523 $zy = 30 * $zn + $zj - 30;
1525 return array( $zy, $zm, $zd );
1529 * Converting Gregorian dates to Hebrew dates.
1531 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1532 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1533 * to translate the relevant functions into PHP and release them under
1534 * GNU GPL.
1536 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1537 * and Adar II is 14. In a non-leap year, Adar is 6.
1539 * @param $ts string
1541 * @return string
1543 private static function tsToHebrew( $ts ) {
1544 # Parse date
1545 $year = substr( $ts, 0, 4 );
1546 $month = substr( $ts, 4, 2 );
1547 $day = substr( $ts, 6, 2 );
1549 # Calculate Hebrew year
1550 $hebrewYear = $year + 3760;
1552 # Month number when September = 1, August = 12
1553 $month += 4;
1554 if ( $month > 12 ) {
1555 # Next year
1556 $month -= 12;
1557 $year++;
1558 $hebrewYear++;
1561 # Calculate day of year from 1 September
1562 $dayOfYear = $day;
1563 for ( $i = 1; $i < $month; $i++ ) {
1564 if ( $i == 6 ) {
1565 # February
1566 $dayOfYear += 28;
1567 # Check if the year is leap
1568 if ( $year % 400 == 0 || ( $year % 4 == 0 && $year % 100 > 0 ) ) {
1569 $dayOfYear++;
1571 } elseif ( $i == 8 || $i == 10 || $i == 1 || $i == 3 ) {
1572 $dayOfYear += 30;
1573 } else {
1574 $dayOfYear += 31;
1578 # Calculate the start of the Hebrew year
1579 $start = self::hebrewYearStart( $hebrewYear );
1581 # Calculate next year's start
1582 if ( $dayOfYear <= $start ) {
1583 # Day is before the start of the year - it is the previous year
1584 # Next year's start
1585 $nextStart = $start;
1586 # Previous year
1587 $year--;
1588 $hebrewYear--;
1589 # Add days since previous year's 1 September
1590 $dayOfYear += 365;
1591 if ( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
1592 # Leap year
1593 $dayOfYear++;
1595 # Start of the new (previous) year
1596 $start = self::hebrewYearStart( $hebrewYear );
1597 } else {
1598 # Next year's start
1599 $nextStart = self::hebrewYearStart( $hebrewYear + 1 );
1602 # Calculate Hebrew day of year
1603 $hebrewDayOfYear = $dayOfYear - $start;
1605 # Difference between year's days
1606 $diff = $nextStart - $start;
1607 # Add 12 (or 13 for leap years) days to ignore the difference between
1608 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1609 # difference is only about the year type
1610 if ( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
1611 $diff += 13;
1612 } else {
1613 $diff += 12;
1616 # Check the year pattern, and is leap year
1617 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1618 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1619 # and non-leap years
1620 $yearPattern = $diff % 30;
1621 # Check if leap year
1622 $isLeap = $diff >= 30;
1624 # Calculate day in the month from number of day in the Hebrew year
1625 # Don't check Adar - if the day is not in Adar, we will stop before;
1626 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1627 $hebrewDay = $hebrewDayOfYear;
1628 $hebrewMonth = 1;
1629 $days = 0;
1630 while ( $hebrewMonth <= 12 ) {
1631 # Calculate days in this month
1632 if ( $isLeap && $hebrewMonth == 6 ) {
1633 # Adar in a leap year
1634 if ( $isLeap ) {
1635 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1636 $days = 30;
1637 if ( $hebrewDay <= $days ) {
1638 # Day in Adar I
1639 $hebrewMonth = 13;
1640 } else {
1641 # Subtract the days of Adar I
1642 $hebrewDay -= $days;
1643 # Try Adar II
1644 $days = 29;
1645 if ( $hebrewDay <= $days ) {
1646 # Day in Adar II
1647 $hebrewMonth = 14;
1651 } elseif ( $hebrewMonth == 2 && $yearPattern == 2 ) {
1652 # Cheshvan in a complete year (otherwise as the rule below)
1653 $days = 30;
1654 } elseif ( $hebrewMonth == 3 && $yearPattern == 0 ) {
1655 # Kislev in an incomplete year (otherwise as the rule below)
1656 $days = 29;
1657 } else {
1658 # Odd months have 30 days, even have 29
1659 $days = 30 - ( $hebrewMonth - 1 ) % 2;
1661 if ( $hebrewDay <= $days ) {
1662 # In the current month
1663 break;
1664 } else {
1665 # Subtract the days of the current month
1666 $hebrewDay -= $days;
1667 # Try in the next month
1668 $hebrewMonth++;
1672 return array( $hebrewYear, $hebrewMonth, $hebrewDay, $days );
1676 * This calculates the Hebrew year start, as days since 1 September.
1677 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1678 * Used for Hebrew date.
1680 * @param $year int
1682 * @return string
1684 private static function hebrewYearStart( $year ) {
1685 $a = intval( ( 12 * ( $year - 1 ) + 17 ) % 19 );
1686 $b = intval( ( $year - 1 ) % 4 );
1687 $m = 32.044093161144 + 1.5542417966212 * $a + $b / 4.0 - 0.0031777940220923 * ( $year - 1 );
1688 if ( $m < 0 ) {
1689 $m--;
1691 $Mar = intval( $m );
1692 if ( $m < 0 ) {
1693 $m++;
1695 $m -= $Mar;
1697 $c = intval( ( $Mar + 3 * ( $year - 1 ) + 5 * $b + 5 ) % 7 );
1698 if ( $c == 0 && $a > 11 && $m >= 0.89772376543210 ) {
1699 $Mar++;
1700 } elseif ( $c == 1 && $a > 6 && $m >= 0.63287037037037 ) {
1701 $Mar += 2;
1702 } elseif ( $c == 2 || $c == 4 || $c == 6 ) {
1703 $Mar++;
1706 $Mar += intval( ( $year - 3761 ) / 100 ) - intval( ( $year - 3761 ) / 400 ) - 24;
1707 return $Mar;
1711 * Algorithm to convert Gregorian dates to Thai solar dates,
1712 * Minguo dates or Minguo dates.
1714 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1715 * http://en.wikipedia.org/wiki/Minguo_calendar
1716 * http://en.wikipedia.org/wiki/Japanese_era_name
1718 * @param $ts String: 14-character timestamp
1719 * @param $cName String: calender name
1720 * @return Array: converted year, month, day
1722 private static function tsToYear( $ts, $cName ) {
1723 $gy = substr( $ts, 0, 4 );
1724 $gm = substr( $ts, 4, 2 );
1725 $gd = substr( $ts, 6, 2 );
1727 if ( !strcmp( $cName, 'thai' ) ) {
1728 # Thai solar dates
1729 # Add 543 years to the Gregorian calendar
1730 # Months and days are identical
1731 $gy_offset = $gy + 543;
1732 } elseif ( ( !strcmp( $cName, 'minguo' ) ) || !strcmp( $cName, 'juche' ) ) {
1733 # Minguo dates
1734 # Deduct 1911 years from the Gregorian calendar
1735 # Months and days are identical
1736 $gy_offset = $gy - 1911;
1737 } elseif ( !strcmp( $cName, 'tenno' ) ) {
1738 # Nengō dates up to Meiji period
1739 # Deduct years from the Gregorian calendar
1740 # depending on the nengo periods
1741 # Months and days are identical
1742 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1743 # Meiji period
1744 $gy_gannen = $gy - 1868 + 1;
1745 $gy_offset = $gy_gannen;
1746 if ( $gy_gannen == 1 ) {
1747 $gy_offset = '元';
1749 $gy_offset = '明治' . $gy_offset;
1750 } elseif (
1751 ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd == 31 ) ) ||
1752 ( ( $gy == 1912 ) && ( $gm >= 8 ) ) ||
1753 ( ( $gy > 1912 ) && ( $gy < 1926 ) ) ||
1754 ( ( $gy == 1926 ) && ( $gm < 12 ) ) ||
1755 ( ( $gy == 1926 ) && ( $gm == 12 ) && ( $gd < 26 ) )
1758 # Taishō period
1759 $gy_gannen = $gy - 1912 + 1;
1760 $gy_offset = $gy_gannen;
1761 if ( $gy_gannen == 1 ) {
1762 $gy_offset = '元';
1764 $gy_offset = '大正' . $gy_offset;
1765 } elseif (
1766 ( ( $gy == 1926 ) && ( $gm == 12 ) && ( $gd >= 26 ) ) ||
1767 ( ( $gy > 1926 ) && ( $gy < 1989 ) ) ||
1768 ( ( $gy == 1989 ) && ( $gm == 1 ) && ( $gd < 8 ) )
1771 # Shōwa period
1772 $gy_gannen = $gy - 1926 + 1;
1773 $gy_offset = $gy_gannen;
1774 if ( $gy_gannen == 1 ) {
1775 $gy_offset = '元';
1777 $gy_offset = '昭和' . $gy_offset;
1778 } else {
1779 # Heisei period
1780 $gy_gannen = $gy - 1989 + 1;
1781 $gy_offset = $gy_gannen;
1782 if ( $gy_gannen == 1 ) {
1783 $gy_offset = '元';
1785 $gy_offset = '平成' . $gy_offset;
1787 } else {
1788 $gy_offset = $gy;
1791 return array( $gy_offset, $gm, $gd );
1795 * Roman number formatting up to 10000
1797 * @param $num int
1799 * @return string
1801 static function romanNumeral( $num ) {
1802 static $table = array(
1803 array( '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X' ),
1804 array( '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', 'C' ),
1805 array( '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', 'M' ),
1806 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1809 $num = intval( $num );
1810 if ( $num > 10000 || $num <= 0 ) {
1811 return $num;
1814 $s = '';
1815 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1816 if ( $num >= $pow10 ) {
1817 $s .= $table[$i][(int)floor( $num / $pow10 )];
1819 $num = $num % $pow10;
1821 return $s;
1825 * Hebrew Gematria number formatting up to 9999
1827 * @param $num int
1829 * @return string
1831 static function hebrewNumeral( $num ) {
1832 static $table = array(
1833 array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' ),
1834 array( '', 'י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ', 'ק' ),
1835 array( '', 'ק', 'ר', 'ש', 'ת', 'תק', 'תר', 'תש', 'תת', 'תתק', 'תתר' ),
1836 array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' )
1839 $num = intval( $num );
1840 if ( $num > 9999 || $num <= 0 ) {
1841 return $num;
1844 $s = '';
1845 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1846 if ( $num >= $pow10 ) {
1847 if ( $num == 15 || $num == 16 ) {
1848 $s .= $table[0][9] . $table[0][$num - 9];
1849 $num = 0;
1850 } else {
1851 $s .= $table[$i][intval( ( $num / $pow10 ) )];
1852 if ( $pow10 == 1000 ) {
1853 $s .= "'";
1857 $num = $num % $pow10;
1859 if ( strlen( $s ) == 2 ) {
1860 $str = $s . "'";
1861 } else {
1862 $str = substr( $s, 0, strlen( $s ) - 2 ) . '"';
1863 $str .= substr( $s, strlen( $s ) - 2, 2 );
1865 $start = substr( $str, 0, strlen( $str ) - 2 );
1866 $end = substr( $str, strlen( $str ) - 2 );
1867 switch ( $end ) {
1868 case 'כ':
1869 $str = $start . 'ך';
1870 break;
1871 case 'מ':
1872 $str = $start . 'ם';
1873 break;
1874 case 'נ':
1875 $str = $start . 'ן';
1876 break;
1877 case 'פ':
1878 $str = $start . 'ף';
1879 break;
1880 case 'צ':
1881 $str = $start . 'ץ';
1882 break;
1884 return $str;
1888 * Used by date() and time() to adjust the time output.
1890 * @param $ts Int the time in date('YmdHis') format
1891 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1892 * get user timecorrection setting)
1893 * @return int
1895 function userAdjust( $ts, $tz = false ) {
1896 global $wgUser, $wgLocalTZoffset;
1898 if ( $tz === false ) {
1899 $tz = $wgUser->getOption( 'timecorrection' );
1902 $data = explode( '|', $tz, 3 );
1904 if ( $data[0] == 'ZoneInfo' ) {
1905 wfSuppressWarnings();
1906 $userTZ = timezone_open( $data[2] );
1907 wfRestoreWarnings();
1908 if ( $userTZ !== false ) {
1909 $date = date_create( $ts, timezone_open( 'UTC' ) );
1910 date_timezone_set( $date, $userTZ );
1911 $date = date_format( $date, 'YmdHis' );
1912 return $date;
1914 # Unrecognized timezone, default to 'Offset' with the stored offset.
1915 $data[0] = 'Offset';
1918 $minDiff = 0;
1919 if ( $data[0] == 'System' || $tz == '' ) {
1920 #  Global offset in minutes.
1921 if ( isset( $wgLocalTZoffset ) ) {
1922 $minDiff = $wgLocalTZoffset;
1924 } elseif ( $data[0] == 'Offset' ) {
1925 $minDiff = intval( $data[1] );
1926 } else {
1927 $data = explode( ':', $tz );
1928 if ( count( $data ) == 2 ) {
1929 $data[0] = intval( $data[0] );
1930 $data[1] = intval( $data[1] );
1931 $minDiff = abs( $data[0] ) * 60 + $data[1];
1932 if ( $data[0] < 0 ) {
1933 $minDiff = -$minDiff;
1935 } else {
1936 $minDiff = intval( $data[0] ) * 60;
1940 # No difference ? Return time unchanged
1941 if ( 0 == $minDiff ) {
1942 return $ts;
1945 wfSuppressWarnings(); // E_STRICT system time bitching
1946 # Generate an adjusted date; take advantage of the fact that mktime
1947 # will normalize out-of-range values so we don't have to split $minDiff
1948 # into hours and minutes.
1949 $t = mktime( (
1950 (int)substr( $ts, 8, 2 ) ), # Hours
1951 (int)substr( $ts, 10, 2 ) + $minDiff, # Minutes
1952 (int)substr( $ts, 12, 2 ), # Seconds
1953 (int)substr( $ts, 4, 2 ), # Month
1954 (int)substr( $ts, 6, 2 ), # Day
1955 (int)substr( $ts, 0, 4 ) ); # Year
1957 $date = date( 'YmdHis', $t );
1958 wfRestoreWarnings();
1960 return $date;
1964 * This is meant to be used by time(), date(), and timeanddate() to get
1965 * the date preference they're supposed to use, it should be used in
1966 * all children.
1968 *<code>
1969 * function timeanddate([...], $format = true) {
1970 * $datePreference = $this->dateFormat($format);
1971 * [...]
1973 *</code>
1975 * @param $usePrefs Mixed: if true, the user's preference is used
1976 * if false, the site/language default is used
1977 * if int/string, assumed to be a format.
1978 * @return string
1980 function dateFormat( $usePrefs = true ) {
1981 global $wgUser;
1983 if ( is_bool( $usePrefs ) ) {
1984 if ( $usePrefs ) {
1985 $datePreference = $wgUser->getDatePreference();
1986 } else {
1987 $datePreference = (string)User::getDefaultOption( 'date' );
1989 } else {
1990 $datePreference = (string)$usePrefs;
1993 // return int
1994 if ( $datePreference == '' ) {
1995 return 'default';
1998 return $datePreference;
2002 * Get a format string for a given type and preference
2003 * @param $type string May be date, time or both
2004 * @param $pref string The format name as it appears in Messages*.php
2006 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2008 * @return string
2010 function getDateFormatString( $type, $pref ) {
2011 if ( !isset( $this->dateFormatStrings[$type][$pref] ) ) {
2012 if ( $pref == 'default' ) {
2013 $pref = $this->getDefaultDateFormat();
2014 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
2015 } else {
2016 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
2018 if ( $type === 'pretty' && $df === null ) {
2019 $df = $this->getDateFormatString( 'date', $pref );
2022 if ( $df === null ) {
2023 $pref = $this->getDefaultDateFormat();
2024 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
2027 $this->dateFormatStrings[$type][$pref] = $df;
2029 return $this->dateFormatStrings[$type][$pref];
2033 * @param $ts Mixed: the time format which needs to be turned into a
2034 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2035 * @param $adj Bool: whether to adjust the time output according to the
2036 * user configured offset ($timecorrection)
2037 * @param $format Mixed: true to use user's date format preference
2038 * @param $timecorrection String|bool the time offset as returned by
2039 * validateTimeZone() in Special:Preferences
2040 * @return string
2042 function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
2043 $ts = wfTimestamp( TS_MW, $ts );
2044 if ( $adj ) {
2045 $ts = $this->userAdjust( $ts, $timecorrection );
2047 $df = $this->getDateFormatString( 'date', $this->dateFormat( $format ) );
2048 return $this->sprintfDate( $df, $ts );
2052 * @param $ts Mixed: the time format which needs to be turned into a
2053 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2054 * @param $adj Bool: whether to adjust the time output according to the
2055 * user configured offset ($timecorrection)
2056 * @param $format Mixed: true to use user's date format preference
2057 * @param $timecorrection String|bool the time offset as returned by
2058 * validateTimeZone() in Special:Preferences
2059 * @return string
2061 function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
2062 $ts = wfTimestamp( TS_MW, $ts );
2063 if ( $adj ) {
2064 $ts = $this->userAdjust( $ts, $timecorrection );
2066 $df = $this->getDateFormatString( 'time', $this->dateFormat( $format ) );
2067 return $this->sprintfDate( $df, $ts );
2071 * @param $ts Mixed: the time format which needs to be turned into a
2072 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2073 * @param $adj Bool: whether to adjust the time output according to the
2074 * user configured offset ($timecorrection)
2075 * @param $format Mixed: what format to return, if it's false output the
2076 * default one (default true)
2077 * @param $timecorrection String|bool the time offset as returned by
2078 * validateTimeZone() in Special:Preferences
2079 * @return string
2081 function timeanddate( $ts, $adj = false, $format = true, $timecorrection = false ) {
2082 $ts = wfTimestamp( TS_MW, $ts );
2083 if ( $adj ) {
2084 $ts = $this->userAdjust( $ts, $timecorrection );
2086 $df = $this->getDateFormatString( 'both', $this->dateFormat( $format ) );
2087 return $this->sprintfDate( $df, $ts );
2091 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2093 * @since 1.20
2095 * @param integer $seconds The amount of seconds.
2096 * @param array $chosenIntervals The intervals to enable.
2098 * @return string
2100 public function formatDuration( $seconds, array $chosenIntervals = array() ) {
2101 $intervals = $this->getDurationIntervals( $seconds, $chosenIntervals );
2103 $segments = array();
2105 foreach ( $intervals as $intervalName => $intervalValue ) {
2106 // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2107 // duration-years, duration-decades, duration-centuries, duration-millennia
2108 $message = wfMessage( 'duration-' . $intervalName )->numParams( $intervalValue );
2109 $segments[] = $message->inLanguage( $this )->escaped();
2112 return $this->listToText( $segments );
2116 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2117 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2119 * @since 1.20
2121 * @param integer $seconds The amount of seconds.
2122 * @param array $chosenIntervals The intervals to enable.
2124 * @return array
2126 public function getDurationIntervals( $seconds, array $chosenIntervals = array() ) {
2127 if ( empty( $chosenIntervals ) ) {
2128 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2131 $intervals = array_intersect_key( self::$durationIntervals, array_flip( $chosenIntervals ) );
2132 $sortedNames = array_keys( $intervals );
2133 $smallestInterval = array_pop( $sortedNames );
2135 $segments = array();
2137 foreach ( $intervals as $name => $length ) {
2138 $value = floor( $seconds / $length );
2140 if ( $value > 0 || ( $name == $smallestInterval && empty( $segments ) ) ) {
2141 $seconds -= $value * $length;
2142 $segments[$name] = $value;
2146 return $segments;
2150 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2152 * @param $type String: can be 'date', 'time' or 'both'
2153 * @param $ts Mixed: the time format which needs to be turned into a
2154 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2155 * @param $user User object used to get preferences for timezone and format
2156 * @param $options Array, can contain the following keys:
2157 * - 'timecorrection': time correction, can have the following values:
2158 * - true: use user's preference
2159 * - false: don't use time correction
2160 * - integer: value of time correction in minutes
2161 * - 'format': format to use, can have the following values:
2162 * - true: use user's preference
2163 * - false: use default preference
2164 * - string: format to use
2165 * @since 1.19
2166 * @return String
2168 private function internalUserTimeAndDate( $type, $ts, User $user, array $options ) {
2169 $ts = wfTimestamp( TS_MW, $ts );
2170 $options += array( 'timecorrection' => true, 'format' => true );
2171 if ( $options['timecorrection'] !== false ) {
2172 if ( $options['timecorrection'] === true ) {
2173 $offset = $user->getOption( 'timecorrection' );
2174 } else {
2175 $offset = $options['timecorrection'];
2177 $ts = $this->userAdjust( $ts, $offset );
2179 if ( $options['format'] === true ) {
2180 $format = $user->getDatePreference();
2181 } else {
2182 $format = $options['format'];
2184 $df = $this->getDateFormatString( $type, $this->dateFormat( $format ) );
2185 return $this->sprintfDate( $df, $ts );
2189 * Get the formatted date for the given timestamp and formatted for
2190 * the given user.
2192 * @param $ts Mixed: the time format which needs to be turned into a
2193 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2194 * @param $user User object used to get preferences for timezone and format
2195 * @param $options Array, can contain the following keys:
2196 * - 'timecorrection': time correction, can have the following values:
2197 * - true: use user's preference
2198 * - false: don't use time correction
2199 * - integer: value of time correction in minutes
2200 * - 'format': format to use, can have the following values:
2201 * - true: use user's preference
2202 * - false: use default preference
2203 * - string: format to use
2204 * @since 1.19
2205 * @return String
2207 public function userDate( $ts, User $user, array $options = array() ) {
2208 return $this->internalUserTimeAndDate( 'date', $ts, $user, $options );
2212 * Get the formatted time for the given timestamp and formatted for
2213 * the given user.
2215 * @param $ts Mixed: the time format which needs to be turned into a
2216 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2217 * @param $user User object used to get preferences for timezone and format
2218 * @param $options Array, can contain the following keys:
2219 * - 'timecorrection': time correction, can have the following values:
2220 * - true: use user's preference
2221 * - false: don't use time correction
2222 * - integer: value of time correction in minutes
2223 * - 'format': format to use, can have the following values:
2224 * - true: use user's preference
2225 * - false: use default preference
2226 * - string: format to use
2227 * @since 1.19
2228 * @return String
2230 public function userTime( $ts, User $user, array $options = array() ) {
2231 return $this->internalUserTimeAndDate( 'time', $ts, $user, $options );
2235 * Get the formatted date and time for the given timestamp and formatted for
2236 * the given user.
2238 * @param $ts Mixed: the time format which needs to be turned into a
2239 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2240 * @param $user User object used to get preferences for timezone and format
2241 * @param $options Array, can contain the following keys:
2242 * - 'timecorrection': time correction, can have the following values:
2243 * - true: use user's preference
2244 * - false: don't use time correction
2245 * - integer: value of time correction in minutes
2246 * - 'format': format to use, can have the following values:
2247 * - true: use user's preference
2248 * - false: use default preference
2249 * - string: format to use
2250 * @since 1.19
2251 * @return String
2253 public function userTimeAndDate( $ts, User $user, array $options = array() ) {
2254 return $this->internalUserTimeAndDate( 'both', $ts, $user, $options );
2258 * Convert an MWTimestamp into a pretty human-readable timestamp using
2259 * the given user preferences and relative base time.
2261 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2262 * on your timestamp object, which will then call this function. Calling
2263 * this function directly will cause hooks to be skipped over.
2265 * @see MWTimestamp::getHumanTimestamp
2266 * @param MWTimestamp $ts Timestamp to prettify
2267 * @param MWTimestamp $relativeTo Base timestamp
2268 * @param User $user User preferences to use
2269 * @return string Human timestamp
2270 * @since 1.22
2272 public function getHumanTimestamp( MWTimestamp $ts, MWTimestamp $relativeTo, User $user ) {
2273 $diff = $ts->diff( $relativeTo );
2274 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) - (int)$relativeTo->timestamp->format( 'w' ) );
2275 $days = $diff->days ?: (int)$diffDay;
2276 if ( $diff->invert || $days > 5 && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' ) ) {
2277 // Timestamps are in different years: use full timestamp
2278 // Also do full timestamp for future dates
2280 * @FIXME Add better handling of future timestamps.
2282 $format = $this->getDateFormatString( 'both', $user->getDatePreference() ?: 'default' );
2283 $ts = $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) );
2284 } elseif ( $days > 5 ) {
2285 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2286 $format = $this->getDateFormatString( 'pretty', $user->getDatePreference() ?: 'default' );
2287 $ts = $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) );
2288 } elseif ( $days > 1 ) {
2289 // Timestamp within the past week: show the day of the week and time
2290 $format = $this->getDateFormatString( 'time', $user->getDatePreference() ?: 'default' );
2291 $weekday = self::$mWeekdayMsgs[$ts->timestamp->format( 'w' )];
2292 // Messages:
2293 // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2294 $ts = wfMessage( "$weekday-at" )
2295 ->inLanguage( $this )
2296 ->params( $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) ) )
2297 ->text();
2298 } elseif ( $days == 1 ) {
2299 // Timestamp was yesterday: say 'yesterday' and the time.
2300 $format = $this->getDateFormatString( 'time', $user->getDatePreference() ?: 'default' );
2301 $ts = wfMessage( 'yesterday-at' )
2302 ->inLanguage( $this )
2303 ->params( $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) ) )
2304 ->text();
2305 } elseif ( $diff->h > 1 || $diff->h == 1 && $diff->i > 30 ) {
2306 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2307 $format = $this->getDateFormatString( 'time', $user->getDatePreference() ?: 'default' );
2308 $ts = wfMessage( 'today-at' )
2309 ->inLanguage( $this )
2310 ->params( $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) ) )
2311 ->text();
2313 // From here on in, the timestamp was soon enough ago so that we can simply say
2314 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2315 } elseif ( $diff->h == 1 ) {
2316 // Less than 90 minutes, but more than an hour ago.
2317 $ts = wfMessage( 'hours-ago' )->inLanguage( $this )->numParams( 1 )->text();
2318 } elseif ( $diff->i >= 1 ) {
2319 // A few minutes ago.
2320 $ts = wfMessage( 'minutes-ago' )->inLanguage( $this )->numParams( $diff->i )->text();
2321 } elseif ( $diff->s >= 30 ) {
2322 // Less than a minute, but more than 30 sec ago.
2323 $ts = wfMessage( 'seconds-ago' )->inLanguage( $this )->numParams( $diff->s )->text();
2324 } else {
2325 // Less than 30 seconds ago.
2326 $ts = wfMessage( 'just-now' )->text();
2329 return $ts;
2333 * @param $key string
2334 * @return array|null
2336 function getMessage( $key ) {
2337 return self::$dataCache->getSubitem( $this->mCode, 'messages', $key );
2341 * @return array
2343 function getAllMessages() {
2344 return self::$dataCache->getItem( $this->mCode, 'messages' );
2348 * @param $in
2349 * @param $out
2350 * @param $string
2351 * @return string
2353 function iconv( $in, $out, $string ) {
2354 # This is a wrapper for iconv in all languages except esperanto,
2355 # which does some nasty x-conversions beforehand
2357 # Even with //IGNORE iconv can whine about illegal characters in
2358 # *input* string. We just ignore those too.
2359 # REF: http://bugs.php.net/bug.php?id=37166
2360 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2361 wfSuppressWarnings();
2362 $text = iconv( $in, $out . '//IGNORE', $string );
2363 wfRestoreWarnings();
2364 return $text;
2367 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2370 * @param $matches array
2371 * @return mixed|string
2373 function ucwordbreaksCallbackAscii( $matches ) {
2374 return $this->ucfirst( $matches[1] );
2378 * @param $matches array
2379 * @return string
2381 function ucwordbreaksCallbackMB( $matches ) {
2382 return mb_strtoupper( $matches[0] );
2386 * @param $matches array
2387 * @return string
2389 function ucCallback( $matches ) {
2390 list( $wikiUpperChars ) = self::getCaseMaps();
2391 return strtr( $matches[1], $wikiUpperChars );
2395 * @param $matches array
2396 * @return string
2398 function lcCallback( $matches ) {
2399 list( , $wikiLowerChars ) = self::getCaseMaps();
2400 return strtr( $matches[1], $wikiLowerChars );
2404 * @param $matches array
2405 * @return string
2407 function ucwordsCallbackMB( $matches ) {
2408 return mb_strtoupper( $matches[0] );
2412 * @param $matches array
2413 * @return string
2415 function ucwordsCallbackWiki( $matches ) {
2416 list( $wikiUpperChars ) = self::getCaseMaps();
2417 return strtr( $matches[0], $wikiUpperChars );
2421 * Make a string's first character uppercase
2423 * @param $str string
2425 * @return string
2427 function ucfirst( $str ) {
2428 $o = ord( $str );
2429 if ( $o < 96 ) { // if already uppercase...
2430 return $str;
2431 } elseif ( $o < 128 ) {
2432 return ucfirst( $str ); // use PHP's ucfirst()
2433 } else {
2434 // fall back to more complex logic in case of multibyte strings
2435 return $this->uc( $str, true );
2440 * Convert a string to uppercase
2442 * @param $str string
2443 * @param $first bool
2445 * @return string
2447 function uc( $str, $first = false ) {
2448 if ( function_exists( 'mb_strtoupper' ) ) {
2449 if ( $first ) {
2450 if ( $this->isMultibyte( $str ) ) {
2451 return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
2452 } else {
2453 return ucfirst( $str );
2455 } else {
2456 return $this->isMultibyte( $str ) ? mb_strtoupper( $str ) : strtoupper( $str );
2458 } else {
2459 if ( $this->isMultibyte( $str ) ) {
2460 $x = $first ? '^' : '';
2461 return preg_replace_callback(
2462 "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
2463 array( $this, 'ucCallback' ),
2464 $str
2466 } else {
2467 return $first ? ucfirst( $str ) : strtoupper( $str );
2473 * @param $str string
2474 * @return mixed|string
2476 function lcfirst( $str ) {
2477 $o = ord( $str );
2478 if ( !$o ) {
2479 return strval( $str );
2480 } elseif ( $o >= 128 ) {
2481 return $this->lc( $str, true );
2482 } elseif ( $o > 96 ) {
2483 return $str;
2484 } else {
2485 $str[0] = strtolower( $str[0] );
2486 return $str;
2491 * @param $str string
2492 * @param $first bool
2493 * @return mixed|string
2495 function lc( $str, $first = false ) {
2496 if ( function_exists( 'mb_strtolower' ) ) {
2497 if ( $first ) {
2498 if ( $this->isMultibyte( $str ) ) {
2499 return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
2500 } else {
2501 return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
2503 } else {
2504 return $this->isMultibyte( $str ) ? mb_strtolower( $str ) : strtolower( $str );
2506 } else {
2507 if ( $this->isMultibyte( $str ) ) {
2508 $x = $first ? '^' : '';
2509 return preg_replace_callback(
2510 "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
2511 array( $this, 'lcCallback' ),
2512 $str
2514 } else {
2515 return $first ? strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
2521 * @param $str string
2522 * @return bool
2524 function isMultibyte( $str ) {
2525 return (bool)preg_match( '/[\x80-\xff]/', $str );
2529 * @param $str string
2530 * @return mixed|string
2532 function ucwords( $str ) {
2533 if ( $this->isMultibyte( $str ) ) {
2534 $str = $this->lc( $str );
2536 // regexp to find first letter in each word (i.e. after each space)
2537 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2539 // function to use to capitalize a single char
2540 if ( function_exists( 'mb_strtoupper' ) ) {
2541 return preg_replace_callback(
2542 $replaceRegexp,
2543 array( $this, 'ucwordsCallbackMB' ),
2544 $str
2546 } else {
2547 return preg_replace_callback(
2548 $replaceRegexp,
2549 array( $this, 'ucwordsCallbackWiki' ),
2550 $str
2553 } else {
2554 return ucwords( strtolower( $str ) );
2559 * capitalize words at word breaks
2561 * @param $str string
2562 * @return mixed
2564 function ucwordbreaks( $str ) {
2565 if ( $this->isMultibyte( $str ) ) {
2566 $str = $this->lc( $str );
2568 // since \b doesn't work for UTF-8, we explicitely define word break chars
2569 $breaks = "[ \-\(\)\}\{\.,\?!]";
2571 // find first letter after word break
2572 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2574 if ( function_exists( 'mb_strtoupper' ) ) {
2575 return preg_replace_callback(
2576 $replaceRegexp,
2577 array( $this, 'ucwordbreaksCallbackMB' ),
2578 $str
2580 } else {
2581 return preg_replace_callback(
2582 $replaceRegexp,
2583 array( $this, 'ucwordsCallbackWiki' ),
2584 $str
2587 } else {
2588 return preg_replace_callback(
2589 '/\b([\w\x80-\xff]+)\b/',
2590 array( $this, 'ucwordbreaksCallbackAscii' ),
2591 $str
2597 * Return a case-folded representation of $s
2599 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2600 * and $s2 are the same except for the case of their characters. It is not
2601 * necessary for the value returned to make sense when displayed.
2603 * Do *not* perform any other normalisation in this function. If a caller
2604 * uses this function when it should be using a more general normalisation
2605 * function, then fix the caller.
2607 * @param $s string
2609 * @return string
2611 function caseFold( $s ) {
2612 return $this->uc( $s );
2616 * @param $s string
2617 * @return string
2619 function checkTitleEncoding( $s ) {
2620 if ( is_array( $s ) ) {
2621 throw new MWException( 'Given array to checkTitleEncoding.' );
2623 if ( StringUtils::isUtf8( $s ) ) {
2624 return $s;
2627 return $this->iconv( $this->fallback8bitEncoding(), 'utf-8', $s );
2631 * @return array
2633 function fallback8bitEncoding() {
2634 return self::$dataCache->getItem( $this->mCode, 'fallback8bitEncoding' );
2638 * Most writing systems use whitespace to break up words.
2639 * Some languages such as Chinese don't conventionally do this,
2640 * which requires special handling when breaking up words for
2641 * searching etc.
2643 * @return bool
2645 function hasWordBreaks() {
2646 return true;
2650 * Some languages such as Chinese require word segmentation,
2651 * Specify such segmentation when overridden in derived class.
2653 * @param $string String
2654 * @return String
2656 function segmentByWord( $string ) {
2657 return $string;
2661 * Some languages have special punctuation need to be normalized.
2662 * Make such changes here.
2664 * @param $string String
2665 * @return String
2667 function normalizeForSearch( $string ) {
2668 return self::convertDoubleWidth( $string );
2672 * convert double-width roman characters to single-width.
2673 * range: ff00-ff5f ~= 0020-007f
2675 * @param $string string
2677 * @return string
2679 protected static function convertDoubleWidth( $string ) {
2680 static $full = null;
2681 static $half = null;
2683 if ( $full === null ) {
2684 $fullWidth = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
2685 $halfWidth = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
2686 $full = str_split( $fullWidth, 3 );
2687 $half = str_split( $halfWidth );
2690 $string = str_replace( $full, $half, $string );
2691 return $string;
2695 * @param $string string
2696 * @param $pattern string
2697 * @return string
2699 protected static function insertSpace( $string, $pattern ) {
2700 $string = preg_replace( $pattern, " $1 ", $string );
2701 $string = preg_replace( '/ +/', ' ', $string );
2702 return $string;
2706 * @param $termsArray array
2707 * @return array
2709 function convertForSearchResult( $termsArray ) {
2710 # some languages, e.g. Chinese, need to do a conversion
2711 # in order for search results to be displayed correctly
2712 return $termsArray;
2716 * Get the first character of a string.
2718 * @param $s string
2719 * @return string
2721 function firstChar( $s ) {
2722 $matches = array();
2723 preg_match(
2724 '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
2725 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/',
2727 $matches
2730 if ( isset( $matches[1] ) ) {
2731 if ( strlen( $matches[1] ) != 3 ) {
2732 return $matches[1];
2735 // Break down Hangul syllables to grab the first jamo
2736 $code = utf8ToCodepoint( $matches[1] );
2737 if ( $code < 0xac00 || 0xd7a4 <= $code ) {
2738 return $matches[1];
2739 } elseif ( $code < 0xb098 ) {
2740 return "\xe3\x84\xb1";
2741 } elseif ( $code < 0xb2e4 ) {
2742 return "\xe3\x84\xb4";
2743 } elseif ( $code < 0xb77c ) {
2744 return "\xe3\x84\xb7";
2745 } elseif ( $code < 0xb9c8 ) {
2746 return "\xe3\x84\xb9";
2747 } elseif ( $code < 0xbc14 ) {
2748 return "\xe3\x85\x81";
2749 } elseif ( $code < 0xc0ac ) {
2750 return "\xe3\x85\x82";
2751 } elseif ( $code < 0xc544 ) {
2752 return "\xe3\x85\x85";
2753 } elseif ( $code < 0xc790 ) {
2754 return "\xe3\x85\x87";
2755 } elseif ( $code < 0xcc28 ) {
2756 return "\xe3\x85\x88";
2757 } elseif ( $code < 0xce74 ) {
2758 return "\xe3\x85\x8a";
2759 } elseif ( $code < 0xd0c0 ) {
2760 return "\xe3\x85\x8b";
2761 } elseif ( $code < 0xd30c ) {
2762 return "\xe3\x85\x8c";
2763 } elseif ( $code < 0xd558 ) {
2764 return "\xe3\x85\x8d";
2765 } else {
2766 return "\xe3\x85\x8e";
2768 } else {
2769 return '';
2773 function initEncoding() {
2774 # Some languages may have an alternate char encoding option
2775 # (Esperanto X-coding, Japanese furigana conversion, etc)
2776 # If this language is used as the primary content language,
2777 # an override to the defaults can be set here on startup.
2781 * @param $s string
2782 * @return string
2784 function recodeForEdit( $s ) {
2785 # For some languages we'll want to explicitly specify
2786 # which characters make it into the edit box raw
2787 # or are converted in some way or another.
2788 global $wgEditEncoding;
2789 if ( $wgEditEncoding == '' || $wgEditEncoding == 'UTF-8' ) {
2790 return $s;
2791 } else {
2792 return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
2797 * @param $s string
2798 * @return string
2800 function recodeInput( $s ) {
2801 # Take the previous into account.
2802 global $wgEditEncoding;
2803 if ( $wgEditEncoding != '' ) {
2804 $enc = $wgEditEncoding;
2805 } else {
2806 $enc = 'UTF-8';
2808 if ( $enc == 'UTF-8' ) {
2809 return $s;
2810 } else {
2811 return $this->iconv( $enc, 'UTF-8', $s );
2816 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2817 * also cleans up certain backwards-compatible sequences, converting them
2818 * to the modern Unicode equivalent.
2820 * This is language-specific for performance reasons only.
2822 * @param $s string
2824 * @return string
2826 function normalize( $s ) {
2827 global $wgAllUnicodeFixes;
2828 $s = UtfNormal::cleanUp( $s );
2829 if ( $wgAllUnicodeFixes ) {
2830 $s = $this->transformUsingPairFile( 'normalize-ar.ser', $s );
2831 $s = $this->transformUsingPairFile( 'normalize-ml.ser', $s );
2834 return $s;
2838 * Transform a string using serialized data stored in the given file (which
2839 * must be in the serialized subdirectory of $IP). The file contains pairs
2840 * mapping source characters to destination characters.
2842 * The data is cached in process memory. This will go faster if you have the
2843 * FastStringSearch extension.
2845 * @param $file string
2846 * @param $string string
2848 * @throws MWException
2849 * @return string
2851 function transformUsingPairFile( $file, $string ) {
2852 if ( !isset( $this->transformData[$file] ) ) {
2853 $data = wfGetPrecompiledData( $file );
2854 if ( $data === false ) {
2855 throw new MWException( __METHOD__ . ": The transformation file $file is missing" );
2857 $this->transformData[$file] = new ReplacementArray( $data );
2859 return $this->transformData[$file]->replace( $string );
2863 * For right-to-left language support
2865 * @return bool
2867 function isRTL() {
2868 return self::$dataCache->getItem( $this->mCode, 'rtl' );
2872 * Return the correct HTML 'dir' attribute value for this language.
2873 * @return String
2875 function getDir() {
2876 return $this->isRTL() ? 'rtl' : 'ltr';
2880 * Return 'left' or 'right' as appropriate alignment for line-start
2881 * for this language's text direction.
2883 * Should be equivalent to CSS3 'start' text-align value....
2885 * @return String
2887 function alignStart() {
2888 return $this->isRTL() ? 'right' : 'left';
2892 * Return 'right' or 'left' as appropriate alignment for line-end
2893 * for this language's text direction.
2895 * Should be equivalent to CSS3 'end' text-align value....
2897 * @return String
2899 function alignEnd() {
2900 return $this->isRTL() ? 'left' : 'right';
2904 * A hidden direction mark (LRM or RLM), depending on the language direction.
2905 * Unlike getDirMark(), this function returns the character as an HTML entity.
2906 * This function should be used when the output is guaranteed to be HTML,
2907 * because it makes the output HTML source code more readable. When
2908 * the output is plain text or can be escaped, getDirMark() should be used.
2910 * @param $opposite Boolean Get the direction mark opposite to your language
2911 * @return string
2912 * @since 1.20
2914 function getDirMarkEntity( $opposite = false ) {
2915 if ( $opposite ) {
2916 return $this->isRTL() ? '&lrm;' : '&rlm;';
2918 return $this->isRTL() ? '&rlm;' : '&lrm;';
2922 * A hidden direction mark (LRM or RLM), depending on the language direction.
2923 * This function produces them as invisible Unicode characters and
2924 * the output may be hard to read and debug, so it should only be used
2925 * when the output is plain text or can be escaped. When the output is
2926 * HTML, use getDirMarkEntity() instead.
2928 * @param $opposite Boolean Get the direction mark opposite to your language
2929 * @return string
2931 function getDirMark( $opposite = false ) {
2932 $lrm = "\xE2\x80\x8E"; # LEFT-TO-RIGHT MARK, commonly abbreviated LRM
2933 $rlm = "\xE2\x80\x8F"; # RIGHT-TO-LEFT MARK, commonly abbreviated RLM
2934 if ( $opposite ) {
2935 return $this->isRTL() ? $lrm : $rlm;
2937 return $this->isRTL() ? $rlm : $lrm;
2941 * @return array
2943 function capitalizeAllNouns() {
2944 return self::$dataCache->getItem( $this->mCode, 'capitalizeAllNouns' );
2948 * An arrow, depending on the language direction.
2950 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2951 * @return string
2953 function getArrow( $direction = 'forwards' ) {
2954 switch ( $direction ) {
2955 case 'forwards':
2956 return $this->isRTL() ? '←' : '→';
2957 case 'backwards':
2958 return $this->isRTL() ? '→' : '←';
2959 case 'left':
2960 return '←';
2961 case 'right':
2962 return '→';
2963 case 'up':
2964 return '↑';
2965 case 'down':
2966 return '↓';
2971 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2973 * @return bool
2975 function linkPrefixExtension() {
2976 return self::$dataCache->getItem( $this->mCode, 'linkPrefixExtension' );
2980 * Get all magic words from cache.
2981 * @return array
2983 function getMagicWords() {
2984 return self::$dataCache->getItem( $this->mCode, 'magicWords' );
2988 * Run the LanguageGetMagic hook once.
2990 protected function doMagicHook() {
2991 if ( $this->mMagicHookDone ) {
2992 return;
2994 $this->mMagicHookDone = true;
2995 wfProfileIn( 'LanguageGetMagic' );
2996 wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
2997 wfProfileOut( 'LanguageGetMagic' );
3001 * Fill a MagicWord object with data from here
3003 * @param $mw
3005 function getMagic( $mw ) {
3006 // Saves a function call
3007 if ( ! $this->mMagicHookDone ) {
3008 $this->doMagicHook();
3011 if ( isset( $this->mMagicExtensions[$mw->mId] ) ) {
3012 $rawEntry = $this->mMagicExtensions[$mw->mId];
3013 } else {
3014 $rawEntry = self::$dataCache->getSubitem(
3015 $this->mCode, 'magicWords', $mw->mId );
3018 if ( !is_array( $rawEntry ) ) {
3019 error_log( "\"$rawEntry\" is not a valid magic word for \"$mw->mId\"" );
3020 } else {
3021 $mw->mCaseSensitive = $rawEntry[0];
3022 $mw->mSynonyms = array_slice( $rawEntry, 1 );
3027 * Add magic words to the extension array
3029 * @param $newWords array
3031 function addMagicWordsByLang( $newWords ) {
3032 $fallbackChain = $this->getFallbackLanguages();
3033 $fallbackChain = array_reverse( $fallbackChain );
3034 foreach ( $fallbackChain as $code ) {
3035 if ( isset( $newWords[$code] ) ) {
3036 $this->mMagicExtensions = $newWords[$code] + $this->mMagicExtensions;
3042 * Get special page names, as an associative array
3043 * case folded alias => real name
3045 function getSpecialPageAliases() {
3046 // Cache aliases because it may be slow to load them
3047 if ( is_null( $this->mExtendedSpecialPageAliases ) ) {
3048 // Initialise array
3049 $this->mExtendedSpecialPageAliases =
3050 self::$dataCache->getItem( $this->mCode, 'specialPageAliases' );
3051 wfRunHooks( 'LanguageGetSpecialPageAliases',
3052 array( &$this->mExtendedSpecialPageAliases, $this->getCode() ) );
3055 return $this->mExtendedSpecialPageAliases;
3059 * Italic is unsuitable for some languages
3061 * @param $text String: the text to be emphasized.
3062 * @return string
3064 function emphasize( $text ) {
3065 return "<em>$text</em>";
3069 * Normally we output all numbers in plain en_US style, that is
3070 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3071 * point twohundredthirtyfive. However this is not suitable for all
3072 * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3073 * Icelandic just want to use commas instead of dots, and dots instead
3074 * of commas like "293.291,235".
3076 * An example of this function being called:
3077 * <code>
3078 * wfMessage( 'message' )->numParams( $num )->text()
3079 * </code>
3081 * See LanguageGu.php for the Gujarati implementation and
3082 * $separatorTransformTable on MessageIs.php for
3083 * the , => . and . => , implementation.
3085 * @todo check if it's viable to use localeconv() for the decimal
3086 * separator thing.
3087 * @param $number Mixed: the string to be formatted, should be an integer
3088 * or a floating point number.
3089 * @param $nocommafy Bool: set to true for special numbers like dates
3090 * @return string
3092 public function formatNum( $number, $nocommafy = false ) {
3093 global $wgTranslateNumerals;
3094 if ( !$nocommafy ) {
3095 $number = $this->commafy( $number );
3096 $s = $this->separatorTransformTable();
3097 if ( $s ) {
3098 $number = strtr( $number, $s );
3102 if ( $wgTranslateNumerals ) {
3103 $s = $this->digitTransformTable();
3104 if ( $s ) {
3105 $number = strtr( $number, $s );
3109 return $number;
3113 * Front-end for non-commafied formatNum
3115 * @param mixed $number the string to be formatted, should be an integer
3116 * or a floating point number.
3117 * @since 1.21
3118 * @return string
3120 public function formatNumNoSeparators( $number ) {
3121 return $this->formatNum( $number, true );
3125 * @param $number string
3126 * @return string
3128 function parseFormattedNumber( $number ) {
3129 $s = $this->digitTransformTable();
3130 if ( $s ) {
3131 $number = strtr( $number, array_flip( $s ) );
3134 $s = $this->separatorTransformTable();
3135 if ( $s ) {
3136 $number = strtr( $number, array_flip( $s ) );
3139 $number = strtr( $number, array( ',' => '' ) );
3140 return $number;
3144 * Adds commas to a given number
3145 * @since 1.19
3146 * @param $number mixed
3147 * @return string
3149 function commafy( $number ) {
3150 $digitGroupingPattern = $this->digitGroupingPattern();
3151 if ( $number === null ) {
3152 return '';
3155 if ( !$digitGroupingPattern || $digitGroupingPattern === "###,###,###" ) {
3156 // default grouping is at thousands, use the same for ###,###,### pattern too.
3157 return strrev( (string)preg_replace( '/(\d{3})(?=\d)(?!\d*\.)/', '$1,', strrev( $number ) ) );
3158 } else {
3159 // Ref: http://cldr.unicode.org/translation/number-patterns
3160 $sign = "";
3161 if ( intval( $number ) < 0 ) {
3162 // For negative numbers apply the algorithm like positive number and add sign.
3163 $sign = "-";
3164 $number = substr( $number, 1 );
3166 $integerPart = array();
3167 $decimalPart = array();
3168 $numMatches = preg_match_all( "/(#+)/", $digitGroupingPattern, $matches );
3169 preg_match( "/\d+/", $number, $integerPart );
3170 preg_match( "/\.\d*/", $number, $decimalPart );
3171 $groupedNumber = ( count( $decimalPart ) > 0 ) ? $decimalPart[0] : "";
3172 if ( $groupedNumber === $number ) {
3173 // the string does not have any number part. Eg: .12345
3174 return $sign . $groupedNumber;
3176 $start = $end = strlen( $integerPart[0] );
3177 while ( $start > 0 ) {
3178 $match = $matches[0][$numMatches - 1];
3179 $matchLen = strlen( $match );
3180 $start = $end - $matchLen;
3181 if ( $start < 0 ) {
3182 $start = 0;
3184 $groupedNumber = substr( $number, $start, $end -$start ) . $groupedNumber;
3185 $end = $start;
3186 if ( $numMatches > 1 ) {
3187 // use the last pattern for the rest of the number
3188 $numMatches--;
3190 if ( $start > 0 ) {
3191 $groupedNumber = "," . $groupedNumber;
3194 return $sign . $groupedNumber;
3199 * @return String
3201 function digitGroupingPattern() {
3202 return self::$dataCache->getItem( $this->mCode, 'digitGroupingPattern' );
3206 * @return array
3208 function digitTransformTable() {
3209 return self::$dataCache->getItem( $this->mCode, 'digitTransformTable' );
3213 * @return array
3215 function separatorTransformTable() {
3216 return self::$dataCache->getItem( $this->mCode, 'separatorTransformTable' );
3220 * Take a list of strings and build a locale-friendly comma-separated
3221 * list, using the local comma-separator message.
3222 * The last two strings are chained with an "and".
3223 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3225 * @param $l Array
3226 * @return string
3228 function listToText( array $l ) {
3229 $m = count( $l ) - 1;
3230 if ( $m < 0 ) {
3231 return '';
3233 if ( $m > 0 ) {
3234 $and = $this->getMessageFromDB( 'and' );
3235 $space = $this->getMessageFromDB( 'word-separator' );
3236 if ( $m > 1 ) {
3237 $comma = $this->getMessageFromDB( 'comma-separator' );
3240 $s = $l[$m];
3241 for ( $i = $m - 1; $i >= 0; $i-- ) {
3242 if ( $i == $m - 1 ) {
3243 $s = $l[$i] . $and . $space . $s;
3244 } else {
3245 $s = $l[$i] . $comma . $s;
3248 return $s;
3252 * Take a list of strings and build a locale-friendly comma-separated
3253 * list, using the local comma-separator message.
3254 * @param $list array of strings to put in a comma list
3255 * @return string
3257 function commaList( array $list ) {
3258 return implode(
3259 wfMessage( 'comma-separator' )->inLanguage( $this )->escaped(),
3260 $list
3265 * Take a list of strings and build a locale-friendly semicolon-separated
3266 * list, using the local semicolon-separator message.
3267 * @param $list array of strings to put in a semicolon list
3268 * @return string
3270 function semicolonList( array $list ) {
3271 return implode(
3272 wfMessage( 'semicolon-separator' )->inLanguage( $this )->escaped(),
3273 $list
3278 * Same as commaList, but separate it with the pipe instead.
3279 * @param $list array of strings to put in a pipe list
3280 * @return string
3282 function pipeList( array $list ) {
3283 return implode(
3284 wfMessage( 'pipe-separator' )->inLanguage( $this )->escaped(),
3285 $list
3290 * Truncate a string to a specified length in bytes, appending an optional
3291 * string (e.g. for ellipses)
3293 * The database offers limited byte lengths for some columns in the database;
3294 * multi-byte character sets mean we need to ensure that only whole characters
3295 * are included, otherwise broken characters can be passed to the user
3297 * If $length is negative, the string will be truncated from the beginning
3299 * @param $string String to truncate
3300 * @param $length Int: maximum length (including ellipses)
3301 * @param $ellipsis String to append to the truncated text
3302 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3303 * $adjustLength was introduced in 1.18, before that behaved as if false.
3304 * @return string
3306 function truncate( $string, $length, $ellipsis = '...', $adjustLength = true ) {
3307 # Use the localized ellipsis character
3308 if ( $ellipsis == '...' ) {
3309 $ellipsis = wfMessage( 'ellipsis' )->inLanguage( $this )->escaped();
3311 # Check if there is no need to truncate
3312 if ( $length == 0 ) {
3313 return $ellipsis; // convention
3314 } elseif ( strlen( $string ) <= abs( $length ) ) {
3315 return $string; // no need to truncate
3317 $stringOriginal = $string;
3318 # If ellipsis length is >= $length then we can't apply $adjustLength
3319 if ( $adjustLength && strlen( $ellipsis ) >= abs( $length ) ) {
3320 $string = $ellipsis; // this can be slightly unexpected
3321 # Otherwise, truncate and add ellipsis...
3322 } else {
3323 $eLength = $adjustLength ? strlen( $ellipsis ) : 0;
3324 if ( $length > 0 ) {
3325 $length -= $eLength;
3326 $string = substr( $string, 0, $length ); // xyz...
3327 $string = $this->removeBadCharLast( $string );
3328 $string = $string . $ellipsis;
3329 } else {
3330 $length += $eLength;
3331 $string = substr( $string, $length ); // ...xyz
3332 $string = $this->removeBadCharFirst( $string );
3333 $string = $ellipsis . $string;
3336 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3337 # This check is *not* redundant if $adjustLength, due to the single case where
3338 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3339 if ( strlen( $string ) < strlen( $stringOriginal ) ) {
3340 return $string;
3341 } else {
3342 return $stringOriginal;
3347 * Remove bytes that represent an incomplete Unicode character
3348 * at the end of string (e.g. bytes of the char are missing)
3350 * @param $string String
3351 * @return string
3353 protected function removeBadCharLast( $string ) {
3354 if ( $string != '' ) {
3355 $char = ord( $string[strlen( $string ) - 1] );
3356 $m = array();
3357 if ( $char >= 0xc0 ) {
3358 # We got the first byte only of a multibyte char; remove it.
3359 $string = substr( $string, 0, -1 );
3360 } elseif ( $char >= 0x80 &&
3361 preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
3362 '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m )
3364 # We chopped in the middle of a character; remove it
3365 $string = $m[1];
3368 return $string;
3372 * Remove bytes that represent an incomplete Unicode character
3373 * at the start of string (e.g. bytes of the char are missing)
3375 * @param $string String
3376 * @return string
3378 protected function removeBadCharFirst( $string ) {
3379 if ( $string != '' ) {
3380 $char = ord( $string[0] );
3381 if ( $char >= 0x80 && $char < 0xc0 ) {
3382 # We chopped in the middle of a character; remove the whole thing
3383 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
3386 return $string;
3390 * Truncate a string of valid HTML to a specified length in bytes,
3391 * appending an optional string (e.g. for ellipses), and return valid HTML
3393 * This is only intended for styled/linked text, such as HTML with
3394 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3395 * Also, this will not detect things like "display:none" CSS.
3397 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3399 * @param string $text HTML string to truncate
3400 * @param int $length (zero/positive) Maximum length (including ellipses)
3401 * @param string $ellipsis String to append to the truncated text
3402 * @return string
3404 function truncateHtml( $text, $length, $ellipsis = '...' ) {
3405 # Use the localized ellipsis character
3406 if ( $ellipsis == '...' ) {
3407 $ellipsis = wfMessage( 'ellipsis' )->inLanguage( $this )->escaped();
3409 # Check if there is clearly no need to truncate
3410 if ( $length <= 0 ) {
3411 return $ellipsis; // no text shown, nothing to format (convention)
3412 } elseif ( strlen( $text ) <= $length ) {
3413 return $text; // string short enough even *with* HTML (short-circuit)
3416 $dispLen = 0; // innerHTML legth so far
3417 $testingEllipsis = false; // checking if ellipses will make string longer/equal?
3418 $tagType = 0; // 0-open, 1-close
3419 $bracketState = 0; // 1-tag start, 2-tag name, 0-neither
3420 $entityState = 0; // 0-not entity, 1-entity
3421 $tag = $ret = ''; // accumulated tag name, accumulated result string
3422 $openTags = array(); // open tag stack
3423 $maybeState = null; // possible truncation state
3425 $textLen = strlen( $text );
3426 $neLength = max( 0, $length - strlen( $ellipsis ) ); // non-ellipsis len if truncated
3427 for ( $pos = 0; true; ++$pos ) {
3428 # Consider truncation once the display length has reached the maximim.
3429 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3430 # Check that we're not in the middle of a bracket/entity...
3431 if ( $dispLen && $dispLen >= $neLength && $bracketState == 0 && !$entityState ) {
3432 if ( !$testingEllipsis ) {
3433 $testingEllipsis = true;
3434 # Save where we are; we will truncate here unless there turn out to
3435 # be so few remaining characters that truncation is not necessary.
3436 if ( !$maybeState ) { // already saved? ($neLength = 0 case)
3437 $maybeState = array( $ret, $openTags ); // save state
3439 } elseif ( $dispLen > $length && $dispLen > strlen( $ellipsis ) ) {
3440 # String in fact does need truncation, the truncation point was OK.
3441 list( $ret, $openTags ) = $maybeState; // reload state
3442 $ret = $this->removeBadCharLast( $ret ); // multi-byte char fix
3443 $ret .= $ellipsis; // add ellipsis
3444 break;
3447 if ( $pos >= $textLen ) {
3448 break; // extra iteration just for above checks
3451 # Read the next char...
3452 $ch = $text[$pos];
3453 $lastCh = $pos ? $text[$pos - 1] : '';
3454 $ret .= $ch; // add to result string
3455 if ( $ch == '<' ) {
3456 $this->truncate_endBracket( $tag, $tagType, $lastCh, $openTags ); // for bad HTML
3457 $entityState = 0; // for bad HTML
3458 $bracketState = 1; // tag started (checking for backslash)
3459 } elseif ( $ch == '>' ) {
3460 $this->truncate_endBracket( $tag, $tagType, $lastCh, $openTags );
3461 $entityState = 0; // for bad HTML
3462 $bracketState = 0; // out of brackets
3463 } elseif ( $bracketState == 1 ) {
3464 if ( $ch == '/' ) {
3465 $tagType = 1; // close tag (e.g. "</span>")
3466 } else {
3467 $tagType = 0; // open tag (e.g. "<span>")
3468 $tag .= $ch;
3470 $bracketState = 2; // building tag name
3471 } elseif ( $bracketState == 2 ) {
3472 if ( $ch != ' ' ) {
3473 $tag .= $ch;
3474 } else {
3475 // Name found (e.g. "<a href=..."), add on tag attributes...
3476 $pos += $this->truncate_skip( $ret, $text, "<>", $pos + 1 );
3478 } elseif ( $bracketState == 0 ) {
3479 if ( $entityState ) {
3480 if ( $ch == ';' ) {
3481 $entityState = 0;
3482 $dispLen++; // entity is one displayed char
3484 } else {
3485 if ( $neLength == 0 && !$maybeState ) {
3486 // Save state without $ch. We want to *hit* the first
3487 // display char (to get tags) but not *use* it if truncating.
3488 $maybeState = array( substr( $ret, 0, -1 ), $openTags );
3490 if ( $ch == '&' ) {
3491 $entityState = 1; // entity found, (e.g. "&#160;")
3492 } else {
3493 $dispLen++; // this char is displayed
3494 // Add the next $max display text chars after this in one swoop...
3495 $max = ( $testingEllipsis ? $length : $neLength ) - $dispLen;
3496 $skipped = $this->truncate_skip( $ret, $text, "<>&", $pos + 1, $max );
3497 $dispLen += $skipped;
3498 $pos += $skipped;
3503 // Close the last tag if left unclosed by bad HTML
3504 $this->truncate_endBracket( $tag, $text[$textLen - 1], $tagType, $openTags );
3505 while ( count( $openTags ) > 0 ) {
3506 $ret .= '</' . array_pop( $openTags ) . '>'; // close open tags
3508 return $ret;
3512 * truncateHtml() helper function
3513 * like strcspn() but adds the skipped chars to $ret
3515 * @param $ret
3516 * @param $text
3517 * @param $search
3518 * @param $start
3519 * @param $len
3520 * @return int
3522 private function truncate_skip( &$ret, $text, $search, $start, $len = null ) {
3523 if ( $len === null ) {
3524 $len = -1; // -1 means "no limit" for strcspn
3525 } elseif ( $len < 0 ) {
3526 $len = 0; // sanity
3528 $skipCount = 0;
3529 if ( $start < strlen( $text ) ) {
3530 $skipCount = strcspn( $text, $search, $start, $len );
3531 $ret .= substr( $text, $start, $skipCount );
3533 return $skipCount;
3537 * truncateHtml() helper function
3538 * (a) push or pop $tag from $openTags as needed
3539 * (b) clear $tag value
3540 * @param &$tag string Current HTML tag name we are looking at
3541 * @param $tagType int (0-open tag, 1-close tag)
3542 * @param $lastCh string Character before the '>' that ended this tag
3543 * @param &$openTags array Open tag stack (not accounting for $tag)
3545 private function truncate_endBracket( &$tag, $tagType, $lastCh, &$openTags ) {
3546 $tag = ltrim( $tag );
3547 if ( $tag != '' ) {
3548 if ( $tagType == 0 && $lastCh != '/' ) {
3549 $openTags[] = $tag; // tag opened (didn't close itself)
3550 } elseif ( $tagType == 1 ) {
3551 if ( $openTags && $tag == $openTags[count( $openTags ) - 1] ) {
3552 array_pop( $openTags ); // tag closed
3555 $tag = '';
3560 * Grammatical transformations, needed for inflected languages
3561 * Invoked by putting {{grammar:case|word}} in a message
3563 * @param $word string
3564 * @param $case string
3565 * @return string
3567 function convertGrammar( $word, $case ) {
3568 global $wgGrammarForms;
3569 if ( isset( $wgGrammarForms[$this->getCode()][$case][$word] ) ) {
3570 return $wgGrammarForms[$this->getCode()][$case][$word];
3572 return $word;
3575 * Get the grammar forms for the content language
3576 * @return array of grammar forms
3577 * @since 1.20
3579 function getGrammarForms() {
3580 global $wgGrammarForms;
3581 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3582 return $wgGrammarForms[$this->getCode()];
3584 return array();
3587 * Provides an alternative text depending on specified gender.
3588 * Usage {{gender:username|masculine|feminine|neutral}}.
3589 * username is optional, in which case the gender of current user is used,
3590 * but only in (some) interface messages; otherwise default gender is used.
3592 * If no forms are given, an empty string is returned. If only one form is
3593 * given, it will be returned unconditionally. These details are implied by
3594 * the caller and cannot be overridden in subclasses.
3596 * If more than one form is given, the default is to use the neutral one
3597 * if it is specified, and to use the masculine one otherwise. These
3598 * details can be overridden in subclasses.
3600 * @param $gender string
3601 * @param $forms array
3603 * @return string
3605 function gender( $gender, $forms ) {
3606 if ( !count( $forms ) ) {
3607 return '';
3609 $forms = $this->preConvertPlural( $forms, 2 );
3610 if ( $gender === 'male' ) {
3611 return $forms[0];
3613 if ( $gender === 'female' ) {
3614 return $forms[1];
3616 return isset( $forms[2] ) ? $forms[2] : $forms[0];
3620 * Plural form transformations, needed for some languages.
3621 * For example, there are 3 form of plural in Russian and Polish,
3622 * depending on "count mod 10". See [[w:Plural]]
3623 * For English it is pretty simple.
3625 * Invoked by putting {{plural:count|wordform1|wordform2}}
3626 * or {{plural:count|wordform1|wordform2|wordform3}}
3628 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3630 * @param $count Integer: non-localized number
3631 * @param $forms Array: different plural forms
3632 * @return string Correct form of plural for $count in this language
3634 function convertPlural( $count, $forms ) {
3635 // Handle explicit n=pluralform cases
3636 foreach ( $forms as $index => $form ) {
3637 if ( preg_match( '/^\d+=/i', $form ) ) {
3638 $pos = strpos( $form, '=' );
3639 if ( substr( $form, 0, $pos ) === (string)$count ) {
3640 return substr( $form, $pos + 1 );
3642 unset( $forms[$index] );
3646 $forms = array_values( $forms );
3647 if ( !count( $forms ) ) {
3648 return '';
3651 $pluralForm = $this->getPluralRuleIndexNumber( $count );
3652 $pluralForm = min( $pluralForm, count( $forms ) - 1 );
3653 return $forms[$pluralForm];
3657 * Checks that convertPlural was given an array and pads it to requested
3658 * amount of forms by copying the last one.
3660 * @param $count Integer: How many forms should there be at least
3661 * @param $forms Array of forms given to convertPlural
3662 * @return array Padded array of forms or an exception if not an array
3664 protected function preConvertPlural( /* Array */ $forms, $count ) {
3665 while ( count( $forms ) < $count ) {
3666 $forms[] = $forms[count( $forms ) - 1];
3668 return $forms;
3672 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3673 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3674 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3675 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3676 * match up with it.
3678 * @param $str String: the validated block duration in English
3679 * @return string Somehow translated block duration
3680 * @see LanguageFi.php for example implementation
3682 function translateBlockExpiry( $str ) {
3683 $duration = SpecialBlock::getSuggestedDurations( $this );
3684 foreach ( $duration as $show => $value ) {
3685 if ( strcmp( $str, $value ) == 0 ) {
3686 return htmlspecialchars( trim( $show ) );
3690 // Since usually only infinite or indefinite is only on list, so try
3691 // equivalents if still here.
3692 $indefs = array( 'infinite', 'infinity', 'indefinite' );
3693 if ( in_array( $str, $indefs ) ) {
3694 foreach ( $indefs as $val ) {
3695 $show = array_search( $val, $duration, true );
3696 if ( $show !== false ) {
3697 return htmlspecialchars( trim( $show ) );
3702 // If all else fails, return a standard duration or timestamp description.
3703 $time = strtotime( $str, 0 );
3704 if ( $time === false ) { // Unknown format. Return it as-is in case.
3705 return $str;
3706 } elseif ( $time !== strtotime( $str, 1 ) ) { // It's a relative timestamp.
3707 // $time is relative to 0 so it's a duration length.
3708 return $this->formatDuration( $time );
3709 } else { // It's an absolute timestamp.
3710 if ( $time === 0 ) {
3711 // wfTimestamp() handles 0 as current time instead of epoch.
3712 return $this->timeanddate( '19700101000000' );
3713 } else {
3714 return $this->timeanddate( $time );
3720 * languages like Chinese need to be segmented in order for the diff
3721 * to be of any use
3723 * @param $text String
3724 * @return String
3726 public function segmentForDiff( $text ) {
3727 return $text;
3731 * and unsegment to show the result
3733 * @param $text String
3734 * @return String
3736 public function unsegmentForDiff( $text ) {
3737 return $text;
3741 * Return the LanguageConverter used in the Language
3743 * @since 1.19
3744 * @return LanguageConverter
3746 public function getConverter() {
3747 return $this->mConverter;
3751 * convert text to all supported variants
3753 * @param $text string
3754 * @return array
3756 public function autoConvertToAllVariants( $text ) {
3757 return $this->mConverter->autoConvertToAllVariants( $text );
3761 * convert text to different variants of a language.
3763 * @param $text string
3764 * @return string
3766 public function convert( $text ) {
3767 return $this->mConverter->convert( $text );
3771 * Convert a Title object to a string in the preferred variant
3773 * @param $title Title
3774 * @return string
3776 public function convertTitle( $title ) {
3777 return $this->mConverter->convertTitle( $title );
3781 * Convert a namespace index to a string in the preferred variant
3783 * @param $ns int
3784 * @return string
3786 public function convertNamespace( $ns ) {
3787 return $this->mConverter->convertNamespace( $ns );
3791 * Check if this is a language with variants
3793 * @return bool
3795 public function hasVariants() {
3796 return count( $this->getVariants() ) > 1;
3800 * Check if the language has the specific variant
3802 * @since 1.19
3803 * @param $variant string
3804 * @return bool
3806 public function hasVariant( $variant ) {
3807 return (bool)$this->mConverter->validateVariant( $variant );
3811 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3813 * @param $text string
3814 * @return string
3815 * @deprecated since 1.22 is no longer used
3817 public function armourMath( $text ) {
3818 return $this->mConverter->armourMath( $text );
3822 * Perform output conversion on a string, and encode for safe HTML output.
3823 * @param $text String text to be converted
3824 * @param $isTitle Bool whether this conversion is for the article title
3825 * @return string
3826 * @todo this should get integrated somewhere sane
3828 public function convertHtml( $text, $isTitle = false ) {
3829 return htmlspecialchars( $this->convert( $text, $isTitle ) );
3833 * @param $key string
3834 * @return string
3836 public function convertCategoryKey( $key ) {
3837 return $this->mConverter->convertCategoryKey( $key );
3841 * Get the list of variants supported by this language
3842 * see sample implementation in LanguageZh.php
3844 * @return array an array of language codes
3846 public function getVariants() {
3847 return $this->mConverter->getVariants();
3851 * @return string
3853 public function getPreferredVariant() {
3854 return $this->mConverter->getPreferredVariant();
3858 * @return string
3860 public function getDefaultVariant() {
3861 return $this->mConverter->getDefaultVariant();
3865 * @return string
3867 public function getURLVariant() {
3868 return $this->mConverter->getURLVariant();
3872 * If a language supports multiple variants, it is
3873 * possible that non-existing link in one variant
3874 * actually exists in another variant. this function
3875 * tries to find it. See e.g. LanguageZh.php
3877 * @param $link String: the name of the link
3878 * @param $nt Mixed: the title object of the link
3879 * @param $ignoreOtherCond Boolean: to disable other conditions when
3880 * we need to transclude a template or update a category's link
3881 * @return null the input parameters may be modified upon return
3883 public function findVariantLink( &$link, &$nt, $ignoreOtherCond = false ) {
3884 $this->mConverter->findVariantLink( $link, $nt, $ignoreOtherCond );
3888 * If a language supports multiple variants, converts text
3889 * into an array of all possible variants of the text:
3890 * 'variant' => text in that variant
3892 * @deprecated since 1.17 Use autoConvertToAllVariants()
3894 * @param $text string
3896 * @return string
3898 public function convertLinkToAllVariants( $text ) {
3899 return $this->mConverter->convertLinkToAllVariants( $text );
3903 * returns language specific options used by User::getPageRenderHash()
3904 * for example, the preferred language variant
3906 * @return string
3908 function getExtraHashOptions() {
3909 return $this->mConverter->getExtraHashOptions();
3913 * For languages that support multiple variants, the title of an
3914 * article may be displayed differently in different variants. this
3915 * function returns the apporiate title defined in the body of the article.
3917 * @return string
3919 public function getParsedTitle() {
3920 return $this->mConverter->getParsedTitle();
3924 * Prepare external link text for conversion. When the text is
3925 * a URL, it shouldn't be converted, and it'll be wrapped in
3926 * the "raw" tag (-{R| }-) to prevent conversion.
3928 * This function is called "markNoConversion" for historical
3929 * reasons.
3931 * @param $text String: text to be used for external link
3932 * @param $noParse bool: wrap it without confirming it's a real URL first
3933 * @return string the tagged text
3935 public function markNoConversion( $text, $noParse = false ) {
3936 // Excluding protocal-relative URLs may avoid many false positives.
3937 if ( $noParse || preg_match( '/^(?:' . wfUrlProtocolsWithoutProtRel() . ')/', $text ) ) {
3938 return $this->mConverter->markNoConversion( $text );
3939 } else {
3940 return $text;
3945 * A regular expression to match legal word-trailing characters
3946 * which should be merged onto a link of the form [[foo]]bar.
3948 * @return string
3950 public function linkTrail() {
3951 return self::$dataCache->getItem( $this->mCode, 'linkTrail' );
3955 * A regular expression character set to match legal word-prefixing
3956 * characters which should be merged onto a link of the form foo[[bar]].
3958 * @return string
3960 public function linkPrefixCharset() {
3961 return self::$dataCache->getItem( $this->mCode, 'linkPrefixCharset' );
3965 * @return Language
3967 function getLangObj() {
3968 return $this;
3972 * Get the "parent" language which has a converter to convert a "compatible" language
3973 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
3975 * @return Language|null
3976 * @since 1.22
3978 public function getParentLanguage() {
3979 if ( $this->mParentLanguage !== false ) {
3980 return $this->mParentLanguage;
3983 $pieces = explode( '-', $this->getCode() );
3984 $code = $pieces[0];
3985 if ( !in_array( $code, LanguageConverter::$languagesWithVariants ) ) {
3986 $this->mParentLanguage = null;
3987 return null;
3989 $lang = Language::factory( $code );
3990 if ( !$lang->hasVariant( $this->getCode() ) ) {
3991 $this->mParentLanguage = null;
3992 return null;
3995 $this->mParentLanguage = $lang;
3996 return $lang;
4000 * Get the RFC 3066 code for this language object
4002 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4003 * htmlspecialchars() or similar
4005 * @return string
4007 public function getCode() {
4008 return $this->mCode;
4012 * Get the code in Bcp47 format which we can use
4013 * inside of html lang="" tags.
4015 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4016 * htmlspecialchars() or similar.
4018 * @since 1.19
4019 * @return string
4021 public function getHtmlCode() {
4022 if ( is_null( $this->mHtmlCode ) ) {
4023 $this->mHtmlCode = wfBCP47( $this->getCode() );
4025 return $this->mHtmlCode;
4029 * @param $code string
4031 public function setCode( $code ) {
4032 $this->mCode = $code;
4033 // Ensure we don't leave incorrect cached data lying around
4034 $this->mHtmlCode = null;
4035 $this->mParentLanguage = false;
4039 * Get the name of a file for a certain language code
4040 * @param $prefix string Prepend this to the filename
4041 * @param $code string Language code
4042 * @param $suffix string Append this to the filename
4043 * @throws MWException
4044 * @return string $prefix . $mangledCode . $suffix
4046 public static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
4047 // Protect against path traversal
4048 if ( !Language::isValidCode( $code )
4049 || strcspn( $code, ":/\\\000" ) !== strlen( $code ) )
4051 throw new MWException( "Invalid language code \"$code\"" );
4054 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
4058 * Get the language code from a file name. Inverse of getFileName()
4059 * @param $filename string $prefix . $languageCode . $suffix
4060 * @param $prefix string Prefix before the language code
4061 * @param $suffix string Suffix after the language code
4062 * @return string Language code, or false if $prefix or $suffix isn't found
4064 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4065 $m = null;
4066 preg_match( '/' . preg_quote( $prefix, '/' ) . '([A-Z][a-z_]+)' .
4067 preg_quote( $suffix, '/' ) . '/', $filename, $m );
4068 if ( !count( $m ) ) {
4069 return false;
4071 return str_replace( '_', '-', strtolower( $m[1] ) );
4075 * @param $code string
4076 * @return string
4078 public static function getMessagesFileName( $code ) {
4079 global $IP;
4080 $file = self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
4081 wfRunHooks( 'Language::getMessagesFileName', array( $code, &$file ) );
4082 return $file;
4086 * @param $code string
4087 * @return string
4089 public static function getClassFileName( $code ) {
4090 global $IP;
4091 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
4095 * Get the first fallback for a given language.
4097 * @param $code string
4099 * @return bool|string
4101 public static function getFallbackFor( $code ) {
4102 if ( $code === 'en' || !Language::isValidBuiltInCode( $code ) ) {
4103 return false;
4104 } else {
4105 $fallbacks = self::getFallbacksFor( $code );
4106 $first = array_shift( $fallbacks );
4107 return $first;
4112 * Get the ordered list of fallback languages.
4114 * @since 1.19
4115 * @param $code string Language code
4116 * @return array
4118 public static function getFallbacksFor( $code ) {
4119 if ( $code === 'en' || !Language::isValidBuiltInCode( $code ) ) {
4120 return array();
4121 } else {
4122 $v = self::getLocalisationCache()->getItem( $code, 'fallback' );
4123 $v = array_map( 'trim', explode( ',', $v ) );
4124 if ( $v[count( $v ) - 1] !== 'en' ) {
4125 $v[] = 'en';
4127 return $v;
4132 * Get the ordered list of fallback languages, ending with the fallback
4133 * language chain for the site language.
4135 * @since 1.22
4136 * @param string $code Language code
4137 * @return array array( fallbacks, site fallbacks )
4139 public static function getFallbacksIncludingSiteLanguage( $code ) {
4140 global $wgLanguageCode;
4142 // Usually, we will only store a tiny number of fallback chains, so we
4143 // keep them in static memory.
4144 $cacheKey = "{$code}-{$wgLanguageCode}";
4146 if ( !array_key_exists( $cacheKey, self::$fallbackLanguageCache ) ) {
4147 $fallbacks = self::getFallbacksFor( $code );
4149 // Append the site's fallback chain, including the site language itself
4150 $siteFallbacks = self::getFallbacksFor( $wgLanguageCode );
4151 array_unshift( $siteFallbacks, $wgLanguageCode );
4153 // Eliminate any languages already included in the chain
4154 $siteFallbacks = array_diff( $siteFallbacks, $fallbacks );
4156 self::$fallbackLanguageCache[$cacheKey] = array( $fallbacks, $siteFallbacks );
4158 return self::$fallbackLanguageCache[$cacheKey];
4162 * Get all messages for a given language
4163 * WARNING: this may take a long time. If you just need all message *keys*
4164 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4166 * @param $code string
4168 * @return array
4170 public static function getMessagesFor( $code ) {
4171 return self::getLocalisationCache()->getItem( $code, 'messages' );
4175 * Get a message for a given language
4177 * @param $key string
4178 * @param $code string
4180 * @return string
4182 public static function getMessageFor( $key, $code ) {
4183 return self::getLocalisationCache()->getSubitem( $code, 'messages', $key );
4187 * Get all message keys for a given language. This is a faster alternative to
4188 * array_keys( Language::getMessagesFor( $code ) )
4190 * @since 1.19
4191 * @param $code string Language code
4192 * @return array of message keys (strings)
4194 public static function getMessageKeysFor( $code ) {
4195 return self::getLocalisationCache()->getSubItemList( $code, 'messages' );
4199 * @param $talk
4200 * @return mixed
4202 function fixVariableInNamespace( $talk ) {
4203 if ( strpos( $talk, '$1' ) === false ) {
4204 return $talk;
4207 global $wgMetaNamespace;
4208 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
4210 # Allow grammar transformations
4211 # Allowing full message-style parsing would make simple requests
4212 # such as action=raw much more expensive than they need to be.
4213 # This will hopefully cover most cases.
4214 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
4215 array( &$this, 'replaceGrammarInNamespace' ), $talk );
4216 return str_replace( ' ', '_', $talk );
4220 * @param $m string
4221 * @return string
4223 function replaceGrammarInNamespace( $m ) {
4224 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
4228 * @throws MWException
4229 * @return array
4231 static function getCaseMaps() {
4232 static $wikiUpperChars, $wikiLowerChars;
4233 if ( isset( $wikiUpperChars ) ) {
4234 return array( $wikiUpperChars, $wikiLowerChars );
4237 wfProfileIn( __METHOD__ );
4238 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
4239 if ( $arr === false ) {
4240 throw new MWException(
4241 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
4243 $wikiUpperChars = $arr['wikiUpperChars'];
4244 $wikiLowerChars = $arr['wikiLowerChars'];
4245 wfProfileOut( __METHOD__ );
4246 return array( $wikiUpperChars, $wikiLowerChars );
4250 * Decode an expiry (block, protection, etc) which has come from the DB
4252 * @todo FIXME: why are we returnings DBMS-dependent strings???
4254 * @param $expiry String: Database expiry String
4255 * @param $format Bool|Int true to process using language functions, or TS_ constant
4256 * to return the expiry in a given timestamp
4257 * @return String
4258 * @since 1.18
4260 public function formatExpiry( $expiry, $format = true ) {
4261 static $infinity;
4262 if ( $infinity === null ) {
4263 $infinity = wfGetDB( DB_SLAVE )->getInfinity();
4266 if ( $expiry == '' || $expiry == $infinity ) {
4267 return $format === true
4268 ? $this->getMessageFromDB( 'infiniteblock' )
4269 : $infinity;
4270 } else {
4271 return $format === true
4272 ? $this->timeanddate( $expiry, /* User preference timezone */ true )
4273 : wfTimestamp( $format, $expiry );
4278 * @todo Document
4279 * @param $seconds int|float
4280 * @param $format Array Optional
4281 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4282 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4283 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4284 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4285 * @return string
4287 function formatTimePeriod( $seconds, $format = array() ) {
4288 if ( !is_array( $format ) ) {
4289 $format = array( 'avoid' => $format ); // For backwards compatibility
4291 if ( !isset( $format['avoid'] ) ) {
4292 $format['avoid'] = false;
4294 if ( !isset( $format['noabbrevs' ] ) ) {
4295 $format['noabbrevs'] = false;
4297 $secondsMsg = wfMessage(
4298 $format['noabbrevs'] ? 'seconds' : 'seconds-abbrev' )->inLanguage( $this );
4299 $minutesMsg = wfMessage(
4300 $format['noabbrevs'] ? 'minutes' : 'minutes-abbrev' )->inLanguage( $this );
4301 $hoursMsg = wfMessage(
4302 $format['noabbrevs'] ? 'hours' : 'hours-abbrev' )->inLanguage( $this );
4303 $daysMsg = wfMessage(
4304 $format['noabbrevs'] ? 'days' : 'days-abbrev' )->inLanguage( $this );
4306 if ( round( $seconds * 10 ) < 100 ) {
4307 $s = $this->formatNum( sprintf( "%.1f", round( $seconds * 10 ) / 10 ) );
4308 $s = $secondsMsg->params( $s )->text();
4309 } elseif ( round( $seconds ) < 60 ) {
4310 $s = $this->formatNum( round( $seconds ) );
4311 $s = $secondsMsg->params( $s )->text();
4312 } elseif ( round( $seconds ) < 3600 ) {
4313 $minutes = floor( $seconds / 60 );
4314 $secondsPart = round( fmod( $seconds, 60 ) );
4315 if ( $secondsPart == 60 ) {
4316 $secondsPart = 0;
4317 $minutes++;
4319 $s = $minutesMsg->params( $this->formatNum( $minutes ) )->text();
4320 $s .= ' ';
4321 $s .= $secondsMsg->params( $this->formatNum( $secondsPart ) )->text();
4322 } elseif ( round( $seconds ) <= 2 * 86400 ) {
4323 $hours = floor( $seconds / 3600 );
4324 $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
4325 $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
4326 if ( $secondsPart == 60 ) {
4327 $secondsPart = 0;
4328 $minutes++;
4330 if ( $minutes == 60 ) {
4331 $minutes = 0;
4332 $hours++;
4334 $s = $hoursMsg->params( $this->formatNum( $hours ) )->text();
4335 $s .= ' ';
4336 $s .= $minutesMsg->params( $this->formatNum( $minutes ) )->text();
4337 if ( !in_array( $format['avoid'], array( 'avoidseconds', 'avoidminutes' ) ) ) {
4338 $s .= ' ' . $secondsMsg->params( $this->formatNum( $secondsPart ) )->text();
4340 } else {
4341 $days = floor( $seconds / 86400 );
4342 if ( $format['avoid'] === 'avoidminutes' ) {
4343 $hours = round( ( $seconds - $days * 86400 ) / 3600 );
4344 if ( $hours == 24 ) {
4345 $hours = 0;
4346 $days++;
4348 $s = $daysMsg->params( $this->formatNum( $days ) )->text();
4349 $s .= ' ';
4350 $s .= $hoursMsg->params( $this->formatNum( $hours ) )->text();
4351 } elseif ( $format['avoid'] === 'avoidseconds' ) {
4352 $hours = floor( ( $seconds - $days * 86400 ) / 3600 );
4353 $minutes = round( ( $seconds - $days * 86400 - $hours * 3600 ) / 60 );
4354 if ( $minutes == 60 ) {
4355 $minutes = 0;
4356 $hours++;
4358 if ( $hours == 24 ) {
4359 $hours = 0;
4360 $days++;
4362 $s = $daysMsg->params( $this->formatNum( $days ) )->text();
4363 $s .= ' ';
4364 $s .= $hoursMsg->params( $this->formatNum( $hours ) )->text();
4365 $s .= ' ';
4366 $s .= $minutesMsg->params( $this->formatNum( $minutes ) )->text();
4367 } else {
4368 $s = $daysMsg->params( $this->formatNum( $days ) )->text();
4369 $s .= ' ';
4370 $s .= $this->formatTimePeriod( $seconds - $days * 86400, $format );
4373 return $s;
4377 * Format a bitrate for output, using an appropriate
4378 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4380 * This use base 1000. For base 1024 use formatSize(), for another base
4381 * see formatComputingNumbers()
4383 * @param $bps int
4384 * @return string
4386 function formatBitrate( $bps ) {
4387 return $this->formatComputingNumbers( $bps, 1000, "bitrate-$1bits" );
4391 * @param $size int Size of the unit
4392 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4393 * @param $messageKey string Message key to be uesd
4394 * @return string
4396 function formatComputingNumbers( $size, $boundary, $messageKey ) {
4397 if ( $size <= 0 ) {
4398 return str_replace( '$1', $this->formatNum( $size ),
4399 $this->getMessageFromDB( str_replace( '$1', '', $messageKey ) )
4402 $sizes = array( '', 'kilo', 'mega', 'giga', 'tera', 'peta', 'exa', 'zeta', 'yotta' );
4403 $index = 0;
4405 $maxIndex = count( $sizes ) - 1;
4406 while ( $size >= $boundary && $index < $maxIndex ) {
4407 $index++;
4408 $size /= $boundary;
4411 // For small sizes no decimal places necessary
4412 $round = 0;
4413 if ( $index > 1 ) {
4414 // For MB and bigger two decimal places are smarter
4415 $round = 2;
4417 $msg = str_replace( '$1', $sizes[$index], $messageKey );
4419 $size = round( $size, $round );
4420 $text = $this->getMessageFromDB( $msg );
4421 return str_replace( '$1', $this->formatNum( $size ), $text );
4425 * Format a size in bytes for output, using an appropriate
4426 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4428 * This method use base 1024. For base 1000 use formatBitrate(), for
4429 * another base see formatComputingNumbers()
4431 * @param $size int Size to format
4432 * @return string Plain text (not HTML)
4434 function formatSize( $size ) {
4435 return $this->formatComputingNumbers( $size, 1024, "size-$1bytes" );
4439 * Make a list item, used by various special pages
4441 * @param $page String Page link
4442 * @param $details String Text between brackets
4443 * @param $oppositedm Boolean Add the direction mark opposite to your
4444 * language, to display text properly
4445 * @return String
4447 function specialList( $page, $details, $oppositedm = true ) {
4448 $dirmark = ( $oppositedm ? $this->getDirMark( true ) : '' ) .
4449 $this->getDirMark();
4450 $details = $details ? $dirmark . $this->getMessageFromDB( 'word-separator' ) .
4451 wfMessage( 'parentheses' )->rawParams( $details )->inLanguage( $this )->escaped() : '';
4452 return $page . $details;
4456 * Generate (prev x| next x) (20|50|100...) type links for paging
4458 * @param $title Title object to link
4459 * @param $offset Integer offset parameter
4460 * @param $limit Integer limit parameter
4461 * @param $query array|String optional URL query parameter string
4462 * @param $atend Bool optional param for specified if this is the last page
4463 * @return String
4465 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4466 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4468 # Make 'previous' link
4469 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4470 if ( $offset > 0 ) {
4471 $plink = $this->numLink( $title, max( $offset - $limit, 0 ), $limit,
4472 $query, $prev, 'prevn-title', 'mw-prevlink' );
4473 } else {
4474 $plink = htmlspecialchars( $prev );
4477 # Make 'next' link
4478 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4479 if ( $atend ) {
4480 $nlink = htmlspecialchars( $next );
4481 } else {
4482 $nlink = $this->numLink( $title, $offset + $limit, $limit,
4483 $query, $next, 'nextn-title', 'mw-nextlink' );
4486 # Make links to set number of items per page
4487 $numLinks = array();
4488 foreach ( array( 20, 50, 100, 250, 500 ) as $num ) {
4489 $numLinks[] = $this->numLink( $title, $offset, $num,
4490 $query, $this->formatNum( $num ), 'shown-title', 'mw-numlink' );
4493 return wfMessage( 'viewprevnext' )->inLanguage( $this )->title( $title
4494 )->rawParams( $plink, $nlink, $this->pipeList( $numLinks ) )->escaped();
4498 * Helper function for viewPrevNext() that generates links
4500 * @param $title Title object to link
4501 * @param $offset Integer offset parameter
4502 * @param $limit Integer limit parameter
4503 * @param $query Array extra query parameters
4504 * @param $link String text to use for the link; will be escaped
4505 * @param $tooltipMsg String name of the message to use as tooltip
4506 * @param $class String value of the "class" attribute of the link
4507 * @return String HTML fragment
4509 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4510 $query = array( 'limit' => $limit, 'offset' => $offset ) + $query;
4511 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4512 return Html::element( 'a', array( 'href' => $title->getLocalURL( $query ),
4513 'title' => $tooltip, 'class' => $class ), $link );
4517 * Get the conversion rule title, if any.
4519 * @return string
4521 public function getConvRuleTitle() {
4522 return $this->mConverter->getConvRuleTitle();
4526 * Get the compiled plural rules for the language
4527 * @since 1.20
4528 * @return array Associative array with plural form, and plural rule as key-value pairs
4530 public function getCompiledPluralRules() {
4531 $pluralRules = self::$dataCache->getItem( strtolower( $this->mCode ), 'compiledPluralRules' );
4532 $fallbacks = Language::getFallbacksFor( $this->mCode );
4533 if ( !$pluralRules ) {
4534 foreach ( $fallbacks as $fallbackCode ) {
4535 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4536 if ( $pluralRules ) {
4537 break;
4541 return $pluralRules;
4545 * Get the plural rules for the language
4546 * @since 1.20
4547 * @return array Associative array with plural form number and plural rule as key-value pairs
4549 public function getPluralRules() {
4550 $pluralRules = self::$dataCache->getItem( strtolower( $this->mCode ), 'pluralRules' );
4551 $fallbacks = Language::getFallbacksFor( $this->mCode );
4552 if ( !$pluralRules ) {
4553 foreach ( $fallbacks as $fallbackCode ) {
4554 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRules' );
4555 if ( $pluralRules ) {
4556 break;
4560 return $pluralRules;
4564 * Get the plural rule types for the language
4565 * @since 1.22
4566 * @return array Associative array with plural form number and plural rule type as key-value pairs
4568 public function getPluralRuleTypes() {
4569 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $this->mCode ), 'pluralRuleTypes' );
4570 $fallbacks = Language::getFallbacksFor( $this->mCode );
4571 if ( !$pluralRuleTypes ) {
4572 foreach ( $fallbacks as $fallbackCode ) {
4573 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4574 if ( $pluralRuleTypes ) {
4575 break;
4579 return $pluralRuleTypes;
4583 * Find the index number of the plural rule appropriate for the given number
4584 * @return int The index number of the plural rule
4586 public function getPluralRuleIndexNumber( $number ) {
4587 $pluralRules = $this->getCompiledPluralRules();
4588 $form = CLDRPluralRuleEvaluator::evaluateCompiled( $number, $pluralRules );
4589 return $form;
4593 * Find the plural rule type appropriate for the given number
4594 * For example, if the language is set to Arabic, getPluralType(5) should
4595 * return 'few'.
4596 * @since 1.22
4597 * @return string The name of the plural rule type, e.g. one, two, few, many
4599 public function getPluralRuleType( $number ) {
4600 $index = $this->getPluralRuleIndexNumber( $number );
4601 $pluralRuleTypes = $this->getPluralRuleTypes();
4602 if ( isset( $pluralRuleTypes[$index] ) ) {
4603 return $pluralRuleTypes[$index];
4604 } else {
4605 return 'other';