| blob | 2038baca98c2122dce52c9e4fbcb46a9ebc3111c |
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 )
1506 {
1514 }
1519 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1520 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1526 }
1528 /**
1529 * Converting Gregorian dates to Hebrew dates.
1530 *
1531 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1532 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1533 * to translate the relevant functions into PHP and release them under
1534 * GNU GPL.
1535 *
1536 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1537 * and Adar II is 14. In a non-leap year, Adar is 6.
1538 *
1539 * @param $ts string
1540 *
1541 * @return string
1542 */
1544 # Parse date
1549 # Calculate Hebrew year
1552 # Month number when September = 1, August = 12
1555 # Next year
1559 }
1561 # Calculate day of year from 1 September
1565 # February
1567 # Check if the year is leap
1570 }
1575 }
1576 }
1578 # Calculate the start of the Hebrew year
1581 # Calculate next year's start
1583 # Day is before the start of the year - it is the previous year
1584 # Next year's start
1586 # Previous year
1589 # Add days since previous year's 1 September
1592 # Leap year
1594 }
1595 # Start of the new (previous) year
1598 # Next year's start
1600 }
1602 # Calculate Hebrew day of year
1605 # Difference between year's days
1607 # Add 12 (or 13 for leap years) days to ignore the difference between
1608 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1609 # difference is only about the year type
1614 }
1616 # Check the year pattern, and is leap year
1617 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1618 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1619 # and non-leap years
1621 # Check if leap year
1624 # Calculate day in the month from number of day in the Hebrew year
1625 # Don't check Adar - if the day is not in Adar, we will stop before;
1626 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1631 # Calculate days in this month
1633 # Adar in a leap year
1635 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1638 # Day in Adar I
1641 # Subtract the days of Adar I
1643 # Try Adar II
1646 # Day in Adar II
1648 }
1649 }
1650 }
1652 # Cheshvan in a complete year (otherwise as the rule below)
1655 # Kislev in an incomplete year (otherwise as the rule below)
1658 # Odd months have 30 days, even have 29
1660 }
1662 # In the current month
1665 # Subtract the days of the current month
1667 # Try in the next month
1669 }
1670 }
1673 }
1675 /**
1676 * This calculates the Hebrew year start, as days since 1 September.
1677 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1678 * Used for Hebrew date.
1679 *
1680 * @param $year int
1681 *
1682 * @return string
1683 */
1690 }
1694 }
1704 }
1708 }
1710 /**
1711 * Algorithm to convert Gregorian dates to Thai solar dates,
1712 * Minguo dates or Minguo dates.
1713 *
1714 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1715 * http://en.wikipedia.org/wiki/Minguo_calendar
1716 * http://en.wikipedia.org/wiki/Japanese_era_name
1717 *
1718 * @param $ts String: 14-character timestamp
1719 * @param $cName String: calender name
1720 * @return Array: converted year, month, day
1721 */
1728 # Thai solar dates
1729 # Add 543 years to the Gregorian calendar
1730 # Months and days are identical
1733 # Minguo dates
1734 # Deduct 1911 years from the Gregorian calendar
1735 # Months and days are identical
1738 # Nengō dates up to Meiji period
1739 # Deduct years from the Gregorian calendar
1740 # depending on the nengo periods
1741 # Months and days are identical
1742 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1743 # Meiji period
1748 }
1756 )
1757 {
1758 # Taishō period
1763 }
1769 )
1770 {
1771 # Shōwa period
1776 }
1779 # Heisei period
1784 }
1786 }
1789 }
1792 }
1794 /**
1795 * Roman number formatting up to 10000
1796 *
1797 * @param $num int
1798 *
1799 * @return string
1800 */
1806 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1807 );
1812 }
1818 }
1820 }
1822 }
1824 /**
1825 * Hebrew Gematria number formatting up to 9999
1826 *
1827 * @param $num int
1828 *
1829 * @return string
1830 */
1837 );
1842 }
1854 }
1855 }
1856 }
1858 }
1864 }
1883 }
1885 }
1887 /**
1888 * Used by date() and time() to adjust the time output.
1889 *
1890 * @param $ts Int the time in date('YmdHis') format
1891 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1892 * get user timecorrection setting)
1893 * @return int
1894 */
1900 }
1913 }
1914 # Unrecognized timezone, default to 'Offset' with the stored offset.
1916 }
1920 # Global offset in minutes.
1923 }
1934 }
1937 }
1938 }
1940 # No difference ? Return time unchanged
1943 }
1946 # Generate an adjusted date; take advantage of the fact that mktime
1947 # will normalize out-of-range values so we don't have to split $minDiff
1948 # into hours and minutes.
1961 }
1963 /**
1964 * This is meant to be used by time(), date(), and timeanddate() to get
1965 * the date preference they're supposed to use, it should be used in
1966 * all children.
1967 *
1968 *<code>
1969 * function timeanddate([...], $format = true) {
1970 * $datePreference = $this->dateFormat($format);
1971 * [...]
1972 * }
1973 *</code>
1974 *
1975 * @param $usePrefs Mixed: if true, the user's preference is used
1976 * if false, the site/language default is used
1977 * if int/string, assumed to be a format.
1978 * @return string
1979 */
1988 }
1991 }
1993 // return int
1996 }
1999 }
2001 /**
2002 * Get a format string for a given type and preference
2003 * @param $type string May be date, time or both
2004 * @param $pref string The format name as it appears in Messages*.php
2005 *
2006 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2007 *
2008 * @return string
2009 */
2020 }
2025 }
2026 }
2028 }
2030 }
2032 /**
2033 * @param $ts Mixed: the time format which needs to be turned into a
2034 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2035 * @param $adj Bool: whether to adjust the time output according to the
2036 * user configured offset ($timecorrection)
2037 * @param $format Mixed: true to use user's date format preference
2038 * @param $timecorrection String|bool the time offset as returned by
2039 * validateTimeZone() in Special:Preferences
2040 * @return string
2041 */
2046 }
2049 }
2051 /**
2052 * @param $ts Mixed: the time format which needs to be turned into a
2053 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2054 * @param $adj Bool: whether to adjust the time output according to the
2055 * user configured offset ($timecorrection)
2056 * @param $format Mixed: true to use user's date format preference
2057 * @param $timecorrection String|bool the time offset as returned by
2058 * validateTimeZone() in Special:Preferences
2059 * @return string
2060 */
2065 }
2068 }
2070 /**
2071 * @param $ts Mixed: the time format which needs to be turned into a
2072 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2073 * @param $adj Bool: whether to adjust the time output according to the
2074 * user configured offset ($timecorrection)
2075 * @param $format Mixed: what format to return, if it's false output the
2076 * default one (default true)
2077 * @param $timecorrection String|bool the time offset as returned by
2078 * validateTimeZone() in Special:Preferences
2079 * @return string
2080 */
2085 }
2088 }
2090 /**
2091 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2092 *
2093 * @since 1.20
2094 *
2095 * @param integer $seconds The amount of seconds.
2096 * @param array $chosenIntervals The intervals to enable.
2097 *
2098 * @return string
2099 */
2106 // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2107 // duration-years, duration-decades, duration-centuries, duration-millennia
2110 }
2113 }
2115 /**
2116 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2117 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2118 *
2119 * @since 1.20
2120 *
2121 * @param integer $seconds The amount of seconds.
2122 * @param array $chosenIntervals The intervals to enable.
2123 *
2124 * @return array
2125 */
2128 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2129 }
2143 }
2144 }
2147 }
2149 /**
2150 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2151 *
2152 * @param $type String: can be 'date', 'time' or 'both'
2153 * @param $ts Mixed: the time format which needs to be turned into a
2154 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2155 * @param $user User object used to get preferences for timezone and format
2156 * @param $options Array, can contain the following keys:
2157 * - 'timecorrection': time correction, can have the following values:
2158 * - true: use user's preference
2159 * - false: don't use time correction
2160 * - integer: value of time correction in minutes
2161 * - 'format': format to use, can have the following values:
2162 * - true: use user's preference
2163 * - false: use default preference
2164 * - string: format to use
2165 * @since 1.19
2166 * @return String
2167 */
2176 }
2178 }
2183 }
2186 }
2188 /**
2189 * Get the formatted date for the given timestamp and formatted for
2190 * the given user.
2191 *
2192 * @param $ts Mixed: the time format which needs to be turned into a
2193 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2194 * @param $user User object used to get preferences for timezone and format
2195 * @param $options Array, can contain the following keys:
2196 * - 'timecorrection': time correction, can have the following values:
2197 * - true: use user's preference
2198 * - false: don't use time correction
2199 * - integer: value of time correction in minutes
2200 * - 'format': format to use, can have the following values:
2201 * - true: use user's preference
2202 * - false: use default preference
2203 * - string: format to use
2204 * @since 1.19
2205 * @return String
2206 */
2209 }
2211 /**
2212 * Get the formatted time for the given timestamp and formatted for
2213 * the given user.
2214 *
2215 * @param $ts Mixed: the time format which needs to be turned into a
2216 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2217 * @param $user User object used to get preferences for timezone and format
2218 * @param $options Array, can contain the following keys:
2219 * - 'timecorrection': time correction, can have the following values:
2220 * - true: use user's preference
2221 * - false: don't use time correction
2222 * - integer: value of time correction in minutes
2223 * - 'format': format to use, can have the following values:
2224 * - true: use user's preference
2225 * - false: use default preference
2226 * - string: format to use
2227 * @since 1.19
2228 * @return String
2229 */
2232 }
2234 /**
2235 * Get the formatted date and time for the given timestamp and formatted for
2236 * the given user.
2237 *
2238 * @param $ts Mixed: the time format which needs to be turned into a
2239 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2240 * @param $user User object used to get preferences for timezone and format
2241 * @param $options Array, can contain the following keys:
2242 * - 'timecorrection': time correction, can have the following values:
2243 * - true: use user's preference
2244 * - false: don't use time correction
2245 * - integer: value of time correction in minutes
2246 * - 'format': format to use, can have the following values:
2247 * - true: use user's preference
2248 * - false: use default preference
2249 * - string: format to use
2250 * @since 1.19
2251 * @return String
2252 */
2255 }
2257 /**
2258 * Convert an MWTimestamp into a pretty human-readable timestamp using
2259 * the given user preferences and relative base time.
2260 *
2261 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2262 * on your timestamp object, which will then call this function. Calling
2263 * this function directly will cause hooks to be skipped over.
2264 *
2265 * @see MWTimestamp::getHumanTimestamp
2266 * @param MWTimestamp $ts Timestamp to prettify
2267 * @param MWTimestamp $relativeTo Base timestamp
2268 * @param User $user User preferences to use
2269 * @return string Human timestamp
2270 * @since 1.22
2271 */
2274 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) - (int)$relativeTo->timestamp->format( 'w' ) );
2276 if ( $diff->invert || $days > 5 && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' ) ) {
2277 // Timestamps are in different years: use full timestamp
2278 // Also do full timestamp for future dates
2279 /**
2280 * @FIXME Add better handling of future timestamps.
2281 */
2285 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2289 // Timestamp within the past week: show the day of the week and time
2292 // Messages:
2293 // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2299 // Timestamp was yesterday: say 'yesterday' and the time.
2306 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2313 // From here on in, the timestamp was soon enough ago so that we can simply say
2314 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2316 // Less than 90 minutes, but more than an hour ago.
2319 // A few minutes ago.
2322 // Less than a minute, but more than 30 sec ago.
2325 // Less than 30 seconds ago.
2327 }
2330 }
2332 /**
2333 * @param $key string
2334 * @return array|null
2335 */
2338 }
2340 /**
2341 * @return array
2342 */
2345 }
2347 /**
2348 * @param $in
2349 * @param $out
2350 * @param $string
2351 * @return string
2352 */
2354 # This is a wrapper for iconv in all languages except esperanto,
2355 # which does some nasty x-conversions beforehand
2357 # Even with //IGNORE iconv can whine about illegal characters in
2358 # *input* string. We just ignore those too.
2359 # REF: http://bugs.php.net/bug.php?id=37166
2360 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2365 }
2367 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2369 /**
2370 * @param $matches array
2371 * @return mixed|string
2372 */
2375 }
2377 /**
2378 * @param $matches array
2379 * @return string
2380 */
2383 }
2385 /**
2386 * @param $matches array
2387 * @return string
2388 */
2392 }
2394 /**
2395 * @param $matches array
2396 * @return string
2397 */
2401 }
2403 /**
2404 * @param $matches array
2405 * @return string
2406 */
2409 }
2411 /**
2412 * @param $matches array
2413 * @return string
2414 */
2418 }
2420 /**
2421 * Make a string's first character uppercase
2422 *
2423 * @param $str string
2424 *
2425 * @return string
2426 */
2434 // fall back to more complex logic in case of multibyte strings
2436 }
2437 }
2439 /**
2440 * Convert a string to uppercase
2441 *
2442 * @param $str string
2443 * @param $first bool
2444 *
2445 * @return string
2446 */
2454 }
2457 }
2464 $str
2465 );
2468 }
2469 }
2470 }
2472 /**
2473 * @param $str string
2474 * @return mixed|string
2475 */
2487 }
2488 }
2490 /**
2491 * @param $str string
2492 * @param $first bool
2493 * @return mixed|string
2494 */
2502 }
2505 }
2512 $str
2513 );
2516 }
2517 }
2518 }
2520 /**
2521 * @param $str string
2522 * @return bool
2523 */
2526 }
2528 /**
2529 * @param $str string
2530 * @return mixed|string
2531 */
2536 // regexp to find first letter in each word (i.e. after each space)
2537 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2539 // function to use to capitalize a single char
2544 $str
2545 );
2550 $str
2551 );
2552 }
2555 }
2556 }
2558 /**
2559 * capitalize words at word breaks
2560 *
2561 * @param $str string
2562 * @return mixed
2563 */
2568 // since \b doesn't work for UTF-8, we explicitely define word break chars
2571 // find first letter after word break
2572 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2578 $str
2579 );
2584 $str
2585 );
2586 }
2591 $str
2592 );
2593 }
2594 }
2596 /**
2597 * Return a case-folded representation of $s
2598 *
2599 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2600 * and $s2 are the same except for the case of their characters. It is not
2601 * necessary for the value returned to make sense when displayed.
2602 *
2603 * Do *not* perform any other normalisation in this function. If a caller
2604 * uses this function when it should be using a more general normalisation
2605 * function, then fix the caller.
2606 *
2607 * @param $s string
2608 *
2609 * @return string
2610 */
2613 }
2615 /**
2616 * @param $s string
2617 * @return string
2618 */
2622 }
2625 }
2628 }
2630 /**
2631 * @return array
2632 */
2635 }
2637 /**
2638 * Most writing systems use whitespace to break up words.
2639 * Some languages such as Chinese don't conventionally do this,
2640 * which requires special handling when breaking up words for
2641 * searching etc.
2642 *
2643 * @return bool
2644 */
2647 }
2649 /**
2650 * Some languages such as Chinese require word segmentation,
2651 * Specify such segmentation when overridden in derived class.
2652 *
2653 * @param $string String
2654 * @return String
2655 */
2658 }
2660 /**
2661 * Some languages have special punctuation need to be normalized.
2662 * Make such changes here.
2663 *
2664 * @param $string String
2665 * @return String
2666 */
2669 }
2671 /**
2672 * convert double-width roman characters to single-width.
2673 * range: ff00-ff5f ~= 0020-007f
2674 *
2675 * @param $string string
2676 *
2677 * @return string
2678 */
2688 }
2692 }
2694 /**
2695 * @param $string string
2696 * @param $pattern string
2697 * @return string
2698 */
2703 }
2705 /**
2706 * @param $termsArray array
2707 * @return array
2708 */
2710 # some languages, e.g. Chinese, need to do a conversion
2711 # in order for search results to be displayed correctly
2713 }
2715 /**
2716 * Get the first character of a string.
2717 *
2718 * @param $s string
2719 * @return string
2720 */
2727 $matches
2728 );
2733 }
2735 // Break down Hangul syllables to grab the first jamo
2767 }
2770 }
2771 }
2774 # Some languages may have an alternate char encoding option
2775 # (Esperanto X-coding, Japanese furigana conversion, etc)
2776 # If this language is used as the primary content language,
2777 # an override to the defaults can be set here on startup.
2778 }
2780 /**
2781 * @param $s string
2782 * @return string
2783 */
2785 # For some languages we'll want to explicitly specify
2786 # which characters make it into the edit box raw
2787 # or are converted in some way or another.
2793 }
2794 }
2796 /**
2797 * @param $s string
2798 * @return string
2799 */
2801 # Take the previous into account.
2807 }
2812 }
2813 }
2815 /**
2816 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2817 * also cleans up certain backwards-compatible sequences, converting them
2818 * to the modern Unicode equivalent.
2819 *
2820 * This is language-specific for performance reasons only.
2821 *
2822 * @param $s string
2823 *
2824 * @return string
2825 */
2832 }
2835 }
2837 /**
2838 * Transform a string using serialized data stored in the given file (which
2839 * must be in the serialized subdirectory of $IP). The file contains pairs
2840 * mapping source characters to destination characters.
2841 *
2842 * The data is cached in process memory. This will go faster if you have the
2843 * FastStringSearch extension.
2844 *
2845 * @param $file string
2846 * @param $string string
2847 *
2848 * @throws MWException
2849 * @return string
2850 */
2856 }
2858 }
2860 }
2862 /**
2863 * For right-to-left language support
2864 *
2865 * @return bool
2866 */
2869 }
2871 /**
2872 * Return the correct HTML 'dir' attribute value for this language.
2873 * @return String
2874 */
2877 }
2879 /**
2880 * Return 'left' or 'right' as appropriate alignment for line-start
2881 * for this language's text direction.
2882 *
2883 * Should be equivalent to CSS3 'start' text-align value....
2884 *
2885 * @return String
2886 */
2889 }
2891 /**
2892 * Return 'right' or 'left' as appropriate alignment for line-end
2893 * for this language's text direction.
2894 *
2895 * Should be equivalent to CSS3 'end' text-align value....
2896 *
2897 * @return String
2898 */
2901 }
2903 /**
2904 * A hidden direction mark (LRM or RLM), depending on the language direction.
2905 * Unlike getDirMark(), this function returns the character as an HTML entity.
2906 * This function should be used when the output is guaranteed to be HTML,
2907 * because it makes the output HTML source code more readable. When
2908 * the output is plain text or can be escaped, getDirMark() should be used.
2909 *
2910 * @param $opposite Boolean Get the direction mark opposite to your language
2911 * @return string
2912 * @since 1.20
2913 */
2917 }
2919 }
2921 /**
2922 * A hidden direction mark (LRM or RLM), depending on the language direction.
2923 * This function produces them as invisible Unicode characters and
2924 * the output may be hard to read and debug, so it should only be used
2925 * when the output is plain text or can be escaped. When the output is
2926 * HTML, use getDirMarkEntity() instead.
2927 *
2928 * @param $opposite Boolean Get the direction mark opposite to your language
2929 * @return string
2930 */
2936 }
2938 }
2940 /**
2941 * @return array
2942 */
2945 }
2947 /**
2948 * An arrow, depending on the language direction.
2949 *
2950 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2951 * @return string
2952 */
2967 }
2968 }
2970 /**
2971 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2972 *
2973 * @return bool
2974 */
2977 }
2979 /**
2980 * Get all magic words from cache.
2981 * @return array
2982 */
2985 }
2987 /**
2988 * Run the LanguageGetMagic hook once.
2989 */
2993 }
2998 }
3000 /**
3001 * Fill a MagicWord object with data from here
3002 *
3003 * @param $mw
3004 */
3006 // Saves a function call
3009 }
3016 }
3023 }
3024 }
3026 /**
3027 * Add magic words to the extension array
3028 *
3029 * @param $newWords array
3030 */
3037 }
3038 }
3039 }
3041 /**
3042 * Get special page names, as an associative array
3043 * case folded alias => real name
3044 */
3046 // Cache aliases because it may be slow to load them
3048 // Initialise array
3053 }
3056 }
3058 /**
3059 * Italic is unsuitable for some languages
3060 *
3061 * @param $text String: the text to be emphasized.
3062 * @return string
3063 */
3066 }
3068 /**
3069 * Normally we output all numbers in plain en_US style, that is
3070 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3071 * point twohundredthirtyfive. However this is not suitable for all
3072 * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3073 * Icelandic just want to use commas instead of dots, and dots instead
3074 * of commas like "293.291,235".
3075 *
3076 * An example of this function being called:
3077 * <code>
3078 * wfMessage( 'message' )->numParams( $num )->text()
3079 * </code>
3080 *
3081 * See LanguageGu.php for the Gujarati implementation and
3082 * $separatorTransformTable on MessageIs.php for
3083 * the , => . and . => , implementation.
3084 *
3085 * @todo check if it's viable to use localeconv() for the decimal
3086 * separator thing.
3087 * @param $number Mixed: the string to be formatted, should be an integer
3088 * or a floating point number.
3089 * @param $nocommafy Bool: set to true for special numbers like dates
3090 * @return string
3091 */
3099 }
3100 }
3106 }
3107 }
3110 }
3112 /**
3113 * Front-end for non-commafied formatNum
3114 *
3115 * @param mixed $number the string to be formatted, should be an integer
3116 * or a floating point number.
3117 * @since 1.21
3118 * @return string
3119 */
3122 }
3124 /**
3125 * @param $number string
3126 * @return string
3127 */
3132 }
3137 }
3141 }
3143 /**
3144 * Adds commas to a given number
3145 * @since 1.19
3146 * @param $number mixed
3147 * @return string
3148 */
3153 }
3156 // default grouping is at thousands, use the same for ###,###,### pattern too.
3159 // Ref: http://cldr.unicode.org/translation/number-patterns
3162 // For negative numbers apply the algorithm like positive number and add sign.
3165 }
3173 // the string does not have any number part. Eg: .12345
3175 }
3183 }
3187 // use the last pattern for the rest of the number
3189 }
3192 }
3193 }
3195 }
3196 }
3198 /**
3199 * @return String
3200 */
3203 }
3205 /**
3206 * @return array
3207 */
3210 }
3212 /**
3213 * @return array
3214 */
3217 }
3219 /**
3220 * Take a list of strings and build a locale-friendly comma-separated
3221 * list, using the local comma-separator message.
3222 * The last two strings are chained with an "and".
3223 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3224 *
3225 * @param $l Array
3226 * @return string
3227 */
3232 }
3238 }
3239 }
3246 }
3247 }
3249 }
3251 /**
3252 * Take a list of strings and build a locale-friendly comma-separated
3253 * list, using the local comma-separator message.
3254 * @param $list array of strings to put in a comma list
3255 * @return string
3256 */
3260 $list
3261 );
3262 }
3264 /**
3265 * Take a list of strings and build a locale-friendly semicolon-separated
3266 * list, using the local semicolon-separator message.
3267 * @param $list array of strings to put in a semicolon list
3268 * @return string
3269 */
3273 $list
3274 );
3275 }
3277 /**
3278 * Same as commaList, but separate it with the pipe instead.
3279 * @param $list array of strings to put in a pipe list
3280 * @return string
3281 */
3285 $list
3286 );
3287 }
3289 /**
3290 * Truncate a string to a specified length in bytes, appending an optional
3291 * string (e.g. for ellipses)
3292 *
3293 * The database offers limited byte lengths for some columns in the database;
3294 * multi-byte character sets mean we need to ensure that only whole characters
3295 * are included, otherwise broken characters can be passed to the user
3296 *
3297 * If $length is negative, the string will be truncated from the beginning
3298 *
3299 * @param $string String to truncate
3300 * @param $length Int: maximum length (including ellipses)
3301 * @param $ellipsis String to append to the truncated text
3302 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3303 * $adjustLength was introduced in 1.18, before that behaved as if false.
3304 * @return string
3305 */
3307 # Use the localized ellipsis character
3310 }
3311 # Check if there is no need to truncate
3316 }
3318 # If ellipsis length is >= $length then we can't apply $adjustLength
3321 # Otherwise, truncate and add ellipsis...
3336 }
3337 }
3338 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3339 # This check is *not* redundant if $adjustLength, due to the single case where
3340 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3345 }
3346 }
3348 /**
3349 * Remove bytes that represent an incomplete Unicode character
3350 * at the end of string (e.g. bytes of the char are missing)
3351 *
3352 * @param $string String
3353 * @return string
3354 */
3360 # We got the first byte only of a multibyte char; remove it.
3365 ) {
3366 # We chopped in the middle of a character; remove it
3368 }
3369 }
3371 }
3373 /**
3374 * Remove bytes that represent an incomplete Unicode character
3375 * at the start of string (e.g. bytes of the char are missing)
3376 *
3377 * @param $string String
3378 * @return string
3379 */
3384 # We chopped in the middle of a character; remove the whole thing
3386 }
3387 }
3389 }
3391 /**
3392 * Truncate a string of valid HTML to a specified length in bytes,
3393 * appending an optional string (e.g. for ellipses), and return valid HTML
3394 *
3395 * This is only intended for styled/linked text, such as HTML with
3396 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3397 * Also, this will not detect things like "display:none" CSS.
3398 *
3399 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3400 *
3401 * @param string $text HTML string to truncate
3402 * @param int $length (zero/positive) Maximum length (including ellipses)
3403 * @param string $ellipsis String to append to the truncated text
3404 * @return string
3405 */
3407 # Use the localized ellipsis character
3410 }
3411 # Check if there is clearly no need to truncate
3416 }
3430 # Consider truncation once the display length has reached the maximim.
3431 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3432 # Check that we're not in the middle of a bracket/entity...
3436 # Save where we are; we will truncate here unless there turn out to
3437 # be so few remaining characters that truncation is not necessary.
3440 }
3442 # String in fact does need truncation, the truncation point was OK.
3447 }
3448 }
3451 }
3453 # Read the next char...
3471 }
3477 // Name found (e.g. "<a href=..."), add on tag attributes...
3479 }
3485 }
3488 // Save state without $ch. We want to *hit* the first
3489 // display char (to get tags) but not *use* it if truncating.
3491 }
3496 // Add the next $max display text chars after this in one swoop...
3501 }
3502 }
3503 }
3504 }
3505 // Close the last tag if left unclosed by bad HTML
3509 }
3511 }
3513 /**
3514 * truncateHtml() helper function
3515 * like strcspn() but adds the skipped chars to $ret
3516 *
3517 * @param $ret
3518 * @param $text
3519 * @param $search
3520 * @param $start
3521 * @param $len
3522 * @return int
3523 */
3529 }
3534 }
3536 }
3538 /**
3539 * truncateHtml() helper function
3540 * (a) push or pop $tag from $openTags as needed
3541 * (b) clear $tag value
3542 * @param &$tag string Current HTML tag name we are looking at
3543 * @param $tagType int (0-open tag, 1-close tag)
3544 * @param $lastCh string Character before the '>' that ended this tag
3545 * @param &$openTags array Open tag stack (not accounting for $tag)
3546 */
3555 }
3556 }
3558 }
3559 }
3561 /**
3562 * Grammatical transformations, needed for inflected languages
3563 * Invoked by putting {{grammar:case|word}} in a message
3564 *
3565 * @param $word string
3566 * @param $case string
3567 * @return string
3568 */
3573 }
3575 }
3576 /**
3577 * Get the grammar forms for the content language
3578 * @return array of grammar forms
3579 * @since 1.20
3580 */
3583 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3585 }
3587 }
3588 /**
3589 * Provides an alternative text depending on specified gender.
3590 * Usage {{gender:username|masculine|feminine|neutral}}.
3591 * username is optional, in which case the gender of current user is used,
3592 * but only in (some) interface messages; otherwise default gender is used.
3593 *
3594 * If no forms are given, an empty string is returned. If only one form is
3595 * given, it will be returned unconditionally. These details are implied by
3596 * the caller and cannot be overridden in subclasses.
3597 *
3598 * If more than one form is given, the default is to use the neutral one
3599 * if it is specified, and to use the masculine one otherwise. These
3600 * details can be overridden in subclasses.
3601 *
3602 * @param $gender string
3603 * @param $forms array
3604 *
3605 * @return string
3606 */
3610 }
3614 }
3617 }
3619 }
3621 /**
3622 * Plural form transformations, needed for some languages.
3623 * For example, there are 3 form of plural in Russian and Polish,
3624 * depending on "count mod 10". See [[w:Plural]]
3625 * For English it is pretty simple.
3626 *
3627 * Invoked by putting {{plural:count|wordform1|wordform2}}
3628 * or {{plural:count|wordform1|wordform2|wordform3}}
3629 *
3630 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3631 *
3632 * @param $count Integer: non-localized number
3633 * @param $forms Array: different plural forms
3634 * @return string Correct form of plural for $count in this language
3635 */
3637 // Handle explicit n=pluralform cases
3643 }
3645 }
3646 }
3651 }
3656 }
3658 /**
3659 * Checks that convertPlural was given an array and pads it to requested
3660 * amount of forms by copying the last one.
3661 *
3662 * @param $count Integer: How many forms should there be at least
3663 * @param $forms Array of forms given to convertPlural
3664 * @return array Padded array of forms or an exception if not an array
3665 */
3669 }
3671 }
3673 /**
3674 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3675 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3676 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3677 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3678 * match up with it.
3679 *
3680 * @param $str String: the validated block duration in English
3681 * @return string Somehow translated block duration
3682 * @see LanguageFi.php for example implementation
3683 */
3689 }
3690 }
3692 // Since usually only infinite or indefinite is only on list, so try
3693 // equivalents if still here.
3700 }
3701 }
3702 }
3704 // If all else fails, return a standard duration or timestamp description.
3709 // $time is relative to 0 so it's a duration length.
3713 // wfTimestamp() handles 0 as current time instead of epoch.
3717 }
3718 }
3719 }
3721 /**
3722 * languages like Chinese need to be segmented in order for the diff
3723 * to be of any use
3724 *
3725 * @param $text String
3726 * @return String
3727 */
3730 }
3732 /**
3733 * and unsegment to show the result
3734 *
3735 * @param $text String
3736 * @return String
3737 */
3740 }
3742 /**
3743 * Return the LanguageConverter used in the Language
3744 *
3745 * @since 1.19
3746 * @return LanguageConverter
3747 */
3750 }
3752 /**
3753 * convert text to all supported variants
3754 *
3755 * @param $text string
3756 * @return array
3757 */
3760 }
3762 /**
3763 * convert text to different variants of a language.
3764 *
3765 * @param $text string
3766 * @return string
3767 */
3770 }
3772 /**
3773 * Convert a Title object to a string in the preferred variant
3774 *
3775 * @param $title Title
3776 * @return string
3777 */
3780 }
3782 /**
3783 * Convert a namespace index to a string in the preferred variant
3784 *
3785 * @param $ns int
3786 * @return string
3787 */
3790 }
3792 /**
3793 * Check if this is a language with variants
3794 *
3795 * @return bool
3796 */
3799 }
3801 /**
3802 * Check if the language has the specific variant
3803 *
3804 * @since 1.19
3805 * @param $variant string
3806 * @return bool
3807 */
3810 }
3812 /**
3813 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3814 *
3815 * @param $text string
3816 * @return string
3817 * @deprecated since 1.22 is no longer used
3818 */
3821 }
3823 /**
3824 * Perform output conversion on a string, and encode for safe HTML output.
3825 * @param $text String text to be converted
3826 * @param $isTitle Bool whether this conversion is for the article title
3827 * @return string
3828 * @todo this should get integrated somewhere sane
3829 */
3832 }
3834 /**
3835 * @param $key string
3836 * @return string
3837 */
3840 }
3842 /**
3843 * Get the list of variants supported by this language
3844 * see sample implementation in LanguageZh.php
3845 *
3846 * @return array an array of language codes
3847 */
3850 }
3852 /**
3853 * @return string
3854 */
3857 }
3859 /**
3860 * @return string
3861 */
3864 }
3866 /**
3867 * @return string
3868 */
3871 }
3873 /**
3874 * If a language supports multiple variants, it is
3875 * possible that non-existing link in one variant
3876 * actually exists in another variant. this function
3877 * tries to find it. See e.g. LanguageZh.php
3878 *
3879 * @param $link String: the name of the link
3880 * @param $nt Mixed: the title object of the link
3881 * @param $ignoreOtherCond Boolean: to disable other conditions when
3882 * we need to transclude a template or update a category's link
3883 * @return null the input parameters may be modified upon return
3884 */
3887 }
3889 /**
3890 * If a language supports multiple variants, converts text
3891 * into an array of all possible variants of the text:
3892 * 'variant' => text in that variant
3893 *
3894 * @deprecated since 1.17 Use autoConvertToAllVariants()
3895 *
3896 * @param $text string
3897 *
3898 * @return string
3899 */
3902 }
3904 /**
3905 * returns language specific options used by User::getPageRenderHash()
3906 * for example, the preferred language variant
3907 *
3908 * @return string
3909 */
3912 }
3914 /**
3915 * For languages that support multiple variants, the title of an
3916 * article may be displayed differently in different variants. this
3917 * function returns the apporiate title defined in the body of the article.
3918 *
3919 * @return string
3920 */
3923 }
3925 /**
3926 * Prepare external link text for conversion. When the text is
3927 * a URL, it shouldn't be converted, and it'll be wrapped in
3928 * the "raw" tag (-{R| }-) to prevent conversion.
3929 *
3930 * This function is called "markNoConversion" for historical
3931 * reasons.
3932 *
3933 * @param $text String: text to be used for external link
3934 * @param $noParse bool: wrap it without confirming it's a real URL first
3935 * @return string the tagged text
3936 */
3938 // Excluding protocal-relative URLs may avoid many false positives.
3943 }
3944 }
3946 /**
3947 * A regular expression to match legal word-trailing characters
3948 * which should be merged onto a link of the form [[foo]]bar.
3949 *
3950 * @return string
3951 */
3954 }
3956 /**
3957 * A regular expression character set to match legal word-prefixing
3958 * characters which should be merged onto a link of the form foo[[bar]].
3959 *
3960 * @return string
3961 */
3964 }
3966 /**
3967 * @return Language
3968 */
3971 }
3973 /**
3974 * Get the "parent" language which has a converter to convert a "compatible" language
3975 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
3976 *
3977 * @return Language|null
3978 * @since 1.22
3979 */
3983 }
3990 }
3995 }
3999 }
4001 /**
4002 * Get the RFC 3066 code for this language object
4003 *
4004 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4005 * htmlspecialchars() or similar
4006 *
4007 * @return string
4008 */
4011 }
4013 /**
4014 * Get the code in Bcp47 format which we can use
4015 * inside of html lang="" tags.
4016 *
4017 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4018 * htmlspecialchars() or similar.
4019 *
4020 * @since 1.19
4021 * @return string
4022 */
4026 }
4028 }
4030 /**
4031 * @param $code string
4032 */
4035 // Ensure we don't leave incorrect cached data lying around
4038 }
4040 /**
4041 * Get the name of a file for a certain language code
4042 * @param $prefix string Prepend this to the filename
4043 * @param $code string Language code
4044 * @param $suffix string Append this to the filename
4045 * @throws MWException
4046 * @return string $prefix . $mangledCode . $suffix
4047 */
4049 // Protect against path traversal
4052 {
4054 }
4057 }
4059 /**
4060 * Get the language code from a file name. Inverse of getFileName()
4061 * @param $filename string $prefix . $languageCode . $suffix
4062 * @param $prefix string Prefix before the language code
4063 * @param $suffix string Suffix after the language code
4064 * @return string Language code, or false if $prefix or $suffix isn't found
4065 */
4066 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4072 }
4074 }
4076 /**
4077 * @param $code string
4078 * @return string
4079 */
4085 }
4087 /**
4088 * @param $code string
4089 * @return string
4090 */
4094 }
4096 /**
4097 * Get the first fallback for a given language.
4098 *
4099 * @param $code string
4100 *
4101 * @return bool|string
4102 */
4110 }
4111 }
4113 /**
4114 * Get the ordered list of fallback languages.
4115 *
4116 * @since 1.19
4117 * @param $code string Language code
4118 * @return array
4119 */
4128 }
4130 }
4131 }
4133 /**
4134 * Get the ordered list of fallback languages, ending with the fallback
4135 * language chain for the site language.
4136 *
4137 * @since 1.22
4138 * @param string $code Language code
4139 * @return array array( fallbacks, site fallbacks )
4140 */
4144 // Usually, we will only store a tiny number of fallback chains, so we
4145 // keep them in static memory.
4151 // Append the site's fallback chain, including the site language itself
4155 // Eliminate any languages already included in the chain
4159 }
4161 }
4163 /**
4164 * Get all messages for a given language
4165 * WARNING: this may take a long time. If you just need all message *keys*
4166 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4167 *
4168 * @param $code string
4169 *
4170 * @return array
4171 */
4174 }
4176 /**
4177 * Get a message for a given language
4178 *
4179 * @param $key string
4180 * @param $code string
4181 *
4182 * @return string
4183 */
4186 }
4188 /**
4189 * Get all message keys for a given language. This is a faster alternative to
4190 * array_keys( Language::getMessagesFor( $code ) )
4191 *
4192 * @since 1.19
4193 * @param $code string Language code
4194 * @return array of message keys (strings)
4195 */
4198 }
4200 /**
4201 * @param $talk
4202 * @return mixed
4203 */
4207 }
4212 # Allow grammar transformations
4213 # Allowing full message-style parsing would make simple requests
4214 # such as action=raw much more expensive than they need to be.
4215 # This will hopefully cover most cases.
4219 }
4221 /**
4222 * @param $m string
4223 * @return string
4224 */
4227 }
4229 /**
4230 * @throws MWException
4231 * @return array
4232 */
4237 }
4244 }
4249 }
4251 /**
4252 * Decode an expiry (block, protection, etc) which has come from the DB
4253 *
4254 * @todo FIXME: why are we returnings DBMS-dependent strings???
4255 *
4256 * @param $expiry String: Database expiry String
4257 * @param $format Bool|Int true to process using language functions, or TS_ constant
4258 * to return the expiry in a given timestamp
4259 * @return String
4260 * @since 1.18
4261 */
4266 }
4276 }
4277 }
4279 /**
4280 * @todo Document
4281 * @param $seconds int|float
4282 * @param $format Array Optional
4283 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4284 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4285 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4286 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4287 * @return string
4288 */
4292 }
4295 }
4298 }
4320 }
4331 }
4335 }
4341 }
4349 }
4359 }
4363 }
4373 }
4374 }
4376 }
4378 /**
4379 * Format a bitrate for output, using an appropriate
4380 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4381 *
4382 * This use base 1000. For base 1024 use formatSize(), for another base
4383 * see formatComputingNumbers()
4384 *
4385 * @param $bps int
4386 * @return string
4387 */
4390 }
4392 /**
4393 * @param $size int Size of the unit
4394 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4395 * @param $messageKey string Message key to be uesd
4396 * @return string
4397 */
4402 );
4403 }
4411 }
4413 // For small sizes no decimal places necessary
4416 // For MB and bigger two decimal places are smarter
4418 }
4424 }
4426 /**
4427 * Format a size in bytes for output, using an appropriate
4428 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4429 *
4430 * This method use base 1024. For base 1000 use formatBitrate(), for
4431 * another base see formatComputingNumbers()
4432 *
4433 * @param $size int Size to format
4434 * @return string Plain text (not HTML)
4435 */
4438 }
4440 /**
4441 * Make a list item, used by various special pages
4442 *
4443 * @param $page String Page link
4444 * @param $details String Text between brackets
4445 * @param $oppositedm Boolean Add the direction mark opposite to your
4446 * language, to display text properly
4447 * @return String
4448 */
4455 }
4457 /**
4458 * Generate (prev x| next x) (20|50|100...) type links for paging
4459 *
4460 * @param $title Title object to link
4461 * @param $offset Integer offset parameter
4462 * @param $limit Integer limit parameter
4463 * @param $query array|String optional URL query parameter string
4464 * @param $atend Bool optional param for specified if this is the last page
4465 * @return String
4466 */
4467 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4468 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4470 # Make 'previous' link
4471 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4477 }
4479 # Make 'next' link
4480 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4486 }
4488 # Make links to set number of items per page
4493 }
4497 }
4499 /**
4500 * Helper function for viewPrevNext() that generates links
4501 *
4502 * @param $title Title object to link
4503 * @param $offset Integer offset parameter
4504 * @param $limit Integer limit parameter
4505 * @param $query Array extra query parameters
4506 * @param $link String text to use for the link; will be escaped
4507 * @param $tooltipMsg String name of the message to use as tooltip
4508 * @param $class String value of the "class" attribute of the link
4509 * @return String HTML fragment
4510 */
4511 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4513 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4516 }
4518 /**
4519 * Get the conversion rule title, if any.
4520 *
4521 * @return string
4522 */
4525 }
4527 /**
4528 * Get the compiled plural rules for the language
4529 * @since 1.20
4530 * @return array Associative array with plural form, and plural rule as key-value pairs
4531 */
4537 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4540 }
4541 }
4542 }
4544 }
4546 /**
4547 * Get the plural rules for the language
4548 * @since 1.20
4549 * @return array Associative array with plural form number and plural rule as key-value pairs
4550 */
4559 }
4560 }
4561 }
4563 }
4565 /**
4566 * Get the plural rule types for the language
4567 * @since 1.22
4568 * @return array Associative array with plural form number and plural rule type as key-value pairs
4569 */
4575 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4578 }
4579 }
4580 }
4582 }
4584 /**
4585 * Find the index number of the plural rule appropriate for the given number
4586 * @return int The index number of the plural rule
4587 */
4592 }
4594 /**
4595 * Find the plural rule type appropriate for the given number
4596 * For example, if the language is set to Arabic, getPluralType(5) should
4597 * return 'few'.
4598 * @since 1.22
4599 * @return string The name of the plural rule type, e.g. one, two, few, many
4600 */
4608 }
4609 }
4610 }