| blob | 92ea75c814b197a972a30e5ee06c5fbfca4b13f4 |
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 */
390 }
394 ) {
396 }
399 }
401 /**
402 * @param $code
403 * @return String Name of the language class
404 */
410 }
411 }
413 /**
414 * Includes language class files
415 *
416 * @param $class string Name of the language class
417 */
423 }
427 }
428 }
430 /**
431 * Get the LocalisationCache instance
432 *
433 * @return LocalisationCache
434 */
440 }
442 }
446 // Set the code to the name of the descendant
451 }
453 }
455 /**
456 * Reduce memory usage
457 */
461 }
462 }
464 /**
465 * Hook which will be called if this is the content language.
466 * Descendants can use this to register hook functions or modify globals
467 */
470 /**
471 * Same as getFallbacksFor for current language.
472 * @return array|bool
473 * @deprecated in 1.19
474 */
478 }
480 /**
481 * @return array
482 * @since 1.19
483 */
486 }
488 /**
489 * Exports $wgBookstoreListEn
490 * @return array
491 */
494 }
496 /**
497 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
498 * available in localised form, it will be included in English.
499 *
500 * @return array
501 */
518 }
520 # Sometimes a language will be localised but not actually exist on this wiki.
524 }
525 }
527 # The above mixing may leave namespaces out of canonical order.
528 # Re-order by namespace ID number...
532 }
534 }
536 /**
537 * Arbitrarily set all of the namespace names at once. Mainly used for testing
538 * @param $namespaces Array of namespaces (id => name)
539 */
543 }
545 /**
546 * Resets all of the namespace caches. Mainly used for testing
547 */
552 }
554 /**
555 * A convenience function that returns the same thing as
556 * getNamespaces() except with the array values changed to ' '
557 * where it found '_', useful for producing output to be displayed
558 * e.g. in <select> forms.
559 *
560 * @return array
561 */
566 }
568 }
570 /**
571 * Get a namespace value by key
572 * <code>
573 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
574 * echo $mw_ns; // prints 'MediaWiki'
575 * </code>
576 *
577 * @param $index Int: the array key of the namespace to return
578 * @return mixed, string if the namespace value exists, otherwise false
579 */
583 }
585 /**
586 * A convenience function that returns the same thing as
587 * getNsText() except with '_' changed to ' ', useful for
588 * producing output.
589 *
590 * <code>
591 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
592 * echo $mw_ns; // prints 'MediaWiki talk'
593 * </code>
594 *
595 * @param int $index The array key of the namespace to return
596 * @return string Namespace name without underscores (empty string if namespace does not exist)
597 */
601 }
603 /**
604 * Returns gender-dependent namespace alias if available.
605 * @param $index Int: namespace index
606 * @param $gender String: gender key (male, female... )
607 * @return String
608 * @since 1.18
609 */
613 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
615 }
617 /**
618 * Whether this language makes distinguishes genders for example in
619 * namespaces.
620 * @return bool
621 * @since 1.18
622 */
626 // $wgExtraGenderNamespaces overrides everything
628 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
629 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
630 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
633 // Check what is in i18n files
636 }
637 }
639 /**
640 * Get a namespace key by value, case insensitive.
641 * Only matches namespace names for the current language, not the
642 * canonical ones defined in Namespace.php.
643 *
644 * @param $text String
645 * @return mixed An integer if $text is a valid value otherwise false
646 */
651 }
653 /**
654 * @return array
655 */
667 }
668 }
669 }
672 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
676 }
677 }
680 }
682 }
684 /**
685 * @return array
686 */
690 # Put namespace names and aliases into a hashtable.
691 # If this is too slow, then we should arrange it so that it is done
692 # before caching. The catch is that at pre-cache time, the above
693 # class-specific fixup hasn't been done.
697 }
700 }
704 }
705 }
706 }
708 }
710 /**
711 * Get a namespace key by value, case insensitive. Canonical namespace
712 * names override custom ones defined for the current language.
713 *
714 * @param $text String
715 * @return mixed An integer if $text is a valid value otherwise false
716 */
722 }
725 }
727 /**
728 * short names for language variants used for language conversion links.
729 *
730 * @param $code String
731 * @param $usemsg bool Use the "variantname-xyz" message if it exists
732 * @return string
733 */
738 }
743 # otherwise, output the language code
745 }
746 }
748 /**
749 * @param $name string
750 * @return string
751 */
756 }
758 }
760 /**
761 * @return array
762 */
765 }
767 /**
768 * @return array
769 */
772 }
774 /**
775 * @return array|string
776 */
784 }
785 }
787 /**
788 * @return array
789 */
792 }
794 /**
795 * @param $image
796 * @return array|null
797 */
800 }
802 /**
803 * @return array
804 */
807 }
809 /**
810 * @param $tog
811 * @return string
812 */
815 }
817 /**
818 * Get native language names, indexed by code.
819 * Only those defined in MediaWiki, no other data like CLDR.
820 * If $customisedOnly is true, only returns codes with a messages file
821 *
822 * @param $customisedOnly bool
823 *
824 * @return array
825 * @deprecated in 1.20, use fetchLanguageNames()
826 */
829 }
831 /**
832 * Get translated language names. This is done on best effort and
833 * by default this is exactly the same as Language::getLanguageNames.
834 * The CLDR extension provides translated names.
835 * @param $code String Language code.
836 * @return Array language code => language name
837 * @since 1.18.0
838 * @deprecated in 1.20, use fetchLanguageNames()
839 */
842 }
844 /**
845 * Get an array of language names, indexed by code.
846 * @param $inLanguage null|string: Code of language in which to return the names
847 * Use null for autonyms (native names)
848 * @param $include string:
849 * 'all' all available languages
850 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
851 * 'mwfile' only if the language is in 'mw' *and* has a message file
852 * @return array: language code => language name
853 * @since 1.20
854 */
861 }
866 # TODO: also include when $inLanguage is null, when this code is more efficient
868 }
872 # - Prefer own MediaWiki native name when not using the hook
873 # - For other names just add if not added through the hook
876 }
877 }
881 }
887 }
891 # We do this using a foreach over the codes instead of a directory
892 # loop so that messages files in extensions will work correctly.
896 }
897 }
899 }
900 # 'mw' option; default if it's not one of the other two options (all/mwfile)
902 }
904 /**
905 * @param $code string: The code of the language for which to get the name
906 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
907 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
908 * @return string: Language name or empty
909 * @since 1.20
910 */
914 }
916 /**
917 * Get a message from the MediaWiki namespace.
918 *
919 * @param $msg String: message name
920 * @return string
921 */
924 }
926 /**
927 * Get the native language name of $code.
928 * Only if defined in MediaWiki, no other data like CLDR.
929 * @param $code string
930 * @return string
931 * @deprecated in 1.20, use fetchLanguageName()
932 */
935 }
937 /**
938 * @param $key string
939 * @return string
940 */
943 }
945 /**
946 * @return array
947 */
952 }
954 }
956 /**
957 * @param $key string
958 * @return string
959 */
962 }
964 /**
965 * @param $key string
966 * @return string
967 */
970 }
972 /**
973 * @return array
974 */
979 }
981 }
983 /**
984 * @param $key string
985 * @return string
986 */
989 }
991 /**
992 * @param $key string
993 * @return string
994 */
997 }
999 /**
1000 * @param $key string
1001 * @return string
1002 */
1005 }
1007 /**
1008 * @param $key string
1009 * @return string
1010 */
1013 }
1015 /**
1016 * @param $key string
1017 * @return string
1018 */
1021 }
1023 /**
1024 * @param $key string
1025 * @return string
1026 */
1029 }
1031 /**
1032 * This is a workalike of PHP's date() function, but with better
1033 * internationalisation, a reduced set of format characters, and a better
1034 * escaping format.
1035 *
1036 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1037 * the PHP manual for definitions. There are a number of extensions, which
1038 * start with "x":
1039 *
1040 * xn Do not translate digits of the next numeric format character
1041 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1042 * xr Use roman numerals for the next numeric format character
1043 * xh Use hebrew numerals for the next numeric format character
1044 * xx Literal x
1045 * xg Genitive month name
1046 *
1047 * xij j (day number) in Iranian calendar
1048 * xiF F (month name) in Iranian calendar
1049 * xin n (month number) in Iranian calendar
1050 * xiy y (two digit year) in Iranian calendar
1051 * xiY Y (full year) in Iranian calendar
1052 *
1053 * xjj j (day number) in Hebrew calendar
1054 * xjF F (month name) in Hebrew calendar
1055 * xjt t (days in month) in Hebrew calendar
1056 * xjx xg (genitive month name) in Hebrew calendar
1057 * xjn n (month number) in Hebrew calendar
1058 * xjY Y (full year) in Hebrew calendar
1059 *
1060 * xmj j (day number) in Hijri calendar
1061 * xmF F (month name) in Hijri calendar
1062 * xmn n (month number) in Hijri calendar
1063 * xmY Y (full year) in Hijri calendar
1064 *
1065 * xkY Y (full year) in Thai solar calendar. Months and days are
1066 * identical to the Gregorian calendar
1067 * xoY Y (full year) in Minguo calendar or Juche year.
1068 * Months and days are identical to the
1069 * Gregorian calendar
1070 * xtY Y (full year) in Japanese nengo. Months and days are
1071 * identical to the Gregorian calendar
1072 *
1073 * Characters enclosed in double quotes will be considered literal (with
1074 * the quotes themselves removed). Unmatched quotes will be considered
1075 * literal quotes. Example:
1076 *
1077 * "The month is" F => The month is January
1078 * i's" => 20'11"
1079 *
1080 * Backslash escaping is also supported.
1081 *
1082 * Input timestamp is assumed to be pre-normalized to the desired local
1083 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1084 * $ts is UTC if $zone is not given.
1085 *
1086 * @param $format String
1087 * @param $ts String: 14-character timestamp
1088 * YYYYMMDDHHMMSS
1089 * 01234567890123
1090 * @param $zone DateTimeZone: Timezone of $ts
1091 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1092 *
1093 * @throws MWException
1094 * @return string
1095 */
1112 }
1116 }
1123 }
1125 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1127 }
1151 }
1161 );
1162 }
1171 }
1177 }
1183 }
1190 );
1191 }
1200 }
1206 }
1212 }
1227 }
1233 }
1239 }
1245 }
1254 }
1260 }
1266 }
1272 }
1278 }
1284 }
1293 }
1328 // Pass through string from $dateTimeObj->format()
1332 );
1333 }
1346 // Pass through number from $dateTimeObj->format()
1350 );
1351 }
1355 # Backslash escaping
1360 }
1363 # Quoted literal
1367 # No terminating quote, assume literal "
1372 }
1374 # Quote at end of string, assume literal "
1376 }
1380 }
1393 }
1394 }
1395 }
1397 }
1402 /**
1403 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1404 * Gregorian dates to Iranian dates. Originally written in C, it
1405 * is released under the terms of GNU Lesser General Public
1406 * License. Conversion to PHP was performed by Niklas Laxström.
1407 *
1408 * Link: http://www.farsiweb.info/jalali/jalali.c
1409 *
1410 * @param $ts string
1411 *
1412 * @return string
1413 */
1419 # Days passed from the beginning (including leap years)
1425 // Add days of the past months of this year
1428 }
1430 // Leap years
1433 }
1435 // Days passed in current month
1449 }
1453 }
1459 }
1461 /**
1462 * Converting Gregorian dates to Hijri dates.
1463 *
1464 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1465 *
1466 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1467 *
1468 * @param $ts string
1469 *
1470 * @return string
1471 */
1485 )
1486 {
1494 }
1499 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1500 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1506 }
1508 /**
1509 * Converting Gregorian dates to Hebrew dates.
1510 *
1511 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1512 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1513 * to translate the relevant functions into PHP and release them under
1514 * GNU GPL.
1515 *
1516 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1517 * and Adar II is 14. In a non-leap year, Adar is 6.
1518 *
1519 * @param $ts string
1520 *
1521 * @return string
1522 */
1524 # Parse date
1529 # Calculate Hebrew year
1532 # Month number when September = 1, August = 12
1535 # Next year
1539 }
1541 # Calculate day of year from 1 September
1545 # February
1547 # Check if the year is leap
1550 }
1555 }
1556 }
1558 # Calculate the start of the Hebrew year
1561 # Calculate next year's start
1563 # Day is before the start of the year - it is the previous year
1564 # Next year's start
1566 # Previous year
1569 # Add days since previous year's 1 September
1572 # Leap year
1574 }
1575 # Start of the new (previous) year
1578 # Next year's start
1580 }
1582 # Calculate Hebrew day of year
1585 # Difference between year's days
1587 # Add 12 (or 13 for leap years) days to ignore the difference between
1588 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1589 # difference is only about the year type
1594 }
1596 # Check the year pattern, and is leap year
1597 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1598 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1599 # and non-leap years
1601 # Check if leap year
1604 # Calculate day in the month from number of day in the Hebrew year
1605 # Don't check Adar - if the day is not in Adar, we will stop before;
1606 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1611 # Calculate days in this month
1613 # Adar in a leap year
1615 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1618 # Day in Adar I
1621 # Subtract the days of Adar I
1623 # Try Adar II
1626 # Day in Adar II
1628 }
1629 }
1630 }
1632 # Cheshvan in a complete year (otherwise as the rule below)
1635 # Kislev in an incomplete year (otherwise as the rule below)
1638 # Odd months have 30 days, even have 29
1640 }
1642 # In the current month
1645 # Subtract the days of the current month
1647 # Try in the next month
1649 }
1650 }
1653 }
1655 /**
1656 * This calculates the Hebrew year start, as days since 1 September.
1657 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1658 * Used for Hebrew date.
1659 *
1660 * @param $year int
1661 *
1662 * @return string
1663 */
1670 }
1674 }
1684 }
1688 }
1690 /**
1691 * Algorithm to convert Gregorian dates to Thai solar dates,
1692 * Minguo dates or Minguo dates.
1693 *
1694 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1695 * http://en.wikipedia.org/wiki/Minguo_calendar
1696 * http://en.wikipedia.org/wiki/Japanese_era_name
1697 *
1698 * @param $ts String: 14-character timestamp
1699 * @param $cName String: calender name
1700 * @return Array: converted year, month, day
1701 */
1708 # Thai solar dates
1709 # Add 543 years to the Gregorian calendar
1710 # Months and days are identical
1713 # Minguo dates
1714 # Deduct 1911 years from the Gregorian calendar
1715 # Months and days are identical
1718 # Nengō dates up to Meiji period
1719 # Deduct years from the Gregorian calendar
1720 # depending on the nengo periods
1721 # Months and days are identical
1722 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1723 # Meiji period
1728 }
1736 )
1737 {
1738 # Taishō period
1743 }
1749 )
1750 {
1751 # Shōwa period
1756 }
1759 # Heisei period
1764 }
1766 }
1769 }
1772 }
1774 /**
1775 * Roman number formatting up to 10000
1776 *
1777 * @param $num int
1778 *
1779 * @return string
1780 */
1786 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1787 );
1792 }
1798 }
1800 }
1802 }
1804 /**
1805 * Hebrew Gematria number formatting up to 9999
1806 *
1807 * @param $num int
1808 *
1809 * @return string
1810 */
1817 );
1822 }
1834 }
1835 }
1836 }
1838 }
1844 }
1863 }
1865 }
1867 /**
1868 * Used by date() and time() to adjust the time output.
1869 *
1870 * @param $ts Int the time in date('YmdHis') format
1871 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1872 * get user timecorrection setting)
1873 * @return int
1874 */
1880 }
1893 }
1894 # Unrecognized timezone, default to 'Offset' with the stored offset.
1896 }
1900 # Global offset in minutes.
1903 }
1914 }
1917 }
1918 }
1920 # No difference ? Return time unchanged
1923 }
1926 # Generate an adjusted date; take advantage of the fact that mktime
1927 # will normalize out-of-range values so we don't have to split $minDiff
1928 # into hours and minutes.
1941 }
1943 /**
1944 * This is meant to be used by time(), date(), and timeanddate() to get
1945 * the date preference they're supposed to use, it should be used in
1946 * all children.
1947 *
1948 *<code>
1949 * function timeanddate([...], $format = true) {
1950 * $datePreference = $this->dateFormat($format);
1951 * [...]
1952 * }
1953 *</code>
1954 *
1955 * @param $usePrefs Mixed: if true, the user's preference is used
1956 * if false, the site/language default is used
1957 * if int/string, assumed to be a format.
1958 * @return string
1959 */
1968 }
1971 }
1973 // return int
1976 }
1979 }
1981 /**
1982 * Get a format string for a given type and preference
1983 * @param $type string May be date, time or both
1984 * @param $pref string The format name as it appears in Messages*.php
1985 *
1986 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
1987 *
1988 * @return string
1989 */
2000 }
2005 }
2006 }
2008 }
2010 }
2012 /**
2013 * @param $ts Mixed: the time format which needs to be turned into a
2014 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2015 * @param $adj Bool: whether to adjust the time output according to the
2016 * user configured offset ($timecorrection)
2017 * @param $format Mixed: true to use user's date format preference
2018 * @param $timecorrection String|bool the time offset as returned by
2019 * validateTimeZone() in Special:Preferences
2020 * @return string
2021 */
2026 }
2029 }
2031 /**
2032 * @param $ts Mixed: the time format which needs to be turned into a
2033 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2034 * @param $adj Bool: whether to adjust the time output according to the
2035 * user configured offset ($timecorrection)
2036 * @param $format Mixed: true to use user's date format preference
2037 * @param $timecorrection String|bool the time offset as returned by
2038 * validateTimeZone() in Special:Preferences
2039 * @return string
2040 */
2045 }
2048 }
2050 /**
2051 * @param $ts Mixed: the time format which needs to be turned into a
2052 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2053 * @param $adj Bool: whether to adjust the time output according to the
2054 * user configured offset ($timecorrection)
2055 * @param $format Mixed: what format to return, if it's false output the
2056 * default one (default true)
2057 * @param $timecorrection String|bool the time offset as returned by
2058 * validateTimeZone() in Special:Preferences
2059 * @return string
2060 */
2065 }
2068 }
2070 /**
2071 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2072 *
2073 * @since 1.20
2074 *
2075 * @param integer $seconds The amount of seconds.
2076 * @param array $chosenIntervals The intervals to enable.
2077 *
2078 * @return string
2079 */
2088 }
2091 }
2093 /**
2094 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2095 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2096 *
2097 * @since 1.20
2098 *
2099 * @param integer $seconds The amount of seconds.
2100 * @param array $chosenIntervals The intervals to enable.
2101 *
2102 * @return array
2103 */
2106 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2107 }
2121 }
2122 }
2125 }
2127 /**
2128 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2129 *
2130 * @param $type String: can be 'date', 'time' or 'both'
2131 * @param $ts Mixed: the time format which needs to be turned into a
2132 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2133 * @param $user User object used to get preferences for timezone and format
2134 * @param $options Array, can contain the following keys:
2135 * - 'timecorrection': time correction, can have the following values:
2136 * - true: use user's preference
2137 * - false: don't use time correction
2138 * - integer: value of time correction in minutes
2139 * - 'format': format to use, can have the following values:
2140 * - true: use user's preference
2141 * - false: use default preference
2142 * - string: format to use
2143 * @since 1.19
2144 * @return String
2145 */
2154 }
2156 }
2161 }
2164 }
2166 /**
2167 * Get the formatted date for the given timestamp and formatted for
2168 * the given user.
2169 *
2170 * @param $ts Mixed: the time format which needs to be turned into a
2171 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2172 * @param $user User object used to get preferences for timezone and format
2173 * @param $options Array, can contain the following keys:
2174 * - 'timecorrection': time correction, can have the following values:
2175 * - true: use user's preference
2176 * - false: don't use time correction
2177 * - integer: value of time correction in minutes
2178 * - 'format': format to use, can have the following values:
2179 * - true: use user's preference
2180 * - false: use default preference
2181 * - string: format to use
2182 * @since 1.19
2183 * @return String
2184 */
2187 }
2189 /**
2190 * Get the formatted time for the given timestamp and formatted for
2191 * the given user.
2192 *
2193 * @param $ts Mixed: the time format which needs to be turned into a
2194 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2195 * @param $user User object used to get preferences for timezone and format
2196 * @param $options Array, can contain the following keys:
2197 * - 'timecorrection': time correction, can have the following values:
2198 * - true: use user's preference
2199 * - false: don't use time correction
2200 * - integer: value of time correction in minutes
2201 * - 'format': format to use, can have the following values:
2202 * - true: use user's preference
2203 * - false: use default preference
2204 * - string: format to use
2205 * @since 1.19
2206 * @return String
2207 */
2210 }
2212 /**
2213 * Get the formatted date and time for the given timestamp and formatted for
2214 * the given user.
2215 *
2216 * @param $ts Mixed: the time format which needs to be turned into a
2217 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2218 * @param $user User object used to get preferences for timezone and format
2219 * @param $options Array, can contain the following keys:
2220 * - 'timecorrection': time correction, can have the following values:
2221 * - true: use user's preference
2222 * - false: don't use time correction
2223 * - integer: value of time correction in minutes
2224 * - 'format': format to use, can have the following values:
2225 * - true: use user's preference
2226 * - false: use default preference
2227 * - string: format to use
2228 * @since 1.19
2229 * @return String
2230 */
2233 }
2235 /**
2236 * Convert an MWTimestamp into a pretty human-readable timestamp using
2237 * the given user preferences and relative base time.
2238 *
2239 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2240 * on your timestamp object, which will then call this function. Calling
2241 * this function directly will cause hooks to be skipped over.
2242 *
2243 * @see MWTimestamp::getHumanTimestamp
2244 * @param MWTimestamp $ts Timestamp to prettify
2245 * @param MWTimestamp $relativeTo Base timestamp
2246 * @param User $user User preferences to use
2247 * @return string Human timestamp
2248 * @since 1.21
2249 */
2252 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) - (int)$relativeTo->timestamp->format( 'w' ) );
2254 if ( $diff->invert || $days > 5 && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' ) ) {
2255 // Timestamps are in different years: use full timestamp
2256 // Also do full timestamp for future dates
2257 /**
2258 * @FIXME Add better handling of future timestamps.
2259 */
2263 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2267 // Timestamp within the past week: show the day of the week and time
2275 // Timestamp was yesterday: say 'yesterday' and the time.
2282 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2289 // From here on in, the timestamp was soon enough ago so that we can simply say
2290 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2292 // Less than 90 minutes, but more than an hour ago.
2295 // A few minutes ago.
2298 // Less than a minute, but more than 30 sec ago.
2301 // Less than 30 seconds ago.
2303 }
2306 }
2308 /**
2309 * @param $key string
2310 * @return array|null
2311 */
2314 }
2316 /**
2317 * @return array
2318 */
2321 }
2323 /**
2324 * @param $in
2325 * @param $out
2326 * @param $string
2327 * @return string
2328 */
2330 # This is a wrapper for iconv in all languages except esperanto,
2331 # which does some nasty x-conversions beforehand
2333 # Even with //IGNORE iconv can whine about illegal characters in
2334 # *input* string. We just ignore those too.
2335 # REF: http://bugs.php.net/bug.php?id=37166
2336 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2341 }
2343 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2345 /**
2346 * @param $matches array
2347 * @return mixed|string
2348 */
2351 }
2353 /**
2354 * @param $matches array
2355 * @return string
2356 */
2359 }
2361 /**
2362 * @param $matches array
2363 * @return string
2364 */
2368 }
2370 /**
2371 * @param $matches array
2372 * @return string
2373 */
2377 }
2379 /**
2380 * @param $matches array
2381 * @return string
2382 */
2385 }
2387 /**
2388 * @param $matches array
2389 * @return string
2390 */
2394 }
2396 /**
2397 * Make a string's first character uppercase
2398 *
2399 * @param $str string
2400 *
2401 * @return string
2402 */
2410 // fall back to more complex logic in case of multibyte strings
2412 }
2413 }
2415 /**
2416 * Convert a string to uppercase
2417 *
2418 * @param $str string
2419 * @param $first bool
2420 *
2421 * @return string
2422 */
2430 }
2433 }
2440 $str
2441 );
2444 }
2445 }
2446 }
2448 /**
2449 * @param $str string
2450 * @return mixed|string
2451 */
2463 }
2464 }
2466 /**
2467 * @param $str string
2468 * @param $first bool
2469 * @return mixed|string
2470 */
2478 }
2481 }
2488 $str
2489 );
2492 }
2493 }
2494 }
2496 /**
2497 * @param $str string
2498 * @return bool
2499 */
2502 }
2504 /**
2505 * @param $str string
2506 * @return mixed|string
2507 */
2512 // regexp to find first letter in each word (i.e. after each space)
2513 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2515 // function to use to capitalize a single char
2520 $str
2521 );
2526 $str
2527 );
2528 }
2531 }
2532 }
2534 /**
2535 * capitalize words at word breaks
2536 *
2537 * @param $str string
2538 * @return mixed
2539 */
2544 // since \b doesn't work for UTF-8, we explicitely define word break chars
2547 // find first letter after word break
2548 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2554 $str
2555 );
2560 $str
2561 );
2562 }
2567 $str
2568 );
2569 }
2570 }
2572 /**
2573 * Return a case-folded representation of $s
2574 *
2575 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2576 * and $s2 are the same except for the case of their characters. It is not
2577 * necessary for the value returned to make sense when displayed.
2578 *
2579 * Do *not* perform any other normalisation in this function. If a caller
2580 * uses this function when it should be using a more general normalisation
2581 * function, then fix the caller.
2582 *
2583 * @param $s string
2584 *
2585 * @return string
2586 */
2589 }
2591 /**
2592 * @param $s string
2593 * @return string
2594 */
2598 }
2601 }
2604 }
2606 /**
2607 * @return array
2608 */
2611 }
2613 /**
2614 * Most writing systems use whitespace to break up words.
2615 * Some languages such as Chinese don't conventionally do this,
2616 * which requires special handling when breaking up words for
2617 * searching etc.
2618 *
2619 * @return bool
2620 */
2623 }
2625 /**
2626 * Some languages such as Chinese require word segmentation,
2627 * Specify such segmentation when overridden in derived class.
2628 *
2629 * @param $string String
2630 * @return String
2631 */
2634 }
2636 /**
2637 * Some languages have special punctuation need to be normalized.
2638 * Make such changes here.
2639 *
2640 * @param $string String
2641 * @return String
2642 */
2645 }
2647 /**
2648 * convert double-width roman characters to single-width.
2649 * range: ff00-ff5f ~= 0020-007f
2650 *
2651 * @param $string string
2652 *
2653 * @return string
2654 */
2664 }
2668 }
2670 /**
2671 * @param $string string
2672 * @param $pattern string
2673 * @return string
2674 */
2679 }
2681 /**
2682 * @param $termsArray array
2683 * @return array
2684 */
2686 # some languages, e.g. Chinese, need to do a conversion
2687 # in order for search results to be displayed correctly
2689 }
2691 /**
2692 * Get the first character of a string.
2693 *
2694 * @param $s string
2695 * @return string
2696 */
2703 $matches
2704 );
2709 }
2711 // Break down Hangul syllables to grab the first jamo
2743 }
2746 }
2747 }
2750 # Some languages may have an alternate char encoding option
2751 # (Esperanto X-coding, Japanese furigana conversion, etc)
2752 # If this language is used as the primary content language,
2753 # an override to the defaults can be set here on startup.
2754 }
2756 /**
2757 * @param $s string
2758 * @return string
2759 */
2761 # For some languages we'll want to explicitly specify
2762 # which characters make it into the edit box raw
2763 # or are converted in some way or another.
2769 }
2770 }
2772 /**
2773 * @param $s string
2774 * @return string
2775 */
2777 # Take the previous into account.
2783 }
2788 }
2789 }
2791 /**
2792 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2793 * also cleans up certain backwards-compatible sequences, converting them
2794 * to the modern Unicode equivalent.
2795 *
2796 * This is language-specific for performance reasons only.
2797 *
2798 * @param $s string
2799 *
2800 * @return string
2801 */
2808 }
2811 }
2813 /**
2814 * Transform a string using serialized data stored in the given file (which
2815 * must be in the serialized subdirectory of $IP). The file contains pairs
2816 * mapping source characters to destination characters.
2817 *
2818 * The data is cached in process memory. This will go faster if you have the
2819 * FastStringSearch extension.
2820 *
2821 * @param $file string
2822 * @param $string string
2823 *
2824 * @throws MWException
2825 * @return string
2826 */
2832 }
2834 }
2836 }
2838 /**
2839 * For right-to-left language support
2840 *
2841 * @return bool
2842 */
2845 }
2847 /**
2848 * Return the correct HTML 'dir' attribute value for this language.
2849 * @return String
2850 */
2853 }
2855 /**
2856 * Return 'left' or 'right' as appropriate alignment for line-start
2857 * for this language's text direction.
2858 *
2859 * Should be equivalent to CSS3 'start' text-align value....
2860 *
2861 * @return String
2862 */
2865 }
2867 /**
2868 * Return 'right' or 'left' as appropriate alignment for line-end
2869 * for this language's text direction.
2870 *
2871 * Should be equivalent to CSS3 'end' text-align value....
2872 *
2873 * @return String
2874 */
2877 }
2879 /**
2880 * A hidden direction mark (LRM or RLM), depending on the language direction.
2881 * Unlike getDirMark(), this function returns the character as an HTML entity.
2882 * This function should be used when the output is guaranteed to be HTML,
2883 * because it makes the output HTML source code more readable. When
2884 * the output is plain text or can be escaped, getDirMark() should be used.
2885 *
2886 * @param $opposite Boolean Get the direction mark opposite to your language
2887 * @return string
2888 * @since 1.20
2889 */
2893 }
2895 }
2897 /**
2898 * A hidden direction mark (LRM or RLM), depending on the language direction.
2899 * This function produces them as invisible Unicode characters and
2900 * the output may be hard to read and debug, so it should only be used
2901 * when the output is plain text or can be escaped. When the output is
2902 * HTML, use getDirMarkEntity() instead.
2903 *
2904 * @param $opposite Boolean Get the direction mark opposite to your language
2905 * @return string
2906 */
2912 }
2914 }
2916 /**
2917 * @return array
2918 */
2921 }
2923 /**
2924 * An arrow, depending on the language direction.
2925 *
2926 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2927 * @return string
2928 */
2943 }
2944 }
2946 /**
2947 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2948 *
2949 * @return bool
2950 */
2953 }
2955 /**
2956 * Get all magic words from cache.
2957 * @return array
2958 */
2961 }
2963 /**
2964 * Run the LanguageGetMagic hook once.
2965 */
2969 }
2974 }
2976 /**
2977 * Fill a MagicWord object with data from here
2978 *
2979 * @param $mw
2980 */
2982 // Saves a function call
2985 }
2992 }
2999 }
3000 }
3002 /**
3003 * Add magic words to the extension array
3004 *
3005 * @param $newWords array
3006 */
3013 }
3014 }
3015 }
3017 /**
3018 * Get special page names, as an associative array
3019 * case folded alias => real name
3020 */
3022 // Cache aliases because it may be slow to load them
3024 // Initialise array
3029 }
3032 }
3034 /**
3035 * Italic is unsuitable for some languages
3036 *
3037 * @param $text String: the text to be emphasized.
3038 * @return string
3039 */
3042 }
3044 /**
3045 * Normally we output all numbers in plain en_US style, that is
3046 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3047 * point twohundredthirtyfive. However this is not suitable for all
3048 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
3049 * Icelandic just want to use commas instead of dots, and dots instead
3050 * of commas like "293.291,235".
3051 *
3052 * An example of this function being called:
3053 * <code>
3054 * wfMessage( 'message' )->numParams( $num )->text()
3055 * </code>
3056 *
3057 * See LanguageGu.php for the Gujarati implementation and
3058 * $separatorTransformTable on MessageIs.php for
3059 * the , => . and . => , implementation.
3060 *
3061 * @todo check if it's viable to use localeconv() for the decimal
3062 * separator thing.
3063 * @param $number Mixed: the string to be formatted, should be an integer
3064 * or a floating point number.
3065 * @param $nocommafy Bool: set to true for special numbers like dates
3066 * @return string
3067 */
3075 }
3076 }
3082 }
3083 }
3086 }
3088 /**
3089 * Front-end for non-commafied formatNum
3090 *
3091 * @param mixed $number the string to be formatted, should be an integer
3092 * or a floating point number.
3093 * @since 1.21
3094 * @return string
3095 */
3098 }
3100 /**
3101 * @param $number string
3102 * @return string
3103 */
3108 }
3113 }
3117 }
3119 /**
3120 * Adds commas to a given number
3121 * @since 1.19
3122 * @param $number mixed
3123 * @return string
3124 */
3129 }
3132 // default grouping is at thousands, use the same for ###,###,### pattern too.
3135 // Ref: http://cldr.unicode.org/translation/number-patterns
3138 // For negative numbers apply the algorithm like positive number and add sign.
3141 }
3149 // the string does not have any number part. Eg: .12345
3151 }
3159 }
3163 // use the last pattern for the rest of the number
3165 }
3168 }
3169 }
3171 }
3172 }
3174 /**
3175 * @return String
3176 */
3179 }
3181 /**
3182 * @return array
3183 */
3186 }
3188 /**
3189 * @return array
3190 */
3193 }
3195 /**
3196 * Take a list of strings and build a locale-friendly comma-separated
3197 * list, using the local comma-separator message.
3198 * The last two strings are chained with an "and".
3199 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3200 *
3201 * @param $l Array
3202 * @return string
3203 */
3208 }
3214 }
3215 }
3222 }
3223 }
3225 }
3227 /**
3228 * Take a list of strings and build a locale-friendly comma-separated
3229 * list, using the local comma-separator message.
3230 * @param $list array of strings to put in a comma list
3231 * @return string
3232 */
3236 $list
3237 );
3238 }
3240 /**
3241 * Take a list of strings and build a locale-friendly semicolon-separated
3242 * list, using the local semicolon-separator message.
3243 * @param $list array of strings to put in a semicolon list
3244 * @return string
3245 */
3249 $list
3250 );
3251 }
3253 /**
3254 * Same as commaList, but separate it with the pipe instead.
3255 * @param $list array of strings to put in a pipe list
3256 * @return string
3257 */
3261 $list
3262 );
3263 }
3265 /**
3266 * Truncate a string to a specified length in bytes, appending an optional
3267 * string (e.g. for ellipses)
3268 *
3269 * The database offers limited byte lengths for some columns in the database;
3270 * multi-byte character sets mean we need to ensure that only whole characters
3271 * are included, otherwise broken characters can be passed to the user
3272 *
3273 * If $length is negative, the string will be truncated from the beginning
3274 *
3275 * @param $string String to truncate
3276 * @param $length Int: maximum length (including ellipses)
3277 * @param $ellipsis String to append to the truncated text
3278 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3279 * $adjustLength was introduced in 1.18, before that behaved as if false.
3280 * @return string
3281 */
3283 # Use the localized ellipsis character
3286 }
3287 # Check if there is no need to truncate
3292 }
3294 # If ellipsis length is >= $length then we can't apply $adjustLength
3297 # Otherwise, truncate and add ellipsis...
3310 }
3311 }
3312 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3313 # This check is *not* redundant if $adjustLength, due to the single case where
3314 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3319 }
3320 }
3322 /**
3323 * Remove bytes that represent an incomplete Unicode character
3324 * at the end of string (e.g. bytes of the char are missing)
3325 *
3326 * @param $string String
3327 * @return string
3328 */
3334 # We got the first byte only of a multibyte char; remove it.
3339 ) {
3340 # We chopped in the middle of a character; remove it
3342 }
3343 }
3345 }
3347 /**
3348 * Remove bytes that represent an incomplete Unicode character
3349 * at the start of string (e.g. bytes of the char are missing)
3350 *
3351 * @param $string String
3352 * @return string
3353 */
3358 # We chopped in the middle of a character; remove the whole thing
3360 }
3361 }
3363 }
3365 /**
3366 * Truncate a string of valid HTML to a specified length in bytes,
3367 * appending an optional string (e.g. for ellipses), and return valid HTML
3368 *
3369 * This is only intended for styled/linked text, such as HTML with
3370 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3371 * Also, this will not detect things like "display:none" CSS.
3372 *
3373 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3374 *
3375 * @param string $text HTML string to truncate
3376 * @param int $length (zero/positive) Maximum length (including ellipses)
3377 * @param string $ellipsis String to append to the truncated text
3378 * @return string
3379 */
3381 # Use the localized ellipsis character
3384 }
3385 # Check if there is clearly no need to truncate
3390 }
3404 # Consider truncation once the display length has reached the maximim.
3405 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3406 # Check that we're not in the middle of a bracket/entity...
3410 # Save where we are; we will truncate here unless there turn out to
3411 # be so few remaining characters that truncation is not necessary.
3414 }
3416 # String in fact does need truncation, the truncation point was OK.
3421 }
3422 }
3425 }
3427 # Read the next char...
3445 }
3451 // Name found (e.g. "<a href=..."), add on tag attributes...
3453 }
3459 }
3462 // Save state without $ch. We want to *hit* the first
3463 // display char (to get tags) but not *use* it if truncating.
3465 }
3470 // Add the next $max display text chars after this in one swoop...
3475 }
3476 }
3477 }
3478 }
3479 // Close the last tag if left unclosed by bad HTML
3483 }
3485 }
3487 /**
3488 * truncateHtml() helper function
3489 * like strcspn() but adds the skipped chars to $ret
3490 *
3491 * @param $ret
3492 * @param $text
3493 * @param $search
3494 * @param $start
3495 * @param $len
3496 * @return int
3497 */
3503 }
3508 }
3510 }
3512 /**
3513 * truncateHtml() helper function
3514 * (a) push or pop $tag from $openTags as needed
3515 * (b) clear $tag value
3516 * @param &$tag string Current HTML tag name we are looking at
3517 * @param $tagType int (0-open tag, 1-close tag)
3518 * @param $lastCh string Character before the '>' that ended this tag
3519 * @param &$openTags array Open tag stack (not accounting for $tag)
3520 */
3529 }
3530 }
3532 }
3533 }
3535 /**
3536 * Grammatical transformations, needed for inflected languages
3537 * Invoked by putting {{grammar:case|word}} in a message
3538 *
3539 * @param $word string
3540 * @param $case string
3541 * @return string
3542 */
3547 }
3549 }
3550 /**
3551 * Get the grammar forms for the content language
3552 * @return array of grammar forms
3553 * @since 1.20
3554 */
3557 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3559 }
3561 }
3562 /**
3563 * Provides an alternative text depending on specified gender.
3564 * Usage {{gender:username|masculine|feminine|neutral}}.
3565 * username is optional, in which case the gender of current user is used,
3566 * but only in (some) interface messages; otherwise default gender is used.
3567 *
3568 * If no forms are given, an empty string is returned. If only one form is
3569 * given, it will be returned unconditionally. These details are implied by
3570 * the caller and cannot be overridden in subclasses.
3571 *
3572 * If more than one form is given, the default is to use the neutral one
3573 * if it is specified, and to use the masculine one otherwise. These
3574 * details can be overridden in subclasses.
3575 *
3576 * @param $gender string
3577 * @param $forms array
3578 *
3579 * @return string
3580 */
3584 }
3588 }
3591 }
3593 }
3595 /**
3596 * Plural form transformations, needed for some languages.
3597 * For example, there are 3 form of plural in Russian and Polish,
3598 * depending on "count mod 10". See [[w:Plural]]
3599 * For English it is pretty simple.
3600 *
3601 * Invoked by putting {{plural:count|wordform1|wordform2}}
3602 * or {{plural:count|wordform1|wordform2|wordform3}}
3603 *
3604 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3605 *
3606 * @param $count Integer: non-localized number
3607 * @param $forms Array: different plural forms
3608 * @return string Correct form of plural for $count in this language
3609 */
3611 // Handle explicit n=pluralform cases
3617 }
3619 }
3620 }
3625 }
3630 }
3632 /**
3633 * Checks that convertPlural was given an array and pads it to requested
3634 * amount of forms by copying the last one.
3635 *
3636 * @param $count Integer: How many forms should there be at least
3637 * @param $forms Array of forms given to convertPlural
3638 * @return array Padded array of forms or an exception if not an array
3639 */
3643 }
3645 }
3647 /**
3648 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3649 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3650 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3651 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3652 * match up with it.
3653 *
3654 * @param $str String: the validated block duration in English
3655 * @return string Somehow translated block duration
3656 * @see LanguageFi.php for example implementation
3657 */
3663 }
3664 }
3666 // Since usually only infinite or indefinite is only on list, so try
3667 // equivalents if still here.
3674 }
3675 }
3676 }
3678 // If all else fails, return a standard duration or timestamp description.
3683 // $time is relative to 0 so it's a duration length.
3687 // wfTimestamp() handles 0 as current time instead of epoch.
3691 }
3692 }
3693 }
3695 /**
3696 * languages like Chinese need to be segmented in order for the diff
3697 * to be of any use
3698 *
3699 * @param $text String
3700 * @return String
3701 */
3704 }
3706 /**
3707 * and unsegment to show the result
3708 *
3709 * @param $text String
3710 * @return String
3711 */
3714 }
3716 /**
3717 * Return the LanguageConverter used in the Language
3718 *
3719 * @since 1.19
3720 * @return LanguageConverter
3721 */
3724 }
3726 /**
3727 * convert text to all supported variants
3728 *
3729 * @param $text string
3730 * @return array
3731 */
3734 }
3736 /**
3737 * convert text to different variants of a language.
3738 *
3739 * @param $text string
3740 * @return string
3741 */
3744 }
3746 /**
3747 * Convert a Title object to a string in the preferred variant
3748 *
3749 * @param $title Title
3750 * @return string
3751 */
3754 }
3756 /**
3757 * Convert a namespace index to a string in the preferred variant
3758 *
3759 * @param $ns int
3760 * @return string
3761 */
3764 }
3766 /**
3767 * Check if this is a language with variants
3768 *
3769 * @return bool
3770 */
3773 }
3775 /**
3776 * Check if the language has the specific variant
3777 *
3778 * @since 1.19
3779 * @param $variant string
3780 * @return bool
3781 */
3784 }
3786 /**
3787 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3788 *
3789 * @param $text string
3790 * @return string
3791 */
3794 }
3796 /**
3797 * Perform output conversion on a string, and encode for safe HTML output.
3798 * @param $text String text to be converted
3799 * @param $isTitle Bool whether this conversion is for the article title
3800 * @return string
3801 * @todo this should get integrated somewhere sane
3802 */
3805 }
3807 /**
3808 * @param $key string
3809 * @return string
3810 */
3813 }
3815 /**
3816 * Get the list of variants supported by this language
3817 * see sample implementation in LanguageZh.php
3818 *
3819 * @return array an array of language codes
3820 */
3823 }
3825 /**
3826 * @return string
3827 */
3830 }
3832 /**
3833 * @return string
3834 */
3837 }
3839 /**
3840 * @return string
3841 */
3844 }
3846 /**
3847 * If a language supports multiple variants, it is
3848 * possible that non-existing link in one variant
3849 * actually exists in another variant. this function
3850 * tries to find it. See e.g. LanguageZh.php
3851 *
3852 * @param $link String: the name of the link
3853 * @param $nt Mixed: the title object of the link
3854 * @param $ignoreOtherCond Boolean: to disable other conditions when
3855 * we need to transclude a template or update a category's link
3856 * @return null the input parameters may be modified upon return
3857 */
3860 }
3862 /**
3863 * If a language supports multiple variants, converts text
3864 * into an array of all possible variants of the text:
3865 * 'variant' => text in that variant
3866 *
3867 * @deprecated since 1.17 Use autoConvertToAllVariants()
3868 *
3869 * @param $text string
3870 *
3871 * @return string
3872 */
3875 }
3877 /**
3878 * returns language specific options used by User::getPageRenderHash()
3879 * for example, the preferred language variant
3880 *
3881 * @return string
3882 */
3885 }
3887 /**
3888 * For languages that support multiple variants, the title of an
3889 * article may be displayed differently in different variants. this
3890 * function returns the apporiate title defined in the body of the article.
3891 *
3892 * @return string
3893 */
3896 }
3898 /**
3899 * Prepare external link text for conversion. When the text is
3900 * a URL, it shouldn't be converted, and it'll be wrapped in
3901 * the "raw" tag (-{R| }-) to prevent conversion.
3902 *
3903 * This function is called "markNoConversion" for historical
3904 * reasons.
3905 *
3906 * @param $text String: text to be used for external link
3907 * @param $noParse bool: wrap it without confirming it's a real URL first
3908 * @return string the tagged text
3909 */
3911 // Excluding protocal-relative URLs may avoid many false positives.
3916 }
3917 }
3919 /**
3920 * A regular expression to match legal word-trailing characters
3921 * which should be merged onto a link of the form [[foo]]bar.
3922 *
3923 * @return string
3924 */
3927 }
3929 /**
3930 * @return Language
3931 */
3934 }
3936 /**
3937 * Get the RFC 3066 code for this language object
3938 *
3939 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3940 * htmlspecialchars() or similar
3941 *
3942 * @return string
3943 */
3946 }
3948 /**
3949 * Get the code in Bcp47 format which we can use
3950 * inside of html lang="" tags.
3951 *
3952 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3953 * htmlspecialchars() or similar.
3954 *
3955 * @since 1.19
3956 * @return string
3957 */
3961 }
3963 }
3965 /**
3966 * @param $code string
3967 */
3970 // Ensure we don't leave an incorrect html code lying around
3972 }
3974 /**
3975 * Get the name of a file for a certain language code
3976 * @param $prefix string Prepend this to the filename
3977 * @param $code string Language code
3978 * @param $suffix string Append this to the filename
3979 * @throws MWException
3980 * @return string $prefix . $mangledCode . $suffix
3981 */
3983 // Protect against path traversal
3986 {
3988 }
3991 }
3993 /**
3994 * Get the language code from a file name. Inverse of getFileName()
3995 * @param $filename string $prefix . $languageCode . $suffix
3996 * @param $prefix string Prefix before the language code
3997 * @param $suffix string Suffix after the language code
3998 * @return string Language code, or false if $prefix or $suffix isn't found
3999 */
4000 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4006 }
4008 }
4010 /**
4011 * @param $code string
4012 * @return string
4013 */
4019 }
4021 /**
4022 * @param $code string
4023 * @return string
4024 */
4028 }
4030 /**
4031 * Get the first fallback for a given language.
4032 *
4033 * @param $code string
4034 *
4035 * @return bool|string
4036 */
4044 }
4045 }
4047 /**
4048 * Get the ordered list of fallback languages.
4049 *
4050 * @since 1.19
4051 * @param $code string Language code
4052 * @return array
4053 */
4062 }
4064 }
4065 }
4067 /**
4068 * Get the ordered list of fallback languages, ending with the fallback
4069 * language chain for the site language.
4070 *
4071 * @since 1.22
4072 * @param string $code Language code
4073 * @return array array( fallbacks, site fallbacks )
4074 */
4078 // Usually, we will only store a tiny number of fallback chains, so we
4079 // keep them in static memory.
4085 // Append the site's fallback chain, including the site language itself
4089 // Eliminate any languages already included in the chain
4093 }
4095 }
4097 /**
4098 * Get all messages for a given language
4099 * WARNING: this may take a long time. If you just need all message *keys*
4100 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4101 *
4102 * @param $code string
4103 *
4104 * @return array
4105 */
4108 }
4110 /**
4111 * Get a message for a given language
4112 *
4113 * @param $key string
4114 * @param $code string
4115 *
4116 * @return string
4117 */
4120 }
4122 /**
4123 * Get all message keys for a given language. This is a faster alternative to
4124 * array_keys( Language::getMessagesFor( $code ) )
4125 *
4126 * @since 1.19
4127 * @param $code string Language code
4128 * @return array of message keys (strings)
4129 */
4132 }
4134 /**
4135 * @param $talk
4136 * @return mixed
4137 */
4141 }
4146 # Allow grammar transformations
4147 # Allowing full message-style parsing would make simple requests
4148 # such as action=raw much more expensive than they need to be.
4149 # This will hopefully cover most cases.
4153 }
4155 /**
4156 * @param $m string
4157 * @return string
4158 */
4161 }
4163 /**
4164 * @throws MWException
4165 * @return array
4166 */
4171 }
4178 }
4183 }
4185 /**
4186 * Decode an expiry (block, protection, etc) which has come from the DB
4187 *
4188 * @todo FIXME: why are we returnings DBMS-dependent strings???
4189 *
4190 * @param $expiry String: Database expiry String
4191 * @param $format Bool|Int true to process using language functions, or TS_ constant
4192 * to return the expiry in a given timestamp
4193 * @return String
4194 * @since 1.18
4195 */
4200 }
4210 }
4211 }
4213 /**
4214 * @todo Document
4215 * @param $seconds int|float
4216 * @param $format Array Optional
4217 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4218 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4219 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4220 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4221 * @return string
4222 */
4226 }
4229 }
4232 }
4254 }
4265 }
4269 }
4275 }
4283 }
4293 }
4297 }
4307 }
4308 }
4310 }
4312 /**
4313 * Format a bitrate for output, using an appropriate
4314 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4315 *
4316 * This use base 1000. For base 1024 use formatSize(), for another base
4317 * see formatComputingNumbers()
4318 *
4319 * @param $bps int
4320 * @return string
4321 */
4324 }
4326 /**
4327 * @param $size int Size of the unit
4328 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4329 * @param $messageKey string Message key to be uesd
4330 * @return string
4331 */
4336 );
4337 }
4345 }
4347 // For small sizes no decimal places necessary
4350 // For MB and bigger two decimal places are smarter
4352 }
4358 }
4360 /**
4361 * Format a size in bytes for output, using an appropriate
4362 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4363 *
4364 * This method use base 1024. For base 1000 use formatBitrate(), for
4365 * another base see formatComputingNumbers()
4366 *
4367 * @param $size int Size to format
4368 * @return string Plain text (not HTML)
4369 */
4372 }
4374 /**
4375 * Make a list item, used by various special pages
4376 *
4377 * @param $page String Page link
4378 * @param $details String Text between brackets
4379 * @param $oppositedm Boolean Add the direction mark opposite to your
4380 * language, to display text properly
4381 * @return String
4382 */
4389 }
4391 /**
4392 * Generate (prev x| next x) (20|50|100...) type links for paging
4393 *
4394 * @param $title Title object to link
4395 * @param $offset Integer offset parameter
4396 * @param $limit Integer limit parameter
4397 * @param $query array|String optional URL query parameter string
4398 * @param $atend Bool optional param for specified if this is the last page
4399 * @return String
4400 */
4401 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4402 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4404 # Make 'previous' link
4405 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4411 }
4413 # Make 'next' link
4414 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4420 }
4422 # Make links to set number of items per page
4427 }
4431 }
4433 /**
4434 * Helper function for viewPrevNext() that generates links
4435 *
4436 * @param $title Title object to link
4437 * @param $offset Integer offset parameter
4438 * @param $limit Integer limit parameter
4439 * @param $query Array extra query parameters
4440 * @param $link String text to use for the link; will be escaped
4441 * @param $tooltipMsg String name of the message to use as tooltip
4442 * @param $class String value of the "class" attribute of the link
4443 * @return String HTML fragment
4444 */
4445 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4447 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4450 }
4452 /**
4453 * Get the conversion rule title, if any.
4454 *
4455 * @return string
4456 */
4459 }
4461 /**
4462 * Get the compiled plural rules for the language
4463 * @since 1.20
4464 * @return array Associative array with plural form, and plural rule as key-value pairs
4465 */
4471 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4474 }
4475 }
4476 }
4478 }
4480 /**
4481 * Get the plural rules for the language
4482 * @since 1.20
4483 * @return array Associative array with plural form number and plural rule as key-value pairs
4484 */
4493 }
4494 }
4495 }
4497 }
4499 /**
4500 * Get the plural rule types for the language
4501 * @since 1.21
4502 * @return array Associative array with plural form number and plural rule type as key-value pairs
4503 */
4509 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4512 }
4513 }
4514 }
4516 }
4518 /**
4519 * Find the index number of the plural rule appropriate for the given number
4520 * @return int The index number of the plural rule
4521 */
4526 }
4528 /**
4529 * Find the plural rule type appropriate for the given number
4530 * For example, if the language is set to Arabic, getPluralType(5) should
4531 * return 'few'.
4532 * @since 1.21
4533 * @return string The name of the plural rule type, e.g. one, two, few, many
4534 */
4542 }
4543 }
4544 }