| blob | ea34363b4f85f722d99f9a811680cb1925d4dc71 |
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 * @return array
2957 */
2960 }
2965 }
2970 }
2972 /**
2973 * Fill a MagicWord object with data from here
2974 *
2975 * @param $mw
2976 */
2988 }
2989 }
2996 }
2997 }
2999 /**
3000 * Add magic words to the extension array
3001 *
3002 * @param $newWords array
3003 */
3010 }
3011 }
3012 }
3014 /**
3015 * Get special page names, as an associative array
3016 * case folded alias => real name
3017 */
3019 // Cache aliases because it may be slow to load them
3021 // Initialise array
3026 }
3029 }
3031 /**
3032 * Italic is unsuitable for some languages
3033 *
3034 * @param $text String: the text to be emphasized.
3035 * @return string
3036 */
3039 }
3041 /**
3042 * Normally we output all numbers in plain en_US style, that is
3043 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3044 * point twohundredthirtyfive. However this is not suitable for all
3045 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
3046 * Icelandic just want to use commas instead of dots, and dots instead
3047 * of commas like "293.291,235".
3048 *
3049 * An example of this function being called:
3050 * <code>
3051 * wfMessage( 'message' )->numParams( $num )->text()
3052 * </code>
3053 *
3054 * See LanguageGu.php for the Gujarati implementation and
3055 * $separatorTransformTable on MessageIs.php for
3056 * the , => . and . => , implementation.
3057 *
3058 * @todo check if it's viable to use localeconv() for the decimal
3059 * separator thing.
3060 * @param $number Mixed: the string to be formatted, should be an integer
3061 * or a floating point number.
3062 * @param $nocommafy Bool: set to true for special numbers like dates
3063 * @return string
3064 */
3072 }
3073 }
3079 }
3080 }
3083 }
3085 /**
3086 * Front-end for non-commafied formatNum
3087 *
3088 * @param mixed $number the string to be formatted, should be an integer
3089 * or a floating point number.
3090 * @since 1.21
3091 * @return string
3092 */
3095 }
3097 /**
3098 * @param $number string
3099 * @return string
3100 */
3105 }
3110 }
3114 }
3116 /**
3117 * Adds commas to a given number
3118 * @since 1.19
3119 * @param $number mixed
3120 * @return string
3121 */
3126 }
3129 // default grouping is at thousands, use the same for ###,###,### pattern too.
3132 // Ref: http://cldr.unicode.org/translation/number-patterns
3135 // For negative numbers apply the algorithm like positive number and add sign.
3138 }
3146 // the string does not have any number part. Eg: .12345
3148 }
3156 }
3160 // use the last pattern for the rest of the number
3162 }
3165 }
3166 }
3168 }
3169 }
3171 /**
3172 * @return String
3173 */
3176 }
3178 /**
3179 * @return array
3180 */
3183 }
3185 /**
3186 * @return array
3187 */
3190 }
3192 /**
3193 * Take a list of strings and build a locale-friendly comma-separated
3194 * list, using the local comma-separator message.
3195 * The last two strings are chained with an "and".
3196 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3197 *
3198 * @param $l Array
3199 * @return string
3200 */
3205 }
3211 }
3212 }
3219 }
3220 }
3222 }
3224 /**
3225 * Take a list of strings and build a locale-friendly comma-separated
3226 * list, using the local comma-separator message.
3227 * @param $list array of strings to put in a comma list
3228 * @return string
3229 */
3233 $list
3234 );
3235 }
3237 /**
3238 * Take a list of strings and build a locale-friendly semicolon-separated
3239 * list, using the local semicolon-separator message.
3240 * @param $list array of strings to put in a semicolon list
3241 * @return string
3242 */
3246 $list
3247 );
3248 }
3250 /**
3251 * Same as commaList, but separate it with the pipe instead.
3252 * @param $list array of strings to put in a pipe list
3253 * @return string
3254 */
3258 $list
3259 );
3260 }
3262 /**
3263 * Truncate a string to a specified length in bytes, appending an optional
3264 * string (e.g. for ellipses)
3265 *
3266 * The database offers limited byte lengths for some columns in the database;
3267 * multi-byte character sets mean we need to ensure that only whole characters
3268 * are included, otherwise broken characters can be passed to the user
3269 *
3270 * If $length is negative, the string will be truncated from the beginning
3271 *
3272 * @param $string String to truncate
3273 * @param $length Int: maximum length (including ellipses)
3274 * @param $ellipsis String to append to the truncated text
3275 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3276 * $adjustLength was introduced in 1.18, before that behaved as if false.
3277 * @return string
3278 */
3280 # Use the localized ellipsis character
3283 }
3284 # Check if there is no need to truncate
3289 }
3291 # If ellipsis length is >= $length then we can't apply $adjustLength
3294 # Otherwise, truncate and add ellipsis...
3307 }
3308 }
3309 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3310 # This check is *not* redundant if $adjustLength, due to the single case where
3311 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3316 }
3317 }
3319 /**
3320 * Remove bytes that represent an incomplete Unicode character
3321 * at the end of string (e.g. bytes of the char are missing)
3322 *
3323 * @param $string String
3324 * @return string
3325 */
3331 # We got the first byte only of a multibyte char; remove it.
3336 ) {
3337 # We chopped in the middle of a character; remove it
3339 }
3340 }
3342 }
3344 /**
3345 * Remove bytes that represent an incomplete Unicode character
3346 * at the start of string (e.g. bytes of the char are missing)
3347 *
3348 * @param $string String
3349 * @return string
3350 */
3355 # We chopped in the middle of a character; remove the whole thing
3357 }
3358 }
3360 }
3362 /**
3363 * Truncate a string of valid HTML to a specified length in bytes,
3364 * appending an optional string (e.g. for ellipses), and return valid HTML
3365 *
3366 * This is only intended for styled/linked text, such as HTML with
3367 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3368 * Also, this will not detect things like "display:none" CSS.
3369 *
3370 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3371 *
3372 * @param string $text HTML string to truncate
3373 * @param int $length (zero/positive) Maximum length (including ellipses)
3374 * @param string $ellipsis String to append to the truncated text
3375 * @return string
3376 */
3378 # Use the localized ellipsis character
3381 }
3382 # Check if there is clearly no need to truncate
3387 }
3401 # Consider truncation once the display length has reached the maximim.
3402 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3403 # Check that we're not in the middle of a bracket/entity...
3407 # Save where we are; we will truncate here unless there turn out to
3408 # be so few remaining characters that truncation is not necessary.
3411 }
3413 # String in fact does need truncation, the truncation point was OK.
3418 }
3419 }
3422 }
3424 # Read the next char...
3442 }
3448 // Name found (e.g. "<a href=..."), add on tag attributes...
3450 }
3456 }
3459 // Save state without $ch. We want to *hit* the first
3460 // display char (to get tags) but not *use* it if truncating.
3462 }
3467 // Add the next $max display text chars after this in one swoop...
3472 }
3473 }
3474 }
3475 }
3476 // Close the last tag if left unclosed by bad HTML
3480 }
3482 }
3484 /**
3485 * truncateHtml() helper function
3486 * like strcspn() but adds the skipped chars to $ret
3487 *
3488 * @param $ret
3489 * @param $text
3490 * @param $search
3491 * @param $start
3492 * @param $len
3493 * @return int
3494 */
3500 }
3505 }
3507 }
3509 /**
3510 * truncateHtml() helper function
3511 * (a) push or pop $tag from $openTags as needed
3512 * (b) clear $tag value
3513 * @param &$tag string Current HTML tag name we are looking at
3514 * @param $tagType int (0-open tag, 1-close tag)
3515 * @param $lastCh string Character before the '>' that ended this tag
3516 * @param &$openTags array Open tag stack (not accounting for $tag)
3517 */
3526 }
3527 }
3529 }
3530 }
3532 /**
3533 * Grammatical transformations, needed for inflected languages
3534 * Invoked by putting {{grammar:case|word}} in a message
3535 *
3536 * @param $word string
3537 * @param $case string
3538 * @return string
3539 */
3544 }
3546 }
3547 /**
3548 * Get the grammar forms for the content language
3549 * @return array of grammar forms
3550 * @since 1.20
3551 */
3554 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3556 }
3558 }
3559 /**
3560 * Provides an alternative text depending on specified gender.
3561 * Usage {{gender:username|masculine|feminine|neutral}}.
3562 * username is optional, in which case the gender of current user is used,
3563 * but only in (some) interface messages; otherwise default gender is used.
3564 *
3565 * If no forms are given, an empty string is returned. If only one form is
3566 * given, it will be returned unconditionally. These details are implied by
3567 * the caller and cannot be overridden in subclasses.
3568 *
3569 * If more than one form is given, the default is to use the neutral one
3570 * if it is specified, and to use the masculine one otherwise. These
3571 * details can be overridden in subclasses.
3572 *
3573 * @param $gender string
3574 * @param $forms array
3575 *
3576 * @return string
3577 */
3581 }
3585 }
3588 }
3590 }
3592 /**
3593 * Plural form transformations, needed for some languages.
3594 * For example, there are 3 form of plural in Russian and Polish,
3595 * depending on "count mod 10". See [[w:Plural]]
3596 * For English it is pretty simple.
3597 *
3598 * Invoked by putting {{plural:count|wordform1|wordform2}}
3599 * or {{plural:count|wordform1|wordform2|wordform3}}
3600 *
3601 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3602 *
3603 * @param $count Integer: non-localized number
3604 * @param $forms Array: different plural forms
3605 * @return string Correct form of plural for $count in this language
3606 */
3608 // Handle explicit n=pluralform cases
3614 }
3616 }
3617 }
3622 }
3627 }
3629 /**
3630 * Checks that convertPlural was given an array and pads it to requested
3631 * amount of forms by copying the last one.
3632 *
3633 * @param $count Integer: How many forms should there be at least
3634 * @param $forms Array of forms given to convertPlural
3635 * @return array Padded array of forms or an exception if not an array
3636 */
3640 }
3642 }
3644 /**
3645 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3646 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3647 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3648 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3649 * match up with it.
3650 *
3651 * @param $str String: the validated block duration in English
3652 * @return string Somehow translated block duration
3653 * @see LanguageFi.php for example implementation
3654 */
3660 }
3661 }
3663 // Since usually only infinite or indefinite is only on list, so try
3664 // equivalents if still here.
3671 }
3672 }
3673 }
3675 // If all else fails, return a standard duration or timestamp description.
3680 // $time is relative to 0 so it's a duration length.
3684 // wfTimestamp() handles 0 as current time instead of epoch.
3688 }
3689 }
3690 }
3692 /**
3693 * languages like Chinese need to be segmented in order for the diff
3694 * to be of any use
3695 *
3696 * @param $text String
3697 * @return String
3698 */
3701 }
3703 /**
3704 * and unsegment to show the result
3705 *
3706 * @param $text String
3707 * @return String
3708 */
3711 }
3713 /**
3714 * Return the LanguageConverter used in the Language
3715 *
3716 * @since 1.19
3717 * @return LanguageConverter
3718 */
3721 }
3723 /**
3724 * convert text to all supported variants
3725 *
3726 * @param $text string
3727 * @return array
3728 */
3731 }
3733 /**
3734 * convert text to different variants of a language.
3735 *
3736 * @param $text string
3737 * @return string
3738 */
3741 }
3743 /**
3744 * Convert a Title object to a string in the preferred variant
3745 *
3746 * @param $title Title
3747 * @return string
3748 */
3751 }
3753 /**
3754 * Convert a namespace index to a string in the preferred variant
3755 *
3756 * @param $ns int
3757 * @return string
3758 */
3761 }
3763 /**
3764 * Check if this is a language with variants
3765 *
3766 * @return bool
3767 */
3770 }
3772 /**
3773 * Check if the language has the specific variant
3774 *
3775 * @since 1.19
3776 * @param $variant string
3777 * @return bool
3778 */
3781 }
3783 /**
3784 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3785 *
3786 * @param $text string
3787 * @return string
3788 */
3791 }
3793 /**
3794 * Perform output conversion on a string, and encode for safe HTML output.
3795 * @param $text String text to be converted
3796 * @param $isTitle Bool whether this conversion is for the article title
3797 * @return string
3798 * @todo this should get integrated somewhere sane
3799 */
3802 }
3804 /**
3805 * @param $key string
3806 * @return string
3807 */
3810 }
3812 /**
3813 * Get the list of variants supported by this language
3814 * see sample implementation in LanguageZh.php
3815 *
3816 * @return array an array of language codes
3817 */
3820 }
3822 /**
3823 * @return string
3824 */
3827 }
3829 /**
3830 * @return string
3831 */
3834 }
3836 /**
3837 * @return string
3838 */
3841 }
3843 /**
3844 * If a language supports multiple variants, it is
3845 * possible that non-existing link in one variant
3846 * actually exists in another variant. this function
3847 * tries to find it. See e.g. LanguageZh.php
3848 *
3849 * @param $link String: the name of the link
3850 * @param $nt Mixed: the title object of the link
3851 * @param $ignoreOtherCond Boolean: to disable other conditions when
3852 * we need to transclude a template or update a category's link
3853 * @return null the input parameters may be modified upon return
3854 */
3857 }
3859 /**
3860 * If a language supports multiple variants, converts text
3861 * into an array of all possible variants of the text:
3862 * 'variant' => text in that variant
3863 *
3864 * @deprecated since 1.17 Use autoConvertToAllVariants()
3865 *
3866 * @param $text string
3867 *
3868 * @return string
3869 */
3872 }
3874 /**
3875 * returns language specific options used by User::getPageRenderHash()
3876 * for example, the preferred language variant
3877 *
3878 * @return string
3879 */
3882 }
3884 /**
3885 * For languages that support multiple variants, the title of an
3886 * article may be displayed differently in different variants. this
3887 * function returns the apporiate title defined in the body of the article.
3888 *
3889 * @return string
3890 */
3893 }
3895 /**
3896 * Prepare external link text for conversion. When the text is
3897 * a URL, it shouldn't be converted, and it'll be wrapped in
3898 * the "raw" tag (-{R| }-) to prevent conversion.
3899 *
3900 * This function is called "markNoConversion" for historical
3901 * reasons.
3902 *
3903 * @param $text String: text to be used for external link
3904 * @param $noParse bool: wrap it without confirming it's a real URL first
3905 * @return string the tagged text
3906 */
3908 // Excluding protocal-relative URLs may avoid many false positives.
3913 }
3914 }
3916 /**
3917 * A regular expression to match legal word-trailing characters
3918 * which should be merged onto a link of the form [[foo]]bar.
3919 *
3920 * @return string
3921 */
3924 }
3926 /**
3927 * @return Language
3928 */
3931 }
3933 /**
3934 * Get the RFC 3066 code for this language object
3935 *
3936 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3937 * htmlspecialchars() or similar
3938 *
3939 * @return string
3940 */
3943 }
3945 /**
3946 * Get the code in Bcp47 format which we can use
3947 * inside of html lang="" tags.
3948 *
3949 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3950 * htmlspecialchars() or similar.
3951 *
3952 * @since 1.19
3953 * @return string
3954 */
3958 }
3960 }
3962 /**
3963 * @param $code string
3964 */
3967 // Ensure we don't leave an incorrect html code lying around
3969 }
3971 /**
3972 * Get the name of a file for a certain language code
3973 * @param $prefix string Prepend this to the filename
3974 * @param $code string Language code
3975 * @param $suffix string Append this to the filename
3976 * @throws MWException
3977 * @return string $prefix . $mangledCode . $suffix
3978 */
3980 // Protect against path traversal
3983 {
3985 }
3988 }
3990 /**
3991 * Get the language code from a file name. Inverse of getFileName()
3992 * @param $filename string $prefix . $languageCode . $suffix
3993 * @param $prefix string Prefix before the language code
3994 * @param $suffix string Suffix after the language code
3995 * @return string Language code, or false if $prefix or $suffix isn't found
3996 */
3997 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4003 }
4005 }
4007 /**
4008 * @param $code string
4009 * @return string
4010 */
4016 }
4018 /**
4019 * @param $code string
4020 * @return string
4021 */
4025 }
4027 /**
4028 * Get the first fallback for a given language.
4029 *
4030 * @param $code string
4031 *
4032 * @return bool|string
4033 */
4041 }
4042 }
4044 /**
4045 * Get the ordered list of fallback languages.
4046 *
4047 * @since 1.19
4048 * @param $code string Language code
4049 * @return array
4050 */
4059 }
4061 }
4062 }
4064 /**
4065 * Get the ordered list of fallback languages, ending with the fallback
4066 * language chain for the site language.
4067 *
4068 * @since 1.22
4069 * @param string $code Language code
4070 * @return array array( fallbacks, site fallbacks )
4071 */
4075 // Usually, we will only store a tiny number of fallback chains, so we
4076 // keep them in static memory.
4082 // Append the site's fallback chain, including the site language itself
4086 // Eliminate any languages already included in the chain
4090 }
4092 }
4094 /**
4095 * Get all messages for a given language
4096 * WARNING: this may take a long time. If you just need all message *keys*
4097 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4098 *
4099 * @param $code string
4100 *
4101 * @return array
4102 */
4105 }
4107 /**
4108 * Get a message for a given language
4109 *
4110 * @param $key string
4111 * @param $code string
4112 *
4113 * @return string
4114 */
4117 }
4119 /**
4120 * Get all message keys for a given language. This is a faster alternative to
4121 * array_keys( Language::getMessagesFor( $code ) )
4122 *
4123 * @since 1.19
4124 * @param $code string Language code
4125 * @return array of message keys (strings)
4126 */
4129 }
4131 /**
4132 * @param $talk
4133 * @return mixed
4134 */
4138 }
4143 # Allow grammar transformations
4144 # Allowing full message-style parsing would make simple requests
4145 # such as action=raw much more expensive than they need to be.
4146 # This will hopefully cover most cases.
4150 }
4152 /**
4153 * @param $m string
4154 * @return string
4155 */
4158 }
4160 /**
4161 * @throws MWException
4162 * @return array
4163 */
4168 }
4175 }
4180 }
4182 /**
4183 * Decode an expiry (block, protection, etc) which has come from the DB
4184 *
4185 * @todo FIXME: why are we returnings DBMS-dependent strings???
4186 *
4187 * @param $expiry String: Database expiry String
4188 * @param $format Bool|Int true to process using language functions, or TS_ constant
4189 * to return the expiry in a given timestamp
4190 * @return String
4191 * @since 1.18
4192 */
4197 }
4207 }
4208 }
4210 /**
4211 * @todo Document
4212 * @param $seconds int|float
4213 * @param $format Array Optional
4214 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4215 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4216 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4217 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4218 * @return string
4219 */
4223 }
4226 }
4229 }
4251 }
4262 }
4266 }
4272 }
4280 }
4290 }
4294 }
4304 }
4305 }
4307 }
4309 /**
4310 * Format a bitrate for output, using an appropriate
4311 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4312 *
4313 * This use base 1000. For base 1024 use formatSize(), for another base
4314 * see formatComputingNumbers()
4315 *
4316 * @param $bps int
4317 * @return string
4318 */
4321 }
4323 /**
4324 * @param $size int Size of the unit
4325 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4326 * @param $messageKey string Message key to be uesd
4327 * @return string
4328 */
4333 );
4334 }
4342 }
4344 // For small sizes no decimal places necessary
4347 // For MB and bigger two decimal places are smarter
4349 }
4355 }
4357 /**
4358 * Format a size in bytes for output, using an appropriate
4359 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4360 *
4361 * This method use base 1024. For base 1000 use formatBitrate(), for
4362 * another base see formatComputingNumbers()
4363 *
4364 * @param $size int Size to format
4365 * @return string Plain text (not HTML)
4366 */
4369 }
4371 /**
4372 * Make a list item, used by various special pages
4373 *
4374 * @param $page String Page link
4375 * @param $details String Text between brackets
4376 * @param $oppositedm Boolean Add the direction mark opposite to your
4377 * language, to display text properly
4378 * @return String
4379 */
4386 }
4388 /**
4389 * Generate (prev x| next x) (20|50|100...) type links for paging
4390 *
4391 * @param $title Title object to link
4392 * @param $offset Integer offset parameter
4393 * @param $limit Integer limit parameter
4394 * @param $query array|String optional URL query parameter string
4395 * @param $atend Bool optional param for specified if this is the last page
4396 * @return String
4397 */
4398 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4399 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4401 # Make 'previous' link
4402 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4408 }
4410 # Make 'next' link
4411 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4417 }
4419 # Make links to set number of items per page
4424 }
4428 }
4430 /**
4431 * Helper function for viewPrevNext() that generates links
4432 *
4433 * @param $title Title object to link
4434 * @param $offset Integer offset parameter
4435 * @param $limit Integer limit parameter
4436 * @param $query Array extra query parameters
4437 * @param $link String text to use for the link; will be escaped
4438 * @param $tooltipMsg String name of the message to use as tooltip
4439 * @param $class String value of the "class" attribute of the link
4440 * @return String HTML fragment
4441 */
4442 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4444 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4447 }
4449 /**
4450 * Get the conversion rule title, if any.
4451 *
4452 * @return string
4453 */
4456 }
4458 /**
4459 * Get the compiled plural rules for the language
4460 * @since 1.20
4461 * @return array Associative array with plural form, and plural rule as key-value pairs
4462 */
4468 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4471 }
4472 }
4473 }
4475 }
4477 /**
4478 * Get the plural rules for the language
4479 * @since 1.20
4480 * @return array Associative array with plural form number and plural rule as key-value pairs
4481 */
4490 }
4491 }
4492 }
4494 }
4496 /**
4497 * Get the plural rule types for the language
4498 * @since 1.21
4499 * @return array Associative array with plural form number and plural rule type as key-value pairs
4500 */
4506 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4509 }
4510 }
4511 }
4513 }
4515 /**
4516 * Find the index number of the plural rule appropriate for the given number
4517 * @return int The index number of the plural rule
4518 */
4523 }
4525 /**
4526 * Find the plural rule type appropriate for the given number
4527 * For example, if the language is set to Arabic, getPluralType(5) should
4528 * return 'few'.
4529 * @since 1.21
4530 * @return string The name of the plural rule type, e.g. one, two, few, many
4531 */
4539 }
4540 }
4541 }