| blob | c73ccd1eabfb27ebc09004bdf00f31e6e93969f7 |
1 <?php
2 /**
3 * Internationalisation code.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
19 *
20 * @file
21 * @ingroup Language
22 */
24 /**
25 * @defgroup Language Language
26 */
31 }
33 # Read language names
39 }
41 /**
42 * a fake language converter
43 *
44 * @ingroup Language
45 */
47 /**
48 * @var Language
49 */
69 }
71 /**
72 * Internationalisation code
73 * @ingroup Language
74 */
77 /**
78 * @var LanguageConverter
79 */
91 /**
92 * ReplacementArray object caches
93 */
96 /**
97 * @var LocalisationCache
98 */
106 );
110 );
115 'december'
116 );
120 'december-gen'
121 );
125 );
132 );
140 );
148 );
155 );
157 /**
158 * @since 1.20
159 * @var array
160 */
171 );
173 /**
174 * Get a cached or new language object for a given language code
175 * @param $code String
176 * @return Language
177 */
183 }
185 // get the language object to process
190 // merge the language object in to get it up front in the cache
192 // get rid of the oldest ones in case we have an overflow
196 }
198 /**
199 * Create a language object for a given language code
200 * @param $code String
201 * @throws MWException
202 * @return Language
203 */
205 // Protect against path traversal below
208 {
210 }
213 // It's not possible to customise this code with class files, so
214 // just return a Language object. This is to support uselang= hacks.
218 }
220 // Check if there is a language class for the code
226 }
228 // Keep trying the fallback list until we find an existing class
233 }
241 }
242 }
245 }
247 /**
248 * Checks whether any localisation is available for that language tag
249 * in MediaWiki (MessagesXx.php exists).
250 *
251 * @param string $code Language tag (in lower case)
252 * @return bool Whether language is supported
253 * @since 1.21
254 */
257 }
259 /**
260 * Returns true if a language code string is a well-formed language tag
261 * according to RFC 5646.
262 * This function only checks well-formedness; it doesn't check that
263 * language, script or variant codes actually exist in the repositories.
264 *
265 * Based on regexes by Mark Davis of the Unicode Consortium:
266 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
267 *
268 * @param $code string
269 * @param $lenient boolean Whether to allow '_' as separator. The default is only '-'.
270 *
271 * @return bool
272 * @since 1.21
273 */
289 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
290 # Since these are limited, this is safe even later changes to the registry --
291 # the only oddity is that it might change the type of the tag, and thus
292 # the results from the capturing groups.
293 # http://www.iana.org/assignments/language-subtag-registry
311 # The final breakdown, with capturing groups for each of these components
312 # The variants, extensions, grandfathered, and private-use may have interior '-'
317 }
319 /**
320 * Returns true if a language code string is of a valid form, whether or
321 * not it exists. This includes codes which are used solely for
322 * customisation via the MediaWiki namespace.
323 *
324 * @param $code string
325 *
326 * @return bool
327 */
332 }
333 // People think language codes are html safe, so enforce it.
334 // Ideally we should only allow a-zA-Z0-9-
335 // but, .+ and other chars are often used for {{int:}} hacks
336 // see bugs 37564, 37587, 36938
342 }
344 /**
345 * Returns true if a language code is of a valid form for the purposes of
346 * internal customisation of MediaWiki, via Messages*.php.
347 *
348 * @param $code string
349 *
350 * @throws MWException
351 * @since 1.18
352 * @return bool
353 */
361 }
364 }
367 }
369 /**
370 * Returns true if a language code is an IETF tag known to MediaWiki.
371 *
372 * @param $code string
373 *
374 * @since 1.21
375 * @return bool
376 */
382 }
386 ) {
388 }
391 }
393 /**
394 * @param $code
395 * @return String Name of the language class
396 */
402 }
403 }
405 /**
406 * Includes language class files
407 *
408 * @param $class string Name of the language class
409 */
415 }
419 }
420 }
422 /**
423 * Get the LocalisationCache instance
424 *
425 * @return LocalisationCache
426 */
432 }
434 }
438 // Set the code to the name of the descendant
443 }
445 }
447 /**
448 * Reduce memory usage
449 */
453 }
454 }
456 /**
457 * Hook which will be called if this is the content language.
458 * Descendants can use this to register hook functions or modify globals
459 */
462 /**
463 * Same as getFallbacksFor for current language.
464 * @return array|bool
465 * @deprecated in 1.19
466 */
470 }
472 /**
473 * @return array
474 * @since 1.19
475 */
478 }
480 /**
481 * Exports $wgBookstoreListEn
482 * @return array
483 */
486 }
488 /**
489 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
490 * available in localised form, it will be included in English.
491 *
492 * @return array
493 */
510 }
512 # Sometimes a language will be localised but not actually exist on this wiki.
516 }
517 }
519 # The above mixing may leave namespaces out of canonical order.
520 # Re-order by namespace ID number...
524 }
526 }
528 /**
529 * Arbitrarily set all of the namespace names at once. Mainly used for testing
530 * @param $namespaces Array of namespaces (id => name)
531 */
535 }
537 /**
538 * Resets all of the namespace caches. Mainly used for testing
539 */
544 }
546 /**
547 * A convenience function that returns the same thing as
548 * getNamespaces() except with the array values changed to ' '
549 * where it found '_', useful for producing output to be displayed
550 * e.g. in <select> forms.
551 *
552 * @return array
553 */
558 }
560 }
562 /**
563 * Get a namespace value by key
564 * <code>
565 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
566 * echo $mw_ns; // prints 'MediaWiki'
567 * </code>
568 *
569 * @param $index Int: the array key of the namespace to return
570 * @return mixed, string if the namespace value exists, otherwise false
571 */
575 }
577 /**
578 * A convenience function that returns the same thing as
579 * getNsText() except with '_' changed to ' ', useful for
580 * producing output.
581 *
582 * <code>
583 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
584 * echo $mw_ns; // prints 'MediaWiki talk'
585 * </code>
586 *
587 * @param int $index The array key of the namespace to return
588 * @return string Namespace name without underscores (empty string if namespace does not exist)
589 */
593 }
595 /**
596 * Returns gender-dependent namespace alias if available.
597 * @param $index Int: namespace index
598 * @param $gender String: gender key (male, female... )
599 * @return String
600 * @since 1.18
601 */
605 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
607 }
609 /**
610 * Whether this language makes distinguishes genders for example in
611 * namespaces.
612 * @return bool
613 * @since 1.18
614 */
618 // $wgExtraGenderNamespaces overrides everything
620 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
621 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
622 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
625 // Check what is in i18n files
628 }
629 }
631 /**
632 * Get a namespace key by value, case insensitive.
633 * Only matches namespace names for the current language, not the
634 * canonical ones defined in Namespace.php.
635 *
636 * @param $text String
637 * @return mixed An integer if $text is a valid value otherwise false
638 */
643 }
645 /**
646 * @return array
647 */
659 }
660 }
661 }
664 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
668 }
669 }
672 }
674 }
676 /**
677 * @return array
678 */
682 # Put namespace names and aliases into a hashtable.
683 # If this is too slow, then we should arrange it so that it is done
684 # before caching. The catch is that at pre-cache time, the above
685 # class-specific fixup hasn't been done.
689 }
692 }
696 }
697 }
698 }
700 }
702 /**
703 * Get a namespace key by value, case insensitive. Canonical namespace
704 * names override custom ones defined for the current language.
705 *
706 * @param $text String
707 * @return mixed An integer if $text is a valid value otherwise false
708 */
714 }
717 }
719 /**
720 * short names for language variants used for language conversion links.
721 *
722 * @param $code String
723 * @param $usemsg bool Use the "variantname-xyz" message if it exists
724 * @return string
725 */
730 }
735 # otherwise, output the language code
737 }
738 }
740 /**
741 * @param $name string
742 * @return string
743 */
748 }
750 }
752 /**
753 * @return array
754 */
757 }
759 /**
760 * @return array
761 */
764 }
766 /**
767 * @return array|string
768 */
776 }
777 }
779 /**
780 * @return array
781 */
784 }
786 /**
787 * @param $image
788 * @return array|null
789 */
792 }
794 /**
795 * @return array
796 */
799 }
801 /**
802 * @param $tog
803 * @return string
804 */
807 }
809 /**
810 * Get native language names, indexed by code.
811 * Only those defined in MediaWiki, no other data like CLDR.
812 * If $customisedOnly is true, only returns codes with a messages file
813 *
814 * @param $customisedOnly bool
815 *
816 * @return array
817 * @deprecated in 1.20, use fetchLanguageNames()
818 */
821 }
823 /**
824 * Get translated language names. This is done on best effort and
825 * by default this is exactly the same as Language::getLanguageNames.
826 * The CLDR extension provides translated names.
827 * @param $code String Language code.
828 * @return Array language code => language name
829 * @since 1.18.0
830 * @deprecated in 1.20, use fetchLanguageNames()
831 */
834 }
836 /**
837 * Get an array of language names, indexed by code.
838 * @param $inLanguage null|string: Code of language in which to return the names
839 * Use null for autonyms (native names)
840 * @param $include string:
841 * 'all' all available languages
842 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
843 * 'mwfile' only if the language is in 'mw' *and* has a message file
844 * @return array: language code => language name
845 * @since 1.20
846 */
853 }
858 # TODO: also include when $inLanguage is null, when this code is more efficient
860 }
864 # - Prefer own MediaWiki native name when not using the hook
865 # - For other names just add if not added through the hook
868 }
869 }
873 }
879 }
883 # We do this using a foreach over the codes instead of a directory
884 # loop so that messages files in extensions will work correctly.
888 }
889 }
891 }
892 # 'mw' option; default if it's not one of the other two options (all/mwfile)
894 }
896 /**
897 * @param $code string: The code of the language for which to get the name
898 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
899 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
900 * @return string: Language name or empty
901 * @since 1.20
902 */
906 }
908 /**
909 * Get a message from the MediaWiki namespace.
910 *
911 * @param $msg String: message name
912 * @return string
913 */
916 }
918 /**
919 * Get the native language name of $code.
920 * Only if defined in MediaWiki, no other data like CLDR.
921 * @param $code string
922 * @return string
923 * @deprecated in 1.20, use fetchLanguageName()
924 */
927 }
929 /**
930 * @param $key string
931 * @return string
932 */
935 }
937 /**
938 * @return array
939 */
944 }
946 }
948 /**
949 * @param $key string
950 * @return string
951 */
954 }
956 /**
957 * @param $key string
958 * @return string
959 */
962 }
964 /**
965 * @return array
966 */
971 }
973 }
975 /**
976 * @param $key string
977 * @return string
978 */
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 * This is a workalike of PHP's date() function, but with better
1025 * internationalisation, a reduced set of format characters, and a better
1026 * escaping format.
1027 *
1028 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1029 * the PHP manual for definitions. There are a number of extensions, which
1030 * start with "x":
1031 *
1032 * xn Do not translate digits of the next numeric format character
1033 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1034 * xr Use roman numerals for the next numeric format character
1035 * xh Use hebrew numerals for the next numeric format character
1036 * xx Literal x
1037 * xg Genitive month name
1038 *
1039 * xij j (day number) in Iranian calendar
1040 * xiF F (month name) in Iranian calendar
1041 * xin n (month number) in Iranian calendar
1042 * xiy y (two digit year) in Iranian calendar
1043 * xiY Y (full year) in Iranian calendar
1044 *
1045 * xjj j (day number) in Hebrew calendar
1046 * xjF F (month name) in Hebrew calendar
1047 * xjt t (days in month) in Hebrew calendar
1048 * xjx xg (genitive month name) in Hebrew calendar
1049 * xjn n (month number) in Hebrew calendar
1050 * xjY Y (full year) in Hebrew calendar
1051 *
1052 * xmj j (day number) in Hijri calendar
1053 * xmF F (month name) in Hijri calendar
1054 * xmn n (month number) in Hijri calendar
1055 * xmY Y (full year) in Hijri calendar
1056 *
1057 * xkY Y (full year) in Thai solar calendar. Months and days are
1058 * identical to the Gregorian calendar
1059 * xoY Y (full year) in Minguo calendar or Juche year.
1060 * Months and days are identical to the
1061 * Gregorian calendar
1062 * xtY Y (full year) in Japanese nengo. Months and days are
1063 * identical to the Gregorian calendar
1064 *
1065 * Characters enclosed in double quotes will be considered literal (with
1066 * the quotes themselves removed). Unmatched quotes will be considered
1067 * literal quotes. Example:
1068 *
1069 * "The month is" F => The month is January
1070 * i's" => 20'11"
1071 *
1072 * Backslash escaping is also supported.
1073 *
1074 * Input timestamp is assumed to be pre-normalized to the desired local
1075 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1076 * $ts is UTC if $zone is not given.
1077 *
1078 * @param $format String
1079 * @param $ts String: 14-character timestamp
1080 * YYYYMMDDHHMMSS
1081 * 01234567890123
1082 * @param $zone DateTimeZone: Timezone of $ts
1083 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1084 *
1085 * @throws MWException
1086 * @return string
1087 */
1104 }
1108 }
1115 }
1117 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1119 }
1143 }
1153 );
1154 }
1163 }
1169 }
1175 }
1182 );
1183 }
1192 }
1198 }
1204 }
1219 }
1225 }
1231 }
1237 }
1246 }
1252 }
1258 }
1264 }
1270 }
1276 }
1285 }
1320 // Pass through string from $dateTimeObj->format()
1324 );
1325 }
1338 // Pass through number from $dateTimeObj->format()
1342 );
1343 }
1347 # Backslash escaping
1352 }
1355 # Quoted literal
1359 # No terminating quote, assume literal "
1364 }
1366 # Quote at end of string, assume literal "
1368 }
1372 }
1385 }
1386 }
1387 }
1389 }
1394 /**
1395 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1396 * Gregorian dates to Iranian dates. Originally written in C, it
1397 * is released under the terms of GNU Lesser General Public
1398 * License. Conversion to PHP was performed by Niklas Laxström.
1399 *
1400 * Link: http://www.farsiweb.info/jalali/jalali.c
1401 *
1402 * @param $ts string
1403 *
1404 * @return string
1405 */
1411 # Days passed from the beginning (including leap years)
1417 // Add days of the past months of this year
1420 }
1422 // Leap years
1425 }
1427 // Days passed in current month
1441 }
1445 }
1451 }
1453 /**
1454 * Converting Gregorian dates to Hijri dates.
1455 *
1456 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1457 *
1458 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1459 *
1460 * @param $ts string
1461 *
1462 * @return string
1463 */
1477 )
1478 {
1486 }
1491 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1492 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1498 }
1500 /**
1501 * Converting Gregorian dates to Hebrew dates.
1502 *
1503 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1504 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1505 * to translate the relevant functions into PHP and release them under
1506 * GNU GPL.
1507 *
1508 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1509 * and Adar II is 14. In a non-leap year, Adar is 6.
1510 *
1511 * @param $ts string
1512 *
1513 * @return string
1514 */
1516 # Parse date
1521 # Calculate Hebrew year
1524 # Month number when September = 1, August = 12
1527 # Next year
1531 }
1533 # Calculate day of year from 1 September
1537 # February
1539 # Check if the year is leap
1542 }
1547 }
1548 }
1550 # Calculate the start of the Hebrew year
1553 # Calculate next year's start
1555 # Day is before the start of the year - it is the previous year
1556 # Next year's start
1558 # Previous year
1561 # Add days since previous year's 1 September
1564 # Leap year
1566 }
1567 # Start of the new (previous) year
1570 # Next year's start
1572 }
1574 # Calculate Hebrew day of year
1577 # Difference between year's days
1579 # Add 12 (or 13 for leap years) days to ignore the difference between
1580 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1581 # difference is only about the year type
1586 }
1588 # Check the year pattern, and is leap year
1589 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1590 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1591 # and non-leap years
1593 # Check if leap year
1596 # Calculate day in the month from number of day in the Hebrew year
1597 # Don't check Adar - if the day is not in Adar, we will stop before;
1598 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1603 # Calculate days in this month
1605 # Adar in a leap year
1607 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1610 # Day in Adar I
1613 # Subtract the days of Adar I
1615 # Try Adar II
1618 # Day in Adar II
1620 }
1621 }
1622 }
1624 # Cheshvan in a complete year (otherwise as the rule below)
1627 # Kislev in an incomplete year (otherwise as the rule below)
1630 # Odd months have 30 days, even have 29
1632 }
1634 # In the current month
1637 # Subtract the days of the current month
1639 # Try in the next month
1641 }
1642 }
1645 }
1647 /**
1648 * This calculates the Hebrew year start, as days since 1 September.
1649 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1650 * Used for Hebrew date.
1651 *
1652 * @param $year int
1653 *
1654 * @return string
1655 */
1662 }
1666 }
1676 }
1680 }
1682 /**
1683 * Algorithm to convert Gregorian dates to Thai solar dates,
1684 * Minguo dates or Minguo dates.
1685 *
1686 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1687 * http://en.wikipedia.org/wiki/Minguo_calendar
1688 * http://en.wikipedia.org/wiki/Japanese_era_name
1689 *
1690 * @param $ts String: 14-character timestamp
1691 * @param $cName String: calender name
1692 * @return Array: converted year, month, day
1693 */
1700 # Thai solar dates
1701 # Add 543 years to the Gregorian calendar
1702 # Months and days are identical
1705 # Minguo dates
1706 # Deduct 1911 years from the Gregorian calendar
1707 # Months and days are identical
1710 # Nengō dates up to Meiji period
1711 # Deduct years from the Gregorian calendar
1712 # depending on the nengo periods
1713 # Months and days are identical
1714 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1715 # Meiji period
1720 }
1728 )
1729 {
1730 # Taishō period
1735 }
1741 )
1742 {
1743 # Shōwa period
1748 }
1751 # Heisei period
1756 }
1758 }
1761 }
1764 }
1766 /**
1767 * Roman number formatting up to 10000
1768 *
1769 * @param $num int
1770 *
1771 * @return string
1772 */
1778 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1779 );
1784 }
1790 }
1792 }
1794 }
1796 /**
1797 * Hebrew Gematria number formatting up to 9999
1798 *
1799 * @param $num int
1800 *
1801 * @return string
1802 */
1809 );
1814 }
1826 }
1827 }
1828 }
1830 }
1836 }
1855 }
1857 }
1859 /**
1860 * Used by date() and time() to adjust the time output.
1861 *
1862 * @param $ts Int the time in date('YmdHis') format
1863 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1864 * get user timecorrection setting)
1865 * @return int
1866 */
1872 }
1885 }
1886 # Unrecognized timezone, default to 'Offset' with the stored offset.
1888 }
1892 # Global offset in minutes.
1895 }
1906 }
1909 }
1910 }
1912 # No difference ? Return time unchanged
1915 }
1918 # Generate an adjusted date; take advantage of the fact that mktime
1919 # will normalize out-of-range values so we don't have to split $minDiff
1920 # into hours and minutes.
1933 }
1935 /**
1936 * This is meant to be used by time(), date(), and timeanddate() to get
1937 * the date preference they're supposed to use, it should be used in
1938 * all children.
1939 *
1940 *<code>
1941 * function timeanddate([...], $format = true) {
1942 * $datePreference = $this->dateFormat($format);
1943 * [...]
1944 * }
1945 *</code>
1946 *
1947 * @param $usePrefs Mixed: if true, the user's preference is used
1948 * if false, the site/language default is used
1949 * if int/string, assumed to be a format.
1950 * @return string
1951 */
1960 }
1963 }
1965 // return int
1968 }
1971 }
1973 /**
1974 * Get a format string for a given type and preference
1975 * @param $type string May be date, time or both
1976 * @param $pref string The format name as it appears in Messages*.php
1977 *
1978 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
1979 *
1980 * @return string
1981 */
1992 }
1997 }
1998 }
2000 }
2002 }
2004 /**
2005 * @param $ts Mixed: the time format which needs to be turned into a
2006 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2007 * @param $adj Bool: whether to adjust the time output according to the
2008 * user configured offset ($timecorrection)
2009 * @param $format Mixed: true to use user's date format preference
2010 * @param $timecorrection String|bool the time offset as returned by
2011 * validateTimeZone() in Special:Preferences
2012 * @return string
2013 */
2018 }
2021 }
2023 /**
2024 * @param $ts Mixed: the time format which needs to be turned into a
2025 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2026 * @param $adj Bool: whether to adjust the time output according to the
2027 * user configured offset ($timecorrection)
2028 * @param $format Mixed: true to use user's date format preference
2029 * @param $timecorrection String|bool the time offset as returned by
2030 * validateTimeZone() in Special:Preferences
2031 * @return string
2032 */
2037 }
2040 }
2042 /**
2043 * @param $ts Mixed: the time format which needs to be turned into a
2044 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2045 * @param $adj Bool: whether to adjust the time output according to the
2046 * user configured offset ($timecorrection)
2047 * @param $format Mixed: what format to return, if it's false output the
2048 * default one (default true)
2049 * @param $timecorrection String|bool the time offset as returned by
2050 * validateTimeZone() in Special:Preferences
2051 * @return string
2052 */
2057 }
2060 }
2062 /**
2063 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2064 *
2065 * @since 1.20
2066 *
2067 * @param integer $seconds The amount of seconds.
2068 * @param array $chosenIntervals The intervals to enable.
2069 *
2070 * @return string
2071 */
2080 }
2083 }
2085 /**
2086 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2087 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2088 *
2089 * @since 1.20
2090 *
2091 * @param integer $seconds The amount of seconds.
2092 * @param array $chosenIntervals The intervals to enable.
2093 *
2094 * @return array
2095 */
2098 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2099 }
2113 }
2114 }
2117 }
2119 /**
2120 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2121 *
2122 * @param $type String: can be 'date', 'time' or 'both'
2123 * @param $ts Mixed: the time format which needs to be turned into a
2124 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2125 * @param $user User object used to get preferences for timezone and format
2126 * @param $options Array, can contain the following keys:
2127 * - 'timecorrection': time correction, can have the following values:
2128 * - true: use user's preference
2129 * - false: don't use time correction
2130 * - integer: value of time correction in minutes
2131 * - 'format': format to use, can have the following values:
2132 * - true: use user's preference
2133 * - false: use default preference
2134 * - string: format to use
2135 * @since 1.19
2136 * @return String
2137 */
2146 }
2148 }
2153 }
2156 }
2158 /**
2159 * Get the formatted date for the given timestamp and formatted for
2160 * the given user.
2161 *
2162 * @param $ts Mixed: the time format which needs to be turned into a
2163 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2164 * @param $user User object used to get preferences for timezone and format
2165 * @param $options Array, can contain the following keys:
2166 * - 'timecorrection': time correction, can have the following values:
2167 * - true: use user's preference
2168 * - false: don't use time correction
2169 * - integer: value of time correction in minutes
2170 * - 'format': format to use, can have the following values:
2171 * - true: use user's preference
2172 * - false: use default preference
2173 * - string: format to use
2174 * @since 1.19
2175 * @return String
2176 */
2179 }
2181 /**
2182 * Get the formatted time for the given timestamp and formatted for
2183 * the given user.
2184 *
2185 * @param $ts Mixed: the time format which needs to be turned into a
2186 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2187 * @param $user User object used to get preferences for timezone and format
2188 * @param $options Array, can contain the following keys:
2189 * - 'timecorrection': time correction, can have the following values:
2190 * - true: use user's preference
2191 * - false: don't use time correction
2192 * - integer: value of time correction in minutes
2193 * - 'format': format to use, can have the following values:
2194 * - true: use user's preference
2195 * - false: use default preference
2196 * - string: format to use
2197 * @since 1.19
2198 * @return String
2199 */
2202 }
2204 /**
2205 * Get the formatted date and time for the given timestamp and formatted for
2206 * the given user.
2207 *
2208 * @param $ts Mixed: the time format which needs to be turned into a
2209 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2210 * @param $user User object used to get preferences for timezone and format
2211 * @param $options Array, can contain the following keys:
2212 * - 'timecorrection': time correction, can have the following values:
2213 * - true: use user's preference
2214 * - false: don't use time correction
2215 * - integer: value of time correction in minutes
2216 * - 'format': format to use, can have the following values:
2217 * - true: use user's preference
2218 * - false: use default preference
2219 * - string: format to use
2220 * @since 1.19
2221 * @return String
2222 */
2225 }
2227 /**
2228 * Convert an MWTimestamp into a pretty human-readable timestamp using
2229 * the given user preferences and relative base time.
2230 *
2231 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2232 * on your timestamp object, which will then call this function. Calling
2233 * this function directly will cause hooks to be skipped over.
2234 *
2235 * @see MWTimestamp::getHumanTimestamp
2236 * @param MWTimestamp $ts Timestamp to prettify
2237 * @param MWTimestamp $relativeTo Base timestamp
2238 * @param User $user User preferences to use
2239 * @return string Human timestamp
2240 * @since 1.21
2241 */
2244 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) - (int)$relativeTo->timestamp->format( 'w' ) );
2246 if ( $diff->invert || $days > 5 && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' ) ) {
2247 // Timestamps are in different years: use full timestamp
2248 // Also do full timestamp for future dates
2249 /**
2250 * @FIXME Add better handling of future timestamps.
2251 */
2255 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2259 // Timestamp within the past week: show the day of the week and time
2267 // Timestamp was yesterday: say 'yesterday' and the time.
2274 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2281 // From here on in, the timestamp was soon enough ago so that we can simply say
2282 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2284 // Less than 90 minutes, but more than an hour ago.
2287 // A few minutes ago.
2290 // Less than a minute, but more than 30 sec ago.
2293 // Less than 30 seconds ago.
2295 }
2298 }
2300 /**
2301 * @param $key string
2302 * @return array|null
2303 */
2306 }
2308 /**
2309 * @return array
2310 */
2313 }
2315 /**
2316 * @param $in
2317 * @param $out
2318 * @param $string
2319 * @return string
2320 */
2322 # This is a wrapper for iconv in all languages except esperanto,
2323 # which does some nasty x-conversions beforehand
2325 # Even with //IGNORE iconv can whine about illegal characters in
2326 # *input* string. We just ignore those too.
2327 # REF: http://bugs.php.net/bug.php?id=37166
2328 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2333 }
2335 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2337 /**
2338 * @param $matches array
2339 * @return mixed|string
2340 */
2343 }
2345 /**
2346 * @param $matches array
2347 * @return string
2348 */
2351 }
2353 /**
2354 * @param $matches array
2355 * @return string
2356 */
2360 }
2362 /**
2363 * @param $matches array
2364 * @return string
2365 */
2369 }
2371 /**
2372 * @param $matches array
2373 * @return string
2374 */
2377 }
2379 /**
2380 * @param $matches array
2381 * @return string
2382 */
2386 }
2388 /**
2389 * Make a string's first character uppercase
2390 *
2391 * @param $str string
2392 *
2393 * @return string
2394 */
2402 // fall back to more complex logic in case of multibyte strings
2404 }
2405 }
2407 /**
2408 * Convert a string to uppercase
2409 *
2410 * @param $str string
2411 * @param $first bool
2412 *
2413 * @return string
2414 */
2422 }
2425 }
2432 $str
2433 );
2436 }
2437 }
2438 }
2440 /**
2441 * @param $str string
2442 * @return mixed|string
2443 */
2455 }
2456 }
2458 /**
2459 * @param $str string
2460 * @param $first bool
2461 * @return mixed|string
2462 */
2470 }
2473 }
2480 $str
2481 );
2484 }
2485 }
2486 }
2488 /**
2489 * @param $str string
2490 * @return bool
2491 */
2494 }
2496 /**
2497 * @param $str string
2498 * @return mixed|string
2499 */
2504 // regexp to find first letter in each word (i.e. after each space)
2505 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2507 // function to use to capitalize a single char
2512 $str
2513 );
2518 $str
2519 );
2520 }
2523 }
2524 }
2526 /**
2527 * capitalize words at word breaks
2528 *
2529 * @param $str string
2530 * @return mixed
2531 */
2536 // since \b doesn't work for UTF-8, we explicitely define word break chars
2539 // find first letter after word break
2540 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2546 $str
2547 );
2552 $str
2553 );
2554 }
2559 $str
2560 );
2561 }
2562 }
2564 /**
2565 * Return a case-folded representation of $s
2566 *
2567 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2568 * and $s2 are the same except for the case of their characters. It is not
2569 * necessary for the value returned to make sense when displayed.
2570 *
2571 * Do *not* perform any other normalisation in this function. If a caller
2572 * uses this function when it should be using a more general normalisation
2573 * function, then fix the caller.
2574 *
2575 * @param $s string
2576 *
2577 * @return string
2578 */
2581 }
2583 /**
2584 * @param $s string
2585 * @return string
2586 */
2590 }
2593 }
2596 }
2598 /**
2599 * @return array
2600 */
2603 }
2605 /**
2606 * Most writing systems use whitespace to break up words.
2607 * Some languages such as Chinese don't conventionally do this,
2608 * which requires special handling when breaking up words for
2609 * searching etc.
2610 *
2611 * @return bool
2612 */
2615 }
2617 /**
2618 * Some languages such as Chinese require word segmentation,
2619 * Specify such segmentation when overridden in derived class.
2620 *
2621 * @param $string String
2622 * @return String
2623 */
2626 }
2628 /**
2629 * Some languages have special punctuation need to be normalized.
2630 * Make such changes here.
2631 *
2632 * @param $string String
2633 * @return String
2634 */
2637 }
2639 /**
2640 * convert double-width roman characters to single-width.
2641 * range: ff00-ff5f ~= 0020-007f
2642 *
2643 * @param $string string
2644 *
2645 * @return string
2646 */
2656 }
2660 }
2662 /**
2663 * @param $string string
2664 * @param $pattern string
2665 * @return string
2666 */
2671 }
2673 /**
2674 * @param $termsArray array
2675 * @return array
2676 */
2678 # some languages, e.g. Chinese, need to do a conversion
2679 # in order for search results to be displayed correctly
2681 }
2683 /**
2684 * Get the first character of a string.
2685 *
2686 * @param $s string
2687 * @return string
2688 */
2695 $matches
2696 );
2701 }
2703 // Break down Hangul syllables to grab the first jamo
2735 }
2738 }
2739 }
2742 # Some languages may have an alternate char encoding option
2743 # (Esperanto X-coding, Japanese furigana conversion, etc)
2744 # If this language is used as the primary content language,
2745 # an override to the defaults can be set here on startup.
2746 }
2748 /**
2749 * @param $s string
2750 * @return string
2751 */
2753 # For some languages we'll want to explicitly specify
2754 # which characters make it into the edit box raw
2755 # or are converted in some way or another.
2761 }
2762 }
2764 /**
2765 * @param $s string
2766 * @return string
2767 */
2769 # Take the previous into account.
2775 }
2780 }
2781 }
2783 /**
2784 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2785 * also cleans up certain backwards-compatible sequences, converting them
2786 * to the modern Unicode equivalent.
2787 *
2788 * This is language-specific for performance reasons only.
2789 *
2790 * @param $s string
2791 *
2792 * @return string
2793 */
2800 }
2803 }
2805 /**
2806 * Transform a string using serialized data stored in the given file (which
2807 * must be in the serialized subdirectory of $IP). The file contains pairs
2808 * mapping source characters to destination characters.
2809 *
2810 * The data is cached in process memory. This will go faster if you have the
2811 * FastStringSearch extension.
2812 *
2813 * @param $file string
2814 * @param $string string
2815 *
2816 * @throws MWException
2817 * @return string
2818 */
2824 }
2826 }
2828 }
2830 /**
2831 * For right-to-left language support
2832 *
2833 * @return bool
2834 */
2837 }
2839 /**
2840 * Return the correct HTML 'dir' attribute value for this language.
2841 * @return String
2842 */
2845 }
2847 /**
2848 * Return 'left' or 'right' as appropriate alignment for line-start
2849 * for this language's text direction.
2850 *
2851 * Should be equivalent to CSS3 'start' text-align value....
2852 *
2853 * @return String
2854 */
2857 }
2859 /**
2860 * Return 'right' or 'left' as appropriate alignment for line-end
2861 * for this language's text direction.
2862 *
2863 * Should be equivalent to CSS3 'end' text-align value....
2864 *
2865 * @return String
2866 */
2869 }
2871 /**
2872 * A hidden direction mark (LRM or RLM), depending on the language direction.
2873 * Unlike getDirMark(), this function returns the character as an HTML entity.
2874 * This function should be used when the output is guaranteed to be HTML,
2875 * because it makes the output HTML source code more readable. When
2876 * the output is plain text or can be escaped, getDirMark() should be used.
2877 *
2878 * @param $opposite Boolean Get the direction mark opposite to your language
2879 * @return string
2880 * @since 1.20
2881 */
2885 }
2887 }
2889 /**
2890 * A hidden direction mark (LRM or RLM), depending on the language direction.
2891 * This function produces them as invisible Unicode characters and
2892 * the output may be hard to read and debug, so it should only be used
2893 * when the output is plain text or can be escaped. When the output is
2894 * HTML, use getDirMarkEntity() instead.
2895 *
2896 * @param $opposite Boolean Get the direction mark opposite to your language
2897 * @return string
2898 */
2904 }
2906 }
2908 /**
2909 * @return array
2910 */
2913 }
2915 /**
2916 * An arrow, depending on the language direction.
2917 *
2918 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2919 * @return string
2920 */
2935 }
2936 }
2938 /**
2939 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2940 *
2941 * @return bool
2942 */
2945 }
2947 /**
2948 * @return array
2949 */
2952 }
2957 }
2962 }
2964 /**
2965 * Fill a MagicWord object with data from here
2966 *
2967 * @param $mw
2968 */
2980 }
2981 }
2988 }
2989 }
2991 /**
2992 * Add magic words to the extension array
2993 *
2994 * @param $newWords array
2995 */
3002 }
3003 }
3004 }
3006 /**
3007 * Get special page names, as an associative array
3008 * case folded alias => real name
3009 */
3011 // Cache aliases because it may be slow to load them
3013 // Initialise array
3018 }
3021 }
3023 /**
3024 * Italic is unsuitable for some languages
3025 *
3026 * @param $text String: the text to be emphasized.
3027 * @return string
3028 */
3031 }
3033 /**
3034 * Normally we output all numbers in plain en_US style, that is
3035 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3036 * point twohundredthirtyfive. However this is not suitable for all
3037 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
3038 * Icelandic just want to use commas instead of dots, and dots instead
3039 * of commas like "293.291,235".
3040 *
3041 * An example of this function being called:
3042 * <code>
3043 * wfMessage( 'message' )->numParams( $num )->text()
3044 * </code>
3045 *
3046 * See LanguageGu.php for the Gujarati implementation and
3047 * $separatorTransformTable on MessageIs.php for
3048 * the , => . and . => , implementation.
3049 *
3050 * @todo check if it's viable to use localeconv() for the decimal
3051 * separator thing.
3052 * @param $number Mixed: the string to be formatted, should be an integer
3053 * or a floating point number.
3054 * @param $nocommafy Bool: set to true for special numbers like dates
3055 * @return string
3056 */
3064 }
3065 }
3071 }
3072 }
3075 }
3077 /**
3078 * Front-end for non-commafied formatNum
3079 *
3080 * @param mixed $number the string to be formatted, should be an integer
3081 * or a floating point number.
3082 * @since 1.21
3083 * @return string
3084 */
3087 }
3089 /**
3090 * @param $number string
3091 * @return string
3092 */
3097 }
3102 }
3106 }
3108 /**
3109 * Adds commas to a given number
3110 * @since 1.19
3111 * @param $number mixed
3112 * @return string
3113 */
3118 }
3121 // default grouping is at thousands, use the same for ###,###,### pattern too.
3124 // Ref: http://cldr.unicode.org/translation/number-patterns
3127 // For negative numbers apply the algorithm like positive number and add sign.
3130 }
3138 // the string does not have any number part. Eg: .12345
3140 }
3148 }
3152 // use the last pattern for the rest of the number
3154 }
3157 }
3158 }
3160 }
3161 }
3163 /**
3164 * @return String
3165 */
3168 }
3170 /**
3171 * @return array
3172 */
3175 }
3177 /**
3178 * @return array
3179 */
3182 }
3184 /**
3185 * Take a list of strings and build a locale-friendly comma-separated
3186 * list, using the local comma-separator message.
3187 * The last two strings are chained with an "and".
3188 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3189 *
3190 * @param $l Array
3191 * @return string
3192 */
3197 }
3203 }
3204 }
3211 }
3212 }
3214 }
3216 /**
3217 * Take a list of strings and build a locale-friendly comma-separated
3218 * list, using the local comma-separator message.
3219 * @param $list array of strings to put in a comma list
3220 * @return string
3221 */
3225 $list
3226 );
3227 }
3229 /**
3230 * Take a list of strings and build a locale-friendly semicolon-separated
3231 * list, using the local semicolon-separator message.
3232 * @param $list array of strings to put in a semicolon list
3233 * @return string
3234 */
3238 $list
3239 );
3240 }
3242 /**
3243 * Same as commaList, but separate it with the pipe instead.
3244 * @param $list array of strings to put in a pipe list
3245 * @return string
3246 */
3250 $list
3251 );
3252 }
3254 /**
3255 * Truncate a string to a specified length in bytes, appending an optional
3256 * string (e.g. for ellipses)
3257 *
3258 * The database offers limited byte lengths for some columns in the database;
3259 * multi-byte character sets mean we need to ensure that only whole characters
3260 * are included, otherwise broken characters can be passed to the user
3261 *
3262 * If $length is negative, the string will be truncated from the beginning
3263 *
3264 * @param $string String to truncate
3265 * @param $length Int: maximum length (including ellipses)
3266 * @param $ellipsis String to append to the truncated text
3267 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3268 * $adjustLength was introduced in 1.18, before that behaved as if false.
3269 * @return string
3270 */
3272 # Use the localized ellipsis character
3275 }
3276 # Check if there is no need to truncate
3281 }
3283 # If ellipsis length is >= $length then we can't apply $adjustLength
3286 # Otherwise, truncate and add ellipsis...
3299 }
3300 }
3301 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3302 # This check is *not* redundant if $adjustLength, due to the single case where
3303 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3308 }
3309 }
3311 /**
3312 * Remove bytes that represent an incomplete Unicode character
3313 * at the end of string (e.g. bytes of the char are missing)
3314 *
3315 * @param $string String
3316 * @return string
3317 */
3323 # We got the first byte only of a multibyte char; remove it.
3328 ) {
3329 # We chopped in the middle of a character; remove it
3331 }
3332 }
3334 }
3336 /**
3337 * Remove bytes that represent an incomplete Unicode character
3338 * at the start of string (e.g. bytes of the char are missing)
3339 *
3340 * @param $string String
3341 * @return string
3342 */
3347 # We chopped in the middle of a character; remove the whole thing
3349 }
3350 }
3352 }
3354 /**
3355 * Truncate a string of valid HTML to a specified length in bytes,
3356 * appending an optional string (e.g. for ellipses), and return valid HTML
3357 *
3358 * This is only intended for styled/linked text, such as HTML with
3359 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3360 * Also, this will not detect things like "display:none" CSS.
3361 *
3362 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3363 *
3364 * @param string $text HTML string to truncate
3365 * @param int $length (zero/positive) Maximum length (including ellipses)
3366 * @param string $ellipsis String to append to the truncated text
3367 * @return string
3368 */
3370 # Use the localized ellipsis character
3373 }
3374 # Check if there is clearly no need to truncate
3379 }
3393 # Consider truncation once the display length has reached the maximim.
3394 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3395 # Check that we're not in the middle of a bracket/entity...
3399 # Save where we are; we will truncate here unless there turn out to
3400 # be so few remaining characters that truncation is not necessary.
3403 }
3405 # String in fact does need truncation, the truncation point was OK.
3410 }
3411 }
3414 }
3416 # Read the next char...
3434 }
3440 // Name found (e.g. "<a href=..."), add on tag attributes...
3442 }
3448 }
3451 // Save state without $ch. We want to *hit* the first
3452 // display char (to get tags) but not *use* it if truncating.
3454 }
3459 // Add the next $max display text chars after this in one swoop...
3464 }
3465 }
3466 }
3467 }
3468 // Close the last tag if left unclosed by bad HTML
3472 }
3474 }
3476 /**
3477 * truncateHtml() helper function
3478 * like strcspn() but adds the skipped chars to $ret
3479 *
3480 * @param $ret
3481 * @param $text
3482 * @param $search
3483 * @param $start
3484 * @param $len
3485 * @return int
3486 */
3492 }
3497 }
3499 }
3501 /**
3502 * truncateHtml() helper function
3503 * (a) push or pop $tag from $openTags as needed
3504 * (b) clear $tag value
3505 * @param &$tag string Current HTML tag name we are looking at
3506 * @param $tagType int (0-open tag, 1-close tag)
3507 * @param $lastCh string Character before the '>' that ended this tag
3508 * @param &$openTags array Open tag stack (not accounting for $tag)
3509 */
3518 }
3519 }
3521 }
3522 }
3524 /**
3525 * Grammatical transformations, needed for inflected languages
3526 * Invoked by putting {{grammar:case|word}} in a message
3527 *
3528 * @param $word string
3529 * @param $case string
3530 * @return string
3531 */
3536 }
3538 }
3539 /**
3540 * Get the grammar forms for the content language
3541 * @return array of grammar forms
3542 * @since 1.20
3543 */
3546 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3548 }
3550 }
3551 /**
3552 * Provides an alternative text depending on specified gender.
3553 * Usage {{gender:username|masculine|feminine|neutral}}.
3554 * username is optional, in which case the gender of current user is used,
3555 * but only in (some) interface messages; otherwise default gender is used.
3556 *
3557 * If no forms are given, an empty string is returned. If only one form is
3558 * given, it will be returned unconditionally. These details are implied by
3559 * the caller and cannot be overridden in subclasses.
3560 *
3561 * If more than one form is given, the default is to use the neutral one
3562 * if it is specified, and to use the masculine one otherwise. These
3563 * details can be overridden in subclasses.
3564 *
3565 * @param $gender string
3566 * @param $forms array
3567 *
3568 * @return string
3569 */
3573 }
3577 }
3580 }
3582 }
3584 /**
3585 * Plural form transformations, needed for some languages.
3586 * For example, there are 3 form of plural in Russian and Polish,
3587 * depending on "count mod 10". See [[w:Plural]]
3588 * For English it is pretty simple.
3589 *
3590 * Invoked by putting {{plural:count|wordform1|wordform2}}
3591 * or {{plural:count|wordform1|wordform2|wordform3}}
3592 *
3593 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3594 *
3595 * @param $count Integer: non-localized number
3596 * @param $forms Array: different plural forms
3597 * @return string Correct form of plural for $count in this language
3598 */
3602 }
3604 // Handle explicit n=pluralform cases
3610 }
3612 }
3613 }
3619 }
3621 /**
3622 * Checks that convertPlural was given an array and pads it to requested
3623 * amount of forms by copying the last one.
3624 *
3625 * @param $count Integer: How many forms should there be at least
3626 * @param $forms Array of forms given to convertPlural
3627 * @return array Padded array of forms or an exception if not an array
3628 */
3632 }
3634 }
3636 /**
3637 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3638 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3639 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3640 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3641 * match up with it.
3642 *
3643 * @param $str String: the validated block duration in English
3644 * @return string Somehow translated block duration
3645 * @see LanguageFi.php for example implementation
3646 */
3652 }
3653 }
3655 // Since usually only infinite or indefinite is only on list, so try
3656 // equivalents if still here.
3663 }
3664 }
3665 }
3667 // If all else fails, return a standard duration or timestamp description.
3672 // $time is relative to 0 so it's a duration length.
3676 // wfTimestamp() handles 0 as current time instead of epoch.
3680 }
3681 }
3682 }
3684 /**
3685 * languages like Chinese need to be segmented in order for the diff
3686 * to be of any use
3687 *
3688 * @param $text String
3689 * @return String
3690 */
3693 }
3695 /**
3696 * and unsegment to show the result
3697 *
3698 * @param $text String
3699 * @return String
3700 */
3703 }
3705 /**
3706 * Return the LanguageConverter used in the Language
3707 *
3708 * @since 1.19
3709 * @return LanguageConverter
3710 */
3713 }
3715 /**
3716 * convert text to all supported variants
3717 *
3718 * @param $text string
3719 * @return array
3720 */
3723 }
3725 /**
3726 * convert text to different variants of a language.
3727 *
3728 * @param $text string
3729 * @return string
3730 */
3733 }
3735 /**
3736 * Convert a Title object to a string in the preferred variant
3737 *
3738 * @param $title Title
3739 * @return string
3740 */
3743 }
3745 /**
3746 * Convert a namespace index to a string in the preferred variant
3747 *
3748 * @param $ns int
3749 * @return string
3750 */
3753 }
3755 /**
3756 * Check if this is a language with variants
3757 *
3758 * @return bool
3759 */
3762 }
3764 /**
3765 * Check if the language has the specific variant
3766 *
3767 * @since 1.19
3768 * @param $variant string
3769 * @return bool
3770 */
3773 }
3775 /**
3776 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3777 *
3778 * @param $text string
3779 * @return string
3780 */
3783 }
3785 /**
3786 * Perform output conversion on a string, and encode for safe HTML output.
3787 * @param $text String text to be converted
3788 * @param $isTitle Bool whether this conversion is for the article title
3789 * @return string
3790 * @todo this should get integrated somewhere sane
3791 */
3794 }
3796 /**
3797 * @param $key string
3798 * @return string
3799 */
3802 }
3804 /**
3805 * Get the list of variants supported by this language
3806 * see sample implementation in LanguageZh.php
3807 *
3808 * @return array an array of language codes
3809 */
3812 }
3814 /**
3815 * @return string
3816 */
3819 }
3821 /**
3822 * @return string
3823 */
3826 }
3828 /**
3829 * @return string
3830 */
3833 }
3835 /**
3836 * If a language supports multiple variants, it is
3837 * possible that non-existing link in one variant
3838 * actually exists in another variant. this function
3839 * tries to find it. See e.g. LanguageZh.php
3840 *
3841 * @param $link String: the name of the link
3842 * @param $nt Mixed: the title object of the link
3843 * @param $ignoreOtherCond Boolean: to disable other conditions when
3844 * we need to transclude a template or update a category's link
3845 * @return null the input parameters may be modified upon return
3846 */
3849 }
3851 /**
3852 * If a language supports multiple variants, converts text
3853 * into an array of all possible variants of the text:
3854 * 'variant' => text in that variant
3855 *
3856 * @deprecated since 1.17 Use autoConvertToAllVariants()
3857 *
3858 * @param $text string
3859 *
3860 * @return string
3861 */
3864 }
3866 /**
3867 * returns language specific options used by User::getPageRenderHash()
3868 * for example, the preferred language variant
3869 *
3870 * @return string
3871 */
3874 }
3876 /**
3877 * For languages that support multiple variants, the title of an
3878 * article may be displayed differently in different variants. this
3879 * function returns the apporiate title defined in the body of the article.
3880 *
3881 * @return string
3882 */
3885 }
3887 /**
3888 * Prepare external link text for conversion. When the text is
3889 * a URL, it shouldn't be converted, and it'll be wrapped in
3890 * the "raw" tag (-{R| }-) to prevent conversion.
3891 *
3892 * This function is called "markNoConversion" for historical
3893 * reasons.
3894 *
3895 * @param $text String: text to be used for external link
3896 * @param $noParse bool: wrap it without confirming it's a real URL first
3897 * @return string the tagged text
3898 */
3900 // Excluding protocal-relative URLs may avoid many false positives.
3905 }
3906 }
3908 /**
3909 * A regular expression to match legal word-trailing characters
3910 * which should be merged onto a link of the form [[foo]]bar.
3911 *
3912 * @return string
3913 */
3916 }
3918 /**
3919 * @return Language
3920 */
3923 }
3925 /**
3926 * Get the RFC 3066 code for this language object
3927 *
3928 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3929 * htmlspecialchars() or similar
3930 *
3931 * @return string
3932 */
3935 }
3937 /**
3938 * Get the code in Bcp47 format which we can use
3939 * inside of html lang="" tags.
3940 *
3941 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3942 * htmlspecialchars() or similar.
3943 *
3944 * @since 1.19
3945 * @return string
3946 */
3950 }
3952 }
3954 /**
3955 * @param $code string
3956 */
3959 // Ensure we don't leave an incorrect html code lying around
3961 }
3963 /**
3964 * Get the name of a file for a certain language code
3965 * @param $prefix string Prepend this to the filename
3966 * @param $code string Language code
3967 * @param $suffix string Append this to the filename
3968 * @throws MWException
3969 * @return string $prefix . $mangledCode . $suffix
3970 */
3972 // Protect against path traversal
3975 {
3977 }
3980 }
3982 /**
3983 * Get the language code from a file name. Inverse of getFileName()
3984 * @param $filename string $prefix . $languageCode . $suffix
3985 * @param $prefix string Prefix before the language code
3986 * @param $suffix string Suffix after the language code
3987 * @return string Language code, or false if $prefix or $suffix isn't found
3988 */
3989 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3995 }
3997 }
3999 /**
4000 * @param $code string
4001 * @return string
4002 */
4008 }
4010 /**
4011 * @param $code string
4012 * @return string
4013 */
4017 }
4019 /**
4020 * Get the first fallback for a given language.
4021 *
4022 * @param $code string
4023 *
4024 * @return bool|string
4025 */
4033 }
4034 }
4036 /**
4037 * Get the ordered list of fallback languages.
4038 *
4039 * @since 1.19
4040 * @param $code string Language code
4041 * @return array
4042 */
4051 }
4053 }
4054 }
4056 /**
4057 * Get all messages for a given language
4058 * WARNING: this may take a long time. If you just need all message *keys*
4059 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4060 *
4061 * @param $code string
4062 *
4063 * @return array
4064 */
4067 }
4069 /**
4070 * Get a message for a given language
4071 *
4072 * @param $key string
4073 * @param $code string
4074 *
4075 * @return string
4076 */
4079 }
4081 /**
4082 * Get all message keys for a given language. This is a faster alternative to
4083 * array_keys( Language::getMessagesFor( $code ) )
4084 *
4085 * @since 1.19
4086 * @param $code string Language code
4087 * @return array of message keys (strings)
4088 */
4091 }
4093 /**
4094 * @param $talk
4095 * @return mixed
4096 */
4100 }
4105 # Allow grammar transformations
4106 # Allowing full message-style parsing would make simple requests
4107 # such as action=raw much more expensive than they need to be.
4108 # This will hopefully cover most cases.
4112 }
4114 /**
4115 * @param $m string
4116 * @return string
4117 */
4120 }
4122 /**
4123 * @throws MWException
4124 * @return array
4125 */
4130 }
4137 }
4142 }
4144 /**
4145 * Decode an expiry (block, protection, etc) which has come from the DB
4146 *
4147 * @todo FIXME: why are we returnings DBMS-dependent strings???
4148 *
4149 * @param $expiry String: Database expiry String
4150 * @param $format Bool|Int true to process using language functions, or TS_ constant
4151 * to return the expiry in a given timestamp
4152 * @return String
4153 * @since 1.18
4154 */
4159 }
4169 }
4170 }
4172 /**
4173 * @todo Document
4174 * @param $seconds int|float
4175 * @param $format Array Optional
4176 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4177 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4178 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4179 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4180 * @return string
4181 */
4185 }
4188 }
4191 }
4213 }
4224 }
4228 }
4234 }
4242 }
4252 }
4256 }
4266 }
4267 }
4269 }
4271 /**
4272 * Format a bitrate for output, using an appropriate
4273 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4274 *
4275 * This use base 1000. For base 1024 use formatSize(), for another base
4276 * see formatComputingNumbers()
4277 *
4278 * @param $bps int
4279 * @return string
4280 */
4283 }
4285 /**
4286 * @param $size int Size of the unit
4287 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4288 * @param $messageKey string Message key to be uesd
4289 * @return string
4290 */
4295 );
4296 }
4304 }
4306 // For small sizes no decimal places necessary
4309 // For MB and bigger two decimal places are smarter
4311 }
4317 }
4319 /**
4320 * Format a size in bytes for output, using an appropriate
4321 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4322 *
4323 * This method use base 1024. For base 1000 use formatBitrate(), for
4324 * another base see formatComputingNumbers()
4325 *
4326 * @param $size int Size to format
4327 * @return string Plain text (not HTML)
4328 */
4331 }
4333 /**
4334 * Make a list item, used by various special pages
4335 *
4336 * @param $page String Page link
4337 * @param $details String Text between brackets
4338 * @param $oppositedm Boolean Add the direction mark opposite to your
4339 * language, to display text properly
4340 * @return String
4341 */
4348 }
4350 /**
4351 * Generate (prev x| next x) (20|50|100...) type links for paging
4352 *
4353 * @param $title Title object to link
4354 * @param $offset Integer offset parameter
4355 * @param $limit Integer limit parameter
4356 * @param $query array|String optional URL query parameter string
4357 * @param $atend Bool optional param for specified if this is the last page
4358 * @return String
4359 */
4360 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4361 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4363 # Make 'previous' link
4364 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4370 }
4372 # Make 'next' link
4373 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4379 }
4381 # Make links to set number of items per page
4386 }
4390 }
4392 /**
4393 * Helper function for viewPrevNext() that generates links
4394 *
4395 * @param $title Title object to link
4396 * @param $offset Integer offset parameter
4397 * @param $limit Integer limit parameter
4398 * @param $query Array extra query parameters
4399 * @param $link String text to use for the link; will be escaped
4400 * @param $tooltipMsg String name of the message to use as tooltip
4401 * @param $class String value of the "class" attribute of the link
4402 * @return String HTML fragment
4403 */
4404 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4406 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4409 }
4411 /**
4412 * Get the conversion rule title, if any.
4413 *
4414 * @return string
4415 */
4418 }
4420 /**
4421 * Get the compiled plural rules for the language
4422 * @since 1.20
4423 * @return array Associative array with plural form, and plural rule as key-value pairs
4424 */
4430 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4433 }
4434 }
4435 }
4437 }
4439 /**
4440 * Get the plural rules for the language
4441 * @since 1.20
4442 * @return array Associative array with plural form number and plural rule as key-value pairs
4443 */
4452 }
4453 }
4454 }
4456 }
4458 /**
4459 * Get the plural rule types for the language
4460 * @since 1.21
4461 * @return array Associative array with plural form number and plural rule type as key-value pairs
4462 */
4468 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4471 }
4472 }
4473 }
4475 }
4477 /**
4478 * Find the index number of the plural rule appropriate for the given number
4479 * @return int The index number of the plural rule
4480 */
4485 }
4487 /**
4488 * Find the plural rule type appropriate for the given number
4489 * For example, if the language is set to Arabic, getPluralType(5) should
4490 * return 'few'.
4491 * @since 1.21
4492 * @return string The name of the plural rule type, e.g. one, two, few, many
4493 */
4501 }
4502 }
4503 }