dépôts / lhc / web / wiklou.git / blob
? search:


56367dbf7a88b1d2dbbb8591a64f3bc4f6d58d9c
[lhc/web/wiklou.git] / languages / Language.php
1 <?php
2 /**
3 * Internationalisation code
4 *
5 * @file
6 * @ingroup Language
7 */
8
9 /**
10 * @defgroup Language Language
11 */
12
13 if ( !defined( 'MEDIAWIKI' ) ) {
14 echo "This file is part of MediaWiki, it is not a valid entry point.\n";
15 exit( 1 );
16 }
17
18 # Read language names
19 global $wgLanguageNames;
20 require_once( dirname( __FILE__ ) . '/Names.php' );
21
22 if ( function_exists( 'mb_strtoupper' ) ) {
23 mb_internal_encoding( 'UTF-8' );
24 }
25
26 /**
27 * a fake language converter
28 *
29 * @ingroup Language
30 */
31 class FakeConverter {
32 var $mLang;
33 function __construct( $langobj ) { $this->mLang = $langobj; }
34 function autoConvertToAllVariants( $text ) { return array( $this->mLang->getCode() => $text ); }
35 function convert( $t ) { return $t; }
36 function convertTitle( $t ) { return $t->getPrefixedText(); }
37 function getVariants() { return array( $this->mLang->getCode() ); }
38 function getPreferredVariant() { return $this->mLang->getCode(); }
39 function getDefaultVariant() { return $this->mLang->getCode(); }
40 function getURLVariant() { return ''; }
41 function getConvRuleTitle() { return false; }
42 function findVariantLink( &$l, &$n, $ignoreOtherCond = false ) { }
43 function getExtraHashOptions() { return ''; }
44 function getParsedTitle() { return ''; }
45 function markNoConversion( $text, $noParse = false ) { return $text; }
46 function convertCategoryKey( $key ) { return $key; }
47 function convertLinkToAllVariants( $text ) { return $this->autoConvertToAllVariants( $text ); }
48 function armourMath( $text ) { return $text; }
49 }
50
51 /**
52 * Internationalisation code
53 * @ingroup Language
54 */
55 class Language {
56
57 /**
58 * @var LanguageConverter
59 */
60 var $mConverter;
61
62 var $mVariants, $mCode, $mLoaded = false;
63 var $mMagicExtensions = array(), $mMagicHookDone = false;
64 private $mHtmlCode = null;
65
66 var $mNamespaceIds, $namespaceNames, $namespaceAliases;
67 var $dateFormatStrings = array();
68 var $mExtendedSpecialPageAliases;
69
70 /**
71 * ReplacementArray object caches
72 */
73 var $transformData = array();
74
75 /**
76 * @var LocalisationCache
77 */
78 static public $dataCache;
79
80 static public $mLangObjCache = array();
81
82 static public $mWeekdayMsgs = array(
83 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
84 'friday', 'saturday'
85 );
86
87 static public $mWeekdayAbbrevMsgs = array(
88 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'
89 );
90
91 static public $mMonthMsgs = array(
92 'january', 'february', 'march', 'april', 'may_long', 'june',
93 'july', 'august', 'september', 'october', 'november',
94 'december'
95 );
96 static public $mMonthGenMsgs = array(
97 'january-gen', 'february-gen', 'march-gen', 'april-gen', 'may-gen', 'june-gen',
98 'july-gen', 'august-gen', 'september-gen', 'october-gen', 'november-gen',
99 'december-gen'
100 );
101 static public $mMonthAbbrevMsgs = array(
102 'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
103 'sep', 'oct', 'nov', 'dec'
104 );
105
106 static public $mIranianCalendarMonthMsgs = array(
107 'iranian-calendar-m1', 'iranian-calendar-m2', 'iranian-calendar-m3',
108 'iranian-calendar-m4', 'iranian-calendar-m5', 'iranian-calendar-m6',
109 'iranian-calendar-m7', 'iranian-calendar-m8', 'iranian-calendar-m9',
110 'iranian-calendar-m10', 'iranian-calendar-m11', 'iranian-calendar-m12'
111 );
112
113 static public $mHebrewCalendarMonthMsgs = array(
114 'hebrew-calendar-m1', 'hebrew-calendar-m2', 'hebrew-calendar-m3',
115 'hebrew-calendar-m4', 'hebrew-calendar-m5', 'hebrew-calendar-m6',
116 'hebrew-calendar-m7', 'hebrew-calendar-m8', 'hebrew-calendar-m9',
117 'hebrew-calendar-m10', 'hebrew-calendar-m11', 'hebrew-calendar-m12',
118 'hebrew-calendar-m6a', 'hebrew-calendar-m6b'
119 );
120
121 static public $mHebrewCalendarMonthGenMsgs = array(
122 'hebrew-calendar-m1-gen', 'hebrew-calendar-m2-gen', 'hebrew-calendar-m3-gen',
123 'hebrew-calendar-m4-gen', 'hebrew-calendar-m5-gen', 'hebrew-calendar-m6-gen',
124 'hebrew-calendar-m7-gen', 'hebrew-calendar-m8-gen', 'hebrew-calendar-m9-gen',
125 'hebrew-calendar-m10-gen', 'hebrew-calendar-m11-gen', 'hebrew-calendar-m12-gen',
126 'hebrew-calendar-m6a-gen', 'hebrew-calendar-m6b-gen'
127 );
128
129 static public $mHijriCalendarMonthMsgs = array(
130 'hijri-calendar-m1', 'hijri-calendar-m2', 'hijri-calendar-m3',
131 'hijri-calendar-m4', 'hijri-calendar-m5', 'hijri-calendar-m6',
132 'hijri-calendar-m7', 'hijri-calendar-m8', 'hijri-calendar-m9',
133 'hijri-calendar-m10', 'hijri-calendar-m11', 'hijri-calendar-m12'
134 );
135
136 /**
137 * Get a cached language object for a given language code
138 * @param $code String
139 * @return Language
140 */
141 static function factory( $code ) {
142 if ( !isset( self::$mLangObjCache[$code] ) ) {
143 if ( count( self::$mLangObjCache ) > 10 ) {
144 // Don't keep a billion objects around, that's stupid.
145 self::$mLangObjCache = array();
146 }
147 self::$mLangObjCache[$code] = self::newFromCode( $code );
148 }
149 return self::$mLangObjCache[$code];
150 }
151
152 /**
153 * Create a language object for a given language code
154 * @param $code String
155 * @return Language
156 */
157 protected static function newFromCode( $code ) {
158 // Protect against path traversal below
159 if ( !Language::isValidCode( $code )
160 || strcspn( $code, ":/\\\000" ) !== strlen( $code ) )
161 {
162 throw new MWException( "Invalid language code \"$code\"" );
163 }
164
165 if ( !Language::isValidBuiltInCode( $code ) ) {
166 // It's not possible to customise this code with class files, so
167 // just return a Language object. This is to support uselang= hacks.
168 $lang = new Language;
169 $lang->setCode( $code );
170 return $lang;
171 }
172
173 // Check if there is a language class for the code
174 $class = self::classFromCode( $code );
175 self::preloadLanguageClass( $class );
176 if ( MWInit::classExists( $class ) ) {
177 $lang = new $class;
178 return $lang;
179 }
180
181 // Keep trying the fallback list until we find an existing class
182 $fallbacks = Language::getFallbacksFor( $code );
183 foreach ( $fallbacks as $fallbackCode ) {
184 if ( !Language::isValidBuiltInCode( $fallbackCode ) ) {
185 throw new MWException( "Invalid fallback '$fallbackCode' in fallback sequence for '$code'" );
186 }
187
188 $class = self::classFromCode( $fallbackCode );
189 self::preloadLanguageClass( $class );
190 if ( MWInit::classExists( $class ) ) {
191 $lang = Language::newFromCode( $fallbackCode );
192 $lang->setCode( $code );
193 return $lang;
194 }
195 }
196
197 throw new MWException( "Invalid fallback sequence for language '$code'" );
198 }
199
200 /**
201 * Returns true if a language code string is of a valid form, whether or
202 * not it exists. This includes codes which are used solely for
203 * customisation via the MediaWiki namespace.
204 *
205 * @param $code string
206 *
207 * @return bool
208 */
209 public static function isValidCode( $code ) {
210 return
211 strcspn( $code, ":/\\\000" ) === strlen( $code )
212 && !preg_match( Title::getTitleInvalidRegex(), $code );
213 }
214
215 /**
216 * Returns true if a language code is of a valid form for the purposes of
217 * internal customisation of MediaWiki, via Messages*.php.
218 *
219 * @param $code string
220 *
221 * @since 1.18
222 * @return bool
223 */
224 public static function isValidBuiltInCode( $code ) {
225 return preg_match( '/^[a-z0-9-]+$/i', $code );
226 }
227
228 /**
229 * @param $code
230 * @return String Name of the language class
231 */
232 public static function classFromCode( $code ) {
233 if ( $code == 'en' ) {
234 return 'Language';
235 } else {
236 return 'Language' . str_replace( '-', '_', ucfirst( $code ) );
237 }
238 }
239
240 /**
241 * Includes language class files
242 *
243 * @param $class string Name of the language class
244 */
245 public static function preloadLanguageClass( $class ) {
246 global $IP;
247
248 if ( $class === 'Language' ) {
249 return;
250 }
251
252 if ( !defined( 'MW_COMPILED' ) ) {
253 // Preload base classes to work around APC/PHP5 bug
254 if ( file_exists( "$IP/languages/classes/$class.deps.php" ) ) {
255 include_once( "$IP/languages/classes/$class.deps.php" );
256 }
257 if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
258 include_once( "$IP/languages/classes/$class.php" );
259 }
260 }
261 }
262
263 /**
264 * Get the LocalisationCache instance
265 *
266 * @return LocalisationCache
267 */
268 public static function getLocalisationCache() {
269 if ( is_null( self::$dataCache ) ) {
270 global $wgLocalisationCacheConf;
271 $class = $wgLocalisationCacheConf['class'];
272 self::$dataCache = new $class( $wgLocalisationCacheConf );
273 }
274 return self::$dataCache;
275 }
276
277 function __construct() {
278 $this->mConverter = new FakeConverter( $this );
279 // Set the code to the name of the descendant
280 if ( get_class( $this ) == 'Language' ) {
281 $this->mCode = 'en';
282 } else {
283 $this->mCode = str_replace( '_', '-', strtolower( substr( get_class( $this ), 8 ) ) );
284 }
285 self::getLocalisationCache();
286 }
287
288 /**
289 * Reduce memory usage
290 */
291 function __destruct() {
292 foreach ( $this as $name => $value ) {
293 unset( $this->$name );
294 }
295 }
296
297 /**
298 * Hook which will be called if this is the content language.
299 * Descendants can use this to register hook functions or modify globals
300 */
301 function initContLang() { }
302
303 /**
304 * Same as getFallbacksFor for current language.
305 * @return array|bool
306 * @deprecated in 1.19
307 */
308 function getFallbackLanguageCode() {
309 wfDeprecated( __METHOD__ );
310 return self::getFallbackFor( $this->mCode );
311 }
312
313 /**
314 * @return array
315 * @since 1.19
316 */
317 function getFallbackLanguages() {
318 return self::getFallbacksFor( $this->mCode );
319 }
320
321 /**
322 * Exports $wgBookstoreListEn
323 * @return array
324 */
325 function getBookstoreList() {
326 return self::$dataCache->getItem( $this->mCode, 'bookstoreList' );
327 }
328
329 /**
330 * @return array
331 */
332 function getNamespaces() {
333 if ( is_null( $this->namespaceNames ) ) {
334 global $wgMetaNamespace, $wgMetaNamespaceTalk, $wgExtraNamespaces;
335
336 $this->namespaceNames = self::$dataCache->getItem( $this->mCode, 'namespaceNames' );
337 $validNamespaces = MWNamespace::getCanonicalNamespaces();
338
339 $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames + $validNamespaces;
340
341 $this->namespaceNames[NS_PROJECT] = $wgMetaNamespace;
342 if ( $wgMetaNamespaceTalk ) {
343 $this->namespaceNames[NS_PROJECT_TALK] = $wgMetaNamespaceTalk;
344 } else {
345 $talk = $this->namespaceNames[NS_PROJECT_TALK];
346 $this->namespaceNames[NS_PROJECT_TALK] =
347 $this->fixVariableInNamespace( $talk );
348 }
349
350 # Sometimes a language will be localised but not actually exist on this wiki.
351 foreach ( $this->namespaceNames as $key => $text ) {
352 if ( !isset( $validNamespaces[$key] ) ) {
353 unset( $this->namespaceNames[$key] );
354 }
355 }
356
357 # The above mixing may leave namespaces out of canonical order.
358 # Re-order by namespace ID number...
359 ksort( $this->namespaceNames );
360
361 wfRunHooks( 'LanguageGetNamespaces', array( &$this->namespaceNames ) );
362 }
363 return $this->namespaceNames;
364 }
365
366 /**
367 * A convenience function that returns the same thing as
368 * getNamespaces() except with the array values changed to ' '
369 * where it found '_', useful for producing output to be displayed
370 * e.g. in <select> forms.
371 *
372 * @return array
373 */
374 function getFormattedNamespaces() {
375 $ns = $this->getNamespaces();
376 foreach ( $ns as $k => $v ) {
377 $ns[$k] = strtr( $v, '_', ' ' );
378 }
379 return $ns;
380 }
381
382 /**
383 * Get a namespace value by key
384 * <code>
385 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
386 * echo $mw_ns; // prints 'MediaWiki'
387 * </code>
388 *
389 * @param $index Int: the array key of the namespace to return
390 * @return mixed, string if the namespace value exists, otherwise false
391 */
392 function getNsText( $index ) {
393 $ns = $this->getNamespaces();
394 return isset( $ns[$index] ) ? $ns[$index] : false;
395 }
396
397 /**
398 * A convenience function that returns the same thing as
399 * getNsText() except with '_' changed to ' ', useful for
400 * producing output.
401 *
402 * @param $index string
403 *
404 * @return array
405 */
406 function getFormattedNsText( $index ) {
407 $ns = $this->getNsText( $index );
408 return strtr( $ns, '_', ' ' );
409 }
410
411 /**
412 * Returns gender-dependent namespace alias if available.
413 * @param $index Int: namespace index
414 * @param $gender String: gender key (male, female... )
415 * @return String
416 * @since 1.18
417 */
418 function getGenderNsText( $index, $gender ) {
419 global $wgExtraGenderNamespaces;
420
421 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
422 return isset( $ns[$index][$gender] ) ? $ns[$index][$gender] : $this->getNsText( $index );
423 }
424
425 /**
426 * Whether this language makes distinguishes genders for example in
427 * namespaces.
428 * @return bool
429 * @since 1.18
430 */
431 function needsGenderDistinction() {
432 global $wgExtraGenderNamespaces, $wgExtraNamespaces;
433 if ( count( $wgExtraGenderNamespaces ) > 0 ) {
434 // $wgExtraGenderNamespaces overrides everything
435 return true;
436 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
437 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
438 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
439 return false;
440 } else {
441 // Check what is in i18n files
442 $aliases = self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
443 return count( $aliases ) > 0;
444 }
445 }
446
447 /**
448 * Get a namespace key by value, case insensitive.
449 * Only matches namespace names for the current language, not the
450 * canonical ones defined in Namespace.php.
451 *
452 * @param $text String
453 * @return mixed An integer if $text is a valid value otherwise false
454 */
455 function getLocalNsIndex( $text ) {
456 $lctext = $this->lc( $text );
457 $ids = $this->getNamespaceIds();
458 return isset( $ids[$lctext] ) ? $ids[$lctext] : false;
459 }
460
461 /**
462 * @return array
463 */
464 function getNamespaceAliases() {
465 if ( is_null( $this->namespaceAliases ) ) {
466 $aliases = self::$dataCache->getItem( $this->mCode, 'namespaceAliases' );
467 if ( !$aliases ) {
468 $aliases = array();
469 } else {
470 foreach ( $aliases as $name => $index ) {
471 if ( $index === NS_PROJECT_TALK ) {
472 unset( $aliases[$name] );
473 $name = $this->fixVariableInNamespace( $name );
474 $aliases[$name] = $index;
475 }
476 }
477 }
478
479 global $wgExtraGenderNamespaces;
480 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
481 foreach ( $genders as $index => $forms ) {
482 foreach ( $forms as $alias ) {
483 $aliases[$alias] = $index;
484 }
485 }
486
487 $this->namespaceAliases = $aliases;
488 }
489 return $this->namespaceAliases;
490 }
491
492 /**
493 * @return array
494 */
495 function getNamespaceIds() {
496 if ( is_null( $this->mNamespaceIds ) ) {
497 global $wgNamespaceAliases;
498 # Put namespace names and aliases into a hashtable.
499 # If this is too slow, then we should arrange it so that it is done
500 # before caching. The catch is that at pre-cache time, the above
501 # class-specific fixup hasn't been done.
502 $this->mNamespaceIds = array();
503 foreach ( $this->getNamespaces() as $index => $name ) {
504 $this->mNamespaceIds[$this->lc( $name )] = $index;
505 }
506 foreach ( $this->getNamespaceAliases() as $name => $index ) {
507 $this->mNamespaceIds[$this->lc( $name )] = $index;
508 }
509 if ( $wgNamespaceAliases ) {
510 foreach ( $wgNamespaceAliases as $name => $index ) {
511 $this->mNamespaceIds[$this->lc( $name )] = $index;
512 }
513 }
514 }
515 return $this->mNamespaceIds;
516 }
517
518 /**
519 * Get a namespace key by value, case insensitive. Canonical namespace
520 * names override custom ones defined for the current language.
521 *
522 * @param $text String
523 * @return mixed An integer if $text is a valid value otherwise false
524 */
525 function getNsIndex( $text ) {
526 $lctext = $this->lc( $text );
527 $ns = MWNamespace::getCanonicalIndex( $lctext );
528 if ( $ns !== null ) {
529 return $ns;
530 }
531 $ids = $this->getNamespaceIds();
532 return isset( $ids[$lctext] ) ? $ids[$lctext] : false;
533 }
534
535 /**
536 * short names for language variants used for language conversion links.
537 *
538 * @param $code String
539 * @param $usemsg bool Use the "variantname-xyz" message if it exists
540 * @return string
541 */
542 function getVariantname( $code, $usemsg = true ) {
543 $msg = "variantname-$code";
544 list( $rootCode ) = explode( '-', $code );
545 if ( $usemsg && wfMessage( $msg )->exists() ) {
546 return $this->getMessageFromDB( $msg );
547 }
548 $name = self::getLanguageName( $code );
549 if ( $name ) {
550 return $name; # if it's defined as a language name, show that
551 } else {
552 # otherwise, output the language code
553 return $code;
554 }
555 }
556
557 /**
558 * @param $name string
559 * @return string
560 */
561 function specialPage( $name ) {
562 $aliases = $this->getSpecialPageAliases();
563 if ( isset( $aliases[$name][0] ) ) {
564 $name = $aliases[$name][0];
565 }
566 return $this->getNsText( NS_SPECIAL ) . ':' . $name;
567 }
568
569 /**
570 * @return array
571 */
572 function getQuickbarSettings() {
573 return array(
574 $this->getMessage( 'qbsettings-none' ),
575 $this->getMessage( 'qbsettings-fixedleft' ),
576 $this->getMessage( 'qbsettings-fixedright' ),
577 $this->getMessage( 'qbsettings-floatingleft' ),
578 $this->getMessage( 'qbsettings-floatingright' ),
579 $this->getMessage( 'qbsettings-directionality' )
580 );
581 }
582
583 /**
584 * @return array
585 */
586 function getDatePreferences() {
587 return self::$dataCache->getItem( $this->mCode, 'datePreferences' );
588 }
589
590 /**
591 * @return array
592 */
593 function getDateFormats() {
594 return self::$dataCache->getItem( $this->mCode, 'dateFormats' );
595 }
596
597 /**
598 * @return array|string
599 */
600 function getDefaultDateFormat() {
601 $df = self::$dataCache->getItem( $this->mCode, 'defaultDateFormat' );
602 if ( $df === 'dmy or mdy' ) {
603 global $wgAmericanDates;
604 return $wgAmericanDates ? 'mdy' : 'dmy';
605 } else {
606 return $df;
607 }
608 }
609
610 /**
611 * @return array
612 */
613 function getDatePreferenceMigrationMap() {
614 return self::$dataCache->getItem( $this->mCode, 'datePreferenceMigrationMap' );
615 }
616
617 /**
618 * @param $image
619 * @return array|null
620 */
621 function getImageFile( $image ) {
622 return self::$dataCache->getSubitem( $this->mCode, 'imageFiles', $image );
623 }
624
625 /**
626 * @return array
627 */
628 function getExtraUserToggles() {
629 return (array)self::$dataCache->getItem( $this->mCode, 'extraUserToggles' );
630 }
631
632 /**
633 * @param $tog
634 * @return string
635 */
636 function getUserToggle( $tog ) {
637 return $this->getMessageFromDB( "tog-$tog" );
638 }
639
640 /**
641 * Get native language names, indexed by code.
642 * Only those defined in MediaWiki, no other data like CLDR.
643 * If $customisedOnly is true, only returns codes with a messages file
644 *
645 * @param $customisedOnly bool
646 *
647 * @return array
648 */
649 public static function getLanguageNames( $customisedOnly = false ) {
650 global $wgExtraLanguageNames;
651 static $coreLanguageNames;
652
653 if ( $coreLanguageNames === null ) {
654 include( MWInit::compiledPath( 'languages/Names.php' ) );
655 }
656
657 $allNames = $wgExtraLanguageNames + $coreLanguageNames;
658 if ( !$customisedOnly ) {
659 return $allNames;
660 }
661
662 $names = array();
663 // We do this using a foreach over the codes instead of a directory
664 // loop so that messages files in extensions will work correctly.
665 foreach ( $allNames as $code => $value ) {
666 if ( is_readable( self::getMessagesFileName( $code ) ) ) {
667 $names[$code] = $allNames[$code];
668 }
669 }
670 return $names;
671 }
672
673 /**
674 * Get translated language names. This is done on best effort and
675 * by default this is exactly the same as Language::getLanguageNames.
676 * The CLDR extension provides translated names.
677 * @param $code String Language code.
678 * @return Array language code => language name
679 * @since 1.18.0
680 */
681 public static function getTranslatedLanguageNames( $code ) {
682 $names = array();
683 wfRunHooks( 'LanguageGetTranslatedLanguageNames', array( &$names, $code ) );
684
685 foreach ( self::getLanguageNames() as $code => $name ) {
686 if ( !isset( $names[$code] ) ) $names[$code] = $name;
687 }
688
689 return $names;
690 }
691
692 /**
693 * Get a message from the MediaWiki namespace.
694 *
695 * @param $msg String: message name
696 * @return string
697 */
698 function getMessageFromDB( $msg ) {
699 return wfMsgExt( $msg, array( 'parsemag', 'language' => $this ) );
700 }
701
702 /**
703 * Get the native language name of $code.
704 * Only if defined in MediaWiki, no other data like CLDR.
705 * @param $code string
706 * @return string
707 */
708 function getLanguageName( $code ) {
709 $names = self::getLanguageNames();
710 if ( !array_key_exists( $code, $names ) ) {
711 return '';
712 }
713 return $names[$code];
714 }
715
716 /**
717 * @param $key string
718 * @return string
719 */
720 function getMonthName( $key ) {
721 return $this->getMessageFromDB( self::$mMonthMsgs[$key - 1] );
722 }
723
724 /**
725 * @return array
726 */
727 function getMonthNamesArray() {
728 $monthNames = array( '' );
729 for ( $i = 1; $i < 13; $i++ ) {
730 $monthNames[] = $this->getMonthName( $i );
731 }
732 return $monthNames;
733 }
734
735 /**
736 * @param $key string
737 * @return string
738 */
739 function getMonthNameGen( $key ) {
740 return $this->getMessageFromDB( self::$mMonthGenMsgs[$key - 1] );
741 }
742
743 /**
744 * @param $key string
745 * @return string
746 */
747 function getMonthAbbreviation( $key ) {
748 return $this->getMessageFromDB( self::$mMonthAbbrevMsgs[$key - 1] );
749 }
750
751 /**
752 * @return array
753 */
754 function getMonthAbbreviationsArray() {
755 $monthNames = array( '' );
756 for ( $i = 1; $i < 13; $i++ ) {
757 $monthNames[] = $this->getMonthAbbreviation( $i );
758 }
759 return $monthNames;
760 }
761
762 /**
763 * @param $key string
764 * @return string
765 */
766 function getWeekdayName( $key ) {
767 return $this->getMessageFromDB( self::$mWeekdayMsgs[$key - 1] );
768 }
769
770 /**
771 * @param $key string
772 * @return string
773 */
774 function getWeekdayAbbreviation( $key ) {
775 return $this->getMessageFromDB( self::$mWeekdayAbbrevMsgs[$key - 1] );
776 }
777
778 /**
779 * @param $key string
780 * @return string
781 */
782 function getIranianCalendarMonthName( $key ) {
783 return $this->getMessageFromDB( self::$mIranianCalendarMonthMsgs[$key - 1] );
784 }
785
786 /**
787 * @param $key string
788 * @return string
789 */
790 function getHebrewCalendarMonthName( $key ) {
791 return $this->getMessageFromDB( self::$mHebrewCalendarMonthMsgs[$key - 1] );
792 }
793
794 /**
795 * @param $key string
796 * @return string
797 */
798 function getHebrewCalendarMonthNameGen( $key ) {
799 return $this->getMessageFromDB( self::$mHebrewCalendarMonthGenMsgs[$key - 1] );
800 }
801
802 /**
803 * @param $key string
804 * @return string
805 */
806 function getHijriCalendarMonthName( $key ) {
807 return $this->getMessageFromDB( self::$mHijriCalendarMonthMsgs[$key - 1] );
808 }
809
810 /**
811 * This is a workalike of PHP's date() function, but with better
812 * internationalisation, a reduced set of format characters, and a better
813 * escaping format.
814 *
815 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
816 * PHP manual for definitions. There are a number of extensions, which
817 * start with "x":
818 *
819 * xn Do not translate digits of the next numeric format character
820 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
821 * xr Use roman numerals for the next numeric format character
822 * xh Use hebrew numerals for the next numeric format character
823 * xx Literal x
824 * xg Genitive month name
825 *
826 * xij j (day number) in Iranian calendar
827 * xiF F (month name) in Iranian calendar
828 * xin n (month number) in Iranian calendar
829 * xiy y (two digit year) in Iranian calendar
830 * xiY Y (full year) in Iranian calendar
831 *
832 * xjj j (day number) in Hebrew calendar
833 * xjF F (month name) in Hebrew calendar
834 * xjt t (days in month) in Hebrew calendar
835 * xjx xg (genitive month name) in Hebrew calendar
836 * xjn n (month number) in Hebrew calendar
837 * xjY Y (full year) in Hebrew calendar
838 *
839 * xmj j (day number) in Hijri calendar
840 * xmF F (month name) in Hijri calendar
841 * xmn n (month number) in Hijri calendar
842 * xmY Y (full year) in Hijri calendar
843 *
844 * xkY Y (full year) in Thai solar calendar. Months and days are
845 * identical to the Gregorian calendar
846 * xoY Y (full year) in Minguo calendar or Juche year.
847 * Months and days are identical to the
848 * Gregorian calendar
849 * xtY Y (full year) in Japanese nengo. Months and days are
850 * identical to the Gregorian calendar
851 *
852 * Characters enclosed in double quotes will be considered literal (with
853 * the quotes themselves removed). Unmatched quotes will be considered
854 * literal quotes. Example:
855 *
856 * "The month is" F => The month is January
857 * i's" => 20'11"
858 *
859 * Backslash escaping is also supported.
860 *
861 * Input timestamp is assumed to be pre-normalized to the desired local
862 * time zone, if any.
863 *
864 * @param $format String
865 * @param $ts String: 14-character timestamp
866 * YYYYMMDDHHMMSS
867 * 01234567890123
868 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
869 *
870 * @return string
871 */
872 function sprintfDate( $format, $ts ) {
873 $s = '';
874 $raw = false;
875 $roman = false;
876 $hebrewNum = false;
877 $unix = false;
878 $rawToggle = false;
879 $iranian = false;
880 $hebrew = false;
881 $hijri = false;
882 $thai = false;
883 $minguo = false;
884 $tenno = false;
885 for ( $p = 0; $p < strlen( $format ); $p++ ) {
886 $num = false;
887 $code = $format[$p];
888 if ( $code == 'x' && $p < strlen( $format ) - 1 ) {
889 $code .= $format[++$p];
890 }
891
892 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
893 $code .= $format[++$p];
894 }
895
896 switch ( $code ) {
897 case 'xx':
898 $s .= 'x';
899 break;
900 case 'xn':
901 $raw = true;
902 break;
903 case 'xN':
904 $rawToggle = !$rawToggle;
905 break;
906 case 'xr':
907 $roman = true;
908 break;
909 case 'xh':
910 $hebrewNum = true;
911 break;
912 case 'xg':
913 $s .= $this->getMonthNameGen( substr( $ts, 4, 2 ) );
914 break;
915 case 'xjx':
916 if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
917 $s .= $this->getHebrewCalendarMonthNameGen( $hebrew[1] );
918 break;
919 case 'd':
920 $num = substr( $ts, 6, 2 );
921 break;
922 case 'D':
923 if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
924 $s .= $this->getWeekdayAbbreviation( gmdate( 'w', $unix ) + 1 );
925 break;
926 case 'j':
927 $num = intval( substr( $ts, 6, 2 ) );
928 break;
929 case 'xij':
930 if ( !$iranian ) {
931 $iranian = self::tsToIranian( $ts );
932 }
933 $num = $iranian[2];
934 break;
935 case 'xmj':
936 if ( !$hijri ) {
937 $hijri = self::tsToHijri( $ts );
938 }
939 $num = $hijri[2];
940 break;
941 case 'xjj':
942 if ( !$hebrew ) {
943 $hebrew = self::tsToHebrew( $ts );
944 }
945 $num = $hebrew[2];
946 break;
947 case 'l':
948 if ( !$unix ) {
949 $unix = wfTimestamp( TS_UNIX, $ts );
950 }
951 $s .= $this->getWeekdayName( gmdate( 'w', $unix ) + 1 );
952 break;
953 case 'N':
954 if ( !$unix ) {
955 $unix = wfTimestamp( TS_UNIX, $ts );
956 }
957 $w = gmdate( 'w', $unix );
958 $num = $w ? $w : 7;
959 break;
960 case 'w':
961 if ( !$unix ) {
962 $unix = wfTimestamp( TS_UNIX, $ts );
963 }
964 $num = gmdate( 'w', $unix );
965 break;
966 case 'z':
967 if ( !$unix ) {
968 $unix = wfTimestamp( TS_UNIX, $ts );
969 }
970 $num = gmdate( 'z', $unix );
971 break;
972 case 'W':
973 if ( !$unix ) {
974 $unix = wfTimestamp( TS_UNIX, $ts );
975 }
976 $num = gmdate( 'W', $unix );
977 break;
978 case 'F':
979 $s .= $this->getMonthName( substr( $ts, 4, 2 ) );
980 break;
981 case 'xiF':
982 if ( !$iranian ) {
983 $iranian = self::tsToIranian( $ts );
984 }
985 $s .= $this->getIranianCalendarMonthName( $iranian[1] );
986 break;
987 case 'xmF':
988 if ( !$hijri ) {
989 $hijri = self::tsToHijri( $ts );
990 }
991 $s .= $this->getHijriCalendarMonthName( $hijri[1] );
992 break;
993 case 'xjF':
994 if ( !$hebrew ) {
995 $hebrew = self::tsToHebrew( $ts );
996 }
997 $s .= $this->getHebrewCalendarMonthName( $hebrew[1] );
998 break;
999 case 'm':
1000 $num = substr( $ts, 4, 2 );
1001 break;
1002 case 'M':
1003 $s .= $this->getMonthAbbreviation( substr( $ts, 4, 2 ) );
1004 break;
1005 case 'n':
1006 $num = intval( substr( $ts, 4, 2 ) );
1007 break;
1008 case 'xin':
1009 if ( !$iranian ) {
1010 $iranian = self::tsToIranian( $ts );
1011 }
1012 $num = $iranian[1];
1013 break;
1014 case 'xmn':
1015 if ( !$hijri ) {
1016 $hijri = self::tsToHijri ( $ts );
1017 }
1018 $num = $hijri[1];
1019 break;
1020 case 'xjn':
1021 if ( !$hebrew ) {
1022 $hebrew = self::tsToHebrew( $ts );
1023 }
1024 $num = $hebrew[1];
1025 break;
1026 case 't':
1027 if ( !$unix ) {
1028 $unix = wfTimestamp( TS_UNIX, $ts );
1029 }
1030 $num = gmdate( 't', $unix );
1031 break;
1032 case 'xjt':
1033 if ( !$hebrew ) {
1034 $hebrew = self::tsToHebrew( $ts );
1035 }
1036 $num = $hebrew[3];
1037 break;
1038 case 'L':
1039 if ( !$unix ) {
1040 $unix = wfTimestamp( TS_UNIX, $ts );
1041 }
1042 $num = gmdate( 'L', $unix );
1043 break;
1044 case 'o':
1045 if ( !$unix ) {
1046 $unix = wfTimestamp( TS_UNIX, $ts );
1047 }
1048 $num = gmdate( 'o', $unix );
1049 break;
1050 case 'Y':
1051 $num = substr( $ts, 0, 4 );
1052 break;
1053 case 'xiY':
1054 if ( !$iranian ) {
1055 $iranian = self::tsToIranian( $ts );
1056 }
1057 $num = $iranian[0];
1058 break;
1059 case 'xmY':
1060 if ( !$hijri ) {
1061 $hijri = self::tsToHijri( $ts );
1062 }
1063 $num = $hijri[0];
1064 break;
1065 case 'xjY':
1066 if ( !$hebrew ) {
1067 $hebrew = self::tsToHebrew( $ts );
1068 }
1069 $num = $hebrew[0];
1070 break;
1071 case 'xkY':
1072 if ( !$thai ) {
1073 $thai = self::tsToYear( $ts, 'thai' );
1074 }
1075 $num = $thai[0];
1076 break;
1077 case 'xoY':
1078 if ( !$minguo ) {
1079 $minguo = self::tsToYear( $ts, 'minguo' );
1080 }
1081 $num = $minguo[0];
1082 break;
1083 case 'xtY':
1084 if ( !$tenno ) {
1085 $tenno = self::tsToYear( $ts, 'tenno' );
1086 }
1087 $num = $tenno[0];
1088 break;
1089 case 'y':
1090 $num = substr( $ts, 2, 2 );
1091 break;
1092 case 'xiy':
1093 if ( !$iranian ) {
1094 $iranian = self::tsToIranian( $ts );
1095 }
1096 $num = substr( $iranian[0], -2 );
1097 break;
1098 case 'a':
1099 $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'am' : 'pm';
1100 break;
1101 case 'A':
1102 $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'AM' : 'PM';
1103 break;
1104 case 'g':
1105 $h = substr( $ts, 8, 2 );
1106 $num = $h % 12 ? $h % 12 : 12;
1107 break;
1108 case 'G':
1109 $num = intval( substr( $ts, 8, 2 ) );
1110 break;
1111 case 'h':
1112 $h = substr( $ts, 8, 2 );
1113 $num = sprintf( '%02d', $h % 12 ? $h % 12 : 12 );
1114 break;
1115 case 'H':
1116 $num = substr( $ts, 8, 2 );
1117 break;
1118 case 'i':
1119 $num = substr( $ts, 10, 2 );
1120 break;
1121 case 's':
1122 $num = substr( $ts, 12, 2 );
1123 break;
1124 case 'c':
1125 if ( !$unix ) {
1126 $unix = wfTimestamp( TS_UNIX, $ts );
1127 }
1128 $s .= gmdate( 'c', $unix );
1129 break;
1130 case 'r':
1131 if ( !$unix ) {
1132 $unix = wfTimestamp( TS_UNIX, $ts );
1133 }
1134 $s .= gmdate( 'r', $unix );
1135 break;
1136 case 'U':
1137 if ( !$unix ) {
1138 $unix = wfTimestamp( TS_UNIX, $ts );
1139 }
1140 $num = $unix;
1141 break;
1142 case '\\':
1143 # Backslash escaping
1144 if ( $p < strlen( $format ) - 1 ) {
1145 $s .= $format[++$p];
1146 } else {
1147 $s .= '\\';
1148 }
1149 break;
1150 case '"':
1151 # Quoted literal
1152 if ( $p < strlen( $format ) - 1 ) {
1153 $endQuote = strpos( $format, '"', $p + 1 );
1154 if ( $endQuote === false ) {
1155 # No terminating quote, assume literal "
1156 $s .= '"';
1157 } else {
1158 $s .= substr( $format, $p + 1, $endQuote - $p - 1 );
1159 $p = $endQuote;
1160 }
1161 } else {
1162 # Quote at end of string, assume literal "
1163 $s .= '"';
1164 }
1165 break;
1166 default:
1167 $s .= $format[$p];
1168 }
1169 if ( $num !== false ) {
1170 if ( $rawToggle || $raw ) {
1171 $s .= $num;
1172 $raw = false;
1173 } elseif ( $roman ) {
1174 $s .= self::romanNumeral( $num );
1175 $roman = false;
1176 } elseif ( $hebrewNum ) {
1177 $s .= self::hebrewNumeral( $num );
1178 $hebrewNum = false;
1179 } else {
1180 $s .= $this->formatNum( $num, true );
1181 }
1182 }
1183 }
1184 return $s;
1185 }
1186
1187 private static $GREG_DAYS = array( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
1188 private static $IRANIAN_DAYS = array( 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29 );
1189
1190 /**
1191 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1192 * Gregorian dates to Iranian dates. Originally written in C, it
1193 * is released under the terms of GNU Lesser General Public
1194 * License. Conversion to PHP was performed by Niklas Laxström.
1195 *
1196 * Link: http://www.farsiweb.info/jalali/jalali.c
1197 *
1198 * @param $ts string
1199 *
1200 * @return string
1201 */
1202 private static function tsToIranian( $ts ) {
1203 $gy = substr( $ts, 0, 4 ) -1600;
1204 $gm = substr( $ts, 4, 2 ) -1;
1205 $gd = substr( $ts, 6, 2 ) -1;
1206
1207 # Days passed from the beginning (including leap years)
1208 $gDayNo = 365 * $gy
1209 + floor( ( $gy + 3 ) / 4 )
1210 - floor( ( $gy + 99 ) / 100 )
1211 + floor( ( $gy + 399 ) / 400 );
1212
1213 // Add days of the past months of this year
1214 for ( $i = 0; $i < $gm; $i++ ) {
1215 $gDayNo += self::$GREG_DAYS[$i];
1216 }
1217
1218 // Leap years
1219 if ( $gm > 1 && ( ( $gy % 4 === 0 && $gy % 100 !== 0 || ( $gy % 400 == 0 ) ) ) ) {
1220 $gDayNo++;
1221 }
1222
1223 // Days passed in current month
1224 $gDayNo += (int)$gd;
1225
1226 $jDayNo = $gDayNo - 79;
1227
1228 $jNp = floor( $jDayNo / 12053 );
1229 $jDayNo %= 12053;
1230
1231 $jy = 979 + 33 * $jNp + 4 * floor( $jDayNo / 1461 );
1232 $jDayNo %= 1461;
1233
1234 if ( $jDayNo >= 366 ) {
1235 $jy += floor( ( $jDayNo - 1 ) / 365 );
1236 $jDayNo = floor( ( $jDayNo - 1 ) % 365 );
1237 }
1238
1239 for ( $i = 0; $i < 11 && $jDayNo >= self::$IRANIAN_DAYS[$i]; $i++ ) {
1240 $jDayNo -= self::$IRANIAN_DAYS[$i];
1241 }
1242
1243 $jm = $i + 1;
1244 $jd = $jDayNo + 1;
1245
1246 return array( $jy, $jm, $jd );
1247 }
1248
1249 /**
1250 * Converting Gregorian dates to Hijri dates.
1251 *
1252 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1253 *
1254 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1255 *
1256 * @param $ts string
1257 *
1258 * @return string
1259 */
1260 private static function tsToHijri( $ts ) {
1261 $year = substr( $ts, 0, 4 );
1262 $month = substr( $ts, 4, 2 );
1263 $day = substr( $ts, 6, 2 );
1264
1265 $zyr = $year;
1266 $zd = $day;
1267 $zm = $month;
1268 $zy = $zyr;
1269
1270 if (
1271 ( $zy > 1582 ) || ( ( $zy == 1582 ) && ( $zm > 10 ) ) ||
1272 ( ( $zy == 1582 ) && ( $zm == 10 ) && ( $zd > 14 ) )
1273 )
1274 {
1275 $zjd = (int)( ( 1461 * ( $zy + 4800 + (int)( ( $zm - 14 ) / 12 ) ) ) / 4 ) +
1276 (int)( ( 367 * ( $zm - 2 - 12 * ( (int)( ( $zm - 14 ) / 12 ) ) ) ) / 12 ) -
1277 (int)( ( 3 * (int)( ( ( $zy + 4900 + (int)( ( $zm - 14 ) / 12 ) ) / 100 ) ) ) / 4 ) +
1278 $zd - 32075;
1279 } else {
1280 $zjd = 367 * $zy - (int)( ( 7 * ( $zy + 5001 + (int)( ( $zm - 9 ) / 7 ) ) ) / 4 ) +
1281 (int)( ( 275 * $zm ) / 9 ) + $zd + 1729777;
1282 }
1283
1284 $zl = $zjd -1948440 + 10632;
1285 $zn = (int)( ( $zl - 1 ) / 10631 );
1286 $zl = $zl - 10631 * $zn + 354;
1287 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1288 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1289 $zm = (int)( ( 24 * $zl ) / 709 );
1290 $zd = $zl - (int)( ( 709 * $zm ) / 24 );
1291 $zy = 30 * $zn + $zj - 30;
1292
1293 return array( $zy, $zm, $zd );
1294 }
1295
1296 /**
1297 * Converting Gregorian dates to Hebrew dates.
1298 *
1299 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1300 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1301 * to translate the relevant functions into PHP and release them under
1302 * GNU GPL.
1303 *
1304 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1305 * and Adar II is 14. In a non-leap year, Adar is 6.
1306 *
1307 * @param $ts string
1308 *
1309 * @return string
1310 */
1311 private static function tsToHebrew( $ts ) {
1312 # Parse date
1313 $year = substr( $ts, 0, 4 );
1314 $month = substr( $ts, 4, 2 );
1315 $day = substr( $ts, 6, 2 );
1316
1317 # Calculate Hebrew year
1318 $hebrewYear = $year + 3760;
1319
1320 # Month number when September = 1, August = 12
1321 $month += 4;
1322 if ( $month > 12 ) {
1323 # Next year
1324 $month -= 12;
1325 $year++;
1326 $hebrewYear++;
1327 }
1328
1329 # Calculate day of year from 1 September
1330 $dayOfYear = $day;
1331 for ( $i = 1; $i < $month; $i++ ) {
1332 if ( $i == 6 ) {
1333 # February
1334 $dayOfYear += 28;
1335 # Check if the year is leap
1336 if ( $year % 400 == 0 || ( $year % 4 == 0 && $year % 100 > 0 ) ) {
1337 $dayOfYear++;
1338 }
1339 } elseif ( $i == 8 || $i == 10 || $i == 1 || $i == 3 ) {
1340 $dayOfYear += 30;
1341 } else {
1342 $dayOfYear += 31;
1343 }
1344 }
1345
1346 # Calculate the start of the Hebrew year
1347 $start = self::hebrewYearStart( $hebrewYear );
1348
1349 # Calculate next year's start
1350 if ( $dayOfYear <= $start ) {
1351 # Day is before the start of the year - it is the previous year
1352 # Next year's start
1353 $nextStart = $start;
1354 # Previous year
1355 $year--;
1356 $hebrewYear--;
1357 # Add days since previous year's 1 September
1358 $dayOfYear += 365;
1359 if ( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
1360 # Leap year
1361 $dayOfYear++;
1362 }
1363 # Start of the new (previous) year
1364 $start = self::hebrewYearStart( $hebrewYear );
1365 } else {
1366 # Next year's start
1367 $nextStart = self::hebrewYearStart( $hebrewYear + 1 );
1368 }
1369
1370 # Calculate Hebrew day of year
1371 $hebrewDayOfYear = $dayOfYear - $start;
1372
1373 # Difference between year's days
1374 $diff = $nextStart - $start;
1375 # Add 12 (or 13 for leap years) days to ignore the difference between
1376 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1377 # difference is only about the year type
1378 if ( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
1379 $diff += 13;
1380 } else {
1381 $diff += 12;
1382 }
1383
1384 # Check the year pattern, and is leap year
1385 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1386 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1387 # and non-leap years
1388 $yearPattern = $diff % 30;
1389 # Check if leap year
1390 $isLeap = $diff >= 30;
1391
1392 # Calculate day in the month from number of day in the Hebrew year
1393 # Don't check Adar - if the day is not in Adar, we will stop before;
1394 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1395 $hebrewDay = $hebrewDayOfYear;
1396 $hebrewMonth = 1;
1397 $days = 0;
1398 while ( $hebrewMonth <= 12 ) {
1399 # Calculate days in this month
1400 if ( $isLeap && $hebrewMonth == 6 ) {
1401 # Adar in a leap year
1402 if ( $isLeap ) {
1403 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1404 $days = 30;
1405 if ( $hebrewDay <= $days ) {
1406 # Day in Adar I
1407 $hebrewMonth = 13;
1408 } else {
1409 # Subtract the days of Adar I
1410 $hebrewDay -= $days;
1411 # Try Adar II
1412 $days = 29;
1413 if ( $hebrewDay <= $days ) {
1414 # Day in Adar II
1415 $hebrewMonth = 14;
1416 }
1417 }
1418 }
1419 } elseif ( $hebrewMonth == 2 && $yearPattern == 2 ) {
1420 # Cheshvan in a complete year (otherwise as the rule below)
1421 $days = 30;
1422 } elseif ( $hebrewMonth == 3 && $yearPattern == 0 ) {
1423 # Kislev in an incomplete year (otherwise as the rule below)
1424 $days = 29;
1425 } else {
1426 # Odd months have 30 days, even have 29
1427 $days = 30 - ( $hebrewMonth - 1 ) % 2;
1428 }
1429 if ( $hebrewDay <= $days ) {
1430 # In the current month
1431 break;
1432 } else {
1433 # Subtract the days of the current month
1434 $hebrewDay -= $days;
1435 # Try in the next month
1436 $hebrewMonth++;
1437 }
1438 }
1439
1440 return array( $hebrewYear, $hebrewMonth, $hebrewDay, $days );
1441 }
1442
1443 /**
1444 * This calculates the Hebrew year start, as days since 1 September.
1445 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1446 * Used for Hebrew date.
1447 *
1448 * @param $year int
1449 *
1450 * @return string
1451 */
1452 private static function hebrewYearStart( $year ) {
1453 $a = intval( ( 12 * ( $year - 1 ) + 17 ) % 19 );
1454 $b = intval( ( $year - 1 ) % 4 );
1455 $m = 32.044093161144 + 1.5542417966212 * $a + $b / 4.0 - 0.0031777940220923 * ( $year - 1 );
1456 if ( $m < 0 ) {
1457 $m--;
1458 }
1459 $Mar = intval( $m );
1460 if ( $m < 0 ) {
1461 $m++;
1462 }
1463 $m -= $Mar;
1464
1465 $c = intval( ( $Mar + 3 * ( $year - 1 ) + 5 * $b + 5 ) % 7 );
1466 if ( $c == 0 && $a > 11 && $m >= 0.89772376543210 ) {
1467 $Mar++;
1468 } elseif ( $c == 1 && $a > 6 && $m >= 0.63287037037037 ) {
1469 $Mar += 2;
1470 } elseif ( $c == 2 || $c == 4 || $c == 6 ) {
1471 $Mar++;
1472 }
1473
1474 $Mar += intval( ( $year - 3761 ) / 100 ) - intval( ( $year - 3761 ) / 400 ) - 24;
1475 return $Mar;
1476 }
1477
1478 /**
1479 * Algorithm to convert Gregorian dates to Thai solar dates,
1480 * Minguo dates or Minguo dates.
1481 *
1482 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1483 * http://en.wikipedia.org/wiki/Minguo_calendar
1484 * http://en.wikipedia.org/wiki/Japanese_era_name
1485 *
1486 * @param $ts String: 14-character timestamp
1487 * @param $cName String: calender name
1488 * @return Array: converted year, month, day
1489 */
1490 private static function tsToYear( $ts, $cName ) {
1491 $gy = substr( $ts, 0, 4 );
1492 $gm = substr( $ts, 4, 2 );
1493 $gd = substr( $ts, 6, 2 );
1494
1495 if ( !strcmp( $cName, 'thai' ) ) {
1496 # Thai solar dates
1497 # Add 543 years to the Gregorian calendar
1498 # Months and days are identical
1499 $gy_offset = $gy + 543;
1500 } elseif ( ( !strcmp( $cName, 'minguo' ) ) || !strcmp( $cName, 'juche' ) ) {
1501 # Minguo dates
1502 # Deduct 1911 years from the Gregorian calendar
1503 # Months and days are identical
1504 $gy_offset = $gy - 1911;
1505 } elseif ( !strcmp( $cName, 'tenno' ) ) {
1506 # Nengō dates up to Meiji period
1507 # Deduct years from the Gregorian calendar
1508 # depending on the nengo periods
1509 # Months and days are identical
1510 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1511 # Meiji period
1512 $gy_gannen = $gy - 1868 + 1;
1513 $gy_offset = $gy_gannen;
1514 if ( $gy_gannen == 1 ) {
1515 $gy_offset = '元';
1516 }
1517 $gy_offset = '明治' . $gy_offset;
1518 } elseif (
1519 ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd == 31 ) ) ||
1520 ( ( $gy == 1912 ) && ( $gm >= 8 ) ) ||
1521 ( ( $gy > 1912 ) && ( $gy < 1926 ) ) ||
1522 ( ( $gy == 1926 ) && ( $gm < 12 ) ) ||
1523 ( ( $gy == 1926 ) && ( $gm == 12 ) && ( $gd < 26 ) )
1524 )
1525 {
1526 # Taishō period
1527 $gy_gannen = $gy - 1912 + 1;
1528 $gy_offset = $gy_gannen;
1529 if ( $gy_gannen == 1 ) {
1530 $gy_offset = '元';
1531 }
1532 $gy_offset = '大正' . $gy_offset;
1533 } elseif (
1534 ( ( $gy == 1926 ) && ( $gm == 12 ) && ( $gd >= 26 ) ) ||
1535 ( ( $gy > 1926 ) && ( $gy < 1989 ) ) ||
1536 ( ( $gy == 1989 ) && ( $gm == 1 ) && ( $gd < 8 ) )
1537 )
1538 {
1539 # Shōwa period
1540 $gy_gannen = $gy - 1926 + 1;
1541 $gy_offset = $gy_gannen;
1542 if ( $gy_gannen == 1 ) {
1543 $gy_offset = '元';
1544 }
1545 $gy_offset = '昭和' . $gy_offset;
1546 } else {
1547 # Heisei period
1548 $gy_gannen = $gy - 1989 + 1;
1549 $gy_offset = $gy_gannen;
1550 if ( $gy_gannen == 1 ) {
1551 $gy_offset = '元';
1552 }
1553 $gy_offset = '平成' . $gy_offset;
1554 }
1555 } else {
1556 $gy_offset = $gy;
1557 }
1558
1559 return array( $gy_offset, $gm, $gd );
1560 }
1561
1562 /**
1563 * Roman number formatting up to 3000
1564 *
1565 * @param $num int
1566 *
1567 * @return string
1568 */
1569 static function romanNumeral( $num ) {
1570 static $table = array(
1571 array( '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X' ),
1572 array( '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', 'C' ),
1573 array( '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', 'M' ),
1574 array( '', 'M', 'MM', 'MMM' )
1575 );
1576
1577 $num = intval( $num );
1578 if ( $num > 3000 || $num <= 0 ) {
1579 return $num;
1580 }
1581
1582 $s = '';
1583 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1584 if ( $num >= $pow10 ) {
1585 $s .= $table[$i][(int)floor( $num / $pow10 )];
1586 }
1587 $num = $num % $pow10;
1588 }
1589 return $s;
1590 }
1591
1592 /**
1593 * Hebrew Gematria number formatting up to 9999
1594 *
1595 * @param $num int
1596 *
1597 * @return string
1598 */
1599 static function hebrewNumeral( $num ) {
1600 static $table = array(
1601 array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' ),
1602 array( '', 'י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ', 'ק' ),
1603 array( '', 'ק', 'ר', 'ש', 'ת', 'תק', 'תר', 'תש', 'תת', 'תתק', 'תתר' ),
1604 array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' )
1605 );
1606
1607 $num = intval( $num );
1608 if ( $num > 9999 || $num <= 0 ) {
1609 return $num;
1610 }
1611
1612 $s = '';
1613 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1614 if ( $num >= $pow10 ) {
1615 if ( $num == 15 || $num == 16 ) {
1616 $s .= $table[0][9] . $table[0][$num - 9];
1617 $num = 0;
1618 } else {
1619 $s .= $table[$i][intval( ( $num / $pow10 ) )];
1620 if ( $pow10 == 1000 ) {
1621 $s .= "'";
1622 }
1623 }
1624 }
1625 $num = $num % $pow10;
1626 }
1627 if ( strlen( $s ) == 2 ) {
1628 $str = $s . "'";
1629 } else {
1630 $str = substr( $s, 0, strlen( $s ) - 2 ) . '"';
1631 $str .= substr( $s, strlen( $s ) - 2, 2 );
1632 }
1633 $start = substr( $str, 0, strlen( $str ) - 2 );
1634 $end = substr( $str, strlen( $str ) - 2 );
1635 switch( $end ) {
1636 case 'כ':
1637 $str = $start . 'ך';
1638 break;
1639 case 'מ':
1640 $str = $start . 'ם';
1641 break;
1642 case 'נ':
1643 $str = $start . 'ן';
1644 break;
1645 case 'פ':
1646 $str = $start . 'ף';
1647 break;
1648 case 'צ':
1649 $str = $start . 'ץ';
1650 break;
1651 }
1652 return $str;
1653 }
1654
1655 /**
1656 * Used by date() and time() to adjust the time output.
1657 *
1658 * @param $ts Int the time in date('YmdHis') format
1659 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1660 * get user timecorrection setting)
1661 * @return int
1662 */
1663 function userAdjust( $ts, $tz = false ) {
1664 global $wgUser, $wgLocalTZoffset;
1665
1666 if ( $tz === false ) {
1667 $tz = $wgUser->getOption( 'timecorrection' );
1668 }
1669
1670 $data = explode( '|', $tz, 3 );
1671
1672 if ( $data[0] == 'ZoneInfo' ) {
1673 wfSuppressWarnings();
1674 $userTZ = timezone_open( $data[2] );
1675 wfRestoreWarnings();
1676 if ( $userTZ !== false ) {
1677 $date = date_create( $ts, timezone_open( 'UTC' ) );
1678 date_timezone_set( $date, $userTZ );
1679 $date = date_format( $date, 'YmdHis' );
1680 return $date;
1681 }
1682 # Unrecognized timezone, default to 'Offset' with the stored offset.
1683 $data[0] = 'Offset';
1684 }
1685
1686 $minDiff = 0;
1687 if ( $data[0] == 'System' || $tz == '' ) {
1688 #  Global offset in minutes.
1689 if ( isset( $wgLocalTZoffset ) ) {
1690 $minDiff = $wgLocalTZoffset;
1691 }
1692 } elseif ( $data[0] == 'Offset' ) {
1693 $minDiff = intval( $data[1] );
1694 } else {
1695 $data = explode( ':', $tz );
1696 if ( count( $data ) == 2 ) {
1697 $data[0] = intval( $data[0] );
1698 $data[1] = intval( $data[1] );
1699 $minDiff = abs( $data[0] ) * 60 + $data[1];
1700 if ( $data[0] < 0 ) {
1701 $minDiff = -$minDiff;
1702 }
1703 } else {
1704 $minDiff = intval( $data[0] ) * 60;
1705 }
1706 }
1707
1708 # No difference ? Return time unchanged
1709 if ( 0 == $minDiff ) {
1710 return $ts;
1711 }
1712
1713 wfSuppressWarnings(); // E_STRICT system time bitching
1714 # Generate an adjusted date; take advantage of the fact that mktime
1715 # will normalize out-of-range values so we don't have to split $minDiff
1716 # into hours and minutes.
1717 $t = mktime( (
1718 (int)substr( $ts, 8, 2 ) ), # Hours
1719 (int)substr( $ts, 10, 2 ) + $minDiff, # Minutes
1720 (int)substr( $ts, 12, 2 ), # Seconds
1721 (int)substr( $ts, 4, 2 ), # Month
1722 (int)substr( $ts, 6, 2 ), # Day
1723 (int)substr( $ts, 0, 4 ) ); # Year
1724
1725 $date = date( 'YmdHis', $t );
1726 wfRestoreWarnings();
1727
1728 return $date;
1729 }
1730
1731 /**
1732 * This is meant to be used by time(), date(), and timeanddate() to get
1733 * the date preference they're supposed to use, it should be used in
1734 * all children.
1735 *
1736 *<code>
1737 * function timeanddate([...], $format = true) {
1738 * $datePreference = $this->dateFormat($format);
1739 * [...]
1740 * }
1741 *</code>
1742 *
1743 * @param $usePrefs Mixed: if true, the user's preference is used
1744 * if false, the site/language default is used
1745 * if int/string, assumed to be a format.
1746 * @return string
1747 */
1748 function dateFormat( $usePrefs = true ) {
1749 global $wgUser;
1750
1751 if ( is_bool( $usePrefs ) ) {
1752 if ( $usePrefs ) {
1753 $datePreference = $wgUser->getDatePreference();
1754 } else {
1755 $datePreference = (string)User::getDefaultOption( 'date' );
1756 }
1757 } else {
1758 $datePreference = (string)$usePrefs;
1759 }
1760
1761 // return int
1762 if ( $datePreference == '' ) {
1763 return 'default';
1764 }
1765
1766 return $datePreference;
1767 }
1768
1769 /**
1770 * Get a format string for a given type and preference
1771 * @param $type string May be date, time or both
1772 * @param $pref string The format name as it appears in Messages*.php
1773 *
1774 * @return string
1775 */
1776 function getDateFormatString( $type, $pref ) {
1777 if ( !isset( $this->dateFormatStrings[$type][$pref] ) ) {
1778 if ( $pref == 'default' ) {
1779 $pref = $this->getDefaultDateFormat();
1780 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
1781 } else {
1782 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
1783 if ( is_null( $df ) ) {
1784 $pref = $this->getDefaultDateFormat();
1785 $df = self::$dataCache->getSubitem( $this->mCode, 'dateFormats', "$pref $type" );
1786 }
1787 }
1788 $this->dateFormatStrings[$type][$pref] = $df;
1789 }
1790 return $this->dateFormatStrings[$type][$pref];
1791 }
1792
1793 /**
1794 * @param $ts Mixed: the time format which needs to be turned into a
1795 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1796 * @param $adj Bool: whether to adjust the time output according to the
1797 * user configured offset ($timecorrection)
1798 * @param $format Mixed: true to use user's date format preference
1799 * @param $timecorrection String|bool the time offset as returned by
1800 * validateTimeZone() in Special:Preferences
1801 * @return string
1802 */
1803 function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
1804 $ts = wfTimestamp( TS_MW, $ts );
1805 if ( $adj ) {
1806 $ts = $this->userAdjust( $ts, $timecorrection );
1807 }
1808 $df = $this->getDateFormatString( 'date', $this->dateFormat( $format ) );
1809 return $this->sprintfDate( $df, $ts );
1810 }
1811
1812 /**
1813 * @param $ts Mixed: the time format which needs to be turned into a
1814 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1815 * @param $adj Bool: whether to adjust the time output according to the
1816 * user configured offset ($timecorrection)
1817 * @param $format Mixed: true to use user's date format preference
1818 * @param $timecorrection String|bool the time offset as returned by
1819 * validateTimeZone() in Special:Preferences
1820 * @return string
1821 */
1822 function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
1823 $ts = wfTimestamp( TS_MW, $ts );
1824 if ( $adj ) {
1825 $ts = $this->userAdjust( $ts, $timecorrection );
1826 }
1827 $df = $this->getDateFormatString( 'time', $this->dateFormat( $format ) );
1828 return $this->sprintfDate( $df, $ts );
1829 }
1830
1831 /**
1832 * @param $ts Mixed: the time format which needs to be turned into a
1833 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1834 * @param $adj Bool: whether to adjust the time output according to the
1835 * user configured offset ($timecorrection)
1836 * @param $format Mixed: what format to return, if it's false output the
1837 * default one (default true)
1838 * @param $timecorrection String|bool the time offset as returned by
1839 * validateTimeZone() in Special:Preferences
1840 * @return string
1841 */
1842 function timeanddate( $ts, $adj = false, $format = true, $timecorrection = false ) {
1843 $ts = wfTimestamp( TS_MW, $ts );
1844 if ( $adj ) {
1845 $ts = $this->userAdjust( $ts, $timecorrection );
1846 }
1847 $df = $this->getDateFormatString( 'both', $this->dateFormat( $format ) );
1848 return $this->sprintfDate( $df, $ts );
1849 }
1850
1851 /**
1852 * Internal helper function for userDate(), userTime() and userTimeAndDate()
1853 *
1854 * @param $type String: can be 'date', 'time' or 'both'
1855 * @param $ts Mixed: the time format which needs to be turned into a
1856 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1857 * @param $user User object used to get preferences for timezone and format
1858 * @param $options Array, can contain the following keys:
1859 * - 'timecorrection': time correction, can have the following values:
1860 * - true: use user's preference
1861 * - false: don't use time correction
1862 * - integer: value of time correction in minutes
1863 * - 'format': format to use, can have the following values:
1864 * - true: use user's preference
1865 * - false: use default preference
1866 * - string: format to use
1867 * @since 1.19
1868 * @return String
1869 */
1870 private function internalUserTimeAndDate( $type, $ts, User $user, array $options ) {
1871 $ts = wfTimestamp( TS_MW, $ts );
1872 $options += array( 'timecorrection' => true, 'format' => true );
1873 if ( $options['timecorrection'] !== false ) {
1874 if ( $options['timecorrection'] === true ) {
1875 $offset = $user->getOption( 'timecorrection' );
1876 } else {
1877 $offset = $options['timecorrection'];
1878 }
1879 $ts = $this->userAdjust( $ts, $offset );
1880 }
1881 if ( $options['format'] === true ) {
1882 $format = $user->getDatePreference();
1883 } else {
1884 $format = $options['format'];
1885 }
1886 $df = $this->getDateFormatString( $type, $this->dateFormat( $format ) );
1887 return $this->sprintfDate( $df, $ts );
1888 }
1889
1890 /**
1891 * Get the formatted date for the given timestamp and formatted for
1892 * the given user.
1893 *
1894 * @param $ts Mixed: the time format which needs to be turned into a
1895 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1896 * @param $user User object used to get preferences for timezone and format
1897 * @param $options Array, can contain the following keys:
1898 * - 'timecorrection': time correction, can have the following values:
1899 * - true: use user's preference
1900 * - false: don't use time correction
1901 * - integer: value of time correction in minutes
1902 * - 'format': format to use, can have the following values:
1903 * - true: use user's preference
1904 * - false: use default preference
1905 * - string: format to use
1906 * @since 1.19
1907 * @return String
1908 */
1909 public function userDate( $ts, User $user, array $options = array() ) {
1910 return $this->internalUserTimeAndDate( 'date', $ts, $user, $options );
1911 }
1912
1913 /**
1914 * Get the formatted time for the given timestamp and formatted for
1915 * the given user.
1916 *
1917 * @param $ts Mixed: the time format which needs to be turned into a
1918 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1919 * @param $user User object used to get preferences for timezone and format
1920 * @param $options Array, can contain the following keys:
1921 * - 'timecorrection': time correction, can have the following values:
1922 * - true: use user's preference
1923 * - false: don't use time correction
1924 * - integer: value of time correction in minutes
1925 * - 'format': format to use, can have the following values:
1926 * - true: use user's preference
1927 * - false: use default preference
1928 * - string: format to use
1929 * @since 1.19
1930 * @return String
1931 */
1932 public function userTime( $ts, User $user, array $options = array() ) {
1933 return $this->internalUserTimeAndDate( 'time', $ts, $user, $options );
1934 }
1935
1936 /**
1937 * Get the formatted date and time for the given timestamp and formatted for
1938 * the given user.
1939 *
1940 * @param $ts Mixed: the time format which needs to be turned into a
1941 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1942 * @param $user User object used to get preferences for timezone and format
1943 * @param $options Array, can contain the following keys:
1944 * - 'timecorrection': time correction, can have the following values:
1945 * - true: use user's preference
1946 * - false: don't use time correction
1947 * - integer: value of time correction in minutes
1948 * - 'format': format to use, can have the following values:
1949 * - true: use user's preference
1950 * - false: use default preference
1951 * - string: format to use
1952 * @since 1.19
1953 * @return String
1954 */
1955 public function userTimeAndDate( $ts, User $user, array $options = array() ) {
1956 return $this->internalUserTimeAndDate( 'both', $ts, $user, $options );
1957 }
1958
1959 /**
1960 * @param $key string
1961 * @return array|null
1962 */
1963 function getMessage( $key ) {
1964 return self::$dataCache->getSubitem( $this->mCode, 'messages', $key );
1965 }
1966
1967 /**
1968 * @return array
1969 */
1970 function getAllMessages() {
1971 return self::$dataCache->getItem( $this->mCode, 'messages' );
1972 }
1973
1974 /**
1975 * @param $in
1976 * @param $out
1977 * @param $string
1978 * @return string
1979 */
1980 function iconv( $in, $out, $string ) {
1981 # This is a wrapper for iconv in all languages except esperanto,
1982 # which does some nasty x-conversions beforehand
1983
1984 # Even with //IGNORE iconv can whine about illegal characters in
1985 # *input* string. We just ignore those too.
1986 # REF: http://bugs.php.net/bug.php?id=37166
1987 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1988 wfSuppressWarnings();
1989 $text = iconv( $in, $out . '//IGNORE', $string );
1990 wfRestoreWarnings();
1991 return $text;
1992 }
1993
1994 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1995
1996 /**
1997 * @param $matches array
1998 * @return mixed|string
1999 */
2000 function ucwordbreaksCallbackAscii( $matches ) {
2001 return $this->ucfirst( $matches[1] );
2002 }
2003
2004 /**
2005 * @param $matches array
2006 * @return string
2007 */
2008 function ucwordbreaksCallbackMB( $matches ) {
2009 return mb_strtoupper( $matches[0] );
2010 }
2011
2012 /**
2013 * @param $matches array
2014 * @return string
2015 */
2016 function ucCallback( $matches ) {
2017 list( $wikiUpperChars ) = self::getCaseMaps();
2018 return strtr( $matches[1], $wikiUpperChars );
2019 }
2020
2021 /**
2022 * @param $matches array
2023 * @return string
2024 */
2025 function lcCallback( $matches ) {
2026 list( , $wikiLowerChars ) = self::getCaseMaps();
2027 return strtr( $matches[1], $wikiLowerChars );
2028 }
2029
2030 /**
2031 * @param $matches array
2032 * @return string
2033 */
2034 function ucwordsCallbackMB( $matches ) {
2035 return mb_strtoupper( $matches[0] );
2036 }
2037
2038 /**
2039 * @param $matches array
2040 * @return string
2041 */
2042 function ucwordsCallbackWiki( $matches ) {
2043 list( $wikiUpperChars ) = self::getCaseMaps();
2044 return strtr( $matches[0], $wikiUpperChars );
2045 }
2046
2047 /**
2048 * Make a string's first character uppercase
2049 *
2050 * @param $str string
2051 *
2052 * @return string
2053 */
2054 function ucfirst( $str ) {
2055 $o = ord( $str );
2056 if ( $o < 96 ) { // if already uppercase...
2057 return $str;
2058 } elseif ( $o < 128 ) {
2059 return ucfirst( $str ); // use PHP's ucfirst()
2060 } else {
2061 // fall back to more complex logic in case of multibyte strings
2062 return $this->uc( $str, true );
2063 }
2064 }
2065
2066 /**
2067 * Convert a string to uppercase
2068 *
2069 * @param $str string
2070 * @param $first bool
2071 *
2072 * @return string
2073 */
2074 function uc( $str, $first = false ) {
2075 if ( function_exists( 'mb_strtoupper' ) ) {
2076 if ( $first ) {
2077 if ( $this->isMultibyte( $str ) ) {
2078 return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
2079 } else {
2080 return ucfirst( $str );
2081 }
2082 } else {
2083 return $this->isMultibyte( $str ) ? mb_strtoupper( $str ) : strtoupper( $str );
2084 }
2085 } else {
2086 if ( $this->isMultibyte( $str ) ) {
2087 $x = $first ? '^' : '';
2088 return preg_replace_callback(
2089 "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
2090 array( $this, 'ucCallback' ),
2091 $str
2092 );
2093 } else {
2094 return $first ? ucfirst( $str ) : strtoupper( $str );
2095 }
2096 }
2097 }
2098
2099 /**
2100 * @param $str string
2101 * @return mixed|string
2102 */
2103 function lcfirst( $str ) {
2104 $o = ord( $str );
2105 if ( !$o ) {
2106 return strval( $str );
2107 } elseif ( $o >= 128 ) {
2108 return $this->lc( $str, true );
2109 } elseif ( $o > 96 ) {
2110 return $str;
2111 } else {
2112 $str[0] = strtolower( $str[0] );
2113 return $str;
2114 }
2115 }
2116
2117 /**
2118 * @param $str string
2119 * @param $first bool
2120 * @return mixed|string
2121 */
2122 function lc( $str, $first = false ) {
2123 if ( function_exists( 'mb_strtolower' ) ) {
2124 if ( $first ) {
2125 if ( $this->isMultibyte( $str ) ) {
2126 return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
2127 } else {
2128 return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
2129 }
2130 } else {
2131 return $this->isMultibyte( $str ) ? mb_strtolower( $str ) : strtolower( $str );
2132 }
2133 } else {
2134 if ( $this->isMultibyte( $str ) ) {
2135 $x = $first ? '^' : '';
2136 return preg_replace_callback(
2137 "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
2138 array( $this, 'lcCallback' ),
2139 $str
2140 );
2141 } else {
2142 return $first ? strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
2143 }
2144 }
2145 }
2146
2147 /**
2148 * @param $str string
2149 * @return bool
2150 */
2151 function isMultibyte( $str ) {
2152 return (bool)preg_match( '/[\x80-\xff]/', $str );
2153 }
2154
2155 /**
2156 * @param $str string
2157 * @return mixed|string
2158 */
2159 function ucwords( $str ) {
2160 if ( $this->isMultibyte( $str ) ) {
2161 $str = $this->lc( $str );
2162
2163 // regexp to find first letter in each word (i.e. after each space)
2164 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2165
2166 // function to use to capitalize a single char
2167 if ( function_exists( 'mb_strtoupper' ) ) {
2168 return preg_replace_callback(
2169 $replaceRegexp,
2170 array( $this, 'ucwordsCallbackMB' ),
2171 $str
2172 );
2173 } else {
2174 return preg_replace_callback(
2175 $replaceRegexp,
2176 array( $this, 'ucwordsCallbackWiki' ),
2177 $str
2178 );
2179 }
2180 } else {
2181 return ucwords( strtolower( $str ) );
2182 }
2183 }
2184
2185 /**
2186 * capitalize words at word breaks
2187 *
2188 * @param $str string
2189 * @return mixed
2190 */
2191 function ucwordbreaks( $str ) {
2192 if ( $this->isMultibyte( $str ) ) {
2193 $str = $this->lc( $str );
2194
2195 // since \b doesn't work for UTF-8, we explicitely define word break chars
2196 $breaks = "[ \-\(\)\}\{\.,\?!]";
2197
2198 // find first letter after word break
2199 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2200
2201 if ( function_exists( 'mb_strtoupper' ) ) {
2202 return preg_replace_callback(
2203 $replaceRegexp,
2204 array( $this, 'ucwordbreaksCallbackMB' ),
2205 $str
2206 );
2207 } else {
2208 return preg_replace_callback(
2209 $replaceRegexp,
2210 array( $this, 'ucwordsCallbackWiki' ),
2211 $str
2212 );
2213 }
2214 } else {
2215 return preg_replace_callback(
2216 '/\b([\w\x80-\xff]+)\b/',
2217 array( $this, 'ucwordbreaksCallbackAscii' ),
2218 $str
2219 );
2220 }
2221 }
2222
2223 /**
2224 * Return a case-folded representation of $s
2225 *
2226 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2227 * and $s2 are the same except for the case of their characters. It is not
2228 * necessary for the value returned to make sense when displayed.
2229 *
2230 * Do *not* perform any other normalisation in this function. If a caller
2231 * uses this function when it should be using a more general normalisation
2232 * function, then fix the caller.
2233 *
2234 * @param $s string
2235 *
2236 * @return string
2237 */
2238 function caseFold( $s ) {
2239 return $this->uc( $s );
2240 }
2241
2242 /**
2243 * @param $s string
2244 * @return string
2245 */
2246 function checkTitleEncoding( $s ) {
2247 if ( is_array( $s ) ) {
2248 wfDebugDieBacktrace( 'Given array to checkTitleEncoding.' );
2249 }
2250 # Check for non-UTF-8 URLs
2251 $ishigh = preg_match( '/[\x80-\xff]/', $s );
2252 if ( !$ishigh ) {
2253 return $s;
2254 }
2255
2256 $isutf8 = preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
2257 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
2258 if ( $isutf8 ) {
2259 return $s;
2260 }
2261
2262 return $this->iconv( $this->fallback8bitEncoding(), 'utf-8', $s );
2263 }
2264
2265 /**
2266 * @return array
2267 */
2268 function fallback8bitEncoding() {
2269 return self::$dataCache->getItem( $this->mCode, 'fallback8bitEncoding' );
2270 }
2271
2272 /**
2273 * Most writing systems use whitespace to break up words.
2274 * Some languages such as Chinese don't conventionally do this,
2275 * which requires special handling when breaking up words for
2276 * searching etc.
2277 *
2278 * @return bool
2279 */
2280 function hasWordBreaks() {
2281 return true;
2282 }
2283
2284 /**
2285 * Some languages such as Chinese require word segmentation,
2286 * Specify such segmentation when overridden in derived class.
2287 *
2288 * @param $string String
2289 * @return String
2290 */
2291 function segmentByWord( $string ) {
2292 return $string;
2293 }
2294
2295 /**
2296 * Some languages have special punctuation need to be normalized.
2297 * Make such changes here.
2298 *
2299 * @param $string String
2300 * @return String
2301 */
2302 function normalizeForSearch( $string ) {
2303 return self::convertDoubleWidth( $string );
2304 }
2305
2306 /**
2307 * convert double-width roman characters to single-width.
2308 * range: ff00-ff5f ~= 0020-007f
2309 *
2310 * @param $string string
2311 *
2312 * @return string
2313 */
2314 protected static function convertDoubleWidth( $string ) {
2315 static $full = null;
2316 static $half = null;
2317
2318 if ( $full === null ) {
2319 $fullWidth = "０１２３４５６７８９ＡＢＣＤＥＦＧＨＩＪＫＬＭＮＯＰＱＲＳＴＵＶＷＸＹＺａｂｃｄｅｆｇｈｉｊｋｌｍｎｏｐｑｒｓｔｕｖｗｘｙｚ";
2320 $halfWidth = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
2321 $full = str_split( $fullWidth, 3 );
2322 $half = str_split( $halfWidth );
2323 }
2324
2325 $string = str_replace( $full, $half, $string );
2326 return $string;
2327 }
2328
2329 /**
2330 * @param $string string
2331 * @param $pattern string
2332 * @return string
2333 */
2334 protected static function insertSpace( $string, $pattern ) {
2335 $string = preg_replace( $pattern, " $1 ", $string );
2336 $string = preg_replace( '/ +/', ' ', $string );
2337 return $string;
2338 }
2339
2340 /**
2341 * @param $termsArray array
2342 * @return array
2343 */
2344 function convertForSearchResult( $termsArray ) {
2345 # some languages, e.g. Chinese, need to do a conversion
2346 # in order for search results to be displayed correctly
2347 return $termsArray;
2348 }
2349
2350 /**
2351 * Get the first character of a string.
2352 *
2353 * @param $s string
2354 * @return string
2355 */
2356 function firstChar( $s ) {
2357 $matches = array();
2358 preg_match(
2359 '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
2360 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/',
2361 $s,
2362 $matches
2363 );
2364
2365 if ( isset( $matches[1] ) ) {
2366 if ( strlen( $matches[1] ) != 3 ) {
2367 return $matches[1];
2368 }
2369
2370 // Break down Hangul syllables to grab the first jamo
2371 $code = utf8ToCodepoint( $matches[1] );
2372 if ( $code < 0xac00 || 0xd7a4 <= $code ) {
2373 return $matches[1];
2374 } elseif ( $code < 0xb098 ) {
2375 return "\xe3\x84\xb1";
2376 } elseif ( $code < 0xb2e4 ) {
2377 return "\xe3\x84\xb4";
2378 } elseif ( $code < 0xb77c ) {
2379 return "\xe3\x84\xb7";
2380 } elseif ( $code < 0xb9c8 ) {
2381 return "\xe3\x84\xb9";
2382 } elseif ( $code < 0xbc14 ) {
2383 return "\xe3\x85\x81";
2384 } elseif ( $code < 0xc0ac ) {
2385 return "\xe3\x85\x82";
2386 } elseif ( $code < 0xc544 ) {
2387 return "\xe3\x85\x85";
2388 } elseif ( $code < 0xc790 ) {
2389 return "\xe3\x85\x87";
2390 } elseif ( $code < 0xcc28 ) {
2391 return "\xe3\x85\x88";
2392 } elseif ( $code < 0xce74 ) {
2393 return "\xe3\x85\x8a";
2394 } elseif ( $code < 0xd0c0 ) {
2395 return "\xe3\x85\x8b";
2396 } elseif ( $code < 0xd30c ) {
2397 return "\xe3\x85\x8c";
2398 } elseif ( $code < 0xd558 ) {
2399 return "\xe3\x85\x8d";
2400 } else {
2401 return "\xe3\x85\x8e";
2402 }
2403 } else {
2404 return '';
2405 }
2406 }
2407
2408 function initEncoding() {
2409 # Some languages may have an alternate char encoding option
2410 # (Esperanto X-coding, Japanese furigana conversion, etc)
2411 # If this language is used as the primary content language,
2412 # an override to the defaults can be set here on startup.
2413 }
2414
2415 /**
2416 * @param $s string
2417 * @return string
2418 */
2419 function recodeForEdit( $s ) {
2420 # For some languages we'll want to explicitly specify
2421 # which characters make it into the edit box raw
2422 # or are converted in some way or another.
2423 global $wgEditEncoding;
2424 if ( $wgEditEncoding == '' || $wgEditEncoding == 'UTF-8' ) {
2425 return $s;
2426 } else {
2427 return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
2428 }
2429 }
2430
2431 /**
2432 * @param $s string
2433 * @return string
2434 */
2435 function recodeInput( $s ) {
2436 # Take the previous into account.
2437 global $wgEditEncoding;
2438 if ( $wgEditEncoding != '' ) {
2439 $enc = $wgEditEncoding;
2440 } else {
2441 $enc = 'UTF-8';
2442 }
2443 if ( $enc == 'UTF-8' ) {
2444 return $s;
2445 } else {
2446 return $this->iconv( $enc, 'UTF-8', $s );
2447 }
2448 }
2449
2450 /**
2451 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2452 * also cleans up certain backwards-compatible sequences, converting them
2453 * to the modern Unicode equivalent.
2454 *
2455 * This is language-specific for performance reasons only.
2456 *
2457 * @param $s string
2458 *
2459 * @return string
2460 */
2461 function normalize( $s ) {
2462 global $wgAllUnicodeFixes;
2463 $s = UtfNormal::cleanUp( $s );
2464 if ( $wgAllUnicodeFixes ) {
2465 $s = $this->transformUsingPairFile( 'normalize-ar.ser', $s );
2466 $s = $this->transformUsingPairFile( 'normalize-ml.ser', $s );
2467 }
2468
2469 return $s;
2470 }
2471
2472 /**
2473 * Transform a string using serialized data stored in the given file (which
2474 * must be in the serialized subdirectory of $IP). The file contains pairs
2475 * mapping source characters to destination characters.
2476 *
2477 * The data is cached in process memory. This will go faster if you have the
2478 * FastStringSearch extension.
2479 *
2480 * @param $file string
2481 * @param $string string
2482 *
2483 * @return string
2484 */
2485 function transformUsingPairFile( $file, $string ) {
2486 if ( !isset( $this->transformData[$file] ) ) {
2487 $data = wfGetPrecompiledData( $file );
2488 if ( $data === false ) {
2489 throw new MWException( __METHOD__ . ": The transformation file $file is missing" );
2490 }
2491 $this->transformData[$file] = new ReplacementArray( $data );
2492 }
2493 return $this->transformData[$file]->replace( $string );
2494 }
2495
2496 /**
2497 * For right-to-left language support
2498 *
2499 * @return bool
2500 */
2501 function isRTL() {
2502 return self::$dataCache->getItem( $this->mCode, 'rtl' );
2503 }
2504
2505 /**
2506 * Return the correct HTML 'dir' attribute value for this language.
2507 * @return String
2508 */
2509 function getDir() {
2510 return $this->isRTL() ? 'rtl' : 'ltr';
2511 }
2512
2513 /**
2514 * Return 'left' or 'right' as appropriate alignment for line-start
2515 * for this language's text direction.
2516 *
2517 * Should be equivalent to CSS3 'start' text-align value....
2518 *
2519 * @return String
2520 */
2521 function alignStart() {
2522 return $this->isRTL() ? 'right' : 'left';
2523 }
2524
2525 /**
2526 * Return 'right' or 'left' as appropriate alignment for line-end
2527 * for this language's text direction.
2528 *
2529 * Should be equivalent to CSS3 'end' text-align value....
2530 *
2531 * @return String
2532 */
2533 function alignEnd() {
2534 return $this->isRTL() ? 'left' : 'right';
2535 }
2536
2537 /**
2538 * A hidden direction mark (LRM or RLM), depending on the language direction
2539 *
2540 * @param $opposite Boolean Get the direction mark opposite to your language
2541 * @return string
2542 */
2543 function getDirMark( $opposite = false ) {
2544 $rtl = "\xE2\x80\x8F";
2545 $ltr = "\xE2\x80\x8E";
2546 if ( $opposite ) { return $this->isRTL() ? $ltr : $rtl; }
2547 return $this->isRTL() ? $rtl : $ltr;
2548 }
2549
2550 /**
2551 * @return array
2552 */
2553 function capitalizeAllNouns() {
2554 return self::$dataCache->getItem( $this->mCode, 'capitalizeAllNouns' );
2555 }
2556
2557 /**
2558 * An arrow, depending on the language direction
2559 *
2560 * @return string
2561 */
2562 function getArrow() {
2563 return $this->isRTL() ? '←' : '→';
2564 }
2565
2566 /**
2567 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2568 *
2569 * @return bool
2570 */
2571 function linkPrefixExtension() {
2572 return self::$dataCache->getItem( $this->mCode, 'linkPrefixExtension' );
2573 }
2574
2575 /**
2576 * @return array
2577 */
2578 function getMagicWords() {
2579 return self::$dataCache->getItem( $this->mCode, 'magicWords' );
2580 }
2581
2582 protected function doMagicHook() {
2583 if ( $this->mMagicHookDone ) {
2584 return;
2585 }
2586 $this->mMagicHookDone = true;
2587 wfProfileIn( 'LanguageGetMagic' );
2588 wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
2589 wfProfileOut( 'LanguageGetMagic' );
2590 }
2591
2592 /**
2593 * Fill a MagicWord object with data from here
2594 *
2595 * @param $mw
2596 */
2597 function getMagic( $mw ) {
2598 $this->doMagicHook();
2599
2600 if ( isset( $this->mMagicExtensions[$mw->mId] ) ) {
2601 $rawEntry = $this->mMagicExtensions[$mw->mId];
2602 } else {
2603 $magicWords = $this->getMagicWords();
2604 if ( isset( $magicWords[$mw->mId] ) ) {
2605 $rawEntry = $magicWords[$mw->mId];
2606 } else {
2607 $rawEntry = false;
2608 }
2609 }
2610
2611 if ( !is_array( $rawEntry ) ) {
2612 error_log( "\"$rawEntry\" is not a valid magic word for \"$mw->mId\"" );
2613 } else {
2614 $mw->mCaseSensitive = $rawEntry[0];
2615 $mw->mSynonyms = array_slice( $rawEntry, 1 );
2616 }
2617 }
2618
2619 /**
2620 * Add magic words to the extension array
2621 *
2622 * @param $newWords array
2623 */
2624 function addMagicWordsByLang( $newWords ) {
2625 $fallbackChain = $this->getFallbackLanguages();
2626 $fallbackChain = array_reverse( $fallbackChain );
2627 foreach ( $fallbackChain as $code ) {
2628 if ( isset( $newWords[$code] ) ) {
2629 $this->mMagicExtensions = $newWords[$code] + $this->mMagicExtensions;
2630 }
2631 }
2632 }
2633
2634 /**
2635 * Get special page names, as an associative array
2636 * case folded alias => real name
2637 */
2638 function getSpecialPageAliases() {
2639 // Cache aliases because it may be slow to load them
2640 if ( is_null( $this->mExtendedSpecialPageAliases ) ) {
2641 // Initialise array
2642 $this->mExtendedSpecialPageAliases =
2643 self::$dataCache->getItem( $this->mCode, 'specialPageAliases' );
2644 wfRunHooks( 'LanguageGetSpecialPageAliases',
2645 array( &$this->mExtendedSpecialPageAliases, $this->getCode() ) );
2646 }
2647
2648 return $this->mExtendedSpecialPageAliases;
2649 }
2650
2651 /**
2652 * Italic is unsuitable for some languages
2653 *
2654 * @param $text String: the text to be emphasized.
2655 * @return string
2656 */
2657 function emphasize( $text ) {
2658 return "<em>$text</em>";
2659 }
2660
2661 /**
2662 * Normally we output all numbers in plain en_US style, that is
2663 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2664 * point twohundredthirtyfive. However this is not suitable for all
2665 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2666 * Icelandic just want to use commas instead of dots, and dots instead
2667 * of commas like "293.291,235".
2668 *
2669 * An example of this function being called:
2670 * <code>
2671 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2672 * </code>
2673 *
2674 * See LanguageGu.php for the Gujarati implementation and
2675 * $separatorTransformTable on MessageIs.php for
2676 * the , => . and . => , implementation.
2677 *
2678 * @todo check if it's viable to use localeconv() for the decimal
2679 * separator thing.
2680 * @param $number Mixed: the string to be formatted, should be an integer
2681 * or a floating point number.
2682 * @param $nocommafy Bool: set to true for special numbers like dates
2683 * @return string
2684 */
2685 public function formatNum( $number, $nocommafy = false ) {
2686 global $wgTranslateNumerals;
2687 if ( !$nocommafy ) {
2688 $number = $this->commafy( $number );
2689 $s = $this->separatorTransformTable();
2690 if ( $s ) {
2691 $number = strtr( $number, $s );
2692 }
2693 }
2694
2695 if ( $wgTranslateNumerals ) {
2696 $s = $this->digitTransformTable();
2697 if ( $s ) {
2698 $number = strtr( $number, $s );
2699 }
2700 }
2701
2702 return $number;
2703 }
2704
2705 /**
2706 * @param $number string
2707 * @return string
2708 */
2709 function parseFormattedNumber( $number ) {
2710 $s = $this->digitTransformTable();
2711 if ( $s ) {
2712 $number = strtr( $number, array_flip( $s ) );
2713 }
2714
2715 $s = $this->separatorTransformTable();
2716 if ( $s ) {
2717 $number = strtr( $number, array_flip( $s ) );
2718 }
2719
2720 $number = strtr( $number, array( ',' => '' ) );
2721 return $number;
2722 }
2723
2724 /**
2725 * Adds commas to a given number
2726 * @since 1.19
2727 * @param $_ mixed
2728 * @return string
2729 */
2730 function commafy( $_ ) {
2731 $digitGroupingPattern = $this->digitGroupingPattern();
2732 if ( $_ === null ) {
2733 return '';
2734 }
2735
2736 if ( !$digitGroupingPattern || $digitGroupingPattern === "###,###,###" ) {
2737 // default grouping is at thousands, use the same for ###,###,### pattern too.
2738 return strrev( (string)preg_replace( '/(\d{3})(?=\d)(?!\d*\.)/', '$1,', strrev( $_ ) ) );
2739 } else {
2740 // Ref: http://cldr.unicode.org/translation/number-patterns
2741 $sign = "";
2742 if ( intval( $_ ) < 0 ) {
2743 // For negative numbers apply the algorithm like positive number and add sign.
2744 $sign = "-";
2745 $_ = substr( $_, 1 );
2746 }
2747 $numberpart = array();
2748 $decimalpart = array();
2749 $numMatches = preg_match_all( "/(#+)/", $digitGroupingPattern, $matches );
2750 preg_match( "/\d+/", $_, $numberpart );
2751 preg_match( "/\.\d*/", $_, $decimalpart );
2752 $groupedNumber = ( count( $decimalpart ) > 0 ) ? $decimalpart[0]:"";
2753 if ( $groupedNumber === $_ ) {
2754 // the string does not have any number part. Eg: .12345
2755 return $sign . $groupedNumber;
2756 }
2757 $start = $end = strlen( $numberpart[0] );
2758 while ( $start > 0 ) {
2759 $match = $matches[0][$numMatches -1] ;
2760 $matchLen = strlen( $match );
2761 $start = $end - $matchLen;
2762 if ( $start < 0 ) {
2763 $start = 0;
2764 }
2765 $groupedNumber = substr( $_ , $start, $end -$start ) . $groupedNumber ;
2766 $end = $start;
2767 if ( $numMatches > 1 ) {
2768 // use the last pattern for the rest of the number
2769 $numMatches--;
2770 }
2771 if ( $start > 0 ) {
2772 $groupedNumber = "," . $groupedNumber;
2773 }
2774 }
2775 return $sign . $groupedNumber;
2776 }
2777 }
2778 /**
2779 * @return String
2780 */
2781 function digitGroupingPattern() {
2782 return self::$dataCache->getItem( $this->mCode, 'digitGroupingPattern' );
2783 }
2784
2785 /**
2786 * @return array
2787 */
2788 function digitTransformTable() {
2789 return self::$dataCache->getItem( $this->mCode, 'digitTransformTable' );
2790 }
2791
2792 /**
2793 * @return array
2794 */
2795 function separatorTransformTable() {
2796 return self::$dataCache->getItem( $this->mCode, 'separatorTransformTable' );
2797 }
2798
2799 /**
2800 * Take a list of strings and build a locale-friendly comma-separated
2801 * list, using the local comma-separator message.
2802 * The last two strings are chained with an "and".
2803 *
2804 * @param $l Array
2805 * @return string
2806 */
2807 function listToText( array $l ) {
2808 $s = '';
2809 $m = count( $l ) - 1;
2810 if ( $m == 1 ) {
2811 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2812 } else {
2813 for ( $i = $m; $i >= 0; $i-- ) {
2814 if ( $i == $m ) {
2815 $s = $l[$i];
2816 } elseif ( $i == $m - 1 ) {
2817 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2818 } else {
2819 $s = $l[$i] . $this->getMessageFromDB( 'comma-separator' ) . $s;
2820 }
2821 }
2822 return $s;
2823 }
2824 }
2825
2826 /**
2827 * Take a list of strings and build a locale-friendly comma-separated
2828 * list, using the local comma-separator message.
2829 * @param $list array of strings to put in a comma list
2830 * @return string
2831 */
2832 function commaList( array $list ) {
2833 return implode(
2834 wfMsgExt(
2835 'comma-separator',
2836 array( 'parsemag', 'escapenoentities', 'language' => $this )
2837 ),
2838 $list
2839 );
2840 }
2841
2842 /**
2843 * Take a list of strings and build a locale-friendly semicolon-separated
2844 * list, using the local semicolon-separator message.
2845 * @param $list array of strings to put in a semicolon list
2846 * @return string
2847 */
2848 function semicolonList( array $list ) {
2849 return implode(
2850 wfMsgExt(
2851 'semicolon-separator',
2852 array( 'parsemag', 'escapenoentities', 'language' => $this )
2853 ),
2854 $list
2855 );
2856 }
2857
2858 /**
2859 * Same as commaList, but separate it with the pipe instead.
2860 * @param $list array of strings to put in a pipe list
2861 * @return string
2862 */
2863 function pipeList( array $list ) {
2864 return implode(
2865 wfMsgExt(
2866 'pipe-separator',
2867 array( 'escapenoentities', 'language' => $this )
2868 ),
2869 $list
2870 );
2871 }
2872
2873 /**
2874 * Truncate a string to a specified length in bytes, appending an optional
2875 * string (e.g. for ellipses)
2876 *
2877 * The database offers limited byte lengths for some columns in the database;
2878 * multi-byte character sets mean we need to ensure that only whole characters
2879 * are included, otherwise broken characters can be passed to the user
2880 *
2881 * If $length is negative, the string will be truncated from the beginning
2882 *
2883 * @param $string String to truncate
2884 * @param $length Int: maximum length (including ellipses)
2885 * @param $ellipsis String to append to the truncated text
2886 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
2887 * $adjustLength was introduced in 1.18, before that behaved as if false.
2888 * @return string
2889 */
2890 function truncate( $string, $length, $ellipsis = '...', $adjustLength = true ) {
2891 # Use the localized ellipsis character
2892 if ( $ellipsis == '...' ) {
2893 $ellipsis = wfMsgExt( 'ellipsis', array( 'escapenoentities', 'language' => $this ) );
2894 }
2895 # Check if there is no need to truncate
2896 if ( $length == 0 ) {
2897 return $ellipsis; // convention
2898 } elseif ( strlen( $string ) <= abs( $length ) ) {
2899 return $string; // no need to truncate
2900 }
2901 $stringOriginal = $string;
2902 # If ellipsis length is >= $length then we can't apply $adjustLength
2903 if ( $adjustLength && strlen( $ellipsis ) >= abs( $length ) ) {
2904 $string = $ellipsis; // this can be slightly unexpected
2905 # Otherwise, truncate and add ellipsis...
2906 } else {
2907 $eLength = $adjustLength ? strlen( $ellipsis ) : 0;
2908 if ( $length > 0 ) {
2909 $length -= $eLength;
2910 $string = substr( $string, 0, $length ); // xyz...
2911 $string = $this->removeBadCharLast( $string );
2912 $string = $string . $ellipsis;
2913 } else {
2914 $length += $eLength;
2915 $string = substr( $string, $length ); // ...xyz
2916 $string = $this->removeBadCharFirst( $string );
2917 $string = $ellipsis . $string;
2918 }
2919 }
2920 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
2921 # This check is *not* redundant if $adjustLength, due to the single case where
2922 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
2923 if ( strlen( $string ) < strlen( $stringOriginal ) ) {
2924 return $string;
2925 } else {
2926 return $stringOriginal;
2927 }
2928 }
2929
2930 /**
2931 * Remove bytes that represent an incomplete Unicode character
2932 * at the end of string (e.g. bytes of the char are missing)
2933 *
2934 * @param $string String
2935 * @return string
2936 */
2937 protected function removeBadCharLast( $string ) {
2938 if ( $string != '' ) {
2939 $char = ord( $string[strlen( $string ) - 1] );
2940 $m = array();
2941 if ( $char >= 0xc0 ) {
2942 # We got the first byte only of a multibyte char; remove it.
2943 $string = substr( $string, 0, -1 );
2944 } elseif ( $char >= 0x80 &&
2945 preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
2946 '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) )
2947 {
2948 # We chopped in the middle of a character; remove it
2949 $string = $m[1];
2950 }
2951 }
2952 return $string;
2953 }
2954
2955 /**
2956 * Remove bytes that represent an incomplete Unicode character
2957 * at the start of string (e.g. bytes of the char are missing)
2958 *
2959 * @param $string String
2960 * @return string
2961 */
2962 protected function removeBadCharFirst( $string ) {
2963 if ( $string != '' ) {
2964 $char = ord( $string[0] );
2965 if ( $char >= 0x80 && $char < 0xc0 ) {
2966 # We chopped in the middle of a character; remove the whole thing
2967 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
2968 }
2969 }
2970 return $string;
2971 }
2972
2973 /**
2974 * Truncate a string of valid HTML to a specified length in bytes,
2975 * appending an optional string (e.g. for ellipses), and return valid HTML
2976 *
2977 * This is only intended for styled/linked text, such as HTML with
2978 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
2979 * Also, this will not detect things like "display:none" CSS.
2980 *
2981 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
2982 *
2983 * @param string $text HTML string to truncate
2984 * @param int $length (zero/positive) Maximum length (including ellipses)
2985 * @param string $ellipsis String to append to the truncated text
2986 * @return string
2987 */
2988 function truncateHtml( $text, $length, $ellipsis = '...' ) {
2989 # Use the localized ellipsis character
2990 if ( $ellipsis == '...' ) {
2991 $ellipsis = wfMsgExt( 'ellipsis', array( 'escapenoentities', 'language' => $this ) );
2992 }
2993 # Check if there is clearly no need to truncate
2994 if ( $length <= 0 ) {
2995 return $ellipsis; // no text shown, nothing to format (convention)
2996 } elseif ( strlen( $text ) <= $length ) {
2997 return $text; // string short enough even *with* HTML (short-circuit)
2998 }
2999
3000 $dispLen = 0; // innerHTML legth so far
3001 $testingEllipsis = false; // checking if ellipses will make string longer/equal?
3002 $tagType = 0; // 0-open, 1-close
3003 $bracketState = 0; // 1-tag start, 2-tag name, 0-neither
3004 $entityState = 0; // 0-not entity, 1-entity
3005 $tag = $ret = ''; // accumulated tag name, accumulated result string
3006 $openTags = array(); // open tag stack
3007 $maybeState = null; // possible truncation state
3008
3009 $textLen = strlen( $text );
3010 $neLength = max( 0, $length - strlen( $ellipsis ) ); // non-ellipsis len if truncated
3011 for ( $pos = 0; true; ++$pos ) {
3012 # Consider truncation once the display length has reached the maximim.
3013 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3014 # Check that we're not in the middle of a bracket/entity...
3015 if ( $dispLen && $dispLen >= $neLength && $bracketState == 0 && !$entityState ) {
3016 if ( !$testingEllipsis ) {
3017 $testingEllipsis = true;
3018 # Save where we are; we will truncate here unless there turn out to
3019 # be so few remaining characters that truncation is not necessary.
3020 if ( !$maybeState ) { // already saved? ($neLength = 0 case)
3021 $maybeState = array( $ret, $openTags ); // save state
3022 }
3023 } elseif ( $dispLen > $length && $dispLen > strlen( $ellipsis ) ) {
3024 # String in fact does need truncation, the truncation point was OK.
3025 list( $ret, $openTags ) = $maybeState; // reload state
3026 $ret = $this->removeBadCharLast( $ret ); // multi-byte char fix
3027 $ret .= $ellipsis; // add ellipsis
3028 break;
3029 }
3030 }
3031 if ( $pos >= $textLen ) break; // extra iteration just for above checks
3032
3033 # Read the next char...
3034 $ch = $text[$pos];
3035 $lastCh = $pos ? $text[$pos - 1] : '';
3036 $ret .= $ch; // add to result string
3037 if ( $ch == '<' ) {
3038 $this->truncate_endBracket( $tag, $tagType, $lastCh, $openTags ); // for bad HTML
3039 $entityState = 0; // for bad HTML
3040 $bracketState = 1; // tag started (checking for backslash)
3041 } elseif ( $ch == '>' ) {
3042 $this->truncate_endBracket( $tag, $tagType, $lastCh, $openTags );
3043 $entityState = 0; // for bad HTML
3044 $bracketState = 0; // out of brackets
3045 } elseif ( $bracketState == 1 ) {
3046 if ( $ch == '/' ) {
3047 $tagType = 1; // close tag (e.g. "</span>")
3048 } else {
3049 $tagType = 0; // open tag (e.g. "<span>")
3050 $tag .= $ch;
3051 }
3052 $bracketState = 2; // building tag name
3053 } elseif ( $bracketState == 2 ) {
3054 if ( $ch != ' ' ) {
3055 $tag .= $ch;
3056 } else {
3057 // Name found (e.g. "<a href=..."), add on tag attributes...
3058 $pos += $this->truncate_skip( $ret, $text, "<>", $pos + 1 );
3059 }
3060 } elseif ( $bracketState == 0 ) {
3061 if ( $entityState ) {
3062 if ( $ch == ';' ) {
3063 $entityState = 0;
3064 $dispLen++; // entity is one displayed char
3065 }
3066 } else {
3067 if ( $neLength == 0 && !$maybeState ) {
3068 // Save state without $ch. We want to *hit* the first
3069 // display char (to get tags) but not *use* it if truncating.
3070 $maybeState = array( substr( $ret, 0, -1 ), $openTags );
3071 }
3072 if ( $ch == '&' ) {
3073 $entityState = 1; // entity found, (e.g. "&#160;")
3074 } else {
3075 $dispLen++; // this char is displayed
3076 // Add the next $max display text chars after this in one swoop...
3077 $max = ( $testingEllipsis ? $length : $neLength ) - $dispLen;
3078 $skipped = $this->truncate_skip( $ret, $text, "<>&", $pos + 1, $max );
3079 $dispLen += $skipped;
3080 $pos += $skipped;
3081 }
3082 }
3083 }
3084 }
3085 // Close the last tag if left unclosed by bad HTML
3086 $this->truncate_endBracket( $tag, $text[$textLen - 1], $tagType, $openTags );
3087 while ( count( $openTags ) > 0 ) {
3088 $ret .= '</' . array_pop( $openTags ) . '>'; // close open tags
3089 }
3090 return $ret;
3091 }
3092
3093 /**
3094 * truncateHtml() helper function
3095 * like strcspn() but adds the skipped chars to $ret
3096 *
3097 * @param $ret
3098 * @param $text
3099 * @param $search
3100 * @param $start
3101 * @param $len
3102 * @return int
3103 */
3104 private function truncate_skip( &$ret, $text, $search, $start, $len = null ) {
3105 if ( $len === null ) {
3106 $len = -1; // -1 means "no limit" for strcspn
3107 } elseif ( $len < 0 ) {
3108 $len = 0; // sanity
3109 }
3110 $skipCount = 0;
3111 if ( $start < strlen( $text ) ) {
3112 $skipCount = strcspn( $text, $search, $start, $len );
3113 $ret .= substr( $text, $start, $skipCount );
3114 }
3115 return $skipCount;
3116 }
3117
3118 /**
3119 * truncateHtml() helper function
3120 * (a) push or pop $tag from $openTags as needed
3121 * (b) clear $tag value
3122 * @param &$tag string Current HTML tag name we are looking at
3123 * @param $tagType int (0-open tag, 1-close tag)
3124 * @param $lastCh char|string Character before the '>' that ended this tag
3125 * @param &$openTags array Open tag stack (not accounting for $tag)
3126 */
3127 private function truncate_endBracket( &$tag, $tagType, $lastCh, &$openTags ) {
3128 $tag = ltrim( $tag );
3129 if ( $tag != '' ) {
3130 if ( $tagType == 0 && $lastCh != '/' ) {
3131 $openTags[] = $tag; // tag opened (didn't close itself)
3132 } elseif ( $tagType == 1 ) {
3133 if ( $openTags && $tag == $openTags[count( $openTags ) - 1] ) {
3134 array_pop( $openTags ); // tag closed
3135 }
3136 }
3137 $tag = '';
3138 }
3139 }
3140
3141 /**
3142 * Grammatical transformations, needed for inflected languages
3143 * Invoked by putting {{grammar:case|word}} in a message
3144 *
3145 * @param $word string
3146 * @param $case string
3147 * @return string
3148 */
3149 function convertGrammar( $word, $case ) {
3150 global $wgGrammarForms;
3151 if ( isset( $wgGrammarForms[$this->getCode()][$case][$word] ) ) {
3152 return $wgGrammarForms[$this->getCode()][$case][$word];
3153 }
3154 return $word;
3155 }
3156
3157 /**
3158 * Provides an alternative text depending on specified gender.
3159 * Usage {{gender:username|masculine|feminine|neutral}}.
3160 * username is optional, in which case the gender of current user is used,
3161 * but only in (some) interface messages; otherwise default gender is used.
3162 * If second or third parameter are not specified, masculine is used.
3163 * These details may be overriden per language.
3164 *
3165 * @param $gender string
3166 * @param $forms array
3167 *
3168 * @return string
3169 */
3170 function gender( $gender, $forms ) {
3171 if ( !count( $forms ) ) {
3172 return '';
3173 }
3174 $forms = $this->preConvertPlural( $forms, 2 );
3175 if ( $gender === 'male' ) {
3176 return $forms[0];
3177 }
3178 if ( $gender === 'female' ) {
3179 return $forms[1];
3180 }
3181 return isset( $forms[2] ) ? $forms[2] : $forms[0];
3182 }
3183
3184 /**
3185 * Plural form transformations, needed for some languages.
3186 * For example, there are 3 form of plural in Russian and Polish,
3187 * depending on "count mod 10". See [[w:Plural]]
3188 * For English it is pretty simple.
3189 *
3190 * Invoked by putting {{plural:count|wordform1|wordform2}}
3191 * or {{plural:count|wordform1|wordform2|wordform3}}
3192 *
3193 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3194 *
3195 * @param $count Integer: non-localized number
3196 * @param $forms Array: different plural forms
3197 * @return string Correct form of plural for $count in this language
3198 */
3199 function convertPlural( $count, $forms ) {
3200 if ( !count( $forms ) ) {
3201 return '';
3202 }
3203 $forms = $this->preConvertPlural( $forms, 2 );
3204
3205 return ( $count == 1 ) ? $forms[0] : $forms[1];
3206 }
3207
3208 /**
3209 * Checks that convertPlural was given an array and pads it to requested
3210 * amount of forms by copying the last one.
3211 *
3212 * @param $count Integer: How many forms should there be at least
3213 * @param $forms Array of forms given to convertPlural
3214 * @return array Padded array of forms or an exception if not an array
3215 */
3216 protected function preConvertPlural( /* Array */ $forms, $count ) {
3217 while ( count( $forms ) < $count ) {
3218 $forms[] = $forms[count( $forms ) - 1];
3219 }
3220 return $forms;
3221 }
3222
3223 /**
3224 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3225 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3226 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3227 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3228 * match up with it.
3229 *
3230 * @param $str String: the validated block duration in English
3231 * @return Somehow translated block duration
3232 * @see LanguageFi.php for example implementation
3233 */
3234 function translateBlockExpiry( $str ) {
3235 $duration = SpecialBlock::getSuggestedDurations( $this );
3236 foreach ( $duration as $show => $value ) {
3237 if ( strcmp( $str, $value ) == 0 ) {
3238 return htmlspecialchars( trim( $show ) );
3239 }
3240 }
3241
3242 // Since usually only infinite or indefinite is only on list, so try
3243 // equivalents if still here.
3244 $indefs = array( 'infinite', 'infinity', 'indefinite' );
3245 if ( in_array( $str, $indefs ) ) {
3246 foreach ( $indefs as $val ) {
3247 $show = array_search( $val, $duration, true );
3248 if ( $show !== false ) {
3249 return htmlspecialchars( trim( $show ) );
3250 }
3251 }
3252 }
3253 // If all else fails, return the original string.
3254 return $str;
3255 }
3256
3257 /**
3258 * languages like Chinese need to be segmented in order for the diff
3259 * to be of any use
3260 *
3261 * @param $text String
3262 * @return String
3263 */
3264 public function segmentForDiff( $text ) {
3265 return $text;
3266 }
3267
3268 /**
3269 * and unsegment to show the result
3270 *
3271 * @param $text String
3272 * @return String
3273 */
3274 public function unsegmentForDiff( $text ) {
3275 return $text;
3276 }
3277
3278 /**
3279 * Return the LanguageConverter used in the Language
3280 * @return LanguageConverter
3281 */
3282 public function getConverter() {
3283 return $this->mConverter;
3284 }
3285
3286 /**
3287 * convert text to all supported variants
3288 *
3289 * @param $text string
3290 * @return array
3291 */
3292 public function autoConvertToAllVariants( $text ) {
3293 return $this->mConverter->autoConvertToAllVariants( $text );
3294 }
3295
3296 /**
3297 * convert text to different variants of a language.
3298 *
3299 * @param $text string
3300 * @return string
3301 */
3302 public function convert( $text ) {
3303 return $this->mConverter->convert( $text );
3304 }
3305
3306 /**
3307 * Convert a Title object to a string in the preferred variant
3308 *
3309 * @param $title Title
3310 * @return string
3311 */
3312 public function convertTitle( $title ) {
3313 return $this->mConverter->convertTitle( $title );
3314 }
3315
3316 /**
3317 * Check if this is a language with variants
3318 *
3319 * @return bool
3320 */
3321 public function hasVariants() {
3322 return sizeof( $this->getVariants() ) > 1;
3323 }
3324
3325 /**
3326 * Check if the language has the specific variant
3327 * @param $variant string
3328 * @return bool
3329 */
3330 public function hasVariant( $variant ) {
3331 return (bool)$this->mConverter->validateVariant( $variant );
3332 }
3333
3334 /**
3335 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3336 *
3337 * @param $text string
3338 * @return string
3339 */
3340 public function armourMath( $text ) {
3341 return $this->mConverter->armourMath( $text );
3342 }
3343
3344 /**
3345 * Perform output conversion on a string, and encode for safe HTML output.
3346 * @param $text String text to be converted
3347 * @param $isTitle Bool whether this conversion is for the article title
3348 * @return string
3349 * @todo this should get integrated somewhere sane
3350 */
3351 public function convertHtml( $text, $isTitle = false ) {
3352 return htmlspecialchars( $this->convert( $text, $isTitle ) );
3353 }
3354
3355 /**
3356 * @param $key string
3357 * @return string
3358 */
3359 public function convertCategoryKey( $key ) {
3360 return $this->mConverter->convertCategoryKey( $key );
3361 }
3362
3363 /**
3364 * Get the list of variants supported by this language
3365 * see sample implementation in LanguageZh.php
3366 *
3367 * @return array an array of language codes
3368 */
3369 public function getVariants() {
3370 return $this->mConverter->getVariants();
3371 }
3372
3373 /**
3374 * @return string
3375 */
3376 public function getPreferredVariant() {
3377 return $this->mConverter->getPreferredVariant();
3378 }
3379
3380 /**
3381 * @return string
3382 */
3383 public function getDefaultVariant() {
3384 return $this->mConverter->getDefaultVariant();
3385 }
3386
3387 /**
3388 * @return string
3389 */
3390 public function getURLVariant() {
3391 return $this->mConverter->getURLVariant();
3392 }
3393
3394 /**
3395 * If a language supports multiple variants, it is
3396 * possible that non-existing link in one variant
3397 * actually exists in another variant. this function
3398 * tries to find it. See e.g. LanguageZh.php
3399 *
3400 * @param $link String: the name of the link
3401 * @param $nt Mixed: the title object of the link
3402 * @param $ignoreOtherCond Boolean: to disable other conditions when
3403 * we need to transclude a template or update a category's link
3404 * @return null the input parameters may be modified upon return
3405 */
3406 public function findVariantLink( &$link, &$nt, $ignoreOtherCond = false ) {
3407 $this->mConverter->findVariantLink( $link, $nt, $ignoreOtherCond );
3408 }
3409
3410 /**
3411 * If a language supports multiple variants, converts text
3412 * into an array of all possible variants of the text:
3413 * 'variant' => text in that variant
3414 *
3415 * @deprecated since 1.17 Use autoConvertToAllVariants()
3416 *
3417 * @param $text string
3418 *
3419 * @return string
3420 */
3421 public function convertLinkToAllVariants( $text ) {
3422 return $this->mConverter->convertLinkToAllVariants( $text );
3423 }
3424
3425 /**
3426 * returns language specific options used by User::getPageRenderHash()
3427 * for example, the preferred language variant
3428 *
3429 * @return string
3430 */
3431 function getExtraHashOptions() {
3432 return $this->mConverter->getExtraHashOptions();
3433 }
3434
3435 /**
3436 * For languages that support multiple variants, the title of an
3437 * article may be displayed differently in different variants. this
3438 * function returns the apporiate title defined in the body of the article.
3439 *
3440 * @return string
3441 */
3442 public function getParsedTitle() {
3443 return $this->mConverter->getParsedTitle();
3444 }
3445
3446 /**
3447 * Enclose a string with the "no conversion" tag. This is used by
3448 * various functions in the Parser
3449 *
3450 * @param $text String: text to be tagged for no conversion
3451 * @param $noParse bool
3452 * @return string the tagged text
3453 */
3454 public function markNoConversion( $text, $noParse = false ) {
3455 return $this->mConverter->markNoConversion( $text, $noParse );
3456 }
3457
3458 /**
3459 * A regular expression to match legal word-trailing characters
3460 * which should be merged onto a link of the form [[foo]]bar.
3461 *
3462 * @return string
3463 */
3464 public function linkTrail() {
3465 return self::$dataCache->getItem( $this->mCode, 'linkTrail' );
3466 }
3467
3468 /**
3469 * @return Language
3470 */
3471 function getLangObj() {
3472 return $this;
3473 }
3474
3475 /**
3476 * Get the RFC 3066 code for this language object
3477 *
3478 * @return string
3479 */
3480 public function getCode() {
3481 return $this->mCode;
3482 }
3483
3484 /**
3485 * Get the code in Bcp47 format which we can use
3486 * inside of html lang="" tags.
3487 * @since 1.19
3488 * @return string
3489 */
3490 public function getHtmlCode() {
3491 if ( is_null( $this->mHtmlCode ) ) {
3492 $this->mHtmlCode = wfBCP47( $this->getCode() );
3493 }
3494 return $this->mHtmlCode;
3495 }
3496
3497 /**
3498 * @param $code string
3499 */
3500 public function setCode( $code ) {
3501 $this->mCode = $code;
3502 // Ensure we don't leave an incorrect html code lying around
3503 $this->mHtmlCode = null;
3504 }
3505
3506 /**
3507 * Get the name of a file for a certain language code
3508 * @param $prefix string Prepend this to the filename
3509 * @param $code string Language code
3510 * @param $suffix string Append this to the filename
3511 * @return string $prefix . $mangledCode . $suffix
3512 */
3513 public static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
3514 // Protect against path traversal
3515 if ( !Language::isValidCode( $code )
3516 || strcspn( $code, ":/\\\000" ) !== strlen( $code ) )
3517 {
3518 throw new MWException( "Invalid language code \"$code\"" );
3519 }
3520
3521 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
3522 }
3523
3524 /**
3525 * Get the language code from a file name. Inverse of getFileName()
3526 * @param $filename string $prefix . $languageCode . $suffix
3527 * @param $prefix string Prefix before the language code
3528 * @param $suffix string Suffix after the language code
3529 * @return string Language code, or false if $prefix or $suffix isn't found
3530 */
3531 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3532 $m = null;
3533 preg_match( '/' . preg_quote( $prefix, '/' ) . '([A-Z][a-z_]+)' .
3534 preg_quote( $suffix, '/' ) . '/', $filename, $m );
3535 if ( !count( $m ) ) {
3536 return false;
3537 }
3538 return str_replace( '_', '-', strtolower( $m[1] ) );
3539 }
3540
3541 /**
3542 * @param $code string
3543 * @return string
3544 */
3545 public static function getMessagesFileName( $code ) {
3546 global $IP;
3547 $file = self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
3548 wfRunHooks( 'Language::getMessagesFileName', array( $code, &$file ) );
3549 return $file;
3550 }
3551
3552 /**
3553 * @param $code string
3554 * @return string
3555 */
3556 public static function getClassFileName( $code ) {
3557 global $IP;
3558 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
3559 }
3560
3561 /**
3562 * Get the first fallback for a given language.
3563 *
3564 * @param $code string
3565 *
3566 * @return false|string
3567 */
3568 public static function getFallbackFor( $code ) {
3569 if ( $code === 'en' || !Language::isValidBuiltInCode( $code ) ) {
3570 return false;
3571 } else {
3572 $fallbacks = self::getFallbacksFor( $code );
3573 $first = array_shift( $fallbacks );
3574 return $first;
3575 }
3576 }
3577
3578 /**
3579 * Get the ordered list of fallback languages.
3580 *
3581 * @since 1.19
3582 * @param $code string Language code
3583 * @return array
3584 */
3585 public static function getFallbacksFor( $code ) {
3586 if ( $code === 'en' || !Language::isValidBuiltInCode( $code ) ) {
3587 return array();
3588 } else {
3589 $v = self::getLocalisationCache()->getItem( $code, 'fallback' );
3590 $v = array_map( 'trim', explode( ',', $v ) );
3591 if ( $v[count( $v ) - 1] !== 'en' ) {
3592 $v[] = 'en';
3593 }
3594 return $v;
3595 }
3596 }
3597
3598 /**
3599 * Get all messages for a given language
3600 * WARNING: this may take a long time. If you just need all message *keys*
3601 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3602 *
3603 * @param $code string
3604 *
3605 * @return array
3606 */
3607 public static function getMessagesFor( $code ) {
3608 return self::getLocalisationCache()->getItem( $code, 'messages' );
3609 }
3610
3611 /**
3612 * Get a message for a given language
3613 *
3614 * @param $key string
3615 * @param $code string
3616 *
3617 * @return string
3618 */
3619 public static function getMessageFor( $key, $code ) {
3620 return self::getLocalisationCache()->getSubitem( $code, 'messages', $key );
3621 }
3622
3623 /**
3624 * Get all message keys for a given language. This is a faster alternative to
3625 * array_keys( Language::getMessagesFor( $code ) )
3626 *
3627 * @since 1.19
3628 * @param $code string Language code
3629 * @return array of message keys (strings)
3630 */
3631 public static function getMessageKeysFor( $code ) {
3632 return self::getLocalisationCache()->getSubItemList( $code, 'messages' );
3633 }
3634
3635 /**
3636 * @param $talk
3637 * @return mixed
3638 */
3639 function fixVariableInNamespace( $talk ) {
3640 if ( strpos( $talk, '$1' ) === false ) {
3641 return $talk;
3642 }
3643
3644 global $wgMetaNamespace;
3645 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
3646
3647 # Allow grammar transformations
3648 # Allowing full message-style parsing would make simple requests
3649 # such as action=raw much more expensive than they need to be.
3650 # This will hopefully cover most cases.
3651 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
3652 array( &$this, 'replaceGrammarInNamespace' ), $talk );
3653 return str_replace( ' ', '_', $talk );
3654 }
3655
3656 /**
3657 * @param $m string
3658 * @return string
3659 */
3660 function replaceGrammarInNamespace( $m ) {
3661 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
3662 }
3663
3664 /**
3665 * @throws MWException
3666 * @return array
3667 */
3668 static function getCaseMaps() {
3669 static $wikiUpperChars, $wikiLowerChars;
3670 if ( isset( $wikiUpperChars ) ) {
3671 return array( $wikiUpperChars, $wikiLowerChars );
3672 }
3673
3674 wfProfileIn( __METHOD__ );
3675 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
3676 if ( $arr === false ) {
3677 throw new MWException(
3678 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
3679 }
3680 $wikiUpperChars = $arr['wikiUpperChars'];
3681 $wikiLowerChars = $arr['wikiLowerChars'];
3682 wfProfileOut( __METHOD__ );
3683 return array( $wikiUpperChars, $wikiLowerChars );
3684 }
3685
3686 /**
3687 * Decode an expiry (block, protection, etc) which has come from the DB
3688 *
3689 * @param $expiry String: Database expiry String
3690 * @param $format Bool|Int true to process using language functions, or TS_ constant
3691 * to return the expiry in a given timestamp
3692 * @return String
3693 */
3694 public function formatExpiry( $expiry, $format = true ) {
3695 static $infinity, $infinityMsg;
3696 if ( $infinity === null ) {
3697 $infinityMsg = wfMessage( 'infiniteblock' );
3698 $infinity = wfGetDB( DB_SLAVE )->getInfinity();
3699 }
3700
3701 if ( $expiry == '' || $expiry == $infinity ) {
3702 return $format === true
3703 ? $infinityMsg
3704 : $infinity;
3705 } else {
3706 return $format === true
3707 ? $this->timeanddate( $expiry, /* User preference timezone */ true )
3708 : wfTimestamp( $format, $expiry );
3709 }
3710 }
3711
3712 /**
3713 * @todo Document
3714 * @param $seconds int|float
3715 * @param $format Array Optional
3716 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
3717 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
3718 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
3719 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
3720 * @return string
3721 */
3722 function formatTimePeriod( $seconds, $format = array() ) {
3723 if ( !is_array( $format ) ) {
3724 $format = array( 'avoid' => $format ); // For backwards compatibility
3725 }
3726 if ( !isset( $format['avoid'] ) ) {
3727 $format['avoid'] = false;
3728 }
3729 if ( !isset( $format['noabbrevs' ] ) ) {
3730 $format['noabbrevs'] = false;
3731 }
3732 $secondsMsg = wfMessage(
3733 $format['noabbrevs'] ? 'seconds' : 'seconds-abbrev' )->inLanguage( $this );
3734 $minutesMsg = wfMessage(
3735 $format['noabbrevs'] ? 'minutes' : 'minutes-abbrev' )->inLanguage( $this );
3736 $hoursMsg = wfMessage(
3737 $format['noabbrevs'] ? 'hours' : 'hours-abbrev' )->inLanguage( $this );
3738 $daysMsg = wfMessage(
3739 $format['noabbrevs'] ? 'days' : 'days-abbrev' )->inLanguage( $this );
3740
3741 if ( round( $seconds * 10 ) < 100 ) {
3742 $s = $this->formatNum( sprintf( "%.1f", round( $seconds * 10 ) / 10 ) );
3743 $s = $secondsMsg->params( $s )->text();
3744 } elseif ( round( $seconds ) < 60 ) {
3745 $s = $this->formatNum( round( $seconds ) );
3746 $s = $secondsMsg->params( $s )->text();
3747 } elseif ( round( $seconds ) < 3600 ) {
3748 $minutes = floor( $seconds / 60 );
3749 $secondsPart = round( fmod( $seconds, 60 ) );
3750 if ( $secondsPart == 60 ) {
3751 $secondsPart = 0;
3752 $minutes++;
3753 }
3754 $s = $minutesMsg->params( $this->formatNum( $minutes ) )->text();
3755 $s .= ' ';
3756 $s .= $secondsMsg->params( $this->formatNum( $secondsPart ) )->text();
3757 } elseif ( round( $seconds ) <= 2 * 86400 ) {
3758 $hours = floor( $seconds / 3600 );
3759 $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
3760 $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
3761 if ( $secondsPart == 60 ) {
3762 $secondsPart = 0;
3763 $minutes++;
3764 }
3765 if ( $minutes == 60 ) {
3766 $minutes = 0;
3767 $hours++;
3768 }
3769 $s = $hoursMsg->params( $this->formatNum( $hours ) )->text();
3770 $s .= ' ';
3771 $s .= $minutesMsg->params( $this->formatNum( $minutes ) )->text();
3772 if ( !in_array( $format['avoid'], array( 'avoidseconds', 'avoidminutes' ) ) ) {
3773 $s .= ' ' . $secondsMsg->params( $this->formatNum( $secondsPart ) )->text();
3774 }
3775 } else {
3776 $days = floor( $seconds / 86400 );
3777 if ( $format['avoid'] === 'avoidminutes' ) {
3778 $hours = round( ( $seconds - $days * 86400 ) / 3600 );
3779 if ( $hours == 24 ) {
3780 $hours = 0;
3781 $days++;
3782 }
3783 $s = $daysMsg->params( $this->formatNum( $days ) )->text();
3784 $s .= ' ';
3785 $s .= $hoursMsg->params( $this->formatNum( $hours ) )->text();
3786 } elseif ( $format['avoid'] === 'avoidseconds' ) {
3787 $hours = floor( ( $seconds - $days * 86400 ) / 3600 );
3788 $minutes = round( ( $seconds - $days * 86400 - $hours * 3600 ) / 60 );
3789 if ( $minutes == 60 ) {
3790 $minutes = 0;
3791 $hours++;
3792 }
3793 if ( $hours == 24 ) {
3794 $hours = 0;
3795 $days++;
3796 }
3797 $s = $daysMsg->params( $this->formatNum( $days ) )->text();
3798 $s .= ' ';
3799 $s .= $hoursMsg->params( $this->formatNum( $hours ) )->text();
3800 $s .= ' ';
3801 $s .= $minutesMsg->params( $this->formatNum( $minutes ) )->text();
3802 } else {
3803 $s = $daysMsg->params( $this->formatNum( $days ) )->text();
3804 $s .= ' ';
3805 $s .= $this->formatTimePeriod( $seconds - $days * 86400, $format );
3806 }
3807 }
3808 return $s;
3809 }
3810
3811 /**
3812 * Format a bitrate for output, using an appropriate
3813 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
3814 *
3815 * @param $bps int
3816 * @return string
3817 */
3818 function formatBitrate( $bps ) {
3819 $units = array( '', 'kilo', 'mega', 'giga', 'tera', 'peta', 'exa', 'zeta', 'yotta' );
3820 if ( $bps <= 0 ) {
3821 return str_replace( '$1', $this->formatNum( $bps ), $this->getMessageFromDB( 'bitrate-bits' ) );
3822 }
3823 $unitIndex = (int)floor( log10( $bps ) / 3 );
3824 $mantissa = $bps / pow( 1000, $unitIndex );
3825
3826 $maxIndex = count( $units ) - 1;
3827
3828 if ( $unitIndex > $maxIndex ) {
3829 // Prevent code falling off end of $units array
3830 $mantissa *= ( $unitIndex - $maxIndex ) * 1000;
3831 $unitIndex = $maxIndex;
3832 }
3833 if ( $mantissa < 10 ) {
3834 $mantissa = round( $mantissa, 1 );
3835 } else {
3836 $mantissa = round( $mantissa );
3837 }
3838 $msg = "bitrate-{$units[$unitIndex]}bits";
3839 $text = $this->getMessageFromDB( $msg );
3840 return str_replace( '$1', $this->formatNum( $mantissa ), $text );
3841 }
3842
3843 /**
3844 * Format a size in bytes for output, using an appropriate
3845 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
3846 *
3847 * @param $size int Size to format
3848 * @return string Plain text (not HTML)
3849 */
3850 function formatSize( $size ) {
3851 $sizes = array( '', 'kilo', 'mega', 'giga', 'tera', 'peta', 'exa', 'zeta', 'yotta' );
3852 $index = 0;
3853
3854 $maxIndex = count( $sizes ) - 1;
3855 while ( $size >= 1024 && $index < $maxIndex ) {
3856 $index++;
3857 $size /= 1024;
3858 }
3859
3860 // For small sizes no decimal places necessary
3861 $round = 0;
3862 if ( $index > 1 ) {
3863 // For MB and bigger two decimal places are smarter
3864 $round = 2;
3865 }
3866 $msg = "size-{$sizes[$index]}bytes";
3867
3868 $size = round( $size, $round );
3869 $text = $this->getMessageFromDB( $msg );
3870 return str_replace( '$1', $this->formatNum( $size ), $text );
3871 }
3872
3873 /**
3874 * Make a list item, used by various special pages
3875 *
3876 * @param $page String Page link
3877 * @param $details String Text between brackets
3878 * @param $oppositedm Boolean Add the direction mark opposite to your
3879 * language, to display text properly
3880 * @return String
3881 */
3882 function specialList( $page, $details, $oppositedm = true ) {
3883 $dirmark = ( $oppositedm ? $this->getDirMark( true ) : '' ) .
3884 $this->getDirMark();
3885 $details = $details ? $dirmark . $this->getMessageFromDB( 'word-separator' ) .
3886 wfMsgExt( 'parentheses', array( 'escape', 'replaceafter', 'language' => $this ), $details ) : '';
3887 return $page . $details;
3888 }
3889
3890 /**
3891 * Generate (prev x| next x) (20|50|100...) type links for paging
3892 *
3893 * @param $title Title object to link
3894 * @param $offset Integer offset parameter
3895 * @param $limit Integer limit parameter
3896 * @param $query String optional URL query parameter string
3897 * @param $atend Bool optional param for specified if this is the last page
3898 * @return String
3899 */
3900 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
3901 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
3902
3903 # Make 'previous' link
3904 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3905 if ( $offset > 0 ) {
3906 $plink = $this->numLink( $title, max( $offset - $limit, 0 ), $limit,
3907 $query, $prev, 'prevn-title', 'mw-prevlink' );
3908 } else {
3909 $plink = htmlspecialchars( $prev );
3910 }
3911
3912 # Make 'next' link
3913 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3914 if ( $atend ) {
3915 $nlink = htmlspecialchars( $next );
3916 } else {
3917 $nlink = $this->numLink( $title, $offset + $limit, $limit,
3918 $query, $next, 'prevn-title', 'mw-nextlink' );
3919 }
3920
3921 # Make links to set number of items per page
3922 $numLinks = array();
3923 foreach ( array( 20, 50, 100, 250, 500 ) as $num ) {
3924 $numLinks[] = $this->numLink( $title, $offset, $num,
3925 $query, $this->formatNum( $num ), 'shown-title', 'mw-numlink' );
3926 }
3927
3928 return wfMessage( 'viewprevnext' )->inLanguage( $this )->title( $title
3929 )->rawParams( $plink, $nlink, $this->pipeList( $numLinks ) )->escaped();
3930 }
3931
3932 /**
3933 * Helper function for viewPrevNext() that generates links
3934 *
3935 * @param $title Title object to link
3936 * @param $offset Integer offset parameter
3937 * @param $limit Integer limit parameter
3938 * @param $query Array extra query parameters
3939 * @param $link String text to use for the link; will be escaped
3940 * @param $tooltipMsg String name of the message to use as tooltip
3941 * @param $class String value of the "class" attribute of the link
3942 * @return String HTML fragment
3943 */
3944 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
3945 $query = array( 'limit' => $limit, 'offset' => $offset ) + $query;
3946 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3947 return Html::element( 'a', array( 'href' => $title->getLocalURL( $query ),
3948 'title' => $tooltip, 'class' => $class ), $link );
3949 }
3950
3951 /**
3952 * Get the conversion rule title, if any.
3953 *
3954 * @return string
3955 */
3956 public function getConvRuleTitle() {
3957 return $this->mConverter->getConvRuleTitle();
3958 }
3959 }
Wiklou, le Wiki du Wiklou