| blob | 9b201c8d66707d20fe8980c92b3d0946d06bb3fb |
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 */
49 }
51 /**
52 * Internationalisation code
53 * @ingroup Language
54 */
57 /**
58 * @var LanguageConverter
59 */
70 /**
71 * ReplacementArray object caches
72 */
75 /**
76 * @var LocalisationCache
77 */
85 );
89 );
94 'december'
95 );
99 'december-gen'
100 );
104 );
111 );
119 );
127 );
134 );
136 /**
137 * Get a cached language object for a given language code
138 * @param $code String
139 * @return Language
140 */
144 // Don't keep a billion objects around, that's stupid.
146 }
148 }
150 }
152 /**
153 * Create a language object for a given language code
154 * @param $code String
155 * @return Language
156 */
158 // Protect against path traversal below
161 {
163 }
166 // It's not possible to customise this code with class files, so
167 // just return a Language object. This is to support uselang= hacks.
171 }
173 // Check if there is a language class for the code
179 }
181 // Keep trying the fallback list until we find an existing class
186 }
194 }
195 }
198 }
200 /**
201 * Returns true if a language code string is of a valid form, whether or
202 * not it exists. This includes codes which are used solely for
203 * customisation via the MediaWiki namespace.
204 *
205 * @param $code string
206 *
207 * @return bool
208 */
210 return
213 }
215 /**
216 * Returns true if a language code is of a valid form for the purposes of
217 * internal customisation of MediaWiki, via Messages*.php.
218 *
219 * @param $code string
220 *
221 * @since 1.18
222 * @return bool
223 */
226 }
228 /**
229 * @param $code
230 * @return String Name of the language class
231 */
237 }
238 }
240 /**
241 * Includes language class files
242 *
243 * @param $class string Name of the language class
244 */
250 }
253 // Preload base classes to work around APC/PHP5 bug
256 }
259 }
260 }
261 }
263 /**
264 * Get the LocalisationCache instance
265 *
266 * @return LocalisationCache
267 */
273 }
275 }
279 // Set the code to the name of the descendant
284 }
286 }
288 /**
289 * Reduce memory usage
290 */
294 }
295 }
297 /**
298 * Hook which will be called if this is the content language.
299 * Descendants can use this to register hook functions or modify globals
300 */
303 /**
304 * Same as getFallbacksFor for current language.
305 * @return array|bool
306 * @deprecated in 1.19
307 */
311 }
313 /**
314 * @return array
315 * @since 1.19
316 */
319 }
321 /**
322 * Exports $wgBookstoreListEn
323 * @return array
324 */
327 }
329 /**
330 * @return array
331 */
348 }
350 # Sometimes a language will be localised but not actually exist on this wiki.
354 }
355 }
357 # The above mixing may leave namespaces out of canonical order.
358 # Re-order by namespace ID number...
362 }
364 }
366 /**
367 * A convenience function that returns the same thing as
368 * getNamespaces() except with the array values changed to ' '
369 * where it found '_', useful for producing output to be displayed
370 * e.g. in <select> forms.
371 *
372 * @return array
373 */
378 }
380 }
382 /**
383 * Get a namespace value by key
384 * <code>
385 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
386 * echo $mw_ns; // prints 'MediaWiki'
387 * </code>
388 *
389 * @param $index Int: the array key of the namespace to return
390 * @return mixed, string if the namespace value exists, otherwise false
391 */
395 }
397 /**
398 * A convenience function that returns the same thing as
399 * getNsText() except with '_' changed to ' ', useful for
400 * producing output.
401 *
402 * @param $index string
403 *
404 * @return array
405 */
409 }
411 /**
412 * Returns gender-dependent namespace alias if available.
413 * @param $index Int: namespace index
414 * @param $gender String: gender key (male, female... )
415 * @return String
416 * @since 1.18
417 */
421 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
423 }
425 /**
426 * Whether this language makes distinguishes genders for example in
427 * namespaces.
428 * @return bool
429 * @since 1.18
430 */
434 // $wgExtraGenderNamespaces overrides everything
436 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
437 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
438 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
441 // Check what is in i18n files
444 }
445 }
447 /**
448 * Get a namespace key by value, case insensitive.
449 * Only matches namespace names for the current language, not the
450 * canonical ones defined in Namespace.php.
451 *
452 * @param $text String
453 * @return mixed An integer if $text is a valid value otherwise false
454 */
459 }
461 /**
462 * @return array
463 */
475 }
476 }
477 }
480 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
484 }
485 }
488 }
490 }
492 /**
493 * @return array
494 */
498 # Put namespace names and aliases into a hashtable.
499 # If this is too slow, then we should arrange it so that it is done
500 # before caching. The catch is that at pre-cache time, the above
501 # class-specific fixup hasn't been done.
505 }
508 }
512 }
513 }
514 }
516 }
518 /**
519 * Get a namespace key by value, case insensitive. Canonical namespace
520 * names override custom ones defined for the current language.
521 *
522 * @param $text String
523 * @return mixed An integer if $text is a valid value otherwise false
524 */
530 }
533 }
535 /**
536 * short names for language variants used for language conversion links.
537 *
538 * @param $code String
539 * @param $usemsg bool Use the "variantname-xyz" message if it exists
540 * @return string
541 */
547 }
552 # otherwise, output the language code
554 }
555 }
557 /**
558 * @param $name string
559 * @return string
560 */
565 }
567 }
569 /**
570 * @return array
571 */
580 );
581 }
583 /**
584 * @return array
585 */
588 }
590 /**
591 * @return array
592 */
595 }
597 /**
598 * @return array|string
599 */
607 }
608 }
610 /**
611 * @return array
612 */
615 }
617 /**
618 * @param $image
619 * @return array|null
620 */
623 }
625 /**
626 * @return array
627 */
630 }
632 /**
633 * @param $tog
634 * @return string
635 */
638 }
640 /**
641 * Get native language names, indexed by code.
642 * Only those defined in MediaWiki, no other data like CLDR.
643 * If $customisedOnly is true, only returns codes with a messages file
644 *
645 * @param $customisedOnly bool
646 *
647 * @return array
648 */
655 }
660 }
663 // We do this using a foreach over the codes instead of a directory
664 // loop so that messages files in extensions will work correctly.
668 }
669 }
671 }
673 /**
674 * Get translated language names. This is done on best effort and
675 * by default this is exactly the same as Language::getLanguageNames.
676 * The CLDR extension provides translated names.
677 * @param $code String Language code.
678 * @return Array language code => language name
679 * @since 1.18.0
680 */
687 }
690 }
692 /**
693 * Get a message from the MediaWiki namespace.
694 *
695 * @param $msg String: message name
696 * @return string
697 */
700 }
702 /**
703 * Get the native language name of $code.
704 * Only if defined in MediaWiki, no other data like CLDR.
705 * @param $code string
706 * @return string
707 */
712 }
714 }
716 /**
717 * @param $key string
718 * @return string
719 */
722 }
724 /**
725 * @return array
726 */
731 }
733 }
735 /**
736 * @param $key string
737 * @return string
738 */
741 }
743 /**
744 * @param $key string
745 * @return string
746 */
749 }
751 /**
752 * @return array
753 */
758 }
760 }
762 /**
763 * @param $key string
764 * @return string
765 */
768 }
770 /**
771 * @param $key string
772 * @return string
773 */
776 }
778 /**
779 * @param $key string
780 * @return string
781 */
784 }
786 /**
787 * @param $key string
788 * @return string
789 */
792 }
794 /**
795 * @param $key string
796 * @return string
797 */
800 }
802 /**
803 * @param $key string
804 * @return string
805 */
808 }
810 /**
811 * This is a workalike of PHP's date() function, but with better
812 * internationalisation, a reduced set of format characters, and a better
813 * escaping format.
814 *
815 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
816 * PHP manual for definitions. There are a number of extensions, which
817 * start with "x":
818 *
819 * xn Do not translate digits of the next numeric format character
820 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
821 * xr Use roman numerals for the next numeric format character
822 * xh Use hebrew numerals for the next numeric format character
823 * xx Literal x
824 * xg Genitive month name
825 *
826 * xij j (day number) in Iranian calendar
827 * xiF F (month name) in Iranian calendar
828 * xin n (month number) in Iranian calendar
829 * xiy y (two digit year) in Iranian calendar
830 * xiY Y (full year) in Iranian calendar
831 *
832 * xjj j (day number) in Hebrew calendar
833 * xjF F (month name) in Hebrew calendar
834 * xjt t (days in month) in Hebrew calendar
835 * xjx xg (genitive month name) in Hebrew calendar
836 * xjn n (month number) in Hebrew calendar
837 * xjY Y (full year) in Hebrew calendar
838 *
839 * xmj j (day number) in Hijri calendar
840 * xmF F (month name) in Hijri calendar
841 * xmn n (month number) in Hijri calendar
842 * xmY Y (full year) in Hijri calendar
843 *
844 * xkY Y (full year) in Thai solar calendar. Months and days are
845 * identical to the Gregorian calendar
846 * xoY Y (full year) in Minguo calendar or Juche year.
847 * Months and days are identical to the
848 * Gregorian calendar
849 * xtY Y (full year) in Japanese nengo. Months and days are
850 * identical to the Gregorian calendar
851 *
852 * Characters enclosed in double quotes will be considered literal (with
853 * the quotes themselves removed). Unmatched quotes will be considered
854 * literal quotes. Example:
855 *
856 * "The month is" F => The month is January
857 * i's" => 20'11"
858 *
859 * Backslash escaping is also supported.
860 *
861 * Input timestamp is assumed to be pre-normalized to the desired local
862 * time zone, if any.
863 *
864 * @param $format String
865 * @param $ts String: 14-character timestamp
866 * YYYYMMDDHHMMSS
867 * 01234567890123
868 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
869 *
870 * @return string
871 */
890 }
892 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
894 }
932 }
938 }
944 }
950 }
956 }
963 }
969 }
975 }
984 }
990 }
996 }
1011 }
1017 }
1023 }
1029 }
1035 }
1041 }
1047 }
1056 }
1062 }
1068 }
1074 }
1080 }
1086 }
1095 }
1127 }
1133 }
1139 }
1143 # Backslash escaping
1148 }
1151 # Quoted literal
1155 # No terminating quote, assume literal "
1160 }
1162 # Quote at end of string, assume literal "
1164 }
1168 }
1181 }
1182 }
1183 }
1185 }
1190 /**
1191 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1192 * Gregorian dates to Iranian dates. Originally written in C, it
1193 * is released under the terms of GNU Lesser General Public
1194 * License. Conversion to PHP was performed by Niklas Laxström.
1195 *
1196 * Link: http://www.farsiweb.info/jalali/jalali.c
1197 *
1198 * @param $ts string
1199 *
1200 * @return string
1201 */
1207 # Days passed from the beginning (including leap years)
1213 // Add days of the past months of this year
1216 }
1218 // Leap years
1221 }
1223 // Days passed in current month
1237 }
1241 }
1247 }
1249 /**
1250 * Converting Gregorian dates to Hijri dates.
1251 *
1252 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1253 *
1254 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1255 *
1256 * @param $ts string
1257 *
1258 * @return string
1259 */
1273 )
1274 {
1282 }
1287 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1288 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1294 }
1296 /**
1297 * Converting Gregorian dates to Hebrew dates.
1298 *
1299 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1300 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1301 * to translate the relevant functions into PHP and release them under
1302 * GNU GPL.
1303 *
1304 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1305 * and Adar II is 14. In a non-leap year, Adar is 6.
1306 *
1307 * @param $ts string
1308 *
1309 * @return string
1310 */
1312 # Parse date
1317 # Calculate Hebrew year
1320 # Month number when September = 1, August = 12
1323 # Next year
1327 }
1329 # Calculate day of year from 1 September
1333 # February
1335 # Check if the year is leap
1338 }
1343 }
1344 }
1346 # Calculate the start of the Hebrew year
1349 # Calculate next year's start
1351 # Day is before the start of the year - it is the previous year
1352 # Next year's start
1354 # Previous year
1357 # Add days since previous year's 1 September
1360 # Leap year
1362 }
1363 # Start of the new (previous) year
1366 # Next year's start
1368 }
1370 # Calculate Hebrew day of year
1373 # Difference between year's days
1375 # Add 12 (or 13 for leap years) days to ignore the difference between
1376 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1377 # difference is only about the year type
1382 }
1384 # Check the year pattern, and is leap year
1385 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1386 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1387 # and non-leap years
1389 # Check if leap year
1392 # Calculate day in the month from number of day in the Hebrew year
1393 # Don't check Adar - if the day is not in Adar, we will stop before;
1394 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1399 # Calculate days in this month
1401 # Adar in a leap year
1403 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1406 # Day in Adar I
1409 # Subtract the days of Adar I
1411 # Try Adar II
1414 # Day in Adar II
1416 }
1417 }
1418 }
1420 # Cheshvan in a complete year (otherwise as the rule below)
1423 # Kislev in an incomplete year (otherwise as the rule below)
1426 # Odd months have 30 days, even have 29
1428 }
1430 # In the current month
1433 # Subtract the days of the current month
1435 # Try in the next month
1437 }
1438 }
1441 }
1443 /**
1444 * This calculates the Hebrew year start, as days since 1 September.
1445 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1446 * Used for Hebrew date.
1447 *
1448 * @param $year int
1449 *
1450 * @return string
1451 */
1458 }
1462 }
1472 }
1476 }
1478 /**
1479 * Algorithm to convert Gregorian dates to Thai solar dates,
1480 * Minguo dates or Minguo dates.
1481 *
1482 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1483 * http://en.wikipedia.org/wiki/Minguo_calendar
1484 * http://en.wikipedia.org/wiki/Japanese_era_name
1485 *
1486 * @param $ts String: 14-character timestamp
1487 * @param $cName String: calender name
1488 * @return Array: converted year, month, day
1489 */
1496 # Thai solar dates
1497 # Add 543 years to the Gregorian calendar
1498 # Months and days are identical
1501 # Minguo dates
1502 # Deduct 1911 years from the Gregorian calendar
1503 # Months and days are identical
1506 # Nengō dates up to Meiji period
1507 # Deduct years from the Gregorian calendar
1508 # depending on the nengo periods
1509 # Months and days are identical
1510 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1511 # Meiji period
1516 }
1524 )
1525 {
1526 # Taishō period
1531 }
1537 )
1538 {
1539 # Shōwa period
1544 }
1547 # Heisei period
1552 }
1554 }
1557 }
1560 }
1562 /**
1563 * Roman number formatting up to 3000
1564 *
1565 * @param $num int
1566 *
1567 * @return string
1568 */
1575 );
1580 }
1586 }
1588 }
1590 }
1592 /**
1593 * Hebrew Gematria number formatting up to 9999
1594 *
1595 * @param $num int
1596 *
1597 * @return string
1598 */
1605 );
1610 }
1622 }
1623 }
1624 }
1626 }
1632 }
1651 }
1653 }
1655 /**
1656 * Used by date() and time() to adjust the time output.
1657 *
1658 * @param $ts Int the time in date('YmdHis') format
1659 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1660 * get user timecorrection setting)
1661 * @return int
1662 */
1668 }
1681 }
1682 # Unrecognized timezone, default to 'Offset' with the stored offset.
1684 }
1688 # Global offset in minutes.
1691 }
1702 }
1705 }
1706 }
1708 # No difference ? Return time unchanged
1711 }
1714 # Generate an adjusted date; take advantage of the fact that mktime
1715 # will normalize out-of-range values so we don't have to split $minDiff
1716 # into hours and minutes.
1729 }
1731 /**
1732 * This is meant to be used by time(), date(), and timeanddate() to get
1733 * the date preference they're supposed to use, it should be used in
1734 * all children.
1735 *
1736 *<code>
1737 * function timeanddate([...], $format = true) {
1738 * $datePreference = $this->dateFormat($format);
1739 * [...]
1740 * }
1741 *</code>
1742 *
1743 * @param $usePrefs Mixed: if true, the user's preference is used
1744 * if false, the site/language default is used
1745 * if int/string, assumed to be a format.
1746 * @return string
1747 */
1756 }
1759 }
1761 // return int
1764 }
1767 }
1769 /**
1770 * Get a format string for a given type and preference
1771 * @param $type string May be date, time or both
1772 * @param $pref string The format name as it appears in Messages*.php
1773 *
1774 * @return string
1775 */
1786 }
1787 }
1789 }
1791 }
1793 /**
1794 * @param $ts Mixed: the time format which needs to be turned into a
1795 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1796 * @param $adj Bool: whether to adjust the time output according to the
1797 * user configured offset ($timecorrection)
1798 * @param $format Mixed: true to use user's date format preference
1799 * @param $timecorrection String|bool the time offset as returned by
1800 * validateTimeZone() in Special:Preferences
1801 * @return string
1802 */
1807 }
1810 }
1812 /**
1813 * @param $ts Mixed: the time format which needs to be turned into a
1814 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1815 * @param $adj Bool: whether to adjust the time output according to the
1816 * user configured offset ($timecorrection)
1817 * @param $format Mixed: true to use user's date format preference
1818 * @param $timecorrection String|bool the time offset as returned by
1819 * validateTimeZone() in Special:Preferences
1820 * @return string
1821 */
1826 }
1829 }
1831 /**
1832 * @param $ts Mixed: the time format which needs to be turned into a
1833 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1834 * @param $adj Bool: whether to adjust the time output according to the
1835 * user configured offset ($timecorrection)
1836 * @param $format Mixed: what format to return, if it's false output the
1837 * default one (default true)
1838 * @param $timecorrection String|bool the time offset as returned by
1839 * validateTimeZone() in Special:Preferences
1840 * @return string
1841 */
1846 }
1849 }
1851 /**
1852 * Internal helper function for userDate(), userTime() and userTimeAndDate()
1853 *
1854 * @param $type String: can be 'date', 'time' or 'both'
1855 * @param $ts Mixed: the time format which needs to be turned into a
1856 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1857 * @param $user User object used to get preferences for timezone and format
1858 * @param $options Array, can contain the following keys:
1859 * - 'timecorrection': time correction, can have the following values:
1860 * - true: use user's preference
1861 * - false: don't use time correction
1862 * - integer: value of time correction in minutes
1863 * - 'format': format to use, can have the following values:
1864 * - true: use user's preference
1865 * - false: use default preference
1866 * - string: format to use
1867 * @return String
1868 */
1877 }
1879 }
1884 }
1887 }
1889 /**
1890 * Get the formatted date for the given timestamp and formatted for
1891 * the given user.
1892 *
1893 * @param $ts Mixed: the time format which needs to be turned into a
1894 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1895 * @param $user User object used to get preferences for timezone and format
1896 * @param $options Array, can contain the following keys:
1897 * - 'timecorrection': time correction, can have the following values:
1898 * - true: use user's preference
1899 * - false: don't use time correction
1900 * - integer: value of time correction in minutes
1901 * - 'format': format to use, can have the following values:
1902 * - true: use user's preference
1903 * - false: use default preference
1904 * - string: format to use
1905 * @return String
1906 */
1909 }
1911 /**
1912 * Get the formatted time for the given timestamp and formatted for
1913 * the given user.
1914 *
1915 * @param $ts Mixed: the time format which needs to be turned into a
1916 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1917 * @param $user User object used to get preferences for timezone and format
1918 * @param $options Array, can contain the following keys:
1919 * - 'timecorrection': time correction, can have the following values:
1920 * - true: use user's preference
1921 * - false: don't use time correction
1922 * - integer: value of time correction in minutes
1923 * - 'format': format to use, can have the following values:
1924 * - true: use user's preference
1925 * - false: use default preference
1926 * - string: format to use
1927 * @return String
1928 */
1931 }
1933 /**
1934 * Get the formatted date and time for the given timestamp and formatted for
1935 * the given user.
1936 *
1937 * @param $ts Mixed: the time format which needs to be turned into a
1938 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1939 * @param $user User object used to get preferences for timezone and format
1940 * @param $options Array, can contain the following keys:
1941 * - 'timecorrection': time correction, can have the following values:
1942 * - true: use user's preference
1943 * - false: don't use time correction
1944 * - integer: value of time correction in minutes
1945 * - 'format': format to use, can have the following values:
1946 * - true: use user's preference
1947 * - false: use default preference
1948 * - string: format to use
1949 * @return String
1950 */
1953 }
1955 /**
1956 * @param $key string
1957 * @return array|null
1958 */
1961 }
1963 /**
1964 * @return array
1965 */
1968 }
1970 /**
1971 * @param $in
1972 * @param $out
1973 * @param $string
1974 * @return string
1975 */
1977 # This is a wrapper for iconv in all languages except esperanto,
1978 # which does some nasty x-conversions beforehand
1980 # Even with //IGNORE iconv can whine about illegal characters in
1981 # *input* string. We just ignore those too.
1982 # REF: http://bugs.php.net/bug.php?id=37166
1983 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1988 }
1990 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1992 /**
1993 * @param $matches array
1994 * @return mixed|string
1995 */
1998 }
2000 /**
2001 * @param $matches array
2002 * @return string
2003 */
2006 }
2008 /**
2009 * @param $matches array
2010 * @return string
2011 */
2015 }
2017 /**
2018 * @param $matches array
2019 * @return string
2020 */
2024 }
2026 /**
2027 * @param $matches array
2028 * @return string
2029 */
2032 }
2034 /**
2035 * @param $matches array
2036 * @return string
2037 */
2041 }
2043 /**
2044 * Make a string's first character uppercase
2045 *
2046 * @param $str string
2047 *
2048 * @return string
2049 */
2057 // fall back to more complex logic in case of multibyte strings
2059 }
2060 }
2062 /**
2063 * Convert a string to uppercase
2064 *
2065 * @param $str string
2066 * @param $first bool
2067 *
2068 * @return string
2069 */
2077 }
2080 }
2087 $str
2088 );
2091 }
2092 }
2093 }
2095 /**
2096 * @param $str string
2097 * @return mixed|string
2098 */
2110 }
2111 }
2113 /**
2114 * @param $str string
2115 * @param $first bool
2116 * @return mixed|string
2117 */
2125 }
2128 }
2135 $str
2136 );
2139 }
2140 }
2141 }
2143 /**
2144 * @param $str string
2145 * @return bool
2146 */
2149 }
2151 /**
2152 * @param $str string
2153 * @return mixed|string
2154 */
2159 // regexp to find first letter in each word (i.e. after each space)
2160 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2162 // function to use to capitalize a single char
2167 $str
2168 );
2173 $str
2174 );
2175 }
2178 }
2179 }
2181 /**
2182 * capitalize words at word breaks
2183 *
2184 * @param $str string
2185 * @return mixed
2186 */
2191 // since \b doesn't work for UTF-8, we explicitely define word break chars
2194 // find first letter after word break
2195 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2201 $str
2202 );
2207 $str
2208 );
2209 }
2214 $str
2215 );
2216 }
2217 }
2219 /**
2220 * Return a case-folded representation of $s
2221 *
2222 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2223 * and $s2 are the same except for the case of their characters. It is not
2224 * necessary for the value returned to make sense when displayed.
2225 *
2226 * Do *not* perform any other normalisation in this function. If a caller
2227 * uses this function when it should be using a more general normalisation
2228 * function, then fix the caller.
2229 *
2230 * @param $s string
2231 *
2232 * @return string
2233 */
2236 }
2238 /**
2239 * @param $s string
2240 * @return string
2241 */
2245 }
2246 # Check for non-UTF-8 URLs
2250 }
2256 }
2259 }
2261 /**
2262 * @return array
2263 */
2266 }
2268 /**
2269 * Most writing systems use whitespace to break up words.
2270 * Some languages such as Chinese don't conventionally do this,
2271 * which requires special handling when breaking up words for
2272 * searching etc.
2273 *
2274 * @return bool
2275 */
2278 }
2280 /**
2281 * Some languages such as Chinese require word segmentation,
2282 * Specify such segmentation when overridden in derived class.
2283 *
2284 * @param $string String
2285 * @return String
2286 */
2289 }
2291 /**
2292 * Some languages have special punctuation need to be normalized.
2293 * Make such changes here.
2294 *
2295 * @param $string String
2296 * @return String
2297 */
2300 }
2302 /**
2303 * convert double-width roman characters to single-width.
2304 * range: ff00-ff5f ~= 0020-007f
2305 *
2306 * @param $string string
2307 *
2308 * @return string
2309 */
2319 }
2323 }
2325 /**
2326 * @param $string string
2327 * @param $pattern string
2328 * @return string
2329 */
2334 }
2336 /**
2337 * @param $termsArray array
2338 * @return array
2339 */
2341 # some languages, e.g. Chinese, need to do a conversion
2342 # in order for search results to be displayed correctly
2344 }
2346 /**
2347 * Get the first character of a string.
2348 *
2349 * @param $s string
2350 * @return string
2351 */
2358 $matches
2359 );
2364 }
2366 // Break down Hangul syllables to grab the first jamo
2398 }
2401 }
2402 }
2405 # Some languages may have an alternate char encoding option
2406 # (Esperanto X-coding, Japanese furigana conversion, etc)
2407 # If this language is used as the primary content language,
2408 # an override to the defaults can be set here on startup.
2409 }
2411 /**
2412 * @param $s string
2413 * @return string
2414 */
2416 # For some languages we'll want to explicitly specify
2417 # which characters make it into the edit box raw
2418 # or are converted in some way or another.
2424 }
2425 }
2427 /**
2428 * @param $s string
2429 * @return string
2430 */
2432 # Take the previous into account.
2438 }
2443 }
2444 }
2446 /**
2447 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2448 * also cleans up certain backwards-compatible sequences, converting them
2449 * to the modern Unicode equivalent.
2450 *
2451 * This is language-specific for performance reasons only.
2452 *
2453 * @param $s string
2454 *
2455 * @return string
2456 */
2463 }
2466 }
2468 /**
2469 * Transform a string using serialized data stored in the given file (which
2470 * must be in the serialized subdirectory of $IP). The file contains pairs
2471 * mapping source characters to destination characters.
2472 *
2473 * The data is cached in process memory. This will go faster if you have the
2474 * FastStringSearch extension.
2475 *
2476 * @param $file string
2477 * @param $string string
2478 *
2479 * @return string
2480 */
2486 }
2488 }
2490 }
2492 /**
2493 * For right-to-left language support
2494 *
2495 * @return bool
2496 */
2499 }
2501 /**
2502 * Return the correct HTML 'dir' attribute value for this language.
2503 * @return String
2504 */
2507 }
2509 /**
2510 * Return 'left' or 'right' as appropriate alignment for line-start
2511 * for this language's text direction.
2512 *
2513 * Should be equivalent to CSS3 'start' text-align value....
2514 *
2515 * @return String
2516 */
2519 }
2521 /**
2522 * Return 'right' or 'left' as appropriate alignment for line-end
2523 * for this language's text direction.
2524 *
2525 * Should be equivalent to CSS3 'end' text-align value....
2526 *
2527 * @return String
2528 */
2531 }
2533 /**
2534 * A hidden direction mark (LRM or RLM), depending on the language direction
2535 *
2536 * @param $opposite Boolean Get the direction mark opposite to your language
2537 * @return string
2538 */
2544 }
2546 /**
2547 * @return array
2548 */
2551 }
2553 /**
2554 * An arrow, depending on the language direction
2555 *
2556 * @return string
2557 */
2560 }
2562 /**
2563 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2564 *
2565 * @return bool
2566 */
2569 }
2571 /**
2572 * @return array
2573 */
2576 }
2581 }
2586 }
2588 /**
2589 * Fill a MagicWord object with data from here
2590 *
2591 * @param $mw
2592 */
2604 }
2605 }
2612 }
2613 }
2615 /**
2616 * Add magic words to the extension array
2617 *
2618 * @param $newWords array
2619 */
2626 }
2627 }
2628 }
2630 /**
2631 * Get special page names, as an associative array
2632 * case folded alias => real name
2633 */
2635 // Cache aliases because it may be slow to load them
2637 // Initialise array
2642 }
2645 }
2647 /**
2648 * Italic is unsuitable for some languages
2649 *
2650 * @param $text String: the text to be emphasized.
2651 * @return string
2652 */
2655 }
2657 /**
2658 * Normally we output all numbers in plain en_US style, that is
2659 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2660 * point twohundredthirtyfive. However this is not suitable for all
2661 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2662 * Icelandic just want to use commas instead of dots, and dots instead
2663 * of commas like "293.291,235".
2664 *
2665 * An example of this function being called:
2666 * <code>
2667 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2668 * </code>
2669 *
2670 * See LanguageGu.php for the Gujarati implementation and
2671 * $separatorTransformTable on MessageIs.php for
2672 * the , => . and . => , implementation.
2673 *
2674 * @todo check if it's viable to use localeconv() for the decimal
2675 * separator thing.
2676 * @param $number Mixed: the string to be formatted, should be an integer
2677 * or a floating point number.
2678 * @param $nocommafy Bool: set to true for special numbers like dates
2679 * @return string
2680 */
2688 }
2689 }
2695 }
2696 }
2699 }
2701 /**
2702 * @param $number string
2703 * @return string
2704 */
2709 }
2714 }
2718 }
2720 /**
2721 * Adds commas to a given number
2722 * @since 1.19
2723 * @param $_ mixed
2724 * @return string
2725 */
2730 // default grouping is at thousands, use the same for ###,###,### pattern too.
2733 // Ref: http://cldr.unicode.org/translation/number-patterns
2736 // For negative numbers apply the algorithm like positive number and add sign.
2739 }
2747 // the string does not have any number part. Eg: .12345
2749 }
2757 }
2761 // use the last pattern for the rest of the number
2763 }
2766 }
2767 }
2769 }
2770 }
2771 /**
2772 * @return String
2773 */
2776 }
2778 /**
2779 * @return array
2780 */
2783 }
2785 /**
2786 * @return array
2787 */
2790 }
2792 /**
2793 * Take a list of strings and build a locale-friendly comma-separated
2794 * list, using the local comma-separator message.
2795 * The last two strings are chained with an "and".
2796 *
2797 * @param $l Array
2798 * @return string
2799 */
2804 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2810 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2813 }
2814 }
2816 }
2817 }
2819 /**
2820 * Take a list of strings and build a locale-friendly comma-separated
2821 * list, using the local comma-separator message.
2822 * @param $list array of strings to put in a comma list
2823 * @return string
2824 */
2830 ),
2831 $list
2832 );
2833 }
2835 /**
2836 * Take a list of strings and build a locale-friendly semicolon-separated
2837 * list, using the local semicolon-separator message.
2838 * @param $list array of strings to put in a semicolon list
2839 * @return string
2840 */
2846 ),
2847 $list
2848 );
2849 }
2851 /**
2852 * Same as commaList, but separate it with the pipe instead.
2853 * @param $list array of strings to put in a pipe list
2854 * @return string
2855 */
2861 ),
2862 $list
2863 );
2864 }
2866 /**
2867 * Truncate a string to a specified length in bytes, appending an optional
2868 * string (e.g. for ellipses)
2869 *
2870 * The database offers limited byte lengths for some columns in the database;
2871 * multi-byte character sets mean we need to ensure that only whole characters
2872 * are included, otherwise broken characters can be passed to the user
2873 *
2874 * If $length is negative, the string will be truncated from the beginning
2875 *
2876 * @param $string String to truncate
2877 * @param $length Int: maximum length (including ellipses)
2878 * @param $ellipsis String to append to the truncated text
2879 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
2880 * $adjustLength was introduced in 1.18, before that behaved as if false.
2881 * @return string
2882 */
2884 # Use the localized ellipsis character
2887 }
2888 # Check if there is no need to truncate
2893 }
2895 # If ellipsis length is >= $length then we can't apply $adjustLength
2898 # Otherwise, truncate and add ellipsis...
2911 }
2912 }
2913 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
2914 # This check is *not* redundant if $adjustLength, due to the single case where
2915 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
2920 }
2921 }
2923 /**
2924 * Remove bytes that represent an incomplete Unicode character
2925 * at the end of string (e.g. bytes of the char are missing)
2926 *
2927 * @param $string String
2928 * @return string
2929 */
2935 # We got the first byte only of a multibyte char; remove it.
2940 {
2941 # We chopped in the middle of a character; remove it
2943 }
2944 }
2946 }
2948 /**
2949 * Remove bytes that represent an incomplete Unicode character
2950 * at the start of string (e.g. bytes of the char are missing)
2951 *
2952 * @param $string String
2953 * @return string
2954 */
2959 # We chopped in the middle of a character; remove the whole thing
2961 }
2962 }
2964 }
2966 /**
2967 * Truncate a string of valid HTML to a specified length in bytes,
2968 * appending an optional string (e.g. for ellipses), and return valid HTML
2969 *
2970 * This is only intended for styled/linked text, such as HTML with
2971 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
2972 * Also, this will not detect things like "display:none" CSS.
2973 *
2974 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
2975 *
2976 * @param string $text HTML string to truncate
2977 * @param int $length (zero/positive) Maximum length (including ellipses)
2978 * @param string $ellipsis String to append to the truncated text
2979 * @return string
2980 */
2982 # Use the localized ellipsis character
2985 }
2986 # Check if there is clearly no need to truncate
2991 }
3005 # Consider truncation once the display length has reached the maximim.
3006 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3007 # Check that we're not in the middle of a bracket/entity...
3011 # Save where we are; we will truncate here unless there turn out to
3012 # be so few remaining characters that truncation is not necessary.
3015 }
3017 # String in fact does need truncation, the truncation point was OK.
3022 }
3023 }
3026 # Read the next char...
3044 }
3050 // Name found (e.g. "<a href=..."), add on tag attributes...
3052 }
3058 }
3061 // Save state without $ch. We want to *hit* the first
3062 // display char (to get tags) but not *use* it if truncating.
3064 }
3069 // Add the next $max display text chars after this in one swoop...
3074 }
3075 }
3076 }
3077 }
3078 // Close the last tag if left unclosed by bad HTML
3082 }
3084 }
3086 /**
3087 * truncateHtml() helper function
3088 * like strcspn() but adds the skipped chars to $ret
3089 *
3090 * @param $ret
3091 * @param $text
3092 * @param $search
3093 * @param $start
3094 * @param $len
3095 * @return int
3096 */
3102 }
3107 }
3109 }
3111 /**
3112 * truncateHtml() helper function
3113 * (a) push or pop $tag from $openTags as needed
3114 * (b) clear $tag value
3115 * @param &$tag string Current HTML tag name we are looking at
3116 * @param $tagType int (0-open tag, 1-close tag)
3117 * @param $lastCh char|string Character before the '>' that ended this tag
3118 * @param &$openTags array Open tag stack (not accounting for $tag)
3119 */
3128 }
3129 }
3131 }
3132 }
3134 /**
3135 * Grammatical transformations, needed for inflected languages
3136 * Invoked by putting {{grammar:case|word}} in a message
3137 *
3138 * @param $word string
3139 * @param $case string
3140 * @return string
3141 */
3146 }
3148 }
3150 /**
3151 * Provides an alternative text depending on specified gender.
3152 * Usage {{gender:username|masculine|feminine|neutral}}.
3153 * username is optional, in which case the gender of current user is used,
3154 * but only in (some) interface messages; otherwise default gender is used.
3155 * If second or third parameter are not specified, masculine is used.
3156 * These details may be overriden per language.
3157 *
3158 * @param $gender string
3159 * @param $forms array
3160 *
3161 * @return string
3162 */
3166 }
3170 }
3173 }
3175 }
3177 /**
3178 * Plural form transformations, needed for some languages.
3179 * For example, there are 3 form of plural in Russian and Polish,
3180 * depending on "count mod 10". See [[w:Plural]]
3181 * For English it is pretty simple.
3182 *
3183 * Invoked by putting {{plural:count|wordform1|wordform2}}
3184 * or {{plural:count|wordform1|wordform2|wordform3}}
3185 *
3186 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3187 *
3188 * @param $count Integer: non-localized number
3189 * @param $forms Array: different plural forms
3190 * @return string Correct form of plural for $count in this language
3191 */
3195 }
3199 }
3201 /**
3202 * Checks that convertPlural was given an array and pads it to requested
3203 * amount of forms by copying the last one.
3204 *
3205 * @param $count Integer: How many forms should there be at least
3206 * @param $forms Array of forms given to convertPlural
3207 * @return array Padded array of forms or an exception if not an array
3208 */
3212 }
3214 }
3216 /**
3217 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3218 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3219 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3220 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3221 * match up with it.
3222 *
3223 * @param $str String: the validated block duration in English
3224 * @return Somehow translated block duration
3225 * @see LanguageFi.php for example implementation
3226 */
3232 }
3233 }
3235 // Since usually only infinite or indefinite is only on list, so try
3236 // equivalents if still here.
3243 }
3244 }
3245 }
3246 // If all else fails, return the original string.
3248 }
3250 /**
3251 * languages like Chinese need to be segmented in order for the diff
3252 * to be of any use
3253 *
3254 * @param $text String
3255 * @return String
3256 */
3259 }
3261 /**
3262 * and unsegment to show the result
3263 *
3264 * @param $text String
3265 * @return String
3266 */
3269 }
3271 /**
3272 * Return the LanguageConverter used in the Language
3273 * @return LanguageConverter
3274 */
3277 }
3279 /**
3280 * convert text to all supported variants
3281 *
3282 * @param $text string
3283 * @return array
3284 */
3287 }
3289 /**
3290 * convert text to different variants of a language.
3291 *
3292 * @param $text string
3293 * @return string
3294 */
3297 }
3299 /**
3300 * Convert a Title object to a string in the preferred variant
3301 *
3302 * @param $title Title
3303 * @return string
3304 */
3307 }
3309 /**
3310 * Check if this is a language with variants
3311 *
3312 * @return bool
3313 */
3316 }
3318 /**
3319 * Check if the language has the specific variant
3320 * @param $variant string
3321 * @return bool
3322 */
3325 }
3327 /**
3328 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3329 *
3330 * @param $text string
3331 * @return string
3332 */
3335 }
3337 /**
3338 * Perform output conversion on a string, and encode for safe HTML output.
3339 * @param $text String text to be converted
3340 * @param $isTitle Bool whether this conversion is for the article title
3341 * @return string
3342 * @todo this should get integrated somewhere sane
3343 */
3346 }
3348 /**
3349 * @param $key string
3350 * @return string
3351 */
3354 }
3356 /**
3357 * Get the list of variants supported by this language
3358 * see sample implementation in LanguageZh.php
3359 *
3360 * @return array an array of language codes
3361 */
3364 }
3366 /**
3367 * @return string
3368 */
3371 }
3373 /**
3374 * @return string
3375 */
3378 }
3380 /**
3381 * @return string
3382 */
3385 }
3387 /**
3388 * If a language supports multiple variants, it is
3389 * possible that non-existing link in one variant
3390 * actually exists in another variant. this function
3391 * tries to find it. See e.g. LanguageZh.php
3392 *
3393 * @param $link String: the name of the link
3394 * @param $nt Mixed: the title object of the link
3395 * @param $ignoreOtherCond Boolean: to disable other conditions when
3396 * we need to transclude a template or update a category's link
3397 * @return null the input parameters may be modified upon return
3398 */
3401 }
3403 /**
3404 * If a language supports multiple variants, converts text
3405 * into an array of all possible variants of the text:
3406 * 'variant' => text in that variant
3407 *
3408 * @deprecated since 1.17 Use autoConvertToAllVariants()
3409 *
3410 * @param $text string
3411 *
3412 * @return string
3413 */
3416 }
3418 /**
3419 * returns language specific options used by User::getPageRenderHash()
3420 * for example, the preferred language variant
3421 *
3422 * @return string
3423 */
3426 }
3428 /**
3429 * For languages that support multiple variants, the title of an
3430 * article may be displayed differently in different variants. this
3431 * function returns the apporiate title defined in the body of the article.
3432 *
3433 * @return string
3434 */
3437 }
3439 /**
3440 * Enclose a string with the "no conversion" tag. This is used by
3441 * various functions in the Parser
3442 *
3443 * @param $text String: text to be tagged for no conversion
3444 * @param $noParse bool
3445 * @return string the tagged text
3446 */
3449 }
3451 /**
3452 * A regular expression to match legal word-trailing characters
3453 * which should be merged onto a link of the form [[foo]]bar.
3454 *
3455 * @return string
3456 */
3459 }
3461 /**
3462 * @return Language
3463 */
3466 }
3468 /**
3469 * Get the RFC 3066 code for this language object
3470 *
3471 * @return string
3472 */
3475 }
3477 /**
3478 * Get the code in Bcp47 format which we can use
3479 * inside of html lang="" tags.
3480 * @since 1.19
3481 * @return string
3482 */
3486 }
3488 }
3490 /**
3491 * @param $code string
3492 */
3495 // Ensure we don't leave an incorrect html code lying around
3497 }
3499 /**
3500 * Get the name of a file for a certain language code
3501 * @param $prefix string Prepend this to the filename
3502 * @param $code string Language code
3503 * @param $suffix string Append this to the filename
3504 * @return string $prefix . $mangledCode . $suffix
3505 */
3507 // Protect against path traversal
3510 {
3512 }
3515 }
3517 /**
3518 * Get the language code from a file name. Inverse of getFileName()
3519 * @param $filename string $prefix . $languageCode . $suffix
3520 * @param $prefix string Prefix before the language code
3521 * @param $suffix string Suffix after the language code
3522 * @return string Language code, or false if $prefix or $suffix isn't found
3523 */
3524 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3530 }
3532 }
3534 /**
3535 * @param $code string
3536 * @return string
3537 */
3543 }
3545 /**
3546 * @param $code string
3547 * @return string
3548 */
3552 }
3554 /**
3555 * Get the first fallback for a given language.
3556 *
3557 * @param $code string
3558 *
3559 * @return false|string
3560 */
3568 }
3569 }
3571 /**
3572 * Get the ordered list of fallback languages.
3573 *
3574 * @since 1.19
3575 * @param $code string Language code
3576 * @return array
3577 */
3586 }
3588 }
3589 }
3591 /**
3592 * Get all messages for a given language
3593 * WARNING: this may take a long time. If you just need all message *keys*
3594 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3595 *
3596 * @param $code string
3597 *
3598 * @return array
3599 */
3602 }
3604 /**
3605 * Get a message for a given language
3606 *
3607 * @param $key string
3608 * @param $code string
3609 *
3610 * @return string
3611 */
3614 }
3616 /**
3617 * Get all message keys for a given language. This is a faster alternative to
3618 * array_keys( Language::getMessagesFor( $code ) )
3619 *
3620 * @since 1.19
3621 * @param $code string Language code
3622 * @return array of message keys (strings)
3623 */
3626 }
3628 /**
3629 * @param $talk
3630 * @return mixed
3631 */
3635 }
3640 # Allow grammar transformations
3641 # Allowing full message-style parsing would make simple requests
3642 # such as action=raw much more expensive than they need to be.
3643 # This will hopefully cover most cases.
3647 }
3649 /**
3650 * @param $m string
3651 * @return string
3652 */
3655 }
3657 /**
3658 * @throws MWException
3659 * @return array
3660 */
3665 }
3672 }
3677 }
3679 /**
3680 * Decode an expiry (block, protection, etc) which has come from the DB
3681 *
3682 * @param $expiry String: Database expiry String
3683 * @param $format Bool|Int true to process using language functions, or TS_ constant
3684 * to return the expiry in a given timestamp
3685 * @return String
3686 */
3692 }
3696 ? $infinityMsg
3702 }
3703 }
3705 /**
3706 * @todo Document
3707 * @param $seconds int|float
3708 * @param $format Array Optional
3709 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
3710 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
3711 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
3712 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
3713 * @return string
3714 */
3718 }
3721 }
3724 }
3746 }
3757 }
3761 }
3767 }
3775 }
3785 }
3789 }
3799 }
3800 }
3802 }
3804 /**
3805 * @param $bps int
3806 * @return string
3807 */
3812 }
3819 }
3821 }
3823 /**
3824 * Format a size in bytes for output, using an appropriate
3825 * unit (B, KB, MB or GB) according to the magnitude in question
3826 *
3827 * @param $size int Size to format
3828 * @return string Plain text (not HTML)
3829 */
3831 // For small sizes no decimal places necessary
3837 // For MB and bigger two decimal places are smarter
3844 }
3847 }
3850 }
3854 }
3856 /**
3857 * Make a list item, used by various special pages
3858 *
3859 * @param $page String Page link
3860 * @param $details String Text between brackets
3861 * @param $oppositedm Boolean Add the direction mark opposite to your
3862 * language, to display text properly
3863 * @return String
3864 */
3869 wfMsgExt( 'parentheses', array( 'escape', 'replaceafter', 'language' => $this ), $details ) : '';
3871 }
3873 /**
3874 * Generate (prev x| next x) (20|50|100...) type links for paging
3875 *
3876 * @param $title Title object to link
3877 * @param $offset Integer offset parameter
3878 * @param $limit Integer limit parameter
3879 * @param $query String optional URL query parameter string
3880 * @param $atend Bool optional param for specified if this is the last page
3881 * @return String
3882 */
3883 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
3884 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
3886 # Make 'previous' link
3887 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3893 }
3895 # Make 'next' link
3896 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3902 }
3904 # Make links to set number of items per page
3909 }
3913 }
3915 /**
3916 * Helper function for viewPrevNext() that generates links
3917 *
3918 * @param $title Title object to link
3919 * @param $offset Integer offset parameter
3920 * @param $limit Integer limit parameter
3921 * @param $query Array extra query parameters
3922 * @param $link String text to use for the link; will be escaped
3923 * @param $tooltipMsg String name of the message to use as tooltip
3924 * @param $class String value of the "class" attribute of the link
3925 * @return String HTML fragment
3926 */
3927 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
3929 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3932 }
3934 /**
3935 * Get the conversion rule title, if any.
3936 *
3937 * @return string
3938 */
3941 }
3942 }