| blob | 37a41badc92d6c29b6f8ab688945e7e965334cb7 |
1 <?php
2 /**
3 * Internationalisation code
4 *
5 * @file
6 * @ingroup Language
7 */
9 /**
10 * @defgroup Language Language
11 */
16 }
18 # Read language names
24 }
26 /**
27 * a fake language converter
28 *
29 * @ingroup Language
30 */
33 /**
34 * @var Language
35 */
54 }
56 /**
57 * Internationalisation code
58 * @ingroup Language
59 */
62 /**
63 * @var LanguageConverter
64 */
76 /**
77 * ReplacementArray object caches
78 */
81 /**
82 * @var LocalisationCache
83 */
91 );
95 );
100 'december'
101 );
105 'december-gen'
106 );
110 );
117 );
125 );
133 );
140 );
142 /**
143 * @since 1.20
144 * @var array
145 */
156 );
158 /**
159 * Get a cached language object for a given language code
160 * @param $code String
161 * @return Language
162 */
166 // Don't keep a billion objects around, that's stupid.
168 }
170 }
172 }
174 /**
175 * Create a language object for a given language code
176 * @param $code String
177 * @throws MWException
178 * @return Language
179 */
181 // Protect against path traversal below
184 {
186 }
189 // It's not possible to customise this code with class files, so
190 // just return a Language object. This is to support uselang= hacks.
194 }
196 // Check if there is a language class for the code
202 }
204 // Keep trying the fallback list until we find an existing class
209 }
217 }
218 }
221 }
223 /**
224 * Returns true if a language code string is of a valid form, whether or
225 * not it exists. This includes codes which are used solely for
226 * customisation via the MediaWiki namespace.
227 *
228 * @param $code string
229 *
230 * @return bool
231 */
233 return
236 }
238 /**
239 * Returns true if a language code is of a valid form for the purposes of
240 * internal customisation of MediaWiki, via Messages*.php.
241 *
242 * @param $code string
243 *
244 * @since 1.18
245 * @return bool
246 */
255 }
257 }
260 }
262 /**
263 * @param $code
264 * @return String Name of the language class
265 */
271 }
272 }
274 /**
275 * Includes language class files
276 *
277 * @param $class string Name of the language class
278 */
284 }
289 }
290 }
291 }
293 /**
294 * Get the LocalisationCache instance
295 *
296 * @return LocalisationCache
297 */
303 }
305 }
309 // Set the code to the name of the descendant
314 }
316 }
318 /**
319 * Reduce memory usage
320 */
324 }
325 }
327 /**
328 * Hook which will be called if this is the content language.
329 * Descendants can use this to register hook functions or modify globals
330 */
333 /**
334 * Same as getFallbacksFor for current language.
335 * @return array|bool
336 * @deprecated in 1.19
337 */
341 }
343 /**
344 * @return array
345 * @since 1.19
346 */
349 }
351 /**
352 * Exports $wgBookstoreListEn
353 * @return array
354 */
357 }
359 /**
360 * @return array
361 */
378 }
380 # Sometimes a language will be localised but not actually exist on this wiki.
384 }
385 }
387 # The above mixing may leave namespaces out of canonical order.
388 # Re-order by namespace ID number...
392 }
394 }
396 /**
397 * Arbitrarily set all of the namespace names at once. Mainly used for testing
398 * @param $namespaces Array of namespaces (id => name)
399 */
402 }
404 /**
405 * A convenience function that returns the same thing as
406 * getNamespaces() except with the array values changed to ' '
407 * where it found '_', useful for producing output to be displayed
408 * e.g. in <select> forms.
409 *
410 * @return array
411 */
416 }
418 }
420 /**
421 * Get a namespace value by key
422 * <code>
423 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
424 * echo $mw_ns; // prints 'MediaWiki'
425 * </code>
426 *
427 * @param $index Int: the array key of the namespace to return
428 * @return mixed, string if the namespace value exists, otherwise false
429 */
433 }
435 /**
436 * A convenience function that returns the same thing as
437 * getNsText() except with '_' changed to ' ', useful for
438 * producing output.
439 *
440 * @param $index string
441 *
442 * @return array
443 */
447 }
449 /**
450 * Returns gender-dependent namespace alias if available.
451 * @param $index Int: namespace index
452 * @param $gender String: gender key (male, female... )
453 * @return String
454 * @since 1.18
455 */
459 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
461 }
463 /**
464 * Whether this language makes distinguishes genders for example in
465 * namespaces.
466 * @return bool
467 * @since 1.18
468 */
472 // $wgExtraGenderNamespaces overrides everything
474 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
475 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
476 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
479 // Check what is in i18n files
482 }
483 }
485 /**
486 * Get a namespace key by value, case insensitive.
487 * Only matches namespace names for the current language, not the
488 * canonical ones defined in Namespace.php.
489 *
490 * @param $text String
491 * @return mixed An integer if $text is a valid value otherwise false
492 */
497 }
499 /**
500 * @return array
501 */
513 }
514 }
515 }
518 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
522 }
523 }
526 }
528 }
530 /**
531 * @return array
532 */
536 # Put namespace names and aliases into a hashtable.
537 # If this is too slow, then we should arrange it so that it is done
538 # before caching. The catch is that at pre-cache time, the above
539 # class-specific fixup hasn't been done.
543 }
546 }
550 }
551 }
552 }
554 }
556 /**
557 * Get a namespace key by value, case insensitive. Canonical namespace
558 * names override custom ones defined for the current language.
559 *
560 * @param $text String
561 * @return mixed An integer if $text is a valid value otherwise false
562 */
568 }
571 }
573 /**
574 * short names for language variants used for language conversion links.
575 *
576 * @param $code String
577 * @param $usemsg bool Use the "variantname-xyz" message if it exists
578 * @return string
579 */
584 }
589 # otherwise, output the language code
591 }
592 }
594 /**
595 * @param $name string
596 * @return string
597 */
602 }
604 }
606 /**
607 * @return array
608 */
617 );
618 }
620 /**
621 * @return array
622 */
625 }
627 /**
628 * @return array
629 */
632 }
634 /**
635 * @return array|string
636 */
644 }
645 }
647 /**
648 * @return array
649 */
652 }
654 /**
655 * @param $image
656 * @return array|null
657 */
660 }
662 /**
663 * @return array
664 */
667 }
669 /**
670 * @param $tog
671 * @return string
672 */
675 }
677 /**
678 * Get native language names, indexed by code.
679 * Only those defined in MediaWiki, no other data like CLDR.
680 * If $customisedOnly is true, only returns codes with a messages file
681 *
682 * @param $customisedOnly bool
683 *
684 * @return array
685 * @deprecated in 1.20, use fetchLanguageNames()
686 */
689 }
691 /**
692 * Get translated language names. This is done on best effort and
693 * by default this is exactly the same as Language::getLanguageNames.
694 * The CLDR extension provides translated names.
695 * @param $code String Language code.
696 * @return Array language code => language name
697 * @since 1.18.0
698 * @deprecated in 1.20, use fetchLanguageNames()
699 */
702 }
704 /**
705 * Get an array of language names, indexed by code.
706 * @param $inLanguage null|string: Code of language in which to return the names
707 * Use null for autonyms (native names)
708 * @param $include string:
709 * 'all' all available languages
710 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
711 * 'mwfile' only if the language is in 'mw' *and* has a message file
712 * @return array: language code => language name
713 * @since 1.20
714 */
721 }
726 # TODO: also include when $inLanguage is null, when this code is more efficient
728 }
732 # - Prefer own MediaWiki native name when not using the hook
733 # TODO: prefer it always to make it consistent, but casing is different in CLDR
734 # - For other names just add if not added through the hook
737 }
738 }
742 }
748 }
752 # We do this using a foreach over the codes instead of a directory
753 # loop so that messages files in extensions will work correctly.
757 }
758 }
760 }
761 # 'mw' option; default if it's not one of the other two options (all/mwfile)
763 }
765 /**
766 * @param $code string: The code of the language for which to get the name
767 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
768 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
769 * @return string: Language name or empty
770 * @since 1.20
771 */
775 }
777 /**
778 * Get a message from the MediaWiki namespace.
779 *
780 * @param $msg String: message name
781 * @return string
782 */
785 }
787 /**
788 * Get the native language name of $code.
789 * Only if defined in MediaWiki, no other data like CLDR.
790 * @param $code string
791 * @return string
792 * @deprecated in 1.20, use fetchLanguageName()
793 */
796 }
798 /**
799 * @param $key string
800 * @return string
801 */
804 }
806 /**
807 * @return array
808 */
813 }
815 }
817 /**
818 * @param $key string
819 * @return string
820 */
823 }
825 /**
826 * @param $key string
827 * @return string
828 */
831 }
833 /**
834 * @return array
835 */
840 }
842 }
844 /**
845 * @param $key string
846 * @return string
847 */
850 }
852 /**
853 * @param $key string
854 * @return string
855 */
858 }
860 /**
861 * @param $key string
862 * @return string
863 */
866 }
868 /**
869 * @param $key string
870 * @return string
871 */
874 }
876 /**
877 * @param $key string
878 * @return string
879 */
882 }
884 /**
885 * @param $key string
886 * @return string
887 */
890 }
892 /**
893 * This is a workalike of PHP's date() function, but with better
894 * internationalisation, a reduced set of format characters, and a better
895 * escaping format.
896 *
897 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
898 * PHP manual for definitions. There are a number of extensions, which
899 * start with "x":
900 *
901 * xn Do not translate digits of the next numeric format character
902 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
903 * xr Use roman numerals for the next numeric format character
904 * xh Use hebrew numerals for the next numeric format character
905 * xx Literal x
906 * xg Genitive month name
907 *
908 * xij j (day number) in Iranian calendar
909 * xiF F (month name) in Iranian calendar
910 * xin n (month number) in Iranian calendar
911 * xiy y (two digit year) in Iranian calendar
912 * xiY Y (full year) in Iranian calendar
913 *
914 * xjj j (day number) in Hebrew calendar
915 * xjF F (month name) in Hebrew calendar
916 * xjt t (days in month) in Hebrew calendar
917 * xjx xg (genitive month name) in Hebrew calendar
918 * xjn n (month number) in Hebrew calendar
919 * xjY Y (full year) in Hebrew calendar
920 *
921 * xmj j (day number) in Hijri calendar
922 * xmF F (month name) in Hijri calendar
923 * xmn n (month number) in Hijri calendar
924 * xmY Y (full year) in Hijri calendar
925 *
926 * xkY Y (full year) in Thai solar calendar. Months and days are
927 * identical to the Gregorian calendar
928 * xoY Y (full year) in Minguo calendar or Juche year.
929 * Months and days are identical to the
930 * Gregorian calendar
931 * xtY Y (full year) in Japanese nengo. Months and days are
932 * identical to the Gregorian calendar
933 *
934 * Characters enclosed in double quotes will be considered literal (with
935 * the quotes themselves removed). Unmatched quotes will be considered
936 * literal quotes. Example:
937 *
938 * "The month is" F => The month is January
939 * i's" => 20'11"
940 *
941 * Backslash escaping is also supported.
942 *
943 * Input timestamp is assumed to be pre-normalized to the desired local
944 * time zone, if any.
945 *
946 * @param $format String
947 * @param $ts String: 14-character timestamp
948 * YYYYMMDDHHMMSS
949 * 01234567890123
950 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
951 *
952 * @return string
953 */
972 }
974 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
976 }
1014 }
1020 }
1026 }
1032 }
1038 }
1045 }
1051 }
1057 }
1066 }
1072 }
1078 }
1093 }
1099 }
1105 }
1111 }
1117 }
1123 }
1129 }
1138 }
1144 }
1150 }
1156 }
1162 }
1168 }
1177 }
1209 }
1215 }
1221 }
1225 # Backslash escaping
1230 }
1233 # Quoted literal
1237 # No terminating quote, assume literal "
1242 }
1244 # Quote at end of string, assume literal "
1246 }
1250 }
1263 }
1264 }
1265 }
1267 }
1272 /**
1273 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1274 * Gregorian dates to Iranian dates. Originally written in C, it
1275 * is released under the terms of GNU Lesser General Public
1276 * License. Conversion to PHP was performed by Niklas Laxström.
1277 *
1278 * Link: http://www.farsiweb.info/jalali/jalali.c
1279 *
1280 * @param $ts string
1281 *
1282 * @return string
1283 */
1289 # Days passed from the beginning (including leap years)
1295 // Add days of the past months of this year
1298 }
1300 // Leap years
1303 }
1305 // Days passed in current month
1319 }
1323 }
1329 }
1331 /**
1332 * Converting Gregorian dates to Hijri dates.
1333 *
1334 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1335 *
1336 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1337 *
1338 * @param $ts string
1339 *
1340 * @return string
1341 */
1355 )
1356 {
1364 }
1369 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1370 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1376 }
1378 /**
1379 * Converting Gregorian dates to Hebrew dates.
1380 *
1381 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1382 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1383 * to translate the relevant functions into PHP and release them under
1384 * GNU GPL.
1385 *
1386 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1387 * and Adar II is 14. In a non-leap year, Adar is 6.
1388 *
1389 * @param $ts string
1390 *
1391 * @return string
1392 */
1394 # Parse date
1399 # Calculate Hebrew year
1402 # Month number when September = 1, August = 12
1405 # Next year
1409 }
1411 # Calculate day of year from 1 September
1415 # February
1417 # Check if the year is leap
1420 }
1425 }
1426 }
1428 # Calculate the start of the Hebrew year
1431 # Calculate next year's start
1433 # Day is before the start of the year - it is the previous year
1434 # Next year's start
1436 # Previous year
1439 # Add days since previous year's 1 September
1442 # Leap year
1444 }
1445 # Start of the new (previous) year
1448 # Next year's start
1450 }
1452 # Calculate Hebrew day of year
1455 # Difference between year's days
1457 # Add 12 (or 13 for leap years) days to ignore the difference between
1458 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1459 # difference is only about the year type
1464 }
1466 # Check the year pattern, and is leap year
1467 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1468 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1469 # and non-leap years
1471 # Check if leap year
1474 # Calculate day in the month from number of day in the Hebrew year
1475 # Don't check Adar - if the day is not in Adar, we will stop before;
1476 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1481 # Calculate days in this month
1483 # Adar in a leap year
1485 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1488 # Day in Adar I
1491 # Subtract the days of Adar I
1493 # Try Adar II
1496 # Day in Adar II
1498 }
1499 }
1500 }
1502 # Cheshvan in a complete year (otherwise as the rule below)
1505 # Kislev in an incomplete year (otherwise as the rule below)
1508 # Odd months have 30 days, even have 29
1510 }
1512 # In the current month
1515 # Subtract the days of the current month
1517 # Try in the next month
1519 }
1520 }
1523 }
1525 /**
1526 * This calculates the Hebrew year start, as days since 1 September.
1527 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1528 * Used for Hebrew date.
1529 *
1530 * @param $year int
1531 *
1532 * @return string
1533 */
1540 }
1544 }
1554 }
1558 }
1560 /**
1561 * Algorithm to convert Gregorian dates to Thai solar dates,
1562 * Minguo dates or Minguo dates.
1563 *
1564 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1565 * http://en.wikipedia.org/wiki/Minguo_calendar
1566 * http://en.wikipedia.org/wiki/Japanese_era_name
1567 *
1568 * @param $ts String: 14-character timestamp
1569 * @param $cName String: calender name
1570 * @return Array: converted year, month, day
1571 */
1578 # Thai solar dates
1579 # Add 543 years to the Gregorian calendar
1580 # Months and days are identical
1583 # Minguo dates
1584 # Deduct 1911 years from the Gregorian calendar
1585 # Months and days are identical
1588 # Nengō dates up to Meiji period
1589 # Deduct years from the Gregorian calendar
1590 # depending on the nengo periods
1591 # Months and days are identical
1592 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1593 # Meiji period
1598 }
1606 )
1607 {
1608 # Taishō period
1613 }
1619 )
1620 {
1621 # Shōwa period
1626 }
1629 # Heisei period
1634 }
1636 }
1639 }
1642 }
1644 /**
1645 * Roman number formatting up to 3000
1646 *
1647 * @param $num int
1648 *
1649 * @return string
1650 */
1657 );
1662 }
1668 }
1670 }
1672 }
1674 /**
1675 * Hebrew Gematria number formatting up to 9999
1676 *
1677 * @param $num int
1678 *
1679 * @return string
1680 */
1687 );
1692 }
1704 }
1705 }
1706 }
1708 }
1714 }
1733 }
1735 }
1737 /**
1738 * Used by date() and time() to adjust the time output.
1739 *
1740 * @param $ts Int the time in date('YmdHis') format
1741 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1742 * get user timecorrection setting)
1743 * @return int
1744 */
1750 }
1763 }
1764 # Unrecognized timezone, default to 'Offset' with the stored offset.
1766 }
1770 # Global offset in minutes.
1773 }
1784 }
1787 }
1788 }
1790 # No difference ? Return time unchanged
1793 }
1796 # Generate an adjusted date; take advantage of the fact that mktime
1797 # will normalize out-of-range values so we don't have to split $minDiff
1798 # into hours and minutes.
1811 }
1813 /**
1814 * This is meant to be used by time(), date(), and timeanddate() to get
1815 * the date preference they're supposed to use, it should be used in
1816 * all children.
1817 *
1818 *<code>
1819 * function timeanddate([...], $format = true) {
1820 * $datePreference = $this->dateFormat($format);
1821 * [...]
1822 * }
1823 *</code>
1824 *
1825 * @param $usePrefs Mixed: if true, the user's preference is used
1826 * if false, the site/language default is used
1827 * if int/string, assumed to be a format.
1828 * @return string
1829 */
1838 }
1841 }
1843 // return int
1846 }
1849 }
1851 /**
1852 * Get a format string for a given type and preference
1853 * @param $type string May be date, time or both
1854 * @param $pref string The format name as it appears in Messages*.php
1855 *
1856 * @return string
1857 */
1868 }
1869 }
1871 }
1873 }
1875 /**
1876 * @param $ts Mixed: the time format which needs to be turned into a
1877 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1878 * @param $adj Bool: whether to adjust the time output according to the
1879 * user configured offset ($timecorrection)
1880 * @param $format Mixed: true to use user's date format preference
1881 * @param $timecorrection String|bool the time offset as returned by
1882 * validateTimeZone() in Special:Preferences
1883 * @return string
1884 */
1889 }
1892 }
1894 /**
1895 * @param $ts Mixed: the time format which needs to be turned into a
1896 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1897 * @param $adj Bool: whether to adjust the time output according to the
1898 * user configured offset ($timecorrection)
1899 * @param $format Mixed: true to use user's date format preference
1900 * @param $timecorrection String|bool the time offset as returned by
1901 * validateTimeZone() in Special:Preferences
1902 * @return string
1903 */
1908 }
1911 }
1913 /**
1914 * @param $ts Mixed: the time format which needs to be turned into a
1915 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1916 * @param $adj Bool: whether to adjust the time output according to the
1917 * user configured offset ($timecorrection)
1918 * @param $format Mixed: what format to return, if it's false output the
1919 * default one (default true)
1920 * @param $timecorrection String|bool the time offset as returned by
1921 * validateTimeZone() in Special:Preferences
1922 * @return string
1923 */
1928 }
1931 }
1933 /**
1934 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
1935 *
1936 * @since 1.20
1937 *
1938 * @param integer $seconds The amount of seconds.
1939 * @param array $chosenIntervals The intervals to enable.
1940 *
1941 * @return string
1942 */
1951 }
1954 }
1956 /**
1957 * Takes a number of seconds and returns an array with a set of corresponding intervals.
1958 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
1959 *
1960 * @since 1.20
1961 *
1962 * @param integer $seconds The amount of seconds.
1963 * @param array $chosenIntervals The intervals to enable.
1964 *
1965 * @return array
1966 */
1969 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
1970 }
1984 }
1985 }
1988 }
1990 /**
1991 * Internal helper function for userDate(), userTime() and userTimeAndDate()
1992 *
1993 * @param $type String: can be 'date', 'time' or 'both'
1994 * @param $ts Mixed: the time format which needs to be turned into a
1995 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1996 * @param $user User object used to get preferences for timezone and format
1997 * @param $options Array, can contain the following keys:
1998 * - 'timecorrection': time correction, can have the following values:
1999 * - true: use user's preference
2000 * - false: don't use time correction
2001 * - integer: value of time correction in minutes
2002 * - 'format': format to use, can have the following values:
2003 * - true: use user's preference
2004 * - false: use default preference
2005 * - string: format to use
2006 * @since 1.19
2007 * @return String
2008 */
2017 }
2019 }
2024 }
2027 }
2029 /**
2030 * Get the formatted date for the given timestamp and formatted for
2031 * the given user.
2032 *
2033 * @param $ts Mixed: the time format which needs to be turned into a
2034 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2035 * @param $user User object used to get preferences for timezone and format
2036 * @param $options Array, can contain the following keys:
2037 * - 'timecorrection': time correction, can have the following values:
2038 * - true: use user's preference
2039 * - false: don't use time correction
2040 * - integer: value of time correction in minutes
2041 * - 'format': format to use, can have the following values:
2042 * - true: use user's preference
2043 * - false: use default preference
2044 * - string: format to use
2045 * @since 1.19
2046 * @return String
2047 */
2050 }
2052 /**
2053 * Get the formatted time for the given timestamp and formatted for
2054 * the given user.
2055 *
2056 * @param $ts Mixed: the time format which needs to be turned into a
2057 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2058 * @param $user User object used to get preferences for timezone and format
2059 * @param $options Array, can contain the following keys:
2060 * - 'timecorrection': time correction, can have the following values:
2061 * - true: use user's preference
2062 * - false: don't use time correction
2063 * - integer: value of time correction in minutes
2064 * - 'format': format to use, can have the following values:
2065 * - true: use user's preference
2066 * - false: use default preference
2067 * - string: format to use
2068 * @since 1.19
2069 * @return String
2070 */
2073 }
2075 /**
2076 * Get the formatted date and time for the given timestamp and formatted for
2077 * the given user.
2078 *
2079 * @param $ts Mixed: the time format which needs to be turned into a
2080 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2081 * @param $user User object used to get preferences for timezone and format
2082 * @param $options Array, can contain the following keys:
2083 * - 'timecorrection': time correction, can have the following values:
2084 * - true: use user's preference
2085 * - false: don't use time correction
2086 * - integer: value of time correction in minutes
2087 * - 'format': format to use, can have the following values:
2088 * - true: use user's preference
2089 * - false: use default preference
2090 * - string: format to use
2091 * @since 1.19
2092 * @return String
2093 */
2096 }
2098 /**
2099 * @param $key string
2100 * @return array|null
2101 */
2104 }
2106 /**
2107 * @return array
2108 */
2111 }
2113 /**
2114 * @param $in
2115 * @param $out
2116 * @param $string
2117 * @return string
2118 */
2120 # This is a wrapper for iconv in all languages except esperanto,
2121 # which does some nasty x-conversions beforehand
2123 # Even with //IGNORE iconv can whine about illegal characters in
2124 # *input* string. We just ignore those too.
2125 # REF: http://bugs.php.net/bug.php?id=37166
2126 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2131 }
2133 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2135 /**
2136 * @param $matches array
2137 * @return mixed|string
2138 */
2141 }
2143 /**
2144 * @param $matches array
2145 * @return string
2146 */
2149 }
2151 /**
2152 * @param $matches array
2153 * @return string
2154 */
2158 }
2160 /**
2161 * @param $matches array
2162 * @return string
2163 */
2167 }
2169 /**
2170 * @param $matches array
2171 * @return string
2172 */
2175 }
2177 /**
2178 * @param $matches array
2179 * @return string
2180 */
2184 }
2186 /**
2187 * Make a string's first character uppercase
2188 *
2189 * @param $str string
2190 *
2191 * @return string
2192 */
2200 // fall back to more complex logic in case of multibyte strings
2202 }
2203 }
2205 /**
2206 * Convert a string to uppercase
2207 *
2208 * @param $str string
2209 * @param $first bool
2210 *
2211 * @return string
2212 */
2220 }
2223 }
2230 $str
2231 );
2234 }
2235 }
2236 }
2238 /**
2239 * @param $str string
2240 * @return mixed|string
2241 */
2253 }
2254 }
2256 /**
2257 * @param $str string
2258 * @param $first bool
2259 * @return mixed|string
2260 */
2268 }
2271 }
2278 $str
2279 );
2282 }
2283 }
2284 }
2286 /**
2287 * @param $str string
2288 * @return bool
2289 */
2292 }
2294 /**
2295 * @param $str string
2296 * @return mixed|string
2297 */
2302 // regexp to find first letter in each word (i.e. after each space)
2303 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2305 // function to use to capitalize a single char
2310 $str
2311 );
2316 $str
2317 );
2318 }
2321 }
2322 }
2324 /**
2325 * capitalize words at word breaks
2326 *
2327 * @param $str string
2328 * @return mixed
2329 */
2334 // since \b doesn't work for UTF-8, we explicitely define word break chars
2337 // find first letter after word break
2338 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2344 $str
2345 );
2350 $str
2351 );
2352 }
2357 $str
2358 );
2359 }
2360 }
2362 /**
2363 * Return a case-folded representation of $s
2364 *
2365 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2366 * and $s2 are the same except for the case of their characters. It is not
2367 * necessary for the value returned to make sense when displayed.
2368 *
2369 * Do *not* perform any other normalisation in this function. If a caller
2370 * uses this function when it should be using a more general normalisation
2371 * function, then fix the caller.
2372 *
2373 * @param $s string
2374 *
2375 * @return string
2376 */
2379 }
2381 /**
2382 * @param $s string
2383 * @return string
2384 */
2388 }
2389 # Check for non-UTF-8 URLs
2393 }
2400 }
2403 }
2406 }
2408 /**
2409 * @return array
2410 */
2413 }
2415 /**
2416 * Most writing systems use whitespace to break up words.
2417 * Some languages such as Chinese don't conventionally do this,
2418 * which requires special handling when breaking up words for
2419 * searching etc.
2420 *
2421 * @return bool
2422 */
2425 }
2427 /**
2428 * Some languages such as Chinese require word segmentation,
2429 * Specify such segmentation when overridden in derived class.
2430 *
2431 * @param $string String
2432 * @return String
2433 */
2436 }
2438 /**
2439 * Some languages have special punctuation need to be normalized.
2440 * Make such changes here.
2441 *
2442 * @param $string String
2443 * @return String
2444 */
2447 }
2449 /**
2450 * convert double-width roman characters to single-width.
2451 * range: ff00-ff5f ~= 0020-007f
2452 *
2453 * @param $string string
2454 *
2455 * @return string
2456 */
2466 }
2470 }
2472 /**
2473 * @param $string string
2474 * @param $pattern string
2475 * @return string
2476 */
2481 }
2483 /**
2484 * @param $termsArray array
2485 * @return array
2486 */
2488 # some languages, e.g. Chinese, need to do a conversion
2489 # in order for search results to be displayed correctly
2491 }
2493 /**
2494 * Get the first character of a string.
2495 *
2496 * @param $s string
2497 * @return string
2498 */
2505 $matches
2506 );
2511 }
2513 // Break down Hangul syllables to grab the first jamo
2545 }
2548 }
2549 }
2552 # Some languages may have an alternate char encoding option
2553 # (Esperanto X-coding, Japanese furigana conversion, etc)
2554 # If this language is used as the primary content language,
2555 # an override to the defaults can be set here on startup.
2556 }
2558 /**
2559 * @param $s string
2560 * @return string
2561 */
2563 # For some languages we'll want to explicitly specify
2564 # which characters make it into the edit box raw
2565 # or are converted in some way or another.
2571 }
2572 }
2574 /**
2575 * @param $s string
2576 * @return string
2577 */
2579 # Take the previous into account.
2585 }
2590 }
2591 }
2593 /**
2594 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2595 * also cleans up certain backwards-compatible sequences, converting them
2596 * to the modern Unicode equivalent.
2597 *
2598 * This is language-specific for performance reasons only.
2599 *
2600 * @param $s string
2601 *
2602 * @return string
2603 */
2610 }
2613 }
2615 /**
2616 * Transform a string using serialized data stored in the given file (which
2617 * must be in the serialized subdirectory of $IP). The file contains pairs
2618 * mapping source characters to destination characters.
2619 *
2620 * The data is cached in process memory. This will go faster if you have the
2621 * FastStringSearch extension.
2622 *
2623 * @param $file string
2624 * @param $string string
2625 *
2626 * @throws MWException
2627 * @return string
2628 */
2634 }
2636 }
2638 }
2640 /**
2641 * For right-to-left language support
2642 *
2643 * @return bool
2644 */
2647 }
2649 /**
2650 * Return the correct HTML 'dir' attribute value for this language.
2651 * @return String
2652 */
2655 }
2657 /**
2658 * Return 'left' or 'right' as appropriate alignment for line-start
2659 * for this language's text direction.
2660 *
2661 * Should be equivalent to CSS3 'start' text-align value....
2662 *
2663 * @return String
2664 */
2667 }
2669 /**
2670 * Return 'right' or 'left' as appropriate alignment for line-end
2671 * for this language's text direction.
2672 *
2673 * Should be equivalent to CSS3 'end' text-align value....
2674 *
2675 * @return String
2676 */
2679 }
2681 /**
2682 * A hidden direction mark (LRM or RLM), depending on the language direction.
2683 * Unlike getDirMark(), this function returns the character as an HTML entity.
2684 * This function should be used when the output is guaranteed to be HTML,
2685 * because it makes the output HTML source code more readable. When
2686 * the output is plain text or can be escaped, getDirMark() should be used.
2687 *
2688 * @param $opposite Boolean Get the direction mark opposite to your language
2689 * @return string
2690 */
2694 }
2696 /**
2697 * A hidden direction mark (LRM or RLM), depending on the language direction.
2698 * This function produces them as invisible Unicode characters and
2699 * the output may be hard to read and debug, so it should only be used
2700 * when the output is plain text or can be escaped. When the output is
2701 * HTML, use getDirMarkEntity() instead.
2702 *
2703 * @param $opposite Boolean Get the direction mark opposite to your language
2704 * @return string
2705 */
2711 }
2713 /**
2714 * @return array
2715 */
2718 }
2720 /**
2721 * An arrow, depending on the language direction.
2722 *
2723 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2724 * @return string
2725 */
2740 }
2741 }
2743 /**
2744 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2745 *
2746 * @return bool
2747 */
2750 }
2752 /**
2753 * @return array
2754 */
2757 }
2762 }
2767 }
2769 /**
2770 * Fill a MagicWord object with data from here
2771 *
2772 * @param $mw
2773 */
2785 }
2786 }
2793 }
2794 }
2796 /**
2797 * Add magic words to the extension array
2798 *
2799 * @param $newWords array
2800 */
2807 }
2808 }
2809 }
2811 /**
2812 * Get special page names, as an associative array
2813 * case folded alias => real name
2814 */
2816 // Cache aliases because it may be slow to load them
2818 // Initialise array
2823 }
2826 }
2828 /**
2829 * Italic is unsuitable for some languages
2830 *
2831 * @param $text String: the text to be emphasized.
2832 * @return string
2833 */
2836 }
2838 /**
2839 * Normally we output all numbers in plain en_US style, that is
2840 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2841 * point twohundredthirtyfive. However this is not suitable for all
2842 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2843 * Icelandic just want to use commas instead of dots, and dots instead
2844 * of commas like "293.291,235".
2845 *
2846 * An example of this function being called:
2847 * <code>
2848 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2849 * </code>
2850 *
2851 * See LanguageGu.php for the Gujarati implementation and
2852 * $separatorTransformTable on MessageIs.php for
2853 * the , => . and . => , implementation.
2854 *
2855 * @todo check if it's viable to use localeconv() for the decimal
2856 * separator thing.
2857 * @param $number Mixed: the string to be formatted, should be an integer
2858 * or a floating point number.
2859 * @param $nocommafy Bool: set to true for special numbers like dates
2860 * @return string
2861 */
2869 }
2870 }
2876 }
2877 }
2880 }
2882 /**
2883 * @param $number string
2884 * @return string
2885 */
2890 }
2895 }
2899 }
2901 /**
2902 * Adds commas to a given number
2903 * @since 1.19
2904 * @param $_ mixed
2905 * @return string
2906 */
2911 }
2914 // default grouping is at thousands, use the same for ###,###,### pattern too.
2917 // Ref: http://cldr.unicode.org/translation/number-patterns
2920 // For negative numbers apply the algorithm like positive number and add sign.
2923 }
2931 // the string does not have any number part. Eg: .12345
2933 }
2941 }
2945 // use the last pattern for the rest of the number
2947 }
2950 }
2951 }
2953 }
2954 }
2955 /**
2956 * @return String
2957 */
2960 }
2962 /**
2963 * @return array
2964 */
2967 }
2969 /**
2970 * @return array
2971 */
2974 }
2976 /**
2977 * Take a list of strings and build a locale-friendly comma-separated
2978 * list, using the local comma-separator message.
2979 * The last two strings are chained with an "and".
2980 *
2981 * @param $l Array
2982 * @return string
2983 */
2988 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2994 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2997 }
2998 }
3000 }
3001 }
3003 /**
3004 * Take a list of strings and build a locale-friendly comma-separated
3005 * list, using the local comma-separator message.
3006 * @param $list array of strings to put in a comma list
3007 * @return string
3008 */
3014 ),
3015 $list
3016 );
3017 }
3019 /**
3020 * Take a list of strings and build a locale-friendly semicolon-separated
3021 * list, using the local semicolon-separator message.
3022 * @param $list array of strings to put in a semicolon list
3023 * @return string
3024 */
3030 ),
3031 $list
3032 );
3033 }
3035 /**
3036 * Same as commaList, but separate it with the pipe instead.
3037 * @param $list array of strings to put in a pipe list
3038 * @return string
3039 */
3045 ),
3046 $list
3047 );
3048 }
3050 /**
3051 * Truncate a string to a specified length in bytes, appending an optional
3052 * string (e.g. for ellipses)
3053 *
3054 * The database offers limited byte lengths for some columns in the database;
3055 * multi-byte character sets mean we need to ensure that only whole characters
3056 * are included, otherwise broken characters can be passed to the user
3057 *
3058 * If $length is negative, the string will be truncated from the beginning
3059 *
3060 * @param $string String to truncate
3061 * @param $length Int: maximum length (including ellipses)
3062 * @param $ellipsis String to append to the truncated text
3063 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3064 * $adjustLength was introduced in 1.18, before that behaved as if false.
3065 * @return string
3066 */
3068 # Use the localized ellipsis character
3071 }
3072 # Check if there is no need to truncate
3077 }
3079 # If ellipsis length is >= $length then we can't apply $adjustLength
3082 # Otherwise, truncate and add ellipsis...
3095 }
3096 }
3097 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3098 # This check is *not* redundant if $adjustLength, due to the single case where
3099 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3104 }
3105 }
3107 /**
3108 * Remove bytes that represent an incomplete Unicode character
3109 * at the end of string (e.g. bytes of the char are missing)
3110 *
3111 * @param $string String
3112 * @return string
3113 */
3119 # We got the first byte only of a multibyte char; remove it.
3124 {
3125 # We chopped in the middle of a character; remove it
3127 }
3128 }
3130 }
3132 /**
3133 * Remove bytes that represent an incomplete Unicode character
3134 * at the start of string (e.g. bytes of the char are missing)
3135 *
3136 * @param $string String
3137 * @return string
3138 */
3143 # We chopped in the middle of a character; remove the whole thing
3145 }
3146 }
3148 }
3150 /**
3151 * Truncate a string of valid HTML to a specified length in bytes,
3152 * appending an optional string (e.g. for ellipses), and return valid HTML
3153 *
3154 * This is only intended for styled/linked text, such as HTML with
3155 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3156 * Also, this will not detect things like "display:none" CSS.
3157 *
3158 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3159 *
3160 * @param string $text HTML string to truncate
3161 * @param int $length (zero/positive) Maximum length (including ellipses)
3162 * @param string $ellipsis String to append to the truncated text
3163 * @return string
3164 */
3166 # Use the localized ellipsis character
3169 }
3170 # Check if there is clearly no need to truncate
3175 }
3189 # Consider truncation once the display length has reached the maximim.
3190 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3191 # Check that we're not in the middle of a bracket/entity...
3195 # Save where we are; we will truncate here unless there turn out to
3196 # be so few remaining characters that truncation is not necessary.
3199 }
3201 # String in fact does need truncation, the truncation point was OK.
3206 }
3207 }
3210 # Read the next char...
3228 }
3234 // Name found (e.g. "<a href=..."), add on tag attributes...
3236 }
3242 }
3245 // Save state without $ch. We want to *hit* the first
3246 // display char (to get tags) but not *use* it if truncating.
3248 }
3253 // Add the next $max display text chars after this in one swoop...
3258 }
3259 }
3260 }
3261 }
3262 // Close the last tag if left unclosed by bad HTML
3266 }
3268 }
3270 /**
3271 * truncateHtml() helper function
3272 * like strcspn() but adds the skipped chars to $ret
3273 *
3274 * @param $ret
3275 * @param $text
3276 * @param $search
3277 * @param $start
3278 * @param $len
3279 * @return int
3280 */
3286 }
3291 }
3293 }
3295 /**
3296 * truncateHtml() helper function
3297 * (a) push or pop $tag from $openTags as needed
3298 * (b) clear $tag value
3299 * @param &$tag string Current HTML tag name we are looking at
3300 * @param $tagType int (0-open tag, 1-close tag)
3301 * @param $lastCh string Character before the '>' that ended this tag
3302 * @param &$openTags array Open tag stack (not accounting for $tag)
3303 */
3312 }
3313 }
3315 }
3316 }
3318 /**
3319 * Grammatical transformations, needed for inflected languages
3320 * Invoked by putting {{grammar:case|word}} in a message
3321 *
3322 * @param $word string
3323 * @param $case string
3324 * @return string
3325 */
3330 }
3332 }
3333 /**
3334 * Get the grammar forms for the content language
3335 * @return array of grammar forms
3336 * @since 1.20
3337 */
3340 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3342 }
3344 }
3345 /**
3346 * Provides an alternative text depending on specified gender.
3347 * Usage {{gender:username|masculine|feminine|neutral}}.
3348 * username is optional, in which case the gender of current user is used,
3349 * but only in (some) interface messages; otherwise default gender is used.
3350 *
3351 * If no forms are given, an empty string is returned. If only one form is
3352 * given, it will be returned unconditionally. These details are implied by
3353 * the caller and cannot be overridden in subclasses.
3354 *
3355 * If more than one form is given, the default is to use the neutral one
3356 * if it is specified, and to use the masculine one otherwise. These
3357 * details can be overridden in subclasses.
3358 *
3359 * @param $gender string
3360 * @param $forms array
3361 *
3362 * @return string
3363 */
3367 }
3371 }
3374 }
3376 }
3378 /**
3379 * Plural form transformations, needed for some languages.
3380 * For example, there are 3 form of plural in Russian and Polish,
3381 * depending on "count mod 10". See [[w:Plural]]
3382 * For English it is pretty simple.
3383 *
3384 * Invoked by putting {{plural:count|wordform1|wordform2}}
3385 * or {{plural:count|wordform1|wordform2|wordform3}}
3386 *
3387 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3388 *
3389 * @param $count Integer: non-localized number
3390 * @param $forms Array: different plural forms
3391 * @return string Correct form of plural for $count in this language
3392 */
3396 }
3400 }
3402 /**
3403 * Checks that convertPlural was given an array and pads it to requested
3404 * amount of forms by copying the last one.
3405 *
3406 * @param $count Integer: How many forms should there be at least
3407 * @param $forms Array of forms given to convertPlural
3408 * @return array Padded array of forms or an exception if not an array
3409 */
3413 }
3415 }
3417 /**
3418 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3419 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3420 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3421 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3422 * match up with it.
3423 *
3424 * @param $str String: the validated block duration in English
3425 * @return string Somehow translated block duration
3426 * @see LanguageFi.php for example implementation
3427 */
3433 }
3434 }
3436 // Since usually only infinite or indefinite is only on list, so try
3437 // equivalents if still here.
3444 }
3445 }
3446 }
3447 // If all else fails, return the original string.
3449 }
3451 /**
3452 * languages like Chinese need to be segmented in order for the diff
3453 * to be of any use
3454 *
3455 * @param $text String
3456 * @return String
3457 */
3460 }
3462 /**
3463 * and unsegment to show the result
3464 *
3465 * @param $text String
3466 * @return String
3467 */
3470 }
3472 /**
3473 * Return the LanguageConverter used in the Language
3474 *
3475 * @since 1.19
3476 * @return LanguageConverter
3477 */
3480 }
3482 /**
3483 * convert text to all supported variants
3484 *
3485 * @param $text string
3486 * @return array
3487 */
3490 }
3492 /**
3493 * convert text to different variants of a language.
3494 *
3495 * @param $text string
3496 * @return string
3497 */
3500 }
3502 /**
3503 * Convert a Title object to a string in the preferred variant
3504 *
3505 * @param $title Title
3506 * @return string
3507 */
3510 }
3512 /**
3513 * Check if this is a language with variants
3514 *
3515 * @return bool
3516 */
3519 }
3521 /**
3522 * Check if the language has the specific variant
3523 *
3524 * @since 1.19
3525 * @param $variant string
3526 * @return bool
3527 */
3530 }
3532 /**
3533 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3534 *
3535 * @param $text string
3536 * @return string
3537 */
3540 }
3542 /**
3543 * Perform output conversion on a string, and encode for safe HTML output.
3544 * @param $text String text to be converted
3545 * @param $isTitle Bool whether this conversion is for the article title
3546 * @return string
3547 * @todo this should get integrated somewhere sane
3548 */
3551 }
3553 /**
3554 * @param $key string
3555 * @return string
3556 */
3559 }
3561 /**
3562 * Get the list of variants supported by this language
3563 * see sample implementation in LanguageZh.php
3564 *
3565 * @return array an array of language codes
3566 */
3569 }
3571 /**
3572 * @return string
3573 */
3576 }
3578 /**
3579 * @return string
3580 */
3583 }
3585 /**
3586 * @return string
3587 */
3590 }
3592 /**
3593 * If a language supports multiple variants, it is
3594 * possible that non-existing link in one variant
3595 * actually exists in another variant. this function
3596 * tries to find it. See e.g. LanguageZh.php
3597 *
3598 * @param $link String: the name of the link
3599 * @param $nt Mixed: the title object of the link
3600 * @param $ignoreOtherCond Boolean: to disable other conditions when
3601 * we need to transclude a template or update a category's link
3602 * @return null the input parameters may be modified upon return
3603 */
3606 }
3608 /**
3609 * If a language supports multiple variants, converts text
3610 * into an array of all possible variants of the text:
3611 * 'variant' => text in that variant
3612 *
3613 * @deprecated since 1.17 Use autoConvertToAllVariants()
3614 *
3615 * @param $text string
3616 *
3617 * @return string
3618 */
3621 }
3623 /**
3624 * returns language specific options used by User::getPageRenderHash()
3625 * for example, the preferred language variant
3626 *
3627 * @return string
3628 */
3631 }
3633 /**
3634 * For languages that support multiple variants, the title of an
3635 * article may be displayed differently in different variants. this
3636 * function returns the apporiate title defined in the body of the article.
3637 *
3638 * @return string
3639 */
3642 }
3644 /**
3645 * Enclose a string with the "no conversion" tag. This is used by
3646 * various functions in the Parser
3647 *
3648 * @param $text String: text to be tagged for no conversion
3649 * @param $noParse bool
3650 * @return string the tagged text
3651 */
3654 }
3656 /**
3657 * A regular expression to match legal word-trailing characters
3658 * which should be merged onto a link of the form [[foo]]bar.
3659 *
3660 * @return string
3661 */
3664 }
3666 /**
3667 * @return Language
3668 */
3671 }
3673 /**
3674 * Get the RFC 3066 code for this language object
3675 *
3676 * @return string
3677 */
3680 }
3682 /**
3683 * Get the code in Bcp47 format which we can use
3684 * inside of html lang="" tags.
3685 * @since 1.19
3686 * @return string
3687 */
3691 }
3693 }
3695 /**
3696 * @param $code string
3697 */
3700 // Ensure we don't leave an incorrect html code lying around
3702 }
3704 /**
3705 * Get the name of a file for a certain language code
3706 * @param $prefix string Prepend this to the filename
3707 * @param $code string Language code
3708 * @param $suffix string Append this to the filename
3709 * @throws MWException
3710 * @return string $prefix . $mangledCode . $suffix
3711 */
3713 // Protect against path traversal
3716 {
3718 }
3721 }
3723 /**
3724 * Get the language code from a file name. Inverse of getFileName()
3725 * @param $filename string $prefix . $languageCode . $suffix
3726 * @param $prefix string Prefix before the language code
3727 * @param $suffix string Suffix after the language code
3728 * @return string Language code, or false if $prefix or $suffix isn't found
3729 */
3730 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3736 }
3738 }
3740 /**
3741 * @param $code string
3742 * @return string
3743 */
3749 }
3751 /**
3752 * @param $code string
3753 * @return string
3754 */
3758 }
3760 /**
3761 * Get the first fallback for a given language.
3762 *
3763 * @param $code string
3764 *
3765 * @return bool|string
3766 */
3774 }
3775 }
3777 /**
3778 * Get the ordered list of fallback languages.
3779 *
3780 * @since 1.19
3781 * @param $code string Language code
3782 * @return array
3783 */
3792 }
3794 }
3795 }
3797 /**
3798 * Get all messages for a given language
3799 * WARNING: this may take a long time. If you just need all message *keys*
3800 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3801 *
3802 * @param $code string
3803 *
3804 * @return array
3805 */
3808 }
3810 /**
3811 * Get a message for a given language
3812 *
3813 * @param $key string
3814 * @param $code string
3815 *
3816 * @return string
3817 */
3820 }
3822 /**
3823 * Get all message keys for a given language. This is a faster alternative to
3824 * array_keys( Language::getMessagesFor( $code ) )
3825 *
3826 * @since 1.19
3827 * @param $code string Language code
3828 * @return array of message keys (strings)
3829 */
3832 }
3834 /**
3835 * @param $talk
3836 * @return mixed
3837 */
3841 }
3846 # Allow grammar transformations
3847 # Allowing full message-style parsing would make simple requests
3848 # such as action=raw much more expensive than they need to be.
3849 # This will hopefully cover most cases.
3853 }
3855 /**
3856 * @param $m string
3857 * @return string
3858 */
3861 }
3863 /**
3864 * @throws MWException
3865 * @return array
3866 */
3871 }
3878 }
3883 }
3885 /**
3886 * Decode an expiry (block, protection, etc) which has come from the DB
3887 *
3888 * @FIXME: why are we returnings DBMS-dependent strings???
3889 *
3890 * @param $expiry String: Database expiry String
3891 * @param $format Bool|Int true to process using language functions, or TS_ constant
3892 * to return the expiry in a given timestamp
3893 * @return String
3894 */
3900 }
3904 ? $infinityMsg
3910 }
3911 }
3913 /**
3914 * @todo Document
3915 * @param $seconds int|float
3916 * @param $format Array Optional
3917 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
3918 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
3919 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
3920 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
3921 * @return string
3922 */
3926 }
3929 }
3932 }
3954 }
3965 }
3969 }
3975 }
3983 }
3993 }
3997 }
4007 }
4008 }
4010 }
4012 /**
4013 * Format a bitrate for output, using an appropriate
4014 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4015 *
4016 * This use base 1000. For base 1024 use formatSize(), for another base
4017 * see formatComputingNumbers()
4018 *
4019 * @param $bps int
4020 * @return string
4021 */
4024 }
4026 /**
4027 * @param $size int Size of the unit
4028 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4029 * @param $messageKey string Message key to be uesd
4030 * @return string
4031 */
4036 );
4037 }
4045 }
4047 // For small sizes no decimal places necessary
4050 // For MB and bigger two decimal places are smarter
4052 }
4058 }
4060 /**
4061 * Format a size in bytes for output, using an appropriate
4062 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4063 *
4064 * This method use base 1024. For base 1000 use formatBitrate(), for
4065 * another base see formatComputingNumbers()
4066 *
4067 * @param $size int Size to format
4068 * @return string Plain text (not HTML)
4069 */
4072 }
4074 /**
4075 * Make a list item, used by various special pages
4076 *
4077 * @param $page String Page link
4078 * @param $details String Text between brackets
4079 * @param $oppositedm Boolean Add the direction mark opposite to your
4080 * language, to display text properly
4081 * @return String
4082 */
4087 wfMsgExt( 'parentheses', array( 'escape', 'replaceafter', 'language' => $this ), $details ) : '';
4089 }
4091 /**
4092 * Generate (prev x| next x) (20|50|100...) type links for paging
4093 *
4094 * @param $title Title object to link
4095 * @param $offset Integer offset parameter
4096 * @param $limit Integer limit parameter
4097 * @param $query String optional URL query parameter string
4098 * @param $atend Bool optional param for specified if this is the last page
4099 * @return String
4100 */
4101 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4102 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4104 # Make 'previous' link
4105 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4111 }
4113 # Make 'next' link
4114 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4120 }
4122 # Make links to set number of items per page
4127 }
4131 }
4133 /**
4134 * Helper function for viewPrevNext() that generates links
4135 *
4136 * @param $title Title object to link
4137 * @param $offset Integer offset parameter
4138 * @param $limit Integer limit parameter
4139 * @param $query Array extra query parameters
4140 * @param $link String text to use for the link; will be escaped
4141 * @param $tooltipMsg String name of the message to use as tooltip
4142 * @param $class String value of the "class" attribute of the link
4143 * @return String HTML fragment
4144 */
4145 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4147 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4150 }
4152 /**
4153 * Get the conversion rule title, if any.
4154 *
4155 * @return string
4156 */
4159 }
4160 }