| blob | 2523814d35f2736ed7ec5b0028a4046bae587141 |
1 <?php
2 /**
3 * Internationalisation code.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
19 *
20 * @file
21 * @ingroup Language
22 */
24 /**
25 * @defgroup Language Language
26 */
31 }
33 # Read language names
39 }
41 /**
42 * a fake language converter
43 *
44 * @ingroup Language
45 */
47 /**
48 * @var Language
49 */
69 }
71 /**
72 * Internationalisation code
73 * @ingroup Language
74 */
77 /**
78 * @var LanguageConverter
79 */
91 /**
92 * ReplacementArray object caches
93 */
96 /**
97 * @var LocalisationCache
98 */
106 );
110 );
115 'december'
116 );
120 'december-gen'
121 );
125 );
132 );
140 );
148 );
155 );
157 /**
158 * @since 1.20
159 * @var array
160 */
171 );
173 /**
174 * Cache for language fallbacks.
175 * @see Language::getFallbacksIncludingSiteLanguage
176 * @since 1.21
177 * @var array
178 */
181 /**
182 * Get a cached or new language object for a given language code
183 * @param $code String
184 * @return Language
185 */
191 }
193 // get the language object to process
198 // merge the language object in to get it up front in the cache
200 // get rid of the oldest ones in case we have an overflow
204 }
206 /**
207 * Create a language object for a given language code
208 * @param $code String
209 * @throws MWException
210 * @return Language
211 */
213 // Protect against path traversal below
216 {
218 }
221 // It's not possible to customise this code with class files, so
222 // just return a Language object. This is to support uselang= hacks.
226 }
228 // Check if there is a language class for the code
234 }
236 // Keep trying the fallback list until we find an existing class
241 }
249 }
250 }
253 }
255 /**
256 * Checks whether any localisation is available for that language tag
257 * in MediaWiki (MessagesXx.php exists).
258 *
259 * @param string $code Language tag (in lower case)
260 * @return bool Whether language is supported
261 * @since 1.21
262 */
265 }
267 /**
268 * Returns true if a language code string is a well-formed language tag
269 * according to RFC 5646.
270 * This function only checks well-formedness; it doesn't check that
271 * language, script or variant codes actually exist in the repositories.
272 *
273 * Based on regexes by Mark Davis of the Unicode Consortium:
274 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
275 *
276 * @param $code string
277 * @param $lenient boolean Whether to allow '_' as separator. The default is only '-'.
278 *
279 * @return bool
280 * @since 1.21
281 */
297 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
298 # Since these are limited, this is safe even later changes to the registry --
299 # the only oddity is that it might change the type of the tag, and thus
300 # the results from the capturing groups.
301 # http://www.iana.org/assignments/language-subtag-registry
319 # The final breakdown, with capturing groups for each of these components
320 # The variants, extensions, grandfathered, and private-use may have interior '-'
325 }
327 /**
328 * Returns true if a language code string is of a valid form, whether or
329 * not it exists. This includes codes which are used solely for
330 * customisation via the MediaWiki namespace.
331 *
332 * @param $code string
333 *
334 * @return bool
335 */
340 }
341 // People think language codes are html safe, so enforce it.
342 // Ideally we should only allow a-zA-Z0-9-
343 // but, .+ and other chars are often used for {{int:}} hacks
344 // see bugs 37564, 37587, 36938
350 }
352 /**
353 * Returns true if a language code is of a valid form for the purposes of
354 * internal customisation of MediaWiki, via Messages*.php.
355 *
356 * @param $code string
357 *
358 * @throws MWException
359 * @since 1.18
360 * @return bool
361 */
369 }
372 }
375 }
377 /**
378 * Returns true if a language code is an IETF tag known to MediaWiki.
379 *
380 * @param $code string
381 *
382 * @since 1.21
383 * @return bool
384 */
388 // Quick escape for invalid input to avoid exceptions down the line
389 // when code tries to process tags which are not valid at all.
392 }
396 }
400 ) {
402 }
405 }
407 /**
408 * @param $code
409 * @return String Name of the language class
410 */
416 }
417 }
419 /**
420 * Includes language class files
421 *
422 * @param $class string Name of the language class
423 */
429 }
433 }
434 }
436 /**
437 * Get the LocalisationCache instance
438 *
439 * @return LocalisationCache
440 */
446 }
448 }
452 // Set the code to the name of the descendant
457 }
459 }
461 /**
462 * Reduce memory usage
463 */
467 }
468 }
470 /**
471 * Hook which will be called if this is the content language.
472 * Descendants can use this to register hook functions or modify globals
473 */
476 /**
477 * Same as getFallbacksFor for current language.
478 * @return array|bool
479 * @deprecated in 1.19
480 */
484 }
486 /**
487 * @return array
488 * @since 1.19
489 */
492 }
494 /**
495 * Exports $wgBookstoreListEn
496 * @return array
497 */
500 }
502 /**
503 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
504 * available in localised form, it will be included in English.
505 *
506 * @return array
507 */
524 }
526 # Sometimes a language will be localised but not actually exist on this wiki.
530 }
531 }
533 # The above mixing may leave namespaces out of canonical order.
534 # Re-order by namespace ID number...
538 }
540 }
542 /**
543 * Arbitrarily set all of the namespace names at once. Mainly used for testing
544 * @param $namespaces Array of namespaces (id => name)
545 */
549 }
551 /**
552 * Resets all of the namespace caches. Mainly used for testing
553 */
558 }
560 /**
561 * A convenience function that returns the same thing as
562 * getNamespaces() except with the array values changed to ' '
563 * where it found '_', useful for producing output to be displayed
564 * e.g. in <select> forms.
565 *
566 * @return array
567 */
572 }
574 }
576 /**
577 * Get a namespace value by key
578 * <code>
579 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
580 * echo $mw_ns; // prints 'MediaWiki'
581 * </code>
582 *
583 * @param $index Int: the array key of the namespace to return
584 * @return mixed, string if the namespace value exists, otherwise false
585 */
589 }
591 /**
592 * A convenience function that returns the same thing as
593 * getNsText() except with '_' changed to ' ', useful for
594 * producing output.
595 *
596 * <code>
597 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
598 * echo $mw_ns; // prints 'MediaWiki talk'
599 * </code>
600 *
601 * @param int $index The array key of the namespace to return
602 * @return string Namespace name without underscores (empty string if namespace does not exist)
603 */
607 }
609 /**
610 * Returns gender-dependent namespace alias if available.
611 * @param $index Int: namespace index
612 * @param $gender String: gender key (male, female... )
613 * @return String
614 * @since 1.18
615 */
619 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
621 }
623 /**
624 * Whether this language makes distinguishes genders for example in
625 * namespaces.
626 * @return bool
627 * @since 1.18
628 */
632 // $wgExtraGenderNamespaces overrides everything
634 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
635 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
636 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
639 // Check what is in i18n files
642 }
643 }
645 /**
646 * Get a namespace key by value, case insensitive.
647 * Only matches namespace names for the current language, not the
648 * canonical ones defined in Namespace.php.
649 *
650 * @param $text String
651 * @return mixed An integer if $text is a valid value otherwise false
652 */
657 }
659 /**
660 * @return array
661 */
673 }
674 }
675 }
678 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
682 }
683 }
686 }
688 }
690 /**
691 * @return array
692 */
696 # Put namespace names and aliases into a hashtable.
697 # If this is too slow, then we should arrange it so that it is done
698 # before caching. The catch is that at pre-cache time, the above
699 # class-specific fixup hasn't been done.
703 }
706 }
710 }
711 }
712 }
714 }
716 /**
717 * Get a namespace key by value, case insensitive. Canonical namespace
718 * names override custom ones defined for the current language.
719 *
720 * @param $text String
721 * @return mixed An integer if $text is a valid value otherwise false
722 */
728 }
731 }
733 /**
734 * short names for language variants used for language conversion links.
735 *
736 * @param $code String
737 * @param $usemsg bool Use the "variantname-xyz" message if it exists
738 * @return string
739 */
744 }
749 # otherwise, output the language code
751 }
752 }
754 /**
755 * @param $name string
756 * @return string
757 */
762 }
764 }
766 /**
767 * @return array
768 */
771 }
773 /**
774 * @return array
775 */
778 }
780 /**
781 * @return array|string
782 */
790 }
791 }
793 /**
794 * @return array
795 */
798 }
800 /**
801 * @param $image
802 * @return array|null
803 */
806 }
808 /**
809 * @return array
810 */
813 }
815 /**
816 * @param $tog
817 * @return string
818 */
821 }
823 /**
824 * Get native language names, indexed by code.
825 * Only those defined in MediaWiki, no other data like CLDR.
826 * If $customisedOnly is true, only returns codes with a messages file
827 *
828 * @param $customisedOnly bool
829 *
830 * @return array
831 * @deprecated in 1.20, use fetchLanguageNames()
832 */
835 }
837 /**
838 * Get translated language names. This is done on best effort and
839 * by default this is exactly the same as Language::getLanguageNames.
840 * The CLDR extension provides translated names.
841 * @param $code String Language code.
842 * @return Array language code => language name
843 * @since 1.18.0
844 * @deprecated in 1.20, use fetchLanguageNames()
845 */
848 }
850 /**
851 * Get an array of language names, indexed by code.
852 * @param $inLanguage null|string: Code of language in which to return the names
853 * Use null for autonyms (native names)
854 * @param $include string:
855 * 'all' all available languages
856 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
857 * 'mwfile' only if the language is in 'mw' *and* has a message file
858 * @return array: language code => language name
859 * @since 1.20
860 */
867 }
872 # TODO: also include when $inLanguage is null, when this code is more efficient
874 }
878 # - Prefer own MediaWiki native name when not using the hook
879 # - For other names just add if not added through the hook
882 }
883 }
887 }
893 }
897 # We do this using a foreach over the codes instead of a directory
898 # loop so that messages files in extensions will work correctly.
902 }
903 }
905 }
906 # 'mw' option; default if it's not one of the other two options (all/mwfile)
908 }
910 /**
911 * @param $code string: The code of the language for which to get the name
912 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
913 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
914 * @return string: Language name or empty
915 * @since 1.20
916 */
920 }
922 /**
923 * Get a message from the MediaWiki namespace.
924 *
925 * @param $msg String: message name
926 * @return string
927 */
930 }
932 /**
933 * Get the native language name of $code.
934 * Only if defined in MediaWiki, no other data like CLDR.
935 * @param $code string
936 * @return string
937 * @deprecated in 1.20, use fetchLanguageName()
938 */
941 }
943 /**
944 * @param $key string
945 * @return string
946 */
949 }
951 /**
952 * @return array
953 */
958 }
960 }
962 /**
963 * @param $key string
964 * @return string
965 */
968 }
970 /**
971 * @param $key string
972 * @return string
973 */
976 }
978 /**
979 * @return array
980 */
985 }
987 }
989 /**
990 * @param $key string
991 * @return string
992 */
995 }
997 /**
998 * @param $key string
999 * @return string
1000 */
1003 }
1005 /**
1006 * @param $key string
1007 * @return string
1008 */
1011 }
1013 /**
1014 * @param $key string
1015 * @return string
1016 */
1019 }
1021 /**
1022 * @param $key string
1023 * @return string
1024 */
1027 }
1029 /**
1030 * @param $key string
1031 * @return string
1032 */
1035 }
1037 /**
1038 * This is a workalike of PHP's date() function, but with better
1039 * internationalisation, a reduced set of format characters, and a better
1040 * escaping format.
1041 *
1042 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1043 * the PHP manual for definitions. There are a number of extensions, which
1044 * start with "x":
1045 *
1046 * xn Do not translate digits of the next numeric format character
1047 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1048 * xr Use roman numerals for the next numeric format character
1049 * xh Use hebrew numerals for the next numeric format character
1050 * xx Literal x
1051 * xg Genitive month name
1052 *
1053 * xij j (day number) in Iranian calendar
1054 * xiF F (month name) in Iranian calendar
1055 * xin n (month number) in Iranian calendar
1056 * xiy y (two digit year) in Iranian calendar
1057 * xiY Y (full year) in Iranian calendar
1058 *
1059 * xjj j (day number) in Hebrew calendar
1060 * xjF F (month name) in Hebrew calendar
1061 * xjt t (days in month) in Hebrew calendar
1062 * xjx xg (genitive month name) in Hebrew calendar
1063 * xjn n (month number) in Hebrew calendar
1064 * xjY Y (full year) in Hebrew calendar
1065 *
1066 * xmj j (day number) in Hijri calendar
1067 * xmF F (month name) in Hijri calendar
1068 * xmn n (month number) in Hijri calendar
1069 * xmY Y (full year) in Hijri calendar
1070 *
1071 * xkY Y (full year) in Thai solar calendar. Months and days are
1072 * identical to the Gregorian calendar
1073 * xoY Y (full year) in Minguo calendar or Juche year.
1074 * Months and days are identical to the
1075 * Gregorian calendar
1076 * xtY Y (full year) in Japanese nengo. Months and days are
1077 * identical to the Gregorian calendar
1078 *
1079 * Characters enclosed in double quotes will be considered literal (with
1080 * the quotes themselves removed). Unmatched quotes will be considered
1081 * literal quotes. Example:
1082 *
1083 * "The month is" F => The month is January
1084 * i's" => 20'11"
1085 *
1086 * Backslash escaping is also supported.
1087 *
1088 * Input timestamp is assumed to be pre-normalized to the desired local
1089 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1090 * $ts is UTC if $zone is not given.
1091 *
1092 * @param $format String
1093 * @param $ts String: 14-character timestamp
1094 * YYYYMMDDHHMMSS
1095 * 01234567890123
1096 * @param $zone DateTimeZone: Timezone of $ts
1097 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1098 *
1099 * @throws MWException
1100 * @return string
1101 */
1118 }
1122 }
1129 }
1131 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1133 }
1157 }
1167 );
1168 }
1177 }
1183 }
1189 }
1196 );
1197 }
1206 }
1212 }
1218 }
1233 }
1239 }
1245 }
1251 }
1260 }
1266 }
1272 }
1278 }
1284 }
1290 }
1299 }
1334 // Pass through string from $dateTimeObj->format()
1338 );
1339 }
1352 // Pass through number from $dateTimeObj->format()
1356 );
1357 }
1361 # Backslash escaping
1366 }
1369 # Quoted literal
1373 # No terminating quote, assume literal "
1378 }
1380 # Quote at end of string, assume literal "
1382 }
1386 }
1399 }
1400 }
1401 }
1403 }
1408 /**
1409 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1410 * Gregorian dates to Iranian dates. Originally written in C, it
1411 * is released under the terms of GNU Lesser General Public
1412 * License. Conversion to PHP was performed by Niklas Laxström.
1413 *
1414 * Link: http://www.farsiweb.info/jalali/jalali.c
1415 *
1416 * @param $ts string
1417 *
1418 * @return string
1419 */
1425 # Days passed from the beginning (including leap years)
1431 // Add days of the past months of this year
1434 }
1436 // Leap years
1439 }
1441 // Days passed in current month
1455 }
1459 }
1465 }
1467 /**
1468 * Converting Gregorian dates to Hijri dates.
1469 *
1470 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1471 *
1472 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1473 *
1474 * @param $ts string
1475 *
1476 * @return string
1477 */
1491 )
1492 {
1500 }
1505 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1506 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1512 }
1514 /**
1515 * Converting Gregorian dates to Hebrew dates.
1516 *
1517 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1518 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1519 * to translate the relevant functions into PHP and release them under
1520 * GNU GPL.
1521 *
1522 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1523 * and Adar II is 14. In a non-leap year, Adar is 6.
1524 *
1525 * @param $ts string
1526 *
1527 * @return string
1528 */
1530 # Parse date
1535 # Calculate Hebrew year
1538 # Month number when September = 1, August = 12
1541 # Next year
1545 }
1547 # Calculate day of year from 1 September
1551 # February
1553 # Check if the year is leap
1556 }
1561 }
1562 }
1564 # Calculate the start of the Hebrew year
1567 # Calculate next year's start
1569 # Day is before the start of the year - it is the previous year
1570 # Next year's start
1572 # Previous year
1575 # Add days since previous year's 1 September
1578 # Leap year
1580 }
1581 # Start of the new (previous) year
1584 # Next year's start
1586 }
1588 # Calculate Hebrew day of year
1591 # Difference between year's days
1593 # Add 12 (or 13 for leap years) days to ignore the difference between
1594 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1595 # difference is only about the year type
1600 }
1602 # Check the year pattern, and is leap year
1603 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1604 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1605 # and non-leap years
1607 # Check if leap year
1610 # Calculate day in the month from number of day in the Hebrew year
1611 # Don't check Adar - if the day is not in Adar, we will stop before;
1612 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1617 # Calculate days in this month
1619 # Adar in a leap year
1621 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1624 # Day in Adar I
1627 # Subtract the days of Adar I
1629 # Try Adar II
1632 # Day in Adar II
1634 }
1635 }
1636 }
1638 # Cheshvan in a complete year (otherwise as the rule below)
1641 # Kislev in an incomplete year (otherwise as the rule below)
1644 # Odd months have 30 days, even have 29
1646 }
1648 # In the current month
1651 # Subtract the days of the current month
1653 # Try in the next month
1655 }
1656 }
1659 }
1661 /**
1662 * This calculates the Hebrew year start, as days since 1 September.
1663 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1664 * Used for Hebrew date.
1665 *
1666 * @param $year int
1667 *
1668 * @return string
1669 */
1676 }
1680 }
1690 }
1694 }
1696 /**
1697 * Algorithm to convert Gregorian dates to Thai solar dates,
1698 * Minguo dates or Minguo dates.
1699 *
1700 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1701 * http://en.wikipedia.org/wiki/Minguo_calendar
1702 * http://en.wikipedia.org/wiki/Japanese_era_name
1703 *
1704 * @param $ts String: 14-character timestamp
1705 * @param $cName String: calender name
1706 * @return Array: converted year, month, day
1707 */
1714 # Thai solar dates
1715 # Add 543 years to the Gregorian calendar
1716 # Months and days are identical
1719 # Minguo dates
1720 # Deduct 1911 years from the Gregorian calendar
1721 # Months and days are identical
1724 # Nengō dates up to Meiji period
1725 # Deduct years from the Gregorian calendar
1726 # depending on the nengo periods
1727 # Months and days are identical
1728 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1729 # Meiji period
1734 }
1742 )
1743 {
1744 # Taishō period
1749 }
1755 )
1756 {
1757 # Shōwa period
1762 }
1765 # Heisei period
1770 }
1772 }
1775 }
1778 }
1780 /**
1781 * Roman number formatting up to 10000
1782 *
1783 * @param $num int
1784 *
1785 * @return string
1786 */
1792 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1793 );
1798 }
1804 }
1806 }
1808 }
1810 /**
1811 * Hebrew Gematria number formatting up to 9999
1812 *
1813 * @param $num int
1814 *
1815 * @return string
1816 */
1823 );
1828 }
1840 }
1841 }
1842 }
1844 }
1850 }
1869 }
1871 }
1873 /**
1874 * Used by date() and time() to adjust the time output.
1875 *
1876 * @param $ts Int the time in date('YmdHis') format
1877 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1878 * get user timecorrection setting)
1879 * @return int
1880 */
1886 }
1899 }
1900 # Unrecognized timezone, default to 'Offset' with the stored offset.
1902 }
1906 # Global offset in minutes.
1909 }
1920 }
1923 }
1924 }
1926 # No difference ? Return time unchanged
1929 }
1932 # Generate an adjusted date; take advantage of the fact that mktime
1933 # will normalize out-of-range values so we don't have to split $minDiff
1934 # into hours and minutes.
1947 }
1949 /**
1950 * This is meant to be used by time(), date(), and timeanddate() to get
1951 * the date preference they're supposed to use, it should be used in
1952 * all children.
1953 *
1954 *<code>
1955 * function timeanddate([...], $format = true) {
1956 * $datePreference = $this->dateFormat($format);
1957 * [...]
1958 * }
1959 *</code>
1960 *
1961 * @param $usePrefs Mixed: if true, the user's preference is used
1962 * if false, the site/language default is used
1963 * if int/string, assumed to be a format.
1964 * @return string
1965 */
1974 }
1977 }
1979 // return int
1982 }
1985 }
1987 /**
1988 * Get a format string for a given type and preference
1989 * @param $type string May be date, time or both
1990 * @param $pref string The format name as it appears in Messages*.php
1991 *
1992 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
1993 *
1994 * @return string
1995 */
2006 }
2011 }
2012 }
2014 }
2016 }
2018 /**
2019 * @param $ts Mixed: the time format which needs to be turned into a
2020 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2021 * @param $adj Bool: whether to adjust the time output according to the
2022 * user configured offset ($timecorrection)
2023 * @param $format Mixed: true to use user's date format preference
2024 * @param $timecorrection String|bool the time offset as returned by
2025 * validateTimeZone() in Special:Preferences
2026 * @return string
2027 */
2032 }
2035 }
2037 /**
2038 * @param $ts Mixed: the time format which needs to be turned into a
2039 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2040 * @param $adj Bool: whether to adjust the time output according to the
2041 * user configured offset ($timecorrection)
2042 * @param $format Mixed: true to use user's date format preference
2043 * @param $timecorrection String|bool the time offset as returned by
2044 * validateTimeZone() in Special:Preferences
2045 * @return string
2046 */
2051 }
2054 }
2056 /**
2057 * @param $ts Mixed: the time format which needs to be turned into a
2058 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2059 * @param $adj Bool: whether to adjust the time output according to the
2060 * user configured offset ($timecorrection)
2061 * @param $format Mixed: what format to return, if it's false output the
2062 * default one (default true)
2063 * @param $timecorrection String|bool the time offset as returned by
2064 * validateTimeZone() in Special:Preferences
2065 * @return string
2066 */
2071 }
2074 }
2076 /**
2077 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2078 *
2079 * @since 1.20
2080 *
2081 * @param integer $seconds The amount of seconds.
2082 * @param array $chosenIntervals The intervals to enable.
2083 *
2084 * @return string
2085 */
2092 // Give grep a chance to find the usages:
2093 // duration-centuries, duration-decades, duration-years, duration-days,
2094 // duration-hours, duration-minutes, duration-seconds
2097 }
2100 }
2102 /**
2103 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2104 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2105 *
2106 * @since 1.20
2107 *
2108 * @param integer $seconds The amount of seconds.
2109 * @param array $chosenIntervals The intervals to enable.
2110 *
2111 * @return array
2112 */
2115 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2116 }
2130 }
2131 }
2134 }
2136 /**
2137 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2138 *
2139 * @param $type String: can be 'date', 'time' or 'both'
2140 * @param $ts Mixed: the time format which needs to be turned into a
2141 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2142 * @param $user User object used to get preferences for timezone and format
2143 * @param $options Array, can contain the following keys:
2144 * - 'timecorrection': time correction, can have the following values:
2145 * - true: use user's preference
2146 * - false: don't use time correction
2147 * - integer: value of time correction in minutes
2148 * - 'format': format to use, can have the following values:
2149 * - true: use user's preference
2150 * - false: use default preference
2151 * - string: format to use
2152 * @since 1.19
2153 * @return String
2154 */
2163 }
2165 }
2170 }
2173 }
2175 /**
2176 * Get the formatted date for the given timestamp and formatted for
2177 * the given user.
2178 *
2179 * @param $ts Mixed: the time format which needs to be turned into a
2180 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2181 * @param $user User object used to get preferences for timezone and format
2182 * @param $options Array, can contain the following keys:
2183 * - 'timecorrection': time correction, can have the following values:
2184 * - true: use user's preference
2185 * - false: don't use time correction
2186 * - integer: value of time correction in minutes
2187 * - 'format': format to use, can have the following values:
2188 * - true: use user's preference
2189 * - false: use default preference
2190 * - string: format to use
2191 * @since 1.19
2192 * @return String
2193 */
2196 }
2198 /**
2199 * Get the formatted time for the given timestamp and formatted for
2200 * the given user.
2201 *
2202 * @param $ts Mixed: the time format which needs to be turned into a
2203 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2204 * @param $user User object used to get preferences for timezone and format
2205 * @param $options Array, can contain the following keys:
2206 * - 'timecorrection': time correction, can have the following values:
2207 * - true: use user's preference
2208 * - false: don't use time correction
2209 * - integer: value of time correction in minutes
2210 * - 'format': format to use, can have the following values:
2211 * - true: use user's preference
2212 * - false: use default preference
2213 * - string: format to use
2214 * @since 1.19
2215 * @return String
2216 */
2219 }
2221 /**
2222 * Get the formatted date and time for the given timestamp and formatted for
2223 * the given user.
2224 *
2225 * @param $ts Mixed: the time format which needs to be turned into a
2226 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2227 * @param $user User object used to get preferences for timezone and format
2228 * @param $options Array, can contain the following keys:
2229 * - 'timecorrection': time correction, can have the following values:
2230 * - true: use user's preference
2231 * - false: don't use time correction
2232 * - integer: value of time correction in minutes
2233 * - 'format': format to use, can have the following values:
2234 * - true: use user's preference
2235 * - false: use default preference
2236 * - string: format to use
2237 * @since 1.19
2238 * @return String
2239 */
2242 }
2244 /**
2245 * Convert an MWTimestamp into a pretty human-readable timestamp using
2246 * the given user preferences and relative base time.
2247 *
2248 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2249 * on your timestamp object, which will then call this function. Calling
2250 * this function directly will cause hooks to be skipped over.
2251 *
2252 * @see MWTimestamp::getHumanTimestamp
2253 * @param MWTimestamp $ts Timestamp to prettify
2254 * @param MWTimestamp $relativeTo Base timestamp
2255 * @param User $user User preferences to use
2256 * @return string Human timestamp
2257 * @since 1.22
2258 */
2261 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) - (int)$relativeTo->timestamp->format( 'w' ) );
2263 if ( $diff->invert || $days > 5 && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' ) ) {
2264 // Timestamps are in different years: use full timestamp
2265 // Also do full timestamp for future dates
2266 /**
2267 * @FIXME Add better handling of future timestamps.
2268 */
2272 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2276 // Timestamp within the past week: show the day of the week and time
2284 // Timestamp was yesterday: say 'yesterday' and the time.
2291 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2298 // From here on in, the timestamp was soon enough ago so that we can simply say
2299 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2301 // Less than 90 minutes, but more than an hour ago.
2304 // A few minutes ago.
2307 // Less than a minute, but more than 30 sec ago.
2310 // Less than 30 seconds ago.
2312 }
2315 }
2317 /**
2318 * @param $key string
2319 * @return array|null
2320 */
2323 }
2325 /**
2326 * @return array
2327 */
2330 }
2332 /**
2333 * @param $in
2334 * @param $out
2335 * @param $string
2336 * @return string
2337 */
2339 # This is a wrapper for iconv in all languages except esperanto,
2340 # which does some nasty x-conversions beforehand
2342 # Even with //IGNORE iconv can whine about illegal characters in
2343 # *input* string. We just ignore those too.
2344 # REF: http://bugs.php.net/bug.php?id=37166
2345 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2350 }
2352 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2354 /**
2355 * @param $matches array
2356 * @return mixed|string
2357 */
2360 }
2362 /**
2363 * @param $matches array
2364 * @return string
2365 */
2368 }
2370 /**
2371 * @param $matches array
2372 * @return string
2373 */
2377 }
2379 /**
2380 * @param $matches array
2381 * @return string
2382 */
2386 }
2388 /**
2389 * @param $matches array
2390 * @return string
2391 */
2394 }
2396 /**
2397 * @param $matches array
2398 * @return string
2399 */
2403 }
2405 /**
2406 * Make a string's first character uppercase
2407 *
2408 * @param $str string
2409 *
2410 * @return string
2411 */
2419 // fall back to more complex logic in case of multibyte strings
2421 }
2422 }
2424 /**
2425 * Convert a string to uppercase
2426 *
2427 * @param $str string
2428 * @param $first bool
2429 *
2430 * @return string
2431 */
2439 }
2442 }
2449 $str
2450 );
2453 }
2454 }
2455 }
2457 /**
2458 * @param $str string
2459 * @return mixed|string
2460 */
2472 }
2473 }
2475 /**
2476 * @param $str string
2477 * @param $first bool
2478 * @return mixed|string
2479 */
2487 }
2490 }
2497 $str
2498 );
2501 }
2502 }
2503 }
2505 /**
2506 * @param $str string
2507 * @return bool
2508 */
2511 }
2513 /**
2514 * @param $str string
2515 * @return mixed|string
2516 */
2521 // regexp to find first letter in each word (i.e. after each space)
2522 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2524 // function to use to capitalize a single char
2529 $str
2530 );
2535 $str
2536 );
2537 }
2540 }
2541 }
2543 /**
2544 * capitalize words at word breaks
2545 *
2546 * @param $str string
2547 * @return mixed
2548 */
2553 // since \b doesn't work for UTF-8, we explicitely define word break chars
2556 // find first letter after word break
2557 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2563 $str
2564 );
2569 $str
2570 );
2571 }
2576 $str
2577 );
2578 }
2579 }
2581 /**
2582 * Return a case-folded representation of $s
2583 *
2584 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2585 * and $s2 are the same except for the case of their characters. It is not
2586 * necessary for the value returned to make sense when displayed.
2587 *
2588 * Do *not* perform any other normalisation in this function. If a caller
2589 * uses this function when it should be using a more general normalisation
2590 * function, then fix the caller.
2591 *
2592 * @param $s string
2593 *
2594 * @return string
2595 */
2598 }
2600 /**
2601 * @param $s string
2602 * @return string
2603 */
2607 }
2610 }
2613 }
2615 /**
2616 * @return array
2617 */
2620 }
2622 /**
2623 * Most writing systems use whitespace to break up words.
2624 * Some languages such as Chinese don't conventionally do this,
2625 * which requires special handling when breaking up words for
2626 * searching etc.
2627 *
2628 * @return bool
2629 */
2632 }
2634 /**
2635 * Some languages such as Chinese require word segmentation,
2636 * Specify such segmentation when overridden in derived class.
2637 *
2638 * @param $string String
2639 * @return String
2640 */
2643 }
2645 /**
2646 * Some languages have special punctuation need to be normalized.
2647 * Make such changes here.
2648 *
2649 * @param $string String
2650 * @return String
2651 */
2654 }
2656 /**
2657 * convert double-width roman characters to single-width.
2658 * range: ff00-ff5f ~= 0020-007f
2659 *
2660 * @param $string string
2661 *
2662 * @return string
2663 */
2673 }
2677 }
2679 /**
2680 * @param $string string
2681 * @param $pattern string
2682 * @return string
2683 */
2688 }
2690 /**
2691 * @param $termsArray array
2692 * @return array
2693 */
2695 # some languages, e.g. Chinese, need to do a conversion
2696 # in order for search results to be displayed correctly
2698 }
2700 /**
2701 * Get the first character of a string.
2702 *
2703 * @param $s string
2704 * @return string
2705 */
2712 $matches
2713 );
2718 }
2720 // Break down Hangul syllables to grab the first jamo
2752 }
2755 }
2756 }
2759 # Some languages may have an alternate char encoding option
2760 # (Esperanto X-coding, Japanese furigana conversion, etc)
2761 # If this language is used as the primary content language,
2762 # an override to the defaults can be set here on startup.
2763 }
2765 /**
2766 * @param $s string
2767 * @return string
2768 */
2770 # For some languages we'll want to explicitly specify
2771 # which characters make it into the edit box raw
2772 # or are converted in some way or another.
2778 }
2779 }
2781 /**
2782 * @param $s string
2783 * @return string
2784 */
2786 # Take the previous into account.
2792 }
2797 }
2798 }
2800 /**
2801 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2802 * also cleans up certain backwards-compatible sequences, converting them
2803 * to the modern Unicode equivalent.
2804 *
2805 * This is language-specific for performance reasons only.
2806 *
2807 * @param $s string
2808 *
2809 * @return string
2810 */
2817 }
2820 }
2822 /**
2823 * Transform a string using serialized data stored in the given file (which
2824 * must be in the serialized subdirectory of $IP). The file contains pairs
2825 * mapping source characters to destination characters.
2826 *
2827 * The data is cached in process memory. This will go faster if you have the
2828 * FastStringSearch extension.
2829 *
2830 * @param $file string
2831 * @param $string string
2832 *
2833 * @throws MWException
2834 * @return string
2835 */
2841 }
2843 }
2845 }
2847 /**
2848 * For right-to-left language support
2849 *
2850 * @return bool
2851 */
2854 }
2856 /**
2857 * Return the correct HTML 'dir' attribute value for this language.
2858 * @return String
2859 */
2862 }
2864 /**
2865 * Return 'left' or 'right' as appropriate alignment for line-start
2866 * for this language's text direction.
2867 *
2868 * Should be equivalent to CSS3 'start' text-align value....
2869 *
2870 * @return String
2871 */
2874 }
2876 /**
2877 * Return 'right' or 'left' as appropriate alignment for line-end
2878 * for this language's text direction.
2879 *
2880 * Should be equivalent to CSS3 'end' text-align value....
2881 *
2882 * @return String
2883 */
2886 }
2888 /**
2889 * A hidden direction mark (LRM or RLM), depending on the language direction.
2890 * Unlike getDirMark(), this function returns the character as an HTML entity.
2891 * This function should be used when the output is guaranteed to be HTML,
2892 * because it makes the output HTML source code more readable. When
2893 * the output is plain text or can be escaped, getDirMark() should be used.
2894 *
2895 * @param $opposite Boolean Get the direction mark opposite to your language
2896 * @return string
2897 * @since 1.20
2898 */
2902 }
2904 }
2906 /**
2907 * A hidden direction mark (LRM or RLM), depending on the language direction.
2908 * This function produces them as invisible Unicode characters and
2909 * the output may be hard to read and debug, so it should only be used
2910 * when the output is plain text or can be escaped. When the output is
2911 * HTML, use getDirMarkEntity() instead.
2912 *
2913 * @param $opposite Boolean Get the direction mark opposite to your language
2914 * @return string
2915 */
2921 }
2923 }
2925 /**
2926 * @return array
2927 */
2930 }
2932 /**
2933 * An arrow, depending on the language direction.
2934 *
2935 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2936 * @return string
2937 */
2952 }
2953 }
2955 /**
2956 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2957 *
2958 * @return bool
2959 */
2962 }
2964 /**
2965 * Get all magic words from cache.
2966 * @return array
2967 */
2970 }
2972 /**
2973 * Run the LanguageGetMagic hook once.
2974 */
2978 }
2983 }
2985 /**
2986 * Fill a MagicWord object with data from here
2987 *
2988 * @param $mw
2989 */
2991 // Saves a function call
2994 }
3001 }
3008 }
3009 }
3011 /**
3012 * Add magic words to the extension array
3013 *
3014 * @param $newWords array
3015 */
3022 }
3023 }
3024 }
3026 /**
3027 * Get special page names, as an associative array
3028 * case folded alias => real name
3029 */
3031 // Cache aliases because it may be slow to load them
3033 // Initialise array
3038 }
3041 }
3043 /**
3044 * Italic is unsuitable for some languages
3045 *
3046 * @param $text String: the text to be emphasized.
3047 * @return string
3048 */
3051 }
3053 /**
3054 * Normally we output all numbers in plain en_US style, that is
3055 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3056 * point twohundredthirtyfive. However this is not suitable for all
3057 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
3058 * Icelandic just want to use commas instead of dots, and dots instead
3059 * of commas like "293.291,235".
3060 *
3061 * An example of this function being called:
3062 * <code>
3063 * wfMessage( 'message' )->numParams( $num )->text()
3064 * </code>
3065 *
3066 * See LanguageGu.php for the Gujarati implementation and
3067 * $separatorTransformTable on MessageIs.php for
3068 * the , => . and . => , implementation.
3069 *
3070 * @todo check if it's viable to use localeconv() for the decimal
3071 * separator thing.
3072 * @param $number Mixed: the string to be formatted, should be an integer
3073 * or a floating point number.
3074 * @param $nocommafy Bool: set to true for special numbers like dates
3075 * @return string
3076 */
3084 }
3085 }
3091 }
3092 }
3095 }
3097 /**
3098 * Front-end for non-commafied formatNum
3099 *
3100 * @param mixed $number the string to be formatted, should be an integer
3101 * or a floating point number.
3102 * @since 1.21
3103 * @return string
3104 */
3107 }
3109 /**
3110 * @param $number string
3111 * @return string
3112 */
3117 }
3122 }
3126 }
3128 /**
3129 * Adds commas to a given number
3130 * @since 1.19
3131 * @param $number mixed
3132 * @return string
3133 */
3138 }
3141 // default grouping is at thousands, use the same for ###,###,### pattern too.
3144 // Ref: http://cldr.unicode.org/translation/number-patterns
3147 // For negative numbers apply the algorithm like positive number and add sign.
3150 }
3158 // the string does not have any number part. Eg: .12345
3160 }
3168 }
3172 // use the last pattern for the rest of the number
3174 }
3177 }
3178 }
3180 }
3181 }
3183 /**
3184 * @return String
3185 */
3188 }
3190 /**
3191 * @return array
3192 */
3195 }
3197 /**
3198 * @return array
3199 */
3202 }
3204 /**
3205 * Take a list of strings and build a locale-friendly comma-separated
3206 * list, using the local comma-separator message.
3207 * The last two strings are chained with an "and".
3208 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3209 *
3210 * @param $l Array
3211 * @return string
3212 */
3217 }
3223 }
3224 }
3231 }
3232 }
3234 }
3236 /**
3237 * Take a list of strings and build a locale-friendly comma-separated
3238 * list, using the local comma-separator message.
3239 * @param $list array of strings to put in a comma list
3240 * @return string
3241 */
3245 $list
3246 );
3247 }
3249 /**
3250 * Take a list of strings and build a locale-friendly semicolon-separated
3251 * list, using the local semicolon-separator message.
3252 * @param $list array of strings to put in a semicolon list
3253 * @return string
3254 */
3258 $list
3259 );
3260 }
3262 /**
3263 * Same as commaList, but separate it with the pipe instead.
3264 * @param $list array of strings to put in a pipe list
3265 * @return string
3266 */
3270 $list
3271 );
3272 }
3274 /**
3275 * Truncate a string to a specified length in bytes, appending an optional
3276 * string (e.g. for ellipses)
3277 *
3278 * The database offers limited byte lengths for some columns in the database;
3279 * multi-byte character sets mean we need to ensure that only whole characters
3280 * are included, otherwise broken characters can be passed to the user
3281 *
3282 * If $length is negative, the string will be truncated from the beginning
3283 *
3284 * @param $string String to truncate
3285 * @param $length Int: maximum length (including ellipses)
3286 * @param $ellipsis String to append to the truncated text
3287 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3288 * $adjustLength was introduced in 1.18, before that behaved as if false.
3289 * @return string
3290 */
3292 # Use the localized ellipsis character
3295 }
3296 # Check if there is no need to truncate
3301 }
3303 # If ellipsis length is >= $length then we can't apply $adjustLength
3306 # Otherwise, truncate and add ellipsis...
3319 }
3320 }
3321 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3322 # This check is *not* redundant if $adjustLength, due to the single case where
3323 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3328 }
3329 }
3331 /**
3332 * Remove bytes that represent an incomplete Unicode character
3333 * at the end of string (e.g. bytes of the char are missing)
3334 *
3335 * @param $string String
3336 * @return string
3337 */
3343 # We got the first byte only of a multibyte char; remove it.
3348 ) {
3349 # We chopped in the middle of a character; remove it
3351 }
3352 }
3354 }
3356 /**
3357 * Remove bytes that represent an incomplete Unicode character
3358 * at the start of string (e.g. bytes of the char are missing)
3359 *
3360 * @param $string String
3361 * @return string
3362 */
3367 # We chopped in the middle of a character; remove the whole thing
3369 }
3370 }
3372 }
3374 /**
3375 * Truncate a string of valid HTML to a specified length in bytes,
3376 * appending an optional string (e.g. for ellipses), and return valid HTML
3377 *
3378 * This is only intended for styled/linked text, such as HTML with
3379 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3380 * Also, this will not detect things like "display:none" CSS.
3381 *
3382 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3383 *
3384 * @param string $text HTML string to truncate
3385 * @param int $length (zero/positive) Maximum length (including ellipses)
3386 * @param string $ellipsis String to append to the truncated text
3387 * @return string
3388 */
3390 # Use the localized ellipsis character
3393 }
3394 # Check if there is clearly no need to truncate
3399 }
3413 # Consider truncation once the display length has reached the maximim.
3414 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3415 # Check that we're not in the middle of a bracket/entity...
3419 # Save where we are; we will truncate here unless there turn out to
3420 # be so few remaining characters that truncation is not necessary.
3423 }
3425 # String in fact does need truncation, the truncation point was OK.
3430 }
3431 }
3434 }
3436 # Read the next char...
3454 }
3460 // Name found (e.g. "<a href=..."), add on tag attributes...
3462 }
3468 }
3471 // Save state without $ch. We want to *hit* the first
3472 // display char (to get tags) but not *use* it if truncating.
3474 }
3479 // Add the next $max display text chars after this in one swoop...
3484 }
3485 }
3486 }
3487 }
3488 // Close the last tag if left unclosed by bad HTML
3492 }
3494 }
3496 /**
3497 * truncateHtml() helper function
3498 * like strcspn() but adds the skipped chars to $ret
3499 *
3500 * @param $ret
3501 * @param $text
3502 * @param $search
3503 * @param $start
3504 * @param $len
3505 * @return int
3506 */
3512 }
3517 }
3519 }
3521 /**
3522 * truncateHtml() helper function
3523 * (a) push or pop $tag from $openTags as needed
3524 * (b) clear $tag value
3525 * @param &$tag string Current HTML tag name we are looking at
3526 * @param $tagType int (0-open tag, 1-close tag)
3527 * @param $lastCh string Character before the '>' that ended this tag
3528 * @param &$openTags array Open tag stack (not accounting for $tag)
3529 */
3538 }
3539 }
3541 }
3542 }
3544 /**
3545 * Grammatical transformations, needed for inflected languages
3546 * Invoked by putting {{grammar:case|word}} in a message
3547 *
3548 * @param $word string
3549 * @param $case string
3550 * @return string
3551 */
3556 }
3558 }
3559 /**
3560 * Get the grammar forms for the content language
3561 * @return array of grammar forms
3562 * @since 1.20
3563 */
3566 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3568 }
3570 }
3571 /**
3572 * Provides an alternative text depending on specified gender.
3573 * Usage {{gender:username|masculine|feminine|neutral}}.
3574 * username is optional, in which case the gender of current user is used,
3575 * but only in (some) interface messages; otherwise default gender is used.
3576 *
3577 * If no forms are given, an empty string is returned. If only one form is
3578 * given, it will be returned unconditionally. These details are implied by
3579 * the caller and cannot be overridden in subclasses.
3580 *
3581 * If more than one form is given, the default is to use the neutral one
3582 * if it is specified, and to use the masculine one otherwise. These
3583 * details can be overridden in subclasses.
3584 *
3585 * @param $gender string
3586 * @param $forms array
3587 *
3588 * @return string
3589 */
3593 }
3597 }
3600 }
3602 }
3604 /**
3605 * Plural form transformations, needed for some languages.
3606 * For example, there are 3 form of plural in Russian and Polish,
3607 * depending on "count mod 10". See [[w:Plural]]
3608 * For English it is pretty simple.
3609 *
3610 * Invoked by putting {{plural:count|wordform1|wordform2}}
3611 * or {{plural:count|wordform1|wordform2|wordform3}}
3612 *
3613 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3614 *
3615 * @param $count Integer: non-localized number
3616 * @param $forms Array: different plural forms
3617 * @return string Correct form of plural for $count in this language
3618 */
3620 // Handle explicit n=pluralform cases
3626 }
3628 }
3629 }
3634 }
3639 }
3641 /**
3642 * Checks that convertPlural was given an array and pads it to requested
3643 * amount of forms by copying the last one.
3644 *
3645 * @param $count Integer: How many forms should there be at least
3646 * @param $forms Array of forms given to convertPlural
3647 * @return array Padded array of forms or an exception if not an array
3648 */
3652 }
3654 }
3656 /**
3657 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3658 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3659 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3660 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3661 * match up with it.
3662 *
3663 * @param $str String: the validated block duration in English
3664 * @return string Somehow translated block duration
3665 * @see LanguageFi.php for example implementation
3666 */
3672 }
3673 }
3675 // Since usually only infinite or indefinite is only on list, so try
3676 // equivalents if still here.
3683 }
3684 }
3685 }
3687 // If all else fails, return a standard duration or timestamp description.
3692 // $time is relative to 0 so it's a duration length.
3696 // wfTimestamp() handles 0 as current time instead of epoch.
3700 }
3701 }
3702 }
3704 /**
3705 * languages like Chinese need to be segmented in order for the diff
3706 * to be of any use
3707 *
3708 * @param $text String
3709 * @return String
3710 */
3713 }
3715 /**
3716 * and unsegment to show the result
3717 *
3718 * @param $text String
3719 * @return String
3720 */
3723 }
3725 /**
3726 * Return the LanguageConverter used in the Language
3727 *
3728 * @since 1.19
3729 * @return LanguageConverter
3730 */
3733 }
3735 /**
3736 * convert text to all supported variants
3737 *
3738 * @param $text string
3739 * @return array
3740 */
3743 }
3745 /**
3746 * convert text to different variants of a language.
3747 *
3748 * @param $text string
3749 * @return string
3750 */
3753 }
3755 /**
3756 * Convert a Title object to a string in the preferred variant
3757 *
3758 * @param $title Title
3759 * @return string
3760 */
3763 }
3765 /**
3766 * Convert a namespace index to a string in the preferred variant
3767 *
3768 * @param $ns int
3769 * @return string
3770 */
3773 }
3775 /**
3776 * Check if this is a language with variants
3777 *
3778 * @return bool
3779 */
3782 }
3784 /**
3785 * Check if the language has the specific variant
3786 *
3787 * @since 1.19
3788 * @param $variant string
3789 * @return bool
3790 */
3793 }
3795 /**
3796 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3797 *
3798 * @param $text string
3799 * @return string
3800 */
3803 }
3805 /**
3806 * Perform output conversion on a string, and encode for safe HTML output.
3807 * @param $text String text to be converted
3808 * @param $isTitle Bool whether this conversion is for the article title
3809 * @return string
3810 * @todo this should get integrated somewhere sane
3811 */
3814 }
3816 /**
3817 * @param $key string
3818 * @return string
3819 */
3822 }
3824 /**
3825 * Get the list of variants supported by this language
3826 * see sample implementation in LanguageZh.php
3827 *
3828 * @return array an array of language codes
3829 */
3832 }
3834 /**
3835 * @return string
3836 */
3839 }
3841 /**
3842 * @return string
3843 */
3846 }
3848 /**
3849 * @return string
3850 */
3853 }
3855 /**
3856 * If a language supports multiple variants, it is
3857 * possible that non-existing link in one variant
3858 * actually exists in another variant. this function
3859 * tries to find it. See e.g. LanguageZh.php
3860 *
3861 * @param $link String: the name of the link
3862 * @param $nt Mixed: the title object of the link
3863 * @param $ignoreOtherCond Boolean: to disable other conditions when
3864 * we need to transclude a template or update a category's link
3865 * @return null the input parameters may be modified upon return
3866 */
3869 }
3871 /**
3872 * If a language supports multiple variants, converts text
3873 * into an array of all possible variants of the text:
3874 * 'variant' => text in that variant
3875 *
3876 * @deprecated since 1.17 Use autoConvertToAllVariants()
3877 *
3878 * @param $text string
3879 *
3880 * @return string
3881 */
3884 }
3886 /**
3887 * returns language specific options used by User::getPageRenderHash()
3888 * for example, the preferred language variant
3889 *
3890 * @return string
3891 */
3894 }
3896 /**
3897 * For languages that support multiple variants, the title of an
3898 * article may be displayed differently in different variants. this
3899 * function returns the apporiate title defined in the body of the article.
3900 *
3901 * @return string
3902 */
3905 }
3907 /**
3908 * Prepare external link text for conversion. When the text is
3909 * a URL, it shouldn't be converted, and it'll be wrapped in
3910 * the "raw" tag (-{R| }-) to prevent conversion.
3911 *
3912 * This function is called "markNoConversion" for historical
3913 * reasons.
3914 *
3915 * @param $text String: text to be used for external link
3916 * @param $noParse bool: wrap it without confirming it's a real URL first
3917 * @return string the tagged text
3918 */
3920 // Excluding protocal-relative URLs may avoid many false positives.
3925 }
3926 }
3928 /**
3929 * A regular expression to match legal word-trailing characters
3930 * which should be merged onto a link of the form [[foo]]bar.
3931 *
3932 * @return string
3933 */
3936 }
3938 /**
3939 * @return Language
3940 */
3943 }
3945 /**
3946 * Get the "parent" language which has a converter to convert a "compatible" language
3947 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
3948 *
3949 * @return Language|null
3950 * @since 1.22
3951 */
3955 }
3962 }
3967 }
3971 }
3973 /**
3974 * Get the RFC 3066 code for this language object
3975 *
3976 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3977 * htmlspecialchars() or similar
3978 *
3979 * @return string
3980 */
3983 }
3985 /**
3986 * Get the code in Bcp47 format which we can use
3987 * inside of html lang="" tags.
3988 *
3989 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3990 * htmlspecialchars() or similar.
3991 *
3992 * @since 1.19
3993 * @return string
3994 */
3998 }
4000 }
4002 /**
4003 * @param $code string
4004 */
4007 // Ensure we don't leave incorrect cached data lying around
4010 }
4012 /**
4013 * Get the name of a file for a certain language code
4014 * @param $prefix string Prepend this to the filename
4015 * @param $code string Language code
4016 * @param $suffix string Append this to the filename
4017 * @throws MWException
4018 * @return string $prefix . $mangledCode . $suffix
4019 */
4021 // Protect against path traversal
4024 {
4026 }
4029 }
4031 /**
4032 * Get the language code from a file name. Inverse of getFileName()
4033 * @param $filename string $prefix . $languageCode . $suffix
4034 * @param $prefix string Prefix before the language code
4035 * @param $suffix string Suffix after the language code
4036 * @return string Language code, or false if $prefix or $suffix isn't found
4037 */
4038 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4044 }
4046 }
4048 /**
4049 * @param $code string
4050 * @return string
4051 */
4057 }
4059 /**
4060 * @param $code string
4061 * @return string
4062 */
4066 }
4068 /**
4069 * Get the first fallback for a given language.
4070 *
4071 * @param $code string
4072 *
4073 * @return bool|string
4074 */
4082 }
4083 }
4085 /**
4086 * Get the ordered list of fallback languages.
4087 *
4088 * @since 1.19
4089 * @param $code string Language code
4090 * @return array
4091 */
4100 }
4102 }
4103 }
4105 /**
4106 * Get the ordered list of fallback languages, ending with the fallback
4107 * language chain for the site language.
4108 *
4109 * @since 1.22
4110 * @param string $code Language code
4111 * @return array array( fallbacks, site fallbacks )
4112 */
4116 // Usually, we will only store a tiny number of fallback chains, so we
4117 // keep them in static memory.
4123 // Append the site's fallback chain, including the site language itself
4127 // Eliminate any languages already included in the chain
4131 }
4133 }
4135 /**
4136 * Get all messages for a given language
4137 * WARNING: this may take a long time. If you just need all message *keys*
4138 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4139 *
4140 * @param $code string
4141 *
4142 * @return array
4143 */
4146 }
4148 /**
4149 * Get a message for a given language
4150 *
4151 * @param $key string
4152 * @param $code string
4153 *
4154 * @return string
4155 */
4158 }
4160 /**
4161 * Get all message keys for a given language. This is a faster alternative to
4162 * array_keys( Language::getMessagesFor( $code ) )
4163 *
4164 * @since 1.19
4165 * @param $code string Language code
4166 * @return array of message keys (strings)
4167 */
4170 }
4172 /**
4173 * @param $talk
4174 * @return mixed
4175 */
4179 }
4184 # Allow grammar transformations
4185 # Allowing full message-style parsing would make simple requests
4186 # such as action=raw much more expensive than they need to be.
4187 # This will hopefully cover most cases.
4191 }
4193 /**
4194 * @param $m string
4195 * @return string
4196 */
4199 }
4201 /**
4202 * @throws MWException
4203 * @return array
4204 */
4209 }
4216 }
4221 }
4223 /**
4224 * Decode an expiry (block, protection, etc) which has come from the DB
4225 *
4226 * @todo FIXME: why are we returnings DBMS-dependent strings???
4227 *
4228 * @param $expiry String: Database expiry String
4229 * @param $format Bool|Int true to process using language functions, or TS_ constant
4230 * to return the expiry in a given timestamp
4231 * @return String
4232 * @since 1.18
4233 */
4238 }
4248 }
4249 }
4251 /**
4252 * @todo Document
4253 * @param $seconds int|float
4254 * @param $format Array Optional
4255 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4256 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4257 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4258 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4259 * @return string
4260 */
4264 }
4267 }
4270 }
4292 }
4303 }
4307 }
4313 }
4321 }
4331 }
4335 }
4345 }
4346 }
4348 }
4350 /**
4351 * Format a bitrate for output, using an appropriate
4352 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4353 *
4354 * This use base 1000. For base 1024 use formatSize(), for another base
4355 * see formatComputingNumbers()
4356 *
4357 * @param $bps int
4358 * @return string
4359 */
4362 }
4364 /**
4365 * @param $size int Size of the unit
4366 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4367 * @param $messageKey string Message key to be uesd
4368 * @return string
4369 */
4374 );
4375 }
4383 }
4385 // For small sizes no decimal places necessary
4388 // For MB and bigger two decimal places are smarter
4390 }
4396 }
4398 /**
4399 * Format a size in bytes for output, using an appropriate
4400 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4401 *
4402 * This method use base 1024. For base 1000 use formatBitrate(), for
4403 * another base see formatComputingNumbers()
4404 *
4405 * @param $size int Size to format
4406 * @return string Plain text (not HTML)
4407 */
4410 }
4412 /**
4413 * Make a list item, used by various special pages
4414 *
4415 * @param $page String Page link
4416 * @param $details String Text between brackets
4417 * @param $oppositedm Boolean Add the direction mark opposite to your
4418 * language, to display text properly
4419 * @return String
4420 */
4427 }
4429 /**
4430 * Generate (prev x| next x) (20|50|100...) type links for paging
4431 *
4432 * @param $title Title object to link
4433 * @param $offset Integer offset parameter
4434 * @param $limit Integer limit parameter
4435 * @param $query array|String optional URL query parameter string
4436 * @param $atend Bool optional param for specified if this is the last page
4437 * @return String
4438 */
4439 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4440 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4442 # Make 'previous' link
4443 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4449 }
4451 # Make 'next' link
4452 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4458 }
4460 # Make links to set number of items per page
4465 }
4469 }
4471 /**
4472 * Helper function for viewPrevNext() that generates links
4473 *
4474 * @param $title Title object to link
4475 * @param $offset Integer offset parameter
4476 * @param $limit Integer limit parameter
4477 * @param $query Array extra query parameters
4478 * @param $link String text to use for the link; will be escaped
4479 * @param $tooltipMsg String name of the message to use as tooltip
4480 * @param $class String value of the "class" attribute of the link
4481 * @return String HTML fragment
4482 */
4483 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4485 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4488 }
4490 /**
4491 * Get the conversion rule title, if any.
4492 *
4493 * @return string
4494 */
4497 }
4499 /**
4500 * Get the compiled plural rules for the language
4501 * @since 1.20
4502 * @return array Associative array with plural form, and plural rule as key-value pairs
4503 */
4509 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4512 }
4513 }
4514 }
4516 }
4518 /**
4519 * Get the plural rules for the language
4520 * @since 1.20
4521 * @return array Associative array with plural form number and plural rule as key-value pairs
4522 */
4531 }
4532 }
4533 }
4535 }
4537 /**
4538 * Get the plural rule types for the language
4539 * @since 1.22
4540 * @return array Associative array with plural form number and plural rule type as key-value pairs
4541 */
4547 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4550 }
4551 }
4552 }
4554 }
4556 /**
4557 * Find the index number of the plural rule appropriate for the given number
4558 * @return int The index number of the plural rule
4559 */
4564 }
4566 /**
4567 * Find the plural rule type appropriate for the given number
4568 * For example, if the language is set to Arabic, getPluralType(5) should
4569 * return 'few'.
4570 * @since 1.22
4571 * @return string The name of the plural rule type, e.g. one, two, few, many
4572 */
4580 }
4581 }
4582 }