| blob | 320688a319136d06fd76766a7a33f5ca2c2facd3 |
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 */
65 /** @deprecated since 1.22 is no longer used */
67 function validateVariant( $variant = null ) { return $variant === $this->mLang->getCode() ? $variant : null; }
69 }
71 /**
72 * Internationalisation code
73 * @ingroup Language
74 */
77 /**
78 * @var LanguageConverter
79 */
91 /**
92 * ReplacementArray object caches
93 */
96 /**
97 * @var LocalisationCache
98 */
106 );
110 );
115 'december'
116 );
120 'december-gen'
121 );
125 );
132 );
140 );
148 );
155 );
157 /**
158 * @since 1.20
159 * @var array
160 */
171 );
173 /**
174 * Cache for language fallbacks.
175 * @see Language::getFallbacksIncludingSiteLanguage
176 * @since 1.21
177 * @var array
178 */
181 /**
182 * Get a cached or new language object for a given language code
183 * @param $code String
184 * @return Language
185 */
191 }
193 // get the language object to process
198 // merge the language object in to get it up front in the cache
200 // get rid of the oldest ones in case we have an overflow
204 }
206 /**
207 * Create a language object for a given language code
208 * @param $code String
209 * @throws MWException
210 * @return Language
211 */
213 // Protect against path traversal below
216 ) {
218 }
221 // It's not possible to customise this code with class files, so
222 // just return a Language object. This is to support uselang= hacks.
226 }
228 // Check if there is a language class for the code
234 }
236 // Keep trying the fallback list until we find an existing class
241 }
249 }
250 }
253 }
255 /**
256 * Checks whether any localisation is available for that language tag
257 * in MediaWiki (MessagesXx.php exists).
258 *
259 * @param string $code Language tag (in lower case)
260 * @return bool Whether language is supported
261 * @since 1.21
262 */
265 }
267 /**
268 * Returns true if a language code string is a well-formed language tag
269 * according to RFC 5646.
270 * This function only checks well-formedness; it doesn't check that
271 * language, script or variant codes actually exist in the repositories.
272 *
273 * Based on regexes by Mark Davis of the Unicode Consortium:
274 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
275 *
276 * @param $code string
277 * @param $lenient boolean Whether to allow '_' as separator. The default is only '-'.
278 *
279 * @return bool
280 * @since 1.21
281 */
297 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
298 # Since these are limited, this is safe even later changes to the registry --
299 # the only oddity is that it might change the type of the tag, and thus
300 # the results from the capturing groups.
301 # http://www.iana.org/assignments/language-subtag-registry
319 # The final breakdown, with capturing groups for each of these components
320 # The variants, extensions, grandfathered, and private-use may have interior '-'
325 }
327 /**
328 * Returns true if a language code string is of a valid form, whether or
329 * not it exists. This includes codes which are used solely for
330 * customisation via the MediaWiki namespace.
331 *
332 * @param $code string
333 *
334 * @return bool
335 */
340 }
341 // People think language codes are html safe, so enforce it.
342 // Ideally we should only allow a-zA-Z0-9-
343 // but, .+ and other chars are often used for {{int:}} hacks
344 // see bugs 37564, 37587, 36938
350 }
352 /**
353 * Returns true if a language code is of a valid form for the purposes of
354 * internal customisation of MediaWiki, via Messages*.php.
355 *
356 * @param $code string
357 *
358 * @throws MWException
359 * @since 1.18
360 * @return bool
361 */
369 }
372 }
375 }
377 /**
378 * Returns true if a language code is an IETF tag known to MediaWiki.
379 *
380 * @param $code string
381 *
382 * @since 1.21
383 * @return bool
384 */
388 // Quick escape for invalid input to avoid exceptions down the line
389 // when code tries to process tags which are not valid at all.
392 }
397 }
401 ) {
403 }
406 }
408 /**
409 * @param $code
410 * @return String Name of the language class
411 */
417 }
418 }
420 /**
421 * Includes language class files
422 *
423 * @param $class string Name of the language class
424 */
430 }
434 }
435 }
437 /**
438 * Get the LocalisationCache instance
439 *
440 * @return LocalisationCache
441 */
447 }
449 }
453 // Set the code to the name of the descendant
458 }
460 }
462 /**
463 * Reduce memory usage
464 */
468 }
469 }
471 /**
472 * Hook which will be called if this is the content language.
473 * Descendants can use this to register hook functions or modify globals
474 */
477 /**
478 * Same as getFallbacksFor for current language.
479 * @return array|bool
480 * @deprecated in 1.19
481 */
485 }
487 /**
488 * @return array
489 * @since 1.19
490 */
493 }
495 /**
496 * Exports $wgBookstoreListEn
497 * @return array
498 */
501 }
503 /**
504 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
505 * available in localised form, it will be included in English.
506 *
507 * @return array
508 */
525 }
527 # Sometimes a language will be localised but not actually exist on this wiki.
531 }
532 }
534 # The above mixing may leave namespaces out of canonical order.
535 # Re-order by namespace ID number...
539 }
541 }
543 /**
544 * Arbitrarily set all of the namespace names at once. Mainly used for testing
545 * @param $namespaces Array of namespaces (id => name)
546 */
550 }
552 /**
553 * Resets all of the namespace caches. Mainly used for testing
554 */
559 }
561 /**
562 * A convenience function that returns the same thing as
563 * getNamespaces() except with the array values changed to ' '
564 * where it found '_', useful for producing output to be displayed
565 * e.g. in <select> forms.
566 *
567 * @return array
568 */
573 }
575 }
577 /**
578 * Get a namespace value by key
579 * <code>
580 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
581 * echo $mw_ns; // prints 'MediaWiki'
582 * </code>
583 *
584 * @param $index Int: the array key of the namespace to return
585 * @return mixed, string if the namespace value exists, otherwise false
586 */
590 }
592 /**
593 * A convenience function that returns the same thing as
594 * getNsText() except with '_' changed to ' ', useful for
595 * producing output.
596 *
597 * <code>
598 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
599 * echo $mw_ns; // prints 'MediaWiki talk'
600 * </code>
601 *
602 * @param int $index The array key of the namespace to return
603 * @return string Namespace name without underscores (empty string if namespace does not exist)
604 */
608 }
610 /**
611 * Returns gender-dependent namespace alias if available.
612 * @param $index Int: namespace index
613 * @param $gender String: gender key (male, female... )
614 * @return String
615 * @since 1.18
616 */
620 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
622 }
624 /**
625 * Whether this language makes distinguishes genders for example in
626 * namespaces.
627 * @return bool
628 * @since 1.18
629 */
633 // $wgExtraGenderNamespaces overrides everything
635 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
636 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
637 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
640 // Check what is in i18n files
643 }
644 }
646 /**
647 * Get a namespace key by value, case insensitive.
648 * Only matches namespace names for the current language, not the
649 * canonical ones defined in Namespace.php.
650 *
651 * @param $text String
652 * @return mixed An integer if $text is a valid value otherwise false
653 */
658 }
660 /**
661 * @return array
662 */
674 }
675 }
676 }
679 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
683 }
684 }
686 # Also add converted namespace names as aliases, to avoid confusion.
691 }
694 }
695 }
698 }
700 }
702 /**
703 * @return array
704 */
708 # Put namespace names and aliases into a hashtable.
709 # If this is too slow, then we should arrange it so that it is done
710 # before caching. The catch is that at pre-cache time, the above
711 # class-specific fixup hasn't been done.
715 }
718 }
722 }
723 }
724 }
726 }
728 /**
729 * Get a namespace key by value, case insensitive. Canonical namespace
730 * names override custom ones defined for the current language.
731 *
732 * @param $text String
733 * @return mixed An integer if $text is a valid value otherwise false
734 */
740 }
743 }
745 /**
746 * short names for language variants used for language conversion links.
747 *
748 * @param $code String
749 * @param $usemsg bool Use the "variantname-xyz" message if it exists
750 * @return string
751 */
756 }
761 # otherwise, output the language code
763 }
764 }
766 /**
767 * @param $name string
768 * @return string
769 */
774 }
776 }
778 /**
779 * @return array
780 */
783 }
785 /**
786 * @return array
787 */
790 }
792 /**
793 * @return array|string
794 */
802 }
803 }
805 /**
806 * @return array
807 */
810 }
812 /**
813 * @param $image
814 * @return array|null
815 */
818 }
820 /**
821 * @return array
822 */
825 }
827 /**
828 * @param $tog
829 * @return string
830 */
833 }
835 /**
836 * Get native language names, indexed by code.
837 * Only those defined in MediaWiki, no other data like CLDR.
838 * If $customisedOnly is true, only returns codes with a messages file
839 *
840 * @param $customisedOnly bool
841 *
842 * @return array
843 * @deprecated in 1.20, use fetchLanguageNames()
844 */
847 }
849 /**
850 * Get translated language names. This is done on best effort and
851 * by default this is exactly the same as Language::getLanguageNames.
852 * The CLDR extension provides translated names.
853 * @param $code String Language code.
854 * @return Array language code => language name
855 * @since 1.18.0
856 * @deprecated in 1.20, use fetchLanguageNames()
857 */
860 }
862 /**
863 * Get an array of language names, indexed by code.
864 * @param $inLanguage null|string: Code of language in which to return the names
865 * Use null for autonyms (native names)
866 * @param $include string:
867 * 'all' all available languages
868 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
869 * 'mwfile' only if the language is in 'mw' *and* has a message file
870 * @return array: language code => language name
871 * @since 1.20
872 */
880 }
885 # TODO: also include when $inLanguage is null, when this code is more efficient
887 }
891 # - Prefer own MediaWiki native name when not using the hook
892 # - For other names just add if not added through the hook
895 }
896 }
900 }
906 }
910 # We do this using a foreach over the codes instead of a directory
911 # loop so that messages files in extensions will work correctly.
915 }
916 }
918 }
919 # 'mw' option; default if it's not one of the other two options (all/mwfile)
921 }
923 /**
924 * @param $code string: The code of the language for which to get the name
925 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
926 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
927 * @return string: Language name or empty
928 * @since 1.20
929 */
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 * returns language specific options used by User::getPageRenderHash()
3909 * for example, the preferred language variant
3910 *
3911 * @return string
3912 */
3915 }
3917 /**
3918 * For languages that support multiple variants, the title of an
3919 * article may be displayed differently in different variants. this
3920 * function returns the apporiate title defined in the body of the article.
3921 *
3922 * @return string
3923 */
3926 }
3928 /**
3929 * Prepare external link text for conversion. When the text is
3930 * a URL, it shouldn't be converted, and it'll be wrapped in
3931 * the "raw" tag (-{R| }-) to prevent conversion.
3932 *
3933 * This function is called "markNoConversion" for historical
3934 * reasons.
3935 *
3936 * @param $text String: text to be used for external link
3937 * @param $noParse bool: wrap it without confirming it's a real URL first
3938 * @return string the tagged text
3939 */
3941 // Excluding protocal-relative URLs may avoid many false positives.
3946 }
3947 }
3949 /**
3950 * A regular expression to match legal word-trailing characters
3951 * which should be merged onto a link of the form [[foo]]bar.
3952 *
3953 * @return string
3954 */
3957 }
3959 /**
3960 * A regular expression character set to match legal word-prefixing
3961 * characters which should be merged onto a link of the form foo[[bar]].
3962 *
3963 * @return string
3964 */
3967 }
3969 /**
3970 * @return Language
3971 */
3974 }
3976 /**
3977 * Get the "parent" language which has a converter to convert a "compatible" language
3978 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
3979 *
3980 * @return Language|null
3981 * @since 1.22
3982 */
3986 }
3993 }
3998 }
4002 }
4004 /**
4005 * Get the RFC 3066 code for this language object
4006 *
4007 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4008 * htmlspecialchars() or similar
4009 *
4010 * @return string
4011 */
4014 }
4016 /**
4017 * Get the code in Bcp47 format which we can use
4018 * inside of html lang="" tags.
4019 *
4020 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4021 * htmlspecialchars() or similar.
4022 *
4023 * @since 1.19
4024 * @return string
4025 */
4029 }
4031 }
4033 /**
4034 * @param $code string
4035 */
4038 // Ensure we don't leave incorrect cached data lying around
4041 }
4043 /**
4044 * Get the name of a file for a certain language code
4045 * @param $prefix string Prepend this to the filename
4046 * @param $code string Language code
4047 * @param $suffix string Append this to the filename
4048 * @throws MWException
4049 * @return string $prefix . $mangledCode . $suffix
4050 */
4052 // Protect against path traversal
4055 ) {
4057 }
4060 }
4062 /**
4063 * Get the language code from a file name. Inverse of getFileName()
4064 * @param $filename string $prefix . $languageCode . $suffix
4065 * @param $prefix string Prefix before the language code
4066 * @param $suffix string Suffix after the language code
4067 * @return string Language code, or false if $prefix or $suffix isn't found
4068 */
4069 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4075 }
4077 }
4079 /**
4080 * @param $code string
4081 * @return string
4082 */
4088 }
4090 /**
4091 * @param $code string
4092 * @return string
4093 */
4097 }
4099 /**
4100 * Get the first fallback for a given language.
4101 *
4102 * @param $code string
4103 *
4104 * @return bool|string
4105 */
4113 }
4114 }
4116 /**
4117 * Get the ordered list of fallback languages.
4118 *
4119 * @since 1.19
4120 * @param $code string Language code
4121 * @return array
4122 */
4131 }
4133 }
4134 }
4136 /**
4137 * Get the ordered list of fallback languages, ending with the fallback
4138 * language chain for the site language.
4139 *
4140 * @since 1.22
4141 * @param string $code Language code
4142 * @return array array( fallbacks, site fallbacks )
4143 */
4147 // Usually, we will only store a tiny number of fallback chains, so we
4148 // keep them in static memory.
4154 // Append the site's fallback chain, including the site language itself
4158 // Eliminate any languages already included in the chain
4162 }
4164 }
4166 /**
4167 * Get all messages for a given language
4168 * WARNING: this may take a long time. If you just need all message *keys*
4169 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4170 *
4171 * @param $code string
4172 *
4173 * @return array
4174 */
4177 }
4179 /**
4180 * Get a message for a given language
4181 *
4182 * @param $key string
4183 * @param $code string
4184 *
4185 * @return string
4186 */
4189 }
4191 /**
4192 * Get all message keys for a given language. This is a faster alternative to
4193 * array_keys( Language::getMessagesFor( $code ) )
4194 *
4195 * @since 1.19
4196 * @param $code string Language code
4197 * @return array of message keys (strings)
4198 */
4201 }
4203 /**
4204 * @param $talk
4205 * @return mixed
4206 */
4210 }
4215 # Allow grammar transformations
4216 # Allowing full message-style parsing would make simple requests
4217 # such as action=raw much more expensive than they need to be.
4218 # This will hopefully cover most cases.
4222 }
4224 /**
4225 * @param $m string
4226 * @return string
4227 */
4230 }
4232 /**
4233 * @throws MWException
4234 * @return array
4235 */
4240 }
4247 }
4252 }
4254 /**
4255 * Decode an expiry (block, protection, etc) which has come from the DB
4256 *
4257 * @todo FIXME: why are we returnings DBMS-dependent strings???
4258 *
4259 * @param $expiry String: Database expiry String
4260 * @param $format Bool|Int true to process using language functions, or TS_ constant
4261 * to return the expiry in a given timestamp
4262 * @return String
4263 * @since 1.18
4264 */
4269 }
4279 }
4280 }
4282 /**
4283 * @todo Document
4284 * @param $seconds int|float
4285 * @param $format Array Optional
4286 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4287 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4288 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4289 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4290 * @return string
4291 */
4295 }
4298 }
4301 }
4323 }
4334 }
4338 }
4344 }
4352 }
4362 }
4366 }
4376 }
4377 }
4379 }
4381 /**
4382 * Format a bitrate for output, using an appropriate
4383 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4384 *
4385 * This use base 1000. For base 1024 use formatSize(), for another base
4386 * see formatComputingNumbers()
4387 *
4388 * @param $bps int
4389 * @return string
4390 */
4393 }
4395 /**
4396 * @param $size int Size of the unit
4397 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4398 * @param $messageKey string Message key to be uesd
4399 * @return string
4400 */
4405 );
4406 }
4414 }
4416 // For small sizes no decimal places necessary
4419 // For MB and bigger two decimal places are smarter
4421 }
4427 }
4429 /**
4430 * Format a size in bytes for output, using an appropriate
4431 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4432 *
4433 * This method use base 1024. For base 1000 use formatBitrate(), for
4434 * another base see formatComputingNumbers()
4435 *
4436 * @param $size int Size to format
4437 * @return string Plain text (not HTML)
4438 */
4441 }
4443 /**
4444 * Make a list item, used by various special pages
4445 *
4446 * @param $page String Page link
4447 * @param $details String Text between brackets
4448 * @param $oppositedm Boolean Add the direction mark opposite to your
4449 * language, to display text properly
4450 * @return String
4451 */
4458 }
4460 /**
4461 * Generate (prev x| next x) (20|50|100...) type links for paging
4462 *
4463 * @param $title Title object to link
4464 * @param $offset Integer offset parameter
4465 * @param $limit Integer limit parameter
4466 * @param $query array|String optional URL query parameter string
4467 * @param $atend Bool optional param for specified if this is the last page
4468 * @return String
4469 */
4470 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4471 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4473 # Make 'previous' link
4474 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4480 }
4482 # Make 'next' link
4483 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4489 }
4491 # Make links to set number of items per page
4496 }
4500 }
4502 /**
4503 * Helper function for viewPrevNext() that generates links
4504 *
4505 * @param $title Title object to link
4506 * @param $offset Integer offset parameter
4507 * @param $limit Integer limit parameter
4508 * @param $query Array extra query parameters
4509 * @param $link String text to use for the link; will be escaped
4510 * @param $tooltipMsg String name of the message to use as tooltip
4511 * @param $class String value of the "class" attribute of the link
4512 * @return String HTML fragment
4513 */
4514 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4516 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4519 }
4521 /**
4522 * Get the conversion rule title, if any.
4523 *
4524 * @return string
4525 */
4528 }
4530 /**
4531 * Get the compiled plural rules for the language
4532 * @since 1.20
4533 * @return array Associative array with plural form, and plural rule as key-value pairs
4534 */
4540 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4543 }
4544 }
4545 }
4547 }
4549 /**
4550 * Get the plural rules for the language
4551 * @since 1.20
4552 * @return array Associative array with plural form number and plural rule as key-value pairs
4553 */
4562 }
4563 }
4564 }
4566 }
4568 /**
4569 * Get the plural rule types for the language
4570 * @since 1.22
4571 * @return array Associative array with plural form number and plural rule type as key-value pairs
4572 */
4578 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4581 }
4582 }
4583 }
4585 }
4587 /**
4588 * Find the index number of the plural rule appropriate for the given number
4589 * @return int The index number of the plural rule
4590 */
4595 }
4597 /**
4598 * Find the plural rule type appropriate for the given number
4599 * For example, if the language is set to Arabic, getPluralType(5) should
4600 * return 'few'.
4601 * @since 1.22
4602 * @return string The name of the plural rule type, e.g. one, two, few, many
4603 */
4611 }
4612 }
4613 }