dépôts / lhc / web / wiklou.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge "Fix TOC display for printing"
[lhc/web/wiklou.git] / languages / Language.php
1 <?php
2 /**
3 * Internationalisation code.
4 *
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.
9 *
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.
14 *
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
19 *
20 * @file
21 * @ingroup Language
22 */
23
24 /**
25 * @defgroup Language Language
26 */
27
28 if ( !defined( 'MEDIAWIKI' ) ) {
29 echo "This file is part of MediaWiki, it is not a valid entry point.\n";
30 exit( 1 );
31 }
32
33 if ( function_exists( 'mb_strtoupper' ) ) {
34 mb_internal_encoding( 'UTF-8' );
35 }
36
37 /**
38 * a fake language converter
39 *
40 * @ingroup Language
41 */
42 class FakeConverter {
43 /**
44 * @var Language
45 */
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; }
70 }
71
72 /**
73 * Internationalisation code
74 * @ingroup Language
75 */
76 class Language {
77
78 /**
79 * @var LanguageConverter
80 */
81 public $mConverter;
82
83 public $mVariants, $mCode, $mLoaded = false;
84 public $mMagicExtensions = array(), $mMagicHookDone = false;
85 private $mHtmlCode = null, $mParentLanguage = false;
86
87 public $dateFormatStrings = array();
88 public $mExtendedSpecialPageAliases;
89
90 protected $namespaceNames, $mNamespaceIds, $namespaceAliases;
91
92 /**
93 * ReplacementArray object caches
94 */
95 public $transformData = array();
96
97 /**
98 * @var LocalisationCache
99 */
100 static public $dataCache;
101
102 static public $mLangObjCache = array();
103
104 static public $mWeekdayMsgs = array(
105 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
106 'friday', 'saturday'
107 );
108
109 static public $mWeekdayAbbrevMsgs = array(
110 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'
111 );
112
113 static public $mMonthMsgs = array(
114 'january', 'february', 'march', 'april', 'may_long', 'june',
115 'july', 'august', 'september', 'october', 'november',
116 'december'
117 );
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'
122 );
123 static public $mMonthAbbrevMsgs = array(
124 'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
125 'sep', 'oct', 'nov', 'dec'
126 );
127
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'
133 );
134
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'
141 );
142
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'
149 );
150
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'
156 );
157
158 /**
159 * @since 1.20
160 * @var array
161 */
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,
172 );
173
174 /**
175 * Cache for language fallbacks.
176 * @see Language::getFallbacksIncludingSiteLanguage
177 * @since 1.21
178 * @var array
179 */
180 static private $fallbackLanguageCache = array();
181
182 /**
183 * Get a cached or new language object for a given language code
184 * @param $code String
185 * @return Language
186 */
187 static function factory( $code ) {
188 global $wgDummyLanguageCodes, $wgLangObjCacheSize;
189
190 if ( isset( $wgDummyLanguageCodes[$code] ) ) {
191 $code = $wgDummyLanguageCodes[$code];
192 }
193
194 // get the language object to process
195 $langObj = isset( self::$mLangObjCache[$code] )
196 ? self::$mLangObjCache[$code]
197 : self::newFromCode( $code );
198
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 );
203
204 return $langObj;
205 }
206
207 /**
208 * Create a language object for a given language code
209 * @param $code String
210 * @throws MWException
211 * @return Language
212 */
213 protected static function newFromCode( $code ) {
214 // Protect against path traversal below
215 if ( !Language::isValidCode( $code )
216 || strcspn( $code, ":/\\\000" ) !== strlen( $code )
217 ) {
218 throw new MWException( "Invalid language code \"$code\"" );
219 }
220
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;
227 }
228
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;
235 }
236
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'" );
242 }
243
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;
250 }
251 }
252
253 throw new MWException( "Invalid fallback sequence for language '$code'" );
254 }
255
256 /**
257 * Checks whether any localisation is available for that language tag
258 * in MediaWiki (MessagesXx.php exists).
259 *
260 * @param string $code Language tag (in lower case)
261 * @return bool Whether language is supported
262 * @since 1.21
263 */
264 public static function isSupportedLanguage( $code ) {
265 return $code === strtolower( $code ) && is_readable( self::getMessagesFileName( $code ) );
266 }
267
268 /**
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.
273 *
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
276 *
277 * @param $code string
278 * @param $lenient boolean Whether to allow '_' as separator. The default is only '-'.
279 *
280 * @return bool
281 * @since 1.21
282 */
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 ? '[-_]' : '-';
290
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})+";
297
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
303
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";
309
310 $variantList = "$variant(?:$s$variant)*";
311 $extensionList = "$extension(?:$s$extension)*";
312
313 $langtag = "(?:($language)"
314 . "(?:$s$script)?"
315 . "(?:$s$region)?"
316 . "(?:$s$variantList)?"
317 . "(?:$s$extensionList)?"
318 . "(?:$s$privateUse)?)";
319
320 # The final breakdown, with capturing groups for each of these components
321 # The variants, extensions, grandfathered, and private-use may have interior '-'
322
323 $root = "^(?:$langtag|$privateUse|$grandfathered)$";
324
325 return (bool)preg_match( "/$root/", strtolower( $code ) );
326 }
327
328 /**
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.
332 *
333 * @param $code string
334 *
335 * @return bool
336 */
337 public static function isValidCode( $code ) {
338 static $cache = array();
339 if ( isset( $cache[$code] ) ) {
340 return $cache[$code];
341 }
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 );
349
350 return $cache[$code];
351 }
352
353 /**
354 * Returns true if a language code is of a valid form for the purposes of
355 * internal customisation of MediaWiki, via Messages*.php.
356 *
357 * @param $code string
358 *
359 * @throws MWException
360 * @since 1.18
361 * @return bool
362 */
363 public static function isValidBuiltInCode( $code ) {
364
365 if ( !is_string( $code ) ) {
366 if ( is_object( $code ) ) {
367 $addmsg = " of class " . get_class( $code );
368 } else {
369 $addmsg = '';
370 }
371 $type = gettype( $code );
372 throw new MWException( __METHOD__ . " must be passed a string, $type given$addmsg" );
373 }
374
375 return (bool)preg_match( '/^[a-z0-9-]{2,}$/i', $code );
376 }
377
378 /**
379 * Returns true if a language code is an IETF tag known to MediaWiki.
380 *
381 * @param $code string
382 *
383 * @since 1.21
384 * @return bool
385 */
386 public static function isKnownLanguageTag( $tag ) {
387 static $coreLanguageNames;
388
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;
393 }
394
395 if ( $coreLanguageNames === null ) {
396 global $IP;
397 include "$IP/languages/Names.php";
398 }
399
400 if ( isset( $coreLanguageNames[$tag] )
401 || self::fetchLanguageName( $tag, $tag ) !== ''
402 ) {
403 return true;
404 }
405
406 return false;
407 }
408
409 /**
410 * @param $code
411 * @return String Name of the language class
412 */
413 public static function classFromCode( $code ) {
414 if ( $code == 'en' ) {
415 return 'Language';
416 } else {
417 return 'Language' . str_replace( '-', '_', ucfirst( $code ) );
418 }
419 }
420
421 /**
422 * Includes language class files
423 *
424 * @param $class string Name of the language class
425 */
426 public static function preloadLanguageClass( $class ) {
427 global $IP;
428
429 if ( $class === 'Language' ) {
430 return;
431 }
432
433 if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
434 include_once "$IP/languages/classes/$class.php";
435 }
436 }
437
438 /**
439 * Get the LocalisationCache instance
440 *
441 * @return LocalisationCache
442 */
443 public static function getLocalisationCache() {
444 if ( is_null( self::$dataCache ) ) {
445 global $wgLocalisationCacheConf;
446 $class = $wgLocalisationCacheConf['class'];
447 self::$dataCache = new $class( $wgLocalisationCacheConf );
448 }
449 return self::$dataCache;
450 }
451
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 ) ) );
459 }
460 self::getLocalisationCache();
461 }
462
463 /**
464 * Reduce memory usage
465 */
466 function __destruct() {
467 foreach ( $this as $name => $value ) {
468 unset( $this->$name );
469 }
470 }
471
472 /**
473 * Hook which will be called if this is the content language.
474 * Descendants can use this to register hook functions or modify globals
475 */
476 function initContLang() { }
477
478 /**
479 * Same as getFallbacksFor for current language.
480 * @return array|bool
481 * @deprecated in 1.19
482 */
483 function getFallbackLanguageCode() {
484 wfDeprecated( __METHOD__, '1.19' );
485 return self::getFallbackFor( $this->mCode );
486 }
487
488 /**
489 * @return array
490 * @since 1.19
491 */
492 function getFallbackLanguages() {
493 return self::getFallbacksFor( $this->mCode );
494 }
495
496 /**
497 * Exports $wgBookstoreListEn
498 * @return array
499 */
500 function getBookstoreList() {
501 return self::$dataCache->getItem( $this->mCode, 'bookstoreList' );
502 }
503
504 /**
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.
507 *
508 * @return array
509 */
510 public function getNamespaces() {
511 if ( is_null( $this->namespaceNames ) ) {
512 global $wgMetaNamespace, $wgMetaNamespaceTalk, $wgExtraNamespaces;
513
514 $this->namespaceNames = self::$dataCache->getItem( $this->mCode, 'namespaceNames' );
515 $validNamespaces = MWNamespace::getCanonicalNamespaces();
516
517 $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames + $validNamespaces;
518
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 );
526 }
527
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] );
532 }
533 }
534
535 # The above mixing may leave namespaces out of canonical order.
536 # Re-order by namespace ID number...
537 ksort( $this->namespaceNames );
538
539 wfRunHooks( 'LanguageGetNamespaces', array( &$this->namespaceNames ) );
540 }
541 return $this->namespaceNames;
542 }
543
544 /**
545 * Arbitrarily set all of the namespace names at once. Mainly used for testing
546 * @param $namespaces Array of namespaces (id => name)
547 */
548 public function setNamespaces( array $namespaces ) {
549 $this->namespaceNames = $namespaces;
550 $this->mNamespaceIds = null;
551 }
552
553 /**
554 * Resets all of the namespace caches. Mainly used for testing
555 */
556 public function resetNamespaces() {
557 $this->namespaceNames = null;
558 $this->mNamespaceIds = null;
559 $this->namespaceAliases = null;
560 }
561
562 /**
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.
567 *
568 * @return array
569 */
570 function getFormattedNamespaces() {
571 $ns = $this->getNamespaces();
572 foreach ( $ns as $k => $v ) {
573 $ns[$k] = strtr( $v, '_', ' ' );
574 }
575 return $ns;
576 }
577
578 /**
579 * Get a namespace value by key
580 * <code>
581 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
582 * echo $mw_ns; // prints 'MediaWiki'
583 * </code>
584 *
585 * @param $index Int: the array key of the namespace to return
586 * @return mixed, string if the namespace value exists, otherwise false
587 */
588 function getNsText( $index ) {
589 $ns = $this->getNamespaces();
590 return isset( $ns[$index] ) ? $ns[$index] : false;
591 }
592
593 /**
594 * A convenience function that returns the same thing as
595 * getNsText() except with '_' changed to ' ', useful for
596 * producing output.
597 *
598 * <code>
599 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
600 * echo $mw_ns; // prints 'MediaWiki talk'
601 * </code>
602 *
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)
605 */
606 function getFormattedNsText( $index ) {
607 $ns = $this->getNsText( $index );
608 return strtr( $ns, '_', ' ' );
609 }
610
611 /**
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
617 */
618 function getGenderNsText( $index, $gender ) {
619 global $wgExtraGenderNamespaces;
620
621 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
622 return isset( $ns[$index][$gender] ) ? $ns[$index][$gender] : $this->getNsText( $index );
623 }
624
625 /**
626 * Whether this language makes distinguishes genders for example in
627 * namespaces.
628 * @return bool
629 * @since 1.18
630 */
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;
644 }
645 }
646
647 /**
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.
651 *
652 * @param $text String
653 * @return mixed An integer if $text is a valid value otherwise false
654 */
655 function getLocalNsIndex( $text ) {
656 $lctext = $this->lc( $text );
657 $ids = $this->getNamespaceIds();
658 return isset( $ids[$lctext] ) ? $ids[$lctext] : false;
659 }
660
661 /**
662 * @return array
663 */
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;
675 }
676 }
677 }
678
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;
684 }
685 }
686
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;
692 }
693 foreach ( $this->getNamespaces() as $ns => $_ ) {
694 $convertedNames[$this->getConverter()->convertNamespace( $ns, $variant )] = $ns;
695 }
696 }
697
698 $this->namespaceAliases = $aliases + $convertedNames;
699 }
700 return $this->namespaceAliases;
701 }
702
703 /**
704 * @return array
705 */
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;
716 }
717 foreach ( $this->getNamespaceAliases() as $name => $index ) {
718 $this->mNamespaceIds[$this->lc( $name )] = $index;
719 }
720 if ( $wgNamespaceAliases ) {
721 foreach ( $wgNamespaceAliases as $name => $index ) {
722 $this->mNamespaceIds[$this->lc( $name )] = $index;
723 }
724 }
725 }
726 return $this->mNamespaceIds;
727 }
728
729 /**
730 * Get a namespace key by value, case insensitive. Canonical namespace
731 * names override custom ones defined for the current language.
732 *
733 * @param $text String
734 * @return mixed An integer if $text is a valid value otherwise false
735 */
736 function getNsIndex( $text ) {
737 $lctext = $this->lc( $text );
738 $ns = MWNamespace::getCanonicalIndex( $lctext );
739 if ( $ns !== null ) {
740 return $ns;
741 }
742 $ids = $this->getNamespaceIds();
743 return isset( $ids[$lctext] ) ? $ids[$lctext] : false;
744 }
745
746 /**
747 * short names for language variants used for language conversion links.
748 *
749 * @param $code String
750 * @param $usemsg bool Use the "variantname-xyz" message if it exists
751 * @return string
752 */
753 function getVariantname( $code, $usemsg = true ) {
754 $msg = "variantname-$code";
755 if ( $usemsg && wfMessage( $msg )->exists() ) {
756 return $this->getMessageFromDB( $msg );
757 }
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;
764 }
765 }
766
767 /**
768 * @param $name string
769 * @return string
770 */
771 function specialPage( $name ) {
772 $aliases = $this->getSpecialPageAliases();
773 if ( isset( $aliases[$name][0] ) ) {
774 $name = $aliases[$name][0];
775 }
776 return $this->getNsText( NS_SPECIAL ) . ':' . $name;
777 }
778
779 /**
780 * @return array
781 */
782 function getDatePreferences() {
783 return self::$dataCache->getItem( $this->mCode, 'datePreferences' );
784 }
785
786 /**
787 * @return array
788 */
789 function getDateFormats() {
790 return self::$dataCache->getItem( $this->mCode, 'dateFormats' );
791 }
792
793 /**
794 * @return array|string
795 */
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;
803 }
804 }
805
806 /**
807 * @return array
808 */
809 function getDatePreferenceMigrationMap() {
810 return self::$dataCache->getItem( $this->mCode, 'datePreferenceMigrationMap' );
811 }
812
813 /**
814 * @param $image
815 * @return array|null
816 */
817 function getImageFile( $image ) {
818 return self::$dataCache->getSubitem( $this->mCode, 'imageFiles', $image );
819 }
820
821 /**
822 * @return array
823 */
824 function getExtraUserToggles() {
825 return (array)self::$dataCache->getItem( $this->mCode, 'extraUserToggles' );
826 }
827
828 /**
829 * @param $tog
830 * @return string
831 */
832 function getUserToggle( $tog ) {
833 return $this->getMessageFromDB( "tog-$tog" );
834 }
835
836 /**
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
840 *
841 * @param $customisedOnly bool
842 *
843 * @return array
844 * @deprecated in 1.20, use fetchLanguageNames()
845 */
846 public static function getLanguageNames( $customisedOnly = false ) {
847 return self::fetchLanguageNames( null, $customisedOnly ? 'mwfile' : 'mw' );
848 }
849
850 /**
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()
858 */
859 public static function getTranslatedLanguageNames( $code ) {
860 return self::fetchLanguageNames( $code, 'all' );
861 }
862
863 /**
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
873 */
874 public static function fetchLanguageNames( $inLanguage = null, $include = 'mw' ) {
875 global $wgExtraLanguageNames;
876 static $coreLanguageNames;
877
878 if ( $coreLanguageNames === null ) {
879 global $IP;
880 include "$IP/languages/Names.php";
881 }
882
883 $names = array();
884
885 if ( $inLanguage ) {
886 # TODO: also include when $inLanguage is null, when this code is more efficient
887 wfRunHooks( 'LanguageGetTranslatedLanguageNames', array( &$names, $inLanguage ) );
888 }
889
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;
896 }
897 }
898
899 if ( $include === 'all' ) {
900 return $names;
901 }
902
903 $returnMw = array();
904 $coreCodes = array_keys( $mwNames );
905 foreach ( $coreCodes as $coreCode ) {
906 $returnMw[$coreCode] = $names[$coreCode];
907 }
908
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];
916 }
917 }
918 return $namesMwFile;
919 }
920 # 'mw' option; default if it's not one of the other two options (all/mwfile)
921 return $returnMw;
922 }
923
924 /**
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
930 */
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];
934 }
935
936 /**
937 * Get a message from the MediaWiki namespace.
938 *
939 * @param $msg String: message name
940 * @return string
941 */
942 function getMessageFromDB( $msg ) {
943 return wfMessage( $msg )->inLanguage( $this )->text();
944 }
945
946 /**
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()
952 */
953 function getLanguageName( $code ) {
954 return self::fetchLanguageName( $code );
955 }
956
957 /**
958 * @param $key string
959 * @return string
960 */
961 function getMonthName( $key ) {
962 return $this->getMessageFromDB( self::$mMonthMsgs[$key - 1] );
963 }
964
965 /**
966 * @return array
967 */
968 function getMonthNamesArray() {
969 $monthNames = array( '' );
970 for ( $i = 1; $i < 13; $i++ ) {
971 $monthNames[] = $this->getMonthName( $i );
972 }
973 return $monthNames;
974 }
975
976 /**
977 * @param $key string
978 * @return string
979 */
980 function getMonthNameGen( $key ) {
981 return $this->getMessageFromDB( self::$mMonthGenMsgs[$key - 1] );
982 }
983
984 /**
985 * @param $key string
986 * @return string
987 */
988 function getMonthAbbreviation( $key ) {
989 return $this->getMessageFromDB( self::$mMonthAbbrevMsgs[$key - 1] );
990 }
991
992 /**
993 * @return array
994 */
995 function getMonthAbbreviationsArray() {
996 $monthNames = array( '' );
997 for ( $i = 1; $i < 13; $i++ ) {
998 $monthNames[] = $this->getMonthAbbreviation( $i );
999 }
1000 return $monthNames;
1001 }
1002
1003 /**
1004 * @param $key string
1005 * @return string
1006 */
1007 function getWeekdayName( $key ) {
1008 return $this->getMessageFromDB( self::$mWeekdayMsgs[$key - 1] );
1009 }
1010
1011 /**
1012 * @param $key string
1013 * @return string
1014 */
1015 function getWeekdayAbbreviation( $key ) {
1016 return $this->getMessageFromDB( self::$mWeekdayAbbrevMsgs[$key - 1] );
1017 }
1018
1019 /**
1020 * @param $key string
1021 * @return string
1022 */
1023 function getIranianCalendarMonthName( $key ) {
1024 return $this->getMessageFromDB( self::$mIranianCalendarMonthMsgs[$key - 1] );
1025 }
1026
1027 /**
1028 * @param $key string
1029 * @return string
1030 */
1031 function getHebrewCalendarMonthName( $key ) {
1032 return $this->getMessageFromDB( self::$mHebrewCalendarMonthMsgs[$key - 1] );
1033 }
1034
1035 /**
1036 * @param $key string
1037 * @return string
1038 */
1039 function getHebrewCalendarMonthNameGen( $key ) {
1040 return $this->getMessageFromDB( self::$mHebrewCalendarMonthGenMsgs[$key - 1] );
1041 }
1042
1043 /**
1044 * @param $key string
1045 * @return string
1046 */
1047 function getHijriCalendarMonthName( $key ) {
1048 return $this->getMessageFromDB( self::$mHijriCalendarMonthMsgs[$key - 1] );
1049 }
1050
1051 /**
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.
1055 *
1056 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1057 * the PHP manual for definitions. There are a number of extensions, which
1058 * start with "x":
1059 *
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
1066 *
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
1072 *
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
1079 *
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
1084 *
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
1092 *
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:
1096 *
1097 * "The month is" F => The month is January
1098 * i's" => 20'11"
1099 *
1100 * Backslash escaping is also supported.
1101 *
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.
1105 *
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?
1112 *
1113 * @throws MWException
1114 * @return string
1115 */
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;
1129
1130 if ( strlen( $ts ) !== 14 ) {
1131 throw new MWException( __METHOD__ . ": The timestamp $ts should have 14 characters" );
1132 }
1133
1134 if ( !ctype_digit( $ts ) ) {
1135 throw new MWException( __METHOD__ . ": The timestamp $ts should be a number" );
1136 }
1137
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];
1143 }
1144
1145 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1146 $code .= $format[++$p];
1147 }
1148
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 );
1171 }
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' )
1181 );
1182 }
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 );
1191 }
1192 $num = $iranian[2];
1193 break;
1194 case 'xmj':
1195 if ( !$hijri ) {
1196 $hijri = self::tsToHijri( $ts );
1197 }
1198 $num = $hijri[2];
1199 break;
1200 case 'xjj':
1201 if ( !$hebrew ) {
1202 $hebrew = self::tsToHebrew( $ts );
1203 }
1204 $num = $hebrew[2];
1205 break;
1206 case 'l':
1207 if ( !$dateTimeObj ) {
1208 $dateTimeObj = DateTime::createFromFormat(
1209 'YmdHis', $ts, $zone ?: new DateTimeZone( 'UTC' )
1210 );
1211 }
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 );
1220 }
1221 $s .= $this->getIranianCalendarMonthName( $iranian[1] );
1222 break;
1223 case 'xmF':
1224 if ( !$hijri ) {
1225 $hijri = self::tsToHijri( $ts );
1226 }
1227 $s .= $this->getHijriCalendarMonthName( $hijri[1] );
1228 break;
1229 case 'xjF':
1230 if ( !$hebrew ) {
1231 $hebrew = self::tsToHebrew( $ts );
1232 }
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 );
1247 }
1248 $num = $iranian[1];
1249 break;
1250 case 'xmn':
1251 if ( !$hijri ) {
1252 $hijri = self::tsToHijri ( $ts );
1253 }
1254 $num = $hijri[1];
1255 break;
1256 case 'xjn':
1257 if ( !$hebrew ) {
1258 $hebrew = self::tsToHebrew( $ts );
1259 }
1260 $num = $hebrew[1];
1261 break;
1262 case 'xjt':
1263 if ( !$hebrew ) {
1264 $hebrew = self::tsToHebrew( $ts );
1265 }
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 );
1274 }
1275 $num = $iranian[0];
1276 break;
1277 case 'xmY':
1278 if ( !$hijri ) {
1279 $hijri = self::tsToHijri( $ts );
1280 }
1281 $num = $hijri[0];
1282 break;
1283 case 'xjY':
1284 if ( !$hebrew ) {
1285 $hebrew = self::tsToHebrew( $ts );
1286 }
1287 $num = $hebrew[0];
1288 break;
1289 case 'xkY':
1290 if ( !$thai ) {
1291 $thai = self::tsToYear( $ts, 'thai' );
1292 }
1293 $num = $thai[0];
1294 break;
1295 case 'xoY':
1296 if ( !$minguo ) {
1297 $minguo = self::tsToYear( $ts, 'minguo' );
1298 }
1299 $num = $minguo[0];
1300 break;
1301 case 'xtY':
1302 if ( !$tenno ) {
1303 $tenno = self::tsToYear( $ts, 'tenno' );
1304 }
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 );
1313 }
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' )
1352 );
1353 }
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' )
1370 );
1371 }
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 .= '\\';
1380 }
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;
1392 }
1393 } else {
1394 # Quote at end of string, assume literal "
1395 $s .= '"';
1396 }
1397 break;
1398 default:
1399 $s .= $format[$p];
1400 }
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 );
1413 }
1414 }
1415 }
1416 return $s;
1417 }
1418
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 );
1421
1422 /**
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.
1427 *
1428 * Link: http://www.farsiweb.info/jalali/jalali.c
1429 *
1430 * @param $ts string
1431 *
1432 * @return string
1433 */
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;
1438
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 );
1444
1445 // Add days of the past months of this year
1446 for ( $i = 0; $i < $gm; $i++ ) {
1447 $gDayNo += self::$GREG_DAYS[$i];
1448 }
1449
1450 // Leap years
1451 if ( $gm > 1 && ( ( $gy % 4 === 0 && $gy % 100 !== 0 || ( $gy % 400 == 0 ) ) ) ) {
1452 $gDayNo++;
1453 }
1454
1455 // Days passed in current month
1456 $gDayNo += (int)$gd;
1457
1458 $jDayNo = $gDayNo - 79;
1459
1460 $jNp = floor( $jDayNo / 12053 );
1461 $jDayNo %= 12053;
1462
1463 $jy = 979 + 33 * $jNp + 4 * floor( $jDayNo / 1461 );
1464 $jDayNo %= 1461;
1465
1466 if ( $jDayNo >= 366 ) {
1467 $jy += floor( ( $jDayNo - 1 ) / 365 );
1468 $jDayNo = floor( ( $jDayNo - 1 ) % 365 );
1469 }
1470
1471 for ( $i = 0; $i < 11 && $jDayNo >= self::$IRANIAN_DAYS[$i]; $i++ ) {
1472 $jDayNo -= self::$IRANIAN_DAYS[$i];
1473 }
1474
1475 $jm = $i + 1;
1476 $jd = $jDayNo + 1;
1477
1478 return array( $jy, $jm, $jd );
1479 }
1480
1481 /**
1482 * Converting Gregorian dates to Hijri dates.
1483 *
1484 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1485 *
1486 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1487 *
1488 * @param $ts string
1489 *
1490 * @return string
1491 */
1492 private static function tsToHijri( $ts ) {
1493 $year = substr( $ts, 0, 4 );
1494 $month = substr( $ts, 4, 2 );
1495 $day = substr( $ts, 6, 2 );
1496
1497 $zyr = $year;
1498 $zd = $day;
1499 $zm = $month;
1500 $zy = $zyr;
1501
1502 if (
1503 ( $zy > 1582 ) || ( ( $zy == 1582 ) && ( $zm > 10 ) ) ||
1504 ( ( $zy == 1582 ) && ( $zm == 10 ) && ( $zd > 14 ) )
1505 ) {
1506 $zjd = (int)( ( 1461 * ( $zy + 4800 + (int)( ( $zm - 14 ) / 12 ) ) ) / 4 ) +
1507 (int)( ( 367 * ( $zm - 2 - 12 * ( (int)( ( $zm - 14 ) / 12 ) ) ) ) / 12 ) -
1508 (int)( ( 3 * (int)( ( ( $zy + 4900 + (int)( ( $zm - 14 ) / 12 ) ) / 100 ) ) ) / 4 ) +
1509 $zd - 32075;
1510 } else {
1511 $zjd = 367 * $zy - (int)( ( 7 * ( $zy + 5001 + (int)( ( $zm - 9 ) / 7 ) ) ) / 4 ) +
1512 (int)( ( 275 * $zm ) / 9 ) + $zd + 1729777;
1513 }
1514
1515 $zl = $zjd -1948440 + 10632;
1516 $zn = (int)( ( $zl - 1 ) / 10631 );
1517 $zl = $zl - 10631 * $zn + 354;
1518 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1519 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1520 $zm = (int)( ( 24 * $zl ) / 709 );
1521 $zd = $zl - (int)( ( 709 * $zm ) / 24 );
1522 $zy = 30 * $zn + $zj - 30;
1523
1524 return array( $zy, $zm, $zd );
1525 }
1526
1527 /**
1528 * Converting Gregorian dates to Hebrew dates.
1529 *
1530 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1531 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1532 * to translate the relevant functions into PHP and release them under
1533 * GNU GPL.
1534 *
1535 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1536 * and Adar II is 14. In a non-leap year, Adar is 6.
1537 *
1538 * @param $ts string
1539 *
1540 * @return string
1541 */
1542 private static function tsToHebrew( $ts ) {
1543 # Parse date
1544 $year = substr( $ts, 0, 4 );
1545 $month = substr( $ts, 4, 2 );
1546 $day = substr( $ts, 6, 2 );
1547
1548 # Calculate Hebrew year
1549 $hebrewYear = $year + 3760;
1550
1551 # Month number when September = 1, August = 12
1552 $month += 4;
1553 if ( $month > 12 ) {
1554 # Next year
1555 $month -= 12;
1556 $year++;
1557 $hebrewYear++;
1558 }
1559
1560 # Calculate day of year from 1 September
1561 $dayOfYear = $day;
1562 for ( $i = 1; $i < $month; $i++ ) {
1563 if ( $i == 6 ) {
1564 # February
1565 $dayOfYear += 28;
1566 # Check if the year is leap
1567 if ( $year % 400 == 0 || ( $year % 4 == 0 && $year % 100 > 0 ) ) {
1568 $dayOfYear++;
1569 }
1570 } elseif ( $i == 8 || $i == 10 || $i == 1 || $i == 3 ) {
1571 $dayOfYear += 30;
1572 } else {
1573 $dayOfYear += 31;
1574 }
1575 }
1576
1577 # Calculate the start of the Hebrew year
1578 $start = self::hebrewYearStart( $hebrewYear );
1579
1580 # Calculate next year's start
1581 if ( $dayOfYear <= $start ) {
1582 # Day is before the start of the year - it is the previous year
1583 # Next year's start
1584 $nextStart = $start;
1585 # Previous year
1586 $year--;
1587 $hebrewYear--;
1588 # Add days since previous year's 1 September
1589 $dayOfYear += 365;
1590 if ( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
1591 # Leap year
1592 $dayOfYear++;
1593 }
1594 # Start of the new (previous) year
1595 $start = self::hebrewYearStart( $hebrewYear );
1596 } else {
1597 # Next year's start
1598 $nextStart = self::hebrewYearStart( $hebrewYear + 1 );
1599 }
1600
1601 # Calculate Hebrew day of year
1602 $hebrewDayOfYear = $dayOfYear - $start;
1603
1604 # Difference between year's days
1605 $diff = $nextStart - $start;
1606 # Add 12 (or 13 for leap years) days to ignore the difference between
1607 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1608 # difference is only about the year type
1609 if ( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
1610 $diff += 13;
1611 } else {
1612 $diff += 12;
1613 }
1614
1615 # Check the year pattern, and is leap year
1616 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1617 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1618 # and non-leap years
1619 $yearPattern = $diff % 30;
1620 # Check if leap year
1621 $isLeap = $diff >= 30;
1622
1623 # Calculate day in the month from number of day in the Hebrew year
1624 # Don't check Adar - if the day is not in Adar, we will stop before;
1625 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1626 $hebrewDay = $hebrewDayOfYear;
1627 $hebrewMonth = 1;
1628 $days = 0;
1629 while ( $hebrewMonth <= 12 ) {
1630 # Calculate days in this month
1631 if ( $isLeap && $hebrewMonth == 6 ) {
1632 # Adar in a leap year
1633 if ( $isLeap ) {
1634 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1635 $days = 30;
1636 if ( $hebrewDay <= $days ) {
1637 # Day in Adar I
1638 $hebrewMonth = 13;
1639 } else {
1640 # Subtract the days of Adar I
1641 $hebrewDay -= $days;
1642 # Try Adar II
1643 $days = 29;
1644 if ( $hebrewDay <= $days ) {
1645 # Day in Adar II
1646 $hebrewMonth = 14;
1647 }
1648 }
1649 }
1650 } elseif ( $hebrewMonth == 2 && $yearPattern == 2 ) {
1651 # Cheshvan in a complete year (otherwise as the rule below)
1652 $days = 30;
1653 } elseif ( $hebrewMonth == 3 && $yearPattern == 0 ) {
1654 # Kislev in an incomplete year (otherwise as the rule below)
1655 $days = 29;
1656 } else {
1657 # Odd months have 30 days, even have 29
1658 $days = 30 - ( $hebrewMonth - 1 ) % 2;
1659 }
1660 if ( $hebrewDay <= $days ) {
1661 # In the current month
1662 break;
1663 } else {
1664 # Subtract the days of the current month
1665 $hebrewDay -= $days;
1666 # Try in the next month
1667 $hebrewMonth++;
1668 }
1669 }
1670
1671 return array( $hebrewYear, $hebrewMonth, $hebrewDay, $days );
1672 }
1673
1674 /**
1675 * This calculates the Hebrew year start, as days since 1 September.
1676 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1677 * Used for Hebrew date.
1678 *
1679 * @param $year int
1680 *
1681 * @return string
1682 */
1683 private static function hebrewYearStart( $year ) {
1684 $a = intval( ( 12 * ( $year - 1 ) + 17 ) % 19 );
1685 $b = intval( ( $year - 1 ) % 4 );
1686 $m = 32.044093161144 + 1.5542417966212 * $a + $b / 4.0 - 0.0031777940220923 * ( $year - 1 );
1687 if ( $m < 0 ) {
1688 $m--;
1689 }
1690 $Mar = intval( $m );
1691 if ( $m < 0 ) {
1692 $m++;
1693 }
1694 $m -= $Mar;
1695
1696 $c = intval( ( $Mar + 3 * ( $year - 1 ) + 5 * $b + 5 ) % 7 );
1697 if ( $c == 0 && $a > 11 && $m >= 0.89772376543210 ) {
1698 $Mar++;
1699 } elseif ( $c == 1 && $a > 6 && $m >= 0.63287037037037 ) {
1700 $Mar += 2;
1701 } elseif ( $c == 2 || $c == 4 || $c == 6 ) {
1702 $Mar++;
1703 }
1704
1705 $Mar += intval( ( $year - 3761 ) / 100 ) - intval( ( $year - 3761 ) / 400 ) - 24;
1706 return $Mar;
1707 }
1708
1709 /**
1710 * Algorithm to convert Gregorian dates to Thai solar dates,
1711 * Minguo dates or Minguo dates.
1712 *
1713 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1714 * http://en.wikipedia.org/wiki/Minguo_calendar
1715 * http://en.wikipedia.org/wiki/Japanese_era_name
1716 *
1717 * @param $ts String: 14-character timestamp
1718 * @param $cName String: calender name
1719 * @return Array: converted year, month, day
1720 */
1721 private static function tsToYear( $ts, $cName ) {
1722 $gy = substr( $ts, 0, 4 );
1723 $gm = substr( $ts, 4, 2 );
1724 $gd = substr( $ts, 6, 2 );
1725
1726 if ( !strcmp( $cName, 'thai' ) ) {
1727 # Thai solar dates
1728 # Add 543 years to the Gregorian calendar
1729 # Months and days are identical
1730 $gy_offset = $gy + 543;
1731 } elseif ( ( !strcmp( $cName, 'minguo' ) ) || !strcmp( $cName, 'juche' ) ) {
1732 # Minguo dates
1733 # Deduct 1911 years from the Gregorian calendar
1734 # Months and days are identical
1735 $gy_offset = $gy - 1911;
1736 } elseif ( !strcmp( $cName, 'tenno' ) ) {
1737 # Nengō dates up to Meiji period
1738 # Deduct years from the Gregorian calendar
1739 # depending on the nengo periods
1740 # Months and days are identical
1741 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1742 # Meiji period
1743 $gy_gannen = $gy - 1868 + 1;
1744 $gy_offset = $gy_gannen;
1745 if ( $gy_gannen == 1 ) {
1746 $gy_offset = '元';
1747 }
1748 $gy_offset = '明治' . $gy_offset;
1749 } elseif (
1750 ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd == 31 ) ) ||
1751 ( ( $gy == 1912 ) && ( $gm >= 8 ) ) ||
1752 ( ( $gy > 1912 ) && ( $gy < 1926 ) ) ||
1753 ( ( $gy == 1926 ) && ( $gm < 12 ) ) ||
1754 ( ( $gy == 1926 ) && ( $gm == 12 ) && ( $gd < 26 ) )
1755 ) {
1756 # Taishō period
1757 $gy_gannen = $gy - 1912 + 1;
1758 $gy_offset = $gy_gannen;
1759 if ( $gy_gannen == 1 ) {
1760 $gy_offset = '元';
1761 }
1762 $gy_offset = '大正' . $gy_offset;
1763 } elseif (
1764 ( ( $gy == 1926 ) && ( $gm == 12 ) && ( $gd >= 26 ) ) ||
1765 ( ( $gy > 1926 ) && ( $gy < 1989 ) ) ||
1766 ( ( $gy == 1989 ) && ( $gm == 1 ) && ( $gd < 8 ) )
1767 ) {
1768 # Shōwa period
1769 $gy_gannen = $gy - 1926 + 1;
1770 $gy_offset = $gy_gannen;
1771 if ( $gy_gannen == 1 ) {
1772 $gy_offset = '元';
1773 }
1774 $gy_offset = '昭和' . $gy_offset;
1775 } else {
1776 # Heisei period
1777 $gy_gannen = $gy - 1989 + 1;
1778 $gy_offset = $gy_gannen;
1779 if ( $gy_gannen == 1 ) {
1780 $gy_offset = '元';
1781 }
1782 $gy_offset = '平成' . $gy_offset;
1783 }
1784 } else {
1785 $gy_offset = $gy;
1786 }
1787
1788 return array( $gy_offset, $gm, $gd );
1789 }
1790
1791 /**
1792 * Roman number formatting up to 10000
1793 *
1794 * @param $num int
1795 *
1796 * @return string
1797 */
1798 static function romanNumeral( $num ) {
1799 static $table = array(
1800 array( '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X' ),
1801 array( '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', 'C' ),
1802 array( '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', 'M' ),
1803 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1804 );
1805
1806 $num = intval( $num );
1807 if ( $num > 10000 || $num <= 0 ) {
1808 return $num;
1809 }
1810
1811 $s = '';
1812 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1813 if ( $num >= $pow10 ) {
1814 $s .= $table[$i][(int)floor( $num / $pow10 )];
1815 }
1816 $num = $num % $pow10;
1817 }
1818 return $s;
1819 }
1820
1821 /**
1822 * Hebrew Gematria number formatting up to 9999
1823 *
1824 * @param $num int
1825 *
1826 * @return string
1827 */
1828 static function hebrewNumeral( $num ) {
1829 static $table = array(
1830 array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' ),
1831 array( '', 'י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ', 'ק' ),
1832 array( '', 'ק', 'ר', 'ש', 'ת', 'תק', 'תר', 'תש', 'תת', 'תתק', 'תתר' ),
1833 array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' )
1834 );
1835
1836 $num = intval( $num );
1837 if ( $num > 9999 || $num <= 0 ) {
1838 return $num;
1839 }
1840
1841 $s = '';
1842 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1843 if ( $num >= $pow10 ) {
1844 if ( $num == 15 || $num == 16 ) {
1845 $s .= $table[0][9] . $table[0][$num - 9];
1846 $num = 0;
1847 } else {
1848 $s .= $table[$i][intval( ( $num / $pow10 ) )];
1849 if ( $pow10 == 1000 ) {
1850 $s .= "'";
1851 }
1852 }
1853 }
1854 $num = $num % $pow10;
1855 }
1856 if ( strlen( $s ) == 2 ) {
1857 $str = $s . "'";
1858 } else {
1859 $str = substr( $s, 0, strlen( $s ) - 2 ) . '"';
1860 $str .= substr( $s, strlen( $s ) - 2, 2 );
1861 }
1862 $start = substr( $str, 0, strlen( $str ) - 2 );
1863 $end = substr( $str, strlen( $str ) - 2 );
1864 switch ( $end ) {
1865 case 'כ':
1866 $str = $start . 'ך';
1867 break;
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 }
1881 return $str;
1882 }
1883
1884 /**
1885 * Used by date() and time() to adjust the time output.
1886 *
1887 * @param $ts Int the time in date('YmdHis') format
1888 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1889 * get user timecorrection setting)
1890 * @return int
1891 */
1892 function userAdjust( $ts, $tz = false ) {
1893 global $wgUser, $wgLocalTZoffset;
1894
1895 if ( $tz === false ) {
1896 $tz = $wgUser->getOption( 'timecorrection' );
1897 }
1898
1899 $data = explode( '|', $tz, 3 );
1900
1901 if ( $data[0] == 'ZoneInfo' ) {
1902 wfSuppressWarnings();
1903 $userTZ = timezone_open( $data[2] );
1904 wfRestoreWarnings();
1905 if ( $userTZ !== false ) {
1906 $date = date_create( $ts, timezone_open( 'UTC' ) );
1907 date_timezone_set( $date, $userTZ );
1908 $date = date_format( $date, 'YmdHis' );
1909 return $date;
1910 }
1911 # Unrecognized timezone, default to 'Offset' with the stored offset.
1912 $data[0] = 'Offset';
1913 }
1914
1915 $minDiff = 0;
1916 if ( $data[0] == 'System' || $tz == '' ) {
1917 #  Global offset in minutes.
1918 if ( isset( $wgLocalTZoffset ) ) {
1919 $minDiff = $wgLocalTZoffset;
1920 }
1921 } elseif ( $data[0] == 'Offset' ) {
1922 $minDiff = intval( $data[1] );
1923 } else {
1924 $data = explode( ':', $tz );
1925 if ( count( $data ) == 2 ) {
1926 $data[0] = intval( $data[0] );
1927 $data[1] = intval( $data[1] );
1928 $minDiff = abs( $data[0] ) * 60 + $data[1];
1929 if ( $data[0] < 0 ) {
1930 $minDiff = -$minDiff;
1931 }
1932 } else {
1933 $minDiff = intval( $data[0] ) * 60;
1934 }
1935 }
1936
1937 # No difference ? Return time unchanged
1938 if ( 0 == $minDiff ) {
1939 return $ts;
1940 }
1941
1942 wfSuppressWarnings(); // E_STRICT system time bitching
1943 # Generate an adjusted date; take advantage of the fact that mktime
1944 # will normalize out-of-range values so we don't have to split $minDiff
1945 # into hours and minutes.
1946 $t = mktime( (
1947 (int)substr( $ts, 8, 2 ) ), # Hours
1948 (int)substr( $ts, 10, 2 ) + $minDiff, # Minutes
1949 (int)substr( $ts, 12, 2 ), # Seconds
1950 (int)substr( $ts, 4, 2 ), # Month
1951 (int)substr( $ts, 6, 2 ), # Day
1952 (int)substr( $ts, 0, 4 ) ); # Year
1953
1954 $date = date( 'YmdHis', $t );
1955 wfRestoreWarnings();
1956
1957 return $date;
1958 }
1959
1960 /**
1961 * This is meant to be used by time(), date(), and timeanddate() to get
1962 * the date preference they're supposed to use, it should be used in
1963 * all children.
1964 *
1965 *<code>
1966 * function timeanddate([...], $format = true) {
1967 * $datePreference = $this->dateFormat($format);
1968 * [...]
1969 * }
1970 *</code>
1971 *
1972 * @param $usePrefs Mixed: if true, the user's preference is used
1973 * if false, the site/language default is used
1974 * if int/string, assumed to be a format.
1975 * @return string
1976 */
1977 function dateFormat( $usePrefs = true ) {
1978 global $wgUser;
1979
1980 if ( is_bool( $usePrefs ) ) {
1981 if ( $usePrefs ) {
1982 $datePreference = $wgUser->getDatePreference();
1983 } else {
1984 $datePreference = (string)User::getDefaultOption( 'date' );
1985 }
1986 } else {
1987 $datePreference = (string)$usePrefs;
1988 }
1989
1990 // return int
1991 if ( $datePreference == '' ) {
1992 return 'default';
1993 }
1994
1995 return $datePreference;
1996 }
1997
1998 /**
1999 * Get a format string for a given type and preference
2000 * @param $type string May be date, time or both
2001 * @param $pref string The format name as it appears in Messages*.php
2002 *
2003 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2004 *
2005 * @return string
2006 */
2007 function getDateFormatString( $type, $pref ) {
2008 if ( !isset( $this->dateFormatStrings[$type][$pref] ) ) {
2009 if ( $pref == 'default' ) {
2010 $pref = $this->getDefaultDateFormat();
2011 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
2012 } else {
2013 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
2014
2015 if ( $type === 'pretty' && $df === null ) {
2016 $df = $this->getDateFormatString( 'date', $pref );
2017 }
2018
2019 if ( $df === null ) {
2020 $pref = $this->getDefaultDateFormat();
2021 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
2022 }
2023 }
2024 $this->dateFormatStrings[$type][$pref] = $df;
2025 }
2026 return $this->dateFormatStrings[$type][$pref];
2027 }
2028
2029 /**
2030 * @param $ts Mixed: the time format which needs to be turned into a
2031 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2032 * @param $adj Bool: whether to adjust the time output according to the
2033 * user configured offset ($timecorrection)
2034 * @param $format Mixed: true to use user's date format preference
2035 * @param $timecorrection String|bool the time offset as returned by
2036 * validateTimeZone() in Special:Preferences
2037 * @return string
2038 */
2039 function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
2040 $ts = wfTimestamp( TS_MW, $ts );
2041 if ( $adj ) {
2042 $ts = $this->userAdjust( $ts, $timecorrection );
2043 }
2044 $df = $this->getDateFormatString( 'date', $this->dateFormat( $format ) );
2045 return $this->sprintfDate( $df, $ts );
2046 }
2047
2048 /**
2049 * @param $ts Mixed: the time format which needs to be turned into a
2050 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2051 * @param $adj Bool: whether to adjust the time output according to the
2052 * user configured offset ($timecorrection)
2053 * @param $format Mixed: true to use user's date format preference
2054 * @param $timecorrection String|bool the time offset as returned by
2055 * validateTimeZone() in Special:Preferences
2056 * @return string
2057 */
2058 function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
2059 $ts = wfTimestamp( TS_MW, $ts );
2060 if ( $adj ) {
2061 $ts = $this->userAdjust( $ts, $timecorrection );
2062 }
2063 $df = $this->getDateFormatString( 'time', $this->dateFormat( $format ) );
2064 return $this->sprintfDate( $df, $ts );
2065 }
2066
2067 /**
2068 * @param $ts Mixed: the time format which needs to be turned into a
2069 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2070 * @param $adj Bool: whether to adjust the time output according to the
2071 * user configured offset ($timecorrection)
2072 * @param $format Mixed: what format to return, if it's false output the
2073 * default one (default true)
2074 * @param $timecorrection String|bool the time offset as returned by
2075 * validateTimeZone() in Special:Preferences
2076 * @return string
2077 */
2078 function timeanddate( $ts, $adj = false, $format = true, $timecorrection = false ) {
2079 $ts = wfTimestamp( TS_MW, $ts );
2080 if ( $adj ) {
2081 $ts = $this->userAdjust( $ts, $timecorrection );
2082 }
2083 $df = $this->getDateFormatString( 'both', $this->dateFormat( $format ) );
2084 return $this->sprintfDate( $df, $ts );
2085 }
2086
2087 /**
2088 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2089 *
2090 * @since 1.20
2091 *
2092 * @param integer $seconds The amount of seconds.
2093 * @param array $chosenIntervals The intervals to enable.
2094 *
2095 * @return string
2096 */
2097 public function formatDuration( $seconds, array $chosenIntervals = array() ) {
2098 $intervals = $this->getDurationIntervals( $seconds, $chosenIntervals );
2099
2100 $segments = array();
2101
2102 foreach ( $intervals as $intervalName => $intervalValue ) {
2103 // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2104 // duration-years, duration-decades, duration-centuries, duration-millennia
2105 $message = wfMessage( 'duration-' . $intervalName )->numParams( $intervalValue );
2106 $segments[] = $message->inLanguage( $this )->escaped();
2107 }
2108
2109 return $this->listToText( $segments );
2110 }
2111
2112 /**
2113 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2114 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2115 *
2116 * @since 1.20
2117 *
2118 * @param integer $seconds The amount of seconds.
2119 * @param array $chosenIntervals The intervals to enable.
2120 *
2121 * @return array
2122 */
2123 public function getDurationIntervals( $seconds, array $chosenIntervals = array() ) {
2124 if ( empty( $chosenIntervals ) ) {
2125 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2126 }
2127
2128 $intervals = array_intersect_key( self::$durationIntervals, array_flip( $chosenIntervals ) );
2129 $sortedNames = array_keys( $intervals );
2130 $smallestInterval = array_pop( $sortedNames );
2131
2132 $segments = array();
2133
2134 foreach ( $intervals as $name => $length ) {
2135 $value = floor( $seconds / $length );
2136
2137 if ( $value > 0 || ( $name == $smallestInterval && empty( $segments ) ) ) {
2138 $seconds -= $value * $length;
2139 $segments[$name] = $value;
2140 }
2141 }
2142
2143 return $segments;
2144 }
2145
2146 /**
2147 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2148 *
2149 * @param $type String: can be 'date', 'time' or 'both'
2150 * @param $ts Mixed: the time format which needs to be turned into a
2151 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2152 * @param $user User object used to get preferences for timezone and format
2153 * @param $options Array, can contain the following keys:
2154 * - 'timecorrection': time correction, can have the following values:
2155 * - true: use user's preference
2156 * - false: don't use time correction
2157 * - integer: value of time correction in minutes
2158 * - 'format': format to use, can have the following values:
2159 * - true: use user's preference
2160 * - false: use default preference
2161 * - string: format to use
2162 * @since 1.19
2163 * @return String
2164 */
2165 private function internalUserTimeAndDate( $type, $ts, User $user, array $options ) {
2166 $ts = wfTimestamp( TS_MW, $ts );
2167 $options += array( 'timecorrection' => true, 'format' => true );
2168 if ( $options['timecorrection'] !== false ) {
2169 if ( $options['timecorrection'] === true ) {
2170 $offset = $user->getOption( 'timecorrection' );
2171 } else {
2172 $offset = $options['timecorrection'];
2173 }
2174 $ts = $this->userAdjust( $ts, $offset );
2175 }
2176 if ( $options['format'] === true ) {
2177 $format = $user->getDatePreference();
2178 } else {
2179 $format = $options['format'];
2180 }
2181 $df = $this->getDateFormatString( $type, $this->dateFormat( $format ) );
2182 return $this->sprintfDate( $df, $ts );
2183 }
2184
2185 /**
2186 * Get the formatted date for the given timestamp and formatted for
2187 * the given user.
2188 *
2189 * @param $ts Mixed: the time format which needs to be turned into a
2190 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2191 * @param $user User object used to get preferences for timezone and format
2192 * @param $options Array, can contain the following keys:
2193 * - 'timecorrection': time correction, can have the following values:
2194 * - true: use user's preference
2195 * - false: don't use time correction
2196 * - integer: value of time correction in minutes
2197 * - 'format': format to use, can have the following values:
2198 * - true: use user's preference
2199 * - false: use default preference
2200 * - string: format to use
2201 * @since 1.19
2202 * @return String
2203 */
2204 public function userDate( $ts, User $user, array $options = array() ) {
2205 return $this->internalUserTimeAndDate( 'date', $ts, $user, $options );
2206 }
2207
2208 /**
2209 * Get the formatted time for the given timestamp and formatted for
2210 * the given user.
2211 *
2212 * @param $ts Mixed: the time format which needs to be turned into a
2213 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2214 * @param $user User object used to get preferences for timezone and format
2215 * @param $options Array, can contain the following keys:
2216 * - 'timecorrection': time correction, can have the following values:
2217 * - true: use user's preference
2218 * - false: don't use time correction
2219 * - integer: value of time correction in minutes
2220 * - 'format': format to use, can have the following values:
2221 * - true: use user's preference
2222 * - false: use default preference
2223 * - string: format to use
2224 * @since 1.19
2225 * @return String
2226 */
2227 public function userTime( $ts, User $user, array $options = array() ) {
2228 return $this->internalUserTimeAndDate( 'time', $ts, $user, $options );
2229 }
2230
2231 /**
2232 * Get the formatted date and time for the given timestamp and formatted for
2233 * the given user.
2234 *
2235 * @param $ts Mixed: the time format which needs to be turned into a
2236 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2237 * @param $user User object used to get preferences for timezone and format
2238 * @param $options Array, can contain the following keys:
2239 * - 'timecorrection': time correction, can have the following values:
2240 * - true: use user's preference
2241 * - false: don't use time correction
2242 * - integer: value of time correction in minutes
2243 * - 'format': format to use, can have the following values:
2244 * - true: use user's preference
2245 * - false: use default preference
2246 * - string: format to use
2247 * @since 1.19
2248 * @return String
2249 */
2250 public function userTimeAndDate( $ts, User $user, array $options = array() ) {
2251 return $this->internalUserTimeAndDate( 'both', $ts, $user, $options );
2252 }
2253
2254 /**
2255 * Convert an MWTimestamp into a pretty human-readable timestamp using
2256 * the given user preferences and relative base time.
2257 *
2258 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2259 * on your timestamp object, which will then call this function. Calling
2260 * this function directly will cause hooks to be skipped over.
2261 *
2262 * @see MWTimestamp::getHumanTimestamp
2263 * @param MWTimestamp $ts Timestamp to prettify
2264 * @param MWTimestamp $relativeTo Base timestamp
2265 * @param User $user User preferences to use
2266 * @return string Human timestamp
2267 * @since 1.22
2268 */
2269 public function getHumanTimestamp( MWTimestamp $ts, MWTimestamp $relativeTo, User $user ) {
2270 $diff = $ts->diff( $relativeTo );
2271 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) - (int)$relativeTo->timestamp->format( 'w' ) );
2272 $days = $diff->days ?: (int)$diffDay;
2273 if ( $diff->invert || $days > 5 && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' ) ) {
2274 // Timestamps are in different years: use full timestamp
2275 // Also do full timestamp for future dates
2276 /**
2277 * @FIXME Add better handling of future timestamps.
2278 */
2279 $format = $this->getDateFormatString( 'both', $user->getDatePreference() ?: 'default' );
2280 $ts = $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) );
2281 } elseif ( $days > 5 ) {
2282 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2283 $format = $this->getDateFormatString( 'pretty', $user->getDatePreference() ?: 'default' );
2284 $ts = $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) );
2285 } elseif ( $days > 1 ) {
2286 // Timestamp within the past week: show the day of the week and time
2287 $format = $this->getDateFormatString( 'time', $user->getDatePreference() ?: 'default' );
2288 $weekday = self::$mWeekdayMsgs[$ts->timestamp->format( 'w' )];
2289 // Messages:
2290 // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2291 $ts = wfMessage( "$weekday-at" )
2292 ->inLanguage( $this )
2293 ->params( $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) ) )
2294 ->text();
2295 } elseif ( $days == 1 ) {
2296 // Timestamp was yesterday: say 'yesterday' and the time.
2297 $format = $this->getDateFormatString( 'time', $user->getDatePreference() ?: 'default' );
2298 $ts = wfMessage( 'yesterday-at' )
2299 ->inLanguage( $this )
2300 ->params( $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) ) )
2301 ->text();
2302 } elseif ( $diff->h > 1 || $diff->h == 1 && $diff->i > 30 ) {
2303 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2304 $format = $this->getDateFormatString( 'time', $user->getDatePreference() ?: 'default' );
2305 $ts = wfMessage( 'today-at' )
2306 ->inLanguage( $this )
2307 ->params( $this->sprintfDate( $format, $ts->getTimestamp( TS_MW ) ) )
2308 ->text();
2309
2310 // From here on in, the timestamp was soon enough ago so that we can simply say
2311 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2312 } elseif ( $diff->h == 1 ) {
2313 // Less than 90 minutes, but more than an hour ago.
2314 $ts = wfMessage( 'hours-ago' )->inLanguage( $this )->numParams( 1 )->text();
2315 } elseif ( $diff->i >= 1 ) {
2316 // A few minutes ago.
2317 $ts = wfMessage( 'minutes-ago' )->inLanguage( $this )->numParams( $diff->i )->text();
2318 } elseif ( $diff->s >= 30 ) {
2319 // Less than a minute, but more than 30 sec ago.
2320 $ts = wfMessage( 'seconds-ago' )->inLanguage( $this )->numParams( $diff->s )->text();
2321 } else {
2322 // Less than 30 seconds ago.
2323 $ts = wfMessage( 'just-now' )->text();
2324 }
2325
2326 return $ts;
2327 }
2328
2329 /**
2330 * @param $key string
2331 * @return array|null
2332 */
2333 function getMessage( $key ) {
2334 return self::$dataCache->getSubitem( $this->mCode, 'messages', $key );
2335 }
2336
2337 /**
2338 * @return array
2339 */
2340 function getAllMessages() {
2341 return self::$dataCache->getItem( $this->mCode, 'messages' );
2342 }
2343
2344 /**
2345 * @param $in
2346 * @param $out
2347 * @param $string
2348 * @return string
2349 */
2350 function iconv( $in, $out, $string ) {
2351 # This is a wrapper for iconv in all languages except esperanto,
2352 # which does some nasty x-conversions beforehand
2353
2354 # Even with //IGNORE iconv can whine about illegal characters in
2355 # *input* string. We just ignore those too.
2356 # REF: http://bugs.php.net/bug.php?id=37166
2357 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2358 wfSuppressWarnings();
2359 $text = iconv( $in, $out . '//IGNORE', $string );
2360 wfRestoreWarnings();
2361 return $text;
2362 }
2363
2364 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2365
2366 /**
2367 * @param $matches array
2368 * @return mixed|string
2369 */
2370 function ucwordbreaksCallbackAscii( $matches ) {
2371 return $this->ucfirst( $matches[1] );
2372 }
2373
2374 /**
2375 * @param $matches array
2376 * @return string
2377 */
2378 function ucwordbreaksCallbackMB( $matches ) {
2379 return mb_strtoupper( $matches[0] );
2380 }
2381
2382 /**
2383 * @param $matches array
2384 * @return string
2385 */
2386 function ucCallback( $matches ) {
2387 list( $wikiUpperChars ) = self::getCaseMaps();
2388 return strtr( $matches[1], $wikiUpperChars );
2389 }
2390
2391 /**
2392 * @param $matches array
2393 * @return string
2394 */
2395 function lcCallback( $matches ) {
2396 list( , $wikiLowerChars ) = self::getCaseMaps();
2397 return strtr( $matches[1], $wikiLowerChars );
2398 }
2399
2400 /**
2401 * @param $matches array
2402 * @return string
2403 */
2404 function ucwordsCallbackMB( $matches ) {
2405 return mb_strtoupper( $matches[0] );
2406 }
2407
2408 /**
2409 * @param $matches array
2410 * @return string
2411 */
2412 function ucwordsCallbackWiki( $matches ) {
2413 list( $wikiUpperChars ) = self::getCaseMaps();
2414 return strtr( $matches[0], $wikiUpperChars );
2415 }
2416
2417 /**
2418 * Make a string's first character uppercase
2419 *
2420 * @param $str string
2421 *
2422 * @return string
2423 */
2424 function ucfirst( $str ) {
2425 $o = ord( $str );
2426 if ( $o < 96 ) { // if already uppercase...
2427 return $str;
2428 } elseif ( $o < 128 ) {
2429 return ucfirst( $str ); // use PHP's ucfirst()
2430 } else {
2431 // fall back to more complex logic in case of multibyte strings
2432 return $this->uc( $str, true );
2433 }
2434 }
2435
2436 /**
2437 * Convert a string to uppercase
2438 *
2439 * @param $str string
2440 * @param $first bool
2441 *
2442 * @return string
2443 */
2444 function uc( $str, $first = false ) {
2445 if ( function_exists( 'mb_strtoupper' ) ) {
2446 if ( $first ) {
2447 if ( $this->isMultibyte( $str ) ) {
2448 return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
2449 } else {
2450 return ucfirst( $str );
2451 }
2452 } else {
2453 return $this->isMultibyte( $str ) ? mb_strtoupper( $str ) : strtoupper( $str );
2454 }
2455 } else {
2456 if ( $this->isMultibyte( $str ) ) {
2457 $x = $first ? '^' : '';
2458 return preg_replace_callback(
2459 "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
2460 array( $this, 'ucCallback' ),
2461 $str
2462 );
2463 } else {
2464 return $first ? ucfirst( $str ) : strtoupper( $str );
2465 }
2466 }
2467 }
2468
2469 /**
2470 * @param $str string
2471 * @return mixed|string
2472 */
2473 function lcfirst( $str ) {
2474 $o = ord( $str );
2475 if ( !$o ) {
2476 return strval( $str );
2477 } elseif ( $o >= 128 ) {
2478 return $this->lc( $str, true );
2479 } elseif ( $o > 96 ) {
2480 return $str;
2481 } else {
2482 $str[0] = strtolower( $str[0] );
2483 return $str;
2484 }
2485 }
2486
2487 /**
2488 * @param $str string
2489 * @param $first bool
2490 * @return mixed|string
2491 */
2492 function lc( $str, $first = false ) {
2493 if ( function_exists( 'mb_strtolower' ) ) {
2494 if ( $first ) {
2495 if ( $this->isMultibyte( $str ) ) {
2496 return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
2497 } else {
2498 return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
2499 }
2500 } else {
2501 return $this->isMultibyte( $str ) ? mb_strtolower( $str ) : strtolower( $str );
2502 }
2503 } else {
2504 if ( $this->isMultibyte( $str ) ) {
2505 $x = $first ? '^' : '';
2506 return preg_replace_callback(
2507 "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
2508 array( $this, 'lcCallback' ),
2509 $str
2510 );
2511 } else {
2512 return $first ? strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
2513 }
2514 }
2515 }
2516
2517 /**
2518 * @param $str string
2519 * @return bool
2520 */
2521 function isMultibyte( $str ) {
2522 return (bool)preg_match( '/[\x80-\xff]/', $str );
2523 }
2524
2525 /**
2526 * @param $str string
2527 * @return mixed|string
2528 */
2529 function ucwords( $str ) {
2530 if ( $this->isMultibyte( $str ) ) {
2531 $str = $this->lc( $str );
2532
2533 // regexp to find first letter in each word (i.e. after each space)
2534 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2535
2536 // function to use to capitalize a single char
2537 if ( function_exists( 'mb_strtoupper' ) ) {
2538 return preg_replace_callback(
2539 $replaceRegexp,
2540 array( $this, 'ucwordsCallbackMB' ),
2541 $str
2542 );
2543 } else {
2544 return preg_replace_callback(
2545 $replaceRegexp,
2546 array( $this, 'ucwordsCallbackWiki' ),
2547 $str
2548 );
2549 }
2550 } else {
2551 return ucwords( strtolower( $str ) );
2552 }
2553 }
2554
2555 /**
2556 * capitalize words at word breaks
2557 *
2558 * @param $str string
2559 * @return mixed
2560 */
2561 function ucwordbreaks( $str ) {
2562 if ( $this->isMultibyte( $str ) ) {
2563 $str = $this->lc( $str );
2564
2565 // since \b doesn't work for UTF-8, we explicitely define word break chars
2566 $breaks = "[ \-\(\)\}\{\.,\?!]";
2567
2568 // find first letter after word break
2569 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2570
2571 if ( function_exists( 'mb_strtoupper' ) ) {
2572 return preg_replace_callback(
2573 $replaceRegexp,
2574 array( $this, 'ucwordbreaksCallbackMB' ),
2575 $str
2576 );
2577 } else {
2578 return preg_replace_callback(
2579 $replaceRegexp,
2580 array( $this, 'ucwordsCallbackWiki' ),
2581 $str
2582 );
2583 }
2584 } else {
2585 return preg_replace_callback(
2586 '/\b([\w\x80-\xff]+)\b/',
2587 array( $this, 'ucwordbreaksCallbackAscii' ),
2588 $str
2589 );
2590 }
2591 }
2592
2593 /**
2594 * Return a case-folded representation of $s
2595 *
2596 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2597 * and $s2 are the same except for the case of their characters. It is not
2598 * necessary for the value returned to make sense when displayed.
2599 *
2600 * Do *not* perform any other normalisation in this function. If a caller
2601 * uses this function when it should be using a more general normalisation
2602 * function, then fix the caller.
2603 *
2604 * @param $s string
2605 *
2606 * @return string
2607 */
2608 function caseFold( $s ) {
2609 return $this->uc( $s );
2610 }
2611
2612 /**
2613 * @param $s string
2614 * @return string
2615 */
2616 function checkTitleEncoding( $s ) {
2617 if ( is_array( $s ) ) {
2618 throw new MWException( 'Given array to checkTitleEncoding.' );
2619 }
2620 if ( StringUtils::isUtf8( $s ) ) {
2621 return $s;
2622 }
2623
2624 return $this->iconv( $this->fallback8bitEncoding(), 'utf-8', $s );
2625 }
2626
2627 /**
2628 * @return array
2629 */
2630 function fallback8bitEncoding() {
2631 return self::$dataCache->getItem( $this->mCode, 'fallback8bitEncoding' );
2632 }
2633
2634 /**
2635 * Most writing systems use whitespace to break up words.
2636 * Some languages such as Chinese don't conventionally do this,
2637 * which requires special handling when breaking up words for
2638 * searching etc.
2639 *
2640 * @return bool
2641 */
2642 function hasWordBreaks() {
2643 return true;
2644 }
2645
2646 /**
2647 * Some languages such as Chinese require word segmentation,
2648 * Specify such segmentation when overridden in derived class.
2649 *
2650 * @param $string String
2651 * @return String
2652 */
2653 function segmentByWord( $string ) {
2654 return $string;
2655 }
2656
2657 /**
2658 * Some languages have special punctuation need to be normalized.
2659 * Make such changes here.
2660 *
2661 * @param $string String
2662 * @return String
2663 */
2664 function normalizeForSearch( $string ) {
2665 return self::convertDoubleWidth( $string );
2666 }
2667
2668 /**
2669 * convert double-width roman characters to single-width.
2670 * range: ff00-ff5f ~= 0020-007f
2671 *
2672 * @param $string string
2673 *
2674 * @return string
2675 */
2676 protected static function convertDoubleWidth( $string ) {
2677 static $full = null;
2678 static $half = null;
2679
2680 if ( $full === null ) {
2681 $fullWidth = "０１２３４５６７８９ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ";
2682 $halfWidth = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
2683 $full = str_split( $fullWidth, 3 );
2684 $half = str_split( $halfWidth );
2685 }
2686
2687 $string = str_replace( $full, $half, $string );
2688 return $string;
2689 }
2690
2691 /**
2692 * @param $string string
2693 * @param $pattern string
2694 * @return string
2695 */
2696 protected static function insertSpace( $string, $pattern ) {
2697 $string = preg_replace( $pattern, " $1 ", $string );
2698 $string = preg_replace( '/ +/', ' ', $string );
2699 return $string;
2700 }
2701
2702 /**
2703 * @param $termsArray array
2704 * @return array
2705 */
2706 function convertForSearchResult( $termsArray ) {
2707 # some languages, e.g. Chinese, need to do a conversion
2708 # in order for search results to be displayed correctly
2709 return $termsArray;
2710 }
2711
2712 /**
2713 * Get the first character of a string.
2714 *
2715 * @param $s string
2716 * @return string
2717 */
2718 function firstChar( $s ) {
2719 $matches = array();
2720 preg_match(
2721 '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
2722 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/',
2723 $s,
2724 $matches
2725 );
2726
2727 if ( isset( $matches[1] ) ) {
2728 if ( strlen( $matches[1] ) != 3 ) {
2729 return $matches[1];
2730 }
2731
2732 // Break down Hangul syllables to grab the first jamo
2733 $code = utf8ToCodepoint( $matches[1] );
2734 if ( $code < 0xac00 || 0xd7a4 <= $code ) {
2735 return $matches[1];
2736 } elseif ( $code < 0xb098 ) {
2737 return "\xe3\x84\xb1";
2738 } elseif ( $code < 0xb2e4 ) {
2739 return "\xe3\x84\xb4";
2740 } elseif ( $code < 0xb77c ) {
2741 return "\xe3\x84\xb7";
2742 } elseif ( $code < 0xb9c8 ) {
2743 return "\xe3\x84\xb9";
2744 } elseif ( $code < 0xbc14 ) {
2745 return "\xe3\x85\x81";
2746 } elseif ( $code < 0xc0ac ) {
2747 return "\xe3\x85\x82";
2748 } elseif ( $code < 0xc544 ) {
2749 return "\xe3\x85\x85";
2750 } elseif ( $code < 0xc790 ) {
2751 return "\xe3\x85\x87";
2752 } elseif ( $code < 0xcc28 ) {
2753 return "\xe3\x85\x88";
2754 } elseif ( $code < 0xce74 ) {
2755 return "\xe3\x85\x8a";
2756 } elseif ( $code < 0xd0c0 ) {
2757 return "\xe3\x85\x8b";
2758 } elseif ( $code < 0xd30c ) {
2759 return "\xe3\x85\x8c";
2760 } elseif ( $code < 0xd558 ) {
2761 return "\xe3\x85\x8d";
2762 } else {
2763 return "\xe3\x85\x8e";
2764 }
2765 } else {
2766 return '';
2767 }
2768 }
2769
2770 function initEncoding() {
2771 # Some languages may have an alternate char encoding option
2772 # (Esperanto X-coding, Japanese furigana conversion, etc)
2773 # If this language is used as the primary content language,
2774 # an override to the defaults can be set here on startup.
2775 }
2776
2777 /**
2778 * @param $s string
2779 * @return string
2780 */
2781 function recodeForEdit( $s ) {
2782 # For some languages we'll want to explicitly specify
2783 # which characters make it into the edit box raw
2784 # or are converted in some way or another.
2785 global $wgEditEncoding;
2786 if ( $wgEditEncoding == '' || $wgEditEncoding == 'UTF-8' ) {
2787 return $s;
2788 } else {
2789 return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
2790 }
2791 }
2792
2793 /**
2794 * @param $s string
2795 * @return string
2796 */
2797 function recodeInput( $s ) {
2798 # Take the previous into account.
2799 global $wgEditEncoding;
2800 if ( $wgEditEncoding != '' ) {
2801 $enc = $wgEditEncoding;
2802 } else {
2803 $enc = 'UTF-8';
2804 }
2805 if ( $enc == 'UTF-8' ) {
2806 return $s;
2807 } else {
2808 return $this->iconv( $enc, 'UTF-8', $s );
2809 }
2810 }
2811
2812 /**
2813 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2814 * also cleans up certain backwards-compatible sequences, converting them
2815 * to the modern Unicode equivalent.
2816 *
2817 * This is language-specific for performance reasons only.
2818 *
2819 * @param $s string
2820 *
2821 * @return string
2822 */
2823 function normalize( $s ) {
2824 global $wgAllUnicodeFixes;
2825 $s = UtfNormal::cleanUp( $s );
2826 if ( $wgAllUnicodeFixes ) {
2827 $s = $this->transformUsingPairFile( 'normalize-ar.ser', $s );
2828 $s = $this->transformUsingPairFile( 'normalize-ml.ser', $s );
2829 }
2830
2831 return $s;
2832 }
2833
2834 /**
2835 * Transform a string using serialized data stored in the given file (which
2836 * must be in the serialized subdirectory of $IP). The file contains pairs
2837 * mapping source characters to destination characters.
2838 *
2839 * The data is cached in process memory. This will go faster if you have the
2840 * FastStringSearch extension.
2841 *
2842 * @param $file string
2843 * @param $string string
2844 *
2845 * @throws MWException
2846 * @return string
2847 */
2848 function transformUsingPairFile( $file, $string ) {
2849 if ( !isset( $this->transformData[$file] ) ) {
2850 $data = wfGetPrecompiledData( $file );
2851 if ( $data === false ) {
2852 throw new MWException( __METHOD__ . ": The transformation file $file is missing" );
2853 }
2854 $this->transformData[$file] = new ReplacementArray( $data );
2855 }
2856 return $this->transformData[$file]->replace( $string );
2857 }
2858
2859 /**
2860 * For right-to-left language support
2861 *
2862 * @return bool
2863 */
2864 function isRTL() {
2865 return self::$dataCache->getItem( $this->mCode, 'rtl' );
2866 }
2867
2868 /**
2869 * Return the correct HTML 'dir' attribute value for this language.
2870 * @return String
2871 */
2872 function getDir() {
2873 return $this->isRTL() ? 'rtl' : 'ltr';
2874 }
2875
2876 /**
2877 * Return 'left' or 'right' as appropriate alignment for line-start
2878 * for this language's text direction.
2879 *
2880 * Should be equivalent to CSS3 'start' text-align value....
2881 *
2882 * @return String
2883 */
2884 function alignStart() {
2885 return $this->isRTL() ? 'right' : 'left';
2886 }
2887
2888 /**
2889 * Return 'right' or 'left' as appropriate alignment for line-end
2890 * for this language's text direction.
2891 *
2892 * Should be equivalent to CSS3 'end' text-align value....
2893 *
2894 * @return String
2895 */
2896 function alignEnd() {
2897 return $this->isRTL() ? 'left' : 'right';
2898 }
2899
2900 /**
2901 * A hidden direction mark (LRM or RLM), depending on the language direction.
2902 * Unlike getDirMark(), this function returns the character as an HTML entity.
2903 * This function should be used when the output is guaranteed to be HTML,
2904 * because it makes the output HTML source code more readable. When
2905 * the output is plain text or can be escaped, getDirMark() should be used.
2906 *
2907 * @param $opposite Boolean Get the direction mark opposite to your language
2908 * @return string
2909 * @since 1.20
2910 */
2911 function getDirMarkEntity( $opposite = false ) {
2912 if ( $opposite ) {
2913 return $this->isRTL() ? '&lrm;' : '&rlm;';
2914 }
2915 return $this->isRTL() ? '&rlm;' : '&lrm;';
2916 }
2917
2918 /**
2919 * A hidden direction mark (LRM or RLM), depending on the language direction.
2920 * This function produces them as invisible Unicode characters and
2921 * the output may be hard to read and debug, so it should only be used
2922 * when the output is plain text or can be escaped. When the output is
2923 * HTML, use getDirMarkEntity() instead.
2924 *
2925 * @param $opposite Boolean Get the direction mark opposite to your language
2926 * @return string
2927 */
2928 function getDirMark( $opposite = false ) {
2929 $lrm = "\xE2\x80\x8E"; # LEFT-TO-RIGHT MARK, commonly abbreviated LRM
2930 $rlm = "\xE2\x80\x8F"; # RIGHT-TO-LEFT MARK, commonly abbreviated RLM
2931 if ( $opposite ) {
2932 return $this->isRTL() ? $lrm : $rlm;
2933 }
2934 return $this->isRTL() ? $rlm : $lrm;
2935 }
2936
2937 /**
2938 * @return array
2939 */
2940 function capitalizeAllNouns() {
2941 return self::$dataCache->getItem( $this->mCode, 'capitalizeAllNouns' );
2942 }
2943
2944 /**
2945 * An arrow, depending on the language direction.
2946 *
2947 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2948 * @return string
2949 */
2950 function getArrow( $direction = 'forwards' ) {
2951 switch ( $direction ) {
2952 case 'forwards':
2953 return $this->isRTL() ? '←' : '→';
2954 case 'backwards':
2955 return $this->isRTL() ? '→' : '←';
2956 case 'left':
2957 return '←';
2958 case 'right':
2959 return '→';
2960 case 'up':
2961 return '↑';
2962 case 'down':
2963 return '↓';
2964 }
2965 }
2966
2967 /**
2968 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2969 *
2970 * @return bool
2971 */
2972 function linkPrefixExtension() {
2973 return self::$dataCache->getItem( $this->mCode, 'linkPrefixExtension' );
2974 }
2975
2976 /**
2977 * Get all magic words from cache.
2978 * @return array
2979 */
2980 function getMagicWords() {
2981 return self::$dataCache->getItem( $this->mCode, 'magicWords' );
2982 }
2983
2984 /**
2985 * Run the LanguageGetMagic hook once.
2986 */
2987 protected function doMagicHook() {
2988 if ( $this->mMagicHookDone ) {
2989 return;
2990 }
2991 $this->mMagicHookDone = true;
2992 wfProfileIn( 'LanguageGetMagic' );
2993 wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
2994 wfProfileOut( 'LanguageGetMagic' );
2995 }
2996
2997 /**
2998 * Fill a MagicWord object with data from here
2999 *
3000 * @param $mw
3001 */
3002 function getMagic( $mw ) {
3003 // Saves a function call
3004 if ( ! $this->mMagicHookDone ) {
3005 $this->doMagicHook();
3006 }
3007
3008 if ( isset( $this->mMagicExtensions[$mw->mId] ) ) {
3009 $rawEntry = $this->mMagicExtensions[$mw->mId];
3010 } else {
3011 $rawEntry = self::$dataCache->getSubitem(
3012 $this->mCode, 'magicWords', $mw->mId );
3013 }
3014
3015 if ( !is_array( $rawEntry ) ) {
3016 error_log( "\"$rawEntry\" is not a valid magic word for \"$mw->mId\"" );
3017 } else {
3018 $mw->mCaseSensitive = $rawEntry[0];
3019 $mw->mSynonyms = array_slice( $rawEntry, 1 );
3020 }
3021 }
3022
3023 /**
3024 * Add magic words to the extension array
3025 *
3026 * @param $newWords array
3027 */
3028 function addMagicWordsByLang( $newWords ) {
3029 $fallbackChain = $this->getFallbackLanguages();
3030 $fallbackChain = array_reverse( $fallbackChain );
3031 foreach ( $fallbackChain as $code ) {
3032 if ( isset( $newWords[$code] ) ) {
3033 $this->mMagicExtensions = $newWords[$code] + $this->mMagicExtensions;
3034 }
3035 }
3036 }
3037
3038 /**
3039 * Get special page names, as an associative array
3040 * case folded alias => real name
3041 */
3042 function getSpecialPageAliases() {
3043 // Cache aliases because it may be slow to load them
3044 if ( is_null( $this->mExtendedSpecialPageAliases ) ) {
3045 // Initialise array
3046 $this->mExtendedSpecialPageAliases =
3047 self::$dataCache->getItem( $this->mCode, 'specialPageAliases' );
3048 wfRunHooks( 'LanguageGetSpecialPageAliases',
3049 array( &$this->mExtendedSpecialPageAliases, $this->getCode() ) );
3050 }
3051
3052 return $this->mExtendedSpecialPageAliases;
3053 }
3054
3055 /**
3056 * Italic is unsuitable for some languages
3057 *
3058 * @param $text String: the text to be emphasized.
3059 * @return string
3060 */
3061 function emphasize( $text ) {
3062 return "<em>$text</em>";
3063 }
3064
3065 /**
3066 * Normally we output all numbers in plain en_US style, that is
3067 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3068 * point twohundredthirtyfive. However this is not suitable for all
3069 * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3070 * Icelandic just want to use commas instead of dots, and dots instead
3071 * of commas like "293.291,235".
3072 *
3073 * An example of this function being called:
3074 * <code>
3075 * wfMessage( 'message' )->numParams( $num )->text()
3076 * </code>
3077 *
3078 * See LanguageGu.php for the Gujarati implementation and
3079 * $separatorTransformTable on MessageIs.php for
3080 * the , => . and . => , implementation.
3081 *
3082 * @todo check if it's viable to use localeconv() for the decimal
3083 * separator thing.
3084 * @param $number Mixed: the string to be formatted, should be an integer
3085 * or a floating point number.
3086 * @param $nocommafy Bool: set to true for special numbers like dates
3087 * @return string
3088 */
3089 public function formatNum( $number, $nocommafy = false ) {
3090 global $wgTranslateNumerals;
3091 if ( !$nocommafy ) {
3092 $number = $this->commafy( $number );
3093 $s = $this->separatorTransformTable();
3094 if ( $s ) {
3095 $number = strtr( $number, $s );
3096 }
3097 }
3098
3099 if ( $wgTranslateNumerals ) {
3100 $s = $this->digitTransformTable();
3101 if ( $s ) {
3102 $number = strtr( $number, $s );
3103 }
3104 }
3105
3106 return $number;
3107 }
3108
3109 /**
3110 * Front-end for non-commafied formatNum
3111 *
3112 * @param mixed $number the string to be formatted, should be an integer
3113 * or a floating point number.
3114 * @since 1.21
3115 * @return string
3116 */
3117 public function formatNumNoSeparators( $number ) {
3118 return $this->formatNum( $number, true );
3119 }
3120
3121 /**
3122 * @param $number string
3123 * @return string
3124 */
3125 function parseFormattedNumber( $number ) {
3126 $s = $this->digitTransformTable();
3127 if ( $s ) {
3128 $number = strtr( $number, array_flip( $s ) );
3129 }
3130
3131 $s = $this->separatorTransformTable();
3132 if ( $s ) {
3133 $number = strtr( $number, array_flip( $s ) );
3134 }
3135
3136 $number = strtr( $number, array( ',' => '' ) );
3137 return $number;
3138 }
3139
3140 /**
3141 * Adds commas to a given number
3142 * @since 1.19
3143 * @param $number mixed
3144 * @return string
3145 */
3146 function commafy( $number ) {
3147 $digitGroupingPattern = $this->digitGroupingPattern();
3148 if ( $number === null ) {
3149 return '';
3150 }
3151
3152 if ( !$digitGroupingPattern || $digitGroupingPattern === "###,###,###" ) {
3153 // default grouping is at thousands, use the same for ###,###,### pattern too.
3154 return strrev( (string)preg_replace( '/(\d{3})(?=\d)(?!\d*\.)/', '$1,', strrev( $number ) ) );
3155 } else {
3156 // Ref: http://cldr.unicode.org/translation/number-patterns
3157 $sign = "";
3158 if ( intval( $number ) < 0 ) {
3159 // For negative numbers apply the algorithm like positive number and add sign.
3160 $sign = "-";
3161 $number = substr( $number, 1 );
3162 }
3163 $integerPart = array();
3164 $decimalPart = array();
3165 $numMatches = preg_match_all( "/(#+)/", $digitGroupingPattern, $matches );
3166 preg_match( "/\d+/", $number, $integerPart );
3167 preg_match( "/\.\d*/", $number, $decimalPart );
3168 $groupedNumber = ( count( $decimalPart ) > 0 ) ? $decimalPart[0] : "";
3169 if ( $groupedNumber === $number ) {
3170 // the string does not have any number part. Eg: .12345
3171 return $sign . $groupedNumber;
3172 }
3173 $start = $end = strlen( $integerPart[0] );
3174 while ( $start > 0 ) {
3175 $match = $matches[0][$numMatches - 1];
3176 $matchLen = strlen( $match );
3177 $start = $end - $matchLen;
3178 if ( $start < 0 ) {
3179 $start = 0;
3180 }
3181 $groupedNumber = substr( $number, $start, $end -$start ) . $groupedNumber;
3182 $end = $start;
3183 if ( $numMatches > 1 ) {
3184 // use the last pattern for the rest of the number
3185 $numMatches--;
3186 }
3187 if ( $start > 0 ) {
3188 $groupedNumber = "," . $groupedNumber;
3189 }
3190 }
3191 return $sign . $groupedNumber;
3192 }
3193 }
3194
3195 /**
3196 * @return String
3197 */
3198 function digitGroupingPattern() {
3199 return self::$dataCache->getItem( $this->mCode, 'digitGroupingPattern' );
3200 }
3201
3202 /**
3203 * @return array
3204 */
3205 function digitTransformTable() {
3206 return self::$dataCache->getItem( $this->mCode, 'digitTransformTable' );
3207 }
3208
3209 /**
3210 * @return array
3211 */
3212 function separatorTransformTable() {
3213 return self::$dataCache->getItem( $this->mCode, 'separatorTransformTable' );
3214 }
3215
3216 /**
3217 * Take a list of strings and build a locale-friendly comma-separated
3218 * list, using the local comma-separator message.
3219 * The last two strings are chained with an "and".
3220 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3221 *
3222 * @param $l Array
3223 * @return string
3224 */
3225 function listToText( array $l ) {
3226 $m = count( $l ) - 1;
3227 if ( $m < 0 ) {
3228 return '';
3229 }
3230 if ( $m > 0 ) {
3231 $and = $this->getMessageFromDB( 'and' );
3232 $space = $this->getMessageFromDB( 'word-separator' );
3233 if ( $m > 1 ) {
3234 $comma = $this->getMessageFromDB( 'comma-separator' );
3235 }
3236 }
3237 $s = $l[$m];
3238 for ( $i = $m - 1; $i >= 0; $i-- ) {
3239 if ( $i == $m - 1 ) {
3240 $s = $l[$i] . $and . $space . $s;
3241 } else {
3242 $s = $l[$i] . $comma . $s;
3243 }
3244 }
3245 return $s;
3246 }
3247
3248 /**
3249 * Take a list of strings and build a locale-friendly comma-separated
3250 * list, using the local comma-separator message.
3251 * @param $list array of strings to put in a comma list
3252 * @return string
3253 */
3254 function commaList( array $list ) {
3255 return implode(
3256 wfMessage( 'comma-separator' )->inLanguage( $this )->escaped(),
3257 $list
3258 );
3259 }
3260
3261 /**
3262 * Take a list of strings and build a locale-friendly semicolon-separated
3263 * list, using the local semicolon-separator message.
3264 * @param $list array of strings to put in a semicolon list
3265 * @return string
3266 */
3267 function semicolonList( array $list ) {
3268 return implode(
3269 wfMessage( 'semicolon-separator' )->inLanguage( $this )->escaped(),
3270 $list
3271 );
3272 }
3273
3274 /**
3275 * Same as commaList, but separate it with the pipe instead.
3276 * @param $list array of strings to put in a pipe list
3277 * @return string
3278 */
3279 function pipeList( array $list ) {
3280 return implode(
3281 wfMessage( 'pipe-separator' )->inLanguage( $this )->escaped(),
3282 $list
3283 );
3284 }
3285
3286 /**
3287 * Truncate a string to a specified length in bytes, appending an optional
3288 * string (e.g. for ellipses)
3289 *
3290 * The database offers limited byte lengths for some columns in the database;
3291 * multi-byte character sets mean we need to ensure that only whole characters
3292 * are included, otherwise broken characters can be passed to the user
3293 *
3294 * If $length is negative, the string will be truncated from the beginning
3295 *
3296 * @param $string String to truncate
3297 * @param $length Int: maximum length (including ellipses)
3298 * @param $ellipsis String to append to the truncated text
3299 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3300 * $adjustLength was introduced in 1.18, before that behaved as if false.
3301 * @return string
3302 */
3303 function truncate( $string, $length, $ellipsis = '...', $adjustLength = true ) {
3304 # Use the localized ellipsis character
3305 if ( $ellipsis == '...' ) {
3306 $ellipsis = wfMessage( 'ellipsis' )->inLanguage( $this )->escaped();
3307 }
3308 # Check if there is no need to truncate
3309 if ( $length == 0 ) {
3310 return $ellipsis; // convention
3311 } elseif ( strlen( $string ) <= abs( $length ) ) {
3312 return $string; // no need to truncate
3313 }
3314 $stringOriginal = $string;
3315 # If ellipsis length is >= $length then we can't apply $adjustLength
3316 if ( $adjustLength && strlen( $ellipsis ) >= abs( $length ) ) {
3317 $string = $ellipsis; // this can be slightly unexpected
3318 # Otherwise, truncate and add ellipsis...
3319 } else {
3320 $eLength = $adjustLength ? strlen( $ellipsis ) : 0;
3321 if ( $length > 0 ) {
3322 $length -= $eLength;
3323 $string = substr( $string, 0, $length ); // xyz...
3324 $string = $this->removeBadCharLast( $string );
3325 $string = rtrim( $string );
3326 $string = $string . $ellipsis;
3327 } else {
3328 $length += $eLength;
3329 $string = substr( $string, $length ); // ...xyz
3330 $string = $this->removeBadCharFirst( $string );
3331 $string = ltrim( $string );
3332 $string = $ellipsis . $string;
3333 }
3334 }
3335 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3336 # This check is *not* redundant if $adjustLength, due to the single case where
3337 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3338 if ( strlen( $string ) < strlen( $stringOriginal ) ) {
3339 return $string;
3340 } else {
3341 return $stringOriginal;
3342 }
3343 }
3344
3345 /**
3346 * Remove bytes that represent an incomplete Unicode character
3347 * at the end of string (e.g. bytes of the char are missing)
3348 *
3349 * @param $string String
3350 * @return string
3351 */
3352 protected function removeBadCharLast( $string ) {
3353 if ( $string != '' ) {
3354 $char = ord( $string[strlen( $string ) - 1] );
3355 $m = array();
3356 if ( $char >= 0xc0 ) {
3357 # We got the first byte only of a multibyte char; remove it.
3358 $string = substr( $string, 0, -1 );
3359 } elseif ( $char >= 0x80 &&
3360 preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
3361 '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m )
3362 ) {
3363 # We chopped in the middle of a character; remove it
3364 $string = $m[1];
3365 }
3366 }
3367 return $string;
3368 }
3369
3370 /**
3371 * Remove bytes that represent an incomplete Unicode character
3372 * at the start of string (e.g. bytes of the char are missing)
3373 *
3374 * @param $string String
3375 * @return string
3376 */
3377 protected function removeBadCharFirst( $string ) {
3378 if ( $string != '' ) {
3379 $char = ord( $string[0] );
3380 if ( $char >= 0x80 && $char < 0xc0 ) {
3381 # We chopped in the middle of a character; remove the whole thing
3382 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
3383 }
3384 }
3385 return $string;
3386 }
3387
3388 /**
3389 * Truncate a string of valid HTML to a specified length in bytes,
3390 * appending an optional string (e.g. for ellipses), and return valid HTML
3391 *
3392 * This is only intended for styled/linked text, such as HTML with
3393 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3394 * Also, this will not detect things like "display:none" CSS.
3395 *
3396 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3397 *
3398 * @param string $text HTML string to truncate
3399 * @param int $length (zero/positive) Maximum length (including ellipses)
3400 * @param string $ellipsis String to append to the truncated text
3401 * @return string
3402 */
3403 function truncateHtml( $text, $length, $ellipsis = '...' ) {
3404 # Use the localized ellipsis character
3405 if ( $ellipsis == '...' ) {
3406 $ellipsis = wfMessage( 'ellipsis' )->inLanguage( $this )->escaped();
3407 }
3408 # Check if there is clearly no need to truncate
3409 if ( $length <= 0 ) {
3410 return $ellipsis; // no text shown, nothing to format (convention)
3411 } elseif ( strlen( $text ) <= $length ) {
3412 return $text; // string short enough even *with* HTML (short-circuit)
3413 }
3414
3415 $dispLen = 0; // innerHTML legth so far
3416 $testingEllipsis = false; // checking if ellipses will make string longer/equal?
3417 $tagType = 0; // 0-open, 1-close
3418 $bracketState = 0; // 1-tag start, 2-tag name, 0-neither
3419 $entityState = 0; // 0-not entity, 1-entity
3420 $tag = $ret = ''; // accumulated tag name, accumulated result string
3421 $openTags = array(); // open tag stack
3422 $maybeState = null; // possible truncation state
3423
3424 $textLen = strlen( $text );
3425 $neLength = max( 0, $length - strlen( $ellipsis ) ); // non-ellipsis len if truncated
3426 for ( $pos = 0; true; ++$pos ) {
3427 # Consider truncation once the display length has reached the maximim.
3428 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3429 # Check that we're not in the middle of a bracket/entity...
3430 if ( $dispLen && $dispLen >= $neLength && $bracketState == 0 && !$entityState ) {
3431 if ( !$testingEllipsis ) {
3432 $testingEllipsis = true;
3433 # Save where we are; we will truncate here unless there turn out to
3434 # be so few remaining characters that truncation is not necessary.
3435 if ( !$maybeState ) { // already saved? ($neLength = 0 case)
3436 $maybeState = array( $ret, $openTags ); // save state
3437 }
3438 } elseif ( $dispLen > $length && $dispLen > strlen( $ellipsis ) ) {
3439 # String in fact does need truncation, the truncation point was OK.
3440 list( $ret, $openTags ) = $maybeState; // reload state
3441 $ret = $this->removeBadCharLast( $ret ); // multi-byte char fix
3442 $ret .= $ellipsis; // add ellipsis
3443 break;
3444 }
3445 }
3446 if ( $pos >= $textLen ) {
3447 break; // extra iteration just for above checks
3448 }
3449
3450 # Read the next char...
3451 $ch = $text[$pos];
3452 $lastCh = $pos ? $text[$pos - 1] : '';
3453 $ret .= $ch; // add to result string
3454 if ( $ch == '<' ) {
3455 $this->truncate_endBracket( $tag, $tagType, $lastCh, $openTags ); // for bad HTML
3456 $entityState = 0; // for bad HTML
3457 $bracketState = 1; // tag started (checking for backslash)
3458 } elseif ( $ch == '>' ) {
3459 $this->truncate_endBracket( $tag, $tagType, $lastCh, $openTags );
3460 $entityState = 0; // for bad HTML
3461 $bracketState = 0; // out of brackets
3462 } elseif ( $bracketState == 1 ) {
3463 if ( $ch == '/' ) {
3464 $tagType = 1; // close tag (e.g. "</span>")
3465 } else {
3466 $tagType = 0; // open tag (e.g. "<span>")
3467 $tag .= $ch;
3468 }
3469 $bracketState = 2; // building tag name
3470 } elseif ( $bracketState == 2 ) {
3471 if ( $ch != ' ' ) {
3472 $tag .= $ch;
3473 } else {
3474 // Name found (e.g. "<a href=..."), add on tag attributes...
3475 $pos += $this->truncate_skip( $ret, $text, "<>", $pos + 1 );
3476 }
3477 } elseif ( $bracketState == 0 ) {
3478 if ( $entityState ) {
3479 if ( $ch == ';' ) {
3480 $entityState = 0;
3481 $dispLen++; // entity is one displayed char
3482 }
3483 } else {
3484 if ( $neLength == 0 && !$maybeState ) {
3485 // Save state without $ch. We want to *hit* the first
3486 // display char (to get tags) but not *use* it if truncating.
3487 $maybeState = array( substr( $ret, 0, -1 ), $openTags );
3488 }
3489 if ( $ch == '&' ) {
3490 $entityState = 1; // entity found, (e.g. "&#160;")
3491 } else {
3492 $dispLen++; // this char is displayed
3493 // Add the next $max display text chars after this in one swoop...
3494 $max = ( $testingEllipsis ? $length : $neLength ) - $dispLen;
3495 $skipped = $this->truncate_skip( $ret, $text, "<>&", $pos + 1, $max );
3496 $dispLen += $skipped;
3497 $pos += $skipped;
3498 }
3499 }
3500 }
3501 }
3502 // Close the last tag if left unclosed by bad HTML
3503 $this->truncate_endBracket( $tag, $text[$textLen - 1], $tagType, $openTags );
3504 while ( count( $openTags ) > 0 ) {
3505 $ret .= '</' . array_pop( $openTags ) . '>'; // close open tags
3506 }
3507 return $ret;
3508 }
3509
3510 /**
3511 * truncateHtml() helper function
3512 * like strcspn() but adds the skipped chars to $ret
3513 *
3514 * @param $ret
3515 * @param $text
3516 * @param $search
3517 * @param $start
3518 * @param $len
3519 * @return int
3520 */
3521 private function truncate_skip( &$ret, $text, $search, $start, $len = null ) {
3522 if ( $len === null ) {
3523 $len = -1; // -1 means "no limit" for strcspn
3524 } elseif ( $len < 0 ) {
3525 $len = 0; // sanity
3526 }
3527 $skipCount = 0;
3528 if ( $start < strlen( $text ) ) {
3529 $skipCount = strcspn( $text, $search, $start, $len );
3530 $ret .= substr( $text, $start, $skipCount );
3531 }
3532 return $skipCount;
3533 }
3534
3535 /**
3536 * truncateHtml() helper function
3537 * (a) push or pop $tag from $openTags as needed
3538 * (b) clear $tag value
3539 * @param &$tag string Current HTML tag name we are looking at
3540 * @param $tagType int (0-open tag, 1-close tag)
3541 * @param $lastCh string Character before the '>' that ended this tag
3542 * @param &$openTags array Open tag stack (not accounting for $tag)
3543 */
3544 private function truncate_endBracket( &$tag, $tagType, $lastCh, &$openTags ) {
3545 $tag = ltrim( $tag );
3546 if ( $tag != '' ) {
3547 if ( $tagType == 0 && $lastCh != '/' ) {
3548 $openTags[] = $tag; // tag opened (didn't close itself)
3549 } elseif ( $tagType == 1 ) {
3550 if ( $openTags && $tag == $openTags[count( $openTags ) - 1] ) {
3551 array_pop( $openTags ); // tag closed
3552 }
3553 }
3554 $tag = '';
3555 }
3556 }
3557
3558 /**
3559 * Grammatical transformations, needed for inflected languages
3560 * Invoked by putting {{grammar:case|word}} in a message
3561 *
3562 * @param $word string
3563 * @param $case string
3564 * @return string
3565 */
3566 function convertGrammar( $word, $case ) {
3567 global $wgGrammarForms;
3568 if ( isset( $wgGrammarForms[$this->getCode()][$case][$word] ) ) {
3569 return $wgGrammarForms[$this->getCode()][$case][$word];
3570 }
3571 return $word;
3572 }
3573 /**
3574 * Get the grammar forms for the content language
3575 * @return array of grammar forms
3576 * @since 1.20
3577 */
3578 function getGrammarForms() {
3579 global $wgGrammarForms;
3580 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3581 return $wgGrammarForms[$this->getCode()];
3582 }
3583 return array();
3584 }
3585 /**
3586 * Provides an alternative text depending on specified gender.
3587 * Usage {{gender:username|masculine|feminine|neutral}}.
3588 * username is optional, in which case the gender of current user is used,
3589 * but only in (some) interface messages; otherwise default gender is used.
3590 *
3591 * If no forms are given, an empty string is returned. If only one form is
3592 * given, it will be returned unconditionally. These details are implied by
3593 * the caller and cannot be overridden in subclasses.
3594 *
3595 * If more than one form is given, the default is to use the neutral one
3596 * if it is specified, and to use the masculine one otherwise. These
3597 * details can be overridden in subclasses.
3598 *
3599 * @param $gender string
3600 * @param $forms array
3601 *
3602 * @return string
3603 */
3604 function gender( $gender, $forms ) {
3605 if ( !count( $forms ) ) {
3606 return '';
3607 }
3608 $forms = $this->preConvertPlural( $forms, 2 );
3609 if ( $gender === 'male' ) {
3610 return $forms[0];
3611 }
3612 if ( $gender === 'female' ) {
3613 return $forms[1];
3614 }
3615 return isset( $forms[2] ) ? $forms[2] : $forms[0];
3616 }
3617
3618 /**
3619 * Plural form transformations, needed for some languages.
3620 * For example, there are 3 form of plural in Russian and Polish,
3621 * depending on "count mod 10". See [[w:Plural]]
3622 * For English it is pretty simple.
3623 *
3624 * Invoked by putting {{plural:count|wordform1|wordform2}}
3625 * or {{plural:count|wordform1|wordform2|wordform3}}
3626 *
3627 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3628 *
3629 * @param $count Integer: non-localized number
3630 * @param $forms Array: different plural forms
3631 * @return string Correct form of plural for $count in this language
3632 */
3633 function convertPlural( $count, $forms ) {
3634 // Handle explicit n=pluralform cases
3635 $forms = $this->handleExplicitPluralForms( $count, $forms );
3636 if ( is_string( $forms ) ) {
3637 return $forms;
3638 }
3639 if ( !count( $forms ) ) {
3640 return '';
3641 }
3642
3643 $pluralForm = $this->getPluralRuleIndexNumber( $count );
3644 $pluralForm = min( $pluralForm, count( $forms ) - 1 );
3645 return $forms[$pluralForm];
3646 }
3647
3648 /**
3649 * Handles explicit plural forms for Language::convertPlural()
3650 *
3651 * In {{PLURAL:$1|0=nothing|one|many}}, 0=nothing will be returned if $1 equals zero.
3652 * If an explicitly defined plural form matches the $count, then
3653 * string value returned, otherwise array returned for further consideration
3654 * by CLDR rules or overridden convertPlural().
3655 *
3656 * @since 1.23
3657 *
3658 * @param int $count non-localized number
3659 * @param array $forms different plural forms
3660 *
3661 * @return array|string
3662 */
3663 protected function handleExplicitPluralForms( $count, array $forms ) {
3664 foreach ( $forms as $index => $form ) {
3665 if ( preg_match( '/\d+=/i', $form ) ) {
3666 $pos = strpos( $form, '=' );
3667 if ( substr( $form, 0, $pos ) === (string) $count ) {
3668 return substr( $form, $pos + 1 );
3669 }
3670 unset( $forms[$index] );
3671 }
3672 }
3673 return array_values( $forms );
3674 }
3675
3676 /**
3677 * Checks that convertPlural was given an array and pads it to requested
3678 * amount of forms by copying the last one.
3679 *
3680 * @param $count Integer: How many forms should there be at least
3681 * @param $forms Array of forms given to convertPlural
3682 * @return array Padded array of forms or an exception if not an array
3683 */
3684 protected function preConvertPlural( /* Array */ $forms, $count ) {
3685 while ( count( $forms ) < $count ) {
3686 $forms[] = $forms[count( $forms ) - 1];
3687 }
3688 return $forms;
3689 }
3690
3691 /**
3692 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3693 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3694 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3695 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3696 * match up with it.
3697 *
3698 * @param $str String: the validated block duration in English
3699 * @return string Somehow translated block duration
3700 * @see LanguageFi.php for example implementation
3701 */
3702 function translateBlockExpiry( $str ) {
3703 $duration = SpecialBlock::getSuggestedDurations( $this );
3704 foreach ( $duration as $show => $value ) {
3705 if ( strcmp( $str, $value ) == 0 ) {
3706 return htmlspecialchars( trim( $show ) );
3707 }
3708 }
3709
3710 // Since usually only infinite or indefinite is only on list, so try
3711 // equivalents if still here.
3712 $indefs = array( 'infinite', 'infinity', 'indefinite' );
3713 if ( in_array( $str, $indefs ) ) {
3714 foreach ( $indefs as $val ) {
3715 $show = array_search( $val, $duration, true );
3716 if ( $show !== false ) {
3717 return htmlspecialchars( trim( $show ) );
3718 }
3719 }
3720 }
3721
3722 // If all else fails, return a standard duration or timestamp description.
3723 $time = strtotime( $str, 0 );
3724 if ( $time === false ) { // Unknown format. Return it as-is in case.
3725 return $str;
3726 } elseif ( $time !== strtotime( $str, 1 ) ) { // It's a relative timestamp.
3727 // $time is relative to 0 so it's a duration length.
3728 return $this->formatDuration( $time );
3729 } else { // It's an absolute timestamp.
3730 if ( $time === 0 ) {
3731 // wfTimestamp() handles 0 as current time instead of epoch.
3732 return $this->timeanddate( '19700101000000' );
3733 } else {
3734 return $this->timeanddate( $time );
3735 }
3736 }
3737 }
3738
3739 /**
3740 * languages like Chinese need to be segmented in order for the diff
3741 * to be of any use
3742 *
3743 * @param $text String
3744 * @return String
3745 */
3746 public function segmentForDiff( $text ) {
3747 return $text;
3748 }
3749
3750 /**
3751 * and unsegment to show the result
3752 *
3753 * @param $text String
3754 * @return String
3755 */
3756 public function unsegmentForDiff( $text ) {
3757 return $text;
3758 }
3759
3760 /**
3761 * Return the LanguageConverter used in the Language
3762 *
3763 * @since 1.19
3764 * @return LanguageConverter
3765 */
3766 public function getConverter() {
3767 return $this->mConverter;
3768 }
3769
3770 /**
3771 * convert text to all supported variants
3772 *
3773 * @param $text string
3774 * @return array
3775 */
3776 public function autoConvertToAllVariants( $text ) {
3777 return $this->mConverter->autoConvertToAllVariants( $text );
3778 }
3779
3780 /**
3781 * convert text to different variants of a language.
3782 *
3783 * @param $text string
3784 * @return string
3785 */
3786 public function convert( $text ) {
3787 return $this->mConverter->convert( $text );
3788 }
3789
3790 /**
3791 * Convert a Title object to a string in the preferred variant
3792 *
3793 * @param $title Title
3794 * @return string
3795 */
3796 public function convertTitle( $title ) {
3797 return $this->mConverter->convertTitle( $title );
3798 }
3799
3800 /**
3801 * Convert a namespace index to a string in the preferred variant
3802 *
3803 * @param $ns int
3804 * @return string
3805 */
3806 public function convertNamespace( $ns ) {
3807 return $this->mConverter->convertNamespace( $ns );
3808 }
3809
3810 /**
3811 * Check if this is a language with variants
3812 *
3813 * @return bool
3814 */
3815 public function hasVariants() {
3816 return count( $this->getVariants() ) > 1;
3817 }
3818
3819 /**
3820 * Check if the language has the specific variant
3821 *
3822 * @since 1.19
3823 * @param $variant string
3824 * @return bool
3825 */
3826 public function hasVariant( $variant ) {
3827 return (bool)$this->mConverter->validateVariant( $variant );
3828 }
3829
3830 /**
3831 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3832 *
3833 * @param $text string
3834 * @return string
3835 * @deprecated since 1.22 is no longer used
3836 */
3837 public function armourMath( $text ) {
3838 return $this->mConverter->armourMath( $text );
3839 }
3840
3841 /**
3842 * Perform output conversion on a string, and encode for safe HTML output.
3843 * @param $text String text to be converted
3844 * @param $isTitle Bool whether this conversion is for the article title
3845 * @return string
3846 * @todo this should get integrated somewhere sane
3847 */
3848 public function convertHtml( $text, $isTitle = false ) {
3849 return htmlspecialchars( $this->convert( $text, $isTitle ) );
3850 }
3851
3852 /**
3853 * @param $key string
3854 * @return string
3855 */
3856 public function convertCategoryKey( $key ) {
3857 return $this->mConverter->convertCategoryKey( $key );
3858 }
3859
3860 /**
3861 * Get the list of variants supported by this language
3862 * see sample implementation in LanguageZh.php
3863 *
3864 * @return array an array of language codes
3865 */
3866 public function getVariants() {
3867 return $this->mConverter->getVariants();
3868 }
3869
3870 /**
3871 * @return string
3872 */
3873 public function getPreferredVariant() {
3874 return $this->mConverter->getPreferredVariant();
3875 }
3876
3877 /**
3878 * @return string
3879 */
3880 public function getDefaultVariant() {
3881 return $this->mConverter->getDefaultVariant();
3882 }
3883
3884 /**
3885 * @return string
3886 */
3887 public function getURLVariant() {
3888 return $this->mConverter->getURLVariant();
3889 }
3890
3891 /**
3892 * If a language supports multiple variants, it is
3893 * possible that non-existing link in one variant
3894 * actually exists in another variant. this function
3895 * tries to find it. See e.g. LanguageZh.php
3896 *
3897 * @param $link String: the name of the link
3898 * @param $nt Mixed: the title object of the link
3899 * @param $ignoreOtherCond Boolean: to disable other conditions when
3900 * we need to transclude a template or update a category's link
3901 * @return null the input parameters may be modified upon return
3902 */
3903 public function findVariantLink( &$link, &$nt, $ignoreOtherCond = false ) {
3904 $this->mConverter->findVariantLink( $link, $nt, $ignoreOtherCond );
3905 }
3906
3907 /**
3908 * If a language supports multiple variants, converts text
3909 * into an array of all possible variants of the text:
3910 * 'variant' => text in that variant
3911 *
3912 * @deprecated since 1.17 Use autoConvertToAllVariants()
3913 *
3914 * @param $text string
3915 *
3916 * @return string
3917 */
3918 public function convertLinkToAllVariants( $text ) {
3919 return $this->mConverter->convertLinkToAllVariants( $text );
3920 }
3921
3922 /**
3923 * returns language specific options used by User::getPageRenderHash()
3924 * for example, the preferred language variant
3925 *
3926 * @return string
3927 */
3928 function getExtraHashOptions() {
3929 return $this->mConverter->getExtraHashOptions();
3930 }
3931
3932 /**
3933 * For languages that support multiple variants, the title of an
3934 * article may be displayed differently in different variants. this
3935 * function returns the apporiate title defined in the body of the article.
3936 *
3937 * @return string
3938 */
3939 public function getParsedTitle() {
3940 return $this->mConverter->getParsedTitle();
3941 }
3942
3943 /**
3944 * Prepare external link text for conversion. When the text is
3945 * a URL, it shouldn't be converted, and it'll be wrapped in
3946 * the "raw" tag (-{R| }-) to prevent conversion.
3947 *
3948 * This function is called "markNoConversion" for historical
3949 * reasons.
3950 *
3951 * @param $text String: text to be used for external link
3952 * @param $noParse bool: wrap it without confirming it's a real URL first
3953 * @return string the tagged text
3954 */
3955 public function markNoConversion( $text, $noParse = false ) {
3956 // Excluding protocal-relative URLs may avoid many false positives.
3957 if ( $noParse || preg_match( '/^(?:' . wfUrlProtocolsWithoutProtRel() . ')/', $text ) ) {
3958 return $this->mConverter->markNoConversion( $text );
3959 } else {
3960 return $text;
3961 }
3962 }
3963
3964 /**
3965 * A regular expression to match legal word-trailing characters
3966 * which should be merged onto a link of the form [[foo]]bar.
3967 *
3968 * @return string
3969 */
3970 public function linkTrail() {
3971 return self::$dataCache->getItem( $this->mCode, 'linkTrail' );
3972 }
3973
3974 /**
3975 * A regular expression character set to match legal word-prefixing
3976 * characters which should be merged onto a link of the form foo[[bar]].
3977 *
3978 * @return string
3979 */
3980 public function linkPrefixCharset() {
3981 return self::$dataCache->getItem( $this->mCode, 'linkPrefixCharset' );
3982 }
3983
3984 /**
3985 * @return Language
3986 */
3987 function getLangObj() {
3988 return $this;
3989 }
3990
3991 /**
3992 * Get the "parent" language which has a converter to convert a "compatible" language
3993 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
3994 *
3995 * @return Language|null
3996 * @since 1.22
3997 */
3998 public function getParentLanguage() {
3999 if ( $this->mParentLanguage !== false ) {
4000 return $this->mParentLanguage;
4001 }
4002
4003 $pieces = explode( '-', $this->getCode() );
4004 $code = $pieces[0];
4005 if ( !in_array( $code, LanguageConverter::$languagesWithVariants ) ) {
4006 $this->mParentLanguage = null;
4007 return null;
4008 }
4009 $lang = Language::factory( $code );
4010 if ( !$lang->hasVariant( $this->getCode() ) ) {
4011 $this->mParentLanguage = null;
4012 return null;
4013 }
4014
4015 $this->mParentLanguage = $lang;
4016 return $lang;
4017 }
4018
4019 /**
4020 * Get the RFC 3066 code for this language object
4021 *
4022 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4023 * htmlspecialchars() or similar
4024 *
4025 * @return string
4026 */
4027 public function getCode() {
4028 return $this->mCode;
4029 }
4030
4031 /**
4032 * Get the code in Bcp47 format which we can use
4033 * inside of html lang="" tags.
4034 *
4035 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4036 * htmlspecialchars() or similar.
4037 *
4038 * @since 1.19
4039 * @return string
4040 */
4041 public function getHtmlCode() {
4042 if ( is_null( $this->mHtmlCode ) ) {
4043 $this->mHtmlCode = wfBCP47( $this->getCode() );
4044 }
4045 return $this->mHtmlCode;
4046 }
4047
4048 /**
4049 * @param $code string
4050 */
4051 public function setCode( $code ) {
4052 $this->mCode = $code;
4053 // Ensure we don't leave incorrect cached data lying around
4054 $this->mHtmlCode = null;
4055 $this->mParentLanguage = false;
4056 }
4057
4058 /**
4059 * Get the name of a file for a certain language code
4060 * @param $prefix string Prepend this to the filename
4061 * @param $code string Language code
4062 * @param $suffix string Append this to the filename
4063 * @throws MWException
4064 * @return string $prefix . $mangledCode . $suffix
4065 */
4066 public static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
4067 // Protect against path traversal
4068 if ( !Language::isValidCode( $code )
4069 || strcspn( $code, ":/\\\000" ) !== strlen( $code )
4070 ) {
4071 throw new MWException( "Invalid language code \"$code\"" );
4072 }
4073
4074 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
4075 }
4076
4077 /**
4078 * Get the language code from a file name. Inverse of getFileName()
4079 * @param $filename string $prefix . $languageCode . $suffix
4080 * @param $prefix string Prefix before the language code
4081 * @param $suffix string Suffix after the language code
4082 * @return string Language code, or false if $prefix or $suffix isn't found
4083 */
4084 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4085 $m = null;
4086 preg_match( '/' . preg_quote( $prefix, '/' ) . '([A-Z][a-z_]+)' .
4087 preg_quote( $suffix, '/' ) . '/', $filename, $m );
4088 if ( !count( $m ) ) {
4089 return false;
4090 }
4091 return str_replace( '_', '-', strtolower( $m[1] ) );
4092 }
4093
4094 /**
4095 * @param $code string
4096 * @return string
4097 */
4098 public static function getMessagesFileName( $code ) {
4099 global $IP;
4100 $file = self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
4101 wfRunHooks( 'Language::getMessagesFileName', array( $code, &$file ) );
4102 return $file;
4103 }
4104
4105 /**
4106 * @param $code string
4107 * @return string
4108 */
4109 public static function getClassFileName( $code ) {
4110 global $IP;
4111 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
4112 }
4113
4114 /**
4115 * Get the first fallback for a given language.
4116 *
4117 * @param $code string
4118 *
4119 * @return bool|string
4120 */
4121 public static function getFallbackFor( $code ) {
4122 if ( $code === 'en' || !Language::isValidBuiltInCode( $code ) ) {
4123 return false;
4124 } else {
4125 $fallbacks = self::getFallbacksFor( $code );
4126 $first = array_shift( $fallbacks );
4127 return $first;
4128 }
4129 }
4130
4131 /**
4132 * Get the ordered list of fallback languages.
4133 *
4134 * @since 1.19
4135 * @param $code string Language code
4136 * @return array
4137 */
4138 public static function getFallbacksFor( $code ) {
4139 if ( $code === 'en' || !Language::isValidBuiltInCode( $code ) ) {
4140 return array();
4141 } else {
4142 $v = self::getLocalisationCache()->getItem( $code, 'fallback' );
4143 $v = array_map( 'trim', explode( ',', $v ) );
4144 if ( $v[count( $v ) - 1] !== 'en' ) {
4145 $v[] = 'en';
4146 }
4147 return $v;
4148 }
4149 }
4150
4151 /**
4152 * Get the ordered list of fallback languages, ending with the fallback
4153 * language chain for the site language.
4154 *
4155 * @since 1.22
4156 * @param string $code Language code
4157 * @return array array( fallbacks, site fallbacks )
4158 */
4159 public static function getFallbacksIncludingSiteLanguage( $code ) {
4160 global $wgLanguageCode;
4161
4162 // Usually, we will only store a tiny number of fallback chains, so we
4163 // keep them in static memory.
4164 $cacheKey = "{$code}-{$wgLanguageCode}";
4165
4166 if ( !array_key_exists( $cacheKey, self::$fallbackLanguageCache ) ) {
4167 $fallbacks = self::getFallbacksFor( $code );
4168
4169 // Append the site's fallback chain, including the site language itself
4170 $siteFallbacks = self::getFallbacksFor( $wgLanguageCode );
4171 array_unshift( $siteFallbacks, $wgLanguageCode );
4172
4173 // Eliminate any languages already included in the chain
4174 $siteFallbacks = array_diff( $siteFallbacks, $fallbacks );
4175
4176 self::$fallbackLanguageCache[$cacheKey] = array( $fallbacks, $siteFallbacks );
4177 }
4178 return self::$fallbackLanguageCache[$cacheKey];
4179 }
4180
4181 /**
4182 * Get all messages for a given language
4183 * WARNING: this may take a long time. If you just need all message *keys*
4184 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4185 *
4186 * @param $code string
4187 *
4188 * @return array
4189 */
4190 public static function getMessagesFor( $code ) {
4191 return self::getLocalisationCache()->getItem( $code, 'messages' );
4192 }
4193
4194 /**
4195 * Get a message for a given language
4196 *
4197 * @param $key string
4198 * @param $code string
4199 *
4200 * @return string
4201 */
4202 public static function getMessageFor( $key, $code ) {
4203 return self::getLocalisationCache()->getSubitem( $code, 'messages', $key );
4204 }
4205
4206 /**
4207 * Get all message keys for a given language. This is a faster alternative to
4208 * array_keys( Language::getMessagesFor( $code ) )
4209 *
4210 * @since 1.19
4211 * @param $code string Language code
4212 * @return array of message keys (strings)
4213 */
4214 public static function getMessageKeysFor( $code ) {
4215 return self::getLocalisationCache()->getSubItemList( $code, 'messages' );
4216 }
4217
4218 /**
4219 * @param $talk
4220 * @return mixed
4221 */
4222 function fixVariableInNamespace( $talk ) {
4223 if ( strpos( $talk, '$1' ) === false ) {
4224 return $talk;
4225 }
4226
4227 global $wgMetaNamespace;
4228 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
4229
4230 # Allow grammar transformations
4231 # Allowing full message-style parsing would make simple requests
4232 # such as action=raw much more expensive than they need to be.
4233 # This will hopefully cover most cases.
4234 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
4235 array( &$this, 'replaceGrammarInNamespace' ), $talk );
4236 return str_replace( ' ', '_', $talk );
4237 }
4238
4239 /**
4240 * @param $m string
4241 * @return string
4242 */
4243 function replaceGrammarInNamespace( $m ) {
4244 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
4245 }
4246
4247 /**
4248 * @throws MWException
4249 * @return array
4250 */
4251 static function getCaseMaps() {
4252 static $wikiUpperChars, $wikiLowerChars;
4253 if ( isset( $wikiUpperChars ) ) {
4254 return array( $wikiUpperChars, $wikiLowerChars );
4255 }
4256
4257 wfProfileIn( __METHOD__ );
4258 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
4259 if ( $arr === false ) {
4260 throw new MWException(
4261 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
4262 }
4263 $wikiUpperChars = $arr['wikiUpperChars'];
4264 $wikiLowerChars = $arr['wikiLowerChars'];
4265 wfProfileOut( __METHOD__ );
4266 return array( $wikiUpperChars, $wikiLowerChars );
4267 }
4268
4269 /**
4270 * Decode an expiry (block, protection, etc) which has come from the DB
4271 *
4272 * @todo FIXME: why are we returnings DBMS-dependent strings???
4273 *
4274 * @param $expiry String: Database expiry String
4275 * @param $format Bool|Int true to process using language functions, or TS_ constant
4276 * to return the expiry in a given timestamp
4277 * @return String
4278 * @since 1.18
4279 */
4280 public function formatExpiry( $expiry, $format = true ) {
4281 static $infinity;
4282 if ( $infinity === null ) {
4283 $infinity = wfGetDB( DB_SLAVE )->getInfinity();
4284 }
4285
4286 if ( $expiry == '' || $expiry == $infinity ) {
4287 return $format === true
4288 ? $this->getMessageFromDB( 'infiniteblock' )
4289 : $infinity;
4290 } else {
4291 return $format === true
4292 ? $this->timeanddate( $expiry, /* User preference timezone */ true )
4293 : wfTimestamp( $format, $expiry );
4294 }
4295 }
4296
4297 /**
4298 * @todo Document
4299 * @param $seconds int|float
4300 * @param $format Array Optional
4301 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4302 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4303 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4304 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4305 * @return string
4306 */
4307 function formatTimePeriod( $seconds, $format = array() ) {
4308 if ( !is_array( $format ) ) {
4309 $format = array( 'avoid' => $format ); // For backwards compatibility
4310 }
4311 if ( !isset( $format['avoid'] ) ) {
4312 $format['avoid'] = false;
4313 }
4314 if ( !isset( $format['noabbrevs' ] ) ) {
4315 $format['noabbrevs'] = false;
4316 }
4317 $secondsMsg = wfMessage(
4318 $format['noabbrevs'] ? 'seconds' : 'seconds-abbrev' )->inLanguage( $this );
4319 $minutesMsg = wfMessage(
4320 $format['noabbrevs'] ? 'minutes' : 'minutes-abbrev' )->inLanguage( $this );
4321 $hoursMsg = wfMessage(
4322 $format['noabbrevs'] ? 'hours' : 'hours-abbrev' )->inLanguage( $this );
4323 $daysMsg = wfMessage(
4324 $format['noabbrevs'] ? 'days' : 'days-abbrev' )->inLanguage( $this );
4325
4326 if ( round( $seconds * 10 ) < 100 ) {
4327 $s = $this->formatNum( sprintf( "%.1f", round( $seconds * 10 ) / 10 ) );
4328 $s = $secondsMsg->params( $s )->text();
4329 } elseif ( round( $seconds ) < 60 ) {
4330 $s = $this->formatNum( round( $seconds ) );
4331 $s = $secondsMsg->params( $s )->text();
4332 } elseif ( round( $seconds ) < 3600 ) {
4333 $minutes = floor( $seconds / 60 );
4334 $secondsPart = round( fmod( $seconds, 60 ) );
4335 if ( $secondsPart == 60 ) {
4336 $secondsPart = 0;
4337 $minutes++;
4338 }
4339 $s = $minutesMsg->params( $this->formatNum( $minutes ) )->text();
4340 $s .= ' ';
4341 $s .= $secondsMsg->params( $this->formatNum( $secondsPart ) )->text();
4342 } elseif ( round( $seconds ) <= 2 * 86400 ) {
4343 $hours = floor( $seconds / 3600 );
4344 $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
4345 $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
4346 if ( $secondsPart == 60 ) {
4347 $secondsPart = 0;
4348 $minutes++;
4349 }
4350 if ( $minutes == 60 ) {
4351 $minutes = 0;
4352 $hours++;
4353 }
4354 $s = $hoursMsg->params( $this->formatNum( $hours ) )->text();
4355 $s .= ' ';
4356 $s .= $minutesMsg->params( $this->formatNum( $minutes ) )->text();
4357 if ( !in_array( $format['avoid'], array( 'avoidseconds', 'avoidminutes' ) ) ) {
4358 $s .= ' ' . $secondsMsg->params( $this->formatNum( $secondsPart ) )->text();
4359 }
4360 } else {
4361 $days = floor( $seconds / 86400 );
4362 if ( $format['avoid'] === 'avoidminutes' ) {
4363 $hours = round( ( $seconds - $days * 86400 ) / 3600 );
4364 if ( $hours == 24 ) {
4365 $hours = 0;
4366 $days++;
4367 }
4368 $s = $daysMsg->params( $this->formatNum( $days ) )->text();
4369 $s .= ' ';
4370 $s .= $hoursMsg->params( $this->formatNum( $hours ) )->text();
4371 } elseif ( $format['avoid'] === 'avoidseconds' ) {
4372 $hours = floor( ( $seconds - $days * 86400 ) / 3600 );
4373 $minutes = round( ( $seconds - $days * 86400 - $hours * 3600 ) / 60 );
4374 if ( $minutes == 60 ) {
4375 $minutes = 0;
4376 $hours++;
4377 }
4378 if ( $hours == 24 ) {
4379 $hours = 0;
4380 $days++;
4381 }
4382 $s = $daysMsg->params( $this->formatNum( $days ) )->text();
4383 $s .= ' ';
4384 $s .= $hoursMsg->params( $this->formatNum( $hours ) )->text();
4385 $s .= ' ';
4386 $s .= $minutesMsg->params( $this->formatNum( $minutes ) )->text();
4387 } else {
4388 $s = $daysMsg->params( $this->formatNum( $days ) )->text();
4389 $s .= ' ';
4390 $s .= $this->formatTimePeriod( $seconds - $days * 86400, $format );
4391 }
4392 }
4393 return $s;
4394 }
4395
4396 /**
4397 * Format a bitrate for output, using an appropriate
4398 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4399 *
4400 * This use base 1000. For base 1024 use formatSize(), for another base
4401 * see formatComputingNumbers()
4402 *
4403 * @param $bps int
4404 * @return string
4405 */
4406 function formatBitrate( $bps ) {
4407 return $this->formatComputingNumbers( $bps, 1000, "bitrate-$1bits" );
4408 }
4409
4410 /**
4411 * @param $size int Size of the unit
4412 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4413 * @param $messageKey string Message key to be uesd
4414 * @return string
4415 */
4416 function formatComputingNumbers( $size, $boundary, $messageKey ) {
4417 if ( $size <= 0 ) {
4418 return str_replace( '$1', $this->formatNum( $size ),
4419 $this->getMessageFromDB( str_replace( '$1', '', $messageKey ) )
4420 );
4421 }
4422 $sizes = array( '', 'kilo', 'mega', 'giga', 'tera', 'peta', 'exa', 'zeta', 'yotta' );
4423 $index = 0;
4424
4425 $maxIndex = count( $sizes ) - 1;
4426 while ( $size >= $boundary && $index < $maxIndex ) {
4427 $index++;
4428 $size /= $boundary;
4429 }
4430
4431 // For small sizes no decimal places necessary
4432 $round = 0;
4433 if ( $index > 1 ) {
4434 // For MB and bigger two decimal places are smarter
4435 $round = 2;
4436 }
4437 $msg = str_replace( '$1', $sizes[$index], $messageKey );
4438
4439 $size = round( $size, $round );
4440 $text = $this->getMessageFromDB( $msg );
4441 return str_replace( '$1', $this->formatNum( $size ), $text );
4442 }
4443
4444 /**
4445 * Format a size in bytes for output, using an appropriate
4446 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4447 *
4448 * This method use base 1024. For base 1000 use formatBitrate(), for
4449 * another base see formatComputingNumbers()
4450 *
4451 * @param $size int Size to format
4452 * @return string Plain text (not HTML)
4453 */
4454 function formatSize( $size ) {
4455 return $this->formatComputingNumbers( $size, 1024, "size-$1bytes" );
4456 }
4457
4458 /**
4459 * Make a list item, used by various special pages
4460 *
4461 * @param $page String Page link
4462 * @param $details String Text between brackets
4463 * @param $oppositedm Boolean Add the direction mark opposite to your
4464 * language, to display text properly
4465 * @return String
4466 */
4467 function specialList( $page, $details, $oppositedm = true ) {
4468 $dirmark = ( $oppositedm ? $this->getDirMark( true ) : '' ) .
4469 $this->getDirMark();
4470 $details = $details ? $dirmark . $this->getMessageFromDB( 'word-separator' ) .
4471 wfMessage( 'parentheses' )->rawParams( $details )->inLanguage( $this )->escaped() : '';
4472 return $page . $details;
4473 }
4474
4475 /**
4476 * Generate (prev x| next x) (20|50|100...) type links for paging
4477 *
4478 * @param $title Title object to link
4479 * @param $offset Integer offset parameter
4480 * @param $limit Integer limit parameter
4481 * @param $query array|String optional URL query parameter string
4482 * @param $atend Bool optional param for specified if this is the last page
4483 * @return String
4484 */
4485 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4486 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4487
4488 # Make 'previous' link
4489 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4490 if ( $offset > 0 ) {
4491 $plink = $this->numLink( $title, max( $offset - $limit, 0 ), $limit,
4492 $query, $prev, 'prevn-title', 'mw-prevlink' );
4493 } else {
4494 $plink = htmlspecialchars( $prev );
4495 }
4496
4497 # Make 'next' link
4498 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4499 if ( $atend ) {
4500 $nlink = htmlspecialchars( $next );
4501 } else {
4502 $nlink = $this->numLink( $title, $offset + $limit, $limit,
4503 $query, $next, 'nextn-title', 'mw-nextlink' );
4504 }
4505
4506 # Make links to set number of items per page
4507 $numLinks = array();
4508 foreach ( array( 20, 50, 100, 250, 500 ) as $num ) {
4509 $numLinks[] = $this->numLink( $title, $offset, $num,
4510 $query, $this->formatNum( $num ), 'shown-title', 'mw-numlink' );
4511 }
4512
4513 return wfMessage( 'viewprevnext' )->inLanguage( $this )->title( $title
4514 )->rawParams( $plink, $nlink, $this->pipeList( $numLinks ) )->escaped();
4515 }
4516
4517 /**
4518 * Helper function for viewPrevNext() that generates links
4519 *
4520 * @param $title Title object to link
4521 * @param $offset Integer offset parameter
4522 * @param $limit Integer limit parameter
4523 * @param $query Array extra query parameters
4524 * @param $link String text to use for the link; will be escaped
4525 * @param $tooltipMsg String name of the message to use as tooltip
4526 * @param $class String value of the "class" attribute of the link
4527 * @return String HTML fragment
4528 */
4529 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4530 $query = array( 'limit' => $limit, 'offset' => $offset ) + $query;
4531 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4532 return Html::element( 'a', array( 'href' => $title->getLocalURL( $query ),
4533 'title' => $tooltip, 'class' => $class ), $link );
4534 }
4535
4536 /**
4537 * Get the conversion rule title, if any.
4538 *
4539 * @return string
4540 */
4541 public function getConvRuleTitle() {
4542 return $this->mConverter->getConvRuleTitle();
4543 }
4544
4545 /**
4546 * Get the compiled plural rules for the language
4547 * @since 1.20
4548 * @return array Associative array with plural form, and plural rule as key-value pairs
4549 */
4550 public function getCompiledPluralRules() {
4551 $pluralRules = self::$dataCache->getItem( strtolower( $this->mCode ), 'compiledPluralRules' );
4552 $fallbacks = Language::getFallbacksFor( $this->mCode );
4553 if ( !$pluralRules ) {
4554 foreach ( $fallbacks as $fallbackCode ) {
4555 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4556 if ( $pluralRules ) {
4557 break;
4558 }
4559 }
4560 }
4561 return $pluralRules;
4562 }
4563
4564 /**
4565 * Get the plural rules for the language
4566 * @since 1.20
4567 * @return array Associative array with plural form number and plural rule as key-value pairs
4568 */
4569 public function getPluralRules() {
4570 $pluralRules = self::$dataCache->getItem( strtolower( $this->mCode ), 'pluralRules' );
4571 $fallbacks = Language::getFallbacksFor( $this->mCode );
4572 if ( !$pluralRules ) {
4573 foreach ( $fallbacks as $fallbackCode ) {
4574 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRules' );
4575 if ( $pluralRules ) {
4576 break;
4577 }
4578 }
4579 }
4580 return $pluralRules;
4581 }
4582
4583 /**
4584 * Get the plural rule types for the language
4585 * @since 1.22
4586 * @return array Associative array with plural form number and plural rule type as key-value pairs
4587 */
4588 public function getPluralRuleTypes() {
4589 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $this->mCode ), 'pluralRuleTypes' );
4590 $fallbacks = Language::getFallbacksFor( $this->mCode );
4591 if ( !$pluralRuleTypes ) {
4592 foreach ( $fallbacks as $fallbackCode ) {
4593 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4594 if ( $pluralRuleTypes ) {
4595 break;
4596 }
4597 }
4598 }
4599 return $pluralRuleTypes;
4600 }
4601
4602 /**
4603 * Find the index number of the plural rule appropriate for the given number
4604 * @return int The index number of the plural rule
4605 */
4606 public function getPluralRuleIndexNumber( $number ) {
4607 $pluralRules = $this->getCompiledPluralRules();
4608 $form = CLDRPluralRuleEvaluator::evaluateCompiled( $number, $pluralRules );
4609 return $form;
4610 }
4611
4612 /**
4613 * Find the plural rule type appropriate for the given number
4614 * For example, if the language is set to Arabic, getPluralType(5) should
4615 * return 'few'.
4616 * @since 1.22
4617 * @return string The name of the plural rule type, e.g. one, two, few, many
4618 */
4619 public function getPluralRuleType( $number ) {
4620 $index = $this->getPluralRuleIndexNumber( $number );
4621 $pluralRuleTypes = $this->getPluralRuleTypes();
4622 if ( isset( $pluralRuleTypes[$index] ) ) {
4623 return $pluralRuleTypes[$index];
4624 } else {
4625 return 'other';
4626 }
4627 }
4628 }
Wiklou, le Wiki du Wiklou