| blob | 262d86fa3e61d5e02c1a8030eda2ce83ccb9b434 |
1 <?php
2 /**
3 * Internationalisation code.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
19 *
20 * @file
21 * @ingroup Language
22 */
24 /**
25 * @defgroup Language Language
26 */
31 }
33 # Read language names
39 }
41 /**
42 * a fake language converter
43 *
44 * @ingroup Language
45 */
47 /**
48 * @var Language
49 */
69 }
71 /**
72 * Internationalisation code
73 * @ingroup Language
74 */
77 /**
78 * @var LanguageConverter
79 */
91 /**
92 * ReplacementArray object caches
93 */
96 /**
97 * @var LocalisationCache
98 */
106 );
110 );
115 'december'
116 );
120 'december-gen'
121 );
125 );
132 );
140 );
148 );
155 );
157 /**
158 * @since 1.20
159 * @var array
160 */
171 );
173 /**
174 * Cache for language fallbacks.
175 * @see Language::getFallbacksIncludingSiteLanguage
176 * @since 1.21
177 * @var array
178 */
181 /**
182 * Get a cached or new language object for a given language code
183 * @param $code String
184 * @return Language
185 */
191 }
193 // get the language object to process
198 // merge the language object in to get it up front in the cache
200 // get rid of the oldest ones in case we have an overflow
204 }
206 /**
207 * Create a language object for a given language code
208 * @param $code String
209 * @throws MWException
210 * @return Language
211 */
213 // Protect against path traversal below
216 {
218 }
221 // It's not possible to customise this code with class files, so
222 // just return a Language object. This is to support uselang= hacks.
226 }
228 // Check if there is a language class for the code
234 }
236 // Keep trying the fallback list until we find an existing class
241 }
249 }
250 }
253 }
255 /**
256 * Checks whether any localisation is available for that language tag
257 * in MediaWiki (MessagesXx.php exists).
258 *
259 * @param string $code Language tag (in lower case)
260 * @return bool Whether language is supported
261 * @since 1.21
262 */
265 }
267 /**
268 * Returns true if a language code string is a well-formed language tag
269 * according to RFC 5646.
270 * This function only checks well-formedness; it doesn't check that
271 * language, script or variant codes actually exist in the repositories.
272 *
273 * Based on regexes by Mark Davis of the Unicode Consortium:
274 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
275 *
276 * @param $code string
277 * @param $lenient boolean Whether to allow '_' as separator. The default is only '-'.
278 *
279 * @return bool
280 * @since 1.21
281 */
297 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
298 # Since these are limited, this is safe even later changes to the registry --
299 # the only oddity is that it might change the type of the tag, and thus
300 # the results from the capturing groups.
301 # http://www.iana.org/assignments/language-subtag-registry
319 # The final breakdown, with capturing groups for each of these components
320 # The variants, extensions, grandfathered, and private-use may have interior '-'
325 }
327 /**
328 * Returns true if a language code string is of a valid form, whether or
329 * not it exists. This includes codes which are used solely for
330 * customisation via the MediaWiki namespace.
331 *
332 * @param $code string
333 *
334 * @return bool
335 */
340 }
341 // People think language codes are html safe, so enforce it.
342 // Ideally we should only allow a-zA-Z0-9-
343 // but, .+ and other chars are often used for {{int:}} hacks
344 // see bugs 37564, 37587, 36938
350 }
352 /**
353 * Returns true if a language code is of a valid form for the purposes of
354 * internal customisation of MediaWiki, via Messages*.php.
355 *
356 * @param $code string
357 *
358 * @throws MWException
359 * @since 1.18
360 * @return bool
361 */
369 }
372 }
375 }
377 /**
378 * Returns true if a language code is an IETF tag known to MediaWiki.
379 *
380 * @param $code string
381 *
382 * @since 1.21
383 * @return bool
384 */
388 // Quick escape for invalid input to avoid exceptions down the line
389 // when code tries to process tags which are not valid at all.
392 }
396 }
400 ) {
402 }
405 }
407 /**
408 * @param $code
409 * @return String Name of the language class
410 */
416 }
417 }
419 /**
420 * Includes language class files
421 *
422 * @param $class string Name of the language class
423 */
429 }
433 }
434 }
436 /**
437 * Get the LocalisationCache instance
438 *
439 * @return LocalisationCache
440 */
446 }
448 }
452 // Set the code to the name of the descendant
457 }
459 }
461 /**
462 * Reduce memory usage
463 */
467 }
468 }
470 /**
471 * Hook which will be called if this is the content language.
472 * Descendants can use this to register hook functions or modify globals
473 */
476 /**
477 * Same as getFallbacksFor for current language.
478 * @return array|bool
479 * @deprecated in 1.19
480 */
484 }
486 /**
487 * @return array
488 * @since 1.19
489 */
492 }
494 /**
495 * Exports $wgBookstoreListEn
496 * @return array
497 */
500 }
502 /**
503 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
504 * available in localised form, it will be included in English.
505 *
506 * @return array
507 */
524 }
526 # Sometimes a language will be localised but not actually exist on this wiki.
530 }
531 }
533 # The above mixing may leave namespaces out of canonical order.
534 # Re-order by namespace ID number...
538 }
540 }
542 /**
543 * Arbitrarily set all of the namespace names at once. Mainly used for testing
544 * @param $namespaces Array of namespaces (id => name)
545 */
549 }
551 /**
552 * Resets all of the namespace caches. Mainly used for testing
553 */
558 }
560 /**
561 * A convenience function that returns the same thing as
562 * getNamespaces() except with the array values changed to ' '
563 * where it found '_', useful for producing output to be displayed
564 * e.g. in <select> forms.
565 *
566 * @return array
567 */
572 }
574 }
576 /**
577 * Get a namespace value by key
578 * <code>
579 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
580 * echo $mw_ns; // prints 'MediaWiki'
581 * </code>
582 *
583 * @param $index Int: the array key of the namespace to return
584 * @return mixed, string if the namespace value exists, otherwise false
585 */
589 }
591 /**
592 * A convenience function that returns the same thing as
593 * getNsText() except with '_' changed to ' ', useful for
594 * producing output.
595 *
596 * <code>
597 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
598 * echo $mw_ns; // prints 'MediaWiki talk'
599 * </code>
600 *
601 * @param int $index The array key of the namespace to return
602 * @return string Namespace name without underscores (empty string if namespace does not exist)
603 */
607 }
609 /**
610 * Returns gender-dependent namespace alias if available.
611 * @param $index Int: namespace index
612 * @param $gender String: gender key (male, female... )
613 * @return String
614 * @since 1.18
615 */
619 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
621 }
623 /**
624 * Whether this language makes distinguishes genders for example in
625 * namespaces.
626 * @return bool
627 * @since 1.18
628 */
632 // $wgExtraGenderNamespaces overrides everything
634 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
635 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
636 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
639 // Check what is in i18n files
642 }
643 }
645 /**
646 * Get a namespace key by value, case insensitive.
647 * Only matches namespace names for the current language, not the
648 * canonical ones defined in Namespace.php.
649 *
650 * @param $text String
651 * @return mixed An integer if $text is a valid value otherwise false
652 */
657 }
659 /**
660 * @return array
661 */
673 }
674 }
675 }
678 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
682 }
683 }
686 }
688 }
690 /**
691 * @return array
692 */
696 # Put namespace names and aliases into a hashtable.
697 # If this is too slow, then we should arrange it so that it is done
698 # before caching. The catch is that at pre-cache time, the above
699 # class-specific fixup hasn't been done.
703 }
706 }
710 }
711 }
712 }
714 }
716 /**
717 * Get a namespace key by value, case insensitive. Canonical namespace
718 * names override custom ones defined for the current language.
719 *
720 * @param $text String
721 * @return mixed An integer if $text is a valid value otherwise false
722 */
728 }
731 }
733 /**
734 * short names for language variants used for language conversion links.
735 *
736 * @param $code String
737 * @param $usemsg bool Use the "variantname-xyz" message if it exists
738 * @return string
739 */
744 }
749 # otherwise, output the language code
751 }
752 }
754 /**
755 * @param $name string
756 * @return string
757 */
762 }
764 }
766 /**
767 * @return array
768 */
771 }
773 /**
774 * @return array
775 */
778 }
780 /**
781 * @return array|string
782 */
790 }
791 }
793 /**
794 * @return array
795 */
798 }
800 /**
801 * @param $image
802 * @return array|null
803 */
806 }
808 /**
809 * @return array
810 */
813 }
815 /**
816 * @param $tog
817 * @return string
818 */
821 }
823 /**
824 * Get native language names, indexed by code.
825 * Only those defined in MediaWiki, no other data like CLDR.
826 * If $customisedOnly is true, only returns codes with a messages file
827 *
828 * @param $customisedOnly bool
829 *
830 * @return array
831 * @deprecated in 1.20, use fetchLanguageNames()
832 */
835 }
837 /**
838 * Get translated language names. This is done on best effort and
839 * by default this is exactly the same as Language::getLanguageNames.
840 * The CLDR extension provides translated names.
841 * @param $code String Language code.
842 * @return Array language code => language name
843 * @since 1.18.0
844 * @deprecated in 1.20, use fetchLanguageNames()
845 */
848 }
850 /**
851 * Get an array of language names, indexed by code.
852 * @param $inLanguage null|string: Code of language in which to return the names
853 * Use null for autonyms (native names)
854 * @param $include string:
855 * 'all' all available languages
856 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
857 * 'mwfile' only if the language is in 'mw' *and* has a message file
858 * @return array: language code => language name
859 * @since 1.20
860 */
867 }
872 # TODO: also include when $inLanguage is null, when this code is more efficient
874 }
878 # - Prefer own MediaWiki native name when not using the hook
879 # - For other names just add if not added through the hook
882 }
883 }
887 }
893 }
897 # We do this using a foreach over the codes instead of a directory
898 # loop so that messages files in extensions will work correctly.
902 }
903 }
905 }
906 # 'mw' option; default if it's not one of the other two options (all/mwfile)
908 }
910 /**
911 * @param $code string: The code of the language for which to get the name
912 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
913 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
914 * @return string: Language name or empty
915 * @since 1.20
916 */
920 }
922 /**
923 * Get a message from the MediaWiki namespace.
924 *
925 * @param $msg String: message name
926 * @return string
927 */
930 }
932 /**
933 * Get the native language name of $code.
934 * Only if defined in MediaWiki, no other data like CLDR.
935 * @param $code string
936 * @return string
937 * @deprecated in 1.20, use fetchLanguageName()
938 */
941 }
943 /**
944 * @param $key string
945 * @return string
946 */
949 }
951 /**
952 * @return array
953 */
958 }
960 }
962 /**
963 * @param $key string
964 * @return string
965 */
968 }
970 /**
971 * @param $key string
972 * @return string
973 */
976 }
978 /**
979 * @return array
980 */
985 }
987 }
989 /**
990 * @param $key string
991 * @return string
992 */
995 }
997 /**
998 * @param $key string
999 * @return string
1000 */
1003 }
1005 /**
1006 * @param $key string
1007 * @return string
1008 */
1011 }
1013 /**
1014 * @param $key string
1015 * @return string
1016 */
1019 }
1021 /**
1022 * @param $key string
1023 * @return string
1024 */
1027 }
1029 /**
1030 * @param $key string
1031 * @return string
1032 */
1035 }
1037 /**
1038 * This is a workalike of PHP's date() function, but with better
1039 * internationalisation, a reduced set of format characters, and a better
1040 * escaping format.
1041 *
1042 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1043 * the PHP manual for definitions. There are a number of extensions, which
1044 * start with "x":
1045 *
1046 * xn Do not translate digits of the next numeric format character
1047 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1048 * xr Use roman numerals for the next numeric format character
1049 * xh Use hebrew numerals for the next numeric format character
1050 * xx Literal x
1051 * xg Genitive month name
1052 *
1053 * xij j (day number) in Iranian calendar
1054 * xiF F (month name) in Iranian calendar
1055 * xin n (month number) in Iranian calendar
1056 * xiy y (two digit year) in Iranian calendar
1057 * xiY Y (full year) in Iranian calendar
1058 *
1059 * xjj j (day number) in Hebrew calendar
1060 * xjF F (month name) in Hebrew calendar
1061 * xjt t (days in month) in Hebrew calendar
1062 * xjx xg (genitive month name) in Hebrew calendar
1063 * xjn n (month number) in Hebrew calendar
1064 * xjY Y (full year) in Hebrew calendar
1065 *
1066 * xmj j (day number) in Hijri calendar
1067 * xmF F (month name) in Hijri calendar
1068 * xmn n (month number) in Hijri calendar
1069 * xmY Y (full year) in Hijri calendar
1070 *
1071 * xkY Y (full year) in Thai solar calendar. Months and days are
1072 * identical to the Gregorian calendar
1073 * xoY Y (full year) in Minguo calendar or Juche year.
1074 * Months and days are identical to the
1075 * Gregorian calendar
1076 * xtY Y (full year) in Japanese nengo. Months and days are
1077 * identical to the Gregorian calendar
1078 *
1079 * Characters enclosed in double quotes will be considered literal (with
1080 * the quotes themselves removed). Unmatched quotes will be considered
1081 * literal quotes. Example:
1082 *
1083 * "The month is" F => The month is January
1084 * i's" => 20'11"
1085 *
1086 * Backslash escaping is also supported.
1087 *
1088 * Input timestamp is assumed to be pre-normalized to the desired local
1089 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1090 * $ts is UTC if $zone is not given.
1091 *
1092 * @param $format String
1093 * @param $ts String: 14-character timestamp
1094 * YYYYMMDDHHMMSS
1095 * 01234567890123
1096 * @param $zone DateTimeZone: Timezone of $ts
1097 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1098 *
1099 * @throws MWException
1100 * @return string
1101 */
1118 }
1122 }
1129 }
1131 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1133 }
1157 }
1167 );
1168 }
1177 }
1183 }
1189 }
1196 );
1197 }
1206 }
1212 }
1218 }
1233 }
1239 }
1245 }
1251 }
1260 }
1266 }
1272 }
1278 }
1284 }
1290 }
1299 }
1334 // Pass through string from $dateTimeObj->format()
1338 );
1339 }
1352 // Pass through number from $dateTimeObj->format()
1356 );
1357 }
1361 # Backslash escaping
1366 }
1369 # Quoted literal
1373 # No terminating quote, assume literal "
1378 }
1380 # Quote at end of string, assume literal "
1382 }
1386 }
1399 }
1400 }
1401 }
1403 }
1408 /**
1409 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1410 * Gregorian dates to Iranian dates. Originally written in C, it
1411 * is released under the terms of GNU Lesser General Public
1412 * License. Conversion to PHP was performed by Niklas Laxström.
1413 *
1414 * Link: http://www.farsiweb.info/jalali/jalali.c
1415 *
1416 * @param $ts string
1417 *
1418 * @return string
1419 */
1425 # Days passed from the beginning (including leap years)
1431 // Add days of the past months of this year
1434 }
1436 // Leap years
1439 }
1441 // Days passed in current month
1455 }
1459 }
1465 }
1467 /**
1468 * Converting Gregorian dates to Hijri dates.
1469 *
1470 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1471 *
1472 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1473 *
1474 * @param $ts string
1475 *
1476 * @return string
1477 */
1491 )
1492 {
1500 }
1505 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1506 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1512 }
1514 /**
1515 * Converting Gregorian dates to Hebrew dates.
1516 *
1517 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1518 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1519 * to translate the relevant functions into PHP and release them under
1520 * GNU GPL.
1521 *
1522 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1523 * and Adar II is 14. In a non-leap year, Adar is 6.
1524 *
1525 * @param $ts string
1526 *
1527 * @return string
1528 */
1530 # Parse date
1535 # Calculate Hebrew year
1538 # Month number when September = 1, August = 12
1541 # Next year
1545 }
1547 # Calculate day of year from 1 September
1551 # February
1553 # Check if the year is leap
1556 }
1561 }
1562 }
1564 # Calculate the start of the Hebrew year
1567 # Calculate next year's start
1569 # Day is before the start of the year - it is the previous year
1570 # Next year's start
1572 # Previous year
1575 # Add days since previous year's 1 September
1578 # Leap year
1580 }
1581 # Start of the new (previous) year
1584 # Next year's start
1586 }
1588 # Calculate Hebrew day of year
1591 # Difference between year's days
1593 # Add 12 (or 13 for leap years) days to ignore the difference between
1594 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1595 # difference is only about the year type
1600 }
1602 # Check the year pattern, and is leap year
1603 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1604 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1605 # and non-leap years
1607 # Check if leap year
1610 # Calculate day in the month from number of day in the Hebrew year
1611 # Don't check Adar - if the day is not in Adar, we will stop before;
1612 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1617 # Calculate days in this month
1619 # Adar in a leap year
1621 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1624 # Day in Adar I
1627 # Subtract the days of Adar I
1629 # Try Adar II
1632 # Day in Adar II
1634 }
1635 }
1636 }
1638 # Cheshvan in a complete year (otherwise as the rule below)
1641 # Kislev in an incomplete year (otherwise as the rule below)
1644 # Odd months have 30 days, even have 29
1646 }
1648 # In the current month
1651 # Subtract the days of the current month
1653 # Try in the next month
1655 }
1656 }
1659 }
1661 /**
1662 * This calculates the Hebrew year start, as days since 1 September.
1663 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1664 * Used for Hebrew date.
1665 *
1666 * @param $year int
1667 *
1668 * @return string
1669 */
1676 }
1680 }
1690 }
1694 }
1696 /**
1697 * Algorithm to convert Gregorian dates to Thai solar dates,
1698 * Minguo dates or Minguo dates.
1699 *
1700 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1701 * http://en.wikipedia.org/wiki/Minguo_calendar
1702 * http://en.wikipedia.org/wiki/Japanese_era_name
1703 *
1704 * @param $ts String: 14-character timestamp
1705 * @param $cName String: calender name
1706 * @return Array: converted year, month, day
1707 */
1714 # Thai solar dates
1715 # Add 543 years to the Gregorian calendar
1716 # Months and days are identical
1719 # Minguo dates
1720 # Deduct 1911 years from the Gregorian calendar
1721 # Months and days are identical
1724 # Nengō dates up to Meiji period
1725 # Deduct years from the Gregorian calendar
1726 # depending on the nengo periods
1727 # Months and days are identical
1728 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1729 # Meiji period
1734 }
1742 )
1743 {
1744 # Taishō period
1749 }
1755 )
1756 {
1757 # Shōwa period
1762 }
1765 # Heisei period
1770 }
1772 }
1775 }
1778 }
1780 /**
1781 * Roman number formatting up to 10000
1782 *
1783 * @param $num int
1784 *
1785 * @return string
1786 */
1792 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1793 );
1798 }
1804 }
1806 }
1808 }
1810 /**
1811 * Hebrew Gematria number formatting up to 9999
1812 *
1813 * @param $num int
1814 *
1815 * @return string
1816 */
1823 );
1828 }
1840 }
1841 }
1842 }
1844 }
1850 }
1869 }
1871 }
1873 /**
1874 * Used by date() and time() to adjust the time output.
1875 *
1876 * @param $ts Int the time in date('YmdHis') format
1877 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1878 * get user timecorrection setting)
1879 * @return int
1880 */
1886 }
1899 }
1900 # Unrecognized timezone, default to 'Offset' with the stored offset.
1902 }
1906 # Global offset in minutes.
1909 }
1920 }
1923 }
1924 }
1926 # No difference ? Return time unchanged
1929 }
1932 # Generate an adjusted date; take advantage of the fact that mktime
1933 # will normalize out-of-range values so we don't have to split $minDiff
1934 # into hours and minutes.
1947 }
1949 /**
1950 * This is meant to be used by time(), date(), and timeanddate() to get
1951 * the date preference they're supposed to use, it should be used in
1952 * all children.
1953 *
1954 *<code>
1955 * function timeanddate([...], $format = true) {
1956 * $datePreference = $this->dateFormat($format);
1957 * [...]
1958 * }
1959 *</code>
1960 *
1961 * @param $usePrefs Mixed: if true, the user's preference is used
1962 * if false, the site/language default is used
1963 * if int/string, assumed to be a format.
1964 * @return string
1965 */
1974 }
1977 }
1979 // return int
1982 }
1985 }
1987 /**
1988 * Get a format string for a given type and preference
1989 * @param $type string May be date, time or both
1990 * @param $pref string The format name as it appears in Messages*.php
1991 *
1992 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
1993 *
1994 * @return string
1995 */
2006 }
2011 }
2012 }
2014 }
2016 }
2018 /**
2019 * @param $ts Mixed: the time format which needs to be turned into a
2020 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2021 * @param $adj Bool: whether to adjust the time output according to the
2022 * user configured offset ($timecorrection)
2023 * @param $format Mixed: true to use user's date format preference
2024 * @param $timecorrection String|bool the time offset as returned by
2025 * validateTimeZone() in Special:Preferences
2026 * @return string
2027 */
2032 }
2035 }
2037 /**
2038 * @param $ts Mixed: the time format which needs to be turned into a
2039 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2040 * @param $adj Bool: whether to adjust the time output according to the
2041 * user configured offset ($timecorrection)
2042 * @param $format Mixed: true to use user's date format preference
2043 * @param $timecorrection String|bool the time offset as returned by
2044 * validateTimeZone() in Special:Preferences
2045 * @return string
2046 */
2051 }
2054 }
2056 /**
2057 * @param $ts Mixed: the time format which needs to be turned into a
2058 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2059 * @param $adj Bool: whether to adjust the time output according to the
2060 * user configured offset ($timecorrection)
2061 * @param $format Mixed: what format to return, if it's false output the
2062 * default one (default true)
2063 * @param $timecorrection String|bool the time offset as returned by
2064 * validateTimeZone() in Special:Preferences
2065 * @return string
2066 */
2071 }
2074 }
2076 /**
2077 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2078 *
2079 * @since 1.20
2080 *
2081 * @param integer $seconds The amount of seconds.
2082 * @param array $chosenIntervals The intervals to enable.
2083 *
2084 * @return string
2085 */
2094 }
2097 }
2099 /**
2100 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2101 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2102 *
2103 * @since 1.20
2104 *
2105 * @param integer $seconds The amount of seconds.
2106 * @param array $chosenIntervals The intervals to enable.
2107 *
2108 * @return array
2109 */
2112 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2113 }
2127 }
2128 }
2131 }
2133 /**
2134 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2135 *
2136 * @param $type String: can be 'date', 'time' or 'both'
2137 * @param $ts Mixed: the time format which needs to be turned into a
2138 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2139 * @param $user User object used to get preferences for timezone and format
2140 * @param $options Array, can contain the following keys:
2141 * - 'timecorrection': time correction, can have the following values:
2142 * - true: use user's preference
2143 * - false: don't use time correction
2144 * - integer: value of time correction in minutes
2145 * - 'format': format to use, can have the following values:
2146 * - true: use user's preference
2147 * - false: use default preference
2148 * - string: format to use
2149 * @since 1.19
2150 * @return String
2151 */
2160 }
2162 }
2167 }
2170 }
2172 /**
2173 * Get the formatted date for the given timestamp and formatted for
2174 * the given user.
2175 *
2176 * @param $ts Mixed: the time format which needs to be turned into a
2177 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2178 * @param $user User object used to get preferences for timezone and format
2179 * @param $options Array, can contain the following keys:
2180 * - 'timecorrection': time correction, can have the following values:
2181 * - true: use user's preference
2182 * - false: don't use time correction
2183 * - integer: value of time correction in minutes
2184 * - 'format': format to use, can have the following values:
2185 * - true: use user's preference
2186 * - false: use default preference
2187 * - string: format to use
2188 * @since 1.19
2189 * @return String
2190 */
2193 }
2195 /**
2196 * Get the formatted time for the given timestamp and formatted for
2197 * the given user.
2198 *
2199 * @param $ts Mixed: the time format which needs to be turned into a
2200 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2201 * @param $user User object used to get preferences for timezone and format
2202 * @param $options Array, can contain the following keys:
2203 * - 'timecorrection': time correction, can have the following values:
2204 * - true: use user's preference
2205 * - false: don't use time correction
2206 * - integer: value of time correction in minutes
2207 * - 'format': format to use, can have the following values:
2208 * - true: use user's preference
2209 * - false: use default preference
2210 * - string: format to use
2211 * @since 1.19
2212 * @return String
2213 */
2216 }
2218 /**
2219 * Get the formatted date and time for the given timestamp and formatted for
2220 * the given user.
2221 *
2222 * @param $ts Mixed: the time format which needs to be turned into a
2223 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2224 * @param $user User object used to get preferences for timezone and format
2225 * @param $options Array, can contain the following keys:
2226 * - 'timecorrection': time correction, can have the following values:
2227 * - true: use user's preference
2228 * - false: don't use time correction
2229 * - integer: value of time correction in minutes
2230 * - 'format': format to use, can have the following values:
2231 * - true: use user's preference
2232 * - false: use default preference
2233 * - string: format to use
2234 * @since 1.19
2235 * @return String
2236 */
2239 }
2241 /**
2242 * Convert an MWTimestamp into a pretty human-readable timestamp using
2243 * the given user preferences and relative base time.
2244 *
2245 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2246 * on your timestamp object, which will then call this function. Calling
2247 * this function directly will cause hooks to be skipped over.
2248 *
2249 * @see MWTimestamp::getHumanTimestamp
2250 * @param MWTimestamp $ts Timestamp to prettify
2251 * @param MWTimestamp $relativeTo Base timestamp
2252 * @param User $user User preferences to use
2253 * @return string Human timestamp
2254 * @since 1.22
2255 */
2258 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) - (int)$relativeTo->timestamp->format( 'w' ) );
2260 if ( $diff->invert || $days > 5 && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' ) ) {
2261 // Timestamps are in different years: use full timestamp
2262 // Also do full timestamp for future dates
2263 /**
2264 * @FIXME Add better handling of future timestamps.
2265 */
2269 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2273 // Timestamp within the past week: show the day of the week and time
2281 // Timestamp was yesterday: say 'yesterday' and the time.
2288 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2295 // From here on in, the timestamp was soon enough ago so that we can simply say
2296 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2298 // Less than 90 minutes, but more than an hour ago.
2301 // A few minutes ago.
2304 // Less than a minute, but more than 30 sec ago.
2307 // Less than 30 seconds ago.
2309 }
2312 }
2314 /**
2315 * @param $key string
2316 * @return array|null
2317 */
2320 }
2322 /**
2323 * @return array
2324 */
2327 }
2329 /**
2330 * @param $in
2331 * @param $out
2332 * @param $string
2333 * @return string
2334 */
2336 # This is a wrapper for iconv in all languages except esperanto,
2337 # which does some nasty x-conversions beforehand
2339 # Even with //IGNORE iconv can whine about illegal characters in
2340 # *input* string. We just ignore those too.
2341 # REF: http://bugs.php.net/bug.php?id=37166
2342 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2347 }
2349 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2351 /**
2352 * @param $matches array
2353 * @return mixed|string
2354 */
2357 }
2359 /**
2360 * @param $matches array
2361 * @return string
2362 */
2365 }
2367 /**
2368 * @param $matches array
2369 * @return string
2370 */
2374 }
2376 /**
2377 * @param $matches array
2378 * @return string
2379 */
2383 }
2385 /**
2386 * @param $matches array
2387 * @return string
2388 */
2391 }
2393 /**
2394 * @param $matches array
2395 * @return string
2396 */
2400 }
2402 /**
2403 * Make a string's first character uppercase
2404 *
2405 * @param $str string
2406 *
2407 * @return string
2408 */
2416 // fall back to more complex logic in case of multibyte strings
2418 }
2419 }
2421 /**
2422 * Convert a string to uppercase
2423 *
2424 * @param $str string
2425 * @param $first bool
2426 *
2427 * @return string
2428 */
2436 }
2439 }
2446 $str
2447 );
2450 }
2451 }
2452 }
2454 /**
2455 * @param $str string
2456 * @return mixed|string
2457 */
2469 }
2470 }
2472 /**
2473 * @param $str string
2474 * @param $first bool
2475 * @return mixed|string
2476 */
2484 }
2487 }
2494 $str
2495 );
2498 }
2499 }
2500 }
2502 /**
2503 * @param $str string
2504 * @return bool
2505 */
2508 }
2510 /**
2511 * @param $str string
2512 * @return mixed|string
2513 */
2518 // regexp to find first letter in each word (i.e. after each space)
2519 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2521 // function to use to capitalize a single char
2526 $str
2527 );
2532 $str
2533 );
2534 }
2537 }
2538 }
2540 /**
2541 * capitalize words at word breaks
2542 *
2543 * @param $str string
2544 * @return mixed
2545 */
2550 // since \b doesn't work for UTF-8, we explicitely define word break chars
2553 // find first letter after word break
2554 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2560 $str
2561 );
2566 $str
2567 );
2568 }
2573 $str
2574 );
2575 }
2576 }
2578 /**
2579 * Return a case-folded representation of $s
2580 *
2581 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2582 * and $s2 are the same except for the case of their characters. It is not
2583 * necessary for the value returned to make sense when displayed.
2584 *
2585 * Do *not* perform any other normalisation in this function. If a caller
2586 * uses this function when it should be using a more general normalisation
2587 * function, then fix the caller.
2588 *
2589 * @param $s string
2590 *
2591 * @return string
2592 */
2595 }
2597 /**
2598 * @param $s string
2599 * @return string
2600 */
2604 }
2607 }
2610 }
2612 /**
2613 * @return array
2614 */
2617 }
2619 /**
2620 * Most writing systems use whitespace to break up words.
2621 * Some languages such as Chinese don't conventionally do this,
2622 * which requires special handling when breaking up words for
2623 * searching etc.
2624 *
2625 * @return bool
2626 */
2629 }
2631 /**
2632 * Some languages such as Chinese require word segmentation,
2633 * Specify such segmentation when overridden in derived class.
2634 *
2635 * @param $string String
2636 * @return String
2637 */
2640 }
2642 /**
2643 * Some languages have special punctuation need to be normalized.
2644 * Make such changes here.
2645 *
2646 * @param $string String
2647 * @return String
2648 */
2651 }
2653 /**
2654 * convert double-width roman characters to single-width.
2655 * range: ff00-ff5f ~= 0020-007f
2656 *
2657 * @param $string string
2658 *
2659 * @return string
2660 */
2670 }
2674 }
2676 /**
2677 * @param $string string
2678 * @param $pattern string
2679 * @return string
2680 */
2685 }
2687 /**
2688 * @param $termsArray array
2689 * @return array
2690 */
2692 # some languages, e.g. Chinese, need to do a conversion
2693 # in order for search results to be displayed correctly
2695 }
2697 /**
2698 * Get the first character of a string.
2699 *
2700 * @param $s string
2701 * @return string
2702 */
2709 $matches
2710 );
2715 }
2717 // Break down Hangul syllables to grab the first jamo
2749 }
2752 }
2753 }
2756 # Some languages may have an alternate char encoding option
2757 # (Esperanto X-coding, Japanese furigana conversion, etc)
2758 # If this language is used as the primary content language,
2759 # an override to the defaults can be set here on startup.
2760 }
2762 /**
2763 * @param $s string
2764 * @return string
2765 */
2767 # For some languages we'll want to explicitly specify
2768 # which characters make it into the edit box raw
2769 # or are converted in some way or another.
2775 }
2776 }
2778 /**
2779 * @param $s string
2780 * @return string
2781 */
2783 # Take the previous into account.
2789 }
2794 }
2795 }
2797 /**
2798 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2799 * also cleans up certain backwards-compatible sequences, converting them
2800 * to the modern Unicode equivalent.
2801 *
2802 * This is language-specific for performance reasons only.
2803 *
2804 * @param $s string
2805 *
2806 * @return string
2807 */
2814 }
2817 }
2819 /**
2820 * Transform a string using serialized data stored in the given file (which
2821 * must be in the serialized subdirectory of $IP). The file contains pairs
2822 * mapping source characters to destination characters.
2823 *
2824 * The data is cached in process memory. This will go faster if you have the
2825 * FastStringSearch extension.
2826 *
2827 * @param $file string
2828 * @param $string string
2829 *
2830 * @throws MWException
2831 * @return string
2832 */
2838 }
2840 }
2842 }
2844 /**
2845 * For right-to-left language support
2846 *
2847 * @return bool
2848 */
2851 }
2853 /**
2854 * Return the correct HTML 'dir' attribute value for this language.
2855 * @return String
2856 */
2859 }
2861 /**
2862 * Return 'left' or 'right' as appropriate alignment for line-start
2863 * for this language's text direction.
2864 *
2865 * Should be equivalent to CSS3 'start' text-align value....
2866 *
2867 * @return String
2868 */
2871 }
2873 /**
2874 * Return 'right' or 'left' as appropriate alignment for line-end
2875 * for this language's text direction.
2876 *
2877 * Should be equivalent to CSS3 'end' text-align value....
2878 *
2879 * @return String
2880 */
2883 }
2885 /**
2886 * A hidden direction mark (LRM or RLM), depending on the language direction.
2887 * Unlike getDirMark(), this function returns the character as an HTML entity.
2888 * This function should be used when the output is guaranteed to be HTML,
2889 * because it makes the output HTML source code more readable. When
2890 * the output is plain text or can be escaped, getDirMark() should be used.
2891 *
2892 * @param $opposite Boolean Get the direction mark opposite to your language
2893 * @return string
2894 * @since 1.20
2895 */
2899 }
2901 }
2903 /**
2904 * A hidden direction mark (LRM or RLM), depending on the language direction.
2905 * This function produces them as invisible Unicode characters and
2906 * the output may be hard to read and debug, so it should only be used
2907 * when the output is plain text or can be escaped. When the output is
2908 * HTML, use getDirMarkEntity() instead.
2909 *
2910 * @param $opposite Boolean Get the direction mark opposite to your language
2911 * @return string
2912 */
2918 }
2920 }
2922 /**
2923 * @return array
2924 */
2927 }
2929 /**
2930 * An arrow, depending on the language direction.
2931 *
2932 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2933 * @return string
2934 */
2949 }
2950 }
2952 /**
2953 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2954 *
2955 * @return bool
2956 */
2959 }
2961 /**
2962 * Get all magic words from cache.
2963 * @return array
2964 */
2967 }
2969 /**
2970 * Run the LanguageGetMagic hook once.
2971 */
2975 }
2980 }
2982 /**
2983 * Fill a MagicWord object with data from here
2984 *
2985 * @param $mw
2986 */
2988 // Saves a function call
2991 }
2998 }
3005 }
3006 }
3008 /**
3009 * Add magic words to the extension array
3010 *
3011 * @param $newWords array
3012 */
3019 }
3020 }
3021 }
3023 /**
3024 * Get special page names, as an associative array
3025 * case folded alias => real name
3026 */
3028 // Cache aliases because it may be slow to load them
3030 // Initialise array
3035 }
3038 }
3040 /**
3041 * Italic is unsuitable for some languages
3042 *
3043 * @param $text String: the text to be emphasized.
3044 * @return string
3045 */
3048 }
3050 /**
3051 * Normally we output all numbers in plain en_US style, that is
3052 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3053 * point twohundredthirtyfive. However this is not suitable for all
3054 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
3055 * Icelandic just want to use commas instead of dots, and dots instead
3056 * of commas like "293.291,235".
3057 *
3058 * An example of this function being called:
3059 * <code>
3060 * wfMessage( 'message' )->numParams( $num )->text()
3061 * </code>
3062 *
3063 * See LanguageGu.php for the Gujarati implementation and
3064 * $separatorTransformTable on MessageIs.php for
3065 * the , => . and . => , implementation.
3066 *
3067 * @todo check if it's viable to use localeconv() for the decimal
3068 * separator thing.
3069 * @param $number Mixed: the string to be formatted, should be an integer
3070 * or a floating point number.
3071 * @param $nocommafy Bool: set to true for special numbers like dates
3072 * @return string
3073 */
3081 }
3082 }
3088 }
3089 }
3092 }
3094 /**
3095 * Front-end for non-commafied formatNum
3096 *
3097 * @param mixed $number the string to be formatted, should be an integer
3098 * or a floating point number.
3099 * @since 1.21
3100 * @return string
3101 */
3104 }
3106 /**
3107 * @param $number string
3108 * @return string
3109 */
3114 }
3119 }
3123 }
3125 /**
3126 * Adds commas to a given number
3127 * @since 1.19
3128 * @param $number mixed
3129 * @return string
3130 */
3135 }
3138 // default grouping is at thousands, use the same for ###,###,### pattern too.
3141 // Ref: http://cldr.unicode.org/translation/number-patterns
3144 // For negative numbers apply the algorithm like positive number and add sign.
3147 }
3155 // the string does not have any number part. Eg: .12345
3157 }
3165 }
3169 // use the last pattern for the rest of the number
3171 }
3174 }
3175 }
3177 }
3178 }
3180 /**
3181 * @return String
3182 */
3185 }
3187 /**
3188 * @return array
3189 */
3192 }
3194 /**
3195 * @return array
3196 */
3199 }
3201 /**
3202 * Take a list of strings and build a locale-friendly comma-separated
3203 * list, using the local comma-separator message.
3204 * The last two strings are chained with an "and".
3205 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3206 *
3207 * @param $l Array
3208 * @return string
3209 */
3214 }
3220 }
3221 }
3228 }
3229 }
3231 }
3233 /**
3234 * Take a list of strings and build a locale-friendly comma-separated
3235 * list, using the local comma-separator message.
3236 * @param $list array of strings to put in a comma list
3237 * @return string
3238 */
3242 $list
3243 );
3244 }
3246 /**
3247 * Take a list of strings and build a locale-friendly semicolon-separated
3248 * list, using the local semicolon-separator message.
3249 * @param $list array of strings to put in a semicolon list
3250 * @return string
3251 */
3255 $list
3256 );
3257 }
3259 /**
3260 * Same as commaList, but separate it with the pipe instead.
3261 * @param $list array of strings to put in a pipe list
3262 * @return string
3263 */
3267 $list
3268 );
3269 }
3271 /**
3272 * Truncate a string to a specified length in bytes, appending an optional
3273 * string (e.g. for ellipses)
3274 *
3275 * The database offers limited byte lengths for some columns in the database;
3276 * multi-byte character sets mean we need to ensure that only whole characters
3277 * are included, otherwise broken characters can be passed to the user
3278 *
3279 * If $length is negative, the string will be truncated from the beginning
3280 *
3281 * @param $string String to truncate
3282 * @param $length Int: maximum length (including ellipses)
3283 * @param $ellipsis String to append to the truncated text
3284 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3285 * $adjustLength was introduced in 1.18, before that behaved as if false.
3286 * @return string
3287 */
3289 # Use the localized ellipsis character
3292 }
3293 # Check if there is no need to truncate
3298 }
3300 # If ellipsis length is >= $length then we can't apply $adjustLength
3303 # Otherwise, truncate and add ellipsis...
3316 }
3317 }
3318 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3319 # This check is *not* redundant if $adjustLength, due to the single case where
3320 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3325 }
3326 }
3328 /**
3329 * Remove bytes that represent an incomplete Unicode character
3330 * at the end of string (e.g. bytes of the char are missing)
3331 *
3332 * @param $string String
3333 * @return string
3334 */
3340 # We got the first byte only of a multibyte char; remove it.
3345 ) {
3346 # We chopped in the middle of a character; remove it
3348 }
3349 }
3351 }
3353 /**
3354 * Remove bytes that represent an incomplete Unicode character
3355 * at the start of string (e.g. bytes of the char are missing)
3356 *
3357 * @param $string String
3358 * @return string
3359 */
3364 # We chopped in the middle of a character; remove the whole thing
3366 }
3367 }
3369 }
3371 /**
3372 * Truncate a string of valid HTML to a specified length in bytes,
3373 * appending an optional string (e.g. for ellipses), and return valid HTML
3374 *
3375 * This is only intended for styled/linked text, such as HTML with
3376 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3377 * Also, this will not detect things like "display:none" CSS.
3378 *
3379 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3380 *
3381 * @param string $text HTML string to truncate
3382 * @param int $length (zero/positive) Maximum length (including ellipses)
3383 * @param string $ellipsis String to append to the truncated text
3384 * @return string
3385 */
3387 # Use the localized ellipsis character
3390 }
3391 # Check if there is clearly no need to truncate
3396 }
3410 # Consider truncation once the display length has reached the maximim.
3411 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3412 # Check that we're not in the middle of a bracket/entity...
3416 # Save where we are; we will truncate here unless there turn out to
3417 # be so few remaining characters that truncation is not necessary.
3420 }
3422 # String in fact does need truncation, the truncation point was OK.
3427 }
3428 }
3431 }
3433 # Read the next char...
3451 }
3457 // Name found (e.g. "<a href=..."), add on tag attributes...
3459 }
3465 }
3468 // Save state without $ch. We want to *hit* the first
3469 // display char (to get tags) but not *use* it if truncating.
3471 }
3476 // Add the next $max display text chars after this in one swoop...
3481 }
3482 }
3483 }
3484 }
3485 // Close the last tag if left unclosed by bad HTML
3489 }
3491 }
3493 /**
3494 * truncateHtml() helper function
3495 * like strcspn() but adds the skipped chars to $ret
3496 *
3497 * @param $ret
3498 * @param $text
3499 * @param $search
3500 * @param $start
3501 * @param $len
3502 * @return int
3503 */
3509 }
3514 }
3516 }
3518 /**
3519 * truncateHtml() helper function
3520 * (a) push or pop $tag from $openTags as needed
3521 * (b) clear $tag value
3522 * @param &$tag string Current HTML tag name we are looking at
3523 * @param $tagType int (0-open tag, 1-close tag)
3524 * @param $lastCh string Character before the '>' that ended this tag
3525 * @param &$openTags array Open tag stack (not accounting for $tag)
3526 */
3535 }
3536 }
3538 }
3539 }
3541 /**
3542 * Grammatical transformations, needed for inflected languages
3543 * Invoked by putting {{grammar:case|word}} in a message
3544 *
3545 * @param $word string
3546 * @param $case string
3547 * @return string
3548 */
3553 }
3555 }
3556 /**
3557 * Get the grammar forms for the content language
3558 * @return array of grammar forms
3559 * @since 1.20
3560 */
3563 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3565 }
3567 }
3568 /**
3569 * Provides an alternative text depending on specified gender.
3570 * Usage {{gender:username|masculine|feminine|neutral}}.
3571 * username is optional, in which case the gender of current user is used,
3572 * but only in (some) interface messages; otherwise default gender is used.
3573 *
3574 * If no forms are given, an empty string is returned. If only one form is
3575 * given, it will be returned unconditionally. These details are implied by
3576 * the caller and cannot be overridden in subclasses.
3577 *
3578 * If more than one form is given, the default is to use the neutral one
3579 * if it is specified, and to use the masculine one otherwise. These
3580 * details can be overridden in subclasses.
3581 *
3582 * @param $gender string
3583 * @param $forms array
3584 *
3585 * @return string
3586 */
3590 }
3594 }
3597 }
3599 }
3601 /**
3602 * Plural form transformations, needed for some languages.
3603 * For example, there are 3 form of plural in Russian and Polish,
3604 * depending on "count mod 10". See [[w:Plural]]
3605 * For English it is pretty simple.
3606 *
3607 * Invoked by putting {{plural:count|wordform1|wordform2}}
3608 * or {{plural:count|wordform1|wordform2|wordform3}}
3609 *
3610 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3611 *
3612 * @param $count Integer: non-localized number
3613 * @param $forms Array: different plural forms
3614 * @return string Correct form of plural for $count in this language
3615 */
3617 // Handle explicit n=pluralform cases
3623 }
3625 }
3626 }
3631 }
3636 }
3638 /**
3639 * Checks that convertPlural was given an array and pads it to requested
3640 * amount of forms by copying the last one.
3641 *
3642 * @param $count Integer: How many forms should there be at least
3643 * @param $forms Array of forms given to convertPlural
3644 * @return array Padded array of forms or an exception if not an array
3645 */
3649 }
3651 }
3653 /**
3654 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3655 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3656 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3657 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3658 * match up with it.
3659 *
3660 * @param $str String: the validated block duration in English
3661 * @return string Somehow translated block duration
3662 * @see LanguageFi.php for example implementation
3663 */
3669 }
3670 }
3672 // Since usually only infinite or indefinite is only on list, so try
3673 // equivalents if still here.
3680 }
3681 }
3682 }
3684 // If all else fails, return a standard duration or timestamp description.
3689 // $time is relative to 0 so it's a duration length.
3693 // wfTimestamp() handles 0 as current time instead of epoch.
3697 }
3698 }
3699 }
3701 /**
3702 * languages like Chinese need to be segmented in order for the diff
3703 * to be of any use
3704 *
3705 * @param $text String
3706 * @return String
3707 */
3710 }
3712 /**
3713 * and unsegment to show the result
3714 *
3715 * @param $text String
3716 * @return String
3717 */
3720 }
3722 /**
3723 * Return the LanguageConverter used in the Language
3724 *
3725 * @since 1.19
3726 * @return LanguageConverter
3727 */
3730 }
3732 /**
3733 * convert text to all supported variants
3734 *
3735 * @param $text string
3736 * @return array
3737 */
3740 }
3742 /**
3743 * convert text to different variants of a language.
3744 *
3745 * @param $text string
3746 * @return string
3747 */
3750 }
3752 /**
3753 * Convert a Title object to a string in the preferred variant
3754 *
3755 * @param $title Title
3756 * @return string
3757 */
3760 }
3762 /**
3763 * Convert a namespace index to a string in the preferred variant
3764 *
3765 * @param $ns int
3766 * @return string
3767 */
3770 }
3772 /**
3773 * Check if this is a language with variants
3774 *
3775 * @return bool
3776 */
3779 }
3781 /**
3782 * Check if the language has the specific variant
3783 *
3784 * @since 1.19
3785 * @param $variant string
3786 * @return bool
3787 */
3790 }
3792 /**
3793 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3794 *
3795 * @param $text string
3796 * @return string
3797 */
3800 }
3802 /**
3803 * Perform output conversion on a string, and encode for safe HTML output.
3804 * @param $text String text to be converted
3805 * @param $isTitle Bool whether this conversion is for the article title
3806 * @return string
3807 * @todo this should get integrated somewhere sane
3808 */
3811 }
3813 /**
3814 * @param $key string
3815 * @return string
3816 */
3819 }
3821 /**
3822 * Get the list of variants supported by this language
3823 * see sample implementation in LanguageZh.php
3824 *
3825 * @return array an array of language codes
3826 */
3829 }
3831 /**
3832 * @return string
3833 */
3836 }
3838 /**
3839 * @return string
3840 */
3843 }
3845 /**
3846 * @return string
3847 */
3850 }
3852 /**
3853 * If a language supports multiple variants, it is
3854 * possible that non-existing link in one variant
3855 * actually exists in another variant. this function
3856 * tries to find it. See e.g. LanguageZh.php
3857 *
3858 * @param $link String: the name of the link
3859 * @param $nt Mixed: the title object of the link
3860 * @param $ignoreOtherCond Boolean: to disable other conditions when
3861 * we need to transclude a template or update a category's link
3862 * @return null the input parameters may be modified upon return
3863 */
3866 }
3868 /**
3869 * If a language supports multiple variants, converts text
3870 * into an array of all possible variants of the text:
3871 * 'variant' => text in that variant
3872 *
3873 * @deprecated since 1.17 Use autoConvertToAllVariants()
3874 *
3875 * @param $text string
3876 *
3877 * @return string
3878 */
3881 }
3883 /**
3884 * returns language specific options used by User::getPageRenderHash()
3885 * for example, the preferred language variant
3886 *
3887 * @return string
3888 */
3891 }
3893 /**
3894 * For languages that support multiple variants, the title of an
3895 * article may be displayed differently in different variants. this
3896 * function returns the apporiate title defined in the body of the article.
3897 *
3898 * @return string
3899 */
3902 }
3904 /**
3905 * Prepare external link text for conversion. When the text is
3906 * a URL, it shouldn't be converted, and it'll be wrapped in
3907 * the "raw" tag (-{R| }-) to prevent conversion.
3908 *
3909 * This function is called "markNoConversion" for historical
3910 * reasons.
3911 *
3912 * @param $text String: text to be used for external link
3913 * @param $noParse bool: wrap it without confirming it's a real URL first
3914 * @return string the tagged text
3915 */
3917 // Excluding protocal-relative URLs may avoid many false positives.
3922 }
3923 }
3925 /**
3926 * A regular expression to match legal word-trailing characters
3927 * which should be merged onto a link of the form [[foo]]bar.
3928 *
3929 * @return string
3930 */
3933 }
3935 /**
3936 * @return Language
3937 */
3940 }
3942 /**
3943 * Get the "parent" language which has a converter to convert a "compatible" language
3944 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
3945 *
3946 * @return Language|null
3947 * @since 1.22
3948 */
3952 }
3959 }
3964 }
3968 }
3970 /**
3971 * Get the RFC 3066 code for this language object
3972 *
3973 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3974 * htmlspecialchars() or similar
3975 *
3976 * @return string
3977 */
3980 }
3982 /**
3983 * Get the code in Bcp47 format which we can use
3984 * inside of html lang="" tags.
3985 *
3986 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3987 * htmlspecialchars() or similar.
3988 *
3989 * @since 1.19
3990 * @return string
3991 */
3995 }
3997 }
3999 /**
4000 * @param $code string
4001 */
4004 // Ensure we don't leave incorrect cached data lying around
4007 }
4009 /**
4010 * Get the name of a file for a certain language code
4011 * @param $prefix string Prepend this to the filename
4012 * @param $code string Language code
4013 * @param $suffix string Append this to the filename
4014 * @throws MWException
4015 * @return string $prefix . $mangledCode . $suffix
4016 */
4018 // Protect against path traversal
4021 {
4023 }
4026 }
4028 /**
4029 * Get the language code from a file name. Inverse of getFileName()
4030 * @param $filename string $prefix . $languageCode . $suffix
4031 * @param $prefix string Prefix before the language code
4032 * @param $suffix string Suffix after the language code
4033 * @return string Language code, or false if $prefix or $suffix isn't found
4034 */
4035 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4041 }
4043 }
4045 /**
4046 * @param $code string
4047 * @return string
4048 */
4054 }
4056 /**
4057 * @param $code string
4058 * @return string
4059 */
4063 }
4065 /**
4066 * Get the first fallback for a given language.
4067 *
4068 * @param $code string
4069 *
4070 * @return bool|string
4071 */
4079 }
4080 }
4082 /**
4083 * Get the ordered list of fallback languages.
4084 *
4085 * @since 1.19
4086 * @param $code string Language code
4087 * @return array
4088 */
4097 }
4099 }
4100 }
4102 /**
4103 * Get the ordered list of fallback languages, ending with the fallback
4104 * language chain for the site language.
4105 *
4106 * @since 1.22
4107 * @param string $code Language code
4108 * @return array array( fallbacks, site fallbacks )
4109 */
4113 // Usually, we will only store a tiny number of fallback chains, so we
4114 // keep them in static memory.
4120 // Append the site's fallback chain, including the site language itself
4124 // Eliminate any languages already included in the chain
4128 }
4130 }
4132 /**
4133 * Get all messages for a given language
4134 * WARNING: this may take a long time. If you just need all message *keys*
4135 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4136 *
4137 * @param $code string
4138 *
4139 * @return array
4140 */
4143 }
4145 /**
4146 * Get a message for a given language
4147 *
4148 * @param $key string
4149 * @param $code string
4150 *
4151 * @return string
4152 */
4155 }
4157 /**
4158 * Get all message keys for a given language. This is a faster alternative to
4159 * array_keys( Language::getMessagesFor( $code ) )
4160 *
4161 * @since 1.19
4162 * @param $code string Language code
4163 * @return array of message keys (strings)
4164 */
4167 }
4169 /**
4170 * @param $talk
4171 * @return mixed
4172 */
4176 }
4181 # Allow grammar transformations
4182 # Allowing full message-style parsing would make simple requests
4183 # such as action=raw much more expensive than they need to be.
4184 # This will hopefully cover most cases.
4188 }
4190 /**
4191 * @param $m string
4192 * @return string
4193 */
4196 }
4198 /**
4199 * @throws MWException
4200 * @return array
4201 */
4206 }
4213 }
4218 }
4220 /**
4221 * Decode an expiry (block, protection, etc) which has come from the DB
4222 *
4223 * @todo FIXME: why are we returnings DBMS-dependent strings???
4224 *
4225 * @param $expiry String: Database expiry String
4226 * @param $format Bool|Int true to process using language functions, or TS_ constant
4227 * to return the expiry in a given timestamp
4228 * @return String
4229 * @since 1.18
4230 */
4235 }
4245 }
4246 }
4248 /**
4249 * @todo Document
4250 * @param $seconds int|float
4251 * @param $format Array Optional
4252 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4253 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4254 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4255 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4256 * @return string
4257 */
4261 }
4264 }
4267 }
4289 }
4300 }
4304 }
4310 }
4318 }
4328 }
4332 }
4342 }
4343 }
4345 }
4347 /**
4348 * Format a bitrate for output, using an appropriate
4349 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4350 *
4351 * This use base 1000. For base 1024 use formatSize(), for another base
4352 * see formatComputingNumbers()
4353 *
4354 * @param $bps int
4355 * @return string
4356 */
4359 }
4361 /**
4362 * @param $size int Size of the unit
4363 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4364 * @param $messageKey string Message key to be uesd
4365 * @return string
4366 */
4371 );
4372 }
4380 }
4382 // For small sizes no decimal places necessary
4385 // For MB and bigger two decimal places are smarter
4387 }
4393 }
4395 /**
4396 * Format a size in bytes for output, using an appropriate
4397 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4398 *
4399 * This method use base 1024. For base 1000 use formatBitrate(), for
4400 * another base see formatComputingNumbers()
4401 *
4402 * @param $size int Size to format
4403 * @return string Plain text (not HTML)
4404 */
4407 }
4409 /**
4410 * Make a list item, used by various special pages
4411 *
4412 * @param $page String Page link
4413 * @param $details String Text between brackets
4414 * @param $oppositedm Boolean Add the direction mark opposite to your
4415 * language, to display text properly
4416 * @return String
4417 */
4424 }
4426 /**
4427 * Generate (prev x| next x) (20|50|100...) type links for paging
4428 *
4429 * @param $title Title object to link
4430 * @param $offset Integer offset parameter
4431 * @param $limit Integer limit parameter
4432 * @param $query array|String optional URL query parameter string
4433 * @param $atend Bool optional param for specified if this is the last page
4434 * @return String
4435 */
4436 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4437 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4439 # Make 'previous' link
4440 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4446 }
4448 # Make 'next' link
4449 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4455 }
4457 # Make links to set number of items per page
4462 }
4466 }
4468 /**
4469 * Helper function for viewPrevNext() that generates links
4470 *
4471 * @param $title Title object to link
4472 * @param $offset Integer offset parameter
4473 * @param $limit Integer limit parameter
4474 * @param $query Array extra query parameters
4475 * @param $link String text to use for the link; will be escaped
4476 * @param $tooltipMsg String name of the message to use as tooltip
4477 * @param $class String value of the "class" attribute of the link
4478 * @return String HTML fragment
4479 */
4480 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4482 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4485 }
4487 /**
4488 * Get the conversion rule title, if any.
4489 *
4490 * @return string
4491 */
4494 }
4496 /**
4497 * Get the compiled plural rules for the language
4498 * @since 1.20
4499 * @return array Associative array with plural form, and plural rule as key-value pairs
4500 */
4506 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4509 }
4510 }
4511 }
4513 }
4515 /**
4516 * Get the plural rules for the language
4517 * @since 1.20
4518 * @return array Associative array with plural form number and plural rule as key-value pairs
4519 */
4528 }
4529 }
4530 }
4532 }
4534 /**
4535 * Get the plural rule types for the language
4536 * @since 1.22
4537 * @return array Associative array with plural form number and plural rule type as key-value pairs
4538 */
4544 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4547 }
4548 }
4549 }
4551 }
4553 /**
4554 * Find the index number of the plural rule appropriate for the given number
4555 * @return int The index number of the plural rule
4556 */
4561 }
4563 /**
4564 * Find the plural rule type appropriate for the given number
4565 * For example, if the language is set to Arabic, getPluralType(5) should
4566 * return 'few'.
4567 * @since 1.22
4568 * @return string The name of the plural rule type, e.g. one, two, few, many
4569 */
4577 }
4578 }
4579 }