| blob | 0026fdf4bf0b04c3ba4d74790328e19ebbe1eabe |
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 * a fake language converter
39 *
40 * @ingroup Language
41 */
43 /**
44 * @var Language
45 */
66 /** @deprecated since 1.22 is no longer used */
68 function validateVariant( $variant = null ) { return $variant === $this->mLang->getCode() ? $variant : null; }
70 }
72 /**
73 * Internationalisation code
74 * @ingroup Language
75 */
78 /**
79 * @var LanguageConverter
80 */
92 /**
93 * ReplacementArray object caches
94 */
97 /**
98 * @var LocalisationCache
99 */
107 );
111 );
116 'december'
117 );
121 'december-gen'
122 );
126 );
133 );
141 );
149 );
156 );
158 /**
159 * @since 1.20
160 * @var array
161 */
172 );
174 /**
175 * Cache for language fallbacks.
176 * @see Language::getFallbacksIncludingSiteLanguage
177 * @since 1.21
178 * @var array
179 */
182 /**
183 * Get a cached or new language object for a given language code
184 * @param $code String
185 * @return Language
186 */
192 }
194 // get the language object to process
199 // merge the language object in to get it up front in the cache
201 // get rid of the oldest ones in case we have an overflow
205 }
207 /**
208 * Create a language object for a given language code
209 * @param $code String
210 * @throws MWException
211 * @return Language
212 */
214 // Protect against path traversal below
217 ) {
219 }
222 // It's not possible to customise this code with class files, so
223 // just return a Language object. This is to support uselang= hacks.
227 }
229 // Check if there is a language class for the code
235 }
237 // Keep trying the fallback list until we find an existing class
242 }
250 }
251 }
254 }
256 /**
257 * Checks whether any localisation is available for that language tag
258 * in MediaWiki (MessagesXx.php exists).
259 *
260 * @param string $code Language tag (in lower case)
261 * @return bool Whether language is supported
262 * @since 1.21
263 */
266 }
268 /**
269 * Returns true if a language code string is a well-formed language tag
270 * according to RFC 5646.
271 * This function only checks well-formedness; it doesn't check that
272 * language, script or variant codes actually exist in the repositories.
273 *
274 * Based on regexes by Mark Davis of the Unicode Consortium:
275 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
276 *
277 * @param $code string
278 * @param $lenient boolean Whether to allow '_' as separator. The default is only '-'.
279 *
280 * @return bool
281 * @since 1.21
282 */
298 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
299 # Since these are limited, this is safe even later changes to the registry --
300 # the only oddity is that it might change the type of the tag, and thus
301 # the results from the capturing groups.
302 # http://www.iana.org/assignments/language-subtag-registry
320 # The final breakdown, with capturing groups for each of these components
321 # The variants, extensions, grandfathered, and private-use may have interior '-'
326 }
328 /**
329 * Returns true if a language code string is of a valid form, whether or
330 * not it exists. This includes codes which are used solely for
331 * customisation via the MediaWiki namespace.
332 *
333 * @param $code string
334 *
335 * @return bool
336 */
341 }
342 // People think language codes are html safe, so enforce it.
343 // Ideally we should only allow a-zA-Z0-9-
344 // but, .+ and other chars are often used for {{int:}} hacks
345 // see bugs 37564, 37587, 36938
351 }
353 /**
354 * Returns true if a language code is of a valid form for the purposes of
355 * internal customisation of MediaWiki, via Messages*.php.
356 *
357 * @param $code string
358 *
359 * @throws MWException
360 * @since 1.18
361 * @return bool
362 */
370 }
373 }
376 }
378 /**
379 * Returns true if a language code is an IETF tag known to MediaWiki.
380 *
381 * @param $code string
382 *
383 * @since 1.21
384 * @return bool
385 */
389 // Quick escape for invalid input to avoid exceptions down the line
390 // when code tries to process tags which are not valid at all.
393 }
398 }
402 ) {
404 }
407 }
409 /**
410 * @param $code
411 * @return String Name of the language class
412 */
418 }
419 }
421 /**
422 * Includes language class files
423 *
424 * @param $class string Name of the language class
425 */
431 }
435 }
436 }
438 /**
439 * Get the LocalisationCache instance
440 *
441 * @return LocalisationCache
442 */
448 }
450 }
454 // Set the code to the name of the descendant
459 }
461 }
463 /**
464 * Reduce memory usage
465 */
469 }
470 }
472 /**
473 * Hook which will be called if this is the content language.
474 * Descendants can use this to register hook functions or modify globals
475 */
478 /**
479 * Same as getFallbacksFor for current language.
480 * @return array|bool
481 * @deprecated in 1.19
482 */
486 }
488 /**
489 * @return array
490 * @since 1.19
491 */
494 }
496 /**
497 * Exports $wgBookstoreListEn
498 * @return array
499 */
502 }
504 /**
505 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
506 * available in localised form, it will be included in English.
507 *
508 * @return array
509 */
526 }
528 # Sometimes a language will be localised but not actually exist on this wiki.
532 }
533 }
535 # The above mixing may leave namespaces out of canonical order.
536 # Re-order by namespace ID number...
540 }
542 }
544 /**
545 * Arbitrarily set all of the namespace names at once. Mainly used for testing
546 * @param $namespaces Array of namespaces (id => name)
547 */
551 }
553 /**
554 * Resets all of the namespace caches. Mainly used for testing
555 */
560 }
562 /**
563 * A convenience function that returns the same thing as
564 * getNamespaces() except with the array values changed to ' '
565 * where it found '_', useful for producing output to be displayed
566 * e.g. in <select> forms.
567 *
568 * @return array
569 */
574 }
576 }
578 /**
579 * Get a namespace value by key
580 * <code>
581 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
582 * echo $mw_ns; // prints 'MediaWiki'
583 * </code>
584 *
585 * @param $index Int: the array key of the namespace to return
586 * @return mixed, string if the namespace value exists, otherwise false
587 */
591 }
593 /**
594 * A convenience function that returns the same thing as
595 * getNsText() except with '_' changed to ' ', useful for
596 * producing output.
597 *
598 * <code>
599 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
600 * echo $mw_ns; // prints 'MediaWiki talk'
601 * </code>
602 *
603 * @param int $index The array key of the namespace to return
604 * @return string Namespace name without underscores (empty string if namespace does not exist)
605 */
609 }
611 /**
612 * Returns gender-dependent namespace alias if available.
613 * @param $index Int: namespace index
614 * @param $gender String: gender key (male, female... )
615 * @return String
616 * @since 1.18
617 */
621 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
623 }
625 /**
626 * Whether this language makes distinguishes genders for example in
627 * namespaces.
628 * @return bool
629 * @since 1.18
630 */
634 // $wgExtraGenderNamespaces overrides everything
636 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
637 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
638 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
641 // Check what is in i18n files
644 }
645 }
647 /**
648 * Get a namespace key by value, case insensitive.
649 * Only matches namespace names for the current language, not the
650 * canonical ones defined in Namespace.php.
651 *
652 * @param $text String
653 * @return mixed An integer if $text is a valid value otherwise false
654 */
659 }
661 /**
662 * @return array
663 */
675 }
676 }
677 }
680 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
684 }
685 }
687 # Also add converted namespace names as aliases, to avoid confusion.
692 }
695 }
696 }
699 }
701 }
703 /**
704 * @return array
705 */
709 # Put namespace names and aliases into a hashtable.
710 # If this is too slow, then we should arrange it so that it is done
711 # before caching. The catch is that at pre-cache time, the above
712 # class-specific fixup hasn't been done.
716 }
719 }
723 }
724 }
725 }
727 }
729 /**
730 * Get a namespace key by value, case insensitive. Canonical namespace
731 * names override custom ones defined for the current language.
732 *
733 * @param $text String
734 * @return mixed An integer if $text is a valid value otherwise false
735 */
741 }
744 }
746 /**
747 * short names for language variants used for language conversion links.
748 *
749 * @param $code String
750 * @param $usemsg bool Use the "variantname-xyz" message if it exists
751 * @return string
752 */
757 }
762 # otherwise, output the language code
764 }
765 }
767 /**
768 * @param $name string
769 * @return string
770 */
775 }
777 }
779 /**
780 * @return array
781 */
784 }
786 /**
787 * @return array
788 */
791 }
793 /**
794 * @return array|string
795 */
803 }
804 }
806 /**
807 * @return array
808 */
811 }
813 /**
814 * @param $image
815 * @return array|null
816 */
819 }
821 /**
822 * @return array
823 */
826 }
828 /**
829 * @param $tog
830 * @return string
831 */
834 }
836 /**
837 * Get native language names, indexed by code.
838 * Only those defined in MediaWiki, no other data like CLDR.
839 * If $customisedOnly is true, only returns codes with a messages file
840 *
841 * @param $customisedOnly bool
842 *
843 * @return array
844 * @deprecated in 1.20, use fetchLanguageNames()
845 */
848 }
850 /**
851 * Get translated language names. This is done on best effort and
852 * by default this is exactly the same as Language::getLanguageNames.
853 * The CLDR extension provides translated names.
854 * @param $code String Language code.
855 * @return Array language code => language name
856 * @since 1.18.0
857 * @deprecated in 1.20, use fetchLanguageNames()
858 */
861 }
863 /**
864 * Get an array of language names, indexed by code.
865 * @param $inLanguage null|string: Code of language in which to return the names
866 * Use null for autonyms (native names)
867 * @param $include string:
868 * 'all' all available languages
869 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
870 * 'mwfile' only if the language is in 'mw' *and* has a message file
871 * @return array: language code => language name
872 * @since 1.20
873 */
881 }
886 # TODO: also include when $inLanguage is null, when this code is more efficient
888 }
892 # - Prefer own MediaWiki native name when not using the hook
893 # - For other names just add if not added through the hook
896 }
897 }
901 }
907 }
911 # We do this using a foreach over the codes instead of a directory
912 # loop so that messages files in extensions will work correctly.
916 }
917 }
919 }
920 # 'mw' option; default if it's not one of the other two options (all/mwfile)
922 }
924 /**
925 * @param $code string: The code of the language for which to get the name
926 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
927 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
928 * @return string: Language name or empty
929 * @since 1.20
930 */
934 }
936 /**
937 * Get a message from the MediaWiki namespace.
938 *
939 * @param $msg String: message name
940 * @return string
941 */
944 }
946 /**
947 * Get the native language name of $code.
948 * Only if defined in MediaWiki, no other data like CLDR.
949 * @param $code string
950 * @return string
951 * @deprecated in 1.20, use fetchLanguageName()
952 */
955 }
957 /**
958 * @param $key string
959 * @return string
960 */
963 }
965 /**
966 * @return array
967 */
972 }
974 }
976 /**
977 * @param $key string
978 * @return string
979 */
982 }
984 /**
985 * @param $key string
986 * @return string
987 */
990 }
992 /**
993 * @return array
994 */
999 }
1001 }
1003 /**
1004 * @param $key string
1005 * @return string
1006 */
1009 }
1011 /**
1012 * @param $key string
1013 * @return string
1014 */
1017 }
1019 /**
1020 * @param $key string
1021 * @return string
1022 */
1025 }
1027 /**
1028 * @param $key string
1029 * @return string
1030 */
1033 }
1035 /**
1036 * @param $key string
1037 * @return string
1038 */
1041 }
1043 /**
1044 * @param $key string
1045 * @return string
1046 */
1049 }
1051 /**
1052 * This is a workalike of PHP's date() function, but with better
1053 * internationalisation, a reduced set of format characters, and a better
1054 * escaping format.
1055 *
1056 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1057 * the PHP manual for definitions. There are a number of extensions, which
1058 * start with "x":
1059 *
1060 * xn Do not translate digits of the next numeric format character
1061 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1062 * xr Use roman numerals for the next numeric format character
1063 * xh Use hebrew numerals for the next numeric format character
1064 * xx Literal x
1065 * xg Genitive month name
1066 *
1067 * xij j (day number) in Iranian calendar
1068 * xiF F (month name) in Iranian calendar
1069 * xin n (month number) in Iranian calendar
1070 * xiy y (two digit year) in Iranian calendar
1071 * xiY Y (full year) in Iranian calendar
1072 *
1073 * xjj j (day number) in Hebrew calendar
1074 * xjF F (month name) in Hebrew calendar
1075 * xjt t (days in month) in Hebrew calendar
1076 * xjx xg (genitive month name) in Hebrew calendar
1077 * xjn n (month number) in Hebrew calendar
1078 * xjY Y (full year) in Hebrew calendar
1079 *
1080 * xmj j (day number) in Hijri calendar
1081 * xmF F (month name) in Hijri calendar
1082 * xmn n (month number) in Hijri calendar
1083 * xmY Y (full year) in Hijri calendar
1084 *
1085 * xkY Y (full year) in Thai solar calendar. Months and days are
1086 * identical to the Gregorian calendar
1087 * xoY Y (full year) in Minguo calendar or Juche year.
1088 * Months and days are identical to the
1089 * Gregorian calendar
1090 * xtY Y (full year) in Japanese nengo. Months and days are
1091 * identical to the Gregorian calendar
1092 *
1093 * Characters enclosed in double quotes will be considered literal (with
1094 * the quotes themselves removed). Unmatched quotes will be considered
1095 * literal quotes. Example:
1096 *
1097 * "The month is" F => The month is January
1098 * i's" => 20'11"
1099 *
1100 * Backslash escaping is also supported.
1101 *
1102 * Input timestamp is assumed to be pre-normalized to the desired local
1103 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1104 * $ts is UTC if $zone is not given.
1105 *
1106 * @param $format String
1107 * @param $ts String: 14-character timestamp
1108 * YYYYMMDDHHMMSS
1109 * 01234567890123
1110 * @param $zone DateTimeZone: Timezone of $ts
1111 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1112 *
1113 * @throws MWException
1114 * @return string
1115 */
1132 }
1136 }
1143 }
1145 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1147 }
1171 }
1181 );
1182 }
1191 }
1197 }
1203 }
1210 );
1211 }
1220 }
1226 }
1232 }
1247 }
1253 }
1259 }
1265 }
1274 }
1280 }
1286 }
1292 }
1298 }
1304 }
1313 }
1348 // Pass through string from $dateTimeObj->format()
1352 );
1353 }
1366 // Pass through number from $dateTimeObj->format()
1370 );
1371 }
1375 # Backslash escaping
1380 }
1383 # Quoted literal
1387 # No terminating quote, assume literal "
1392 }
1394 # Quote at end of string, assume literal "
1396 }
1400 }
1413 }
1414 }
1415 }
1417 }
1422 /**
1423 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1424 * Gregorian dates to Iranian dates. Originally written in C, it
1425 * is released under the terms of GNU Lesser General Public
1426 * License. Conversion to PHP was performed by Niklas Laxström.
1427 *
1428 * Link: http://www.farsiweb.info/jalali/jalali.c
1429 *
1430 * @param $ts string
1431 *
1432 * @return string
1433 */
1439 # Days passed from the beginning (including leap years)
1445 // Add days of the past months of this year
1448 }
1450 // Leap years
1453 }
1455 // Days passed in current month
1469 }
1473 }
1479 }
1481 /**
1482 * Converting Gregorian dates to Hijri dates.
1483 *
1484 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1485 *
1486 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1487 *
1488 * @param $ts string
1489 *
1490 * @return string
1491 */
1505 ) {
1513 }
1518 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1519 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1525 }
1527 /**
1528 * Converting Gregorian dates to Hebrew dates.
1529 *
1530 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1531 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1532 * to translate the relevant functions into PHP and release them under
1533 * GNU GPL.
1534 *
1535 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1536 * and Adar II is 14. In a non-leap year, Adar is 6.
1537 *
1538 * @param $ts string
1539 *
1540 * @return string
1541 */
1543 # Parse date
1548 # Calculate Hebrew year
1551 # Month number when September = 1, August = 12
1554 # Next year
1558 }
1560 # Calculate day of year from 1 September
1564 # February
1566 # Check if the year is leap
1569 }
1574 }
1575 }
1577 # Calculate the start of the Hebrew year
1580 # Calculate next year's start
1582 # Day is before the start of the year - it is the previous year
1583 # Next year's start
1585 # Previous year
1588 # Add days since previous year's 1 September
1591 # Leap year
1593 }
1594 # Start of the new (previous) year
1597 # Next year's start
1599 }
1601 # Calculate Hebrew day of year
1604 # Difference between year's days
1606 # Add 12 (or 13 for leap years) days to ignore the difference between
1607 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1608 # difference is only about the year type
1613 }
1615 # Check the year pattern, and is leap year
1616 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1617 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1618 # and non-leap years
1620 # Check if leap year
1623 # Calculate day in the month from number of day in the Hebrew year
1624 # Don't check Adar - if the day is not in Adar, we will stop before;
1625 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1630 # Calculate days in this month
1632 # Adar in a leap year
1634 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1637 # Day in Adar I
1640 # Subtract the days of Adar I
1642 # Try Adar II
1645 # Day in Adar II
1647 }
1648 }
1649 }
1651 # Cheshvan in a complete year (otherwise as the rule below)
1654 # Kislev in an incomplete year (otherwise as the rule below)
1657 # Odd months have 30 days, even have 29
1659 }
1661 # In the current month
1664 # Subtract the days of the current month
1666 # Try in the next month
1668 }
1669 }
1672 }
1674 /**
1675 * This calculates the Hebrew year start, as days since 1 September.
1676 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1677 * Used for Hebrew date.
1678 *
1679 * @param $year int
1680 *
1681 * @return string
1682 */
1689 }
1693 }
1703 }
1707 }
1709 /**
1710 * Algorithm to convert Gregorian dates to Thai solar dates,
1711 * Minguo dates or Minguo dates.
1712 *
1713 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1714 * http://en.wikipedia.org/wiki/Minguo_calendar
1715 * http://en.wikipedia.org/wiki/Japanese_era_name
1716 *
1717 * @param $ts String: 14-character timestamp
1718 * @param $cName String: calender name
1719 * @return Array: converted year, month, day
1720 */
1727 # Thai solar dates
1728 # Add 543 years to the Gregorian calendar
1729 # Months and days are identical
1732 # Minguo dates
1733 # Deduct 1911 years from the Gregorian calendar
1734 # Months and days are identical
1737 # Nengō dates up to Meiji period
1738 # Deduct years from the Gregorian calendar
1739 # depending on the nengo periods
1740 # Months and days are identical
1741 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1742 # Meiji period
1747 }
1755 ) {
1756 # Taishō period
1761 }
1767 ) {
1768 # Shōwa period
1773 }
1776 # Heisei period
1781 }
1783 }
1786 }
1789 }
1791 /**
1792 * Roman number formatting up to 10000
1793 *
1794 * @param $num int
1795 *
1796 * @return string
1797 */
1803 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1804 );
1809 }
1815 }
1817 }
1819 }
1821 /**
1822 * Hebrew Gematria number formatting up to 9999
1823 *
1824 * @param $num int
1825 *
1826 * @return string
1827 */
1834 );
1839 }
1851 }
1852 }
1853 }
1855 }
1861 }
1880 }
1882 }
1884 /**
1885 * Used by date() and time() to adjust the time output.
1886 *
1887 * @param $ts Int the time in date('YmdHis') format
1888 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1889 * get user timecorrection setting)
1890 * @return int
1891 */
1897 }
1910 }
1911 # Unrecognized timezone, default to 'Offset' with the stored offset.
1913 }
1917 # Global offset in minutes.
1920 }
1931 }
1934 }
1935 }
1937 # No difference ? Return time unchanged
1940 }
1943 # Generate an adjusted date; take advantage of the fact that mktime
1944 # will normalize out-of-range values so we don't have to split $minDiff
1945 # into hours and minutes.
1958 }
1960 /**
1961 * This is meant to be used by time(), date(), and timeanddate() to get
1962 * the date preference they're supposed to use, it should be used in
1963 * all children.
1964 *
1965 *<code>
1966 * function timeanddate([...], $format = true) {
1967 * $datePreference = $this->dateFormat($format);
1968 * [...]
1969 * }
1970 *</code>
1971 *
1972 * @param $usePrefs Mixed: if true, the user's preference is used
1973 * if false, the site/language default is used
1974 * if int/string, assumed to be a format.
1975 * @return string
1976 */
1985 }
1988 }
1990 // return int
1993 }
1996 }
1998 /**
1999 * Get a format string for a given type and preference
2000 * @param $type string May be date, time or both
2001 * @param $pref string The format name as it appears in Messages*.php
2002 *
2003 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2004 *
2005 * @return string
2006 */
2017 }
2022 }
2023 }
2025 }
2027 }
2029 /**
2030 * @param $ts Mixed: the time format which needs to be turned into a
2031 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2032 * @param $adj Bool: whether to adjust the time output according to the
2033 * user configured offset ($timecorrection)
2034 * @param $format Mixed: true to use user's date format preference
2035 * @param $timecorrection String|bool the time offset as returned by
2036 * validateTimeZone() in Special:Preferences
2037 * @return string
2038 */
2043 }
2046 }
2048 /**
2049 * @param $ts Mixed: the time format which needs to be turned into a
2050 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2051 * @param $adj Bool: whether to adjust the time output according to the
2052 * user configured offset ($timecorrection)
2053 * @param $format Mixed: true to use user's date format preference
2054 * @param $timecorrection String|bool the time offset as returned by
2055 * validateTimeZone() in Special:Preferences
2056 * @return string
2057 */
2062 }
2065 }
2067 /**
2068 * @param $ts Mixed: the time format which needs to be turned into a
2069 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2070 * @param $adj Bool: whether to adjust the time output according to the
2071 * user configured offset ($timecorrection)
2072 * @param $format Mixed: what format to return, if it's false output the
2073 * default one (default true)
2074 * @param $timecorrection String|bool the time offset as returned by
2075 * validateTimeZone() in Special:Preferences
2076 * @return string
2077 */
2082 }
2085 }
2087 /**
2088 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2089 *
2090 * @since 1.20
2091 *
2092 * @param integer $seconds The amount of seconds.
2093 * @param array $chosenIntervals The intervals to enable.
2094 *
2095 * @return string
2096 */
2103 // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2104 // duration-years, duration-decades, duration-centuries, duration-millennia
2107 }
2110 }
2112 /**
2113 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2114 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2115 *
2116 * @since 1.20
2117 *
2118 * @param integer $seconds The amount of seconds.
2119 * @param array $chosenIntervals The intervals to enable.
2120 *
2121 * @return array
2122 */
2125 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2126 }
2140 }
2141 }
2144 }
2146 /**
2147 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2148 *
2149 * @param $type String: can be 'date', 'time' or 'both'
2150 * @param $ts Mixed: the time format which needs to be turned into a
2151 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2152 * @param $user User object used to get preferences for timezone and format
2153 * @param $options Array, can contain the following keys:
2154 * - 'timecorrection': time correction, can have the following values:
2155 * - true: use user's preference
2156 * - false: don't use time correction
2157 * - integer: value of time correction in minutes
2158 * - 'format': format to use, can have the following values:
2159 * - true: use user's preference
2160 * - false: use default preference
2161 * - string: format to use
2162 * @since 1.19
2163 * @return String
2164 */
2173 }
2175 }
2180 }
2183 }
2185 /**
2186 * Get the formatted date for the given timestamp and formatted for
2187 * the given user.
2188 *
2189 * @param $ts Mixed: the time format which needs to be turned into a
2190 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2191 * @param $user User object used to get preferences for timezone and format
2192 * @param $options Array, can contain the following keys:
2193 * - 'timecorrection': time correction, can have the following values:
2194 * - true: use user's preference
2195 * - false: don't use time correction
2196 * - integer: value of time correction in minutes
2197 * - 'format': format to use, can have the following values:
2198 * - true: use user's preference
2199 * - false: use default preference
2200 * - string: format to use
2201 * @since 1.19
2202 * @return String
2203 */
2206 }
2208 /**
2209 * Get the formatted time for the given timestamp and formatted for
2210 * the given user.
2211 *
2212 * @param $ts Mixed: the time format which needs to be turned into a
2213 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2214 * @param $user User object used to get preferences for timezone and format
2215 * @param $options Array, can contain the following keys:
2216 * - 'timecorrection': time correction, can have the following values:
2217 * - true: use user's preference
2218 * - false: don't use time correction
2219 * - integer: value of time correction in minutes
2220 * - 'format': format to use, can have the following values:
2221 * - true: use user's preference
2222 * - false: use default preference
2223 * - string: format to use
2224 * @since 1.19
2225 * @return String
2226 */
2229 }
2231 /**
2232 * Get the formatted date and time for the given timestamp and formatted for
2233 * the given user.
2234 *
2235 * @param $ts Mixed: the time format which needs to be turned into a
2236 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2237 * @param $user User object used to get preferences for timezone and format
2238 * @param $options Array, can contain the following keys:
2239 * - 'timecorrection': time correction, can have the following values:
2240 * - true: use user's preference
2241 * - false: don't use time correction
2242 * - integer: value of time correction in minutes
2243 * - 'format': format to use, can have the following values:
2244 * - true: use user's preference
2245 * - false: use default preference
2246 * - string: format to use
2247 * @since 1.19
2248 * @return String
2249 */
2252 }
2254 /**
2255 * Convert an MWTimestamp into a pretty human-readable timestamp using
2256 * the given user preferences and relative base time.
2257 *
2258 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2259 * on your timestamp object, which will then call this function. Calling
2260 * this function directly will cause hooks to be skipped over.
2261 *
2262 * @see MWTimestamp::getHumanTimestamp
2263 * @param MWTimestamp $ts Timestamp to prettify
2264 * @param MWTimestamp $relativeTo Base timestamp
2265 * @param User $user User preferences to use
2266 * @return string Human timestamp
2267 * @since 1.22
2268 */
2271 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) - (int)$relativeTo->timestamp->format( 'w' ) );
2273 if ( $diff->invert || $days > 5 && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' ) ) {
2274 // Timestamps are in different years: use full timestamp
2275 // Also do full timestamp for future dates
2276 /**
2277 * @FIXME Add better handling of future timestamps.
2278 */
2282 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2286 // Timestamp within the past week: show the day of the week and time
2289 // Messages:
2290 // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2296 // Timestamp was yesterday: say 'yesterday' and the time.
2303 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2310 // From here on in, the timestamp was soon enough ago so that we can simply say
2311 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2313 // Less than 90 minutes, but more than an hour ago.
2316 // A few minutes ago.
2319 // Less than a minute, but more than 30 sec ago.
2322 // Less than 30 seconds ago.
2324 }
2327 }
2329 /**
2330 * @param $key string
2331 * @return array|null
2332 */
2335 }
2337 /**
2338 * @return array
2339 */
2342 }
2344 /**
2345 * @param $in
2346 * @param $out
2347 * @param $string
2348 * @return string
2349 */
2351 # This is a wrapper for iconv in all languages except esperanto,
2352 # which does some nasty x-conversions beforehand
2354 # Even with //IGNORE iconv can whine about illegal characters in
2355 # *input* string. We just ignore those too.
2356 # REF: http://bugs.php.net/bug.php?id=37166
2357 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2362 }
2364 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2366 /**
2367 * @param $matches array
2368 * @return mixed|string
2369 */
2372 }
2374 /**
2375 * @param $matches array
2376 * @return string
2377 */
2380 }
2382 /**
2383 * @param $matches array
2384 * @return string
2385 */
2389 }
2391 /**
2392 * @param $matches array
2393 * @return string
2394 */
2398 }
2400 /**
2401 * @param $matches array
2402 * @return string
2403 */
2406 }
2408 /**
2409 * @param $matches array
2410 * @return string
2411 */
2415 }
2417 /**
2418 * Make a string's first character uppercase
2419 *
2420 * @param $str string
2421 *
2422 * @return string
2423 */
2431 // fall back to more complex logic in case of multibyte strings
2433 }
2434 }
2436 /**
2437 * Convert a string to uppercase
2438 *
2439 * @param $str string
2440 * @param $first bool
2441 *
2442 * @return string
2443 */
2451 }
2454 }
2461 $str
2462 );
2465 }
2466 }
2467 }
2469 /**
2470 * @param $str string
2471 * @return mixed|string
2472 */
2484 }
2485 }
2487 /**
2488 * @param $str string
2489 * @param $first bool
2490 * @return mixed|string
2491 */
2499 }
2502 }
2509 $str
2510 );
2513 }
2514 }
2515 }
2517 /**
2518 * @param $str string
2519 * @return bool
2520 */
2523 }
2525 /**
2526 * @param $str string
2527 * @return mixed|string
2528 */
2533 // regexp to find first letter in each word (i.e. after each space)
2534 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2536 // function to use to capitalize a single char
2541 $str
2542 );
2547 $str
2548 );
2549 }
2552 }
2553 }
2555 /**
2556 * capitalize words at word breaks
2557 *
2558 * @param $str string
2559 * @return mixed
2560 */
2565 // since \b doesn't work for UTF-8, we explicitely define word break chars
2568 // find first letter after word break
2569 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2575 $str
2576 );
2581 $str
2582 );
2583 }
2588 $str
2589 );
2590 }
2591 }
2593 /**
2594 * Return a case-folded representation of $s
2595 *
2596 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2597 * and $s2 are the same except for the case of their characters. It is not
2598 * necessary for the value returned to make sense when displayed.
2599 *
2600 * Do *not* perform any other normalisation in this function. If a caller
2601 * uses this function when it should be using a more general normalisation
2602 * function, then fix the caller.
2603 *
2604 * @param $s string
2605 *
2606 * @return string
2607 */
2610 }
2612 /**
2613 * @param $s string
2614 * @return string
2615 */
2619 }
2622 }
2625 }
2627 /**
2628 * @return array
2629 */
2632 }
2634 /**
2635 * Most writing systems use whitespace to break up words.
2636 * Some languages such as Chinese don't conventionally do this,
2637 * which requires special handling when breaking up words for
2638 * searching etc.
2639 *
2640 * @return bool
2641 */
2644 }
2646 /**
2647 * Some languages such as Chinese require word segmentation,
2648 * Specify such segmentation when overridden in derived class.
2649 *
2650 * @param $string String
2651 * @return String
2652 */
2655 }
2657 /**
2658 * Some languages have special punctuation need to be normalized.
2659 * Make such changes here.
2660 *
2661 * @param $string String
2662 * @return String
2663 */
2666 }
2668 /**
2669 * convert double-width roman characters to single-width.
2670 * range: ff00-ff5f ~= 0020-007f
2671 *
2672 * @param $string string
2673 *
2674 * @return string
2675 */
2685 }
2689 }
2691 /**
2692 * @param $string string
2693 * @param $pattern string
2694 * @return string
2695 */
2700 }
2702 /**
2703 * @param $termsArray array
2704 * @return array
2705 */
2707 # some languages, e.g. Chinese, need to do a conversion
2708 # in order for search results to be displayed correctly
2710 }
2712 /**
2713 * Get the first character of a string.
2714 *
2715 * @param $s string
2716 * @return string
2717 */
2724 $matches
2725 );
2730 }
2732 // Break down Hangul syllables to grab the first jamo
2764 }
2767 }
2768 }
2771 # Some languages may have an alternate char encoding option
2772 # (Esperanto X-coding, Japanese furigana conversion, etc)
2773 # If this language is used as the primary content language,
2774 # an override to the defaults can be set here on startup.
2775 }
2777 /**
2778 * @param $s string
2779 * @return string
2780 */
2782 # For some languages we'll want to explicitly specify
2783 # which characters make it into the edit box raw
2784 # or are converted in some way or another.
2790 }
2791 }
2793 /**
2794 * @param $s string
2795 * @return string
2796 */
2798 # Take the previous into account.
2804 }
2809 }
2810 }
2812 /**
2813 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2814 * also cleans up certain backwards-compatible sequences, converting them
2815 * to the modern Unicode equivalent.
2816 *
2817 * This is language-specific for performance reasons only.
2818 *
2819 * @param $s string
2820 *
2821 * @return string
2822 */
2829 }
2832 }
2834 /**
2835 * Transform a string using serialized data stored in the given file (which
2836 * must be in the serialized subdirectory of $IP). The file contains pairs
2837 * mapping source characters to destination characters.
2838 *
2839 * The data is cached in process memory. This will go faster if you have the
2840 * FastStringSearch extension.
2841 *
2842 * @param $file string
2843 * @param $string string
2844 *
2845 * @throws MWException
2846 * @return string
2847 */
2853 }
2855 }
2857 }
2859 /**
2860 * For right-to-left language support
2861 *
2862 * @return bool
2863 */
2866 }
2868 /**
2869 * Return the correct HTML 'dir' attribute value for this language.
2870 * @return String
2871 */
2874 }
2876 /**
2877 * Return 'left' or 'right' as appropriate alignment for line-start
2878 * for this language's text direction.
2879 *
2880 * Should be equivalent to CSS3 'start' text-align value....
2881 *
2882 * @return String
2883 */
2886 }
2888 /**
2889 * Return 'right' or 'left' as appropriate alignment for line-end
2890 * for this language's text direction.
2891 *
2892 * Should be equivalent to CSS3 'end' text-align value....
2893 *
2894 * @return String
2895 */
2898 }
2900 /**
2901 * A hidden direction mark (LRM or RLM), depending on the language direction.
2902 * Unlike getDirMark(), this function returns the character as an HTML entity.
2903 * This function should be used when the output is guaranteed to be HTML,
2904 * because it makes the output HTML source code more readable. When
2905 * the output is plain text or can be escaped, getDirMark() should be used.
2906 *
2907 * @param $opposite Boolean Get the direction mark opposite to your language
2908 * @return string
2909 * @since 1.20
2910 */
2914 }
2916 }
2918 /**
2919 * A hidden direction mark (LRM or RLM), depending on the language direction.
2920 * This function produces them as invisible Unicode characters and
2921 * the output may be hard to read and debug, so it should only be used
2922 * when the output is plain text or can be escaped. When the output is
2923 * HTML, use getDirMarkEntity() instead.
2924 *
2925 * @param $opposite Boolean Get the direction mark opposite to your language
2926 * @return string
2927 */
2933 }
2935 }
2937 /**
2938 * @return array
2939 */
2942 }
2944 /**
2945 * An arrow, depending on the language direction.
2946 *
2947 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2948 * @return string
2949 */
2964 }
2965 }
2967 /**
2968 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2969 *
2970 * @return bool
2971 */
2974 }
2976 /**
2977 * Get all magic words from cache.
2978 * @return array
2979 */
2982 }
2984 /**
2985 * Run the LanguageGetMagic hook once.
2986 */
2990 }
2995 }
2997 /**
2998 * Fill a MagicWord object with data from here
2999 *
3000 * @param $mw
3001 */
3003 // Saves a function call
3006 }
3013 }
3020 }
3021 }
3023 /**
3024 * Add magic words to the extension array
3025 *
3026 * @param $newWords array
3027 */
3034 }
3035 }
3036 }
3038 /**
3039 * Get special page names, as an associative array
3040 * case folded alias => real name
3041 */
3043 // Cache aliases because it may be slow to load them
3045 // Initialise array
3050 }
3053 }
3055 /**
3056 * Italic is unsuitable for some languages
3057 *
3058 * @param $text String: the text to be emphasized.
3059 * @return string
3060 */
3063 }
3065 /**
3066 * Normally we output all numbers in plain en_US style, that is
3067 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3068 * point twohundredthirtyfive. However this is not suitable for all
3069 * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3070 * Icelandic just want to use commas instead of dots, and dots instead
3071 * of commas like "293.291,235".
3072 *
3073 * An example of this function being called:
3074 * <code>
3075 * wfMessage( 'message' )->numParams( $num )->text()
3076 * </code>
3077 *
3078 * See LanguageGu.php for the Gujarati implementation and
3079 * $separatorTransformTable on MessageIs.php for
3080 * the , => . and . => , implementation.
3081 *
3082 * @todo check if it's viable to use localeconv() for the decimal
3083 * separator thing.
3084 * @param $number Mixed: the string to be formatted, should be an integer
3085 * or a floating point number.
3086 * @param $nocommafy Bool: set to true for special numbers like dates
3087 * @return string
3088 */
3096 }
3097 }
3103 }
3104 }
3107 }
3109 /**
3110 * Front-end for non-commafied formatNum
3111 *
3112 * @param mixed $number the string to be formatted, should be an integer
3113 * or a floating point number.
3114 * @since 1.21
3115 * @return string
3116 */
3119 }
3121 /**
3122 * @param $number string
3123 * @return string
3124 */
3129 }
3134 }
3138 }
3140 /**
3141 * Adds commas to a given number
3142 * @since 1.19
3143 * @param $number mixed
3144 * @return string
3145 */
3150 }
3153 // default grouping is at thousands, use the same for ###,###,### pattern too.
3156 // Ref: http://cldr.unicode.org/translation/number-patterns
3159 // For negative numbers apply the algorithm like positive number and add sign.
3162 }
3170 // the string does not have any number part. Eg: .12345
3172 }
3180 }
3184 // use the last pattern for the rest of the number
3186 }
3189 }
3190 }
3192 }
3193 }
3195 /**
3196 * @return String
3197 */
3200 }
3202 /**
3203 * @return array
3204 */
3207 }
3209 /**
3210 * @return array
3211 */
3214 }
3216 /**
3217 * Take a list of strings and build a locale-friendly comma-separated
3218 * list, using the local comma-separator message.
3219 * The last two strings are chained with an "and".
3220 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3221 *
3222 * @param $l Array
3223 * @return string
3224 */
3229 }
3235 }
3236 }
3243 }
3244 }
3246 }
3248 /**
3249 * Take a list of strings and build a locale-friendly comma-separated
3250 * list, using the local comma-separator message.
3251 * @param $list array of strings to put in a comma list
3252 * @return string
3253 */
3257 $list
3258 );
3259 }
3261 /**
3262 * Take a list of strings and build a locale-friendly semicolon-separated
3263 * list, using the local semicolon-separator message.
3264 * @param $list array of strings to put in a semicolon list
3265 * @return string
3266 */
3270 $list
3271 );
3272 }
3274 /**
3275 * Same as commaList, but separate it with the pipe instead.
3276 * @param $list array of strings to put in a pipe list
3277 * @return string
3278 */
3282 $list
3283 );
3284 }
3286 /**
3287 * Truncate a string to a specified length in bytes, appending an optional
3288 * string (e.g. for ellipses)
3289 *
3290 * The database offers limited byte lengths for some columns in the database;
3291 * multi-byte character sets mean we need to ensure that only whole characters
3292 * are included, otherwise broken characters can be passed to the user
3293 *
3294 * If $length is negative, the string will be truncated from the beginning
3295 *
3296 * @param $string String to truncate
3297 * @param $length Int: maximum length (including ellipses)
3298 * @param $ellipsis String to append to the truncated text
3299 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3300 * $adjustLength was introduced in 1.18, before that behaved as if false.
3301 * @return string
3302 */
3304 # Use the localized ellipsis character
3307 }
3308 # Check if there is no need to truncate
3313 }
3315 # If ellipsis length is >= $length then we can't apply $adjustLength
3318 # Otherwise, truncate and add ellipsis...
3333 }
3334 }
3335 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3336 # This check is *not* redundant if $adjustLength, due to the single case where
3337 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3342 }
3343 }
3345 /**
3346 * Remove bytes that represent an incomplete Unicode character
3347 * at the end of string (e.g. bytes of the char are missing)
3348 *
3349 * @param $string String
3350 * @return string
3351 */
3357 # We got the first byte only of a multibyte char; remove it.
3362 ) {
3363 # We chopped in the middle of a character; remove it
3365 }
3366 }
3368 }
3370 /**
3371 * Remove bytes that represent an incomplete Unicode character
3372 * at the start of string (e.g. bytes of the char are missing)
3373 *
3374 * @param $string String
3375 * @return string
3376 */
3381 # We chopped in the middle of a character; remove the whole thing
3383 }
3384 }
3386 }
3388 /**
3389 * Truncate a string of valid HTML to a specified length in bytes,
3390 * appending an optional string (e.g. for ellipses), and return valid HTML
3391 *
3392 * This is only intended for styled/linked text, such as HTML with
3393 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3394 * Also, this will not detect things like "display:none" CSS.
3395 *
3396 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3397 *
3398 * @param string $text HTML string to truncate
3399 * @param int $length (zero/positive) Maximum length (including ellipses)
3400 * @param string $ellipsis String to append to the truncated text
3401 * @return string
3402 */
3404 # Use the localized ellipsis character
3407 }
3408 # Check if there is clearly no need to truncate
3413 }
3427 # Consider truncation once the display length has reached the maximim.
3428 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3429 # Check that we're not in the middle of a bracket/entity...
3433 # Save where we are; we will truncate here unless there turn out to
3434 # be so few remaining characters that truncation is not necessary.
3437 }
3439 # String in fact does need truncation, the truncation point was OK.
3444 }
3445 }
3448 }
3450 # Read the next char...
3468 }
3474 // Name found (e.g. "<a href=..."), add on tag attributes...
3476 }
3482 }
3485 // Save state without $ch. We want to *hit* the first
3486 // display char (to get tags) but not *use* it if truncating.
3488 }
3493 // Add the next $max display text chars after this in one swoop...
3498 }
3499 }
3500 }
3501 }
3502 // Close the last tag if left unclosed by bad HTML
3506 }
3508 }
3510 /**
3511 * truncateHtml() helper function
3512 * like strcspn() but adds the skipped chars to $ret
3513 *
3514 * @param $ret
3515 * @param $text
3516 * @param $search
3517 * @param $start
3518 * @param $len
3519 * @return int
3520 */
3526 }
3531 }
3533 }
3535 /**
3536 * truncateHtml() helper function
3537 * (a) push or pop $tag from $openTags as needed
3538 * (b) clear $tag value
3539 * @param &$tag string Current HTML tag name we are looking at
3540 * @param $tagType int (0-open tag, 1-close tag)
3541 * @param $lastCh string Character before the '>' that ended this tag
3542 * @param &$openTags array Open tag stack (not accounting for $tag)
3543 */
3552 }
3553 }
3555 }
3556 }
3558 /**
3559 * Grammatical transformations, needed for inflected languages
3560 * Invoked by putting {{grammar:case|word}} in a message
3561 *
3562 * @param $word string
3563 * @param $case string
3564 * @return string
3565 */
3570 }
3572 }
3573 /**
3574 * Get the grammar forms for the content language
3575 * @return array of grammar forms
3576 * @since 1.20
3577 */
3580 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3582 }
3584 }
3585 /**
3586 * Provides an alternative text depending on specified gender.
3587 * Usage {{gender:username|masculine|feminine|neutral}}.
3588 * username is optional, in which case the gender of current user is used,
3589 * but only in (some) interface messages; otherwise default gender is used.
3590 *
3591 * If no forms are given, an empty string is returned. If only one form is
3592 * given, it will be returned unconditionally. These details are implied by
3593 * the caller and cannot be overridden in subclasses.
3594 *
3595 * If more than one form is given, the default is to use the neutral one
3596 * if it is specified, and to use the masculine one otherwise. These
3597 * details can be overridden in subclasses.
3598 *
3599 * @param $gender string
3600 * @param $forms array
3601 *
3602 * @return string
3603 */
3607 }
3611 }
3614 }
3616 }
3618 /**
3619 * Plural form transformations, needed for some languages.
3620 * For example, there are 3 form of plural in Russian and Polish,
3621 * depending on "count mod 10". See [[w:Plural]]
3622 * For English it is pretty simple.
3623 *
3624 * Invoked by putting {{plural:count|wordform1|wordform2}}
3625 * or {{plural:count|wordform1|wordform2|wordform3}}
3626 *
3627 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3628 *
3629 * @param $count Integer: non-localized number
3630 * @param $forms Array: different plural forms
3631 * @return string Correct form of plural for $count in this language
3632 */
3634 // Handle explicit n=pluralform cases
3638 }
3641 }
3646 }
3648 /**
3649 * Handles explicit plural forms for Language::convertPlural()
3650 *
3651 * In {{PLURAL:$1|0=nothing|one|many}}, 0=nothing will be returned if $1 equals zero.
3652 * If an explicitly defined plural form matches the $count, then
3653 * string value returned, otherwise array returned for further consideration
3654 * by CLDR rules or overridden convertPlural().
3655 *
3656 * @since 1.23
3657 *
3658 * @param int $count non-localized number
3659 * @param array $forms different plural forms
3660 *
3661 * @return array|string
3662 */
3669 }
3671 }
3672 }
3674 }
3676 /**
3677 * Checks that convertPlural was given an array and pads it to requested
3678 * amount of forms by copying the last one.
3679 *
3680 * @param $count Integer: How many forms should there be at least
3681 * @param $forms Array of forms given to convertPlural
3682 * @return array Padded array of forms or an exception if not an array
3683 */
3687 }
3689 }
3691 /**
3692 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3693 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3694 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3695 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3696 * match up with it.
3697 *
3698 * @param $str String: the validated block duration in English
3699 * @return string Somehow translated block duration
3700 * @see LanguageFi.php for example implementation
3701 */
3707 }
3708 }
3710 // Since usually only infinite or indefinite is only on list, so try
3711 // equivalents if still here.
3718 }
3719 }
3720 }
3722 // If all else fails, return a standard duration or timestamp description.
3727 // $time is relative to 0 so it's a duration length.
3731 // wfTimestamp() handles 0 as current time instead of epoch.
3735 }
3736 }
3737 }
3739 /**
3740 * languages like Chinese need to be segmented in order for the diff
3741 * to be of any use
3742 *
3743 * @param $text String
3744 * @return String
3745 */
3748 }
3750 /**
3751 * and unsegment to show the result
3752 *
3753 * @param $text String
3754 * @return String
3755 */
3758 }
3760 /**
3761 * Return the LanguageConverter used in the Language
3762 *
3763 * @since 1.19
3764 * @return LanguageConverter
3765 */
3768 }
3770 /**
3771 * convert text to all supported variants
3772 *
3773 * @param $text string
3774 * @return array
3775 */
3778 }
3780 /**
3781 * convert text to different variants of a language.
3782 *
3783 * @param $text string
3784 * @return string
3785 */
3788 }
3790 /**
3791 * Convert a Title object to a string in the preferred variant
3792 *
3793 * @param $title Title
3794 * @return string
3795 */
3798 }
3800 /**
3801 * Convert a namespace index to a string in the preferred variant
3802 *
3803 * @param $ns int
3804 * @return string
3805 */
3808 }
3810 /**
3811 * Check if this is a language with variants
3812 *
3813 * @return bool
3814 */
3817 }
3819 /**
3820 * Check if the language has the specific variant
3821 *
3822 * @since 1.19
3823 * @param $variant string
3824 * @return bool
3825 */
3828 }
3830 /**
3831 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3832 *
3833 * @param $text string
3834 * @return string
3835 * @deprecated since 1.22 is no longer used
3836 */
3839 }
3841 /**
3842 * Perform output conversion on a string, and encode for safe HTML output.
3843 * @param $text String text to be converted
3844 * @param $isTitle Bool whether this conversion is for the article title
3845 * @return string
3846 * @todo this should get integrated somewhere sane
3847 */
3850 }
3852 /**
3853 * @param $key string
3854 * @return string
3855 */
3858 }
3860 /**
3861 * Get the list of variants supported by this language
3862 * see sample implementation in LanguageZh.php
3863 *
3864 * @return array an array of language codes
3865 */
3868 }
3870 /**
3871 * @return string
3872 */
3875 }
3877 /**
3878 * @return string
3879 */
3882 }
3884 /**
3885 * @return string
3886 */
3889 }
3891 /**
3892 * If a language supports multiple variants, it is
3893 * possible that non-existing link in one variant
3894 * actually exists in another variant. this function
3895 * tries to find it. See e.g. LanguageZh.php
3896 *
3897 * @param $link String: the name of the link
3898 * @param $nt Mixed: the title object of the link
3899 * @param $ignoreOtherCond Boolean: to disable other conditions when
3900 * we need to transclude a template or update a category's link
3901 * @return null the input parameters may be modified upon return
3902 */
3905 }
3907 /**
3908 * If a language supports multiple variants, converts text
3909 * into an array of all possible variants of the text:
3910 * 'variant' => text in that variant
3911 *
3912 * @deprecated since 1.17 Use autoConvertToAllVariants()
3913 *
3914 * @param $text string
3915 *
3916 * @return string
3917 */
3920 }
3922 /**
3923 * returns language specific options used by User::getPageRenderHash()
3924 * for example, the preferred language variant
3925 *
3926 * @return string
3927 */
3930 }
3932 /**
3933 * For languages that support multiple variants, the title of an
3934 * article may be displayed differently in different variants. this
3935 * function returns the apporiate title defined in the body of the article.
3936 *
3937 * @return string
3938 */
3941 }
3943 /**
3944 * Prepare external link text for conversion. When the text is
3945 * a URL, it shouldn't be converted, and it'll be wrapped in
3946 * the "raw" tag (-{R| }-) to prevent conversion.
3947 *
3948 * This function is called "markNoConversion" for historical
3949 * reasons.
3950 *
3951 * @param $text String: text to be used for external link
3952 * @param $noParse bool: wrap it without confirming it's a real URL first
3953 * @return string the tagged text
3954 */
3956 // Excluding protocal-relative URLs may avoid many false positives.
3961 }
3962 }
3964 /**
3965 * A regular expression to match legal word-trailing characters
3966 * which should be merged onto a link of the form [[foo]]bar.
3967 *
3968 * @return string
3969 */
3972 }
3974 /**
3975 * A regular expression character set to match legal word-prefixing
3976 * characters which should be merged onto a link of the form foo[[bar]].
3977 *
3978 * @return string
3979 */
3982 }
3984 /**
3985 * @return Language
3986 */
3989 }
3991 /**
3992 * Get the "parent" language which has a converter to convert a "compatible" language
3993 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
3994 *
3995 * @return Language|null
3996 * @since 1.22
3997 */
4001 }
4008 }
4013 }
4017 }
4019 /**
4020 * Get the RFC 3066 code for this language object
4021 *
4022 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4023 * htmlspecialchars() or similar
4024 *
4025 * @return string
4026 */
4029 }
4031 /**
4032 * Get the code in Bcp47 format which we can use
4033 * inside of html lang="" tags.
4034 *
4035 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4036 * htmlspecialchars() or similar.
4037 *
4038 * @since 1.19
4039 * @return string
4040 */
4044 }
4046 }
4048 /**
4049 * @param $code string
4050 */
4053 // Ensure we don't leave incorrect cached data lying around
4056 }
4058 /**
4059 * Get the name of a file for a certain language code
4060 * @param $prefix string Prepend this to the filename
4061 * @param $code string Language code
4062 * @param $suffix string Append this to the filename
4063 * @throws MWException
4064 * @return string $prefix . $mangledCode . $suffix
4065 */
4067 // Protect against path traversal
4070 ) {
4072 }
4075 }
4077 /**
4078 * Get the language code from a file name. Inverse of getFileName()
4079 * @param $filename string $prefix . $languageCode . $suffix
4080 * @param $prefix string Prefix before the language code
4081 * @param $suffix string Suffix after the language code
4082 * @return string Language code, or false if $prefix or $suffix isn't found
4083 */
4084 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4090 }
4092 }
4094 /**
4095 * @param $code string
4096 * @return string
4097 */
4103 }
4105 /**
4106 * @param $code string
4107 * @return string
4108 */
4112 }
4114 /**
4115 * Get the first fallback for a given language.
4116 *
4117 * @param $code string
4118 *
4119 * @return bool|string
4120 */
4128 }
4129 }
4131 /**
4132 * Get the ordered list of fallback languages.
4133 *
4134 * @since 1.19
4135 * @param $code string Language code
4136 * @return array
4137 */
4146 }
4148 }
4149 }
4151 /**
4152 * Get the ordered list of fallback languages, ending with the fallback
4153 * language chain for the site language.
4154 *
4155 * @since 1.22
4156 * @param string $code Language code
4157 * @return array array( fallbacks, site fallbacks )
4158 */
4162 // Usually, we will only store a tiny number of fallback chains, so we
4163 // keep them in static memory.
4169 // Append the site's fallback chain, including the site language itself
4173 // Eliminate any languages already included in the chain
4177 }
4179 }
4181 /**
4182 * Get all messages for a given language
4183 * WARNING: this may take a long time. If you just need all message *keys*
4184 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4185 *
4186 * @param $code string
4187 *
4188 * @return array
4189 */
4192 }
4194 /**
4195 * Get a message for a given language
4196 *
4197 * @param $key string
4198 * @param $code string
4199 *
4200 * @return string
4201 */
4204 }
4206 /**
4207 * Get all message keys for a given language. This is a faster alternative to
4208 * array_keys( Language::getMessagesFor( $code ) )
4209 *
4210 * @since 1.19
4211 * @param $code string Language code
4212 * @return array of message keys (strings)
4213 */
4216 }
4218 /**
4219 * @param $talk
4220 * @return mixed
4221 */
4225 }
4230 # Allow grammar transformations
4231 # Allowing full message-style parsing would make simple requests
4232 # such as action=raw much more expensive than they need to be.
4233 # This will hopefully cover most cases.
4237 }
4239 /**
4240 * @param $m string
4241 * @return string
4242 */
4245 }
4247 /**
4248 * @throws MWException
4249 * @return array
4250 */
4255 }
4262 }
4267 }
4269 /**
4270 * Decode an expiry (block, protection, etc) which has come from the DB
4271 *
4272 * @todo FIXME: why are we returnings DBMS-dependent strings???
4273 *
4274 * @param $expiry String: Database expiry String
4275 * @param $format Bool|Int true to process using language functions, or TS_ constant
4276 * to return the expiry in a given timestamp
4277 * @return String
4278 * @since 1.18
4279 */
4284 }
4294 }
4295 }
4297 /**
4298 * @todo Document
4299 * @param $seconds int|float
4300 * @param $format Array Optional
4301 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4302 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4303 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4304 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4305 * @return string
4306 */
4310 }
4313 }
4316 }
4338 }
4349 }
4353 }
4359 }
4367 }
4377 }
4381 }
4391 }
4392 }
4394 }
4396 /**
4397 * Format a bitrate for output, using an appropriate
4398 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4399 *
4400 * This use base 1000. For base 1024 use formatSize(), for another base
4401 * see formatComputingNumbers()
4402 *
4403 * @param $bps int
4404 * @return string
4405 */
4408 }
4410 /**
4411 * @param $size int Size of the unit
4412 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4413 * @param $messageKey string Message key to be uesd
4414 * @return string
4415 */
4420 );
4421 }
4429 }
4431 // For small sizes no decimal places necessary
4434 // For MB and bigger two decimal places are smarter
4436 }
4442 }
4444 /**
4445 * Format a size in bytes for output, using an appropriate
4446 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4447 *
4448 * This method use base 1024. For base 1000 use formatBitrate(), for
4449 * another base see formatComputingNumbers()
4450 *
4451 * @param $size int Size to format
4452 * @return string Plain text (not HTML)
4453 */
4456 }
4458 /**
4459 * Make a list item, used by various special pages
4460 *
4461 * @param $page String Page link
4462 * @param $details String Text between brackets
4463 * @param $oppositedm Boolean Add the direction mark opposite to your
4464 * language, to display text properly
4465 * @return String
4466 */
4473 }
4475 /**
4476 * Generate (prev x| next x) (20|50|100...) type links for paging
4477 *
4478 * @param $title Title object to link
4479 * @param $offset Integer offset parameter
4480 * @param $limit Integer limit parameter
4481 * @param $query array|String optional URL query parameter string
4482 * @param $atend Bool optional param for specified if this is the last page
4483 * @return String
4484 */
4485 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4486 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4488 # Make 'previous' link
4489 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4495 }
4497 # Make 'next' link
4498 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4504 }
4506 # Make links to set number of items per page
4511 }
4515 }
4517 /**
4518 * Helper function for viewPrevNext() that generates links
4519 *
4520 * @param $title Title object to link
4521 * @param $offset Integer offset parameter
4522 * @param $limit Integer limit parameter
4523 * @param $query Array extra query parameters
4524 * @param $link String text to use for the link; will be escaped
4525 * @param $tooltipMsg String name of the message to use as tooltip
4526 * @param $class String value of the "class" attribute of the link
4527 * @return String HTML fragment
4528 */
4529 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4531 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4534 }
4536 /**
4537 * Get the conversion rule title, if any.
4538 *
4539 * @return string
4540 */
4543 }
4545 /**
4546 * Get the compiled plural rules for the language
4547 * @since 1.20
4548 * @return array Associative array with plural form, and plural rule as key-value pairs
4549 */
4555 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4558 }
4559 }
4560 }
4562 }
4564 /**
4565 * Get the plural rules for the language
4566 * @since 1.20
4567 * @return array Associative array with plural form number and plural rule as key-value pairs
4568 */
4577 }
4578 }
4579 }
4581 }
4583 /**
4584 * Get the plural rule types for the language
4585 * @since 1.22
4586 * @return array Associative array with plural form number and plural rule type as key-value pairs
4587 */
4593 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4596 }
4597 }
4598 }
4600 }
4602 /**
4603 * Find the index number of the plural rule appropriate for the given number
4604 * @return int The index number of the plural rule
4605 */
4610 }
4612 /**
4613 * Find the plural rule type appropriate for the given number
4614 * For example, if the language is set to Arabic, getPluralType(5) should
4615 * return 'few'.
4616 * @since 1.22
4617 * @return string The name of the plural rule type, e.g. one, two, few, many
4618 */
4626 }
4627 }
4628 }