| blob | b9201d7ed4c738b0be96a1a00963df3e5b54263e |
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 * @throws MWException
1082 * @return string
1083 */
1100 }
1104 }
1111 }
1113 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1115 }
1139 }
1149 );
1150 }
1159 }
1165 }
1171 }
1178 );
1179 }
1188 }
1194 }
1200 }
1215 }
1221 }
1227 }
1233 }
1242 }
1248 }
1254 }
1260 }
1266 }
1272 }
1281 }
1316 // Pass through string from $dateTimeObj->format()
1320 );
1321 }
1334 // Pass through number from $dateTimeObj->format()
1338 );
1339 }
1343 # Backslash escaping
1348 }
1351 # Quoted literal
1355 # No terminating quote, assume literal "
1360 }
1362 # Quote at end of string, assume literal "
1364 }
1368 }
1381 }
1382 }
1383 }
1385 }
1390 /**
1391 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1392 * Gregorian dates to Iranian dates. Originally written in C, it
1393 * is released under the terms of GNU Lesser General Public
1394 * License. Conversion to PHP was performed by Niklas Laxström.
1395 *
1396 * Link: http://www.farsiweb.info/jalali/jalali.c
1397 *
1398 * @param $ts string
1399 *
1400 * @return string
1401 */
1407 # Days passed from the beginning (including leap years)
1413 // Add days of the past months of this year
1416 }
1418 // Leap years
1421 }
1423 // Days passed in current month
1437 }
1441 }
1447 }
1449 /**
1450 * Converting Gregorian dates to Hijri dates.
1451 *
1452 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1453 *
1454 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1455 *
1456 * @param $ts string
1457 *
1458 * @return string
1459 */
1473 )
1474 {
1482 }
1487 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1488 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1494 }
1496 /**
1497 * Converting Gregorian dates to Hebrew dates.
1498 *
1499 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1500 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1501 * to translate the relevant functions into PHP and release them under
1502 * GNU GPL.
1503 *
1504 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1505 * and Adar II is 14. In a non-leap year, Adar is 6.
1506 *
1507 * @param $ts string
1508 *
1509 * @return string
1510 */
1512 # Parse date
1517 # Calculate Hebrew year
1520 # Month number when September = 1, August = 12
1523 # Next year
1527 }
1529 # Calculate day of year from 1 September
1533 # February
1535 # Check if the year is leap
1538 }
1543 }
1544 }
1546 # Calculate the start of the Hebrew year
1549 # Calculate next year's start
1551 # Day is before the start of the year - it is the previous year
1552 # Next year's start
1554 # Previous year
1557 # Add days since previous year's 1 September
1560 # Leap year
1562 }
1563 # Start of the new (previous) year
1566 # Next year's start
1568 }
1570 # Calculate Hebrew day of year
1573 # Difference between year's days
1575 # Add 12 (or 13 for leap years) days to ignore the difference between
1576 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1577 # difference is only about the year type
1582 }
1584 # Check the year pattern, and is leap year
1585 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1586 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1587 # and non-leap years
1589 # Check if leap year
1592 # Calculate day in the month from number of day in the Hebrew year
1593 # Don't check Adar - if the day is not in Adar, we will stop before;
1594 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1599 # Calculate days in this month
1601 # Adar in a leap year
1603 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1606 # Day in Adar I
1609 # Subtract the days of Adar I
1611 # Try Adar II
1614 # Day in Adar II
1616 }
1617 }
1618 }
1620 # Cheshvan in a complete year (otherwise as the rule below)
1623 # Kislev in an incomplete year (otherwise as the rule below)
1626 # Odd months have 30 days, even have 29
1628 }
1630 # In the current month
1633 # Subtract the days of the current month
1635 # Try in the next month
1637 }
1638 }
1641 }
1643 /**
1644 * This calculates the Hebrew year start, as days since 1 September.
1645 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1646 * Used for Hebrew date.
1647 *
1648 * @param $year int
1649 *
1650 * @return string
1651 */
1658 }
1662 }
1672 }
1676 }
1678 /**
1679 * Algorithm to convert Gregorian dates to Thai solar dates,
1680 * Minguo dates or Minguo dates.
1681 *
1682 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1683 * http://en.wikipedia.org/wiki/Minguo_calendar
1684 * http://en.wikipedia.org/wiki/Japanese_era_name
1685 *
1686 * @param $ts String: 14-character timestamp
1687 * @param $cName String: calender name
1688 * @return Array: converted year, month, day
1689 */
1696 # Thai solar dates
1697 # Add 543 years to the Gregorian calendar
1698 # Months and days are identical
1701 # Minguo dates
1702 # Deduct 1911 years from the Gregorian calendar
1703 # Months and days are identical
1706 # Nengō dates up to Meiji period
1707 # Deduct years from the Gregorian calendar
1708 # depending on the nengo periods
1709 # Months and days are identical
1710 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1711 # Meiji period
1716 }
1724 )
1725 {
1726 # Taishō period
1731 }
1737 )
1738 {
1739 # Shōwa period
1744 }
1747 # Heisei period
1752 }
1754 }
1757 }
1760 }
1762 /**
1763 * Roman number formatting up to 10000
1764 *
1765 * @param $num int
1766 *
1767 * @return string
1768 */
1774 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1775 );
1780 }
1786 }
1788 }
1790 }
1792 /**
1793 * Hebrew Gematria number formatting up to 9999
1794 *
1795 * @param $num int
1796 *
1797 * @return string
1798 */
1805 );
1810 }
1822 }
1823 }
1824 }
1826 }
1832 }
1851 }
1853 }
1855 /**
1856 * Used by date() and time() to adjust the time output.
1857 *
1858 * @param $ts Int the time in date('YmdHis') format
1859 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1860 * get user timecorrection setting)
1861 * @return int
1862 */
1868 }
1881 }
1882 # Unrecognized timezone, default to 'Offset' with the stored offset.
1884 }
1888 # Global offset in minutes.
1891 }
1902 }
1905 }
1906 }
1908 # No difference ? Return time unchanged
1911 }
1914 # Generate an adjusted date; take advantage of the fact that mktime
1915 # will normalize out-of-range values so we don't have to split $minDiff
1916 # into hours and minutes.
1929 }
1931 /**
1932 * This is meant to be used by time(), date(), and timeanddate() to get
1933 * the date preference they're supposed to use, it should be used in
1934 * all children.
1935 *
1936 *<code>
1937 * function timeanddate([...], $format = true) {
1938 * $datePreference = $this->dateFormat($format);
1939 * [...]
1940 * }
1941 *</code>
1942 *
1943 * @param $usePrefs Mixed: if true, the user's preference is used
1944 * if false, the site/language default is used
1945 * if int/string, assumed to be a format.
1946 * @return string
1947 */
1956 }
1959 }
1961 // return int
1964 }
1967 }
1969 /**
1970 * Get a format string for a given type and preference
1971 * @param $type string May be date, time or both
1972 * @param $pref string The format name as it appears in Messages*.php
1973 *
1974 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
1975 *
1976 * @return string
1977 */
1988 }
1993 }
1994 }
1996 }
1998 }
2000 /**
2001 * @param $ts Mixed: the time format which needs to be turned into a
2002 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2003 * @param $adj Bool: whether to adjust the time output according to the
2004 * user configured offset ($timecorrection)
2005 * @param $format Mixed: true to use user's date format preference
2006 * @param $timecorrection String|bool the time offset as returned by
2007 * validateTimeZone() in Special:Preferences
2008 * @return string
2009 */
2014 }
2017 }
2019 /**
2020 * @param $ts Mixed: the time format which needs to be turned into a
2021 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2022 * @param $adj Bool: whether to adjust the time output according to the
2023 * user configured offset ($timecorrection)
2024 * @param $format Mixed: true to use user's date format preference
2025 * @param $timecorrection String|bool the time offset as returned by
2026 * validateTimeZone() in Special:Preferences
2027 * @return string
2028 */
2033 }
2036 }
2038 /**
2039 * @param $ts Mixed: the time format which needs to be turned into a
2040 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2041 * @param $adj Bool: whether to adjust the time output according to the
2042 * user configured offset ($timecorrection)
2043 * @param $format Mixed: what format to return, if it's false output the
2044 * default one (default true)
2045 * @param $timecorrection String|bool the time offset as returned by
2046 * validateTimeZone() in Special:Preferences
2047 * @return string
2048 */
2053 }
2056 }
2058 /**
2059 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2060 *
2061 * @since 1.20
2062 *
2063 * @param integer $seconds The amount of seconds.
2064 * @param array $chosenIntervals The intervals to enable.
2065 *
2066 * @return string
2067 */
2076 }
2079 }
2081 /**
2082 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2083 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2084 *
2085 * @since 1.20
2086 *
2087 * @param integer $seconds The amount of seconds.
2088 * @param array $chosenIntervals The intervals to enable.
2089 *
2090 * @return array
2091 */
2094 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2095 }
2109 }
2110 }
2113 }
2115 /**
2116 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2117 *
2118 * @param $type String: can be 'date', 'time' or 'both'
2119 * @param $ts Mixed: the time format which needs to be turned into a
2120 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2121 * @param $user User object used to get preferences for timezone and format
2122 * @param $options Array, can contain the following keys:
2123 * - 'timecorrection': time correction, can have the following values:
2124 * - true: use user's preference
2125 * - false: don't use time correction
2126 * - integer: value of time correction in minutes
2127 * - 'format': format to use, can have the following values:
2128 * - true: use user's preference
2129 * - false: use default preference
2130 * - string: format to use
2131 * @since 1.19
2132 * @return String
2133 */
2142 }
2144 }
2149 }
2152 }
2154 /**
2155 * Get the formatted date for the given timestamp and formatted for
2156 * the given user.
2157 *
2158 * @param $ts Mixed: the time format which needs to be turned into a
2159 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2160 * @param $user User object used to get preferences for timezone and format
2161 * @param $options Array, can contain the following keys:
2162 * - 'timecorrection': time correction, can have the following values:
2163 * - true: use user's preference
2164 * - false: don't use time correction
2165 * - integer: value of time correction in minutes
2166 * - 'format': format to use, can have the following values:
2167 * - true: use user's preference
2168 * - false: use default preference
2169 * - string: format to use
2170 * @since 1.19
2171 * @return String
2172 */
2175 }
2177 /**
2178 * Get the formatted time for the given timestamp and formatted for
2179 * the given user.
2180 *
2181 * @param $ts Mixed: the time format which needs to be turned into a
2182 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2183 * @param $user User object used to get preferences for timezone and format
2184 * @param $options Array, can contain the following keys:
2185 * - 'timecorrection': time correction, can have the following values:
2186 * - true: use user's preference
2187 * - false: don't use time correction
2188 * - integer: value of time correction in minutes
2189 * - 'format': format to use, can have the following values:
2190 * - true: use user's preference
2191 * - false: use default preference
2192 * - string: format to use
2193 * @since 1.19
2194 * @return String
2195 */
2198 }
2200 /**
2201 * Get the formatted date and time for the given timestamp and formatted for
2202 * the given user.
2203 *
2204 * @param $ts Mixed: the time format which needs to be turned into a
2205 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2206 * @param $user User object used to get preferences for timezone and format
2207 * @param $options Array, can contain the following keys:
2208 * - 'timecorrection': time correction, can have the following values:
2209 * - true: use user's preference
2210 * - false: don't use time correction
2211 * - integer: value of time correction in minutes
2212 * - 'format': format to use, can have the following values:
2213 * - true: use user's preference
2214 * - false: use default preference
2215 * - string: format to use
2216 * @since 1.19
2217 * @return String
2218 */
2221 }
2223 /**
2224 * Convert an MWTimestamp into a pretty human-readable timestamp using
2225 * the given user preferences and relative base time.
2226 *
2227 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2228 * on your timestamp object, which will then call this function. Calling
2229 * this function directly will cause hooks to be skipped over.
2230 *
2231 * @see MWTimestamp::getHumanTimestamp
2232 * @param MWTimestamp $ts Timestamp to prettify
2233 * @param MWTimestamp $relativeTo Base timestamp
2234 * @param User $user User preferences to use
2235 * @return string Human timestamp
2236 * @since 1.21
2237 */
2240 $diffDay = (bool)( (int)$ts->timestamp->format( 'w' ) - (int)$relativeTo->timestamp->format( 'w' ) );
2242 if ( $diff->invert || $days > 5 && $ts->timestamp->format( 'Y' ) !== $relativeTo->timestamp->format( 'Y' ) ) {
2243 // Timestamps are in different years: use full timestamp
2244 // Also do full timestamp for future dates
2245 /**
2246 * @FIXME Add better handling of future timestamps.
2247 */
2251 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2255 // Timestamp within the past week: show the day of the week and time
2263 // Timestamp was yesterday: say 'yesterday' and the time.
2270 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2277 // From here on in, the timestamp was soon enough ago so that we can simply say
2278 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2280 // Less than 90 minutes, but more than an hour ago.
2283 // A few minutes ago.
2286 // Less than a minute, but more than 30 sec ago.
2289 // Less than 30 seconds ago.
2291 }
2294 }
2296 /**
2297 * @param $key string
2298 * @return array|null
2299 */
2302 }
2304 /**
2305 * @return array
2306 */
2309 }
2311 /**
2312 * @param $in
2313 * @param $out
2314 * @param $string
2315 * @return string
2316 */
2318 # This is a wrapper for iconv in all languages except esperanto,
2319 # which does some nasty x-conversions beforehand
2321 # Even with //IGNORE iconv can whine about illegal characters in
2322 # *input* string. We just ignore those too.
2323 # REF: http://bugs.php.net/bug.php?id=37166
2324 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2329 }
2331 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2333 /**
2334 * @param $matches array
2335 * @return mixed|string
2336 */
2339 }
2341 /**
2342 * @param $matches array
2343 * @return string
2344 */
2347 }
2349 /**
2350 * @param $matches array
2351 * @return string
2352 */
2356 }
2358 /**
2359 * @param $matches array
2360 * @return string
2361 */
2365 }
2367 /**
2368 * @param $matches array
2369 * @return string
2370 */
2373 }
2375 /**
2376 * @param $matches array
2377 * @return string
2378 */
2382 }
2384 /**
2385 * Make a string's first character uppercase
2386 *
2387 * @param $str string
2388 *
2389 * @return string
2390 */
2398 // fall back to more complex logic in case of multibyte strings
2400 }
2401 }
2403 /**
2404 * Convert a string to uppercase
2405 *
2406 * @param $str string
2407 * @param $first bool
2408 *
2409 * @return string
2410 */
2418 }
2421 }
2428 $str
2429 );
2432 }
2433 }
2434 }
2436 /**
2437 * @param $str string
2438 * @return mixed|string
2439 */
2451 }
2452 }
2454 /**
2455 * @param $str string
2456 * @param $first bool
2457 * @return mixed|string
2458 */
2466 }
2469 }
2476 $str
2477 );
2480 }
2481 }
2482 }
2484 /**
2485 * @param $str string
2486 * @return bool
2487 */
2490 }
2492 /**
2493 * @param $str string
2494 * @return mixed|string
2495 */
2500 // regexp to find first letter in each word (i.e. after each space)
2501 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2503 // function to use to capitalize a single char
2508 $str
2509 );
2514 $str
2515 );
2516 }
2519 }
2520 }
2522 /**
2523 * capitalize words at word breaks
2524 *
2525 * @param $str string
2526 * @return mixed
2527 */
2532 // since \b doesn't work for UTF-8, we explicitely define word break chars
2535 // find first letter after word break
2536 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2542 $str
2543 );
2548 $str
2549 );
2550 }
2555 $str
2556 );
2557 }
2558 }
2560 /**
2561 * Return a case-folded representation of $s
2562 *
2563 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2564 * and $s2 are the same except for the case of their characters. It is not
2565 * necessary for the value returned to make sense when displayed.
2566 *
2567 * Do *not* perform any other normalisation in this function. If a caller
2568 * uses this function when it should be using a more general normalisation
2569 * function, then fix the caller.
2570 *
2571 * @param $s string
2572 *
2573 * @return string
2574 */
2577 }
2579 /**
2580 * @param $s string
2581 * @return string
2582 */
2586 }
2589 }
2592 }
2594 /**
2595 * @return array
2596 */
2599 }
2601 /**
2602 * Most writing systems use whitespace to break up words.
2603 * Some languages such as Chinese don't conventionally do this,
2604 * which requires special handling when breaking up words for
2605 * searching etc.
2606 *
2607 * @return bool
2608 */
2611 }
2613 /**
2614 * Some languages such as Chinese require word segmentation,
2615 * Specify such segmentation when overridden in derived class.
2616 *
2617 * @param $string String
2618 * @return String
2619 */
2622 }
2624 /**
2625 * Some languages have special punctuation need to be normalized.
2626 * Make such changes here.
2627 *
2628 * @param $string String
2629 * @return String
2630 */
2633 }
2635 /**
2636 * convert double-width roman characters to single-width.
2637 * range: ff00-ff5f ~= 0020-007f
2638 *
2639 * @param $string string
2640 *
2641 * @return string
2642 */
2652 }
2656 }
2658 /**
2659 * @param $string string
2660 * @param $pattern string
2661 * @return string
2662 */
2667 }
2669 /**
2670 * @param $termsArray array
2671 * @return array
2672 */
2674 # some languages, e.g. Chinese, need to do a conversion
2675 # in order for search results to be displayed correctly
2677 }
2679 /**
2680 * Get the first character of a string.
2681 *
2682 * @param $s string
2683 * @return string
2684 */
2691 $matches
2692 );
2697 }
2699 // Break down Hangul syllables to grab the first jamo
2731 }
2734 }
2735 }
2738 # Some languages may have an alternate char encoding option
2739 # (Esperanto X-coding, Japanese furigana conversion, etc)
2740 # If this language is used as the primary content language,
2741 # an override to the defaults can be set here on startup.
2742 }
2744 /**
2745 * @param $s string
2746 * @return string
2747 */
2749 # For some languages we'll want to explicitly specify
2750 # which characters make it into the edit box raw
2751 # or are converted in some way or another.
2757 }
2758 }
2760 /**
2761 * @param $s string
2762 * @return string
2763 */
2765 # Take the previous into account.
2771 }
2776 }
2777 }
2779 /**
2780 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2781 * also cleans up certain backwards-compatible sequences, converting them
2782 * to the modern Unicode equivalent.
2783 *
2784 * This is language-specific for performance reasons only.
2785 *
2786 * @param $s string
2787 *
2788 * @return string
2789 */
2796 }
2799 }
2801 /**
2802 * Transform a string using serialized data stored in the given file (which
2803 * must be in the serialized subdirectory of $IP). The file contains pairs
2804 * mapping source characters to destination characters.
2805 *
2806 * The data is cached in process memory. This will go faster if you have the
2807 * FastStringSearch extension.
2808 *
2809 * @param $file string
2810 * @param $string string
2811 *
2812 * @throws MWException
2813 * @return string
2814 */
2820 }
2822 }
2824 }
2826 /**
2827 * For right-to-left language support
2828 *
2829 * @return bool
2830 */
2833 }
2835 /**
2836 * Return the correct HTML 'dir' attribute value for this language.
2837 * @return String
2838 */
2841 }
2843 /**
2844 * Return 'left' or 'right' as appropriate alignment for line-start
2845 * for this language's text direction.
2846 *
2847 * Should be equivalent to CSS3 'start' text-align value....
2848 *
2849 * @return String
2850 */
2853 }
2855 /**
2856 * Return 'right' or 'left' as appropriate alignment for line-end
2857 * for this language's text direction.
2858 *
2859 * Should be equivalent to CSS3 'end' text-align value....
2860 *
2861 * @return String
2862 */
2865 }
2867 /**
2868 * A hidden direction mark (LRM or RLM), depending on the language direction.
2869 * Unlike getDirMark(), this function returns the character as an HTML entity.
2870 * This function should be used when the output is guaranteed to be HTML,
2871 * because it makes the output HTML source code more readable. When
2872 * the output is plain text or can be escaped, getDirMark() should be used.
2873 *
2874 * @param $opposite Boolean Get the direction mark opposite to your language
2875 * @return string
2876 * @since 1.20
2877 */
2881 }
2883 }
2885 /**
2886 * A hidden direction mark (LRM or RLM), depending on the language direction.
2887 * This function produces them as invisible Unicode characters and
2888 * the output may be hard to read and debug, so it should only be used
2889 * when the output is plain text or can be escaped. When the output is
2890 * HTML, use getDirMarkEntity() instead.
2891 *
2892 * @param $opposite Boolean Get the direction mark opposite to your language
2893 * @return string
2894 */
2900 }
2902 }
2904 /**
2905 * @return array
2906 */
2909 }
2911 /**
2912 * An arrow, depending on the language direction.
2913 *
2914 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2915 * @return string
2916 */
2931 }
2932 }
2934 /**
2935 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2936 *
2937 * @return bool
2938 */
2941 }
2943 /**
2944 * @return array
2945 */
2948 }
2953 }
2958 }
2960 /**
2961 * Fill a MagicWord object with data from here
2962 *
2963 * @param $mw
2964 */
2976 }
2977 }
2984 }
2985 }
2987 /**
2988 * Add magic words to the extension array
2989 *
2990 * @param $newWords array
2991 */
2998 }
2999 }
3000 }
3002 /**
3003 * Get special page names, as an associative array
3004 * case folded alias => real name
3005 */
3007 // Cache aliases because it may be slow to load them
3009 // Initialise array
3014 }
3017 }
3019 /**
3020 * Italic is unsuitable for some languages
3021 *
3022 * @param $text String: the text to be emphasized.
3023 * @return string
3024 */
3027 }
3029 /**
3030 * Normally we output all numbers in plain en_US style, that is
3031 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3032 * point twohundredthirtyfive. However this is not suitable for all
3033 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
3034 * Icelandic just want to use commas instead of dots, and dots instead
3035 * of commas like "293.291,235".
3036 *
3037 * An example of this function being called:
3038 * <code>
3039 * wfMessage( 'message' )->numParams( $num )->text()
3040 * </code>
3041 *
3042 * See LanguageGu.php for the Gujarati implementation and
3043 * $separatorTransformTable on MessageIs.php for
3044 * the , => . and . => , implementation.
3045 *
3046 * @todo check if it's viable to use localeconv() for the decimal
3047 * separator thing.
3048 * @param $number Mixed: the string to be formatted, should be an integer
3049 * or a floating point number.
3050 * @param $nocommafy Bool: set to true for special numbers like dates
3051 * @return string
3052 */
3060 }
3061 }
3067 }
3068 }
3071 }
3073 /**
3074 * Front-end for non-commafied formatNum
3075 *
3076 * @param mixed $number the string to be formatted, should be an integer
3077 * or a floating point number.
3078 * @since 1.21
3079 * @return string
3080 */
3083 }
3085 /**
3086 * @param $number string
3087 * @return string
3088 */
3093 }
3098 }
3102 }
3104 /**
3105 * Adds commas to a given number
3106 * @since 1.19
3107 * @param $number mixed
3108 * @return string
3109 */
3114 }
3117 // default grouping is at thousands, use the same for ###,###,### pattern too.
3120 // Ref: http://cldr.unicode.org/translation/number-patterns
3123 // For negative numbers apply the algorithm like positive number and add sign.
3126 }
3134 // the string does not have any number part. Eg: .12345
3136 }
3144 }
3148 // use the last pattern for the rest of the number
3150 }
3153 }
3154 }
3156 }
3157 }
3159 /**
3160 * @return String
3161 */
3164 }
3166 /**
3167 * @return array
3168 */
3171 }
3173 /**
3174 * @return array
3175 */
3178 }
3180 /**
3181 * Take a list of strings and build a locale-friendly comma-separated
3182 * list, using the local comma-separator message.
3183 * The last two strings are chained with an "and".
3184 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3185 *
3186 * @param $l Array
3187 * @return string
3188 */
3193 }
3199 }
3200 }
3207 }
3208 }
3210 }
3212 /**
3213 * Take a list of strings and build a locale-friendly comma-separated
3214 * list, using the local comma-separator message.
3215 * @param $list array of strings to put in a comma list
3216 * @return string
3217 */
3221 $list
3222 );
3223 }
3225 /**
3226 * Take a list of strings and build a locale-friendly semicolon-separated
3227 * list, using the local semicolon-separator message.
3228 * @param $list array of strings to put in a semicolon list
3229 * @return string
3230 */
3234 $list
3235 );
3236 }
3238 /**
3239 * Same as commaList, but separate it with the pipe instead.
3240 * @param $list array of strings to put in a pipe list
3241 * @return string
3242 */
3246 $list
3247 );
3248 }
3250 /**
3251 * Truncate a string to a specified length in bytes, appending an optional
3252 * string (e.g. for ellipses)
3253 *
3254 * The database offers limited byte lengths for some columns in the database;
3255 * multi-byte character sets mean we need to ensure that only whole characters
3256 * are included, otherwise broken characters can be passed to the user
3257 *
3258 * If $length is negative, the string will be truncated from the beginning
3259 *
3260 * @param $string String to truncate
3261 * @param $length Int: maximum length (including ellipses)
3262 * @param $ellipsis String to append to the truncated text
3263 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3264 * $adjustLength was introduced in 1.18, before that behaved as if false.
3265 * @return string
3266 */
3268 # Use the localized ellipsis character
3271 }
3272 # Check if there is no need to truncate
3277 }
3279 # If ellipsis length is >= $length then we can't apply $adjustLength
3282 # Otherwise, truncate and add ellipsis...
3295 }
3296 }
3297 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3298 # This check is *not* redundant if $adjustLength, due to the single case where
3299 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3304 }
3305 }
3307 /**
3308 * Remove bytes that represent an incomplete Unicode character
3309 * at the end of string (e.g. bytes of the char are missing)
3310 *
3311 * @param $string String
3312 * @return string
3313 */
3319 # We got the first byte only of a multibyte char; remove it.
3324 ) {
3325 # We chopped in the middle of a character; remove it
3327 }
3328 }
3330 }
3332 /**
3333 * Remove bytes that represent an incomplete Unicode character
3334 * at the start of string (e.g. bytes of the char are missing)
3335 *
3336 * @param $string String
3337 * @return string
3338 */
3343 # We chopped in the middle of a character; remove the whole thing
3345 }
3346 }
3348 }
3350 /**
3351 * Truncate a string of valid HTML to a specified length in bytes,
3352 * appending an optional string (e.g. for ellipses), and return valid HTML
3353 *
3354 * This is only intended for styled/linked text, such as HTML with
3355 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3356 * Also, this will not detect things like "display:none" CSS.
3357 *
3358 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3359 *
3360 * @param string $text HTML string to truncate
3361 * @param int $length (zero/positive) Maximum length (including ellipses)
3362 * @param string $ellipsis String to append to the truncated text
3363 * @return string
3364 */
3366 # Use the localized ellipsis character
3369 }
3370 # Check if there is clearly no need to truncate
3375 }
3389 # Consider truncation once the display length has reached the maximim.
3390 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3391 # Check that we're not in the middle of a bracket/entity...
3395 # Save where we are; we will truncate here unless there turn out to
3396 # be so few remaining characters that truncation is not necessary.
3399 }
3401 # String in fact does need truncation, the truncation point was OK.
3406 }
3407 }
3410 }
3412 # Read the next char...
3430 }
3436 // Name found (e.g. "<a href=..."), add on tag attributes...
3438 }
3444 }
3447 // Save state without $ch. We want to *hit* the first
3448 // display char (to get tags) but not *use* it if truncating.
3450 }
3455 // Add the next $max display text chars after this in one swoop...
3460 }
3461 }
3462 }
3463 }
3464 // Close the last tag if left unclosed by bad HTML
3468 }
3470 }
3472 /**
3473 * truncateHtml() helper function
3474 * like strcspn() but adds the skipped chars to $ret
3475 *
3476 * @param $ret
3477 * @param $text
3478 * @param $search
3479 * @param $start
3480 * @param $len
3481 * @return int
3482 */
3488 }
3493 }
3495 }
3497 /**
3498 * truncateHtml() helper function
3499 * (a) push or pop $tag from $openTags as needed
3500 * (b) clear $tag value
3501 * @param &$tag string Current HTML tag name we are looking at
3502 * @param $tagType int (0-open tag, 1-close tag)
3503 * @param $lastCh string Character before the '>' that ended this tag
3504 * @param &$openTags array Open tag stack (not accounting for $tag)
3505 */
3514 }
3515 }
3517 }
3518 }
3520 /**
3521 * Grammatical transformations, needed for inflected languages
3522 * Invoked by putting {{grammar:case|word}} in a message
3523 *
3524 * @param $word string
3525 * @param $case string
3526 * @return string
3527 */
3532 }
3534 }
3535 /**
3536 * Get the grammar forms for the content language
3537 * @return array of grammar forms
3538 * @since 1.20
3539 */
3542 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3544 }
3546 }
3547 /**
3548 * Provides an alternative text depending on specified gender.
3549 * Usage {{gender:username|masculine|feminine|neutral}}.
3550 * username is optional, in which case the gender of current user is used,
3551 * but only in (some) interface messages; otherwise default gender is used.
3552 *
3553 * If no forms are given, an empty string is returned. If only one form is
3554 * given, it will be returned unconditionally. These details are implied by
3555 * the caller and cannot be overridden in subclasses.
3556 *
3557 * If more than one form is given, the default is to use the neutral one
3558 * if it is specified, and to use the masculine one otherwise. These
3559 * details can be overridden in subclasses.
3560 *
3561 * @param $gender string
3562 * @param $forms array
3563 *
3564 * @return string
3565 */
3569 }
3573 }
3576 }
3578 }
3580 /**
3581 * Plural form transformations, needed for some languages.
3582 * For example, there are 3 form of plural in Russian and Polish,
3583 * depending on "count mod 10". See [[w:Plural]]
3584 * For English it is pretty simple.
3585 *
3586 * Invoked by putting {{plural:count|wordform1|wordform2}}
3587 * or {{plural:count|wordform1|wordform2|wordform3}}
3588 *
3589 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3590 *
3591 * @param $count Integer: non-localized number
3592 * @param $forms Array: different plural forms
3593 * @return string Correct form of plural for $count in this language
3594 */
3598 }
3600 // Handle explicit n=pluralform cases
3606 }
3608 }
3609 }
3615 }
3617 /**
3618 * Checks that convertPlural was given an array and pads it to requested
3619 * amount of forms by copying the last one.
3620 *
3621 * @param $count Integer: How many forms should there be at least
3622 * @param $forms Array of forms given to convertPlural
3623 * @return array Padded array of forms or an exception if not an array
3624 */
3628 }
3630 }
3632 /**
3633 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3634 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3635 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3636 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3637 * match up with it.
3638 *
3639 * @param $str String: the validated block duration in English
3640 * @return string Somehow translated block duration
3641 * @see LanguageFi.php for example implementation
3642 */
3648 }
3649 }
3651 // Since usually only infinite or indefinite is only on list, so try
3652 // equivalents if still here.
3659 }
3660 }
3661 }
3663 // If all else fails, return a standard duration or timestamp description.
3668 // $time is relative to 0 so it's a duration length.
3672 // wfTimestamp() handles 0 as current time instead of epoch.
3676 }
3677 }
3678 }
3680 /**
3681 * languages like Chinese need to be segmented in order for the diff
3682 * to be of any use
3683 *
3684 * @param $text String
3685 * @return String
3686 */
3689 }
3691 /**
3692 * and unsegment to show the result
3693 *
3694 * @param $text String
3695 * @return String
3696 */
3699 }
3701 /**
3702 * Return the LanguageConverter used in the Language
3703 *
3704 * @since 1.19
3705 * @return LanguageConverter
3706 */
3709 }
3711 /**
3712 * convert text to all supported variants
3713 *
3714 * @param $text string
3715 * @return array
3716 */
3719 }
3721 /**
3722 * convert text to different variants of a language.
3723 *
3724 * @param $text string
3725 * @return string
3726 */
3729 }
3731 /**
3732 * Convert a Title object to a string in the preferred variant
3733 *
3734 * @param $title Title
3735 * @return string
3736 */
3739 }
3741 /**
3742 * Convert a namespace index to a string in the preferred variant
3743 *
3744 * @param $ns int
3745 * @return string
3746 */
3749 }
3751 /**
3752 * Check if this is a language with variants
3753 *
3754 * @return bool
3755 */
3758 }
3760 /**
3761 * Check if the language has the specific variant
3762 *
3763 * @since 1.19
3764 * @param $variant string
3765 * @return bool
3766 */
3769 }
3771 /**
3772 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3773 *
3774 * @param $text string
3775 * @return string
3776 */
3779 }
3781 /**
3782 * Perform output conversion on a string, and encode for safe HTML output.
3783 * @param $text String text to be converted
3784 * @param $isTitle Bool whether this conversion is for the article title
3785 * @return string
3786 * @todo this should get integrated somewhere sane
3787 */
3790 }
3792 /**
3793 * @param $key string
3794 * @return string
3795 */
3798 }
3800 /**
3801 * Get the list of variants supported by this language
3802 * see sample implementation in LanguageZh.php
3803 *
3804 * @return array an array of language codes
3805 */
3808 }
3810 /**
3811 * @return string
3812 */
3815 }
3817 /**
3818 * @return string
3819 */
3822 }
3824 /**
3825 * @return string
3826 */
3829 }
3831 /**
3832 * If a language supports multiple variants, it is
3833 * possible that non-existing link in one variant
3834 * actually exists in another variant. this function
3835 * tries to find it. See e.g. LanguageZh.php
3836 *
3837 * @param $link String: the name of the link
3838 * @param $nt Mixed: the title object of the link
3839 * @param $ignoreOtherCond Boolean: to disable other conditions when
3840 * we need to transclude a template or update a category's link
3841 * @return null the input parameters may be modified upon return
3842 */
3845 }
3847 /**
3848 * If a language supports multiple variants, converts text
3849 * into an array of all possible variants of the text:
3850 * 'variant' => text in that variant
3851 *
3852 * @deprecated since 1.17 Use autoConvertToAllVariants()
3853 *
3854 * @param $text string
3855 *
3856 * @return string
3857 */
3860 }
3862 /**
3863 * returns language specific options used by User::getPageRenderHash()
3864 * for example, the preferred language variant
3865 *
3866 * @return string
3867 */
3870 }
3872 /**
3873 * For languages that support multiple variants, the title of an
3874 * article may be displayed differently in different variants. this
3875 * function returns the apporiate title defined in the body of the article.
3876 *
3877 * @return string
3878 */
3881 }
3883 /**
3884 * Prepare external link text for conversion. When the text is
3885 * a URL, it shouldn't be converted, and it'll be wrapped in
3886 * the "raw" tag (-{R| }-) to prevent conversion.
3887 *
3888 * This function is called "markNoConversion" for historical
3889 * reasons.
3890 *
3891 * @param $text String: text to be used for external link
3892 * @param $noParse bool: wrap it without confirming it's a real URL first
3893 * @return string the tagged text
3894 */
3896 // Excluding protocal-relative URLs may avoid many false positives.
3901 }
3902 }
3904 /**
3905 * A regular expression to match legal word-trailing characters
3906 * which should be merged onto a link of the form [[foo]]bar.
3907 *
3908 * @return string
3909 */
3912 }
3914 /**
3915 * @return Language
3916 */
3919 }
3921 /**
3922 * Get the RFC 3066 code for this language object
3923 *
3924 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3925 * htmlspecialchars() or similar
3926 *
3927 * @return string
3928 */
3931 }
3933 /**
3934 * Get the code in Bcp47 format which we can use
3935 * inside of html lang="" tags.
3936 *
3937 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3938 * htmlspecialchars() or similar.
3939 *
3940 * @since 1.19
3941 * @return string
3942 */
3946 }
3948 }
3950 /**
3951 * @param $code string
3952 */
3955 // Ensure we don't leave an incorrect html code lying around
3957 }
3959 /**
3960 * Get the name of a file for a certain language code
3961 * @param $prefix string Prepend this to the filename
3962 * @param $code string Language code
3963 * @param $suffix string Append this to the filename
3964 * @throws MWException
3965 * @return string $prefix . $mangledCode . $suffix
3966 */
3968 // Protect against path traversal
3971 {
3973 }
3976 }
3978 /**
3979 * Get the language code from a file name. Inverse of getFileName()
3980 * @param $filename string $prefix . $languageCode . $suffix
3981 * @param $prefix string Prefix before the language code
3982 * @param $suffix string Suffix after the language code
3983 * @return string Language code, or false if $prefix or $suffix isn't found
3984 */
3985 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3991 }
3993 }
3995 /**
3996 * @param $code string
3997 * @return string
3998 */
4004 }
4006 /**
4007 * @param $code string
4008 * @return string
4009 */
4013 }
4015 /**
4016 * Get the first fallback for a given language.
4017 *
4018 * @param $code string
4019 *
4020 * @return bool|string
4021 */
4029 }
4030 }
4032 /**
4033 * Get the ordered list of fallback languages.
4034 *
4035 * @since 1.19
4036 * @param $code string Language code
4037 * @return array
4038 */
4047 }
4049 }
4050 }
4052 /**
4053 * Get all messages for a given language
4054 * WARNING: this may take a long time. If you just need all message *keys*
4055 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4056 *
4057 * @param $code string
4058 *
4059 * @return array
4060 */
4063 }
4065 /**
4066 * Get a message for a given language
4067 *
4068 * @param $key string
4069 * @param $code string
4070 *
4071 * @return string
4072 */
4075 }
4077 /**
4078 * Get all message keys for a given language. This is a faster alternative to
4079 * array_keys( Language::getMessagesFor( $code ) )
4080 *
4081 * @since 1.19
4082 * @param $code string Language code
4083 * @return array of message keys (strings)
4084 */
4087 }
4089 /**
4090 * @param $talk
4091 * @return mixed
4092 */
4096 }
4101 # Allow grammar transformations
4102 # Allowing full message-style parsing would make simple requests
4103 # such as action=raw much more expensive than they need to be.
4104 # This will hopefully cover most cases.
4108 }
4110 /**
4111 * @param $m string
4112 * @return string
4113 */
4116 }
4118 /**
4119 * @throws MWException
4120 * @return array
4121 */
4126 }
4133 }
4138 }
4140 /**
4141 * Decode an expiry (block, protection, etc) which has come from the DB
4142 *
4143 * @todo FIXME: why are we returnings DBMS-dependent strings???
4144 *
4145 * @param $expiry String: Database expiry String
4146 * @param $format Bool|Int true to process using language functions, or TS_ constant
4147 * to return the expiry in a given timestamp
4148 * @return String
4149 * @since 1.18
4150 */
4155 }
4165 }
4166 }
4168 /**
4169 * @todo Document
4170 * @param $seconds int|float
4171 * @param $format Array Optional
4172 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4173 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4174 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4175 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4176 * @return string
4177 */
4181 }
4184 }
4187 }
4209 }
4220 }
4224 }
4230 }
4238 }
4248 }
4252 }
4262 }
4263 }
4265 }
4267 /**
4268 * Format a bitrate for output, using an appropriate
4269 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4270 *
4271 * This use base 1000. For base 1024 use formatSize(), for another base
4272 * see formatComputingNumbers()
4273 *
4274 * @param $bps int
4275 * @return string
4276 */
4279 }
4281 /**
4282 * @param $size int Size of the unit
4283 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4284 * @param $messageKey string Message key to be uesd
4285 * @return string
4286 */
4291 );
4292 }
4300 }
4302 // For small sizes no decimal places necessary
4305 // For MB and bigger two decimal places are smarter
4307 }
4313 }
4315 /**
4316 * Format a size in bytes for output, using an appropriate
4317 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4318 *
4319 * This method use base 1024. For base 1000 use formatBitrate(), for
4320 * another base see formatComputingNumbers()
4321 *
4322 * @param $size int Size to format
4323 * @return string Plain text (not HTML)
4324 */
4327 }
4329 /**
4330 * Make a list item, used by various special pages
4331 *
4332 * @param $page String Page link
4333 * @param $details String Text between brackets
4334 * @param $oppositedm Boolean Add the direction mark opposite to your
4335 * language, to display text properly
4336 * @return String
4337 */
4344 }
4346 /**
4347 * Generate (prev x| next x) (20|50|100...) type links for paging
4348 *
4349 * @param $title Title object to link
4350 * @param $offset Integer offset parameter
4351 * @param $limit Integer limit parameter
4352 * @param $query array|String optional URL query parameter string
4353 * @param $atend Bool optional param for specified if this is the last page
4354 * @return String
4355 */
4356 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4357 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4359 # Make 'previous' link
4360 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4366 }
4368 # Make 'next' link
4369 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4375 }
4377 # Make links to set number of items per page
4382 }
4386 }
4388 /**
4389 * Helper function for viewPrevNext() that generates links
4390 *
4391 * @param $title Title object to link
4392 * @param $offset Integer offset parameter
4393 * @param $limit Integer limit parameter
4394 * @param $query Array extra query parameters
4395 * @param $link String text to use for the link; will be escaped
4396 * @param $tooltipMsg String name of the message to use as tooltip
4397 * @param $class String value of the "class" attribute of the link
4398 * @return String HTML fragment
4399 */
4400 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4402 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4405 }
4407 /**
4408 * Get the conversion rule title, if any.
4409 *
4410 * @return string
4411 */
4414 }
4416 /**
4417 * Get the compiled plural rules for the language
4418 * @since 1.20
4419 * @return array Associative array with plural form, and plural rule as key-value pairs
4420 */
4426 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4429 }
4430 }
4431 }
4433 }
4435 /**
4436 * Get the plural rules for the language
4437 * @since 1.20
4438 * @return array Associative array with plural form number and plural rule as key-value pairs
4439 */
4448 }
4449 }
4450 }
4452 }
4454 /**
4455 * Get the plural rule types for the language
4456 * @since 1.21
4457 * @return array Associative array with plural form number and plural rule type as key-value pairs
4458 */
4464 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4467 }
4468 }
4469 }
4471 }
4473 /**
4474 * Find the index number of the plural rule appropriate for the given number
4475 * @return int The index number of the plural rule
4476 */
4481 }
4483 /**
4484 * Find the plural rule type appropriate for the given number
4485 * For example, if the language is set to Arabic, getPluralType(5) should
4486 * return 'few'.
4487 * @since 1.21
4488 * @return string The name of the plural rule type, e.g. one, two, few, many
4489 */
4497 }
4498 }
4499 }