| blob | 24d083d0f8214f5d8c20957392d74414e02efd04 |
1 <?php
2 /**
3 * Internationalisation code.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
19 *
20 * @file
21 * @ingroup Language
22 */
24 /**
25 * @defgroup Language Language
26 */
31 }
33 # Read language names
39 }
41 /**
42 * a fake language converter
43 *
44 * @ingroup Language
45 */
47 /**
48 * @var Language
49 */
69 }
71 /**
72 * Internationalisation code
73 * @ingroup Language
74 */
77 /**
78 * @var LanguageConverter
79 */
91 /**
92 * ReplacementArray object caches
93 */
96 /**
97 * @var LocalisationCache
98 */
106 );
110 );
115 'december'
116 );
120 'december-gen'
121 );
125 );
132 );
140 );
148 );
155 );
157 /**
158 * @since 1.20
159 * @var array
160 */
171 );
173 /**
174 * Get a cached or new language object for a given language code
175 * @param $code String
176 * @return Language
177 */
183 }
185 // get the language object to process
190 // merge the language object in to get it up front in the cache
192 // get rid of the oldest ones in case we have an overflow
196 }
198 /**
199 * Create a language object for a given language code
200 * @param $code String
201 * @throws MWException
202 * @return Language
203 */
205 // Protect against path traversal below
208 {
210 }
213 // It's not possible to customise this code with class files, so
214 // just return a Language object. This is to support uselang= hacks.
218 }
220 // Check if there is a language class for the code
226 }
228 // Keep trying the fallback list until we find an existing class
233 }
241 }
242 }
245 }
247 /**
248 * Checks whether any localisation is available for that language tag
249 * in MediaWiki (MessagesXx.php exists).
250 *
251 * @param string $code Language tag (in lower case)
252 * @return bool Whether language is supported
253 * @since 1.21
254 */
257 }
259 /**
260 * Returns true if a language code string is a well-formed language tag
261 * according to RFC 5646.
262 * This function only checks well-formedness; it doesn't check that
263 * language, script or variant codes actually exist in the repositories.
264 *
265 * Based on regexes by Mark Davis of the Unicode Consortium:
266 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
267 *
268 * @param $code string
269 * @param $lenient boolean Whether to allow '_' as separator. The default is only '-'.
270 *
271 * @return bool
272 * @since 1.21
273 */
289 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
290 # Since these are limited, this is safe even later changes to the registry --
291 # the only oddity is that it might change the type of the tag, and thus
292 # the results from the capturing groups.
293 # http://www.iana.org/assignments/language-subtag-registry
311 # The final breakdown, with capturing groups for each of these components
312 # The variants, extensions, grandfathered, and private-use may have interior '-'
317 }
319 /**
320 * Returns true if a language code string is of a valid form, whether or
321 * not it exists. This includes codes which are used solely for
322 * customisation via the MediaWiki namespace.
323 *
324 * @param $code string
325 *
326 * @return bool
327 */
329 return
330 // People think language codes are html safe, so enforce it.
331 // Ideally we should only allow a-zA-Z0-9-
332 // but, .+ and other chars are often used for {{int:}} hacks
333 // see bugs 37564, 37587, 36938
336 }
338 /**
339 * Returns true if a language code is of a valid form for the purposes of
340 * internal customisation of MediaWiki, via Messages*.php.
341 *
342 * @param $code string
343 *
344 * @throws MWException
345 * @since 1.18
346 * @return bool
347 */
355 }
358 }
361 }
363 /**
364 * Returns true if a language code is an IETF tag known to MediaWiki.
365 *
366 * @param $code string
367 *
368 * @since 1.21
369 * @return bool
370 */
376 }
380 ) {
382 }
385 }
387 /**
388 * @param $code
389 * @return String Name of the language class
390 */
396 }
397 }
399 /**
400 * Includes language class files
401 *
402 * @param $class string Name of the language class
403 */
409 }
414 }
415 }
416 }
418 /**
419 * Get the LocalisationCache instance
420 *
421 * @return LocalisationCache
422 */
428 }
430 }
434 // Set the code to the name of the descendant
439 }
441 }
443 /**
444 * Reduce memory usage
445 */
449 }
450 }
452 /**
453 * Hook which will be called if this is the content language.
454 * Descendants can use this to register hook functions or modify globals
455 */
458 /**
459 * Same as getFallbacksFor for current language.
460 * @return array|bool
461 * @deprecated in 1.19
462 */
466 }
468 /**
469 * @return array
470 * @since 1.19
471 */
474 }
476 /**
477 * Exports $wgBookstoreListEn
478 * @return array
479 */
482 }
484 /**
485 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
486 * available in localised form, it will be included in English.
487 *
488 * @return array
489 */
506 }
508 # Sometimes a language will be localised but not actually exist on this wiki.
512 }
513 }
515 # The above mixing may leave namespaces out of canonical order.
516 # Re-order by namespace ID number...
520 }
522 }
524 /**
525 * Arbitrarily set all of the namespace names at once. Mainly used for testing
526 * @param $namespaces Array of namespaces (id => name)
527 */
531 }
533 /**
534 * Resets all of the namespace caches. Mainly used for testing
535 */
540 }
542 /**
543 * A convenience function that returns the same thing as
544 * getNamespaces() except with the array values changed to ' '
545 * where it found '_', useful for producing output to be displayed
546 * e.g. in <select> forms.
547 *
548 * @return array
549 */
554 }
556 }
558 /**
559 * Get a namespace value by key
560 * <code>
561 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
562 * echo $mw_ns; // prints 'MediaWiki'
563 * </code>
564 *
565 * @param $index Int: the array key of the namespace to return
566 * @return mixed, string if the namespace value exists, otherwise false
567 */
571 }
573 /**
574 * A convenience function that returns the same thing as
575 * getNsText() except with '_' changed to ' ', useful for
576 * producing output.
577 *
578 * <code>
579 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
580 * echo $mw_ns; // prints 'MediaWiki talk'
581 * </code>
582 *
583 * @param int $index The array key of the namespace to return
584 * @return string Namespace name without underscores (empty string if namespace does not exist)
585 */
589 }
591 /**
592 * Returns gender-dependent namespace alias if available.
593 * @param $index Int: namespace index
594 * @param $gender String: gender key (male, female... )
595 * @return String
596 * @since 1.18
597 */
601 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
603 }
605 /**
606 * Whether this language makes distinguishes genders for example in
607 * namespaces.
608 * @return bool
609 * @since 1.18
610 */
614 // $wgExtraGenderNamespaces overrides everything
616 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
617 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
618 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
621 // Check what is in i18n files
624 }
625 }
627 /**
628 * Get a namespace key by value, case insensitive.
629 * Only matches namespace names for the current language, not the
630 * canonical ones defined in Namespace.php.
631 *
632 * @param $text String
633 * @return mixed An integer if $text is a valid value otherwise false
634 */
639 }
641 /**
642 * @return array
643 */
655 }
656 }
657 }
660 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
664 }
665 }
668 }
670 }
672 /**
673 * @return array
674 */
678 # Put namespace names and aliases into a hashtable.
679 # If this is too slow, then we should arrange it so that it is done
680 # before caching. The catch is that at pre-cache time, the above
681 # class-specific fixup hasn't been done.
685 }
688 }
692 }
693 }
694 }
696 }
698 /**
699 * Get a namespace key by value, case insensitive. Canonical namespace
700 * names override custom ones defined for the current language.
701 *
702 * @param $text String
703 * @return mixed An integer if $text is a valid value otherwise false
704 */
710 }
713 }
715 /**
716 * short names for language variants used for language conversion links.
717 *
718 * @param $code String
719 * @param $usemsg bool Use the "variantname-xyz" message if it exists
720 * @return string
721 */
726 }
731 # otherwise, output the language code
733 }
734 }
736 /**
737 * @param $name string
738 * @return string
739 */
744 }
746 }
748 /**
749 * @return array
750 */
753 }
755 /**
756 * @return array
757 */
760 }
762 /**
763 * @return array|string
764 */
772 }
773 }
775 /**
776 * @return array
777 */
780 }
782 /**
783 * @param $image
784 * @return array|null
785 */
788 }
790 /**
791 * @return array
792 */
795 }
797 /**
798 * @param $tog
799 * @return string
800 */
803 }
805 /**
806 * Get native language names, indexed by code.
807 * Only those defined in MediaWiki, no other data like CLDR.
808 * If $customisedOnly is true, only returns codes with a messages file
809 *
810 * @param $customisedOnly bool
811 *
812 * @return array
813 * @deprecated in 1.20, use fetchLanguageNames()
814 */
817 }
819 /**
820 * Get translated language names. This is done on best effort and
821 * by default this is exactly the same as Language::getLanguageNames.
822 * The CLDR extension provides translated names.
823 * @param $code String Language code.
824 * @return Array language code => language name
825 * @since 1.18.0
826 * @deprecated in 1.20, use fetchLanguageNames()
827 */
830 }
832 /**
833 * Get an array of language names, indexed by code.
834 * @param $inLanguage null|string: Code of language in which to return the names
835 * Use null for autonyms (native names)
836 * @param $include string:
837 * 'all' all available languages
838 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
839 * 'mwfile' only if the language is in 'mw' *and* has a message file
840 * @return array: language code => language name
841 * @since 1.20
842 */
849 }
854 # TODO: also include when $inLanguage is null, when this code is more efficient
856 }
860 # - Prefer own MediaWiki native name when not using the hook
861 # - For other names just add if not added through the hook
864 }
865 }
869 }
875 }
879 # We do this using a foreach over the codes instead of a directory
880 # loop so that messages files in extensions will work correctly.
884 }
885 }
887 }
888 # 'mw' option; default if it's not one of the other two options (all/mwfile)
890 }
892 /**
893 * @param $code string: The code of the language for which to get the name
894 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
895 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
896 * @return string: Language name or empty
897 * @since 1.20
898 */
902 }
904 /**
905 * Get a message from the MediaWiki namespace.
906 *
907 * @param $msg String: message name
908 * @return string
909 */
912 }
914 /**
915 * Get the native language name of $code.
916 * Only if defined in MediaWiki, no other data like CLDR.
917 * @param $code string
918 * @return string
919 * @deprecated in 1.20, use fetchLanguageName()
920 */
923 }
925 /**
926 * @param $key string
927 * @return string
928 */
931 }
933 /**
934 * @return array
935 */
940 }
942 }
944 /**
945 * @param $key string
946 * @return string
947 */
950 }
952 /**
953 * @param $key string
954 * @return string
955 */
958 }
960 /**
961 * @return array
962 */
967 }
969 }
971 /**
972 * @param $key string
973 * @return string
974 */
977 }
979 /**
980 * @param $key string
981 * @return string
982 */
985 }
987 /**
988 * @param $key string
989 * @return string
990 */
993 }
995 /**
996 * @param $key string
997 * @return string
998 */
1001 }
1003 /**
1004 * @param $key string
1005 * @return string
1006 */
1009 }
1011 /**
1012 * @param $key string
1013 * @return string
1014 */
1017 }
1019 /**
1020 * This is a workalike of PHP's date() function, but with better
1021 * internationalisation, a reduced set of format characters, and a better
1022 * escaping format.
1023 *
1024 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1025 * the PHP manual for definitions. There are a number of extensions, which
1026 * start with "x":
1027 *
1028 * xn Do not translate digits of the next numeric format character
1029 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1030 * xr Use roman numerals for the next numeric format character
1031 * xh Use hebrew numerals for the next numeric format character
1032 * xx Literal x
1033 * xg Genitive month name
1034 *
1035 * xij j (day number) in Iranian calendar
1036 * xiF F (month name) in Iranian calendar
1037 * xin n (month number) in Iranian calendar
1038 * xiy y (two digit year) in Iranian calendar
1039 * xiY Y (full year) in Iranian calendar
1040 *
1041 * xjj j (day number) in Hebrew calendar
1042 * xjF F (month name) in Hebrew calendar
1043 * xjt t (days in month) in Hebrew calendar
1044 * xjx xg (genitive month name) in Hebrew calendar
1045 * xjn n (month number) in Hebrew calendar
1046 * xjY Y (full year) in Hebrew calendar
1047 *
1048 * xmj j (day number) in Hijri calendar
1049 * xmF F (month name) in Hijri calendar
1050 * xmn n (month number) in Hijri calendar
1051 * xmY Y (full year) in Hijri calendar
1052 *
1053 * xkY Y (full year) in Thai solar calendar. Months and days are
1054 * identical to the Gregorian calendar
1055 * xoY Y (full year) in Minguo calendar or Juche year.
1056 * Months and days are identical to the
1057 * Gregorian calendar
1058 * xtY Y (full year) in Japanese nengo. Months and days are
1059 * identical to the Gregorian calendar
1060 *
1061 * Characters enclosed in double quotes will be considered literal (with
1062 * the quotes themselves removed). Unmatched quotes will be considered
1063 * literal quotes. Example:
1064 *
1065 * "The month is" F => The month is January
1066 * i's" => 20'11"
1067 *
1068 * Backslash escaping is also supported.
1069 *
1070 * Input timestamp is assumed to be pre-normalized to the desired local
1071 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1072 * $ts is UTC if $zone is not given.
1073 *
1074 * @param $format String
1075 * @param $ts String: 14-character timestamp
1076 * YYYYMMDDHHMMSS
1077 * 01234567890123
1078 * @param $zone DateTimeZone: Timezone of $ts
1079 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1080 *
1081 * @return string
1082 */
1101 }
1103 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1105 }
1129 }
1139 );
1140 }
1149 }
1155 }
1161 }
1168 );
1169 }
1178 }
1184 }
1190 }
1205 }
1211 }
1217 }
1223 }
1232 }
1238 }
1244 }
1250 }
1256 }
1262 }
1271 }
1306 // Pass through string from $dateTimeObj->format()
1310 );
1311 }
1324 // Pass through number from $dateTimeObj->format()
1328 );
1329 }
1333 # Backslash escaping
1338 }
1341 # Quoted literal
1345 # No terminating quote, assume literal "
1350 }
1352 # Quote at end of string, assume literal "
1354 }
1358 }
1371 }
1372 }
1373 }
1375 }
1380 /**
1381 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1382 * Gregorian dates to Iranian dates. Originally written in C, it
1383 * is released under the terms of GNU Lesser General Public
1384 * License. Conversion to PHP was performed by Niklas Laxström.
1385 *
1386 * Link: http://www.farsiweb.info/jalali/jalali.c
1387 *
1388 * @param $ts string
1389 *
1390 * @return string
1391 */
1397 # Days passed from the beginning (including leap years)
1403 // Add days of the past months of this year
1406 }
1408 // Leap years
1411 }
1413 // Days passed in current month
1427 }
1431 }
1437 }
1439 /**
1440 * Converting Gregorian dates to Hijri dates.
1441 *
1442 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1443 *
1444 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1445 *
1446 * @param $ts string
1447 *
1448 * @return string
1449 */
1463 )
1464 {
1472 }
1477 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1478 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1484 }
1486 /**
1487 * Converting Gregorian dates to Hebrew dates.
1488 *
1489 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1490 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1491 * to translate the relevant functions into PHP and release them under
1492 * GNU GPL.
1493 *
1494 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1495 * and Adar II is 14. In a non-leap year, Adar is 6.
1496 *
1497 * @param $ts string
1498 *
1499 * @return string
1500 */
1502 # Parse date
1507 # Calculate Hebrew year
1510 # Month number when September = 1, August = 12
1513 # Next year
1517 }
1519 # Calculate day of year from 1 September
1523 # February
1525 # Check if the year is leap
1528 }
1533 }
1534 }
1536 # Calculate the start of the Hebrew year
1539 # Calculate next year's start
1541 # Day is before the start of the year - it is the previous year
1542 # Next year's start
1544 # Previous year
1547 # Add days since previous year's 1 September
1550 # Leap year
1552 }
1553 # Start of the new (previous) year
1556 # Next year's start
1558 }
1560 # Calculate Hebrew day of year
1563 # Difference between year's days
1565 # Add 12 (or 13 for leap years) days to ignore the difference between
1566 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1567 # difference is only about the year type
1572 }
1574 # Check the year pattern, and is leap year
1575 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1576 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1577 # and non-leap years
1579 # Check if leap year
1582 # Calculate day in the month from number of day in the Hebrew year
1583 # Don't check Adar - if the day is not in Adar, we will stop before;
1584 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1589 # Calculate days in this month
1591 # Adar in a leap year
1593 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1596 # Day in Adar I
1599 # Subtract the days of Adar I
1601 # Try Adar II
1604 # Day in Adar II
1606 }
1607 }
1608 }
1610 # Cheshvan in a complete year (otherwise as the rule below)
1613 # Kislev in an incomplete year (otherwise as the rule below)
1616 # Odd months have 30 days, even have 29
1618 }
1620 # In the current month
1623 # Subtract the days of the current month
1625 # Try in the next month
1627 }
1628 }
1631 }
1633 /**
1634 * This calculates the Hebrew year start, as days since 1 September.
1635 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1636 * Used for Hebrew date.
1637 *
1638 * @param $year int
1639 *
1640 * @return string
1641 */
1648 }
1652 }
1662 }
1666 }
1668 /**
1669 * Algorithm to convert Gregorian dates to Thai solar dates,
1670 * Minguo dates or Minguo dates.
1671 *
1672 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1673 * http://en.wikipedia.org/wiki/Minguo_calendar
1674 * http://en.wikipedia.org/wiki/Japanese_era_name
1675 *
1676 * @param $ts String: 14-character timestamp
1677 * @param $cName String: calender name
1678 * @return Array: converted year, month, day
1679 */
1686 # Thai solar dates
1687 # Add 543 years to the Gregorian calendar
1688 # Months and days are identical
1691 # Minguo dates
1692 # Deduct 1911 years from the Gregorian calendar
1693 # Months and days are identical
1696 # Nengō dates up to Meiji period
1697 # Deduct years from the Gregorian calendar
1698 # depending on the nengo periods
1699 # Months and days are identical
1700 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1701 # Meiji period
1706 }
1714 )
1715 {
1716 # Taishō period
1721 }
1727 )
1728 {
1729 # Shōwa period
1734 }
1737 # Heisei period
1742 }
1744 }
1747 }
1750 }
1752 /**
1753 * Roman number formatting up to 10000
1754 *
1755 * @param $num int
1756 *
1757 * @return string
1758 */
1764 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1765 );
1770 }
1776 }
1778 }
1780 }
1782 /**
1783 * Hebrew Gematria number formatting up to 9999
1784 *
1785 * @param $num int
1786 *
1787 * @return string
1788 */
1795 );
1800 }
1812 }
1813 }
1814 }
1816 }
1822 }
1841 }
1843 }
1845 /**
1846 * Used by date() and time() to adjust the time output.
1847 *
1848 * @param $ts Int the time in date('YmdHis') format
1849 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1850 * get user timecorrection setting)
1851 * @return int
1852 */
1858 }
1871 }
1872 # Unrecognized timezone, default to 'Offset' with the stored offset.
1874 }
1878 # Global offset in minutes.
1881 }
1892 }
1895 }
1896 }
1898 # No difference ? Return time unchanged
1901 }
1904 # Generate an adjusted date; take advantage of the fact that mktime
1905 # will normalize out-of-range values so we don't have to split $minDiff
1906 # into hours and minutes.
1919 }
1921 /**
1922 * This is meant to be used by time(), date(), and timeanddate() to get
1923 * the date preference they're supposed to use, it should be used in
1924 * all children.
1925 *
1926 *<code>
1927 * function timeanddate([...], $format = true) {
1928 * $datePreference = $this->dateFormat($format);
1929 * [...]
1930 * }
1931 *</code>
1932 *
1933 * @param $usePrefs Mixed: if true, the user's preference is used
1934 * if false, the site/language default is used
1935 * if int/string, assumed to be a format.
1936 * @return string
1937 */
1946 }
1949 }
1951 // return int
1954 }
1957 }
1959 /**
1960 * Get a format string for a given type and preference
1961 * @param $type string May be date, time or both
1962 * @param $pref string The format name as it appears in Messages*.php
1963 *
1964 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
1965 *
1966 * @return string
1967 */
1978 }
1983 }
1984 }
1986 }
1988 }
1990 /**
1991 * @param $ts Mixed: the time format which needs to be turned into a
1992 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1993 * @param $adj Bool: whether to adjust the time output according to the
1994 * user configured offset ($timecorrection)
1995 * @param $format Mixed: true to use user's date format preference
1996 * @param $timecorrection String|bool the time offset as returned by
1997 * validateTimeZone() in Special:Preferences
1998 * @return string
1999 */
2004 }
2007 }
2009 /**
2010 * @param $ts Mixed: the time format which needs to be turned into a
2011 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2012 * @param $adj Bool: whether to adjust the time output according to the
2013 * user configured offset ($timecorrection)
2014 * @param $format Mixed: true to use user's date format preference
2015 * @param $timecorrection String|bool the time offset as returned by
2016 * validateTimeZone() in Special:Preferences
2017 * @return string
2018 */
2023 }
2026 }
2028 /**
2029 * @param $ts Mixed: the time format which needs to be turned into a
2030 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2031 * @param $adj Bool: whether to adjust the time output according to the
2032 * user configured offset ($timecorrection)
2033 * @param $format Mixed: what format to return, if it's false output the
2034 * default one (default true)
2035 * @param $timecorrection String|bool the time offset as returned by
2036 * validateTimeZone() in Special:Preferences
2037 * @return string
2038 */
2043 }
2046 }
2048 /**
2049 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2050 *
2051 * @since 1.20
2052 *
2053 * @param integer $seconds The amount of seconds.
2054 * @param array $chosenIntervals The intervals to enable.
2055 *
2056 * @return string
2057 */
2066 }
2069 }
2071 /**
2072 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2073 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2074 *
2075 * @since 1.20
2076 *
2077 * @param integer $seconds The amount of seconds.
2078 * @param array $chosenIntervals The intervals to enable.
2079 *
2080 * @return array
2081 */
2084 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2085 }
2099 }
2100 }
2103 }
2105 /**
2106 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2107 *
2108 * @param $type String: can be 'date', 'time' or 'both'
2109 * @param $ts Mixed: the time format which needs to be turned into a
2110 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2111 * @param $user User object used to get preferences for timezone and format
2112 * @param $options Array, can contain the following keys:
2113 * - 'timecorrection': time correction, can have the following values:
2114 * - true: use user's preference
2115 * - false: don't use time correction
2116 * - integer: value of time correction in minutes
2117 * - 'format': format to use, can have the following values:
2118 * - true: use user's preference
2119 * - false: use default preference
2120 * - string: format to use
2121 * @since 1.19
2122 * @return String
2123 */
2132 }
2134 }
2139 }
2142 }
2144 /**
2145 * Get the formatted date for the given timestamp and formatted for
2146 * the given user.
2147 *
2148 * @param $ts Mixed: the time format which needs to be turned into a
2149 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2150 * @param $user User object used to get preferences for timezone and format
2151 * @param $options Array, can contain the following keys:
2152 * - 'timecorrection': time correction, can have the following values:
2153 * - true: use user's preference
2154 * - false: don't use time correction
2155 * - integer: value of time correction in minutes
2156 * - 'format': format to use, can have the following values:
2157 * - true: use user's preference
2158 * - false: use default preference
2159 * - string: format to use
2160 * @since 1.19
2161 * @return String
2162 */
2165 }
2167 /**
2168 * Get the formatted time for the given timestamp and formatted for
2169 * the given user.
2170 *
2171 * @param $ts Mixed: the time format which needs to be turned into a
2172 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2173 * @param $user User object used to get preferences for timezone and format
2174 * @param $options Array, can contain the following keys:
2175 * - 'timecorrection': time correction, can have the following values:
2176 * - true: use user's preference
2177 * - false: don't use time correction
2178 * - integer: value of time correction in minutes
2179 * - 'format': format to use, can have the following values:
2180 * - true: use user's preference
2181 * - false: use default preference
2182 * - string: format to use
2183 * @since 1.19
2184 * @return String
2185 */
2188 }
2190 /**
2191 * Get the formatted date and time for the given timestamp and formatted for
2192 * the given user.
2193 *
2194 * @param $ts Mixed: the time format which needs to be turned into a
2195 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2196 * @param $user User object used to get preferences for timezone and format
2197 * @param $options Array, can contain the following keys:
2198 * - 'timecorrection': time correction, can have the following values:
2199 * - true: use user's preference
2200 * - false: don't use time correction
2201 * - integer: value of time correction in minutes
2202 * - 'format': format to use, can have the following values:
2203 * - true: use user's preference
2204 * - false: use default preference
2205 * - string: format to use
2206 * @since 1.19
2207 * @return String
2208 */
2211 }
2213 /**
2214 * Convert an MWTimestamp into a pretty human-readable timestamp using
2215 * the given user preferences and relative base time.
2216 *
2217 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2218 * on your timestamp object, which will then call this function. Calling
2219 * this function directly will cause hooks to be skipped over.
2220 *
2221 * @see MWTimestamp::getHumanTimestamp
2222 * @param MWTimestamp $ts Timestamp to prettify
2223 * @param MWTimestamp $relativeTo Base timestamp
2224 * @param User $user User preferences to use
2225 * @return string Human timestamp
2226 * @since 1.21
2227 */
2230 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) - (int)$relativeTo->timestamp->format( 'w' ) );
2232 if ( $diff->invert || $days > 5 && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' ) ) {
2233 // Timestamps are in different years: use full timestamp
2234 // Also do full timestamp for future dates
2235 /**
2236 * @FIXME Add better handling of future timestamps.
2237 */
2241 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2245 // Timestamp within the past week: show the day of the week and time
2253 // Timestamp was yesterday: say 'yesterday' and the time.
2260 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2267 // From here on in, the timestamp was soon enough ago so that we can simply say
2268 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2270 // Less than 90 minutes, but more than an hour ago.
2273 // A few minutes ago.
2276 // Less than a minute, but more than 30 sec ago.
2279 // Less than 30 seconds ago.
2281 }
2284 }
2286 /**
2287 * @param $key string
2288 * @return array|null
2289 */
2292 }
2294 /**
2295 * @return array
2296 */
2299 }
2301 /**
2302 * @param $in
2303 * @param $out
2304 * @param $string
2305 * @return string
2306 */
2308 # This is a wrapper for iconv in all languages except esperanto,
2309 # which does some nasty x-conversions beforehand
2311 # Even with //IGNORE iconv can whine about illegal characters in
2312 # *input* string. We just ignore those too.
2313 # REF: http://bugs.php.net/bug.php?id=37166
2314 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2319 }
2321 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2323 /**
2324 * @param $matches array
2325 * @return mixed|string
2326 */
2329 }
2331 /**
2332 * @param $matches array
2333 * @return string
2334 */
2337 }
2339 /**
2340 * @param $matches array
2341 * @return string
2342 */
2346 }
2348 /**
2349 * @param $matches array
2350 * @return string
2351 */
2355 }
2357 /**
2358 * @param $matches array
2359 * @return string
2360 */
2363 }
2365 /**
2366 * @param $matches array
2367 * @return string
2368 */
2372 }
2374 /**
2375 * Make a string's first character uppercase
2376 *
2377 * @param $str string
2378 *
2379 * @return string
2380 */
2388 // fall back to more complex logic in case of multibyte strings
2390 }
2391 }
2393 /**
2394 * Convert a string to uppercase
2395 *
2396 * @param $str string
2397 * @param $first bool
2398 *
2399 * @return string
2400 */
2408 }
2411 }
2418 $str
2419 );
2422 }
2423 }
2424 }
2426 /**
2427 * @param $str string
2428 * @return mixed|string
2429 */
2441 }
2442 }
2444 /**
2445 * @param $str string
2446 * @param $first bool
2447 * @return mixed|string
2448 */
2456 }
2459 }
2466 $str
2467 );
2470 }
2471 }
2472 }
2474 /**
2475 * @param $str string
2476 * @return bool
2477 */
2480 }
2482 /**
2483 * @param $str string
2484 * @return mixed|string
2485 */
2490 // regexp to find first letter in each word (i.e. after each space)
2491 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2493 // function to use to capitalize a single char
2498 $str
2499 );
2504 $str
2505 );
2506 }
2509 }
2510 }
2512 /**
2513 * capitalize words at word breaks
2514 *
2515 * @param $str string
2516 * @return mixed
2517 */
2522 // since \b doesn't work for UTF-8, we explicitely define word break chars
2525 // find first letter after word break
2526 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2532 $str
2533 );
2538 $str
2539 );
2540 }
2545 $str
2546 );
2547 }
2548 }
2550 /**
2551 * Return a case-folded representation of $s
2552 *
2553 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2554 * and $s2 are the same except for the case of their characters. It is not
2555 * necessary for the value returned to make sense when displayed.
2556 *
2557 * Do *not* perform any other normalisation in this function. If a caller
2558 * uses this function when it should be using a more general normalisation
2559 * function, then fix the caller.
2560 *
2561 * @param $s string
2562 *
2563 * @return string
2564 */
2567 }
2569 /**
2570 * @param $s string
2571 * @return string
2572 */
2576 }
2579 }
2582 }
2584 /**
2585 * @return array
2586 */
2589 }
2591 /**
2592 * Most writing systems use whitespace to break up words.
2593 * Some languages such as Chinese don't conventionally do this,
2594 * which requires special handling when breaking up words for
2595 * searching etc.
2596 *
2597 * @return bool
2598 */
2601 }
2603 /**
2604 * Some languages such as Chinese require word segmentation,
2605 * Specify such segmentation when overridden in derived class.
2606 *
2607 * @param $string String
2608 * @return String
2609 */
2612 }
2614 /**
2615 * Some languages have special punctuation need to be normalized.
2616 * Make such changes here.
2617 *
2618 * @param $string String
2619 * @return String
2620 */
2623 }
2625 /**
2626 * convert double-width roman characters to single-width.
2627 * range: ff00-ff5f ~= 0020-007f
2628 *
2629 * @param $string string
2630 *
2631 * @return string
2632 */
2642 }
2646 }
2648 /**
2649 * @param $string string
2650 * @param $pattern string
2651 * @return string
2652 */
2657 }
2659 /**
2660 * @param $termsArray array
2661 * @return array
2662 */
2664 # some languages, e.g. Chinese, need to do a conversion
2665 # in order for search results to be displayed correctly
2667 }
2669 /**
2670 * Get the first character of a string.
2671 *
2672 * @param $s string
2673 * @return string
2674 */
2681 $matches
2682 );
2687 }
2689 // Break down Hangul syllables to grab the first jamo
2721 }
2724 }
2725 }
2728 # Some languages may have an alternate char encoding option
2729 # (Esperanto X-coding, Japanese furigana conversion, etc)
2730 # If this language is used as the primary content language,
2731 # an override to the defaults can be set here on startup.
2732 }
2734 /**
2735 * @param $s string
2736 * @return string
2737 */
2739 # For some languages we'll want to explicitly specify
2740 # which characters make it into the edit box raw
2741 # or are converted in some way or another.
2747 }
2748 }
2750 /**
2751 * @param $s string
2752 * @return string
2753 */
2755 # Take the previous into account.
2761 }
2766 }
2767 }
2769 /**
2770 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2771 * also cleans up certain backwards-compatible sequences, converting them
2772 * to the modern Unicode equivalent.
2773 *
2774 * This is language-specific for performance reasons only.
2775 *
2776 * @param $s string
2777 *
2778 * @return string
2779 */
2786 }
2789 }
2791 /**
2792 * Transform a string using serialized data stored in the given file (which
2793 * must be in the serialized subdirectory of $IP). The file contains pairs
2794 * mapping source characters to destination characters.
2795 *
2796 * The data is cached in process memory. This will go faster if you have the
2797 * FastStringSearch extension.
2798 *
2799 * @param $file string
2800 * @param $string string
2801 *
2802 * @throws MWException
2803 * @return string
2804 */
2810 }
2812 }
2814 }
2816 /**
2817 * For right-to-left language support
2818 *
2819 * @return bool
2820 */
2823 }
2825 /**
2826 * Return the correct HTML 'dir' attribute value for this language.
2827 * @return String
2828 */
2831 }
2833 /**
2834 * Return 'left' or 'right' as appropriate alignment for line-start
2835 * for this language's text direction.
2836 *
2837 * Should be equivalent to CSS3 'start' text-align value....
2838 *
2839 * @return String
2840 */
2843 }
2845 /**
2846 * Return 'right' or 'left' as appropriate alignment for line-end
2847 * for this language's text direction.
2848 *
2849 * Should be equivalent to CSS3 'end' text-align value....
2850 *
2851 * @return String
2852 */
2855 }
2857 /**
2858 * A hidden direction mark (LRM or RLM), depending on the language direction.
2859 * Unlike getDirMark(), this function returns the character as an HTML entity.
2860 * This function should be used when the output is guaranteed to be HTML,
2861 * because it makes the output HTML source code more readable. When
2862 * the output is plain text or can be escaped, getDirMark() should be used.
2863 *
2864 * @param $opposite Boolean Get the direction mark opposite to your language
2865 * @return string
2866 * @since 1.20
2867 */
2871 }
2873 }
2875 /**
2876 * A hidden direction mark (LRM or RLM), depending on the language direction.
2877 * This function produces them as invisible Unicode characters and
2878 * the output may be hard to read and debug, so it should only be used
2879 * when the output is plain text or can be escaped. When the output is
2880 * HTML, use getDirMarkEntity() instead.
2881 *
2882 * @param $opposite Boolean Get the direction mark opposite to your language
2883 * @return string
2884 */
2890 }
2892 }
2894 /**
2895 * @return array
2896 */
2899 }
2901 /**
2902 * An arrow, depending on the language direction.
2903 *
2904 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2905 * @return string
2906 */
2921 }
2922 }
2924 /**
2925 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2926 *
2927 * @return bool
2928 */
2931 }
2933 /**
2934 * @return array
2935 */
2938 }
2943 }
2948 }
2950 /**
2951 * Fill a MagicWord object with data from here
2952 *
2953 * @param $mw
2954 */
2966 }
2967 }
2974 }
2975 }
2977 /**
2978 * Add magic words to the extension array
2979 *
2980 * @param $newWords array
2981 */
2988 }
2989 }
2990 }
2992 /**
2993 * Get special page names, as an associative array
2994 * case folded alias => real name
2995 */
2997 // Cache aliases because it may be slow to load them
2999 // Initialise array
3004 }
3007 }
3009 /**
3010 * Italic is unsuitable for some languages
3011 *
3012 * @param $text String: the text to be emphasized.
3013 * @return string
3014 */
3017 }
3019 /**
3020 * Normally we output all numbers in plain en_US style, that is
3021 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3022 * point twohundredthirtyfive. However this is not suitable for all
3023 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
3024 * Icelandic just want to use commas instead of dots, and dots instead
3025 * of commas like "293.291,235".
3026 *
3027 * An example of this function being called:
3028 * <code>
3029 * wfMessage( 'message' )->numParams( $num )->text()
3030 * </code>
3031 *
3032 * See LanguageGu.php for the Gujarati implementation and
3033 * $separatorTransformTable on MessageIs.php for
3034 * the , => . and . => , implementation.
3035 *
3036 * @todo check if it's viable to use localeconv() for the decimal
3037 * separator thing.
3038 * @param $number Mixed: the string to be formatted, should be an integer
3039 * or a floating point number.
3040 * @param $nocommafy Bool: set to true for special numbers like dates
3041 * @return string
3042 */
3050 }
3051 }
3057 }
3058 }
3061 }
3063 /**
3064 * Front-end for non-commafied formatNum
3065 *
3066 * @param mixed $number the string to be formatted, should be an integer
3067 * or a floating point number.
3068 * @since 1.21
3069 * @return string
3070 */
3073 }
3075 /**
3076 * @param $number string
3077 * @return string
3078 */
3083 }
3088 }
3092 }
3094 /**
3095 * Adds commas to a given number
3096 * @since 1.19
3097 * @param $number mixed
3098 * @return string
3099 */
3104 }
3107 // default grouping is at thousands, use the same for ###,###,### pattern too.
3110 // Ref: http://cldr.unicode.org/translation/number-patterns
3113 // For negative numbers apply the algorithm like positive number and add sign.
3116 }
3124 // the string does not have any number part. Eg: .12345
3126 }
3134 }
3138 // use the last pattern for the rest of the number
3140 }
3143 }
3144 }
3146 }
3147 }
3149 /**
3150 * @return String
3151 */
3154 }
3156 /**
3157 * @return array
3158 */
3161 }
3163 /**
3164 * @return array
3165 */
3168 }
3170 /**
3171 * Take a list of strings and build a locale-friendly comma-separated
3172 * list, using the local comma-separator message.
3173 * The last two strings are chained with an "and".
3174 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3175 *
3176 * @param $l Array
3177 * @return string
3178 */
3183 }
3189 }
3190 }
3197 }
3198 }
3200 }
3202 /**
3203 * Take a list of strings and build a locale-friendly comma-separated
3204 * list, using the local comma-separator message.
3205 * @param $list array of strings to put in a comma list
3206 * @return string
3207 */
3211 $list
3212 );
3213 }
3215 /**
3216 * Take a list of strings and build a locale-friendly semicolon-separated
3217 * list, using the local semicolon-separator message.
3218 * @param $list array of strings to put in a semicolon list
3219 * @return string
3220 */
3224 $list
3225 );
3226 }
3228 /**
3229 * Same as commaList, but separate it with the pipe instead.
3230 * @param $list array of strings to put in a pipe list
3231 * @return string
3232 */
3236 $list
3237 );
3238 }
3240 /**
3241 * Truncate a string to a specified length in bytes, appending an optional
3242 * string (e.g. for ellipses)
3243 *
3244 * The database offers limited byte lengths for some columns in the database;
3245 * multi-byte character sets mean we need to ensure that only whole characters
3246 * are included, otherwise broken characters can be passed to the user
3247 *
3248 * If $length is negative, the string will be truncated from the beginning
3249 *
3250 * @param $string String to truncate
3251 * @param $length Int: maximum length (including ellipses)
3252 * @param $ellipsis String to append to the truncated text
3253 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3254 * $adjustLength was introduced in 1.18, before that behaved as if false.
3255 * @return string
3256 */
3258 # Use the localized ellipsis character
3261 }
3262 # Check if there is no need to truncate
3267 }
3269 # If ellipsis length is >= $length then we can't apply $adjustLength
3272 # Otherwise, truncate and add ellipsis...
3285 }
3286 }
3287 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3288 # This check is *not* redundant if $adjustLength, due to the single case where
3289 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3294 }
3295 }
3297 /**
3298 * Remove bytes that represent an incomplete Unicode character
3299 * at the end of string (e.g. bytes of the char are missing)
3300 *
3301 * @param $string String
3302 * @return string
3303 */
3309 # We got the first byte only of a multibyte char; remove it.
3314 ) {
3315 # We chopped in the middle of a character; remove it
3317 }
3318 }
3320 }
3322 /**
3323 * Remove bytes that represent an incomplete Unicode character
3324 * at the start of string (e.g. bytes of the char are missing)
3325 *
3326 * @param $string String
3327 * @return string
3328 */
3333 # We chopped in the middle of a character; remove the whole thing
3335 }
3336 }
3338 }
3340 /**
3341 * Truncate a string of valid HTML to a specified length in bytes,
3342 * appending an optional string (e.g. for ellipses), and return valid HTML
3343 *
3344 * This is only intended for styled/linked text, such as HTML with
3345 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3346 * Also, this will not detect things like "display:none" CSS.
3347 *
3348 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3349 *
3350 * @param string $text HTML string to truncate
3351 * @param int $length (zero/positive) Maximum length (including ellipses)
3352 * @param string $ellipsis String to append to the truncated text
3353 * @return string
3354 */
3356 # Use the localized ellipsis character
3359 }
3360 # Check if there is clearly no need to truncate
3365 }
3379 # Consider truncation once the display length has reached the maximim.
3380 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3381 # Check that we're not in the middle of a bracket/entity...
3385 # Save where we are; we will truncate here unless there turn out to
3386 # be so few remaining characters that truncation is not necessary.
3389 }
3391 # String in fact does need truncation, the truncation point was OK.
3396 }
3397 }
3400 }
3402 # Read the next char...
3420 }
3426 // Name found (e.g. "<a href=..."), add on tag attributes...
3428 }
3434 }
3437 // Save state without $ch. We want to *hit* the first
3438 // display char (to get tags) but not *use* it if truncating.
3440 }
3445 // Add the next $max display text chars after this in one swoop...
3450 }
3451 }
3452 }
3453 }
3454 // Close the last tag if left unclosed by bad HTML
3458 }
3460 }
3462 /**
3463 * truncateHtml() helper function
3464 * like strcspn() but adds the skipped chars to $ret
3465 *
3466 * @param $ret
3467 * @param $text
3468 * @param $search
3469 * @param $start
3470 * @param $len
3471 * @return int
3472 */
3478 }
3483 }
3485 }
3487 /**
3488 * truncateHtml() helper function
3489 * (a) push or pop $tag from $openTags as needed
3490 * (b) clear $tag value
3491 * @param &$tag string Current HTML tag name we are looking at
3492 * @param $tagType int (0-open tag, 1-close tag)
3493 * @param $lastCh string Character before the '>' that ended this tag
3494 * @param &$openTags array Open tag stack (not accounting for $tag)
3495 */
3504 }
3505 }
3507 }
3508 }
3510 /**
3511 * Grammatical transformations, needed for inflected languages
3512 * Invoked by putting {{grammar:case|word}} in a message
3513 *
3514 * @param $word string
3515 * @param $case string
3516 * @return string
3517 */
3522 }
3524 }
3525 /**
3526 * Get the grammar forms for the content language
3527 * @return array of grammar forms
3528 * @since 1.20
3529 */
3532 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3534 }
3536 }
3537 /**
3538 * Provides an alternative text depending on specified gender.
3539 * Usage {{gender:username|masculine|feminine|neutral}}.
3540 * username is optional, in which case the gender of current user is used,
3541 * but only in (some) interface messages; otherwise default gender is used.
3542 *
3543 * If no forms are given, an empty string is returned. If only one form is
3544 * given, it will be returned unconditionally. These details are implied by
3545 * the caller and cannot be overridden in subclasses.
3546 *
3547 * If more than one form is given, the default is to use the neutral one
3548 * if it is specified, and to use the masculine one otherwise. These
3549 * details can be overridden in subclasses.
3550 *
3551 * @param $gender string
3552 * @param $forms array
3553 *
3554 * @return string
3555 */
3559 }
3563 }
3566 }
3568 }
3570 /**
3571 * Plural form transformations, needed for some languages.
3572 * For example, there are 3 form of plural in Russian and Polish,
3573 * depending on "count mod 10". See [[w:Plural]]
3574 * For English it is pretty simple.
3575 *
3576 * Invoked by putting {{plural:count|wordform1|wordform2}}
3577 * or {{plural:count|wordform1|wordform2|wordform3}}
3578 *
3579 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3580 *
3581 * @param $count Integer: non-localized number
3582 * @param $forms Array: different plural forms
3583 * @return string Correct form of plural for $count in this language
3584 */
3588 }
3590 // Handle explicit n=pluralform cases
3596 }
3598 }
3599 }
3605 }
3607 /**
3608 * Checks that convertPlural was given an array and pads it to requested
3609 * amount of forms by copying the last one.
3610 *
3611 * @param $count Integer: How many forms should there be at least
3612 * @param $forms Array of forms given to convertPlural
3613 * @return array Padded array of forms or an exception if not an array
3614 */
3618 }
3620 }
3622 /**
3623 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3624 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3625 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3626 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3627 * match up with it.
3628 *
3629 * @param $str String: the validated block duration in English
3630 * @return string Somehow translated block duration
3631 * @see LanguageFi.php for example implementation
3632 */
3638 }
3639 }
3641 // Since usually only infinite or indefinite is only on list, so try
3642 // equivalents if still here.
3649 }
3650 }
3651 }
3653 // If all else fails, return a standard duration or timestamp description.
3658 // $time is relative to 0 so it's a duration length.
3662 // wfTimestamp() handles 0 as current time instead of epoch.
3666 }
3667 }
3668 }
3670 /**
3671 * languages like Chinese need to be segmented in order for the diff
3672 * to be of any use
3673 *
3674 * @param $text String
3675 * @return String
3676 */
3679 }
3681 /**
3682 * and unsegment to show the result
3683 *
3684 * @param $text String
3685 * @return String
3686 */
3689 }
3691 /**
3692 * Return the LanguageConverter used in the Language
3693 *
3694 * @since 1.19
3695 * @return LanguageConverter
3696 */
3699 }
3701 /**
3702 * convert text to all supported variants
3703 *
3704 * @param $text string
3705 * @return array
3706 */
3709 }
3711 /**
3712 * convert text to different variants of a language.
3713 *
3714 * @param $text string
3715 * @return string
3716 */
3719 }
3721 /**
3722 * Convert a Title object to a string in the preferred variant
3723 *
3724 * @param $title Title
3725 * @return string
3726 */
3729 }
3731 /**
3732 * Convert a namespace index to a string in the preferred variant
3733 *
3734 * @param $ns int
3735 * @return string
3736 */
3739 }
3741 /**
3742 * Check if this is a language with variants
3743 *
3744 * @return bool
3745 */
3748 }
3750 /**
3751 * Check if the language has the specific variant
3752 *
3753 * @since 1.19
3754 * @param $variant string
3755 * @return bool
3756 */
3759 }
3761 /**
3762 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3763 *
3764 * @param $text string
3765 * @return string
3766 */
3769 }
3771 /**
3772 * Perform output conversion on a string, and encode for safe HTML output.
3773 * @param $text String text to be converted
3774 * @param $isTitle Bool whether this conversion is for the article title
3775 * @return string
3776 * @todo this should get integrated somewhere sane
3777 */
3780 }
3782 /**
3783 * @param $key string
3784 * @return string
3785 */
3788 }
3790 /**
3791 * Get the list of variants supported by this language
3792 * see sample implementation in LanguageZh.php
3793 *
3794 * @return array an array of language codes
3795 */
3798 }
3800 /**
3801 * @return string
3802 */
3805 }
3807 /**
3808 * @return string
3809 */
3812 }
3814 /**
3815 * @return string
3816 */
3819 }
3821 /**
3822 * If a language supports multiple variants, it is
3823 * possible that non-existing link in one variant
3824 * actually exists in another variant. this function
3825 * tries to find it. See e.g. LanguageZh.php
3826 *
3827 * @param $link String: the name of the link
3828 * @param $nt Mixed: the title object of the link
3829 * @param $ignoreOtherCond Boolean: to disable other conditions when
3830 * we need to transclude a template or update a category's link
3831 * @return null the input parameters may be modified upon return
3832 */
3835 }
3837 /**
3838 * If a language supports multiple variants, converts text
3839 * into an array of all possible variants of the text:
3840 * 'variant' => text in that variant
3841 *
3842 * @deprecated since 1.17 Use autoConvertToAllVariants()
3843 *
3844 * @param $text string
3845 *
3846 * @return string
3847 */
3850 }
3852 /**
3853 * returns language specific options used by User::getPageRenderHash()
3854 * for example, the preferred language variant
3855 *
3856 * @return string
3857 */
3860 }
3862 /**
3863 * For languages that support multiple variants, the title of an
3864 * article may be displayed differently in different variants. this
3865 * function returns the apporiate title defined in the body of the article.
3866 *
3867 * @return string
3868 */
3871 }
3873 /**
3874 * Prepare external link text for conversion. When the text is
3875 * a URL, it shouldn't be converted, and it'll be wrapped in
3876 * the "raw" tag (-{R| }-) to prevent conversion.
3877 *
3878 * This function is called "markNoConversion" for historical
3879 * reasons.
3880 *
3881 * @param $text String: text to be used for external link
3882 * @param $noParse bool: wrap it without confirming it's a real URL first
3883 * @return string the tagged text
3884 */
3886 // Excluding protocal-relative URLs may avoid many false positives.
3891 }
3892 }
3894 /**
3895 * A regular expression to match legal word-trailing characters
3896 * which should be merged onto a link of the form [[foo]]bar.
3897 *
3898 * @return string
3899 */
3902 }
3904 /**
3905 * @return Language
3906 */
3909 }
3911 /**
3912 * Get the RFC 3066 code for this language object
3913 *
3914 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3915 * htmlspecialchars() or similar
3916 *
3917 * @return string
3918 */
3921 }
3923 /**
3924 * Get the code in Bcp47 format which we can use
3925 * inside of html lang="" tags.
3926 *
3927 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3928 * htmlspecialchars() or similar.
3929 *
3930 * @since 1.19
3931 * @return string
3932 */
3936 }
3938 }
3940 /**
3941 * @param $code string
3942 */
3945 // Ensure we don't leave an incorrect html code lying around
3947 }
3949 /**
3950 * Get the name of a file for a certain language code
3951 * @param $prefix string Prepend this to the filename
3952 * @param $code string Language code
3953 * @param $suffix string Append this to the filename
3954 * @throws MWException
3955 * @return string $prefix . $mangledCode . $suffix
3956 */
3958 // Protect against path traversal
3961 {
3963 }
3966 }
3968 /**
3969 * Get the language code from a file name. Inverse of getFileName()
3970 * @param $filename string $prefix . $languageCode . $suffix
3971 * @param $prefix string Prefix before the language code
3972 * @param $suffix string Suffix after the language code
3973 * @return string Language code, or false if $prefix or $suffix isn't found
3974 */
3975 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3981 }
3983 }
3985 /**
3986 * @param $code string
3987 * @return string
3988 */
3994 }
3996 /**
3997 * @param $code string
3998 * @return string
3999 */
4003 }
4005 /**
4006 * Get the first fallback for a given language.
4007 *
4008 * @param $code string
4009 *
4010 * @return bool|string
4011 */
4019 }
4020 }
4022 /**
4023 * Get the ordered list of fallback languages.
4024 *
4025 * @since 1.19
4026 * @param $code string Language code
4027 * @return array
4028 */
4037 }
4039 }
4040 }
4042 /**
4043 * Get all messages for a given language
4044 * WARNING: this may take a long time. If you just need all message *keys*
4045 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4046 *
4047 * @param $code string
4048 *
4049 * @return array
4050 */
4053 }
4055 /**
4056 * Get a message for a given language
4057 *
4058 * @param $key string
4059 * @param $code string
4060 *
4061 * @return string
4062 */
4065 }
4067 /**
4068 * Get all message keys for a given language. This is a faster alternative to
4069 * array_keys( Language::getMessagesFor( $code ) )
4070 *
4071 * @since 1.19
4072 * @param $code string Language code
4073 * @return array of message keys (strings)
4074 */
4077 }
4079 /**
4080 * @param $talk
4081 * @return mixed
4082 */
4086 }
4091 # Allow grammar transformations
4092 # Allowing full message-style parsing would make simple requests
4093 # such as action=raw much more expensive than they need to be.
4094 # This will hopefully cover most cases.
4098 }
4100 /**
4101 * @param $m string
4102 * @return string
4103 */
4106 }
4108 /**
4109 * @throws MWException
4110 * @return array
4111 */
4116 }
4123 }
4128 }
4130 /**
4131 * Decode an expiry (block, protection, etc) which has come from the DB
4132 *
4133 * @todo FIXME: why are we returnings DBMS-dependent strings???
4134 *
4135 * @param $expiry String: Database expiry String
4136 * @param $format Bool|Int true to process using language functions, or TS_ constant
4137 * to return the expiry in a given timestamp
4138 * @return String
4139 * @since 1.18
4140 */
4146 }
4150 ? $infinityMsg
4156 }
4157 }
4159 /**
4160 * @todo Document
4161 * @param $seconds int|float
4162 * @param $format Array Optional
4163 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4164 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4165 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4166 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4167 * @return string
4168 */
4172 }
4175 }
4178 }
4200 }
4211 }
4215 }
4221 }
4229 }
4239 }
4243 }
4253 }
4254 }
4256 }
4258 /**
4259 * Format a bitrate for output, using an appropriate
4260 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4261 *
4262 * This use base 1000. For base 1024 use formatSize(), for another base
4263 * see formatComputingNumbers()
4264 *
4265 * @param $bps int
4266 * @return string
4267 */
4270 }
4272 /**
4273 * @param $size int Size of the unit
4274 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4275 * @param $messageKey string Message key to be uesd
4276 * @return string
4277 */
4282 );
4283 }
4291 }
4293 // For small sizes no decimal places necessary
4296 // For MB and bigger two decimal places are smarter
4298 }
4304 }
4306 /**
4307 * Format a size in bytes for output, using an appropriate
4308 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4309 *
4310 * This method use base 1024. For base 1000 use formatBitrate(), for
4311 * another base see formatComputingNumbers()
4312 *
4313 * @param $size int Size to format
4314 * @return string Plain text (not HTML)
4315 */
4318 }
4320 /**
4321 * Make a list item, used by various special pages
4322 *
4323 * @param $page String Page link
4324 * @param $details String Text between brackets
4325 * @param $oppositedm Boolean Add the direction mark opposite to your
4326 * language, to display text properly
4327 * @return String
4328 */
4335 }
4337 /**
4338 * Generate (prev x| next x) (20|50|100...) type links for paging
4339 *
4340 * @param $title Title object to link
4341 * @param $offset Integer offset parameter
4342 * @param $limit Integer limit parameter
4343 * @param $query array|String optional URL query parameter string
4344 * @param $atend Bool optional param for specified if this is the last page
4345 * @return String
4346 */
4347 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4348 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4350 # Make 'previous' link
4351 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4357 }
4359 # Make 'next' link
4360 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4366 }
4368 # Make links to set number of items per page
4373 }
4377 }
4379 /**
4380 * Helper function for viewPrevNext() that generates links
4381 *
4382 * @param $title Title object to link
4383 * @param $offset Integer offset parameter
4384 * @param $limit Integer limit parameter
4385 * @param $query Array extra query parameters
4386 * @param $link String text to use for the link; will be escaped
4387 * @param $tooltipMsg String name of the message to use as tooltip
4388 * @param $class String value of the "class" attribute of the link
4389 * @return String HTML fragment
4390 */
4391 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4393 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4396 }
4398 /**
4399 * Get the conversion rule title, if any.
4400 *
4401 * @return string
4402 */
4405 }
4407 /**
4408 * Get the compiled plural rules for the language
4409 * @since 1.20
4410 * @return array Associative array with plural form, and plural rule as key-value pairs
4411 */
4417 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4420 }
4421 }
4422 }
4424 }
4426 /**
4427 * Get the plural rules for the language
4428 * @since 1.20
4429 * @return array Associative array with plural form number and plural rule as key-value pairs
4430 */
4439 }
4440 }
4441 }
4443 }
4445 /**
4446 * Get the plural rule types for the language
4447 * @since 1.21
4448 * @return array Associative array with plural form number and plural rule type as key-value pairs
4449 */
4455 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4458 }
4459 }
4460 }
4462 }
4464 /**
4465 * Find the index number of the plural rule appropriate for the given number
4466 * @return int The index number of the plural rule
4467 */
4472 }
4474 /**
4475 * Find the plural rule type appropriate for the given number
4476 * For example, if the language is set to Arabic, getPluralType(5) should
4477 * return 'few'.
4478 * @since 1.21
4479 * @return string The name of the plural rule type, e.g. one, two, few, many
4480 */
4488 }
4489 }
4490 }