| blob | 2fd4bb75d024460fe6b1a962fa25fb70a927d2a9 |
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 * Get a cached or new language object for a given language code
175 * @param $code String
176 * @return Language
177 */
183 }
185 // get the language object to process
190 // merge the language object in to get it up front in the cache
192 // get rid of the oldest ones in case we have an overflow
196 }
198 /**
199 * Create a language object for a given language code
200 * @param $code String
201 * @throws MWException
202 * @return Language
203 */
205 // Protect against path traversal below
208 {
210 }
213 // It's not possible to customise this code with class files, so
214 // just return a Language object. This is to support uselang= hacks.
218 }
220 // Check if there is a language class for the code
226 }
228 // Keep trying the fallback list until we find an existing class
233 }
241 }
242 }
245 }
247 /**
248 * Checks whether any localisation is available for that language tag
249 * in MediaWiki (MessagesXx.php exists).
250 *
251 * @param string $code Language tag (in lower case)
252 * @return bool Whether language is supported
253 * @since 1.21
254 */
257 }
259 /**
260 * Returns true if a language code string is a well-formed language tag
261 * according to RFC 5646.
262 * This function only checks well-formedness; it doesn't check that
263 * language, script or variant codes actually exist in the repositories.
264 *
265 * Based on regexes by Mark Davis of the Unicode Consortium:
266 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
267 *
268 * @param $code string
269 * @param $lenient boolean Whether to allow '_' as separator. The default is only '-'.
270 *
271 * @return bool
272 * @since 1.21
273 */
289 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
290 # Since these are limited, this is safe even later changes to the registry --
291 # the only oddity is that it might change the type of the tag, and thus
292 # the results from the capturing groups.
293 # http://www.iana.org/assignments/language-subtag-registry
311 # The final breakdown, with capturing groups for each of these components
312 # The variants, extensions, grandfathered, and private-use may have interior '-'
317 }
319 /**
320 * Returns true if a language code string is of a valid form, whether or
321 * not it exists. This includes codes which are used solely for
322 * customisation via the MediaWiki namespace.
323 *
324 * @param $code string
325 *
326 * @return bool
327 */
332 }
333 // People think language codes are html safe, so enforce it.
334 // Ideally we should only allow a-zA-Z0-9-
335 // but, .+ and other chars are often used for {{int:}} hacks
336 // see bugs 37564, 37587, 36938
342 }
344 /**
345 * Returns true if a language code is of a valid form for the purposes of
346 * internal customisation of MediaWiki, via Messages*.php.
347 *
348 * @param $code string
349 *
350 * @throws MWException
351 * @since 1.18
352 * @return bool
353 */
361 }
364 }
367 }
369 /**
370 * Returns true if a language code is an IETF tag known to MediaWiki.
371 *
372 * @param $code string
373 *
374 * @since 1.21
375 * @return bool
376 */
382 }
386 ) {
388 }
391 }
393 /**
394 * @param $code
395 * @return String Name of the language class
396 */
402 }
403 }
405 /**
406 * Includes language class files
407 *
408 * @param $class string Name of the language class
409 */
415 }
420 }
421 }
422 }
424 /**
425 * Get the LocalisationCache instance
426 *
427 * @return LocalisationCache
428 */
434 }
436 }
440 // Set the code to the name of the descendant
445 }
447 }
449 /**
450 * Reduce memory usage
451 */
455 }
456 }
458 /**
459 * Hook which will be called if this is the content language.
460 * Descendants can use this to register hook functions or modify globals
461 */
464 /**
465 * Same as getFallbacksFor for current language.
466 * @return array|bool
467 * @deprecated in 1.19
468 */
472 }
474 /**
475 * @return array
476 * @since 1.19
477 */
480 }
482 /**
483 * Exports $wgBookstoreListEn
484 * @return array
485 */
488 }
490 /**
491 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
492 * available in localised form, it will be included in English.
493 *
494 * @return array
495 */
512 }
514 # Sometimes a language will be localised but not actually exist on this wiki.
518 }
519 }
521 # The above mixing may leave namespaces out of canonical order.
522 # Re-order by namespace ID number...
526 }
528 }
530 /**
531 * Arbitrarily set all of the namespace names at once. Mainly used for testing
532 * @param $namespaces Array of namespaces (id => name)
533 */
537 }
539 /**
540 * Resets all of the namespace caches. Mainly used for testing
541 */
546 }
548 /**
549 * A convenience function that returns the same thing as
550 * getNamespaces() except with the array values changed to ' '
551 * where it found '_', useful for producing output to be displayed
552 * e.g. in <select> forms.
553 *
554 * @return array
555 */
560 }
562 }
564 /**
565 * Get a namespace value by key
566 * <code>
567 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
568 * echo $mw_ns; // prints 'MediaWiki'
569 * </code>
570 *
571 * @param $index Int: the array key of the namespace to return
572 * @return mixed, string if the namespace value exists, otherwise false
573 */
577 }
579 /**
580 * A convenience function that returns the same thing as
581 * getNsText() except with '_' changed to ' ', useful for
582 * producing output.
583 *
584 * <code>
585 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
586 * echo $mw_ns; // prints 'MediaWiki talk'
587 * </code>
588 *
589 * @param int $index The array key of the namespace to return
590 * @return string Namespace name without underscores (empty string if namespace does not exist)
591 */
595 }
597 /**
598 * Returns gender-dependent namespace alias if available.
599 * @param $index Int: namespace index
600 * @param $gender String: gender key (male, female... )
601 * @return String
602 * @since 1.18
603 */
607 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
609 }
611 /**
612 * Whether this language makes distinguishes genders for example in
613 * namespaces.
614 * @return bool
615 * @since 1.18
616 */
620 // $wgExtraGenderNamespaces overrides everything
622 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
623 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
624 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
627 // Check what is in i18n files
630 }
631 }
633 /**
634 * Get a namespace key by value, case insensitive.
635 * Only matches namespace names for the current language, not the
636 * canonical ones defined in Namespace.php.
637 *
638 * @param $text String
639 * @return mixed An integer if $text is a valid value otherwise false
640 */
645 }
647 /**
648 * @return array
649 */
661 }
662 }
663 }
666 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
670 }
671 }
674 }
676 }
678 /**
679 * @return array
680 */
684 # Put namespace names and aliases into a hashtable.
685 # If this is too slow, then we should arrange it so that it is done
686 # before caching. The catch is that at pre-cache time, the above
687 # class-specific fixup hasn't been done.
691 }
694 }
698 }
699 }
700 }
702 }
704 /**
705 * Get a namespace key by value, case insensitive. Canonical namespace
706 * names override custom ones defined for the current language.
707 *
708 * @param $text String
709 * @return mixed An integer if $text is a valid value otherwise false
710 */
716 }
719 }
721 /**
722 * short names for language variants used for language conversion links.
723 *
724 * @param $code String
725 * @param $usemsg bool Use the "variantname-xyz" message if it exists
726 * @return string
727 */
732 }
737 # otherwise, output the language code
739 }
740 }
742 /**
743 * @param $name string
744 * @return string
745 */
750 }
752 }
754 /**
755 * @return array
756 */
759 }
761 /**
762 * @return array
763 */
766 }
768 /**
769 * @return array|string
770 */
778 }
779 }
781 /**
782 * @return array
783 */
786 }
788 /**
789 * @param $image
790 * @return array|null
791 */
794 }
796 /**
797 * @return array
798 */
801 }
803 /**
804 * @param $tog
805 * @return string
806 */
809 }
811 /**
812 * Get native language names, indexed by code.
813 * Only those defined in MediaWiki, no other data like CLDR.
814 * If $customisedOnly is true, only returns codes with a messages file
815 *
816 * @param $customisedOnly bool
817 *
818 * @return array
819 * @deprecated in 1.20, use fetchLanguageNames()
820 */
823 }
825 /**
826 * Get translated language names. This is done on best effort and
827 * by default this is exactly the same as Language::getLanguageNames.
828 * The CLDR extension provides translated names.
829 * @param $code String Language code.
830 * @return Array language code => language name
831 * @since 1.18.0
832 * @deprecated in 1.20, use fetchLanguageNames()
833 */
836 }
838 /**
839 * Get an array of language names, indexed by code.
840 * @param $inLanguage null|string: Code of language in which to return the names
841 * Use null for autonyms (native names)
842 * @param $include string:
843 * 'all' all available languages
844 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
845 * 'mwfile' only if the language is in 'mw' *and* has a message file
846 * @return array: language code => language name
847 * @since 1.20
848 */
855 }
860 # TODO: also include when $inLanguage is null, when this code is more efficient
862 }
866 # - Prefer own MediaWiki native name when not using the hook
867 # - For other names just add if not added through the hook
870 }
871 }
875 }
881 }
885 # We do this using a foreach over the codes instead of a directory
886 # loop so that messages files in extensions will work correctly.
890 }
891 }
893 }
894 # 'mw' option; default if it's not one of the other two options (all/mwfile)
896 }
898 /**
899 * @param $code string: The code of the language for which to get the name
900 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
901 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
902 * @return string: Language name or empty
903 * @since 1.20
904 */
908 }
910 /**
911 * Get a message from the MediaWiki namespace.
912 *
913 * @param $msg String: message name
914 * @return string
915 */
918 }
920 /**
921 * Get the native language name of $code.
922 * Only if defined in MediaWiki, no other data like CLDR.
923 * @param $code string
924 * @return string
925 * @deprecated in 1.20, use fetchLanguageName()
926 */
929 }
931 /**
932 * @param $key string
933 * @return string
934 */
937 }
939 /**
940 * @return array
941 */
946 }
948 }
950 /**
951 * @param $key string
952 * @return string
953 */
956 }
958 /**
959 * @param $key string
960 * @return string
961 */
964 }
966 /**
967 * @return array
968 */
973 }
975 }
977 /**
978 * @param $key string
979 * @return string
980 */
983 }
985 /**
986 * @param $key string
987 * @return string
988 */
991 }
993 /**
994 * @param $key string
995 * @return string
996 */
999 }
1001 /**
1002 * @param $key string
1003 * @return string
1004 */
1007 }
1009 /**
1010 * @param $key string
1011 * @return string
1012 */
1015 }
1017 /**
1018 * @param $key string
1019 * @return string
1020 */
1023 }
1025 /**
1026 * This is a workalike of PHP's date() function, but with better
1027 * internationalisation, a reduced set of format characters, and a better
1028 * escaping format.
1029 *
1030 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1031 * the PHP manual for definitions. There are a number of extensions, which
1032 * start with "x":
1033 *
1034 * xn Do not translate digits of the next numeric format character
1035 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1036 * xr Use roman numerals for the next numeric format character
1037 * xh Use hebrew numerals for the next numeric format character
1038 * xx Literal x
1039 * xg Genitive month name
1040 *
1041 * xij j (day number) in Iranian calendar
1042 * xiF F (month name) in Iranian calendar
1043 * xin n (month number) in Iranian calendar
1044 * xiy y (two digit year) in Iranian calendar
1045 * xiY Y (full year) in Iranian calendar
1046 *
1047 * xjj j (day number) in Hebrew calendar
1048 * xjF F (month name) in Hebrew calendar
1049 * xjt t (days in month) in Hebrew calendar
1050 * xjx xg (genitive month name) in Hebrew calendar
1051 * xjn n (month number) in Hebrew calendar
1052 * xjY Y (full year) in Hebrew calendar
1053 *
1054 * xmj j (day number) in Hijri calendar
1055 * xmF F (month name) in Hijri calendar
1056 * xmn n (month number) in Hijri calendar
1057 * xmY Y (full year) in Hijri calendar
1058 *
1059 * xkY Y (full year) in Thai solar calendar. Months and days are
1060 * identical to the Gregorian calendar
1061 * xoY Y (full year) in Minguo calendar or Juche year.
1062 * Months and days are identical to the
1063 * Gregorian calendar
1064 * xtY Y (full year) in Japanese nengo. Months and days are
1065 * identical to the Gregorian calendar
1066 *
1067 * Characters enclosed in double quotes will be considered literal (with
1068 * the quotes themselves removed). Unmatched quotes will be considered
1069 * literal quotes. Example:
1070 *
1071 * "The month is" F => The month is January
1072 * i's" => 20'11"
1073 *
1074 * Backslash escaping is also supported.
1075 *
1076 * Input timestamp is assumed to be pre-normalized to the desired local
1077 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1078 * $ts is UTC if $zone is not given.
1079 *
1080 * @param $format String
1081 * @param $ts String: 14-character timestamp
1082 * YYYYMMDDHHMMSS
1083 * 01234567890123
1084 * @param $zone DateTimeZone: Timezone of $ts
1085 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1086 *
1087 * @throws MWException
1088 * @return string
1089 */
1106 }
1110 }
1117 }
1119 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1121 }
1145 }
1155 );
1156 }
1165 }
1171 }
1177 }
1184 );
1185 }
1194 }
1200 }
1206 }
1221 }
1227 }
1233 }
1239 }
1248 }
1254 }
1260 }
1266 }
1272 }
1278 }
1287 }
1322 // Pass through string from $dateTimeObj->format()
1326 );
1327 }
1340 // Pass through number from $dateTimeObj->format()
1344 );
1345 }
1349 # Backslash escaping
1354 }
1357 # Quoted literal
1361 # No terminating quote, assume literal "
1366 }
1368 # Quote at end of string, assume literal "
1370 }
1374 }
1387 }
1388 }
1389 }
1391 }
1396 /**
1397 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1398 * Gregorian dates to Iranian dates. Originally written in C, it
1399 * is released under the terms of GNU Lesser General Public
1400 * License. Conversion to PHP was performed by Niklas Laxström.
1401 *
1402 * Link: http://www.farsiweb.info/jalali/jalali.c
1403 *
1404 * @param $ts string
1405 *
1406 * @return string
1407 */
1413 # Days passed from the beginning (including leap years)
1419 // Add days of the past months of this year
1422 }
1424 // Leap years
1427 }
1429 // Days passed in current month
1443 }
1447 }
1453 }
1455 /**
1456 * Converting Gregorian dates to Hijri dates.
1457 *
1458 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1459 *
1460 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1461 *
1462 * @param $ts string
1463 *
1464 * @return string
1465 */
1479 )
1480 {
1488 }
1493 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1494 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1500 }
1502 /**
1503 * Converting Gregorian dates to Hebrew dates.
1504 *
1505 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1506 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1507 * to translate the relevant functions into PHP and release them under
1508 * GNU GPL.
1509 *
1510 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1511 * and Adar II is 14. In a non-leap year, Adar is 6.
1512 *
1513 * @param $ts string
1514 *
1515 * @return string
1516 */
1518 # Parse date
1523 # Calculate Hebrew year
1526 # Month number when September = 1, August = 12
1529 # Next year
1533 }
1535 # Calculate day of year from 1 September
1539 # February
1541 # Check if the year is leap
1544 }
1549 }
1550 }
1552 # Calculate the start of the Hebrew year
1555 # Calculate next year's start
1557 # Day is before the start of the year - it is the previous year
1558 # Next year's start
1560 # Previous year
1563 # Add days since previous year's 1 September
1566 # Leap year
1568 }
1569 # Start of the new (previous) year
1572 # Next year's start
1574 }
1576 # Calculate Hebrew day of year
1579 # Difference between year's days
1581 # Add 12 (or 13 for leap years) days to ignore the difference between
1582 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1583 # difference is only about the year type
1588 }
1590 # Check the year pattern, and is leap year
1591 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1592 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1593 # and non-leap years
1595 # Check if leap year
1598 # Calculate day in the month from number of day in the Hebrew year
1599 # Don't check Adar - if the day is not in Adar, we will stop before;
1600 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1605 # Calculate days in this month
1607 # Adar in a leap year
1609 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1612 # Day in Adar I
1615 # Subtract the days of Adar I
1617 # Try Adar II
1620 # Day in Adar II
1622 }
1623 }
1624 }
1626 # Cheshvan in a complete year (otherwise as the rule below)
1629 # Kislev in an incomplete year (otherwise as the rule below)
1632 # Odd months have 30 days, even have 29
1634 }
1636 # In the current month
1639 # Subtract the days of the current month
1641 # Try in the next month
1643 }
1644 }
1647 }
1649 /**
1650 * This calculates the Hebrew year start, as days since 1 September.
1651 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1652 * Used for Hebrew date.
1653 *
1654 * @param $year int
1655 *
1656 * @return string
1657 */
1664 }
1668 }
1678 }
1682 }
1684 /**
1685 * Algorithm to convert Gregorian dates to Thai solar dates,
1686 * Minguo dates or Minguo dates.
1687 *
1688 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1689 * http://en.wikipedia.org/wiki/Minguo_calendar
1690 * http://en.wikipedia.org/wiki/Japanese_era_name
1691 *
1692 * @param $ts String: 14-character timestamp
1693 * @param $cName String: calender name
1694 * @return Array: converted year, month, day
1695 */
1702 # Thai solar dates
1703 # Add 543 years to the Gregorian calendar
1704 # Months and days are identical
1707 # Minguo dates
1708 # Deduct 1911 years from the Gregorian calendar
1709 # Months and days are identical
1712 # Nengō dates up to Meiji period
1713 # Deduct years from the Gregorian calendar
1714 # depending on the nengo periods
1715 # Months and days are identical
1716 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1717 # Meiji period
1722 }
1730 )
1731 {
1732 # Taishō period
1737 }
1743 )
1744 {
1745 # Shōwa period
1750 }
1753 # Heisei period
1758 }
1760 }
1763 }
1766 }
1768 /**
1769 * Roman number formatting up to 10000
1770 *
1771 * @param $num int
1772 *
1773 * @return string
1774 */
1780 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1781 );
1786 }
1792 }
1794 }
1796 }
1798 /**
1799 * Hebrew Gematria number formatting up to 9999
1800 *
1801 * @param $num int
1802 *
1803 * @return string
1804 */
1811 );
1816 }
1828 }
1829 }
1830 }
1832 }
1838 }
1857 }
1859 }
1861 /**
1862 * Used by date() and time() to adjust the time output.
1863 *
1864 * @param $ts Int the time in date('YmdHis') format
1865 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1866 * get user timecorrection setting)
1867 * @return int
1868 */
1874 }
1887 }
1888 # Unrecognized timezone, default to 'Offset' with the stored offset.
1890 }
1894 # Global offset in minutes.
1897 }
1908 }
1911 }
1912 }
1914 # No difference ? Return time unchanged
1917 }
1920 # Generate an adjusted date; take advantage of the fact that mktime
1921 # will normalize out-of-range values so we don't have to split $minDiff
1922 # into hours and minutes.
1935 }
1937 /**
1938 * This is meant to be used by time(), date(), and timeanddate() to get
1939 * the date preference they're supposed to use, it should be used in
1940 * all children.
1941 *
1942 *<code>
1943 * function timeanddate([...], $format = true) {
1944 * $datePreference = $this->dateFormat($format);
1945 * [...]
1946 * }
1947 *</code>
1948 *
1949 * @param $usePrefs Mixed: if true, the user's preference is used
1950 * if false, the site/language default is used
1951 * if int/string, assumed to be a format.
1952 * @return string
1953 */
1962 }
1965 }
1967 // return int
1970 }
1973 }
1975 /**
1976 * Get a format string for a given type and preference
1977 * @param $type string May be date, time or both
1978 * @param $pref string The format name as it appears in Messages*.php
1979 *
1980 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
1981 *
1982 * @return string
1983 */
1994 }
1999 }
2000 }
2002 }
2004 }
2006 /**
2007 * @param $ts Mixed: the time format which needs to be turned into a
2008 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2009 * @param $adj Bool: whether to adjust the time output according to the
2010 * user configured offset ($timecorrection)
2011 * @param $format Mixed: true to use user's date format preference
2012 * @param $timecorrection String|bool the time offset as returned by
2013 * validateTimeZone() in Special:Preferences
2014 * @return string
2015 */
2020 }
2023 }
2025 /**
2026 * @param $ts Mixed: the time format which needs to be turned into a
2027 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2028 * @param $adj Bool: whether to adjust the time output according to the
2029 * user configured offset ($timecorrection)
2030 * @param $format Mixed: true to use user's date format preference
2031 * @param $timecorrection String|bool the time offset as returned by
2032 * validateTimeZone() in Special:Preferences
2033 * @return string
2034 */
2039 }
2042 }
2044 /**
2045 * @param $ts Mixed: the time format which needs to be turned into a
2046 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2047 * @param $adj Bool: whether to adjust the time output according to the
2048 * user configured offset ($timecorrection)
2049 * @param $format Mixed: what format to return, if it's false output the
2050 * default one (default true)
2051 * @param $timecorrection String|bool the time offset as returned by
2052 * validateTimeZone() in Special:Preferences
2053 * @return string
2054 */
2059 }
2062 }
2064 /**
2065 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2066 *
2067 * @since 1.20
2068 *
2069 * @param integer $seconds The amount of seconds.
2070 * @param array $chosenIntervals The intervals to enable.
2071 *
2072 * @return string
2073 */
2082 }
2085 }
2087 /**
2088 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2089 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2090 *
2091 * @since 1.20
2092 *
2093 * @param integer $seconds The amount of seconds.
2094 * @param array $chosenIntervals The intervals to enable.
2095 *
2096 * @return array
2097 */
2100 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2101 }
2115 }
2116 }
2119 }
2121 /**
2122 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2123 *
2124 * @param $type String: can be 'date', 'time' or 'both'
2125 * @param $ts Mixed: the time format which needs to be turned into a
2126 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2127 * @param $user User object used to get preferences for timezone and format
2128 * @param $options Array, can contain the following keys:
2129 * - 'timecorrection': time correction, can have the following values:
2130 * - true: use user's preference
2131 * - false: don't use time correction
2132 * - integer: value of time correction in minutes
2133 * - 'format': format to use, can have the following values:
2134 * - true: use user's preference
2135 * - false: use default preference
2136 * - string: format to use
2137 * @since 1.19
2138 * @return String
2139 */
2148 }
2150 }
2155 }
2158 }
2160 /**
2161 * Get the formatted date for the given timestamp and formatted for
2162 * the given user.
2163 *
2164 * @param $ts Mixed: the time format which needs to be turned into a
2165 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2166 * @param $user User object used to get preferences for timezone and format
2167 * @param $options Array, can contain the following keys:
2168 * - 'timecorrection': time correction, can have the following values:
2169 * - true: use user's preference
2170 * - false: don't use time correction
2171 * - integer: value of time correction in minutes
2172 * - 'format': format to use, can have the following values:
2173 * - true: use user's preference
2174 * - false: use default preference
2175 * - string: format to use
2176 * @since 1.19
2177 * @return String
2178 */
2181 }
2183 /**
2184 * Get the formatted time for the given timestamp and formatted for
2185 * the given user.
2186 *
2187 * @param $ts Mixed: the time format which needs to be turned into a
2188 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2189 * @param $user User object used to get preferences for timezone and format
2190 * @param $options Array, can contain the following keys:
2191 * - 'timecorrection': time correction, can have the following values:
2192 * - true: use user's preference
2193 * - false: don't use time correction
2194 * - integer: value of time correction in minutes
2195 * - 'format': format to use, can have the following values:
2196 * - true: use user's preference
2197 * - false: use default preference
2198 * - string: format to use
2199 * @since 1.19
2200 * @return String
2201 */
2204 }
2206 /**
2207 * Get the formatted date and time for the given timestamp and formatted for
2208 * the given user.
2209 *
2210 * @param $ts Mixed: the time format which needs to be turned into a
2211 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2212 * @param $user User object used to get preferences for timezone and format
2213 * @param $options Array, can contain the following keys:
2214 * - 'timecorrection': time correction, can have the following values:
2215 * - true: use user's preference
2216 * - false: don't use time correction
2217 * - integer: value of time correction in minutes
2218 * - 'format': format to use, can have the following values:
2219 * - true: use user's preference
2220 * - false: use default preference
2221 * - string: format to use
2222 * @since 1.19
2223 * @return String
2224 */
2227 }
2229 /**
2230 * Convert an MWTimestamp into a pretty human-readable timestamp using
2231 * the given user preferences and relative base time.
2232 *
2233 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2234 * on your timestamp object, which will then call this function. Calling
2235 * this function directly will cause hooks to be skipped over.
2236 *
2237 * @see MWTimestamp::getHumanTimestamp
2238 * @param MWTimestamp $ts Timestamp to prettify
2239 * @param MWTimestamp $relativeTo Base timestamp
2240 * @param User $user User preferences to use
2241 * @return string Human timestamp
2242 * @since 1.21
2243 */
2246 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) - (int)$relativeTo->timestamp->format( 'w' ) );
2248 if ( $diff->invert || $days > 5 && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' ) ) {
2249 // Timestamps are in different years: use full timestamp
2250 // Also do full timestamp for future dates
2251 /**
2252 * @FIXME Add better handling of future timestamps.
2253 */
2257 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2261 // Timestamp within the past week: show the day of the week and time
2269 // Timestamp was yesterday: say 'yesterday' and the time.
2276 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2283 // From here on in, the timestamp was soon enough ago so that we can simply say
2284 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2286 // Less than 90 minutes, but more than an hour ago.
2289 // A few minutes ago.
2292 // Less than a minute, but more than 30 sec ago.
2295 // Less than 30 seconds ago.
2297 }
2300 }
2302 /**
2303 * @param $key string
2304 * @return array|null
2305 */
2308 }
2310 /**
2311 * @return array
2312 */
2315 }
2317 /**
2318 * @param $in
2319 * @param $out
2320 * @param $string
2321 * @return string
2322 */
2324 # This is a wrapper for iconv in all languages except esperanto,
2325 # which does some nasty x-conversions beforehand
2327 # Even with //IGNORE iconv can whine about illegal characters in
2328 # *input* string. We just ignore those too.
2329 # REF: http://bugs.php.net/bug.php?id=37166
2330 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2335 }
2337 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2339 /**
2340 * @param $matches array
2341 * @return mixed|string
2342 */
2345 }
2347 /**
2348 * @param $matches array
2349 * @return string
2350 */
2353 }
2355 /**
2356 * @param $matches array
2357 * @return string
2358 */
2362 }
2364 /**
2365 * @param $matches array
2366 * @return string
2367 */
2371 }
2373 /**
2374 * @param $matches array
2375 * @return string
2376 */
2379 }
2381 /**
2382 * @param $matches array
2383 * @return string
2384 */
2388 }
2390 /**
2391 * Make a string's first character uppercase
2392 *
2393 * @param $str string
2394 *
2395 * @return string
2396 */
2404 // fall back to more complex logic in case of multibyte strings
2406 }
2407 }
2409 /**
2410 * Convert a string to uppercase
2411 *
2412 * @param $str string
2413 * @param $first bool
2414 *
2415 * @return string
2416 */
2424 }
2427 }
2434 $str
2435 );
2438 }
2439 }
2440 }
2442 /**
2443 * @param $str string
2444 * @return mixed|string
2445 */
2457 }
2458 }
2460 /**
2461 * @param $str string
2462 * @param $first bool
2463 * @return mixed|string
2464 */
2472 }
2475 }
2482 $str
2483 );
2486 }
2487 }
2488 }
2490 /**
2491 * @param $str string
2492 * @return bool
2493 */
2496 }
2498 /**
2499 * @param $str string
2500 * @return mixed|string
2501 */
2506 // regexp to find first letter in each word (i.e. after each space)
2507 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2509 // function to use to capitalize a single char
2514 $str
2515 );
2520 $str
2521 );
2522 }
2525 }
2526 }
2528 /**
2529 * capitalize words at word breaks
2530 *
2531 * @param $str string
2532 * @return mixed
2533 */
2538 // since \b doesn't work for UTF-8, we explicitely define word break chars
2541 // find first letter after word break
2542 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2548 $str
2549 );
2554 $str
2555 );
2556 }
2561 $str
2562 );
2563 }
2564 }
2566 /**
2567 * Return a case-folded representation of $s
2568 *
2569 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2570 * and $s2 are the same except for the case of their characters. It is not
2571 * necessary for the value returned to make sense when displayed.
2572 *
2573 * Do *not* perform any other normalisation in this function. If a caller
2574 * uses this function when it should be using a more general normalisation
2575 * function, then fix the caller.
2576 *
2577 * @param $s string
2578 *
2579 * @return string
2580 */
2583 }
2585 /**
2586 * @param $s string
2587 * @return string
2588 */
2592 }
2595 }
2598 }
2600 /**
2601 * @return array
2602 */
2605 }
2607 /**
2608 * Most writing systems use whitespace to break up words.
2609 * Some languages such as Chinese don't conventionally do this,
2610 * which requires special handling when breaking up words for
2611 * searching etc.
2612 *
2613 * @return bool
2614 */
2617 }
2619 /**
2620 * Some languages such as Chinese require word segmentation,
2621 * Specify such segmentation when overridden in derived class.
2622 *
2623 * @param $string String
2624 * @return String
2625 */
2628 }
2630 /**
2631 * Some languages have special punctuation need to be normalized.
2632 * Make such changes here.
2633 *
2634 * @param $string String
2635 * @return String
2636 */
2639 }
2641 /**
2642 * convert double-width roman characters to single-width.
2643 * range: ff00-ff5f ~= 0020-007f
2644 *
2645 * @param $string string
2646 *
2647 * @return string
2648 */
2658 }
2662 }
2664 /**
2665 * @param $string string
2666 * @param $pattern string
2667 * @return string
2668 */
2673 }
2675 /**
2676 * @param $termsArray array
2677 * @return array
2678 */
2680 # some languages, e.g. Chinese, need to do a conversion
2681 # in order for search results to be displayed correctly
2683 }
2685 /**
2686 * Get the first character of a string.
2687 *
2688 * @param $s string
2689 * @return string
2690 */
2697 $matches
2698 );
2703 }
2705 // Break down Hangul syllables to grab the first jamo
2737 }
2740 }
2741 }
2744 # Some languages may have an alternate char encoding option
2745 # (Esperanto X-coding, Japanese furigana conversion, etc)
2746 # If this language is used as the primary content language,
2747 # an override to the defaults can be set here on startup.
2748 }
2750 /**
2751 * @param $s string
2752 * @return string
2753 */
2755 # For some languages we'll want to explicitly specify
2756 # which characters make it into the edit box raw
2757 # or are converted in some way or another.
2763 }
2764 }
2766 /**
2767 * @param $s string
2768 * @return string
2769 */
2771 # Take the previous into account.
2777 }
2782 }
2783 }
2785 /**
2786 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2787 * also cleans up certain backwards-compatible sequences, converting them
2788 * to the modern Unicode equivalent.
2789 *
2790 * This is language-specific for performance reasons only.
2791 *
2792 * @param $s string
2793 *
2794 * @return string
2795 */
2802 }
2805 }
2807 /**
2808 * Transform a string using serialized data stored in the given file (which
2809 * must be in the serialized subdirectory of $IP). The file contains pairs
2810 * mapping source characters to destination characters.
2811 *
2812 * The data is cached in process memory. This will go faster if you have the
2813 * FastStringSearch extension.
2814 *
2815 * @param $file string
2816 * @param $string string
2817 *
2818 * @throws MWException
2819 * @return string
2820 */
2826 }
2828 }
2830 }
2832 /**
2833 * For right-to-left language support
2834 *
2835 * @return bool
2836 */
2839 }
2841 /**
2842 * Return the correct HTML 'dir' attribute value for this language.
2843 * @return String
2844 */
2847 }
2849 /**
2850 * Return 'left' or 'right' as appropriate alignment for line-start
2851 * for this language's text direction.
2852 *
2853 * Should be equivalent to CSS3 'start' text-align value....
2854 *
2855 * @return String
2856 */
2859 }
2861 /**
2862 * Return 'right' or 'left' as appropriate alignment for line-end
2863 * for this language's text direction.
2864 *
2865 * Should be equivalent to CSS3 'end' text-align value....
2866 *
2867 * @return String
2868 */
2871 }
2873 /**
2874 * A hidden direction mark (LRM or RLM), depending on the language direction.
2875 * Unlike getDirMark(), this function returns the character as an HTML entity.
2876 * This function should be used when the output is guaranteed to be HTML,
2877 * because it makes the output HTML source code more readable. When
2878 * the output is plain text or can be escaped, getDirMark() should be used.
2879 *
2880 * @param $opposite Boolean Get the direction mark opposite to your language
2881 * @return string
2882 * @since 1.20
2883 */
2887 }
2889 }
2891 /**
2892 * A hidden direction mark (LRM or RLM), depending on the language direction.
2893 * This function produces them as invisible Unicode characters and
2894 * the output may be hard to read and debug, so it should only be used
2895 * when the output is plain text or can be escaped. When the output is
2896 * HTML, use getDirMarkEntity() instead.
2897 *
2898 * @param $opposite Boolean Get the direction mark opposite to your language
2899 * @return string
2900 */
2906 }
2908 }
2910 /**
2911 * @return array
2912 */
2915 }
2917 /**
2918 * An arrow, depending on the language direction.
2919 *
2920 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2921 * @return string
2922 */
2937 }
2938 }
2940 /**
2941 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2942 *
2943 * @return bool
2944 */
2947 }
2949 /**
2950 * @return array
2951 */
2954 }
2959 }
2964 }
2966 /**
2967 * Fill a MagicWord object with data from here
2968 *
2969 * @param $mw
2970 */
2982 }
2983 }
2990 }
2991 }
2993 /**
2994 * Add magic words to the extension array
2995 *
2996 * @param $newWords array
2997 */
3004 }
3005 }
3006 }
3008 /**
3009 * Get special page names, as an associative array
3010 * case folded alias => real name
3011 */
3013 // Cache aliases because it may be slow to load them
3015 // Initialise array
3020 }
3023 }
3025 /**
3026 * Italic is unsuitable for some languages
3027 *
3028 * @param $text String: the text to be emphasized.
3029 * @return string
3030 */
3033 }
3035 /**
3036 * Normally we output all numbers in plain en_US style, that is
3037 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3038 * point twohundredthirtyfive. However this is not suitable for all
3039 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
3040 * Icelandic just want to use commas instead of dots, and dots instead
3041 * of commas like "293.291,235".
3042 *
3043 * An example of this function being called:
3044 * <code>
3045 * wfMessage( 'message' )->numParams( $num )->text()
3046 * </code>
3047 *
3048 * See LanguageGu.php for the Gujarati implementation and
3049 * $separatorTransformTable on MessageIs.php for
3050 * the , => . and . => , implementation.
3051 *
3052 * @todo check if it's viable to use localeconv() for the decimal
3053 * separator thing.
3054 * @param $number Mixed: the string to be formatted, should be an integer
3055 * or a floating point number.
3056 * @param $nocommafy Bool: set to true for special numbers like dates
3057 * @return string
3058 */
3066 }
3067 }
3073 }
3074 }
3077 }
3079 /**
3080 * Front-end for non-commafied formatNum
3081 *
3082 * @param mixed $number the string to be formatted, should be an integer
3083 * or a floating point number.
3084 * @since 1.21
3085 * @return string
3086 */
3089 }
3091 /**
3092 * @param $number string
3093 * @return string
3094 */
3099 }
3104 }
3108 }
3110 /**
3111 * Adds commas to a given number
3112 * @since 1.19
3113 * @param $number mixed
3114 * @return string
3115 */
3120 }
3123 // default grouping is at thousands, use the same for ###,###,### pattern too.
3126 // Ref: http://cldr.unicode.org/translation/number-patterns
3129 // For negative numbers apply the algorithm like positive number and add sign.
3132 }
3140 // the string does not have any number part. Eg: .12345
3142 }
3150 }
3154 // use the last pattern for the rest of the number
3156 }
3159 }
3160 }
3162 }
3163 }
3165 /**
3166 * @return String
3167 */
3170 }
3172 /**
3173 * @return array
3174 */
3177 }
3179 /**
3180 * @return array
3181 */
3184 }
3186 /**
3187 * Take a list of strings and build a locale-friendly comma-separated
3188 * list, using the local comma-separator message.
3189 * The last two strings are chained with an "and".
3190 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3191 *
3192 * @param $l Array
3193 * @return string
3194 */
3199 }
3205 }
3206 }
3213 }
3214 }
3216 }
3218 /**
3219 * Take a list of strings and build a locale-friendly comma-separated
3220 * list, using the local comma-separator message.
3221 * @param $list array of strings to put in a comma list
3222 * @return string
3223 */
3227 $list
3228 );
3229 }
3231 /**
3232 * Take a list of strings and build a locale-friendly semicolon-separated
3233 * list, using the local semicolon-separator message.
3234 * @param $list array of strings to put in a semicolon list
3235 * @return string
3236 */
3240 $list
3241 );
3242 }
3244 /**
3245 * Same as commaList, but separate it with the pipe instead.
3246 * @param $list array of strings to put in a pipe list
3247 * @return string
3248 */
3252 $list
3253 );
3254 }
3256 /**
3257 * Truncate a string to a specified length in bytes, appending an optional
3258 * string (e.g. for ellipses)
3259 *
3260 * The database offers limited byte lengths for some columns in the database;
3261 * multi-byte character sets mean we need to ensure that only whole characters
3262 * are included, otherwise broken characters can be passed to the user
3263 *
3264 * If $length is negative, the string will be truncated from the beginning
3265 *
3266 * @param $string String to truncate
3267 * @param $length Int: maximum length (including ellipses)
3268 * @param $ellipsis String to append to the truncated text
3269 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3270 * $adjustLength was introduced in 1.18, before that behaved as if false.
3271 * @return string
3272 */
3274 # Use the localized ellipsis character
3277 }
3278 # Check if there is no need to truncate
3283 }
3285 # If ellipsis length is >= $length then we can't apply $adjustLength
3288 # Otherwise, truncate and add ellipsis...
3301 }
3302 }
3303 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3304 # This check is *not* redundant if $adjustLength, due to the single case where
3305 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3310 }
3311 }
3313 /**
3314 * Remove bytes that represent an incomplete Unicode character
3315 * at the end of string (e.g. bytes of the char are missing)
3316 *
3317 * @param $string String
3318 * @return string
3319 */
3325 # We got the first byte only of a multibyte char; remove it.
3330 ) {
3331 # We chopped in the middle of a character; remove it
3333 }
3334 }
3336 }
3338 /**
3339 * Remove bytes that represent an incomplete Unicode character
3340 * at the start of string (e.g. bytes of the char are missing)
3341 *
3342 * @param $string String
3343 * @return string
3344 */
3349 # We chopped in the middle of a character; remove the whole thing
3351 }
3352 }
3354 }
3356 /**
3357 * Truncate a string of valid HTML to a specified length in bytes,
3358 * appending an optional string (e.g. for ellipses), and return valid HTML
3359 *
3360 * This is only intended for styled/linked text, such as HTML with
3361 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3362 * Also, this will not detect things like "display:none" CSS.
3363 *
3364 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3365 *
3366 * @param string $text HTML string to truncate
3367 * @param int $length (zero/positive) Maximum length (including ellipses)
3368 * @param string $ellipsis String to append to the truncated text
3369 * @return string
3370 */
3372 # Use the localized ellipsis character
3375 }
3376 # Check if there is clearly no need to truncate
3381 }
3395 # Consider truncation once the display length has reached the maximim.
3396 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3397 # Check that we're not in the middle of a bracket/entity...
3401 # Save where we are; we will truncate here unless there turn out to
3402 # be so few remaining characters that truncation is not necessary.
3405 }
3407 # String in fact does need truncation, the truncation point was OK.
3412 }
3413 }
3416 }
3418 # Read the next char...
3436 }
3442 // Name found (e.g. "<a href=..."), add on tag attributes...
3444 }
3450 }
3453 // Save state without $ch. We want to *hit* the first
3454 // display char (to get tags) but not *use* it if truncating.
3456 }
3461 // Add the next $max display text chars after this in one swoop...
3466 }
3467 }
3468 }
3469 }
3470 // Close the last tag if left unclosed by bad HTML
3474 }
3476 }
3478 /**
3479 * truncateHtml() helper function
3480 * like strcspn() but adds the skipped chars to $ret
3481 *
3482 * @param $ret
3483 * @param $text
3484 * @param $search
3485 * @param $start
3486 * @param $len
3487 * @return int
3488 */
3494 }
3499 }
3501 }
3503 /**
3504 * truncateHtml() helper function
3505 * (a) push or pop $tag from $openTags as needed
3506 * (b) clear $tag value
3507 * @param &$tag string Current HTML tag name we are looking at
3508 * @param $tagType int (0-open tag, 1-close tag)
3509 * @param $lastCh string Character before the '>' that ended this tag
3510 * @param &$openTags array Open tag stack (not accounting for $tag)
3511 */
3520 }
3521 }
3523 }
3524 }
3526 /**
3527 * Grammatical transformations, needed for inflected languages
3528 * Invoked by putting {{grammar:case|word}} in a message
3529 *
3530 * @param $word string
3531 * @param $case string
3532 * @return string
3533 */
3538 }
3540 }
3541 /**
3542 * Get the grammar forms for the content language
3543 * @return array of grammar forms
3544 * @since 1.20
3545 */
3548 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3550 }
3552 }
3553 /**
3554 * Provides an alternative text depending on specified gender.
3555 * Usage {{gender:username|masculine|feminine|neutral}}.
3556 * username is optional, in which case the gender of current user is used,
3557 * but only in (some) interface messages; otherwise default gender is used.
3558 *
3559 * If no forms are given, an empty string is returned. If only one form is
3560 * given, it will be returned unconditionally. These details are implied by
3561 * the caller and cannot be overridden in subclasses.
3562 *
3563 * If more than one form is given, the default is to use the neutral one
3564 * if it is specified, and to use the masculine one otherwise. These
3565 * details can be overridden in subclasses.
3566 *
3567 * @param $gender string
3568 * @param $forms array
3569 *
3570 * @return string
3571 */
3575 }
3579 }
3582 }
3584 }
3586 /**
3587 * Plural form transformations, needed for some languages.
3588 * For example, there are 3 form of plural in Russian and Polish,
3589 * depending on "count mod 10". See [[w:Plural]]
3590 * For English it is pretty simple.
3591 *
3592 * Invoked by putting {{plural:count|wordform1|wordform2}}
3593 * or {{plural:count|wordform1|wordform2|wordform3}}
3594 *
3595 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3596 *
3597 * @param $count Integer: non-localized number
3598 * @param $forms Array: different plural forms
3599 * @return string Correct form of plural for $count in this language
3600 */
3604 }
3606 // Handle explicit n=pluralform cases
3612 }
3614 }
3615 }
3621 }
3623 /**
3624 * Checks that convertPlural was given an array and pads it to requested
3625 * amount of forms by copying the last one.
3626 *
3627 * @param $count Integer: How many forms should there be at least
3628 * @param $forms Array of forms given to convertPlural
3629 * @return array Padded array of forms or an exception if not an array
3630 */
3634 }
3636 }
3638 /**
3639 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3640 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3641 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3642 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3643 * match up with it.
3644 *
3645 * @param $str String: the validated block duration in English
3646 * @return string Somehow translated block duration
3647 * @see LanguageFi.php for example implementation
3648 */
3654 }
3655 }
3657 // Since usually only infinite or indefinite is only on list, so try
3658 // equivalents if still here.
3665 }
3666 }
3667 }
3669 // If all else fails, return a standard duration or timestamp description.
3674 // $time is relative to 0 so it's a duration length.
3678 // wfTimestamp() handles 0 as current time instead of epoch.
3682 }
3683 }
3684 }
3686 /**
3687 * languages like Chinese need to be segmented in order for the diff
3688 * to be of any use
3689 *
3690 * @param $text String
3691 * @return String
3692 */
3695 }
3697 /**
3698 * and unsegment to show the result
3699 *
3700 * @param $text String
3701 * @return String
3702 */
3705 }
3707 /**
3708 * Return the LanguageConverter used in the Language
3709 *
3710 * @since 1.19
3711 * @return LanguageConverter
3712 */
3715 }
3717 /**
3718 * convert text to all supported variants
3719 *
3720 * @param $text string
3721 * @return array
3722 */
3725 }
3727 /**
3728 * convert text to different variants of a language.
3729 *
3730 * @param $text string
3731 * @return string
3732 */
3735 }
3737 /**
3738 * Convert a Title object to a string in the preferred variant
3739 *
3740 * @param $title Title
3741 * @return string
3742 */
3745 }
3747 /**
3748 * Convert a namespace index to a string in the preferred variant
3749 *
3750 * @param $ns int
3751 * @return string
3752 */
3755 }
3757 /**
3758 * Check if this is a language with variants
3759 *
3760 * @return bool
3761 */
3764 }
3766 /**
3767 * Check if the language has the specific variant
3768 *
3769 * @since 1.19
3770 * @param $variant string
3771 * @return bool
3772 */
3775 }
3777 /**
3778 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3779 *
3780 * @param $text string
3781 * @return string
3782 */
3785 }
3787 /**
3788 * Perform output conversion on a string, and encode for safe HTML output.
3789 * @param $text String text to be converted
3790 * @param $isTitle Bool whether this conversion is for the article title
3791 * @return string
3792 * @todo this should get integrated somewhere sane
3793 */
3796 }
3798 /**
3799 * @param $key string
3800 * @return string
3801 */
3804 }
3806 /**
3807 * Get the list of variants supported by this language
3808 * see sample implementation in LanguageZh.php
3809 *
3810 * @return array an array of language codes
3811 */
3814 }
3816 /**
3817 * @return string
3818 */
3821 }
3823 /**
3824 * @return string
3825 */
3828 }
3830 /**
3831 * @return string
3832 */
3835 }
3837 /**
3838 * If a language supports multiple variants, it is
3839 * possible that non-existing link in one variant
3840 * actually exists in another variant. this function
3841 * tries to find it. See e.g. LanguageZh.php
3842 *
3843 * @param $link String: the name of the link
3844 * @param $nt Mixed: the title object of the link
3845 * @param $ignoreOtherCond Boolean: to disable other conditions when
3846 * we need to transclude a template or update a category's link
3847 * @return null the input parameters may be modified upon return
3848 */
3851 }
3853 /**
3854 * If a language supports multiple variants, converts text
3855 * into an array of all possible variants of the text:
3856 * 'variant' => text in that variant
3857 *
3858 * @deprecated since 1.17 Use autoConvertToAllVariants()
3859 *
3860 * @param $text string
3861 *
3862 * @return string
3863 */
3866 }
3868 /**
3869 * returns language specific options used by User::getPageRenderHash()
3870 * for example, the preferred language variant
3871 *
3872 * @return string
3873 */
3876 }
3878 /**
3879 * For languages that support multiple variants, the title of an
3880 * article may be displayed differently in different variants. this
3881 * function returns the apporiate title defined in the body of the article.
3882 *
3883 * @return string
3884 */
3887 }
3889 /**
3890 * Prepare external link text for conversion. When the text is
3891 * a URL, it shouldn't be converted, and it'll be wrapped in
3892 * the "raw" tag (-{R| }-) to prevent conversion.
3893 *
3894 * This function is called "markNoConversion" for historical
3895 * reasons.
3896 *
3897 * @param $text String: text to be used for external link
3898 * @param $noParse bool: wrap it without confirming it's a real URL first
3899 * @return string the tagged text
3900 */
3902 // Excluding protocal-relative URLs may avoid many false positives.
3907 }
3908 }
3910 /**
3911 * A regular expression to match legal word-trailing characters
3912 * which should be merged onto a link of the form [[foo]]bar.
3913 *
3914 * @return string
3915 */
3918 }
3920 /**
3921 * @return Language
3922 */
3925 }
3927 /**
3928 * Get the RFC 3066 code for this language object
3929 *
3930 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3931 * htmlspecialchars() or similar
3932 *
3933 * @return string
3934 */
3937 }
3939 /**
3940 * Get the code in Bcp47 format which we can use
3941 * inside of html lang="" tags.
3942 *
3943 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3944 * htmlspecialchars() or similar.
3945 *
3946 * @since 1.19
3947 * @return string
3948 */
3952 }
3954 }
3956 /**
3957 * @param $code string
3958 */
3961 // Ensure we don't leave an incorrect html code lying around
3963 }
3965 /**
3966 * Get the name of a file for a certain language code
3967 * @param $prefix string Prepend this to the filename
3968 * @param $code string Language code
3969 * @param $suffix string Append this to the filename
3970 * @throws MWException
3971 * @return string $prefix . $mangledCode . $suffix
3972 */
3974 // Protect against path traversal
3977 {
3979 }
3982 }
3984 /**
3985 * Get the language code from a file name. Inverse of getFileName()
3986 * @param $filename string $prefix . $languageCode . $suffix
3987 * @param $prefix string Prefix before the language code
3988 * @param $suffix string Suffix after the language code
3989 * @return string Language code, or false if $prefix or $suffix isn't found
3990 */
3991 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3997 }
3999 }
4001 /**
4002 * @param $code string
4003 * @return string
4004 */
4010 }
4012 /**
4013 * @param $code string
4014 * @return string
4015 */
4019 }
4021 /**
4022 * Get the first fallback for a given language.
4023 *
4024 * @param $code string
4025 *
4026 * @return bool|string
4027 */
4035 }
4036 }
4038 /**
4039 * Get the ordered list of fallback languages.
4040 *
4041 * @since 1.19
4042 * @param $code string Language code
4043 * @return array
4044 */
4053 }
4055 }
4056 }
4058 /**
4059 * Get all messages for a given language
4060 * WARNING: this may take a long time. If you just need all message *keys*
4061 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4062 *
4063 * @param $code string
4064 *
4065 * @return array
4066 */
4069 }
4071 /**
4072 * Get a message for a given language
4073 *
4074 * @param $key string
4075 * @param $code string
4076 *
4077 * @return string
4078 */
4081 }
4083 /**
4084 * Get all message keys for a given language. This is a faster alternative to
4085 * array_keys( Language::getMessagesFor( $code ) )
4086 *
4087 * @since 1.19
4088 * @param $code string Language code
4089 * @return array of message keys (strings)
4090 */
4093 }
4095 /**
4096 * @param $talk
4097 * @return mixed
4098 */
4102 }
4107 # Allow grammar transformations
4108 # Allowing full message-style parsing would make simple requests
4109 # such as action=raw much more expensive than they need to be.
4110 # This will hopefully cover most cases.
4114 }
4116 /**
4117 * @param $m string
4118 * @return string
4119 */
4122 }
4124 /**
4125 * @throws MWException
4126 * @return array
4127 */
4132 }
4139 }
4144 }
4146 /**
4147 * Decode an expiry (block, protection, etc) which has come from the DB
4148 *
4149 * @todo FIXME: why are we returnings DBMS-dependent strings???
4150 *
4151 * @param $expiry String: Database expiry String
4152 * @param $format Bool|Int true to process using language functions, or TS_ constant
4153 * to return the expiry in a given timestamp
4154 * @return String
4155 * @since 1.18
4156 */
4161 }
4171 }
4172 }
4174 /**
4175 * @todo Document
4176 * @param $seconds int|float
4177 * @param $format Array Optional
4178 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4179 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4180 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4181 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4182 * @return string
4183 */
4187 }
4190 }
4193 }
4215 }
4226 }
4230 }
4236 }
4244 }
4254 }
4258 }
4268 }
4269 }
4271 }
4273 /**
4274 * Format a bitrate for output, using an appropriate
4275 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4276 *
4277 * This use base 1000. For base 1024 use formatSize(), for another base
4278 * see formatComputingNumbers()
4279 *
4280 * @param $bps int
4281 * @return string
4282 */
4285 }
4287 /**
4288 * @param $size int Size of the unit
4289 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4290 * @param $messageKey string Message key to be uesd
4291 * @return string
4292 */
4297 );
4298 }
4306 }
4308 // For small sizes no decimal places necessary
4311 // For MB and bigger two decimal places are smarter
4313 }
4319 }
4321 /**
4322 * Format a size in bytes for output, using an appropriate
4323 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4324 *
4325 * This method use base 1024. For base 1000 use formatBitrate(), for
4326 * another base see formatComputingNumbers()
4327 *
4328 * @param $size int Size to format
4329 * @return string Plain text (not HTML)
4330 */
4333 }
4335 /**
4336 * Make a list item, used by various special pages
4337 *
4338 * @param $page String Page link
4339 * @param $details String Text between brackets
4340 * @param $oppositedm Boolean Add the direction mark opposite to your
4341 * language, to display text properly
4342 * @return String
4343 */
4350 }
4352 /**
4353 * Generate (prev x| next x) (20|50|100...) type links for paging
4354 *
4355 * @param $title Title object to link
4356 * @param $offset Integer offset parameter
4357 * @param $limit Integer limit parameter
4358 * @param $query array|String optional URL query parameter string
4359 * @param $atend Bool optional param for specified if this is the last page
4360 * @return String
4361 */
4362 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4363 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4365 # Make 'previous' link
4366 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4372 }
4374 # Make 'next' link
4375 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4381 }
4383 # Make links to set number of items per page
4388 }
4392 }
4394 /**
4395 * Helper function for viewPrevNext() that generates links
4396 *
4397 * @param $title Title object to link
4398 * @param $offset Integer offset parameter
4399 * @param $limit Integer limit parameter
4400 * @param $query Array extra query parameters
4401 * @param $link String text to use for the link; will be escaped
4402 * @param $tooltipMsg String name of the message to use as tooltip
4403 * @param $class String value of the "class" attribute of the link
4404 * @return String HTML fragment
4405 */
4406 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4408 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4411 }
4413 /**
4414 * Get the conversion rule title, if any.
4415 *
4416 * @return string
4417 */
4420 }
4422 /**
4423 * Get the compiled plural rules for the language
4424 * @since 1.20
4425 * @return array Associative array with plural form, and plural rule as key-value pairs
4426 */
4432 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4435 }
4436 }
4437 }
4439 }
4441 /**
4442 * Get the plural rules for the language
4443 * @since 1.20
4444 * @return array Associative array with plural form number and plural rule as key-value pairs
4445 */
4454 }
4455 }
4456 }
4458 }
4460 /**
4461 * Get the plural rule types for the language
4462 * @since 1.21
4463 * @return array Associative array with plural form number and plural rule type as key-value pairs
4464 */
4470 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4473 }
4474 }
4475 }
4477 }
4479 /**
4480 * Find the index number of the plural rule appropriate for the given number
4481 * @return int The index number of the plural rule
4482 */
4487 }
4489 /**
4490 * Find the plural rule type appropriate for the given number
4491 * For example, if the language is set to Arabic, getPluralType(5) should
4492 * return 'few'.
4493 * @since 1.21
4494 * @return string The name of the plural rule type, e.g. one, two, few, many
4495 */
4503 }
4504 }
4505 }