| blob | f1b7fa64f2504c74c749423054a64ed9ba0aadcf |
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
2291 // Messages:
2292 // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2298 // Timestamp was yesterday: say 'yesterday' and the time.
2305 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2312 // From here on in, the timestamp was soon enough ago so that we can simply say
2313 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2315 // Less than 90 minutes, but more than an hour ago.
2318 // A few minutes ago.
2321 // Less than a minute, but more than 30 sec ago.
2324 // Less than 30 seconds ago.
2326 }
2329 }
2331 /**
2332 * @param $key string
2333 * @return array|null
2334 */
2337 }
2339 /**
2340 * @return array
2341 */
2344 }
2346 /**
2347 * @param $in
2348 * @param $out
2349 * @param $string
2350 * @return string
2351 */
2353 # This is a wrapper for iconv in all languages except esperanto,
2354 # which does some nasty x-conversions beforehand
2356 # Even with //IGNORE iconv can whine about illegal characters in
2357 # *input* string. We just ignore those too.
2358 # REF: http://bugs.php.net/bug.php?id=37166
2359 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2364 }
2366 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2368 /**
2369 * @param $matches array
2370 * @return mixed|string
2371 */
2374 }
2376 /**
2377 * @param $matches array
2378 * @return string
2379 */
2382 }
2384 /**
2385 * @param $matches array
2386 * @return string
2387 */
2391 }
2393 /**
2394 * @param $matches array
2395 * @return string
2396 */
2400 }
2402 /**
2403 * @param $matches array
2404 * @return string
2405 */
2408 }
2410 /**
2411 * @param $matches array
2412 * @return string
2413 */
2417 }
2419 /**
2420 * Make a string's first character uppercase
2421 *
2422 * @param $str string
2423 *
2424 * @return string
2425 */
2433 // fall back to more complex logic in case of multibyte strings
2435 }
2436 }
2438 /**
2439 * Convert a string to uppercase
2440 *
2441 * @param $str string
2442 * @param $first bool
2443 *
2444 * @return string
2445 */
2453 }
2456 }
2463 $str
2464 );
2467 }
2468 }
2469 }
2471 /**
2472 * @param $str string
2473 * @return mixed|string
2474 */
2486 }
2487 }
2489 /**
2490 * @param $str string
2491 * @param $first bool
2492 * @return mixed|string
2493 */
2501 }
2504 }
2511 $str
2512 );
2515 }
2516 }
2517 }
2519 /**
2520 * @param $str string
2521 * @return bool
2522 */
2525 }
2527 /**
2528 * @param $str string
2529 * @return mixed|string
2530 */
2535 // regexp to find first letter in each word (i.e. after each space)
2536 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2538 // function to use to capitalize a single char
2543 $str
2544 );
2549 $str
2550 );
2551 }
2554 }
2555 }
2557 /**
2558 * capitalize words at word breaks
2559 *
2560 * @param $str string
2561 * @return mixed
2562 */
2567 // since \b doesn't work for UTF-8, we explicitely define word break chars
2570 // find first letter after word break
2571 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2577 $str
2578 );
2583 $str
2584 );
2585 }
2590 $str
2591 );
2592 }
2593 }
2595 /**
2596 * Return a case-folded representation of $s
2597 *
2598 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2599 * and $s2 are the same except for the case of their characters. It is not
2600 * necessary for the value returned to make sense when displayed.
2601 *
2602 * Do *not* perform any other normalisation in this function. If a caller
2603 * uses this function when it should be using a more general normalisation
2604 * function, then fix the caller.
2605 *
2606 * @param $s string
2607 *
2608 * @return string
2609 */
2612 }
2614 /**
2615 * @param $s string
2616 * @return string
2617 */
2621 }
2624 }
2627 }
2629 /**
2630 * @return array
2631 */
2634 }
2636 /**
2637 * Most writing systems use whitespace to break up words.
2638 * Some languages such as Chinese don't conventionally do this,
2639 * which requires special handling when breaking up words for
2640 * searching etc.
2641 *
2642 * @return bool
2643 */
2646 }
2648 /**
2649 * Some languages such as Chinese require word segmentation,
2650 * Specify such segmentation when overridden in derived class.
2651 *
2652 * @param $string String
2653 * @return String
2654 */
2657 }
2659 /**
2660 * Some languages have special punctuation need to be normalized.
2661 * Make such changes here.
2662 *
2663 * @param $string String
2664 * @return String
2665 */
2668 }
2670 /**
2671 * convert double-width roman characters to single-width.
2672 * range: ff00-ff5f ~= 0020-007f
2673 *
2674 * @param $string string
2675 *
2676 * @return string
2677 */
2687 }
2691 }
2693 /**
2694 * @param $string string
2695 * @param $pattern string
2696 * @return string
2697 */
2702 }
2704 /**
2705 * @param $termsArray array
2706 * @return array
2707 */
2709 # some languages, e.g. Chinese, need to do a conversion
2710 # in order for search results to be displayed correctly
2712 }
2714 /**
2715 * Get the first character of a string.
2716 *
2717 * @param $s string
2718 * @return string
2719 */
2726 $matches
2727 );
2732 }
2734 // Break down Hangul syllables to grab the first jamo
2766 }
2769 }
2770 }
2773 # Some languages may have an alternate char encoding option
2774 # (Esperanto X-coding, Japanese furigana conversion, etc)
2775 # If this language is used as the primary content language,
2776 # an override to the defaults can be set here on startup.
2777 }
2779 /**
2780 * @param $s string
2781 * @return string
2782 */
2784 # For some languages we'll want to explicitly specify
2785 # which characters make it into the edit box raw
2786 # or are converted in some way or another.
2792 }
2793 }
2795 /**
2796 * @param $s string
2797 * @return string
2798 */
2800 # Take the previous into account.
2806 }
2811 }
2812 }
2814 /**
2815 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2816 * also cleans up certain backwards-compatible sequences, converting them
2817 * to the modern Unicode equivalent.
2818 *
2819 * This is language-specific for performance reasons only.
2820 *
2821 * @param $s string
2822 *
2823 * @return string
2824 */
2831 }
2834 }
2836 /**
2837 * Transform a string using serialized data stored in the given file (which
2838 * must be in the serialized subdirectory of $IP). The file contains pairs
2839 * mapping source characters to destination characters.
2840 *
2841 * The data is cached in process memory. This will go faster if you have the
2842 * FastStringSearch extension.
2843 *
2844 * @param $file string
2845 * @param $string string
2846 *
2847 * @throws MWException
2848 * @return string
2849 */
2855 }
2857 }
2859 }
2861 /**
2862 * For right-to-left language support
2863 *
2864 * @return bool
2865 */
2868 }
2870 /**
2871 * Return the correct HTML 'dir' attribute value for this language.
2872 * @return String
2873 */
2876 }
2878 /**
2879 * Return 'left' or 'right' as appropriate alignment for line-start
2880 * for this language's text direction.
2881 *
2882 * Should be equivalent to CSS3 'start' text-align value....
2883 *
2884 * @return String
2885 */
2888 }
2890 /**
2891 * Return 'right' or 'left' as appropriate alignment for line-end
2892 * for this language's text direction.
2893 *
2894 * Should be equivalent to CSS3 'end' text-align value....
2895 *
2896 * @return String
2897 */
2900 }
2902 /**
2903 * A hidden direction mark (LRM or RLM), depending on the language direction.
2904 * Unlike getDirMark(), this function returns the character as an HTML entity.
2905 * This function should be used when the output is guaranteed to be HTML,
2906 * because it makes the output HTML source code more readable. When
2907 * the output is plain text or can be escaped, getDirMark() should be used.
2908 *
2909 * @param $opposite Boolean Get the direction mark opposite to your language
2910 * @return string
2911 * @since 1.20
2912 */
2916 }
2918 }
2920 /**
2921 * A hidden direction mark (LRM or RLM), depending on the language direction.
2922 * This function produces them as invisible Unicode characters and
2923 * the output may be hard to read and debug, so it should only be used
2924 * when the output is plain text or can be escaped. When the output is
2925 * HTML, use getDirMarkEntity() instead.
2926 *
2927 * @param $opposite Boolean Get the direction mark opposite to your language
2928 * @return string
2929 */
2935 }
2937 }
2939 /**
2940 * @return array
2941 */
2944 }
2946 /**
2947 * An arrow, depending on the language direction.
2948 *
2949 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2950 * @return string
2951 */
2966 }
2967 }
2969 /**
2970 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2971 *
2972 * @return bool
2973 */
2976 }
2978 /**
2979 * Get all magic words from cache.
2980 * @return array
2981 */
2984 }
2986 /**
2987 * Run the LanguageGetMagic hook once.
2988 */
2992 }
2997 }
2999 /**
3000 * Fill a MagicWord object with data from here
3001 *
3002 * @param $mw
3003 */
3005 // Saves a function call
3008 }
3015 }
3022 }
3023 }
3025 /**
3026 * Add magic words to the extension array
3027 *
3028 * @param $newWords array
3029 */
3036 }
3037 }
3038 }
3040 /**
3041 * Get special page names, as an associative array
3042 * case folded alias => real name
3043 */
3045 // Cache aliases because it may be slow to load them
3047 // Initialise array
3052 }
3055 }
3057 /**
3058 * Italic is unsuitable for some languages
3059 *
3060 * @param $text String: the text to be emphasized.
3061 * @return string
3062 */
3065 }
3067 /**
3068 * Normally we output all numbers in plain en_US style, that is
3069 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3070 * point twohundredthirtyfive. However this is not suitable for all
3071 * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3072 * Icelandic just want to use commas instead of dots, and dots instead
3073 * of commas like "293.291,235".
3074 *
3075 * An example of this function being called:
3076 * <code>
3077 * wfMessage( 'message' )->numParams( $num )->text()
3078 * </code>
3079 *
3080 * See LanguageGu.php for the Gujarati implementation and
3081 * $separatorTransformTable on MessageIs.php for
3082 * the , => . and . => , implementation.
3083 *
3084 * @todo check if it's viable to use localeconv() for the decimal
3085 * separator thing.
3086 * @param $number Mixed: the string to be formatted, should be an integer
3087 * or a floating point number.
3088 * @param $nocommafy Bool: set to true for special numbers like dates
3089 * @return string
3090 */
3098 }
3099 }
3105 }
3106 }
3109 }
3111 /**
3112 * Front-end for non-commafied formatNum
3113 *
3114 * @param mixed $number the string to be formatted, should be an integer
3115 * or a floating point number.
3116 * @since 1.21
3117 * @return string
3118 */
3121 }
3123 /**
3124 * @param $number string
3125 * @return string
3126 */
3131 }
3136 }
3140 }
3142 /**
3143 * Adds commas to a given number
3144 * @since 1.19
3145 * @param $number mixed
3146 * @return string
3147 */
3152 }
3155 // default grouping is at thousands, use the same for ###,###,### pattern too.
3158 // Ref: http://cldr.unicode.org/translation/number-patterns
3161 // For negative numbers apply the algorithm like positive number and add sign.
3164 }
3172 // the string does not have any number part. Eg: .12345
3174 }
3182 }
3186 // use the last pattern for the rest of the number
3188 }
3191 }
3192 }
3194 }
3195 }
3197 /**
3198 * @return String
3199 */
3202 }
3204 /**
3205 * @return array
3206 */
3209 }
3211 /**
3212 * @return array
3213 */
3216 }
3218 /**
3219 * Take a list of strings and build a locale-friendly comma-separated
3220 * list, using the local comma-separator message.
3221 * The last two strings are chained with an "and".
3222 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3223 *
3224 * @param $l Array
3225 * @return string
3226 */
3231 }
3237 }
3238 }
3245 }
3246 }
3248 }
3250 /**
3251 * Take a list of strings and build a locale-friendly comma-separated
3252 * list, using the local comma-separator message.
3253 * @param $list array of strings to put in a comma list
3254 * @return string
3255 */
3259 $list
3260 );
3261 }
3263 /**
3264 * Take a list of strings and build a locale-friendly semicolon-separated
3265 * list, using the local semicolon-separator message.
3266 * @param $list array of strings to put in a semicolon list
3267 * @return string
3268 */
3272 $list
3273 );
3274 }
3276 /**
3277 * Same as commaList, but separate it with the pipe instead.
3278 * @param $list array of strings to put in a pipe list
3279 * @return string
3280 */
3284 $list
3285 );
3286 }
3288 /**
3289 * Truncate a string to a specified length in bytes, appending an optional
3290 * string (e.g. for ellipses)
3291 *
3292 * The database offers limited byte lengths for some columns in the database;
3293 * multi-byte character sets mean we need to ensure that only whole characters
3294 * are included, otherwise broken characters can be passed to the user
3295 *
3296 * If $length is negative, the string will be truncated from the beginning
3297 *
3298 * @param $string String to truncate
3299 * @param $length Int: maximum length (including ellipses)
3300 * @param $ellipsis String to append to the truncated text
3301 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3302 * $adjustLength was introduced in 1.18, before that behaved as if false.
3303 * @return string
3304 */
3306 # Use the localized ellipsis character
3309 }
3310 # Check if there is no need to truncate
3315 }
3317 # If ellipsis length is >= $length then we can't apply $adjustLength
3320 # Otherwise, truncate and add ellipsis...
3333 }
3334 }
3335 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3336 # This check is *not* redundant if $adjustLength, due to the single case where
3337 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3342 }
3343 }
3345 /**
3346 * Remove bytes that represent an incomplete Unicode character
3347 * at the end of string (e.g. bytes of the char are missing)
3348 *
3349 * @param $string String
3350 * @return string
3351 */
3357 # We got the first byte only of a multibyte char; remove it.
3362 ) {
3363 # We chopped in the middle of a character; remove it
3365 }
3366 }
3368 }
3370 /**
3371 * Remove bytes that represent an incomplete Unicode character
3372 * at the start of string (e.g. bytes of the char are missing)
3373 *
3374 * @param $string String
3375 * @return string
3376 */
3381 # We chopped in the middle of a character; remove the whole thing
3383 }
3384 }
3386 }
3388 /**
3389 * Truncate a string of valid HTML to a specified length in bytes,
3390 * appending an optional string (e.g. for ellipses), and return valid HTML
3391 *
3392 * This is only intended for styled/linked text, such as HTML with
3393 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3394 * Also, this will not detect things like "display:none" CSS.
3395 *
3396 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3397 *
3398 * @param string $text HTML string to truncate
3399 * @param int $length (zero/positive) Maximum length (including ellipses)
3400 * @param string $ellipsis String to append to the truncated text
3401 * @return string
3402 */
3404 # Use the localized ellipsis character
3407 }
3408 # Check if there is clearly no need to truncate
3413 }
3427 # Consider truncation once the display length has reached the maximim.
3428 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3429 # Check that we're not in the middle of a bracket/entity...
3433 # Save where we are; we will truncate here unless there turn out to
3434 # be so few remaining characters that truncation is not necessary.
3437 }
3439 # String in fact does need truncation, the truncation point was OK.
3444 }
3445 }
3448 }
3450 # Read the next char...
3468 }
3474 // Name found (e.g. "<a href=..."), add on tag attributes...
3476 }
3482 }
3485 // Save state without $ch. We want to *hit* the first
3486 // display char (to get tags) but not *use* it if truncating.
3488 }
3493 // Add the next $max display text chars after this in one swoop...
3498 }
3499 }
3500 }
3501 }
3502 // Close the last tag if left unclosed by bad HTML
3506 }
3508 }
3510 /**
3511 * truncateHtml() helper function
3512 * like strcspn() but adds the skipped chars to $ret
3513 *
3514 * @param $ret
3515 * @param $text
3516 * @param $search
3517 * @param $start
3518 * @param $len
3519 * @return int
3520 */
3526 }
3531 }
3533 }
3535 /**
3536 * truncateHtml() helper function
3537 * (a) push or pop $tag from $openTags as needed
3538 * (b) clear $tag value
3539 * @param &$tag string Current HTML tag name we are looking at
3540 * @param $tagType int (0-open tag, 1-close tag)
3541 * @param $lastCh string Character before the '>' that ended this tag
3542 * @param &$openTags array Open tag stack (not accounting for $tag)
3543 */
3552 }
3553 }
3555 }
3556 }
3558 /**
3559 * Grammatical transformations, needed for inflected languages
3560 * Invoked by putting {{grammar:case|word}} in a message
3561 *
3562 * @param $word string
3563 * @param $case string
3564 * @return string
3565 */
3570 }
3572 }
3573 /**
3574 * Get the grammar forms for the content language
3575 * @return array of grammar forms
3576 * @since 1.20
3577 */
3580 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3582 }
3584 }
3585 /**
3586 * Provides an alternative text depending on specified gender.
3587 * Usage {{gender:username|masculine|feminine|neutral}}.
3588 * username is optional, in which case the gender of current user is used,
3589 * but only in (some) interface messages; otherwise default gender is used.
3590 *
3591 * If no forms are given, an empty string is returned. If only one form is
3592 * given, it will be returned unconditionally. These details are implied by
3593 * the caller and cannot be overridden in subclasses.
3594 *
3595 * If more than one form is given, the default is to use the neutral one
3596 * if it is specified, and to use the masculine one otherwise. These
3597 * details can be overridden in subclasses.
3598 *
3599 * @param $gender string
3600 * @param $forms array
3601 *
3602 * @return string
3603 */
3607 }
3611 }
3614 }
3616 }
3618 /**
3619 * Plural form transformations, needed for some languages.
3620 * For example, there are 3 form of plural in Russian and Polish,
3621 * depending on "count mod 10". See [[w:Plural]]
3622 * For English it is pretty simple.
3623 *
3624 * Invoked by putting {{plural:count|wordform1|wordform2}}
3625 * or {{plural:count|wordform1|wordform2|wordform3}}
3626 *
3627 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3628 *
3629 * @param $count Integer: non-localized number
3630 * @param $forms Array: different plural forms
3631 * @return string Correct form of plural for $count in this language
3632 */
3634 // Handle explicit n=pluralform cases
3640 }
3642 }
3643 }
3648 }
3653 }
3655 /**
3656 * Checks that convertPlural was given an array and pads it to requested
3657 * amount of forms by copying the last one.
3658 *
3659 * @param $count Integer: How many forms should there be at least
3660 * @param $forms Array of forms given to convertPlural
3661 * @return array Padded array of forms or an exception if not an array
3662 */
3666 }
3668 }
3670 /**
3671 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3672 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3673 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3674 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3675 * match up with it.
3676 *
3677 * @param $str String: the validated block duration in English
3678 * @return string Somehow translated block duration
3679 * @see LanguageFi.php for example implementation
3680 */
3686 }
3687 }
3689 // Since usually only infinite or indefinite is only on list, so try
3690 // equivalents if still here.
3697 }
3698 }
3699 }
3701 // If all else fails, return a standard duration or timestamp description.
3706 // $time is relative to 0 so it's a duration length.
3710 // wfTimestamp() handles 0 as current time instead of epoch.
3714 }
3715 }
3716 }
3718 /**
3719 * languages like Chinese need to be segmented in order for the diff
3720 * to be of any use
3721 *
3722 * @param $text String
3723 * @return String
3724 */
3727 }
3729 /**
3730 * and unsegment to show the result
3731 *
3732 * @param $text String
3733 * @return String
3734 */
3737 }
3739 /**
3740 * Return the LanguageConverter used in the Language
3741 *
3742 * @since 1.19
3743 * @return LanguageConverter
3744 */
3747 }
3749 /**
3750 * convert text to all supported variants
3751 *
3752 * @param $text string
3753 * @return array
3754 */
3757 }
3759 /**
3760 * convert text to different variants of a language.
3761 *
3762 * @param $text string
3763 * @return string
3764 */
3767 }
3769 /**
3770 * Convert a Title object to a string in the preferred variant
3771 *
3772 * @param $title Title
3773 * @return string
3774 */
3777 }
3779 /**
3780 * Convert a namespace index to a string in the preferred variant
3781 *
3782 * @param $ns int
3783 * @return string
3784 */
3787 }
3789 /**
3790 * Check if this is a language with variants
3791 *
3792 * @return bool
3793 */
3796 }
3798 /**
3799 * Check if the language has the specific variant
3800 *
3801 * @since 1.19
3802 * @param $variant string
3803 * @return bool
3804 */
3807 }
3809 /**
3810 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3811 *
3812 * @param $text string
3813 * @return string
3814 */
3817 }
3819 /**
3820 * Perform output conversion on a string, and encode for safe HTML output.
3821 * @param $text String text to be converted
3822 * @param $isTitle Bool whether this conversion is for the article title
3823 * @return string
3824 * @todo this should get integrated somewhere sane
3825 */
3828 }
3830 /**
3831 * @param $key string
3832 * @return string
3833 */
3836 }
3838 /**
3839 * Get the list of variants supported by this language
3840 * see sample implementation in LanguageZh.php
3841 *
3842 * @return array an array of language codes
3843 */
3846 }
3848 /**
3849 * @return string
3850 */
3853 }
3855 /**
3856 * @return string
3857 */
3860 }
3862 /**
3863 * @return string
3864 */
3867 }
3869 /**
3870 * If a language supports multiple variants, it is
3871 * possible that non-existing link in one variant
3872 * actually exists in another variant. this function
3873 * tries to find it. See e.g. LanguageZh.php
3874 *
3875 * @param $link String: the name of the link
3876 * @param $nt Mixed: the title object of the link
3877 * @param $ignoreOtherCond Boolean: to disable other conditions when
3878 * we need to transclude a template or update a category's link
3879 * @return null the input parameters may be modified upon return
3880 */
3883 }
3885 /**
3886 * If a language supports multiple variants, converts text
3887 * into an array of all possible variants of the text:
3888 * 'variant' => text in that variant
3889 *
3890 * @deprecated since 1.17 Use autoConvertToAllVariants()
3891 *
3892 * @param $text string
3893 *
3894 * @return string
3895 */
3898 }
3900 /**
3901 * returns language specific options used by User::getPageRenderHash()
3902 * for example, the preferred language variant
3903 *
3904 * @return string
3905 */
3908 }
3910 /**
3911 * For languages that support multiple variants, the title of an
3912 * article may be displayed differently in different variants. this
3913 * function returns the apporiate title defined in the body of the article.
3914 *
3915 * @return string
3916 */
3919 }
3921 /**
3922 * Prepare external link text for conversion. When the text is
3923 * a URL, it shouldn't be converted, and it'll be wrapped in
3924 * the "raw" tag (-{R| }-) to prevent conversion.
3925 *
3926 * This function is called "markNoConversion" for historical
3927 * reasons.
3928 *
3929 * @param $text String: text to be used for external link
3930 * @param $noParse bool: wrap it without confirming it's a real URL first
3931 * @return string the tagged text
3932 */
3934 // Excluding protocal-relative URLs may avoid many false positives.
3939 }
3940 }
3942 /**
3943 * A regular expression to match legal word-trailing characters
3944 * which should be merged onto a link of the form [[foo]]bar.
3945 *
3946 * @return string
3947 */
3950 }
3952 /**
3953 * @return Language
3954 */
3957 }
3959 /**
3960 * Get the "parent" language which has a converter to convert a "compatible" language
3961 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
3962 *
3963 * @return Language|null
3964 * @since 1.22
3965 */
3969 }
3976 }
3981 }
3985 }
3987 /**
3988 * Get the RFC 3066 code for this language object
3989 *
3990 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3991 * htmlspecialchars() or similar
3992 *
3993 * @return string
3994 */
3997 }
3999 /**
4000 * Get the code in Bcp47 format which we can use
4001 * inside of html lang="" tags.
4002 *
4003 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4004 * htmlspecialchars() or similar.
4005 *
4006 * @since 1.19
4007 * @return string
4008 */
4012 }
4014 }
4016 /**
4017 * @param $code string
4018 */
4021 // Ensure we don't leave incorrect cached data lying around
4024 }
4026 /**
4027 * Get the name of a file for a certain language code
4028 * @param $prefix string Prepend this to the filename
4029 * @param $code string Language code
4030 * @param $suffix string Append this to the filename
4031 * @throws MWException
4032 * @return string $prefix . $mangledCode . $suffix
4033 */
4035 // Protect against path traversal
4038 {
4040 }
4043 }
4045 /**
4046 * Get the language code from a file name. Inverse of getFileName()
4047 * @param $filename string $prefix . $languageCode . $suffix
4048 * @param $prefix string Prefix before the language code
4049 * @param $suffix string Suffix after the language code
4050 * @return string Language code, or false if $prefix or $suffix isn't found
4051 */
4052 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4058 }
4060 }
4062 /**
4063 * @param $code string
4064 * @return string
4065 */
4071 }
4073 /**
4074 * @param $code string
4075 * @return string
4076 */
4080 }
4082 /**
4083 * Get the first fallback for a given language.
4084 *
4085 * @param $code string
4086 *
4087 * @return bool|string
4088 */
4096 }
4097 }
4099 /**
4100 * Get the ordered list of fallback languages.
4101 *
4102 * @since 1.19
4103 * @param $code string Language code
4104 * @return array
4105 */
4114 }
4116 }
4117 }
4119 /**
4120 * Get the ordered list of fallback languages, ending with the fallback
4121 * language chain for the site language.
4122 *
4123 * @since 1.22
4124 * @param string $code Language code
4125 * @return array array( fallbacks, site fallbacks )
4126 */
4130 // Usually, we will only store a tiny number of fallback chains, so we
4131 // keep them in static memory.
4137 // Append the site's fallback chain, including the site language itself
4141 // Eliminate any languages already included in the chain
4145 }
4147 }
4149 /**
4150 * Get all messages for a given language
4151 * WARNING: this may take a long time. If you just need all message *keys*
4152 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4153 *
4154 * @param $code string
4155 *
4156 * @return array
4157 */
4160 }
4162 /**
4163 * Get a message for a given language
4164 *
4165 * @param $key string
4166 * @param $code string
4167 *
4168 * @return string
4169 */
4172 }
4174 /**
4175 * Get all message keys for a given language. This is a faster alternative to
4176 * array_keys( Language::getMessagesFor( $code ) )
4177 *
4178 * @since 1.19
4179 * @param $code string Language code
4180 * @return array of message keys (strings)
4181 */
4184 }
4186 /**
4187 * @param $talk
4188 * @return mixed
4189 */
4193 }
4198 # Allow grammar transformations
4199 # Allowing full message-style parsing would make simple requests
4200 # such as action=raw much more expensive than they need to be.
4201 # This will hopefully cover most cases.
4205 }
4207 /**
4208 * @param $m string
4209 * @return string
4210 */
4213 }
4215 /**
4216 * @throws MWException
4217 * @return array
4218 */
4223 }
4230 }
4235 }
4237 /**
4238 * Decode an expiry (block, protection, etc) which has come from the DB
4239 *
4240 * @todo FIXME: why are we returnings DBMS-dependent strings???
4241 *
4242 * @param $expiry String: Database expiry String
4243 * @param $format Bool|Int true to process using language functions, or TS_ constant
4244 * to return the expiry in a given timestamp
4245 * @return String
4246 * @since 1.18
4247 */
4252 }
4262 }
4263 }
4265 /**
4266 * @todo Document
4267 * @param $seconds int|float
4268 * @param $format Array Optional
4269 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4270 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4271 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4272 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4273 * @return string
4274 */
4278 }
4281 }
4284 }
4306 }
4317 }
4321 }
4327 }
4335 }
4345 }
4349 }
4359 }
4360 }
4362 }
4364 /**
4365 * Format a bitrate for output, using an appropriate
4366 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4367 *
4368 * This use base 1000. For base 1024 use formatSize(), for another base
4369 * see formatComputingNumbers()
4370 *
4371 * @param $bps int
4372 * @return string
4373 */
4376 }
4378 /**
4379 * @param $size int Size of the unit
4380 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4381 * @param $messageKey string Message key to be uesd
4382 * @return string
4383 */
4388 );
4389 }
4397 }
4399 // For small sizes no decimal places necessary
4402 // For MB and bigger two decimal places are smarter
4404 }
4410 }
4412 /**
4413 * Format a size in bytes for output, using an appropriate
4414 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4415 *
4416 * This method use base 1024. For base 1000 use formatBitrate(), for
4417 * another base see formatComputingNumbers()
4418 *
4419 * @param $size int Size to format
4420 * @return string Plain text (not HTML)
4421 */
4424 }
4426 /**
4427 * Make a list item, used by various special pages
4428 *
4429 * @param $page String Page link
4430 * @param $details String Text between brackets
4431 * @param $oppositedm Boolean Add the direction mark opposite to your
4432 * language, to display text properly
4433 * @return String
4434 */
4441 }
4443 /**
4444 * Generate (prev x| next x) (20|50|100...) type links for paging
4445 *
4446 * @param $title Title object to link
4447 * @param $offset Integer offset parameter
4448 * @param $limit Integer limit parameter
4449 * @param $query array|String optional URL query parameter string
4450 * @param $atend Bool optional param for specified if this is the last page
4451 * @return String
4452 */
4453 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4454 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4456 # Make 'previous' link
4457 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4463 }
4465 # Make 'next' link
4466 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4472 }
4474 # Make links to set number of items per page
4479 }
4483 }
4485 /**
4486 * Helper function for viewPrevNext() that generates links
4487 *
4488 * @param $title Title object to link
4489 * @param $offset Integer offset parameter
4490 * @param $limit Integer limit parameter
4491 * @param $query Array extra query parameters
4492 * @param $link String text to use for the link; will be escaped
4493 * @param $tooltipMsg String name of the message to use as tooltip
4494 * @param $class String value of the "class" attribute of the link
4495 * @return String HTML fragment
4496 */
4497 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4499 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4502 }
4504 /**
4505 * Get the conversion rule title, if any.
4506 *
4507 * @return string
4508 */
4511 }
4513 /**
4514 * Get the compiled plural rules for the language
4515 * @since 1.20
4516 * @return array Associative array with plural form, and plural rule as key-value pairs
4517 */
4523 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4526 }
4527 }
4528 }
4530 }
4532 /**
4533 * Get the plural rules for the language
4534 * @since 1.20
4535 * @return array Associative array with plural form number and plural rule as key-value pairs
4536 */
4545 }
4546 }
4547 }
4549 }
4551 /**
4552 * Get the plural rule types for the language
4553 * @since 1.22
4554 * @return array Associative array with plural form number and plural rule type as key-value pairs
4555 */
4561 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4564 }
4565 }
4566 }
4568 }
4570 /**
4571 * Find the index number of the plural rule appropriate for the given number
4572 * @return int The index number of the plural rule
4573 */
4578 }
4580 /**
4581 * Find the plural rule type appropriate for the given number
4582 * For example, if the language is set to Arabic, getPluralType(5) should
4583 * return 'few'.
4584 * @since 1.22
4585 * @return string The name of the plural rule type, e.g. one, two, few, many
4586 */
4594 }
4595 }
4596 }