| blob | 964cd9f38481a2e42eb31989c02a6f189fca9a7e |
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 }
35 }
37 /**
38 * Internationalisation code
39 * @ingroup Language
40 */
42 /**
43 * @var LanguageConverter
44 */
56 /**
57 * ReplacementArray object caches
58 */
61 /**
62 * @var LocalisationCache
63 */
71 );
75 );
80 'december'
81 );
85 'december-gen'
86 );
90 );
97 );
105 );
113 );
120 );
122 /**
123 * @since 1.20
124 * @var array
125 */
136 );
138 /**
139 * Cache for language fallbacks.
140 * @see Language::getFallbacksIncludingSiteLanguage
141 * @since 1.21
142 * @var array
143 */
146 /**
147 * Get a cached or new language object for a given language code
148 * @param string $code
149 * @return Language
150 */
156 }
158 // get the language object to process
163 // merge the language object in to get it up front in the cache
165 // get rid of the oldest ones in case we have an overflow
169 }
171 /**
172 * Create a language object for a given language code
173 * @param string $code
174 * @throws MWException
175 * @return Language
176 */
178 // Protect against path traversal below
181 ) {
183 }
186 // It's not possible to customise this code with class files, so
187 // just return a Language object. This is to support uselang= hacks.
191 }
193 // Check if there is a language class for the code
199 }
201 // Keep trying the fallback list until we find an existing class
206 }
214 }
215 }
218 }
220 /**
221 * Checks whether any localisation is available for that language tag
222 * in MediaWiki (MessagesXx.php exists).
223 *
224 * @param string $code Language tag (in lower case)
225 * @return bool Whether language is supported
226 * @since 1.21
227 */
232 );
233 }
235 /**
236 * Returns true if a language code string is a well-formed language tag
237 * according to RFC 5646.
238 * This function only checks well-formedness; it doesn't check that
239 * language, script or variant codes actually exist in the repositories.
240 *
241 * Based on regexes by Mark Davis of the Unicode Consortium:
242 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
243 *
244 * @param string $code
245 * @param bool $lenient Whether to allow '_' as separator. The default is only '-'.
246 *
247 * @return bool
248 * @since 1.21
249 */
265 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
266 # Since these are limited, this is safe even later changes to the registry --
267 # the only oddity is that it might change the type of the tag, and thus
268 # the results from the capturing groups.
269 # http://www.iana.org/assignments/language-subtag-registry
287 # The final breakdown, with capturing groups for each of these components
288 # The variants, extensions, grandfathered, and private-use may have interior '-'
293 }
295 /**
296 * Returns true if a language code string is of a valid form, whether or
297 * not it exists. This includes codes which are used solely for
298 * customisation via the MediaWiki namespace.
299 *
300 * @param string $code
301 *
302 * @return bool
303 */
308 }
309 // People think language codes are html safe, so enforce it.
310 // Ideally we should only allow a-zA-Z0-9-
311 // but, .+ and other chars are often used for {{int:}} hacks
312 // see bugs 37564, 37587, 36938
318 }
320 /**
321 * Returns true if a language code is of a valid form for the purposes of
322 * internal customisation of MediaWiki, via Messages*.php or *.json.
323 *
324 * @param string $code
325 *
326 * @throws MWException
327 * @since 1.18
328 * @return bool
329 */
337 }
340 }
343 }
345 /**
346 * Returns true if a language code is an IETF tag known to MediaWiki.
347 *
348 * @param string $code
349 *
350 * @since 1.21
351 * @return bool
352 */
356 // Quick escape for invalid input to avoid exceptions down the line
357 // when code tries to process tags which are not valid at all.
360 }
365 }
369 ) {
371 }
374 }
376 /**
377 * @param string $code
378 * @return string Name of the language class
379 */
385 }
386 }
388 /**
389 * Includes language class files
390 *
391 * @param string $class Name of the language class
392 */
398 }
402 }
403 }
405 /**
406 * Get the LocalisationCache instance
407 *
408 * @return LocalisationCache
409 */
415 }
417 }
421 // Set the code to the name of the descendant
426 }
428 }
430 /**
431 * Reduce memory usage
432 */
436 }
437 }
439 /**
440 * Hook which will be called if this is the content language.
441 * Descendants can use this to register hook functions or modify globals
442 */
444 }
446 /**
447 * Same as getFallbacksFor for current language.
448 * @return array|bool
449 * @deprecated since 1.19
450 */
455 }
457 /**
458 * @return array
459 * @since 1.19
460 */
463 }
465 /**
466 * Exports $wgBookstoreListEn
467 * @return array
468 */
471 }
473 /**
474 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
475 * available in localised form, it will be included in English.
476 *
477 * @return array
478 */
495 }
497 # Sometimes a language will be localised but not actually exist on this wiki.
501 }
502 }
504 # The above mixing may leave namespaces out of canonical order.
505 # Re-order by namespace ID number...
509 }
512 }
514 /**
515 * Arbitrarily set all of the namespace names at once. Mainly used for testing
516 * @param array $namespaces Array of namespaces (id => name)
517 */
521 }
523 /**
524 * Resets all of the namespace caches. Mainly used for testing
525 */
530 }
532 /**
533 * A convenience function that returns the same thing as
534 * getNamespaces() except with the array values changed to ' '
535 * where it found '_', useful for producing output to be displayed
536 * e.g. in <select> forms.
537 *
538 * @return array
539 */
544 }
546 }
548 /**
549 * Get a namespace value by key
550 * <code>
551 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
552 * echo $mw_ns; // prints 'MediaWiki'
553 * </code>
554 *
555 * @param int $index The array key of the namespace to return
556 * @return string|bool String if the namespace value exists, otherwise false
557 */
562 }
564 /**
565 * A convenience function that returns the same thing as
566 * getNsText() except with '_' changed to ' ', useful for
567 * producing output.
568 *
569 * <code>
570 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
571 * echo $mw_ns; // prints 'MediaWiki talk'
572 * </code>
573 *
574 * @param int $index The array key of the namespace to return
575 * @return string Namespace name without underscores (empty string if namespace does not exist)
576 */
581 }
583 /**
584 * Returns gender-dependent namespace alias if available.
585 * See https://www.mediawiki.org/wiki/Manual:$wgExtraGenderNamespaces
586 * @param int $index Namespace index
587 * @param string $gender Gender key (male, female... )
588 * @return string
589 * @since 1.18
590 */
598 }
600 /**
601 * Whether this language uses gender-dependent namespace aliases.
602 * See https://www.mediawiki.org/wiki/Manual:$wgExtraGenderNamespaces
603 * @return bool
604 * @since 1.18
605 */
609 // $wgExtraGenderNamespaces overrides everything
611 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
612 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
613 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
616 // Check what is in i18n files
619 }
620 }
622 /**
623 * Get a namespace key by value, case insensitive.
624 * Only matches namespace names for the current language, not the
625 * canonical ones defined in Namespace.php.
626 *
627 * @param string $text
628 * @return int|bool An integer if $text is a valid value otherwise false
629 */
634 }
636 /**
637 * @return array
638 */
650 }
651 }
652 }
660 }
661 }
663 # Also add converted namespace names as aliases, to avoid confusion.
668 }
671 }
672 }
675 }
678 }
680 /**
681 * @return array
682 */
686 # Put namespace names and aliases into a hashtable.
687 # If this is too slow, then we should arrange it so that it is done
688 # before caching. The catch is that at pre-cache time, the above
689 # class-specific fixup hasn't been done.
693 }
696 }
700 }
701 }
702 }
704 }
706 /**
707 * Get a namespace key by value, case insensitive. Canonical namespace
708 * names override custom ones defined for the current language.
709 *
710 * @param string $text
711 * @return int|bool An integer if $text is a valid value otherwise false
712 */
718 }
721 }
723 /**
724 * short names for language variants used for language conversion links.
725 *
726 * @param string $code
727 * @param bool $usemsg Use the "variantname-xyz" message if it exists
728 * @return string
729 */
734 }
739 # otherwise, output the language code
741 }
742 }
744 /**
745 * @param string $name
746 * @return string
747 */
752 }
754 }
756 /**
757 * @return array
758 */
761 }
763 /**
764 * @return array
765 */
768 }
770 /**
771 * @return array|string
772 */
780 }
781 }
783 /**
784 * @return array
785 */
788 }
790 /**
791 * @param string $image
792 * @return array|null
793 */
796 }
798 /**
799 * @return array
800 */
803 }
805 /**
806 * @param string $tog
807 * @return string
808 */
811 }
813 /**
814 * Get native language names, indexed by code.
815 * Only those defined in MediaWiki, no other data like CLDR.
816 * If $customisedOnly is true, only returns codes with a messages file
817 *
818 * @param bool $customisedOnly
819 *
820 * @return array
821 * @deprecated since 1.20, use fetchLanguageNames()
822 */
825 }
827 /**
828 * Get translated language names. This is done on best effort and
829 * by default this is exactly the same as Language::getLanguageNames.
830 * The CLDR extension provides translated names.
831 * @param string $code Language code.
832 * @return array Language code => language name
833 * @since 1.18.0
834 * @deprecated since 1.20, use fetchLanguageNames()
835 */
838 }
840 /**
841 * Get an array of language names, indexed by code.
842 * @param null|string $inLanguage Code of language in which to return the names
843 * Use null for autonyms (native names)
844 * @param string $include One of:
845 * 'all' all available languages
846 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
847 * 'mwfile' only if the language is in 'mw' *and* has a message file
848 * @return array Language code => language name
849 * @since 1.20
850 */
858 }
863 # TODO: also include when $inLanguage is null, when this code is more efficient
865 }
869 # - Prefer own MediaWiki native name when not using the hook
870 # - For other names just add if not added through the hook
873 }
874 }
878 }
884 }
888 # We do this using a foreach over the codes instead of a directory
889 # loop so that messages files in extensions will work correctly.
893 ) {
895 }
896 }
899 }
901 # 'mw' option; default if it's not one of the other two options (all/mwfile)
903 }
905 /**
906 * @param string $code The code of the language for which to get the name
907 * @param null|string $inLanguage Code of language in which to return the name (null for autonyms)
908 * @param string $include 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
909 * @return string Language name or empty
910 * @since 1.20
911 */
916 }
918 /**
919 * Get a message from the MediaWiki namespace.
920 *
921 * @param string $msg Message name
922 * @return string
923 */
926 }
928 /**
929 * Get the native language name of $code.
930 * Only if defined in MediaWiki, no other data like CLDR.
931 * @param string $code
932 * @return string
933 * @deprecated since 1.20, use fetchLanguageName()
934 */
937 }
939 /**
940 * @param string $key
941 * @return string
942 */
945 }
947 /**
948 * @return array
949 */
954 }
956 }
958 /**
959 * @param string $key
960 * @return string
961 */
964 }
966 /**
967 * @param string $key
968 * @return string
969 */
972 }
974 /**
975 * @return array
976 */
981 }
983 }
985 /**
986 * @param string $key
987 * @return string
988 */
991 }
993 /**
994 * @param string $key
995 * @return string
996 */
999 }
1001 /**
1002 * @param string $key
1003 * @return string
1004 */
1007 }
1009 /**
1010 * @param string $key
1011 * @return string
1012 */
1015 }
1017 /**
1018 * @param string $key
1019 * @return string
1020 */
1023 }
1025 /**
1026 * @param string $key
1027 * @return string
1028 */
1031 }
1033 /**
1034 * This is a workalike of PHP's date() function, but with better
1035 * internationalisation, a reduced set of format characters, and a better
1036 * escaping format.
1037 *
1038 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1039 * the PHP manual for definitions. There are a number of extensions, which
1040 * start with "x":
1041 *
1042 * xn Do not translate digits of the next numeric format character
1043 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1044 * xr Use roman numerals for the next numeric format character
1045 * xh Use hebrew numerals for the next numeric format character
1046 * xx Literal x
1047 * xg Genitive month name
1048 *
1049 * xij j (day number) in Iranian calendar
1050 * xiF F (month name) in Iranian calendar
1051 * xin n (month number) in Iranian calendar
1052 * xiy y (two digit year) in Iranian calendar
1053 * xiY Y (full year) in Iranian calendar
1054 *
1055 * xjj j (day number) in Hebrew calendar
1056 * xjF F (month name) in Hebrew calendar
1057 * xjt t (days in month) in Hebrew calendar
1058 * xjx xg (genitive month name) in Hebrew calendar
1059 * xjn n (month number) in Hebrew calendar
1060 * xjY Y (full year) in Hebrew calendar
1061 *
1062 * xmj j (day number) in Hijri calendar
1063 * xmF F (month name) in Hijri calendar
1064 * xmn n (month number) in Hijri calendar
1065 * xmY Y (full year) in Hijri calendar
1066 *
1067 * xkY Y (full year) in Thai solar calendar. Months and days are
1068 * identical to the Gregorian calendar
1069 * xoY Y (full year) in Minguo calendar or Juche year.
1070 * Months and days are identical to the
1071 * Gregorian calendar
1072 * xtY Y (full year) in Japanese nengo. Months and days are
1073 * identical to the Gregorian calendar
1074 *
1075 * Characters enclosed in double quotes will be considered literal (with
1076 * the quotes themselves removed). Unmatched quotes will be considered
1077 * literal quotes. Example:
1078 *
1079 * "The month is" F => The month is January
1080 * i's" => 20'11"
1081 *
1082 * Backslash escaping is also supported.
1083 *
1084 * Input timestamp is assumed to be pre-normalized to the desired local
1085 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1086 * $ts is UTC if $zone is not given.
1087 *
1088 * @param string $format
1089 * @param string $ts 14-character timestamp
1090 * YYYYMMDDHHMMSS
1091 * 01234567890123
1092 * @param DateTimeZone $zone Timezone of $ts
1093 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1094 *
1095 * @throws MWException
1096 * @return string
1097 */
1114 }
1118 }
1126 }
1136 }
1160 }
1170 );
1171 }
1180 }
1186 }
1192 }
1199 );
1200 }
1209 }
1215 }
1221 }
1236 }
1242 }
1248 }
1254 }
1263 }
1269 }
1275 }
1281 }
1287 }
1293 }
1302 }
1337 // Pass through string from $dateTimeObj->format()
1341 );
1342 }
1355 // Pass through number from $dateTimeObj->format()
1359 );
1360 }
1364 # Backslash escaping
1369 }
1372 # Quoted literal
1376 # No terminating quote, assume literal "
1381 }
1383 # Quote at end of string, assume literal "
1385 }
1389 }
1402 }
1403 }
1404 }
1407 }
1412 /**
1413 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1414 * Gregorian dates to Iranian dates. Originally written in C, it
1415 * is released under the terms of GNU Lesser General Public
1416 * License. Conversion to PHP was performed by Niklas Laxström.
1417 *
1418 * Link: http://www.farsiweb.info/jalali/jalali.c
1419 *
1420 * @param string $ts
1421 *
1422 * @return string
1423 */
1429 # Days passed from the beginning (including leap years)
1435 // Add days of the past months of this year
1438 }
1440 // Leap years
1443 }
1445 // Days passed in current month
1459 }
1463 }
1469 }
1471 /**
1472 * Converting Gregorian dates to Hijri dates.
1473 *
1474 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1475 *
1476 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1477 *
1478 * @param string $ts
1479 *
1480 * @return string
1481 */
1495 ) {
1503 }
1517 }
1519 /**
1520 * Converting Gregorian dates to Hebrew dates.
1521 *
1522 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1523 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1524 * to translate the relevant functions into PHP and release them under
1525 * GNU GPL.
1526 *
1527 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1528 * and Adar II is 14. In a non-leap year, Adar is 6.
1529 *
1530 * @param string $ts
1531 *
1532 * @return string
1533 */
1535 # Parse date
1540 # Calculate Hebrew year
1543 # Month number when September = 1, August = 12
1546 # Next year
1550 }
1552 # Calculate day of year from 1 September
1556 # February
1558 # Check if the year is leap
1561 }
1566 }
1567 }
1569 # Calculate the start of the Hebrew year
1572 # Calculate next year's start
1574 # Day is before the start of the year - it is the previous year
1575 # Next year's start
1577 # Previous year
1580 # Add days since previous year's 1 September
1583 # Leap year
1585 }
1586 # Start of the new (previous) year
1589 # Next year's start
1591 }
1593 # Calculate Hebrew day of year
1596 # Difference between year's days
1598 # Add 12 (or 13 for leap years) days to ignore the difference between
1599 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1600 # difference is only about the year type
1605 }
1607 # Check the year pattern, and is leap year
1608 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1609 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1610 # and non-leap years
1612 # Check if leap year
1615 # Calculate day in the month from number of day in the Hebrew year
1616 # Don't check Adar - if the day is not in Adar, we will stop before;
1617 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1622 # Calculate days in this month
1624 # Adar in a leap year
1626 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1629 # Day in Adar I
1632 # Subtract the days of Adar I
1634 # Try Adar II
1637 # Day in Adar II
1639 }
1640 }
1641 }
1643 # Cheshvan in a complete year (otherwise as the rule below)
1646 # Kislev in an incomplete year (otherwise as the rule below)
1649 # Odd months have 30 days, even have 29
1651 }
1653 # In the current month
1656 # Subtract the days of the current month
1658 # Try in the next month
1660 }
1661 }
1664 }
1666 /**
1667 * This calculates the Hebrew year start, as days since 1 September.
1668 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1669 * Used for Hebrew date.
1670 *
1671 * @param int $year
1672 *
1673 * @return string
1674 */
1681 }
1685 }
1695 }
1699 }
1701 /**
1702 * Algorithm to convert Gregorian dates to Thai solar dates,
1703 * Minguo dates or Minguo dates.
1704 *
1705 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1706 * http://en.wikipedia.org/wiki/Minguo_calendar
1707 * http://en.wikipedia.org/wiki/Japanese_era_name
1708 *
1709 * @param string $ts 14-character timestamp
1710 * @param string $cName Calender name
1711 * @return array Converted year, month, day
1712 */
1719 # Thai solar dates
1720 # Add 543 years to the Gregorian calendar
1721 # Months and days are identical
1724 # Minguo dates
1725 # Deduct 1911 years from the Gregorian calendar
1726 # Months and days are identical
1729 # Nengō dates up to Meiji period
1730 # Deduct years from the Gregorian calendar
1731 # depending on the nengo periods
1732 # Months and days are identical
1736 ) {
1737 # Meiji period
1742 }
1750 ) {
1751 # Taishō period
1756 }
1762 ) {
1763 # Shōwa period
1768 }
1771 # Heisei period
1776 }
1778 }
1781 }
1784 }
1786 /**
1787 * Roman number formatting up to 10000
1788 *
1789 * @param int $num
1790 *
1791 * @return string
1792 */
1800 );
1805 }
1811 }
1813 }
1815 }
1817 /**
1818 * Hebrew Gematria number formatting up to 9999
1819 *
1820 * @param int $num
1821 *
1822 * @return string
1823 */
1830 );
1835 }
1847 }
1848 }
1849 }
1851 }
1857 }
1876 }
1878 }
1880 /**
1881 * Used by date() and time() to adjust the time output.
1882 *
1883 * @param int $ts The time in date('YmdHis') format
1884 * @param mixed $tz Adjust the time by this amount (default false, mean we
1885 * get user timecorrection setting)
1886 * @return int
1887 */
1893 }
1906 }
1907 # Unrecognized timezone, default to 'Offset' with the stored offset.
1909 }
1913 # Global offset in minutes.
1916 }
1927 }
1930 }
1931 }
1933 # No difference ? Return time unchanged
1936 }
1939 # Generate an adjusted date; take advantage of the fact that mktime
1940 # will normalize out-of-range values so we don't have to split $minDiff
1941 # into hours and minutes.
1954 }
1956 /**
1957 * This is meant to be used by time(), date(), and timeanddate() to get
1958 * the date preference they're supposed to use, it should be used in
1959 * all children.
1960 *
1961 *<code>
1962 * function timeanddate([...], $format = true) {
1963 * $datePreference = $this->dateFormat($format);
1964 * [...]
1965 * }
1966 *</code>
1967 *
1968 * @param int|string|bool $usePrefs If true, the user's preference is used
1969 * if false, the site/language default is used
1970 * if int/string, assumed to be a format.
1971 * @return string
1972 */
1981 }
1984 }
1986 // return int
1989 }
1992 }
1994 /**
1995 * Get a format string for a given type and preference
1996 * @param string $type May be date, time or both
1997 * @param string $pref The format name as it appears in Messages*.php
1998 *
1999 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2000 *
2001 * @return string
2002 */
2013 }
2018 }
2019 }
2021 }
2023 }
2025 /**
2026 * @param mixed $ts The time format which needs to be turned into a
2027 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2028 * @param bool $adj Whether to adjust the time output according to the
2029 * user configured offset ($timecorrection)
2030 * @param mixed $format True to use user's date format preference
2031 * @param string|bool $timecorrection The time offset as returned by
2032 * validateTimeZone() in Special:Preferences
2033 * @return string
2034 */
2039 }
2042 }
2044 /**
2045 * @param mixed $ts The time format which needs to be turned into a
2046 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2047 * @param bool $adj Whether to adjust the time output according to the
2048 * user configured offset ($timecorrection)
2049 * @param mixed $format True to use user's date format preference
2050 * @param string|bool $timecorrection The time offset as returned by
2051 * validateTimeZone() in Special:Preferences
2052 * @return string
2053 */
2058 }
2061 }
2063 /**
2064 * @param mixed $ts The time format which needs to be turned into a
2065 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2066 * @param bool $adj Whether to adjust the time output according to the
2067 * user configured offset ($timecorrection)
2068 * @param mixed $format What format to return, if it's false output the
2069 * default one (default true)
2070 * @param string|bool $timecorrection The time offset as returned by
2071 * validateTimeZone() in Special:Preferences
2072 * @return string
2073 */
2078 }
2081 }
2083 /**
2084 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2085 *
2086 * @since 1.20
2087 *
2088 * @param int $seconds The amount of seconds.
2089 * @param array $chosenIntervals The intervals to enable.
2090 *
2091 * @return string
2092 */
2099 // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2100 // duration-years, duration-decades, duration-centuries, duration-millennia
2103 }
2106 }
2108 /**
2109 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2110 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2111 *
2112 * @since 1.20
2113 *
2114 * @param int $seconds The amount of seconds.
2115 * @param array $chosenIntervals The intervals to enable.
2116 *
2117 * @return array
2118 */
2129 'seconds'
2130 );
2131 }
2145 }
2146 }
2149 }
2151 /**
2152 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2153 *
2154 * @param string $type Can be 'date', 'time' or 'both'
2155 * @param mixed $ts The time format which needs to be turned into a
2156 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2157 * @param User $user User object used to get preferences for timezone and format
2158 * @param array $options Array, can contain the following keys:
2159 * - 'timecorrection': time correction, can have the following values:
2160 * - true: use user's preference
2161 * - false: don't use time correction
2162 * - int: value of time correction in minutes
2163 * - 'format': format to use, can have the following values:
2164 * - true: use user's preference
2165 * - false: use default preference
2166 * - string: format to use
2167 * @since 1.19
2168 * @return string
2169 */
2178 }
2180 }
2185 }
2188 }
2190 /**
2191 * Get the formatted date for the given timestamp and formatted for
2192 * the given user.
2193 *
2194 * @param mixed $ts Mixed: the time format which needs to be turned into a
2195 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2196 * @param User $user User object used to get preferences for timezone and format
2197 * @param array $options Array, can contain the following keys:
2198 * - 'timecorrection': time correction, can have the following values:
2199 * - true: use user's preference
2200 * - false: don't use time correction
2201 * - int: value of time correction in minutes
2202 * - 'format': format to use, can have the following values:
2203 * - true: use user's preference
2204 * - false: use default preference
2205 * - string: format to use
2206 * @since 1.19
2207 * @return string
2208 */
2211 }
2213 /**
2214 * Get the formatted time for the given timestamp and formatted for
2215 * the given user.
2216 *
2217 * @param mixed $ts The time format which needs to be turned into a
2218 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2219 * @param User $user User object used to get preferences for timezone and format
2220 * @param array $options Array, can contain the following keys:
2221 * - 'timecorrection': time correction, can have the following values:
2222 * - true: use user's preference
2223 * - false: don't use time correction
2224 * - int: value of time correction in minutes
2225 * - 'format': format to use, can have the following values:
2226 * - true: use user's preference
2227 * - false: use default preference
2228 * - string: format to use
2229 * @since 1.19
2230 * @return string
2231 */
2234 }
2236 /**
2237 * Get the formatted date and time for the given timestamp and formatted for
2238 * the given user.
2239 *
2240 * @param mixed $ts the time format which needs to be turned into a
2241 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2242 * @param User $user User object used to get preferences for timezone and format
2243 * @param array $options Array, can contain the following keys:
2244 * - 'timecorrection': time correction, can have the following values:
2245 * - true: use user's preference
2246 * - false: don't use time correction
2247 * - int: value of time correction in minutes
2248 * - 'format': format to use, can have the following values:
2249 * - true: use user's preference
2250 * - false: use default preference
2251 * - string: format to use
2252 * @since 1.19
2253 * @return string
2254 */
2257 }
2259 /**
2260 * Convert an MWTimestamp into a pretty human-readable timestamp using
2261 * the given user preferences and relative base time.
2262 *
2263 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2264 * on your timestamp object, which will then call this function. Calling
2265 * this function directly will cause hooks to be skipped over.
2266 *
2267 * @see MWTimestamp::getHumanTimestamp
2268 * @param MWTimestamp $ts Timestamp to prettify
2269 * @param MWTimestamp $relativeTo Base timestamp
2270 * @param User $user User preferences to use
2271 * @return string Human timestamp
2272 * @since 1.22
2273 */
2281 ) {
2282 // Timestamps are in different years: use full timestamp
2283 // Also do full timestamp for future dates
2284 /**
2285 * @FIXME Add better handling of future timestamps.
2286 */
2290 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2294 // Timestamp within the past week: show the day of the week and time
2297 // Messages:
2298 // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2304 // Timestamp was yesterday: say 'yesterday' and the time.
2311 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2318 // From here on in, the timestamp was soon enough ago so that we can simply say
2319 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2321 // Less than 90 minutes, but more than an hour ago.
2324 // A few minutes ago.
2327 // Less than a minute, but more than 30 sec ago.
2330 // Less than 30 seconds ago.
2332 }
2335 }
2337 /**
2338 * @param string $key
2339 * @return array|null
2340 */
2343 }
2345 /**
2346 * @return array
2347 */
2350 }
2352 /**
2353 * @param string $in
2354 * @param string $out
2355 * @param string $string
2356 * @return string
2357 */
2359 # This is a wrapper for iconv in all languages except esperanto,
2360 # which does some nasty x-conversions beforehand
2362 # Even with //IGNORE iconv can whine about illegal characters in
2363 # *input* string. We just ignore those too.
2364 # REF: http://bugs.php.net/bug.php?id=37166
2365 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2370 }
2372 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2374 /**
2375 * @param array $matches
2376 * @return mixed|string
2377 */
2380 }
2382 /**
2383 * @param array $matches
2384 * @return string
2385 */
2388 }
2390 /**
2391 * @param array $matches
2392 * @return string
2393 */
2397 }
2399 /**
2400 * @param array $matches
2401 * @return string
2402 */
2406 }
2408 /**
2409 * @param array $matches
2410 * @return string
2411 */
2414 }
2416 /**
2417 * @param array $matches
2418 * @return string
2419 */
2423 }
2425 /**
2426 * Make a string's first character uppercase
2427 *
2428 * @param string $str
2429 *
2430 * @return string
2431 */
2439 // fall back to more complex logic in case of multibyte strings
2441 }
2442 }
2444 /**
2445 * Convert a string to uppercase
2446 *
2447 * @param string $str
2448 * @param bool $first
2449 *
2450 * @return string
2451 */
2459 }
2462 }
2469 $str
2470 );
2473 }
2474 }
2475 }
2477 /**
2478 * @param string $str
2479 * @return mixed|string
2480 */
2492 }
2493 }
2495 /**
2496 * @param string $str
2497 * @param bool $first
2498 * @return mixed|string
2499 */
2507 }
2510 }
2517 $str
2518 );
2521 }
2522 }
2523 }
2525 /**
2526 * @param string $str
2527 * @return bool
2528 */
2531 }
2533 /**
2534 * @param string $str
2535 * @return mixed|string
2536 */
2541 // regexp to find first letter in each word (i.e. after each space)
2542 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2544 // function to use to capitalize a single char
2549 $str
2550 );
2555 $str
2556 );
2557 }
2560 }
2561 }
2563 /**
2564 * capitalize words at word breaks
2565 *
2566 * @param string $str
2567 * @return mixed
2568 */
2573 // since \b doesn't work for UTF-8, we explicitely define word break chars
2576 // find first letter after word break
2584 $str
2585 );
2590 $str
2591 );
2592 }
2597 $str
2598 );
2599 }
2600 }
2602 /**
2603 * Return a case-folded representation of $s
2604 *
2605 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2606 * and $s2 are the same except for the case of their characters. It is not
2607 * necessary for the value returned to make sense when displayed.
2608 *
2609 * Do *not* perform any other normalisation in this function. If a caller
2610 * uses this function when it should be using a more general normalisation
2611 * function, then fix the caller.
2612 *
2613 * @param string $s
2614 *
2615 * @return string
2616 */
2619 }
2621 /**
2622 * @param string $s
2623 * @return string
2624 */
2628 }
2631 }
2634 }
2636 /**
2637 * @return array
2638 */
2641 }
2643 /**
2644 * Most writing systems use whitespace to break up words.
2645 * Some languages such as Chinese don't conventionally do this,
2646 * which requires special handling when breaking up words for
2647 * searching etc.
2648 *
2649 * @return bool
2650 */
2653 }
2655 /**
2656 * Some languages such as Chinese require word segmentation,
2657 * Specify such segmentation when overridden in derived class.
2658 *
2659 * @param string $string
2660 * @return string
2661 */
2664 }
2666 /**
2667 * Some languages have special punctuation need to be normalized.
2668 * Make such changes here.
2669 *
2670 * @param string $string
2671 * @return string
2672 */
2675 }
2677 /**
2678 * convert double-width roman characters to single-width.
2679 * range: ff00-ff5f ~= 0020-007f
2680 *
2681 * @param string $string
2682 *
2683 * @return string
2684 */
2694 }
2698 }
2700 /**
2701 * @param string $string
2702 * @param string $pattern
2703 * @return string
2704 */
2709 }
2711 /**
2712 * @param array $termsArray
2713 * @return array
2714 */
2716 # some languages, e.g. Chinese, need to do a conversion
2717 # in order for search results to be displayed correctly
2719 }
2721 /**
2722 * Get the first character of a string.
2723 *
2724 * @param string $s
2725 * @return string
2726 */
2733 $matches
2734 );
2739 }
2741 // Break down Hangul syllables to grab the first jamo
2773 }
2776 }
2777 }
2780 # Some languages may have an alternate char encoding option
2781 # (Esperanto X-coding, Japanese furigana conversion, etc)
2782 # If this language is used as the primary content language,
2783 # an override to the defaults can be set here on startup.
2784 }
2786 /**
2787 * @param string $s
2788 * @return string
2789 */
2791 # For some languages we'll want to explicitly specify
2792 # which characters make it into the edit box raw
2793 # or are converted in some way or another.
2799 }
2800 }
2802 /**
2803 * @param string $s
2804 * @return string
2805 */
2807 # Take the previous into account.
2813 }
2818 }
2819 }
2821 /**
2822 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2823 * also cleans up certain backwards-compatible sequences, converting them
2824 * to the modern Unicode equivalent.
2825 *
2826 * This is language-specific for performance reasons only.
2827 *
2828 * @param string $s
2829 *
2830 * @return string
2831 */
2838 }
2841 }
2843 /**
2844 * Transform a string using serialized data stored in the given file (which
2845 * must be in the serialized subdirectory of $IP). The file contains pairs
2846 * mapping source characters to destination characters.
2847 *
2848 * The data is cached in process memory. This will go faster if you have the
2849 * FastStringSearch extension.
2850 *
2851 * @param string $file
2852 * @param string $string
2853 *
2854 * @throws MWException
2855 * @return string
2856 */
2862 }
2864 }
2866 }
2868 /**
2869 * For right-to-left language support
2870 *
2871 * @return bool
2872 */
2875 }
2877 /**
2878 * Return the correct HTML 'dir' attribute value for this language.
2879 * @return string
2880 */
2883 }
2885 /**
2886 * Return 'left' or 'right' as appropriate alignment for line-start
2887 * for this language's text direction.
2888 *
2889 * Should be equivalent to CSS3 'start' text-align value....
2890 *
2891 * @return string
2892 */
2895 }
2897 /**
2898 * Return 'right' or 'left' as appropriate alignment for line-end
2899 * for this language's text direction.
2900 *
2901 * Should be equivalent to CSS3 'end' text-align value....
2902 *
2903 * @return string
2904 */
2907 }
2909 /**
2910 * A hidden direction mark (LRM or RLM), depending on the language direction.
2911 * Unlike getDirMark(), this function returns the character as an HTML entity.
2912 * This function should be used when the output is guaranteed to be HTML,
2913 * because it makes the output HTML source code more readable. When
2914 * the output is plain text or can be escaped, getDirMark() should be used.
2915 *
2916 * @param bool $opposite Get the direction mark opposite to your language
2917 * @return string
2918 * @since 1.20
2919 */
2923 }
2925 }
2927 /**
2928 * A hidden direction mark (LRM or RLM), depending on the language direction.
2929 * This function produces them as invisible Unicode characters and
2930 * the output may be hard to read and debug, so it should only be used
2931 * when the output is plain text or can be escaped. When the output is
2932 * HTML, use getDirMarkEntity() instead.
2933 *
2934 * @param bool $opposite Get the direction mark opposite to your language
2935 * @return string
2936 */
2942 }
2944 }
2946 /**
2947 * @return array
2948 */
2951 }
2953 /**
2954 * An arrow, depending on the language direction.
2955 *
2956 * @param string $direction The direction of the arrow: forwards (default),
2957 * backwards, left, right, up, down.
2958 * @return string
2959 */
2974 }
2975 }
2977 /**
2978 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2979 *
2980 * @return bool
2981 */
2984 }
2986 /**
2987 * Get all magic words from cache.
2988 * @return array
2989 */
2992 }
2994 /**
2995 * Run the LanguageGetMagic hook once.
2996 */
3000 }
3005 }
3007 /**
3008 * Fill a MagicWord object with data from here
3009 *
3010 * @param MagicWord $mw
3011 */
3013 // Saves a function call
3016 }
3023 }
3030 }
3031 }
3033 /**
3034 * Add magic words to the extension array
3035 *
3036 * @param array $newWords
3037 */
3044 }
3045 }
3046 }
3048 /**
3049 * Get special page names, as an associative array
3050 * case folded alias => real name
3051 * @return array
3052 */
3054 // Cache aliases because it may be slow to load them
3056 // Initialise array
3061 }
3064 }
3066 /**
3067 * Italic is unsuitable for some languages
3068 *
3069 * @param string $text The text to be emphasized.
3070 * @return string
3071 */
3074 }
3076 /**
3077 * Normally we output all numbers in plain en_US style, that is
3078 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3079 * point twohundredthirtyfive. However this is not suitable for all
3080 * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3081 * Icelandic just want to use commas instead of dots, and dots instead
3082 * of commas like "293.291,235".
3083 *
3084 * An example of this function being called:
3085 * <code>
3086 * wfMessage( 'message' )->numParams( $num )->text()
3087 * </code>
3088 *
3089 * See $separatorTransformTable on MessageIs.php for
3090 * the , => . and . => , implementation.
3091 *
3092 * @todo check if it's viable to use localeconv() for the decimal separator thing.
3093 * @param int|float $number The string to be formatted, should be an integer
3094 * or a floating point number.
3095 * @param bool $nocommafy Set to true for special numbers like dates
3096 * @return string
3097 */
3105 }
3106 }
3112 }
3113 }
3116 }
3118 /**
3119 * Front-end for non-commafied formatNum
3120 *
3121 * @param int|float $number The string to be formatted, should be an integer
3122 * or a floating point number.
3123 * @since 1.21
3124 * @return string
3125 */
3128 }
3130 /**
3131 * @param string $number
3132 * @return string
3133 */
3137 // eliminate empty array values such as ''. (bug 64347)
3140 }
3144 // eliminate empty array values such as ''. (bug 64347)
3147 }
3151 }
3153 /**
3154 * Adds commas to a given number
3155 * @since 1.19
3156 * @param mixed $number
3157 * @return string
3158 */
3163 }
3166 // default grouping is at thousands, use the same for ###,###,### pattern too.
3169 // Ref: http://cldr.unicode.org/translation/number-patterns
3172 // For negative numbers apply the algorithm like positive number and add sign.
3175 }
3183 // the string does not have any number part. Eg: .12345
3185 }
3193 }
3197 // use the last pattern for the rest of the number
3199 }
3202 }
3203 }
3205 }
3206 }
3208 /**
3209 * @return string
3210 */
3213 }
3215 /**
3216 * @return array
3217 */
3220 }
3222 /**
3223 * @return array
3224 */
3227 }
3229 /**
3230 * Take a list of strings and build a locale-friendly comma-separated
3231 * list, using the local comma-separator message.
3232 * The last two strings are chained with an "and".
3233 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3234 *
3235 * @param string[] $l
3236 * @return string
3237 */
3242 }
3248 }
3249 }
3256 }
3257 }
3259 }
3261 /**
3262 * Take a list of strings and build a locale-friendly comma-separated
3263 * list, using the local comma-separator message.
3264 * @param string[] $list Array of strings to put in a comma list
3265 * @return string
3266 */
3270 $list
3271 );
3272 }
3274 /**
3275 * Take a list of strings and build a locale-friendly semicolon-separated
3276 * list, using the local semicolon-separator message.
3277 * @param string[] $list Array of strings to put in a semicolon list
3278 * @return string
3279 */
3283 $list
3284 );
3285 }
3287 /**
3288 * Same as commaList, but separate it with the pipe instead.
3289 * @param string[] $list Array of strings to put in a pipe list
3290 * @return string
3291 */
3295 $list
3296 );
3297 }
3299 /**
3300 * Truncate a string to a specified length in bytes, appending an optional
3301 * string (e.g. for ellipses)
3302 *
3303 * The database offers limited byte lengths for some columns in the database;
3304 * multi-byte character sets mean we need to ensure that only whole characters
3305 * are included, otherwise broken characters can be passed to the user
3306 *
3307 * If $length is negative, the string will be truncated from the beginning
3308 *
3309 * @param string $string String to truncate
3310 * @param int $length Maximum length (including ellipses)
3311 * @param string $ellipsis String to append to the truncated text
3312 * @param bool $adjustLength Subtract length of ellipsis from $length.
3313 * $adjustLength was introduced in 1.18, before that behaved as if false.
3314 * @return string
3315 */
3317 # Use the localized ellipsis character
3320 }
3321 # Check if there is no need to truncate
3326 }
3328 # If ellipsis length is >= $length then we can't apply $adjustLength
3331 # Otherwise, truncate and add ellipsis...
3346 }
3347 }
3348 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3349 # This check is *not* redundant if $adjustLength, due to the single case where
3350 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3355 }
3356 }
3358 /**
3359 * Remove bytes that represent an incomplete Unicode character
3360 * at the end of string (e.g. bytes of the char are missing)
3361 *
3362 * @param string $string
3363 * @return string
3364 */
3370 # We got the first byte only of a multibyte char; remove it.
3375 ) {
3376 # We chopped in the middle of a character; remove it
3378 }
3379 }
3381 }
3383 /**
3384 * Remove bytes that represent an incomplete Unicode character
3385 * at the start of string (e.g. bytes of the char are missing)
3386 *
3387 * @param string $string
3388 * @return string
3389 */
3394 # We chopped in the middle of a character; remove the whole thing
3396 }
3397 }
3399 }
3401 /**
3402 * Truncate a string of valid HTML to a specified length in bytes,
3403 * appending an optional string (e.g. for ellipses), and return valid HTML
3404 *
3405 * This is only intended for styled/linked text, such as HTML with
3406 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3407 * Also, this will not detect things like "display:none" CSS.
3408 *
3409 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3410 *
3411 * @param string $text HTML string to truncate
3412 * @param int $length (zero/positive) Maximum length (including ellipses)
3413 * @param string $ellipsis String to append to the truncated text
3414 * @return string
3415 */
3417 # Use the localized ellipsis character
3420 }
3421 # Check if there is clearly no need to truncate
3426 }
3440 # Consider truncation once the display length has reached the maximim.
3441 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3442 # Check that we're not in the middle of a bracket/entity...
3446 # Save where we are; we will truncate here unless there turn out to
3447 # be so few remaining characters that truncation is not necessary.
3450 }
3452 # String in fact does need truncation, the truncation point was OK.
3457 }
3458 }
3461 }
3463 # Read the next char...
3481 }
3487 // Name found (e.g. "<a href=..."), add on tag attributes...
3489 }
3495 }
3498 // Save state without $ch. We want to *hit* the first
3499 // display char (to get tags) but not *use* it if truncating.
3501 }
3506 // Add the next $max display text chars after this in one swoop...
3511 }
3512 }
3513 }
3514 }
3515 // Close the last tag if left unclosed by bad HTML
3519 }
3521 }
3523 /**
3524 * truncateHtml() helper function
3525 * like strcspn() but adds the skipped chars to $ret
3526 *
3527 * @param string $ret
3528 * @param string $text
3529 * @param string $search
3530 * @param int $start
3531 * @param null|int $len
3532 * @return int
3533 */
3539 }
3544 }
3546 }
3548 /**
3549 * truncateHtml() helper function
3550 * (a) push or pop $tag from $openTags as needed
3551 * (b) clear $tag value
3552 * @param string &$tag Current HTML tag name we are looking at
3553 * @param int $tagType (0-open tag, 1-close tag)
3554 * @param string $lastCh Character before the '>' that ended this tag
3555 * @param array &$openTags Open tag stack (not accounting for $tag)
3556 */
3565 }
3566 }
3568 }
3569 }
3571 /**
3572 * Grammatical transformations, needed for inflected languages
3573 * Invoked by putting {{grammar:case|word}} in a message
3574 *
3575 * @param string $word
3576 * @param string $case
3577 * @return string
3578 */
3583 }
3586 }
3587 /**
3588 * Get the grammar forms for the content language
3589 * @return array Array of grammar forms
3590 * @since 1.20
3591 */
3596 ) {
3598 }
3601 }
3602 /**
3603 * Provides an alternative text depending on specified gender.
3604 * Usage {{gender:username|masculine|feminine|unknown}}.
3605 * username is optional, in which case the gender of current user is used,
3606 * but only in (some) interface messages; otherwise default gender is used.
3607 *
3608 * If no forms are given, an empty string is returned. If only one form is
3609 * given, it will be returned unconditionally. These details are implied by
3610 * the caller and cannot be overridden in subclasses.
3611 *
3612 * If three forms are given, the default is to use the third (unknown) form.
3613 * If fewer than three forms are given, the default is to use the first (masculine) form.
3614 * These details can be overridden in subclasses.
3615 *
3616 * @param string $gender
3617 * @param array $forms
3618 *
3619 * @return string
3620 */
3624 }
3628 }
3631 }
3633 }
3635 /**
3636 * Plural form transformations, needed for some languages.
3637 * For example, there are 3 form of plural in Russian and Polish,
3638 * depending on "count mod 10". See [[w:Plural]]
3639 * For English it is pretty simple.
3640 *
3641 * Invoked by putting {{plural:count|wordform1|wordform2}}
3642 * or {{plural:count|wordform1|wordform2|wordform3}}
3643 *
3644 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3645 *
3646 * @param int $count Non-localized number
3647 * @param array $forms Different plural forms
3648 * @return string Correct form of plural for $count in this language
3649 */
3651 // Handle explicit n=pluralform cases
3655 }
3658 }
3663 }
3665 /**
3666 * Handles explicit plural forms for Language::convertPlural()
3667 *
3668 * In {{PLURAL:$1|0=nothing|one|many}}, 0=nothing will be returned if $1 equals zero.
3669 * If an explicitly defined plural form matches the $count, then
3670 * string value returned, otherwise array returned for further consideration
3671 * by CLDR rules or overridden convertPlural().
3672 *
3673 * @since 1.23
3674 *
3675 * @param int $count non-localized number
3676 * @param array $forms different plural forms
3677 *
3678 * @return array|string
3679 */
3686 }
3688 }
3689 }
3691 }
3693 /**
3694 * Checks that convertPlural was given an array and pads it to requested
3695 * amount of forms by copying the last one.
3696 *
3697 * @param int $count How many forms should there be at least
3698 * @param array $forms Array of forms given to convertPlural
3699 * @return array Padded array of forms or an exception if not an array
3700 */
3704 }
3706 }
3708 /**
3709 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3710 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3711 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3712 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3713 * match up with it.
3714 *
3715 * @param string $str The validated block duration in English
3716 * @return string Somehow translated block duration
3717 * @see LanguageFi.php for example implementation
3718 */
3724 }
3725 }
3727 // Since usually only infinite or indefinite is only on list, so try
3728 // equivalents if still here.
3735 }
3736 }
3737 }
3739 // If all else fails, return a standard duration or timestamp description.
3744 // $time is relative to 0 so it's a duration length.
3748 // wfTimestamp() handles 0 as current time instead of epoch.
3752 }
3753 }
3754 }
3756 /**
3757 * languages like Chinese need to be segmented in order for the diff
3758 * to be of any use
3759 *
3760 * @param string $text
3761 * @return string
3762 */
3765 }
3767 /**
3768 * and unsegment to show the result
3769 *
3770 * @param string $text
3771 * @return string
3772 */
3775 }
3777 /**
3778 * Return the LanguageConverter used in the Language
3779 *
3780 * @since 1.19
3781 * @return LanguageConverter
3782 */
3785 }
3787 /**
3788 * convert text to all supported variants
3789 *
3790 * @param string $text
3791 * @return array
3792 */
3795 }
3797 /**
3798 * convert text to different variants of a language.
3799 *
3800 * @param string $text
3801 * @return string
3802 */
3805 }
3807 /**
3808 * Convert a Title object to a string in the preferred variant
3809 *
3810 * @param Title $title
3811 * @return string
3812 */
3815 }
3817 /**
3818 * Convert a namespace index to a string in the preferred variant
3819 *
3820 * @param int $ns
3821 * @return string
3822 */
3825 }
3827 /**
3828 * Check if this is a language with variants
3829 *
3830 * @return bool
3831 */
3834 }
3836 /**
3837 * Check if the language has the specific variant
3838 *
3839 * @since 1.19
3840 * @param string $variant
3841 * @return bool
3842 */
3845 }
3847 /**
3848 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3849 *
3850 * @param string $text
3851 * @return string
3852 * @deprecated since 1.22 is no longer used
3853 */
3856 }
3858 /**
3859 * Perform output conversion on a string, and encode for safe HTML output.
3860 * @param string $text Text to be converted
3861 * @param bool $isTitle Whether this conversion is for the article title
3862 * @return string
3863 * @todo this should get integrated somewhere sane
3864 */
3867 }
3869 /**
3870 * @param string $key
3871 * @return string
3872 */
3875 }
3877 /**
3878 * Get the list of variants supported by this language
3879 * see sample implementation in LanguageZh.php
3880 *
3881 * @return array an array of language codes
3882 */
3885 }
3887 /**
3888 * @return string
3889 */
3892 }
3894 /**
3895 * @return string
3896 */
3899 }
3901 /**
3902 * @return string
3903 */
3906 }
3908 /**
3909 * If a language supports multiple variants, it is
3910 * possible that non-existing link in one variant
3911 * actually exists in another variant. this function
3912 * tries to find it. See e.g. LanguageZh.php
3913 *
3914 * @param string $link The name of the link
3915 * @param Title $nt The title object of the link
3916 * @param bool $ignoreOtherCond To disable other conditions when
3917 * we need to transclude a template or update a category's link
3918 * @return null the input parameters may be modified upon return
3919 */
3922 }
3924 /**
3925 * returns language specific options used by User::getPageRenderHash()
3926 * for example, the preferred language variant
3927 *
3928 * @return string
3929 */
3932 }
3934 /**
3935 * For languages that support multiple variants, the title of an
3936 * article may be displayed differently in different variants. this
3937 * function returns the apporiate title defined in the body of the article.
3938 *
3939 * @return string
3940 */
3943 }
3945 /**
3946 * Prepare external link text for conversion. When the text is
3947 * a URL, it shouldn't be converted, and it'll be wrapped in
3948 * the "raw" tag (-{R| }-) to prevent conversion.
3949 *
3950 * This function is called "markNoConversion" for historical
3951 * reasons.
3952 *
3953 * @param string $text Text to be used for external link
3954 * @param bool $noParse Wrap it without confirming it's a real URL first
3955 * @return string The tagged text
3956 */
3958 // Excluding protocal-relative URLs may avoid many false positives.
3963 }
3964 }
3966 /**
3967 * A regular expression to match legal word-trailing characters
3968 * which should be merged onto a link of the form [[foo]]bar.
3969 *
3970 * @return string
3971 */
3974 }
3976 /**
3977 * A regular expression character set to match legal word-prefixing
3978 * characters which should be merged onto a link of the form foo[[bar]].
3979 *
3980 * @return string
3981 */
3984 }
3986 /**
3987 * @return Language
3988 */
3991 }
3993 /**
3994 * Get the "parent" language which has a converter to convert a "compatible" language
3995 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
3996 *
3997 * @return Language|null
3998 * @since 1.22
3999 */
4003 }
4010 }
4015 }
4019 }
4021 /**
4022 * Get the RFC 3066 code for this language object
4023 *
4024 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4025 * htmlspecialchars() or similar
4026 *
4027 * @return string
4028 */
4031 }
4033 /**
4034 * Get the code in Bcp47 format which we can use
4035 * inside of html lang="" tags.
4036 *
4037 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4038 * htmlspecialchars() or similar.
4039 *
4040 * @since 1.19
4041 * @return string
4042 */
4046 }
4048 }
4050 /**
4051 * @param string $code
4052 */
4055 // Ensure we don't leave incorrect cached data lying around
4058 }
4060 /**
4061 * Get the name of a file for a certain language code
4062 * @param string $prefix Prepend this to the filename
4063 * @param string $code Language code
4064 * @param string $suffix Append this to the filename
4065 * @throws MWException
4066 * @return string $prefix . $mangledCode . $suffix
4067 */
4071 }
4074 }
4076 /**
4077 * Get the language code from a file name. Inverse of getFileName()
4078 * @param string $filename $prefix . $languageCode . $suffix
4079 * @param string $prefix Prefix before the language code
4080 * @param string $suffix Suffix after the language code
4081 * @return string Language code, or false if $prefix or $suffix isn't found
4082 */
4083 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4089 }
4091 }
4093 /**
4094 * @param string $code
4095 * @return string
4096 */
4102 }
4104 /**
4105 * @param string $code
4106 * @return string
4107 * @since 1.23
4108 */
4114 }
4117 }
4119 /**
4120 * @param string $code
4121 * @return string
4122 */
4126 }
4128 /**
4129 * Get the first fallback for a given language.
4130 *
4131 * @param string $code
4132 *
4133 * @return bool|string
4134 */
4142 }
4143 }
4145 /**
4146 * Get the ordered list of fallback languages.
4147 *
4148 * @since 1.19
4149 * @param string $code Language code
4150 * @return array
4151 */
4160 }
4162 }
4163 }
4165 /**
4166 * Get the ordered list of fallback languages, ending with the fallback
4167 * language chain for the site language.
4168 *
4169 * @since 1.22
4170 * @param string $code Language code
4171 * @return array array( fallbacks, site fallbacks )
4172 */
4176 // Usually, we will only store a tiny number of fallback chains, so we
4177 // keep them in static memory.
4183 // Append the site's fallback chain, including the site language itself
4187 // Eliminate any languages already included in the chain
4191 }
4193 }
4195 /**
4196 * Get all messages for a given language
4197 * WARNING: this may take a long time. If you just need all message *keys*
4198 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4199 *
4200 * @param string $code
4201 *
4202 * @return array
4203 */
4206 }
4208 /**
4209 * Get a message for a given language
4210 *
4211 * @param string $key
4212 * @param string $code
4213 *
4214 * @return string
4215 */
4218 }
4220 /**
4221 * Get all message keys for a given language. This is a faster alternative to
4222 * array_keys( Language::getMessagesFor( $code ) )
4223 *
4224 * @since 1.19
4225 * @param string $code Language code
4226 * @return array of message keys (strings)
4227 */
4230 }
4232 /**
4233 * @param string $talk
4234 * @return mixed
4235 */
4239 }
4244 # Allow grammar transformations
4245 # Allowing full message-style parsing would make simple requests
4246 # such as action=raw much more expensive than they need to be.
4247 # This will hopefully cover most cases.
4251 }
4253 /**
4254 * @param string $m
4255 * @return string
4256 */
4259 }
4261 /**
4262 * @throws MWException
4263 * @return array
4264 */
4269 }
4276 }
4281 }
4283 /**
4284 * Decode an expiry (block, protection, etc) which has come from the DB
4285 *
4286 * @todo FIXME: why are we returnings DBMS-dependent strings???
4287 *
4288 * @param string $expiry Database expiry String
4289 * @param bool|int $format True to process using language functions, or TS_ constant
4290 * to return the expiry in a given timestamp
4291 * @return string
4292 * @since 1.18
4293 */
4298 }
4308 }
4309 }
4311 /**
4312 * @todo Document
4313 * @param int|float $seconds
4314 * @param array $format Optional
4315 * If $format['avoid'] === 'avoidseconds': don't mention seconds if $seconds >= 1 hour.
4316 * If $format['avoid'] === 'avoidminutes': don't mention seconds/minutes if $seconds > 48 hours.
4317 * If $format['noabbrevs'] is true: use 'seconds' and friends instead of 'seconds-abbrev'
4318 * and friends.
4319 * For backwards compatibility, $format may also be one of the strings 'avoidseconds'
4320 * or 'avoidminutes'.
4321 * @return string
4322 */
4326 }
4329 }
4332 }
4354 }
4365 }
4369 }
4375 }
4383 }
4393 }
4397 }
4407 }
4408 }
4410 }
4412 /**
4413 * Format a bitrate for output, using an appropriate
4414 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to
4415 * the magnitude in question.
4416 *
4417 * This use base 1000. For base 1024 use formatSize(), for another base
4418 * see formatComputingNumbers().
4419 *
4420 * @param int $bps
4421 * @return string
4422 */
4425 }
4427 /**
4428 * @param int $size Size of the unit
4429 * @param int $boundary Size boundary (1000, or 1024 in most cases)
4430 * @param string $messageKey Message key to be uesd
4431 * @return string
4432 */
4437 );
4438 }
4446 }
4448 // For small sizes no decimal places necessary
4451 // For MB and bigger two decimal places are smarter
4453 }
4459 }
4461 /**
4462 * Format a size in bytes for output, using an appropriate
4463 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4464 *
4465 * This method use base 1024. For base 1000 use formatBitrate(), for
4466 * another base see formatComputingNumbers()
4467 *
4468 * @param int $size Size to format
4469 * @return string Plain text (not HTML)
4470 */
4473 }
4475 /**
4476 * Make a list item, used by various special pages
4477 *
4478 * @param string $page Page link
4479 * @param string $details Text between brackets
4480 * @param bool $oppositedm Add the direction mark opposite to your
4481 * language, to display text properly
4482 * @return string
4483 */
4490 }
4492 /**
4493 * Generate (prev x| next x) (20|50|100...) type links for paging
4494 *
4495 * @param Title $title Title object to link
4496 * @param int $offset
4497 * @param int $limit
4498 * @param array|string $query Optional URL query parameter string
4499 * @param bool $atend Optional param for specified if this is the last page
4500 * @return string
4501 */
4504 ) {
4505 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4507 # Make 'previous' link
4508 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4514 }
4516 # Make 'next' link
4517 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4523 }
4525 # Make links to set number of items per page
4530 }
4534 }
4536 /**
4537 * Helper function for viewPrevNext() that generates links
4538 *
4539 * @param Title $title Title object to link
4540 * @param int $offset
4541 * @param int $limit
4542 * @param array $query Extra query parameters
4543 * @param string $link Text to use for the link; will be escaped
4544 * @param string $tooltipMsg Name of the message to use as tooltip
4545 * @param string $class Value of the "class" attribute of the link
4546 * @return string HTML fragment
4547 */
4550 ) {
4557 }
4559 /**
4560 * Get the conversion rule title, if any.
4561 *
4562 * @return string
4563 */
4566 }
4568 /**
4569 * Get the compiled plural rules for the language
4570 * @since 1.20
4571 * @return array Associative array with plural form, and plural rule as key-value pairs
4572 */
4578 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4581 }
4582 }
4583 }
4585 }
4587 /**
4588 * Get the plural rules for the language
4589 * @since 1.20
4590 * @return array Associative array with plural form number and plural rule as key-value pairs
4591 */
4600 }
4601 }
4602 }
4604 }
4606 /**
4607 * Get the plural rule types for the language
4608 * @since 1.22
4609 * @return array Associative array with plural form number and plural rule type as key-value pairs
4610 */
4616 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4619 }
4620 }
4621 }
4623 }
4625 /**
4626 * Find the index number of the plural rule appropriate for the given number
4627 * @return int The index number of the plural rule
4628 */
4633 }
4635 /**
4636 * Find the plural rule type appropriate for the given number
4637 * For example, if the language is set to Arabic, getPluralType(5) should
4638 * return 'few'.
4639 * @since 1.22
4640 * @return string The name of the plural rule type, e.g. one, two, few, many
4641 */
4649 }
4650 }
4651 }