| blob | 356726ff9d253a3609e2d8e2b85f5568590e111a |
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 }
35 }
37 /**
38 * a fake language converter
39 *
40 * @ingroup Language
41 */
43 /**
44 * @var Language
45 */
67 function validateVariant( $variant = null ) { return $variant === $this->mLang->getCode() ? $variant : null; }
69 }
71 /**
72 * Internationalisation code
73 * @ingroup Language
74 */
77 /**
78 * @var LanguageConverter
79 */
91 /**
92 * ReplacementArray object caches
93 */
96 /**
97 * @var LocalisationCache
98 */
106 );
110 );
115 'december'
116 );
120 'december-gen'
121 );
125 );
132 );
140 );
148 );
155 );
157 /**
158 * @since 1.20
159 * @var array
160 */
171 );
173 /**
174 * Cache for language fallbacks.
175 * @see Language::getFallbacksIncludingSiteLanguage
176 * @since 1.21
177 * @var array
178 */
181 /**
182 * Get a cached or new language object for a given language code
183 * @param $code String
184 * @return Language
185 */
191 }
193 // get the language object to process
198 // merge the language object in to get it up front in the cache
200 // get rid of the oldest ones in case we have an overflow
204 }
206 /**
207 * Create a language object for a given language code
208 * @param $code String
209 * @throws MWException
210 * @return Language
211 */
213 // Protect against path traversal below
216 {
218 }
221 // It's not possible to customise this code with class files, so
222 // just return a Language object. This is to support uselang= hacks.
226 }
228 // Check if there is a language class for the code
234 }
236 // Keep trying the fallback list until we find an existing class
241 }
249 }
250 }
253 }
255 /**
256 * Checks whether any localisation is available for that language tag
257 * in MediaWiki (MessagesXx.php exists).
258 *
259 * @param string $code Language tag (in lower case)
260 * @return bool Whether language is supported
261 * @since 1.21
262 */
265 }
267 /**
268 * Returns true if a language code string is a well-formed language tag
269 * according to RFC 5646.
270 * This function only checks well-formedness; it doesn't check that
271 * language, script or variant codes actually exist in the repositories.
272 *
273 * Based on regexes by Mark Davis of the Unicode Consortium:
274 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
275 *
276 * @param $code string
277 * @param $lenient boolean Whether to allow '_' as separator. The default is only '-'.
278 *
279 * @return bool
280 * @since 1.21
281 */
297 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
298 # Since these are limited, this is safe even later changes to the registry --
299 # the only oddity is that it might change the type of the tag, and thus
300 # the results from the capturing groups.
301 # http://www.iana.org/assignments/language-subtag-registry
319 # The final breakdown, with capturing groups for each of these components
320 # The variants, extensions, grandfathered, and private-use may have interior '-'
325 }
327 /**
328 * Returns true if a language code string is of a valid form, whether or
329 * not it exists. This includes codes which are used solely for
330 * customisation via the MediaWiki namespace.
331 *
332 * @param $code string
333 *
334 * @return bool
335 */
340 }
341 // People think language codes are html safe, so enforce it.
342 // Ideally we should only allow a-zA-Z0-9-
343 // but, .+ and other chars are often used for {{int:}} hacks
344 // see bugs 37564, 37587, 36938
350 }
352 /**
353 * Returns true if a language code is of a valid form for the purposes of
354 * internal customisation of MediaWiki, via Messages*.php.
355 *
356 * @param $code string
357 *
358 * @throws MWException
359 * @since 1.18
360 * @return bool
361 */
369 }
372 }
375 }
377 /**
378 * Returns true if a language code is an IETF tag known to MediaWiki.
379 *
380 * @param $code string
381 *
382 * @since 1.21
383 * @return bool
384 */
388 // Quick escape for invalid input to avoid exceptions down the line
389 // when code tries to process tags which are not valid at all.
392 }
397 }
401 ) {
403 }
406 }
408 /**
409 * @param $code
410 * @return String Name of the language class
411 */
417 }
418 }
420 /**
421 * Includes language class files
422 *
423 * @param $class string Name of the language class
424 */
430 }
434 }
435 }
437 /**
438 * Get the LocalisationCache instance
439 *
440 * @return LocalisationCache
441 */
447 }
449 }
453 // Set the code to the name of the descendant
458 }
460 }
462 /**
463 * Reduce memory usage
464 */
468 }
469 }
471 /**
472 * Hook which will be called if this is the content language.
473 * Descendants can use this to register hook functions or modify globals
474 */
477 /**
478 * Same as getFallbacksFor for current language.
479 * @return array|bool
480 * @deprecated in 1.19
481 */
485 }
487 /**
488 * @return array
489 * @since 1.19
490 */
493 }
495 /**
496 * Exports $wgBookstoreListEn
497 * @return array
498 */
501 }
503 /**
504 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
505 * available in localised form, it will be included in English.
506 *
507 * @return array
508 */
525 }
527 # Sometimes a language will be localised but not actually exist on this wiki.
531 }
532 }
534 # The above mixing may leave namespaces out of canonical order.
535 # Re-order by namespace ID number...
539 }
541 }
543 /**
544 * Arbitrarily set all of the namespace names at once. Mainly used for testing
545 * @param $namespaces Array of namespaces (id => name)
546 */
550 }
552 /**
553 * Resets all of the namespace caches. Mainly used for testing
554 */
559 }
561 /**
562 * A convenience function that returns the same thing as
563 * getNamespaces() except with the array values changed to ' '
564 * where it found '_', useful for producing output to be displayed
565 * e.g. in <select> forms.
566 *
567 * @return array
568 */
573 }
575 }
577 /**
578 * Get a namespace value by key
579 * <code>
580 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
581 * echo $mw_ns; // prints 'MediaWiki'
582 * </code>
583 *
584 * @param $index Int: the array key of the namespace to return
585 * @return mixed, string if the namespace value exists, otherwise false
586 */
590 }
592 /**
593 * A convenience function that returns the same thing as
594 * getNsText() except with '_' changed to ' ', useful for
595 * producing output.
596 *
597 * <code>
598 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
599 * echo $mw_ns; // prints 'MediaWiki talk'
600 * </code>
601 *
602 * @param int $index The array key of the namespace to return
603 * @return string Namespace name without underscores (empty string if namespace does not exist)
604 */
608 }
610 /**
611 * Returns gender-dependent namespace alias if available.
612 * @param $index Int: namespace index
613 * @param $gender String: gender key (male, female... )
614 * @return String
615 * @since 1.18
616 */
620 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
622 }
624 /**
625 * Whether this language makes distinguishes genders for example in
626 * namespaces.
627 * @return bool
628 * @since 1.18
629 */
633 // $wgExtraGenderNamespaces overrides everything
635 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
636 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
637 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
640 // Check what is in i18n files
643 }
644 }
646 /**
647 * Get a namespace key by value, case insensitive.
648 * Only matches namespace names for the current language, not the
649 * canonical ones defined in Namespace.php.
650 *
651 * @param $text String
652 * @return mixed An integer if $text is a valid value otherwise false
653 */
658 }
660 /**
661 * @return array
662 */
674 }
675 }
676 }
679 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
683 }
684 }
686 # Also add converted namespace names as aliases, to avoid confusion.
691 }
694 }
695 }
698 }
700 }
702 /**
703 * @return array
704 */
708 # Put namespace names and aliases into a hashtable.
709 # If this is too slow, then we should arrange it so that it is done
710 # before caching. The catch is that at pre-cache time, the above
711 # class-specific fixup hasn't been done.
715 }
718 }
722 }
723 }
724 }
726 }
728 /**
729 * Get a namespace key by value, case insensitive. Canonical namespace
730 * names override custom ones defined for the current language.
731 *
732 * @param $text String
733 * @return mixed An integer if $text is a valid value otherwise false
734 */
740 }
743 }
745 /**
746 * short names for language variants used for language conversion links.
747 *
748 * @param $code String
749 * @param $usemsg bool Use the "variantname-xyz" message if it exists
750 * @return string
751 */
756 }
761 # otherwise, output the language code
763 }
764 }
766 /**
767 * @param $name string
768 * @return string
769 */
774 }
776 }
778 /**
779 * @return array
780 */
783 }
785 /**
786 * @return array
787 */
790 }
792 /**
793 * @return array|string
794 */
802 }
803 }
805 /**
806 * @return array
807 */
810 }
812 /**
813 * @param $image
814 * @return array|null
815 */
818 }
820 /**
821 * @return array
822 */
825 }
827 /**
828 * @param $tog
829 * @return string
830 */
833 }
835 /**
836 * Get native language names, indexed by code.
837 * Only those defined in MediaWiki, no other data like CLDR.
838 * If $customisedOnly is true, only returns codes with a messages file
839 *
840 * @param $customisedOnly bool
841 *
842 * @return array
843 * @deprecated in 1.20, use fetchLanguageNames()
844 */
847 }
849 /**
850 * Get translated language names. This is done on best effort and
851 * by default this is exactly the same as Language::getLanguageNames.
852 * The CLDR extension provides translated names.
853 * @param $code String Language code.
854 * @return Array language code => language name
855 * @since 1.18.0
856 * @deprecated in 1.20, use fetchLanguageNames()
857 */
860 }
862 /**
863 * Get an array of language names, indexed by code.
864 * @param $inLanguage null|string: Code of language in which to return the names
865 * Use null for autonyms (native names)
866 * @param $include string:
867 * 'all' all available languages
868 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
869 * 'mwfile' only if the language is in 'mw' *and* has a message file
870 * @return array: language code => language name
871 * @since 1.20
872 */
880 }
885 # TODO: also include when $inLanguage is null, when this code is more efficient
887 }
891 # - Prefer own MediaWiki native name when not using the hook
892 # - For other names just add if not added through the hook
895 }
896 }
900 }
906 }
910 # We do this using a foreach over the codes instead of a directory
911 # loop so that messages files in extensions will work correctly.
915 }
916 }
918 }
919 # 'mw' option; default if it's not one of the other two options (all/mwfile)
921 }
923 /**
924 * @param $code string: The code of the language for which to get the name
925 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
926 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
927 * @return string: Language name or empty
928 * @since 1.20
929 */
933 }
935 /**
936 * Get a message from the MediaWiki namespace.
937 *
938 * @param $msg String: message name
939 * @return string
940 */
943 }
945 /**
946 * Get the native language name of $code.
947 * Only if defined in MediaWiki, no other data like CLDR.
948 * @param $code string
949 * @return string
950 * @deprecated in 1.20, use fetchLanguageName()
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 * @return array
993 */
998 }
1000 }
1002 /**
1003 * @param $key string
1004 * @return string
1005 */
1008 }
1010 /**
1011 * @param $key string
1012 * @return string
1013 */
1016 }
1018 /**
1019 * @param $key string
1020 * @return string
1021 */
1024 }
1026 /**
1027 * @param $key string
1028 * @return string
1029 */
1032 }
1034 /**
1035 * @param $key string
1036 * @return string
1037 */
1040 }
1042 /**
1043 * @param $key string
1044 * @return string
1045 */
1048 }
1050 /**
1051 * This is a workalike of PHP's date() function, but with better
1052 * internationalisation, a reduced set of format characters, and a better
1053 * escaping format.
1054 *
1055 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1056 * the PHP manual for definitions. There are a number of extensions, which
1057 * start with "x":
1058 *
1059 * xn Do not translate digits of the next numeric format character
1060 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1061 * xr Use roman numerals for the next numeric format character
1062 * xh Use hebrew numerals for the next numeric format character
1063 * xx Literal x
1064 * xg Genitive month name
1065 *
1066 * xij j (day number) in Iranian calendar
1067 * xiF F (month name) in Iranian calendar
1068 * xin n (month number) in Iranian calendar
1069 * xiy y (two digit year) in Iranian calendar
1070 * xiY Y (full year) in Iranian calendar
1071 *
1072 * xjj j (day number) in Hebrew calendar
1073 * xjF F (month name) in Hebrew calendar
1074 * xjt t (days in month) in Hebrew calendar
1075 * xjx xg (genitive month name) in Hebrew calendar
1076 * xjn n (month number) in Hebrew calendar
1077 * xjY Y (full year) in Hebrew calendar
1078 *
1079 * xmj j (day number) in Hijri calendar
1080 * xmF F (month name) in Hijri calendar
1081 * xmn n (month number) in Hijri calendar
1082 * xmY Y (full year) in Hijri calendar
1083 *
1084 * xkY Y (full year) in Thai solar calendar. Months and days are
1085 * identical to the Gregorian calendar
1086 * xoY Y (full year) in Minguo calendar or Juche year.
1087 * Months and days are identical to the
1088 * Gregorian calendar
1089 * xtY Y (full year) in Japanese nengo. Months and days are
1090 * identical to the Gregorian calendar
1091 *
1092 * Characters enclosed in double quotes will be considered literal (with
1093 * the quotes themselves removed). Unmatched quotes will be considered
1094 * literal quotes. Example:
1095 *
1096 * "The month is" F => The month is January
1097 * i's" => 20'11"
1098 *
1099 * Backslash escaping is also supported.
1100 *
1101 * Input timestamp is assumed to be pre-normalized to the desired local
1102 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1103 * $ts is UTC if $zone is not given.
1104 *
1105 * @param $format String
1106 * @param $ts String: 14-character timestamp
1107 * YYYYMMDDHHMMSS
1108 * 01234567890123
1109 * @param $zone DateTimeZone: Timezone of $ts
1110 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1111 *
1112 * @throws MWException
1113 * @return string
1114 */
1131 }
1135 }
1142 }
1144 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1146 }
1170 }
1180 );
1181 }
1190 }
1196 }
1202 }
1209 );
1210 }
1219 }
1225 }
1231 }
1246 }
1252 }
1258 }
1264 }
1273 }
1279 }
1285 }
1291 }
1297 }
1303 }
1312 }
1347 // Pass through string from $dateTimeObj->format()
1351 );
1352 }
1365 // Pass through number from $dateTimeObj->format()
1369 );
1370 }
1374 # Backslash escaping
1379 }
1382 # Quoted literal
1386 # No terminating quote, assume literal "
1391 }
1393 # Quote at end of string, assume literal "
1395 }
1399 }
1412 }
1413 }
1414 }
1416 }
1421 /**
1422 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1423 * Gregorian dates to Iranian dates. Originally written in C, it
1424 * is released under the terms of GNU Lesser General Public
1425 * License. Conversion to PHP was performed by Niklas Laxström.
1426 *
1427 * Link: http://www.farsiweb.info/jalali/jalali.c
1428 *
1429 * @param $ts string
1430 *
1431 * @return string
1432 */
1438 # Days passed from the beginning (including leap years)
1444 // Add days of the past months of this year
1447 }
1449 // Leap years
1452 }
1454 // Days passed in current month
1468 }
1472 }
1478 }
1480 /**
1481 * Converting Gregorian dates to Hijri dates.
1482 *
1483 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1484 *
1485 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1486 *
1487 * @param $ts string
1488 *
1489 * @return string
1490 */
1504 )
1505 {
1513 }
1518 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1519 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1525 }
1527 /**
1528 * Converting Gregorian dates to Hebrew dates.
1529 *
1530 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1531 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1532 * to translate the relevant functions into PHP and release them under
1533 * GNU GPL.
1534 *
1535 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1536 * and Adar II is 14. In a non-leap year, Adar is 6.
1537 *
1538 * @param $ts string
1539 *
1540 * @return string
1541 */
1543 # Parse date
1548 # Calculate Hebrew year
1551 # Month number when September = 1, August = 12
1554 # Next year
1558 }
1560 # Calculate day of year from 1 September
1564 # February
1566 # Check if the year is leap
1569 }
1574 }
1575 }
1577 # Calculate the start of the Hebrew year
1580 # Calculate next year's start
1582 # Day is before the start of the year - it is the previous year
1583 # Next year's start
1585 # Previous year
1588 # Add days since previous year's 1 September
1591 # Leap year
1593 }
1594 # Start of the new (previous) year
1597 # Next year's start
1599 }
1601 # Calculate Hebrew day of year
1604 # Difference between year's days
1606 # Add 12 (or 13 for leap years) days to ignore the difference between
1607 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1608 # difference is only about the year type
1613 }
1615 # Check the year pattern, and is leap year
1616 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1617 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1618 # and non-leap years
1620 # Check if leap year
1623 # Calculate day in the month from number of day in the Hebrew year
1624 # Don't check Adar - if the day is not in Adar, we will stop before;
1625 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1630 # Calculate days in this month
1632 # Adar in a leap year
1634 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1637 # Day in Adar I
1640 # Subtract the days of Adar I
1642 # Try Adar II
1645 # Day in Adar II
1647 }
1648 }
1649 }
1651 # Cheshvan in a complete year (otherwise as the rule below)
1654 # Kislev in an incomplete year (otherwise as the rule below)
1657 # Odd months have 30 days, even have 29
1659 }
1661 # In the current month
1664 # Subtract the days of the current month
1666 # Try in the next month
1668 }
1669 }
1672 }
1674 /**
1675 * This calculates the Hebrew year start, as days since 1 September.
1676 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1677 * Used for Hebrew date.
1678 *
1679 * @param $year int
1680 *
1681 * @return string
1682 */
1689 }
1693 }
1703 }
1707 }
1709 /**
1710 * Algorithm to convert Gregorian dates to Thai solar dates,
1711 * Minguo dates or Minguo dates.
1712 *
1713 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1714 * http://en.wikipedia.org/wiki/Minguo_calendar
1715 * http://en.wikipedia.org/wiki/Japanese_era_name
1716 *
1717 * @param $ts String: 14-character timestamp
1718 * @param $cName String: calender name
1719 * @return Array: converted year, month, day
1720 */
1727 # Thai solar dates
1728 # Add 543 years to the Gregorian calendar
1729 # Months and days are identical
1732 # Minguo dates
1733 # Deduct 1911 years from the Gregorian calendar
1734 # Months and days are identical
1737 # Nengō dates up to Meiji period
1738 # Deduct years from the Gregorian calendar
1739 # depending on the nengo periods
1740 # Months and days are identical
1741 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1742 # Meiji period
1747 }
1755 )
1756 {
1757 # Taishō period
1762 }
1768 )
1769 {
1770 # Shōwa period
1775 }
1778 # Heisei period
1783 }
1785 }
1788 }
1791 }
1793 /**
1794 * Roman number formatting up to 10000
1795 *
1796 * @param $num int
1797 *
1798 * @return string
1799 */
1805 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1806 );
1811 }
1817 }
1819 }
1821 }
1823 /**
1824 * Hebrew Gematria number formatting up to 9999
1825 *
1826 * @param $num int
1827 *
1828 * @return string
1829 */
1836 );
1841 }
1853 }
1854 }
1855 }
1857 }
1863 }
1882 }
1884 }
1886 /**
1887 * Used by date() and time() to adjust the time output.
1888 *
1889 * @param $ts Int the time in date('YmdHis') format
1890 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1891 * get user timecorrection setting)
1892 * @return int
1893 */
1899 }
1912 }
1913 # Unrecognized timezone, default to 'Offset' with the stored offset.
1915 }
1919 # Global offset in minutes.
1922 }
1933 }
1936 }
1937 }
1939 # No difference ? Return time unchanged
1942 }
1945 # Generate an adjusted date; take advantage of the fact that mktime
1946 # will normalize out-of-range values so we don't have to split $minDiff
1947 # into hours and minutes.
1960 }
1962 /**
1963 * This is meant to be used by time(), date(), and timeanddate() to get
1964 * the date preference they're supposed to use, it should be used in
1965 * all children.
1966 *
1967 *<code>
1968 * function timeanddate([...], $format = true) {
1969 * $datePreference = $this->dateFormat($format);
1970 * [...]
1971 * }
1972 *</code>
1973 *
1974 * @param $usePrefs Mixed: if true, the user's preference is used
1975 * if false, the site/language default is used
1976 * if int/string, assumed to be a format.
1977 * @return string
1978 */
1987 }
1990 }
1992 // return int
1995 }
1998 }
2000 /**
2001 * Get a format string for a given type and preference
2002 * @param $type string May be date, time or both
2003 * @param $pref string The format name as it appears in Messages*.php
2004 *
2005 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2006 *
2007 * @return string
2008 */
2019 }
2024 }
2025 }
2027 }
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: true to use user's date format preference
2056 * @param $timecorrection String|bool the time offset as returned by
2057 * validateTimeZone() in Special:Preferences
2058 * @return string
2059 */
2064 }
2067 }
2069 /**
2070 * @param $ts Mixed: the time format which needs to be turned into a
2071 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2072 * @param $adj Bool: whether to adjust the time output according to the
2073 * user configured offset ($timecorrection)
2074 * @param $format Mixed: what format to return, if it's false output the
2075 * default one (default true)
2076 * @param $timecorrection String|bool the time offset as returned by
2077 * validateTimeZone() in Special:Preferences
2078 * @return string
2079 */
2084 }
2087 }
2089 /**
2090 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2091 *
2092 * @since 1.20
2093 *
2094 * @param integer $seconds The amount of seconds.
2095 * @param array $chosenIntervals The intervals to enable.
2096 *
2097 * @return string
2098 */
2105 // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2106 // duration-years, duration-decades, duration-centuries, duration-millennia
2109 }
2112 }
2114 /**
2115 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2116 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2117 *
2118 * @since 1.20
2119 *
2120 * @param integer $seconds The amount of seconds.
2121 * @param array $chosenIntervals The intervals to enable.
2122 *
2123 * @return array
2124 */
2127 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2128 }
2142 }
2143 }
2146 }
2148 /**
2149 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2150 *
2151 * @param $type String: can be 'date', 'time' or 'both'
2152 * @param $ts Mixed: the time format which needs to be turned into a
2153 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2154 * @param $user User object used to get preferences for timezone and format
2155 * @param $options Array, can contain the following keys:
2156 * - 'timecorrection': time correction, can have the following values:
2157 * - true: use user's preference
2158 * - false: don't use time correction
2159 * - integer: value of time correction in minutes
2160 * - 'format': format to use, can have the following values:
2161 * - true: use user's preference
2162 * - false: use default preference
2163 * - string: format to use
2164 * @since 1.19
2165 * @return String
2166 */
2175 }
2177 }
2182 }
2185 }
2187 /**
2188 * Get the formatted date for the given timestamp and formatted for
2189 * the given user.
2190 *
2191 * @param $ts Mixed: the time format which needs to be turned into a
2192 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2193 * @param $user User object used to get preferences for timezone and format
2194 * @param $options Array, can contain the following keys:
2195 * - 'timecorrection': time correction, can have the following values:
2196 * - true: use user's preference
2197 * - false: don't use time correction
2198 * - integer: value of time correction in minutes
2199 * - 'format': format to use, can have the following values:
2200 * - true: use user's preference
2201 * - false: use default preference
2202 * - string: format to use
2203 * @since 1.19
2204 * @return String
2205 */
2208 }
2210 /**
2211 * Get the formatted time for the given timestamp and formatted for
2212 * the given user.
2213 *
2214 * @param $ts Mixed: the time format which needs to be turned into a
2215 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2216 * @param $user User object used to get preferences for timezone and format
2217 * @param $options Array, can contain the following keys:
2218 * - 'timecorrection': time correction, can have the following values:
2219 * - true: use user's preference
2220 * - false: don't use time correction
2221 * - integer: value of time correction in minutes
2222 * - 'format': format to use, can have the following values:
2223 * - true: use user's preference
2224 * - false: use default preference
2225 * - string: format to use
2226 * @since 1.19
2227 * @return String
2228 */
2231 }
2233 /**
2234 * Get the formatted date and time for the given timestamp and formatted for
2235 * the given user.
2236 *
2237 * @param $ts Mixed: the time format which needs to be turned into a
2238 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2239 * @param $user User object used to get preferences for timezone and format
2240 * @param $options Array, can contain the following keys:
2241 * - 'timecorrection': time correction, can have the following values:
2242 * - true: use user's preference
2243 * - false: don't use time correction
2244 * - integer: value of time correction in minutes
2245 * - 'format': format to use, can have the following values:
2246 * - true: use user's preference
2247 * - false: use default preference
2248 * - string: format to use
2249 * @since 1.19
2250 * @return String
2251 */
2254 }
2256 /**
2257 * Convert an MWTimestamp into a pretty human-readable timestamp using
2258 * the given user preferences and relative base time.
2259 *
2260 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2261 * on your timestamp object, which will then call this function. Calling
2262 * this function directly will cause hooks to be skipped over.
2263 *
2264 * @see MWTimestamp::getHumanTimestamp
2265 * @param MWTimestamp $ts Timestamp to prettify
2266 * @param MWTimestamp $relativeTo Base timestamp
2267 * @param User $user User preferences to use
2268 * @return string Human timestamp
2269 * @since 1.22
2270 */
2273 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) - (int)$relativeTo->timestamp->format( 'w' ) );
2275 if ( $diff->invert || $days > 5 && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' ) ) {
2276 // Timestamps are in different years: use full timestamp
2277 // Also do full timestamp for future dates
2278 /**
2279 * @FIXME Add better handling of future timestamps.
2280 */
2284 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2288 // Timestamp within the past week: show the day of the week and time
2296 // Timestamp was yesterday: say 'yesterday' and the time.
2303 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2310 // From here on in, the timestamp was soon enough ago so that we can simply say
2311 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2313 // Less than 90 minutes, but more than an hour ago.
2316 // A few minutes ago.
2319 // Less than a minute, but more than 30 sec ago.
2322 // Less than 30 seconds ago.
2324 }
2327 }
2329 /**
2330 * @param $key string
2331 * @return array|null
2332 */
2335 }
2337 /**
2338 * @return array
2339 */
2342 }
2344 /**
2345 * @param $in
2346 * @param $out
2347 * @param $string
2348 * @return string
2349 */
2351 # This is a wrapper for iconv in all languages except esperanto,
2352 # which does some nasty x-conversions beforehand
2354 # Even with //IGNORE iconv can whine about illegal characters in
2355 # *input* string. We just ignore those too.
2356 # REF: http://bugs.php.net/bug.php?id=37166
2357 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2362 }
2364 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2366 /**
2367 * @param $matches array
2368 * @return mixed|string
2369 */
2372 }
2374 /**
2375 * @param $matches array
2376 * @return string
2377 */
2380 }
2382 /**
2383 * @param $matches array
2384 * @return string
2385 */
2389 }
2391 /**
2392 * @param $matches array
2393 * @return string
2394 */
2398 }
2400 /**
2401 * @param $matches array
2402 * @return string
2403 */
2406 }
2408 /**
2409 * @param $matches array
2410 * @return string
2411 */
2415 }
2417 /**
2418 * Make a string's first character uppercase
2419 *
2420 * @param $str string
2421 *
2422 * @return string
2423 */
2431 // fall back to more complex logic in case of multibyte strings
2433 }
2434 }
2436 /**
2437 * Convert a string to uppercase
2438 *
2439 * @param $str string
2440 * @param $first bool
2441 *
2442 * @return string
2443 */
2451 }
2454 }
2461 $str
2462 );
2465 }
2466 }
2467 }
2469 /**
2470 * @param $str string
2471 * @return mixed|string
2472 */
2484 }
2485 }
2487 /**
2488 * @param $str string
2489 * @param $first bool
2490 * @return mixed|string
2491 */
2499 }
2502 }
2509 $str
2510 );
2513 }
2514 }
2515 }
2517 /**
2518 * @param $str string
2519 * @return bool
2520 */
2523 }
2525 /**
2526 * @param $str string
2527 * @return mixed|string
2528 */
2533 // regexp to find first letter in each word (i.e. after each space)
2534 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2536 // function to use to capitalize a single char
2541 $str
2542 );
2547 $str
2548 );
2549 }
2552 }
2553 }
2555 /**
2556 * capitalize words at word breaks
2557 *
2558 * @param $str string
2559 * @return mixed
2560 */
2565 // since \b doesn't work for UTF-8, we explicitely define word break chars
2568 // find first letter after word break
2569 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2575 $str
2576 );
2581 $str
2582 );
2583 }
2588 $str
2589 );
2590 }
2591 }
2593 /**
2594 * Return a case-folded representation of $s
2595 *
2596 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2597 * and $s2 are the same except for the case of their characters. It is not
2598 * necessary for the value returned to make sense when displayed.
2599 *
2600 * Do *not* perform any other normalisation in this function. If a caller
2601 * uses this function when it should be using a more general normalisation
2602 * function, then fix the caller.
2603 *
2604 * @param $s string
2605 *
2606 * @return string
2607 */
2610 }
2612 /**
2613 * @param $s string
2614 * @return string
2615 */
2619 }
2622 }
2625 }
2627 /**
2628 * @return array
2629 */
2632 }
2634 /**
2635 * Most writing systems use whitespace to break up words.
2636 * Some languages such as Chinese don't conventionally do this,
2637 * which requires special handling when breaking up words for
2638 * searching etc.
2639 *
2640 * @return bool
2641 */
2644 }
2646 /**
2647 * Some languages such as Chinese require word segmentation,
2648 * Specify such segmentation when overridden in derived class.
2649 *
2650 * @param $string String
2651 * @return String
2652 */
2655 }
2657 /**
2658 * Some languages have special punctuation need to be normalized.
2659 * Make such changes here.
2660 *
2661 * @param $string String
2662 * @return String
2663 */
2666 }
2668 /**
2669 * convert double-width roman characters to single-width.
2670 * range: ff00-ff5f ~= 0020-007f
2671 *
2672 * @param $string string
2673 *
2674 * @return string
2675 */
2685 }
2689 }
2691 /**
2692 * @param $string string
2693 * @param $pattern string
2694 * @return string
2695 */
2700 }
2702 /**
2703 * @param $termsArray array
2704 * @return array
2705 */
2707 # some languages, e.g. Chinese, need to do a conversion
2708 # in order for search results to be displayed correctly
2710 }
2712 /**
2713 * Get the first character of a string.
2714 *
2715 * @param $s string
2716 * @return string
2717 */
2724 $matches
2725 );
2730 }
2732 // Break down Hangul syllables to grab the first jamo
2764 }
2767 }
2768 }
2771 # Some languages may have an alternate char encoding option
2772 # (Esperanto X-coding, Japanese furigana conversion, etc)
2773 # If this language is used as the primary content language,
2774 # an override to the defaults can be set here on startup.
2775 }
2777 /**
2778 * @param $s string
2779 * @return string
2780 */
2782 # For some languages we'll want to explicitly specify
2783 # which characters make it into the edit box raw
2784 # or are converted in some way or another.
2790 }
2791 }
2793 /**
2794 * @param $s string
2795 * @return string
2796 */
2798 # Take the previous into account.
2804 }
2809 }
2810 }
2812 /**
2813 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2814 * also cleans up certain backwards-compatible sequences, converting them
2815 * to the modern Unicode equivalent.
2816 *
2817 * This is language-specific for performance reasons only.
2818 *
2819 * @param $s string
2820 *
2821 * @return string
2822 */
2829 }
2832 }
2834 /**
2835 * Transform a string using serialized data stored in the given file (which
2836 * must be in the serialized subdirectory of $IP). The file contains pairs
2837 * mapping source characters to destination characters.
2838 *
2839 * The data is cached in process memory. This will go faster if you have the
2840 * FastStringSearch extension.
2841 *
2842 * @param $file string
2843 * @param $string string
2844 *
2845 * @throws MWException
2846 * @return string
2847 */
2853 }
2855 }
2857 }
2859 /**
2860 * For right-to-left language support
2861 *
2862 * @return bool
2863 */
2866 }
2868 /**
2869 * Return the correct HTML 'dir' attribute value for this language.
2870 * @return String
2871 */
2874 }
2876 /**
2877 * Return 'left' or 'right' as appropriate alignment for line-start
2878 * for this language's text direction.
2879 *
2880 * Should be equivalent to CSS3 'start' text-align value....
2881 *
2882 * @return String
2883 */
2886 }
2888 /**
2889 * Return 'right' or 'left' as appropriate alignment for line-end
2890 * for this language's text direction.
2891 *
2892 * Should be equivalent to CSS3 'end' text-align value....
2893 *
2894 * @return String
2895 */
2898 }
2900 /**
2901 * A hidden direction mark (LRM or RLM), depending on the language direction.
2902 * Unlike getDirMark(), this function returns the character as an HTML entity.
2903 * This function should be used when the output is guaranteed to be HTML,
2904 * because it makes the output HTML source code more readable. When
2905 * the output is plain text or can be escaped, getDirMark() should be used.
2906 *
2907 * @param $opposite Boolean Get the direction mark opposite to your language
2908 * @return string
2909 * @since 1.20
2910 */
2914 }
2916 }
2918 /**
2919 * A hidden direction mark (LRM or RLM), depending on the language direction.
2920 * This function produces them as invisible Unicode characters and
2921 * the output may be hard to read and debug, so it should only be used
2922 * when the output is plain text or can be escaped. When the output is
2923 * HTML, use getDirMarkEntity() instead.
2924 *
2925 * @param $opposite Boolean Get the direction mark opposite to your language
2926 * @return string
2927 */
2933 }
2935 }
2937 /**
2938 * @return array
2939 */
2942 }
2944 /**
2945 * An arrow, depending on the language direction.
2946 *
2947 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2948 * @return string
2949 */
2964 }
2965 }
2967 /**
2968 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2969 *
2970 * @return bool
2971 */
2974 }
2976 /**
2977 * Get all magic words from cache.
2978 * @return array
2979 */
2982 }
2984 /**
2985 * Run the LanguageGetMagic hook once.
2986 */
2990 }
2995 }
2997 /**
2998 * Fill a MagicWord object with data from here
2999 *
3000 * @param $mw
3001 */
3003 // Saves a function call
3006 }
3013 }
3020 }
3021 }
3023 /**
3024 * Add magic words to the extension array
3025 *
3026 * @param $newWords array
3027 */
3034 }
3035 }
3036 }
3038 /**
3039 * Get special page names, as an associative array
3040 * case folded alias => real name
3041 */
3043 // Cache aliases because it may be slow to load them
3045 // Initialise array
3050 }
3053 }
3055 /**
3056 * Italic is unsuitable for some languages
3057 *
3058 * @param $text String: the text to be emphasized.
3059 * @return string
3060 */
3063 }
3065 /**
3066 * Normally we output all numbers in plain en_US style, that is
3067 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3068 * point twohundredthirtyfive. However this is not suitable for all
3069 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
3070 * Icelandic just want to use commas instead of dots, and dots instead
3071 * of commas like "293.291,235".
3072 *
3073 * An example of this function being called:
3074 * <code>
3075 * wfMessage( 'message' )->numParams( $num )->text()
3076 * </code>
3077 *
3078 * See LanguageGu.php for the Gujarati implementation and
3079 * $separatorTransformTable on MessageIs.php for
3080 * the , => . and . => , implementation.
3081 *
3082 * @todo check if it's viable to use localeconv() for the decimal
3083 * separator thing.
3084 * @param $number Mixed: the string to be formatted, should be an integer
3085 * or a floating point number.
3086 * @param $nocommafy Bool: set to true for special numbers like dates
3087 * @return string
3088 */
3096 }
3097 }
3103 }
3104 }
3107 }
3109 /**
3110 * Front-end for non-commafied formatNum
3111 *
3112 * @param mixed $number the string to be formatted, should be an integer
3113 * or a floating point number.
3114 * @since 1.21
3115 * @return string
3116 */
3119 }
3121 /**
3122 * @param $number string
3123 * @return string
3124 */
3129 }
3134 }
3138 }
3140 /**
3141 * Adds commas to a given number
3142 * @since 1.19
3143 * @param $number mixed
3144 * @return string
3145 */
3150 }
3153 // default grouping is at thousands, use the same for ###,###,### pattern too.
3156 // Ref: http://cldr.unicode.org/translation/number-patterns
3159 // For negative numbers apply the algorithm like positive number and add sign.
3162 }
3170 // the string does not have any number part. Eg: .12345
3172 }
3180 }
3184 // use the last pattern for the rest of the number
3186 }
3189 }
3190 }
3192 }
3193 }
3195 /**
3196 * @return String
3197 */
3200 }
3202 /**
3203 * @return array
3204 */
3207 }
3209 /**
3210 * @return array
3211 */
3214 }
3216 /**
3217 * Take a list of strings and build a locale-friendly comma-separated
3218 * list, using the local comma-separator message.
3219 * The last two strings are chained with an "and".
3220 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3221 *
3222 * @param $l Array
3223 * @return string
3224 */
3229 }
3235 }
3236 }
3243 }
3244 }
3246 }
3248 /**
3249 * Take a list of strings and build a locale-friendly comma-separated
3250 * list, using the local comma-separator message.
3251 * @param $list array of strings to put in a comma list
3252 * @return string
3253 */
3257 $list
3258 );
3259 }
3261 /**
3262 * Take a list of strings and build a locale-friendly semicolon-separated
3263 * list, using the local semicolon-separator message.
3264 * @param $list array of strings to put in a semicolon list
3265 * @return string
3266 */
3270 $list
3271 );
3272 }
3274 /**
3275 * Same as commaList, but separate it with the pipe instead.
3276 * @param $list array of strings to put in a pipe list
3277 * @return string
3278 */
3282 $list
3283 );
3284 }
3286 /**
3287 * Truncate a string to a specified length in bytes, appending an optional
3288 * string (e.g. for ellipses)
3289 *
3290 * The database offers limited byte lengths for some columns in the database;
3291 * multi-byte character sets mean we need to ensure that only whole characters
3292 * are included, otherwise broken characters can be passed to the user
3293 *
3294 * If $length is negative, the string will be truncated from the beginning
3295 *
3296 * @param $string String to truncate
3297 * @param $length Int: maximum length (including ellipses)
3298 * @param $ellipsis String to append to the truncated text
3299 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3300 * $adjustLength was introduced in 1.18, before that behaved as if false.
3301 * @return string
3302 */
3304 # Use the localized ellipsis character
3307 }
3308 # Check if there is no need to truncate
3313 }
3315 # If ellipsis length is >= $length then we can't apply $adjustLength
3318 # Otherwise, truncate and add ellipsis...
3331 }
3332 }
3333 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3334 # This check is *not* redundant if $adjustLength, due to the single case where
3335 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3340 }
3341 }
3343 /**
3344 * Remove bytes that represent an incomplete Unicode character
3345 * at the end of string (e.g. bytes of the char are missing)
3346 *
3347 * @param $string String
3348 * @return string
3349 */
3355 # We got the first byte only of a multibyte char; remove it.
3360 ) {
3361 # We chopped in the middle of a character; remove it
3363 }
3364 }
3366 }
3368 /**
3369 * Remove bytes that represent an incomplete Unicode character
3370 * at the start of string (e.g. bytes of the char are missing)
3371 *
3372 * @param $string String
3373 * @return string
3374 */
3379 # We chopped in the middle of a character; remove the whole thing
3381 }
3382 }
3384 }
3386 /**
3387 * Truncate a string of valid HTML to a specified length in bytes,
3388 * appending an optional string (e.g. for ellipses), and return valid HTML
3389 *
3390 * This is only intended for styled/linked text, such as HTML with
3391 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3392 * Also, this will not detect things like "display:none" CSS.
3393 *
3394 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3395 *
3396 * @param string $text HTML string to truncate
3397 * @param int $length (zero/positive) Maximum length (including ellipses)
3398 * @param string $ellipsis String to append to the truncated text
3399 * @return string
3400 */
3402 # Use the localized ellipsis character
3405 }
3406 # Check if there is clearly no need to truncate
3411 }
3425 # Consider truncation once the display length has reached the maximim.
3426 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3427 # Check that we're not in the middle of a bracket/entity...
3431 # Save where we are; we will truncate here unless there turn out to
3432 # be so few remaining characters that truncation is not necessary.
3435 }
3437 # String in fact does need truncation, the truncation point was OK.
3442 }
3443 }
3446 }
3448 # Read the next char...
3466 }
3472 // Name found (e.g. "<a href=..."), add on tag attributes...
3474 }
3480 }
3483 // Save state without $ch. We want to *hit* the first
3484 // display char (to get tags) but not *use* it if truncating.
3486 }
3491 // Add the next $max display text chars after this in one swoop...
3496 }
3497 }
3498 }
3499 }
3500 // Close the last tag if left unclosed by bad HTML
3504 }
3506 }
3508 /**
3509 * truncateHtml() helper function
3510 * like strcspn() but adds the skipped chars to $ret
3511 *
3512 * @param $ret
3513 * @param $text
3514 * @param $search
3515 * @param $start
3516 * @param $len
3517 * @return int
3518 */
3524 }
3529 }
3531 }
3533 /**
3534 * truncateHtml() helper function
3535 * (a) push or pop $tag from $openTags as needed
3536 * (b) clear $tag value
3537 * @param &$tag string Current HTML tag name we are looking at
3538 * @param $tagType int (0-open tag, 1-close tag)
3539 * @param $lastCh string Character before the '>' that ended this tag
3540 * @param &$openTags array Open tag stack (not accounting for $tag)
3541 */
3550 }
3551 }
3553 }
3554 }
3556 /**
3557 * Grammatical transformations, needed for inflected languages
3558 * Invoked by putting {{grammar:case|word}} in a message
3559 *
3560 * @param $word string
3561 * @param $case string
3562 * @return string
3563 */
3568 }
3570 }
3571 /**
3572 * Get the grammar forms for the content language
3573 * @return array of grammar forms
3574 * @since 1.20
3575 */
3578 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3580 }
3582 }
3583 /**
3584 * Provides an alternative text depending on specified gender.
3585 * Usage {{gender:username|masculine|feminine|neutral}}.
3586 * username is optional, in which case the gender of current user is used,
3587 * but only in (some) interface messages; otherwise default gender is used.
3588 *
3589 * If no forms are given, an empty string is returned. If only one form is
3590 * given, it will be returned unconditionally. These details are implied by
3591 * the caller and cannot be overridden in subclasses.
3592 *
3593 * If more than one form is given, the default is to use the neutral one
3594 * if it is specified, and to use the masculine one otherwise. These
3595 * details can be overridden in subclasses.
3596 *
3597 * @param $gender string
3598 * @param $forms array
3599 *
3600 * @return string
3601 */
3605 }
3609 }
3612 }
3614 }
3616 /**
3617 * Plural form transformations, needed for some languages.
3618 * For example, there are 3 form of plural in Russian and Polish,
3619 * depending on "count mod 10". See [[w:Plural]]
3620 * For English it is pretty simple.
3621 *
3622 * Invoked by putting {{plural:count|wordform1|wordform2}}
3623 * or {{plural:count|wordform1|wordform2|wordform3}}
3624 *
3625 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3626 *
3627 * @param $count Integer: non-localized number
3628 * @param $forms Array: different plural forms
3629 * @return string Correct form of plural for $count in this language
3630 */
3632 // Handle explicit n=pluralform cases
3638 }
3640 }
3641 }
3646 }
3651 }
3653 /**
3654 * Checks that convertPlural was given an array and pads it to requested
3655 * amount of forms by copying the last one.
3656 *
3657 * @param $count Integer: How many forms should there be at least
3658 * @param $forms Array of forms given to convertPlural
3659 * @return array Padded array of forms or an exception if not an array
3660 */
3664 }
3666 }
3668 /**
3669 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3670 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3671 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3672 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3673 * match up with it.
3674 *
3675 * @param $str String: the validated block duration in English
3676 * @return string Somehow translated block duration
3677 * @see LanguageFi.php for example implementation
3678 */
3684 }
3685 }
3687 // Since usually only infinite or indefinite is only on list, so try
3688 // equivalents if still here.
3695 }
3696 }
3697 }
3699 // If all else fails, return a standard duration or timestamp description.
3704 // $time is relative to 0 so it's a duration length.
3708 // wfTimestamp() handles 0 as current time instead of epoch.
3712 }
3713 }
3714 }
3716 /**
3717 * languages like Chinese need to be segmented in order for the diff
3718 * to be of any use
3719 *
3720 * @param $text String
3721 * @return String
3722 */
3725 }
3727 /**
3728 * and unsegment to show the result
3729 *
3730 * @param $text String
3731 * @return String
3732 */
3735 }
3737 /**
3738 * Return the LanguageConverter used in the Language
3739 *
3740 * @since 1.19
3741 * @return LanguageConverter
3742 */
3745 }
3747 /**
3748 * convert text to all supported variants
3749 *
3750 * @param $text string
3751 * @return array
3752 */
3755 }
3757 /**
3758 * convert text to different variants of a language.
3759 *
3760 * @param $text string
3761 * @return string
3762 */
3765 }
3767 /**
3768 * Convert a Title object to a string in the preferred variant
3769 *
3770 * @param $title Title
3771 * @return string
3772 */
3775 }
3777 /**
3778 * Convert a namespace index to a string in the preferred variant
3779 *
3780 * @param $ns int
3781 * @return string
3782 */
3785 }
3787 /**
3788 * Check if this is a language with variants
3789 *
3790 * @return bool
3791 */
3794 }
3796 /**
3797 * Check if the language has the specific variant
3798 *
3799 * @since 1.19
3800 * @param $variant string
3801 * @return bool
3802 */
3805 }
3807 /**
3808 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3809 *
3810 * @param $text string
3811 * @return string
3812 */
3815 }
3817 /**
3818 * Perform output conversion on a string, and encode for safe HTML output.
3819 * @param $text String text to be converted
3820 * @param $isTitle Bool whether this conversion is for the article title
3821 * @return string
3822 * @todo this should get integrated somewhere sane
3823 */
3826 }
3828 /**
3829 * @param $key string
3830 * @return string
3831 */
3834 }
3836 /**
3837 * Get the list of variants supported by this language
3838 * see sample implementation in LanguageZh.php
3839 *
3840 * @return array an array of language codes
3841 */
3844 }
3846 /**
3847 * @return string
3848 */
3851 }
3853 /**
3854 * @return string
3855 */
3858 }
3860 /**
3861 * @return string
3862 */
3865 }
3867 /**
3868 * If a language supports multiple variants, it is
3869 * possible that non-existing link in one variant
3870 * actually exists in another variant. this function
3871 * tries to find it. See e.g. LanguageZh.php
3872 *
3873 * @param $link String: the name of the link
3874 * @param $nt Mixed: the title object of the link
3875 * @param $ignoreOtherCond Boolean: to disable other conditions when
3876 * we need to transclude a template or update a category's link
3877 * @return null the input parameters may be modified upon return
3878 */
3881 }
3883 /**
3884 * If a language supports multiple variants, converts text
3885 * into an array of all possible variants of the text:
3886 * 'variant' => text in that variant
3887 *
3888 * @deprecated since 1.17 Use autoConvertToAllVariants()
3889 *
3890 * @param $text string
3891 *
3892 * @return string
3893 */
3896 }
3898 /**
3899 * returns language specific options used by User::getPageRenderHash()
3900 * for example, the preferred language variant
3901 *
3902 * @return string
3903 */
3906 }
3908 /**
3909 * For languages that support multiple variants, the title of an
3910 * article may be displayed differently in different variants. this
3911 * function returns the apporiate title defined in the body of the article.
3912 *
3913 * @return string
3914 */
3917 }
3919 /**
3920 * Prepare external link text for conversion. When the text is
3921 * a URL, it shouldn't be converted, and it'll be wrapped in
3922 * the "raw" tag (-{R| }-) to prevent conversion.
3923 *
3924 * This function is called "markNoConversion" for historical
3925 * reasons.
3926 *
3927 * @param $text String: text to be used for external link
3928 * @param $noParse bool: wrap it without confirming it's a real URL first
3929 * @return string the tagged text
3930 */
3932 // Excluding protocal-relative URLs may avoid many false positives.
3937 }
3938 }
3940 /**
3941 * A regular expression to match legal word-trailing characters
3942 * which should be merged onto a link of the form [[foo]]bar.
3943 *
3944 * @return string
3945 */
3948 }
3950 /**
3951 * @return Language
3952 */
3955 }
3957 /**
3958 * Get the "parent" language which has a converter to convert a "compatible" language
3959 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
3960 *
3961 * @return Language|null
3962 * @since 1.22
3963 */
3967 }
3974 }
3979 }
3983 }
3985 /**
3986 * Get the RFC 3066 code for this language object
3987 *
3988 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3989 * htmlspecialchars() or similar
3990 *
3991 * @return string
3992 */
3995 }
3997 /**
3998 * Get the code in Bcp47 format which we can use
3999 * inside of html lang="" tags.
4000 *
4001 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4002 * htmlspecialchars() or similar.
4003 *
4004 * @since 1.19
4005 * @return string
4006 */
4010 }
4012 }
4014 /**
4015 * @param $code string
4016 */
4019 // Ensure we don't leave incorrect cached data lying around
4022 }
4024 /**
4025 * Get the name of a file for a certain language code
4026 * @param $prefix string Prepend this to the filename
4027 * @param $code string Language code
4028 * @param $suffix string Append this to the filename
4029 * @throws MWException
4030 * @return string $prefix . $mangledCode . $suffix
4031 */
4033 // Protect against path traversal
4036 {
4038 }
4041 }
4043 /**
4044 * Get the language code from a file name. Inverse of getFileName()
4045 * @param $filename string $prefix . $languageCode . $suffix
4046 * @param $prefix string Prefix before the language code
4047 * @param $suffix string Suffix after the language code
4048 * @return string Language code, or false if $prefix or $suffix isn't found
4049 */
4050 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4056 }
4058 }
4060 /**
4061 * @param $code string
4062 * @return string
4063 */
4069 }
4071 /**
4072 * @param $code string
4073 * @return string
4074 */
4078 }
4080 /**
4081 * Get the first fallback for a given language.
4082 *
4083 * @param $code string
4084 *
4085 * @return bool|string
4086 */
4094 }
4095 }
4097 /**
4098 * Get the ordered list of fallback languages.
4099 *
4100 * @since 1.19
4101 * @param $code string Language code
4102 * @return array
4103 */
4112 }
4114 }
4115 }
4117 /**
4118 * Get the ordered list of fallback languages, ending with the fallback
4119 * language chain for the site language.
4120 *
4121 * @since 1.22
4122 * @param string $code Language code
4123 * @return array array( fallbacks, site fallbacks )
4124 */
4128 // Usually, we will only store a tiny number of fallback chains, so we
4129 // keep them in static memory.
4135 // Append the site's fallback chain, including the site language itself
4139 // Eliminate any languages already included in the chain
4143 }
4145 }
4147 /**
4148 * Get all messages for a given language
4149 * WARNING: this may take a long time. If you just need all message *keys*
4150 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4151 *
4152 * @param $code string
4153 *
4154 * @return array
4155 */
4158 }
4160 /**
4161 * Get a message for a given language
4162 *
4163 * @param $key string
4164 * @param $code string
4165 *
4166 * @return string
4167 */
4170 }
4172 /**
4173 * Get all message keys for a given language. This is a faster alternative to
4174 * array_keys( Language::getMessagesFor( $code ) )
4175 *
4176 * @since 1.19
4177 * @param $code string Language code
4178 * @return array of message keys (strings)
4179 */
4182 }
4184 /**
4185 * @param $talk
4186 * @return mixed
4187 */
4191 }
4196 # Allow grammar transformations
4197 # Allowing full message-style parsing would make simple requests
4198 # such as action=raw much more expensive than they need to be.
4199 # This will hopefully cover most cases.
4203 }
4205 /**
4206 * @param $m string
4207 * @return string
4208 */
4211 }
4213 /**
4214 * @throws MWException
4215 * @return array
4216 */
4221 }
4228 }
4233 }
4235 /**
4236 * Decode an expiry (block, protection, etc) which has come from the DB
4237 *
4238 * @todo FIXME: why are we returnings DBMS-dependent strings???
4239 *
4240 * @param $expiry String: Database expiry String
4241 * @param $format Bool|Int true to process using language functions, or TS_ constant
4242 * to return the expiry in a given timestamp
4243 * @return String
4244 * @since 1.18
4245 */
4250 }
4260 }
4261 }
4263 /**
4264 * @todo Document
4265 * @param $seconds int|float
4266 * @param $format Array Optional
4267 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4268 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4269 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4270 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4271 * @return string
4272 */
4276 }
4279 }
4282 }
4304 }
4315 }
4319 }
4325 }
4333 }
4343 }
4347 }
4357 }
4358 }
4360 }
4362 /**
4363 * Format a bitrate for output, using an appropriate
4364 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4365 *
4366 * This use base 1000. For base 1024 use formatSize(), for another base
4367 * see formatComputingNumbers()
4368 *
4369 * @param $bps int
4370 * @return string
4371 */
4374 }
4376 /**
4377 * @param $size int Size of the unit
4378 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4379 * @param $messageKey string Message key to be uesd
4380 * @return string
4381 */
4386 );
4387 }
4395 }
4397 // For small sizes no decimal places necessary
4400 // For MB and bigger two decimal places are smarter
4402 }
4408 }
4410 /**
4411 * Format a size in bytes for output, using an appropriate
4412 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4413 *
4414 * This method use base 1024. For base 1000 use formatBitrate(), for
4415 * another base see formatComputingNumbers()
4416 *
4417 * @param $size int Size to format
4418 * @return string Plain text (not HTML)
4419 */
4422 }
4424 /**
4425 * Make a list item, used by various special pages
4426 *
4427 * @param $page String Page link
4428 * @param $details String Text between brackets
4429 * @param $oppositedm Boolean Add the direction mark opposite to your
4430 * language, to display text properly
4431 * @return String
4432 */
4439 }
4441 /**
4442 * Generate (prev x| next x) (20|50|100...) type links for paging
4443 *
4444 * @param $title Title object to link
4445 * @param $offset Integer offset parameter
4446 * @param $limit Integer limit parameter
4447 * @param $query array|String optional URL query parameter string
4448 * @param $atend Bool optional param for specified if this is the last page
4449 * @return String
4450 */
4451 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4452 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4454 # Make 'previous' link
4455 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4461 }
4463 # Make 'next' link
4464 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4470 }
4472 # Make links to set number of items per page
4477 }
4481 }
4483 /**
4484 * Helper function for viewPrevNext() that generates links
4485 *
4486 * @param $title Title object to link
4487 * @param $offset Integer offset parameter
4488 * @param $limit Integer limit parameter
4489 * @param $query Array extra query parameters
4490 * @param $link String text to use for the link; will be escaped
4491 * @param $tooltipMsg String name of the message to use as tooltip
4492 * @param $class String value of the "class" attribute of the link
4493 * @return String HTML fragment
4494 */
4495 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4497 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4500 }
4502 /**
4503 * Get the conversion rule title, if any.
4504 *
4505 * @return string
4506 */
4509 }
4511 /**
4512 * Get the compiled plural rules for the language
4513 * @since 1.20
4514 * @return array Associative array with plural form, and plural rule as key-value pairs
4515 */
4521 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4524 }
4525 }
4526 }
4528 }
4530 /**
4531 * Get the plural rules for the language
4532 * @since 1.20
4533 * @return array Associative array with plural form number and plural rule as key-value pairs
4534 */
4543 }
4544 }
4545 }
4547 }
4549 /**
4550 * Get the plural rule types for the language
4551 * @since 1.22
4552 * @return array Associative array with plural form number and plural rule type as key-value pairs
4553 */
4559 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4562 }
4563 }
4564 }
4566 }
4568 /**
4569 * Find the index number of the plural rule appropriate for the given number
4570 * @return int The index number of the plural rule
4571 */
4576 }
4578 /**
4579 * Find the plural rule type appropriate for the given number
4580 * For example, if the language is set to Arabic, getPluralType(5) should
4581 * return 'few'.
4582 * @since 1.22
4583 * @return string The name of the plural rule type, e.g. one, two, few, many
4584 */
4592 }
4593 }
4594 }