| blob | 56367dbf7a88b1d2dbbb8591a64f3bc4f6d58d9c |
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 * @since 1.19
1868 * @return String
1869 */
1878 }
1880 }
1885 }
1888 }
1890 /**
1891 * Get the formatted date for the given timestamp and formatted for
1892 * the given user.
1893 *
1894 * @param $ts Mixed: the time format which needs to be turned into a
1895 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1896 * @param $user User object used to get preferences for timezone and format
1897 * @param $options Array, can contain the following keys:
1898 * - 'timecorrection': time correction, can have the following values:
1899 * - true: use user's preference
1900 * - false: don't use time correction
1901 * - integer: value of time correction in minutes
1902 * - 'format': format to use, can have the following values:
1903 * - true: use user's preference
1904 * - false: use default preference
1905 * - string: format to use
1906 * @since 1.19
1907 * @return String
1908 */
1911 }
1913 /**
1914 * Get the formatted time for the given timestamp and formatted for
1915 * the given user.
1916 *
1917 * @param $ts Mixed: the time format which needs to be turned into a
1918 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1919 * @param $user User object used to get preferences for timezone and format
1920 * @param $options Array, can contain the following keys:
1921 * - 'timecorrection': time correction, can have the following values:
1922 * - true: use user's preference
1923 * - false: don't use time correction
1924 * - integer: value of time correction in minutes
1925 * - 'format': format to use, can have the following values:
1926 * - true: use user's preference
1927 * - false: use default preference
1928 * - string: format to use
1929 * @since 1.19
1930 * @return String
1931 */
1934 }
1936 /**
1937 * Get the formatted date and time for the given timestamp and formatted for
1938 * the given user.
1939 *
1940 * @param $ts Mixed: the time format which needs to be turned into a
1941 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1942 * @param $user User object used to get preferences for timezone and format
1943 * @param $options Array, can contain the following keys:
1944 * - 'timecorrection': time correction, can have the following values:
1945 * - true: use user's preference
1946 * - false: don't use time correction
1947 * - integer: value of time correction in minutes
1948 * - 'format': format to use, can have the following values:
1949 * - true: use user's preference
1950 * - false: use default preference
1951 * - string: format to use
1952 * @since 1.19
1953 * @return String
1954 */
1957 }
1959 /**
1960 * @param $key string
1961 * @return array|null
1962 */
1965 }
1967 /**
1968 * @return array
1969 */
1972 }
1974 /**
1975 * @param $in
1976 * @param $out
1977 * @param $string
1978 * @return string
1979 */
1981 # This is a wrapper for iconv in all languages except esperanto,
1982 # which does some nasty x-conversions beforehand
1984 # Even with //IGNORE iconv can whine about illegal characters in
1985 # *input* string. We just ignore those too.
1986 # REF: http://bugs.php.net/bug.php?id=37166
1987 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1992 }
1994 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1996 /**
1997 * @param $matches array
1998 * @return mixed|string
1999 */
2002 }
2004 /**
2005 * @param $matches array
2006 * @return string
2007 */
2010 }
2012 /**
2013 * @param $matches array
2014 * @return string
2015 */
2019 }
2021 /**
2022 * @param $matches array
2023 * @return string
2024 */
2028 }
2030 /**
2031 * @param $matches array
2032 * @return string
2033 */
2036 }
2038 /**
2039 * @param $matches array
2040 * @return string
2041 */
2045 }
2047 /**
2048 * Make a string's first character uppercase
2049 *
2050 * @param $str string
2051 *
2052 * @return string
2053 */
2061 // fall back to more complex logic in case of multibyte strings
2063 }
2064 }
2066 /**
2067 * Convert a string to uppercase
2068 *
2069 * @param $str string
2070 * @param $first bool
2071 *
2072 * @return string
2073 */
2081 }
2084 }
2091 $str
2092 );
2095 }
2096 }
2097 }
2099 /**
2100 * @param $str string
2101 * @return mixed|string
2102 */
2114 }
2115 }
2117 /**
2118 * @param $str string
2119 * @param $first bool
2120 * @return mixed|string
2121 */
2129 }
2132 }
2139 $str
2140 );
2143 }
2144 }
2145 }
2147 /**
2148 * @param $str string
2149 * @return bool
2150 */
2153 }
2155 /**
2156 * @param $str string
2157 * @return mixed|string
2158 */
2163 // regexp to find first letter in each word (i.e. after each space)
2164 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2166 // function to use to capitalize a single char
2171 $str
2172 );
2177 $str
2178 );
2179 }
2182 }
2183 }
2185 /**
2186 * capitalize words at word breaks
2187 *
2188 * @param $str string
2189 * @return mixed
2190 */
2195 // since \b doesn't work for UTF-8, we explicitely define word break chars
2198 // find first letter after word break
2199 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2205 $str
2206 );
2211 $str
2212 );
2213 }
2218 $str
2219 );
2220 }
2221 }
2223 /**
2224 * Return a case-folded representation of $s
2225 *
2226 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2227 * and $s2 are the same except for the case of their characters. It is not
2228 * necessary for the value returned to make sense when displayed.
2229 *
2230 * Do *not* perform any other normalisation in this function. If a caller
2231 * uses this function when it should be using a more general normalisation
2232 * function, then fix the caller.
2233 *
2234 * @param $s string
2235 *
2236 * @return string
2237 */
2240 }
2242 /**
2243 * @param $s string
2244 * @return string
2245 */
2249 }
2250 # Check for non-UTF-8 URLs
2254 }
2260 }
2263 }
2265 /**
2266 * @return array
2267 */
2270 }
2272 /**
2273 * Most writing systems use whitespace to break up words.
2274 * Some languages such as Chinese don't conventionally do this,
2275 * which requires special handling when breaking up words for
2276 * searching etc.
2277 *
2278 * @return bool
2279 */
2282 }
2284 /**
2285 * Some languages such as Chinese require word segmentation,
2286 * Specify such segmentation when overridden in derived class.
2287 *
2288 * @param $string String
2289 * @return String
2290 */
2293 }
2295 /**
2296 * Some languages have special punctuation need to be normalized.
2297 * Make such changes here.
2298 *
2299 * @param $string String
2300 * @return String
2301 */
2304 }
2306 /**
2307 * convert double-width roman characters to single-width.
2308 * range: ff00-ff5f ~= 0020-007f
2309 *
2310 * @param $string string
2311 *
2312 * @return string
2313 */
2323 }
2327 }
2329 /**
2330 * @param $string string
2331 * @param $pattern string
2332 * @return string
2333 */
2338 }
2340 /**
2341 * @param $termsArray array
2342 * @return array
2343 */
2345 # some languages, e.g. Chinese, need to do a conversion
2346 # in order for search results to be displayed correctly
2348 }
2350 /**
2351 * Get the first character of a string.
2352 *
2353 * @param $s string
2354 * @return string
2355 */
2362 $matches
2363 );
2368 }
2370 // Break down Hangul syllables to grab the first jamo
2402 }
2405 }
2406 }
2409 # Some languages may have an alternate char encoding option
2410 # (Esperanto X-coding, Japanese furigana conversion, etc)
2411 # If this language is used as the primary content language,
2412 # an override to the defaults can be set here on startup.
2413 }
2415 /**
2416 * @param $s string
2417 * @return string
2418 */
2420 # For some languages we'll want to explicitly specify
2421 # which characters make it into the edit box raw
2422 # or are converted in some way or another.
2428 }
2429 }
2431 /**
2432 * @param $s string
2433 * @return string
2434 */
2436 # Take the previous into account.
2442 }
2447 }
2448 }
2450 /**
2451 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2452 * also cleans up certain backwards-compatible sequences, converting them
2453 * to the modern Unicode equivalent.
2454 *
2455 * This is language-specific for performance reasons only.
2456 *
2457 * @param $s string
2458 *
2459 * @return string
2460 */
2467 }
2470 }
2472 /**
2473 * Transform a string using serialized data stored in the given file (which
2474 * must be in the serialized subdirectory of $IP). The file contains pairs
2475 * mapping source characters to destination characters.
2476 *
2477 * The data is cached in process memory. This will go faster if you have the
2478 * FastStringSearch extension.
2479 *
2480 * @param $file string
2481 * @param $string string
2482 *
2483 * @return string
2484 */
2490 }
2492 }
2494 }
2496 /**
2497 * For right-to-left language support
2498 *
2499 * @return bool
2500 */
2503 }
2505 /**
2506 * Return the correct HTML 'dir' attribute value for this language.
2507 * @return String
2508 */
2511 }
2513 /**
2514 * Return 'left' or 'right' as appropriate alignment for line-start
2515 * for this language's text direction.
2516 *
2517 * Should be equivalent to CSS3 'start' text-align value....
2518 *
2519 * @return String
2520 */
2523 }
2525 /**
2526 * Return 'right' or 'left' as appropriate alignment for line-end
2527 * for this language's text direction.
2528 *
2529 * Should be equivalent to CSS3 'end' text-align value....
2530 *
2531 * @return String
2532 */
2535 }
2537 /**
2538 * A hidden direction mark (LRM or RLM), depending on the language direction
2539 *
2540 * @param $opposite Boolean Get the direction mark opposite to your language
2541 * @return string
2542 */
2548 }
2550 /**
2551 * @return array
2552 */
2555 }
2557 /**
2558 * An arrow, depending on the language direction
2559 *
2560 * @return string
2561 */
2564 }
2566 /**
2567 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2568 *
2569 * @return bool
2570 */
2573 }
2575 /**
2576 * @return array
2577 */
2580 }
2585 }
2590 }
2592 /**
2593 * Fill a MagicWord object with data from here
2594 *
2595 * @param $mw
2596 */
2608 }
2609 }
2616 }
2617 }
2619 /**
2620 * Add magic words to the extension array
2621 *
2622 * @param $newWords array
2623 */
2630 }
2631 }
2632 }
2634 /**
2635 * Get special page names, as an associative array
2636 * case folded alias => real name
2637 */
2639 // Cache aliases because it may be slow to load them
2641 // Initialise array
2646 }
2649 }
2651 /**
2652 * Italic is unsuitable for some languages
2653 *
2654 * @param $text String: the text to be emphasized.
2655 * @return string
2656 */
2659 }
2661 /**
2662 * Normally we output all numbers in plain en_US style, that is
2663 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2664 * point twohundredthirtyfive. However this is not suitable for all
2665 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2666 * Icelandic just want to use commas instead of dots, and dots instead
2667 * of commas like "293.291,235".
2668 *
2669 * An example of this function being called:
2670 * <code>
2671 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2672 * </code>
2673 *
2674 * See LanguageGu.php for the Gujarati implementation and
2675 * $separatorTransformTable on MessageIs.php for
2676 * the , => . and . => , implementation.
2677 *
2678 * @todo check if it's viable to use localeconv() for the decimal
2679 * separator thing.
2680 * @param $number Mixed: the string to be formatted, should be an integer
2681 * or a floating point number.
2682 * @param $nocommafy Bool: set to true for special numbers like dates
2683 * @return string
2684 */
2692 }
2693 }
2699 }
2700 }
2703 }
2705 /**
2706 * @param $number string
2707 * @return string
2708 */
2713 }
2718 }
2722 }
2724 /**
2725 * Adds commas to a given number
2726 * @since 1.19
2727 * @param $_ mixed
2728 * @return string
2729 */
2734 }
2737 // default grouping is at thousands, use the same for ###,###,### pattern too.
2740 // Ref: http://cldr.unicode.org/translation/number-patterns
2743 // For negative numbers apply the algorithm like positive number and add sign.
2746 }
2754 // the string does not have any number part. Eg: .12345
2756 }
2764 }
2768 // use the last pattern for the rest of the number
2770 }
2773 }
2774 }
2776 }
2777 }
2778 /**
2779 * @return String
2780 */
2783 }
2785 /**
2786 * @return array
2787 */
2790 }
2792 /**
2793 * @return array
2794 */
2797 }
2799 /**
2800 * Take a list of strings and build a locale-friendly comma-separated
2801 * list, using the local comma-separator message.
2802 * The last two strings are chained with an "and".
2803 *
2804 * @param $l Array
2805 * @return string
2806 */
2811 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2817 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2820 }
2821 }
2823 }
2824 }
2826 /**
2827 * Take a list of strings and build a locale-friendly comma-separated
2828 * list, using the local comma-separator message.
2829 * @param $list array of strings to put in a comma list
2830 * @return string
2831 */
2837 ),
2838 $list
2839 );
2840 }
2842 /**
2843 * Take a list of strings and build a locale-friendly semicolon-separated
2844 * list, using the local semicolon-separator message.
2845 * @param $list array of strings to put in a semicolon list
2846 * @return string
2847 */
2853 ),
2854 $list
2855 );
2856 }
2858 /**
2859 * Same as commaList, but separate it with the pipe instead.
2860 * @param $list array of strings to put in a pipe list
2861 * @return string
2862 */
2868 ),
2869 $list
2870 );
2871 }
2873 /**
2874 * Truncate a string to a specified length in bytes, appending an optional
2875 * string (e.g. for ellipses)
2876 *
2877 * The database offers limited byte lengths for some columns in the database;
2878 * multi-byte character sets mean we need to ensure that only whole characters
2879 * are included, otherwise broken characters can be passed to the user
2880 *
2881 * If $length is negative, the string will be truncated from the beginning
2882 *
2883 * @param $string String to truncate
2884 * @param $length Int: maximum length (including ellipses)
2885 * @param $ellipsis String to append to the truncated text
2886 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
2887 * $adjustLength was introduced in 1.18, before that behaved as if false.
2888 * @return string
2889 */
2891 # Use the localized ellipsis character
2894 }
2895 # Check if there is no need to truncate
2900 }
2902 # If ellipsis length is >= $length then we can't apply $adjustLength
2905 # Otherwise, truncate and add ellipsis...
2918 }
2919 }
2920 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
2921 # This check is *not* redundant if $adjustLength, due to the single case where
2922 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
2927 }
2928 }
2930 /**
2931 * Remove bytes that represent an incomplete Unicode character
2932 * at the end of string (e.g. bytes of the char are missing)
2933 *
2934 * @param $string String
2935 * @return string
2936 */
2942 # We got the first byte only of a multibyte char; remove it.
2947 {
2948 # We chopped in the middle of a character; remove it
2950 }
2951 }
2953 }
2955 /**
2956 * Remove bytes that represent an incomplete Unicode character
2957 * at the start of string (e.g. bytes of the char are missing)
2958 *
2959 * @param $string String
2960 * @return string
2961 */
2966 # We chopped in the middle of a character; remove the whole thing
2968 }
2969 }
2971 }
2973 /**
2974 * Truncate a string of valid HTML to a specified length in bytes,
2975 * appending an optional string (e.g. for ellipses), and return valid HTML
2976 *
2977 * This is only intended for styled/linked text, such as HTML with
2978 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
2979 * Also, this will not detect things like "display:none" CSS.
2980 *
2981 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
2982 *
2983 * @param string $text HTML string to truncate
2984 * @param int $length (zero/positive) Maximum length (including ellipses)
2985 * @param string $ellipsis String to append to the truncated text
2986 * @return string
2987 */
2989 # Use the localized ellipsis character
2992 }
2993 # Check if there is clearly no need to truncate
2998 }
3012 # Consider truncation once the display length has reached the maximim.
3013 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3014 # Check that we're not in the middle of a bracket/entity...
3018 # Save where we are; we will truncate here unless there turn out to
3019 # be so few remaining characters that truncation is not necessary.
3022 }
3024 # String in fact does need truncation, the truncation point was OK.
3029 }
3030 }
3033 # Read the next char...
3051 }
3057 // Name found (e.g. "<a href=..."), add on tag attributes...
3059 }
3065 }
3068 // Save state without $ch. We want to *hit* the first
3069 // display char (to get tags) but not *use* it if truncating.
3071 }
3076 // Add the next $max display text chars after this in one swoop...
3081 }
3082 }
3083 }
3084 }
3085 // Close the last tag if left unclosed by bad HTML
3089 }
3091 }
3093 /**
3094 * truncateHtml() helper function
3095 * like strcspn() but adds the skipped chars to $ret
3096 *
3097 * @param $ret
3098 * @param $text
3099 * @param $search
3100 * @param $start
3101 * @param $len
3102 * @return int
3103 */
3109 }
3114 }
3116 }
3118 /**
3119 * truncateHtml() helper function
3120 * (a) push or pop $tag from $openTags as needed
3121 * (b) clear $tag value
3122 * @param &$tag string Current HTML tag name we are looking at
3123 * @param $tagType int (0-open tag, 1-close tag)
3124 * @param $lastCh char|string Character before the '>' that ended this tag
3125 * @param &$openTags array Open tag stack (not accounting for $tag)
3126 */
3135 }
3136 }
3138 }
3139 }
3141 /**
3142 * Grammatical transformations, needed for inflected languages
3143 * Invoked by putting {{grammar:case|word}} in a message
3144 *
3145 * @param $word string
3146 * @param $case string
3147 * @return string
3148 */
3153 }
3155 }
3157 /**
3158 * Provides an alternative text depending on specified gender.
3159 * Usage {{gender:username|masculine|feminine|neutral}}.
3160 * username is optional, in which case the gender of current user is used,
3161 * but only in (some) interface messages; otherwise default gender is used.
3162 * If second or third parameter are not specified, masculine is used.
3163 * These details may be overriden per language.
3164 *
3165 * @param $gender string
3166 * @param $forms array
3167 *
3168 * @return string
3169 */
3173 }
3177 }
3180 }
3182 }
3184 /**
3185 * Plural form transformations, needed for some languages.
3186 * For example, there are 3 form of plural in Russian and Polish,
3187 * depending on "count mod 10". See [[w:Plural]]
3188 * For English it is pretty simple.
3189 *
3190 * Invoked by putting {{plural:count|wordform1|wordform2}}
3191 * or {{plural:count|wordform1|wordform2|wordform3}}
3192 *
3193 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3194 *
3195 * @param $count Integer: non-localized number
3196 * @param $forms Array: different plural forms
3197 * @return string Correct form of plural for $count in this language
3198 */
3202 }
3206 }
3208 /**
3209 * Checks that convertPlural was given an array and pads it to requested
3210 * amount of forms by copying the last one.
3211 *
3212 * @param $count Integer: How many forms should there be at least
3213 * @param $forms Array of forms given to convertPlural
3214 * @return array Padded array of forms or an exception if not an array
3215 */
3219 }
3221 }
3223 /**
3224 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3225 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3226 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3227 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3228 * match up with it.
3229 *
3230 * @param $str String: the validated block duration in English
3231 * @return Somehow translated block duration
3232 * @see LanguageFi.php for example implementation
3233 */
3239 }
3240 }
3242 // Since usually only infinite or indefinite is only on list, so try
3243 // equivalents if still here.
3250 }
3251 }
3252 }
3253 // If all else fails, return the original string.
3255 }
3257 /**
3258 * languages like Chinese need to be segmented in order for the diff
3259 * to be of any use
3260 *
3261 * @param $text String
3262 * @return String
3263 */
3266 }
3268 /**
3269 * and unsegment to show the result
3270 *
3271 * @param $text String
3272 * @return String
3273 */
3276 }
3278 /**
3279 * Return the LanguageConverter used in the Language
3280 * @return LanguageConverter
3281 */
3284 }
3286 /**
3287 * convert text to all supported variants
3288 *
3289 * @param $text string
3290 * @return array
3291 */
3294 }
3296 /**
3297 * convert text to different variants of a language.
3298 *
3299 * @param $text string
3300 * @return string
3301 */
3304 }
3306 /**
3307 * Convert a Title object to a string in the preferred variant
3308 *
3309 * @param $title Title
3310 * @return string
3311 */
3314 }
3316 /**
3317 * Check if this is a language with variants
3318 *
3319 * @return bool
3320 */
3323 }
3325 /**
3326 * Check if the language has the specific variant
3327 * @param $variant string
3328 * @return bool
3329 */
3332 }
3334 /**
3335 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3336 *
3337 * @param $text string
3338 * @return string
3339 */
3342 }
3344 /**
3345 * Perform output conversion on a string, and encode for safe HTML output.
3346 * @param $text String text to be converted
3347 * @param $isTitle Bool whether this conversion is for the article title
3348 * @return string
3349 * @todo this should get integrated somewhere sane
3350 */
3353 }
3355 /**
3356 * @param $key string
3357 * @return string
3358 */
3361 }
3363 /**
3364 * Get the list of variants supported by this language
3365 * see sample implementation in LanguageZh.php
3366 *
3367 * @return array an array of language codes
3368 */
3371 }
3373 /**
3374 * @return string
3375 */
3378 }
3380 /**
3381 * @return string
3382 */
3385 }
3387 /**
3388 * @return string
3389 */
3392 }
3394 /**
3395 * If a language supports multiple variants, it is
3396 * possible that non-existing link in one variant
3397 * actually exists in another variant. this function
3398 * tries to find it. See e.g. LanguageZh.php
3399 *
3400 * @param $link String: the name of the link
3401 * @param $nt Mixed: the title object of the link
3402 * @param $ignoreOtherCond Boolean: to disable other conditions when
3403 * we need to transclude a template or update a category's link
3404 * @return null the input parameters may be modified upon return
3405 */
3408 }
3410 /**
3411 * If a language supports multiple variants, converts text
3412 * into an array of all possible variants of the text:
3413 * 'variant' => text in that variant
3414 *
3415 * @deprecated since 1.17 Use autoConvertToAllVariants()
3416 *
3417 * @param $text string
3418 *
3419 * @return string
3420 */
3423 }
3425 /**
3426 * returns language specific options used by User::getPageRenderHash()
3427 * for example, the preferred language variant
3428 *
3429 * @return string
3430 */
3433 }
3435 /**
3436 * For languages that support multiple variants, the title of an
3437 * article may be displayed differently in different variants. this
3438 * function returns the apporiate title defined in the body of the article.
3439 *
3440 * @return string
3441 */
3444 }
3446 /**
3447 * Enclose a string with the "no conversion" tag. This is used by
3448 * various functions in the Parser
3449 *
3450 * @param $text String: text to be tagged for no conversion
3451 * @param $noParse bool
3452 * @return string the tagged text
3453 */
3456 }
3458 /**
3459 * A regular expression to match legal word-trailing characters
3460 * which should be merged onto a link of the form [[foo]]bar.
3461 *
3462 * @return string
3463 */
3466 }
3468 /**
3469 * @return Language
3470 */
3473 }
3475 /**
3476 * Get the RFC 3066 code for this language object
3477 *
3478 * @return string
3479 */
3482 }
3484 /**
3485 * Get the code in Bcp47 format which we can use
3486 * inside of html lang="" tags.
3487 * @since 1.19
3488 * @return string
3489 */
3493 }
3495 }
3497 /**
3498 * @param $code string
3499 */
3502 // Ensure we don't leave an incorrect html code lying around
3504 }
3506 /**
3507 * Get the name of a file for a certain language code
3508 * @param $prefix string Prepend this to the filename
3509 * @param $code string Language code
3510 * @param $suffix string Append this to the filename
3511 * @return string $prefix . $mangledCode . $suffix
3512 */
3514 // Protect against path traversal
3517 {
3519 }
3522 }
3524 /**
3525 * Get the language code from a file name. Inverse of getFileName()
3526 * @param $filename string $prefix . $languageCode . $suffix
3527 * @param $prefix string Prefix before the language code
3528 * @param $suffix string Suffix after the language code
3529 * @return string Language code, or false if $prefix or $suffix isn't found
3530 */
3531 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3537 }
3539 }
3541 /**
3542 * @param $code string
3543 * @return string
3544 */
3550 }
3552 /**
3553 * @param $code string
3554 * @return string
3555 */
3559 }
3561 /**
3562 * Get the first fallback for a given language.
3563 *
3564 * @param $code string
3565 *
3566 * @return false|string
3567 */
3575 }
3576 }
3578 /**
3579 * Get the ordered list of fallback languages.
3580 *
3581 * @since 1.19
3582 * @param $code string Language code
3583 * @return array
3584 */
3593 }
3595 }
3596 }
3598 /**
3599 * Get all messages for a given language
3600 * WARNING: this may take a long time. If you just need all message *keys*
3601 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3602 *
3603 * @param $code string
3604 *
3605 * @return array
3606 */
3609 }
3611 /**
3612 * Get a message for a given language
3613 *
3614 * @param $key string
3615 * @param $code string
3616 *
3617 * @return string
3618 */
3621 }
3623 /**
3624 * Get all message keys for a given language. This is a faster alternative to
3625 * array_keys( Language::getMessagesFor( $code ) )
3626 *
3627 * @since 1.19
3628 * @param $code string Language code
3629 * @return array of message keys (strings)
3630 */
3633 }
3635 /**
3636 * @param $talk
3637 * @return mixed
3638 */
3642 }
3647 # Allow grammar transformations
3648 # Allowing full message-style parsing would make simple requests
3649 # such as action=raw much more expensive than they need to be.
3650 # This will hopefully cover most cases.
3654 }
3656 /**
3657 * @param $m string
3658 * @return string
3659 */
3662 }
3664 /**
3665 * @throws MWException
3666 * @return array
3667 */
3672 }
3679 }
3684 }
3686 /**
3687 * Decode an expiry (block, protection, etc) which has come from the DB
3688 *
3689 * @param $expiry String: Database expiry String
3690 * @param $format Bool|Int true to process using language functions, or TS_ constant
3691 * to return the expiry in a given timestamp
3692 * @return String
3693 */
3699 }
3703 ? $infinityMsg
3709 }
3710 }
3712 /**
3713 * @todo Document
3714 * @param $seconds int|float
3715 * @param $format Array Optional
3716 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
3717 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
3718 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
3719 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
3720 * @return string
3721 */
3725 }
3728 }
3731 }
3753 }
3764 }
3768 }
3774 }
3782 }
3792 }
3796 }
3806 }
3807 }
3809 }
3811 /**
3812 * Format a bitrate for output, using an appropriate
3813 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
3814 *
3815 * @param $bps int
3816 * @return string
3817 */
3821 return str_replace( '$1', $this->formatNum( $bps ), $this->getMessageFromDB( 'bitrate-bits' ) );
3822 }
3829 // Prevent code falling off end of $units array
3832 }
3837 }
3841 }
3843 /**
3844 * Format a size in bytes for output, using an appropriate
3845 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
3846 *
3847 * @param $size int Size to format
3848 * @return string Plain text (not HTML)
3849 */
3858 }
3860 // For small sizes no decimal places necessary
3863 // For MB and bigger two decimal places are smarter
3865 }
3871 }
3873 /**
3874 * Make a list item, used by various special pages
3875 *
3876 * @param $page String Page link
3877 * @param $details String Text between brackets
3878 * @param $oppositedm Boolean Add the direction mark opposite to your
3879 * language, to display text properly
3880 * @return String
3881 */
3886 wfMsgExt( 'parentheses', array( 'escape', 'replaceafter', 'language' => $this ), $details ) : '';
3888 }
3890 /**
3891 * Generate (prev x| next x) (20|50|100...) type links for paging
3892 *
3893 * @param $title Title object to link
3894 * @param $offset Integer offset parameter
3895 * @param $limit Integer limit parameter
3896 * @param $query String optional URL query parameter string
3897 * @param $atend Bool optional param for specified if this is the last page
3898 * @return String
3899 */
3900 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
3901 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
3903 # Make 'previous' link
3904 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3910 }
3912 # Make 'next' link
3913 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3919 }
3921 # Make links to set number of items per page
3926 }
3930 }
3932 /**
3933 * Helper function for viewPrevNext() that generates links
3934 *
3935 * @param $title Title object to link
3936 * @param $offset Integer offset parameter
3937 * @param $limit Integer limit parameter
3938 * @param $query Array extra query parameters
3939 * @param $link String text to use for the link; will be escaped
3940 * @param $tooltipMsg String name of the message to use as tooltip
3941 * @param $class String value of the "class" attribute of the link
3942 * @return String HTML fragment
3943 */
3944 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
3946 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3949 }
3951 /**
3952 * Get the conversion rule title, if any.
3953 *
3954 * @return string
3955 */
3958 }
3959 }