| blob | 7b08891de77d4130c7b06ff1ce2493ee596b522e |
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 */
72 /**
73 * ReplacementArray object caches
74 */
77 /**
78 * @var LocalisationCache
79 */
87 );
91 );
96 'december'
97 );
101 'december-gen'
102 );
106 );
113 );
121 );
129 );
136 );
138 /**
139 * Get a cached language object for a given language code
140 * @param $code String
141 * @return Language
142 */
146 // Don't keep a billion objects around, that's stupid.
148 }
150 }
152 }
154 /**
155 * Create a language object for a given language code
156 * @param $code String
157 * @return Language
158 */
160 // Protect against path traversal below
163 {
165 }
168 // It's not possible to customise this code with class files, so
169 // just return a Language object. This is to support uselang= hacks.
173 }
175 // Check if there is a language class for the code
181 }
183 // Keep trying the fallback list until we find an existing class
188 }
196 }
197 }
200 }
202 /**
203 * Returns true if a language code string is of a valid form, whether or
204 * not it exists. This includes codes which are used solely for
205 * customisation via the MediaWiki namespace.
206 *
207 * @param $code string
208 *
209 * @return bool
210 */
212 return
215 }
217 /**
218 * Returns true if a language code is of a valid form for the purposes of
219 * internal customisation of MediaWiki, via Messages*.php.
220 *
221 * @param $code string
222 *
223 * @since 1.18
224 * @return bool
225 */
228 }
230 /**
231 * @param $code
232 * @return String Name of the language class
233 */
239 }
240 }
242 /**
243 * Includes language class files
244 *
245 * @param $class string Name of the language class
246 */
252 }
255 // Preload base classes to work around APC/PHP5 bug
258 }
261 }
262 }
263 }
265 /**
266 * Get the LocalisationCache instance
267 *
268 * @return LocalisationCache
269 */
275 }
277 }
281 // Set the code to the name of the descendant
286 }
288 }
290 /**
291 * Reduce memory usage
292 */
296 }
297 }
299 /**
300 * Hook which will be called if this is the content language.
301 * Descendants can use this to register hook functions or modify globals
302 */
305 /**
306 * Same as getFallbacksFor for current language.
307 * @return array|bool
308 * @deprecated in 1.19
309 */
313 }
315 /**
316 * @return array
317 * @since 1.19
318 */
321 }
323 /**
324 * Exports $wgBookstoreListEn
325 * @return array
326 */
329 }
331 /**
332 * @return array
333 */
350 }
352 # Sometimes a language will be localised but not actually exist on this wiki.
356 }
357 }
359 # The above mixing may leave namespaces out of canonical order.
360 # Re-order by namespace ID number...
364 }
366 }
368 /**
369 * A convenience function that returns the same thing as
370 * getNamespaces() except with the array values changed to ' '
371 * where it found '_', useful for producing output to be displayed
372 * e.g. in <select> forms.
373 *
374 * @return array
375 */
380 }
382 }
384 /**
385 * Get a namespace value by key
386 * <code>
387 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
388 * echo $mw_ns; // prints 'MediaWiki'
389 * </code>
390 *
391 * @param $index Int: the array key of the namespace to return
392 * @return mixed, string if the namespace value exists, otherwise false
393 */
397 }
399 /**
400 * A convenience function that returns the same thing as
401 * getNsText() except with '_' changed to ' ', useful for
402 * producing output.
403 *
404 * @param $index string
405 *
406 * @return array
407 */
411 }
413 /**
414 * Returns gender-dependent namespace alias if available.
415 * @param $index Int: namespace index
416 * @param $gender String: gender key (male, female... )
417 * @return String
418 * @since 1.18
419 */
423 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
425 }
427 /**
428 * Whether this language makes distinguishes genders for example in
429 * namespaces.
430 * @return bool
431 * @since 1.18
432 */
436 // $wgExtraGenderNamespaces overrides everything
438 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
439 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
440 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
443 // Check what is in i18n files
446 }
447 }
449 /**
450 * Get a namespace key by value, case insensitive.
451 * Only matches namespace names for the current language, not the
452 * canonical ones defined in Namespace.php.
453 *
454 * @param $text String
455 * @return mixed An integer if $text is a valid value otherwise false
456 */
461 }
463 /**
464 * @return array
465 */
477 }
478 }
479 }
482 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
486 }
487 }
490 }
492 }
494 /**
495 * @return array
496 */
500 # Put namespace names and aliases into a hashtable.
501 # If this is too slow, then we should arrange it so that it is done
502 # before caching. The catch is that at pre-cache time, the above
503 # class-specific fixup hasn't been done.
507 }
510 }
514 }
515 }
516 }
518 }
520 /**
521 * Get a namespace key by value, case insensitive. Canonical namespace
522 * names override custom ones defined for the current language.
523 *
524 * @param $text String
525 * @return mixed An integer if $text is a valid value otherwise false
526 */
532 }
535 }
537 /**
538 * short names for language variants used for language conversion links.
539 *
540 * @param $code String
541 * @param $usemsg bool Use the "variantname-xyz" message if it exists
542 * @return string
543 */
549 }
554 # otherwise, output the language code
556 }
557 }
559 /**
560 * @param $name string
561 * @return string
562 */
567 }
569 }
571 /**
572 * @return array
573 */
582 );
583 }
585 /**
586 * @return array
587 */
590 }
592 /**
593 * @return array
594 */
597 }
599 /**
600 * @return array|string
601 */
609 }
610 }
612 /**
613 * @return array
614 */
617 }
619 /**
620 * @param $image
621 * @return array|null
622 */
625 }
627 /**
628 * @return array
629 */
632 }
634 /**
635 * @param $tog
636 * @return string
637 */
640 }
642 /**
643 * Get native language names, indexed by code.
644 * Only those defined in MediaWiki, no other data like CLDR.
645 * If $customisedOnly is true, only returns codes with a messages file
646 *
647 * @param $customisedOnly bool
648 *
649 * @return array
650 */
657 }
662 }
665 // We do this using a foreach over the codes instead of a directory
666 // loop so that messages files in extensions will work correctly.
670 }
671 }
673 }
675 /**
676 * Get translated language names. This is done on best effort and
677 * by default this is exactly the same as Language::getLanguageNames.
678 * The CLDR extension provides translated names.
679 * @param $code String Language code.
680 * @return Array language code => language name
681 * @since 1.18.0
682 */
689 }
692 }
694 /**
695 * Get a message from the MediaWiki namespace.
696 *
697 * @param $msg String: message name
698 * @return string
699 */
702 }
704 /**
705 * Get the native language name of $code.
706 * Only if defined in MediaWiki, no other data like CLDR.
707 * @param $code string
708 * @return string
709 */
714 }
716 }
718 /**
719 * @param $key string
720 * @return string
721 */
724 }
726 /**
727 * @return array
728 */
733 }
735 }
737 /**
738 * @param $key string
739 * @return string
740 */
743 }
745 /**
746 * @param $key string
747 * @return string
748 */
751 }
753 /**
754 * @return array
755 */
760 }
762 }
764 /**
765 * @param $key string
766 * @return string
767 */
770 }
772 /**
773 * @param $key string
774 * @return string
775 */
778 }
780 /**
781 * @param $key string
782 * @return string
783 */
786 }
788 /**
789 * @param $key string
790 * @return string
791 */
794 }
796 /**
797 * @param $key string
798 * @return string
799 */
802 }
804 /**
805 * @param $key string
806 * @return string
807 */
810 }
812 /**
813 * This is a workalike of PHP's date() function, but with better
814 * internationalisation, a reduced set of format characters, and a better
815 * escaping format.
816 *
817 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
818 * PHP manual for definitions. There are a number of extensions, which
819 * start with "x":
820 *
821 * xn Do not translate digits of the next numeric format character
822 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
823 * xr Use roman numerals for the next numeric format character
824 * xh Use hebrew numerals for the next numeric format character
825 * xx Literal x
826 * xg Genitive month name
827 *
828 * xij j (day number) in Iranian calendar
829 * xiF F (month name) in Iranian calendar
830 * xin n (month number) in Iranian calendar
831 * xiy y (two digit year) in Iranian calendar
832 * xiY Y (full year) in Iranian calendar
833 *
834 * xjj j (day number) in Hebrew calendar
835 * xjF F (month name) in Hebrew calendar
836 * xjt t (days in month) in Hebrew calendar
837 * xjx xg (genitive month name) in Hebrew calendar
838 * xjn n (month number) in Hebrew calendar
839 * xjY Y (full year) in Hebrew calendar
840 *
841 * xmj j (day number) in Hijri calendar
842 * xmF F (month name) in Hijri calendar
843 * xmn n (month number) in Hijri calendar
844 * xmY Y (full year) in Hijri calendar
845 *
846 * xkY Y (full year) in Thai solar calendar. Months and days are
847 * identical to the Gregorian calendar
848 * xoY Y (full year) in Minguo calendar or Juche year.
849 * Months and days are identical to the
850 * Gregorian calendar
851 * xtY Y (full year) in Japanese nengo. Months and days are
852 * identical to the Gregorian calendar
853 *
854 * Characters enclosed in double quotes will be considered literal (with
855 * the quotes themselves removed). Unmatched quotes will be considered
856 * literal quotes. Example:
857 *
858 * "The month is" F => The month is January
859 * i's" => 20'11"
860 *
861 * Backslash escaping is also supported.
862 *
863 * Input timestamp is assumed to be pre-normalized to the desired local
864 * time zone, if any.
865 *
866 * @param $format String
867 * @param $ts String: 14-character timestamp
868 * YYYYMMDDHHMMSS
869 * 01234567890123
870 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
871 *
872 * @return string
873 */
892 }
894 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
896 }
934 }
940 }
946 }
952 }
958 }
965 }
971 }
977 }
986 }
992 }
998 }
1013 }
1019 }
1025 }
1031 }
1037 }
1043 }
1049 }
1058 }
1064 }
1070 }
1076 }
1082 }
1088 }
1097 }
1129 }
1135 }
1141 }
1145 # Backslash escaping
1150 }
1153 # Quoted literal
1157 # No terminating quote, assume literal "
1162 }
1164 # Quote at end of string, assume literal "
1166 }
1170 }
1183 }
1184 }
1185 }
1187 }
1192 /**
1193 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1194 * Gregorian dates to Iranian dates. Originally written in C, it
1195 * is released under the terms of GNU Lesser General Public
1196 * License. Conversion to PHP was performed by Niklas Laxström.
1197 *
1198 * Link: http://www.farsiweb.info/jalali/jalali.c
1199 *
1200 * @param $ts string
1201 *
1202 * @return string
1203 */
1209 # Days passed from the beginning (including leap years)
1215 // Add days of the past months of this year
1218 }
1220 // Leap years
1223 }
1225 // Days passed in current month
1239 }
1243 }
1249 }
1251 /**
1252 * Converting Gregorian dates to Hijri dates.
1253 *
1254 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1255 *
1256 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1257 *
1258 * @param $ts string
1259 *
1260 * @return string
1261 */
1275 )
1276 {
1284 }
1289 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1290 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1296 }
1298 /**
1299 * Converting Gregorian dates to Hebrew dates.
1300 *
1301 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1302 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1303 * to translate the relevant functions into PHP and release them under
1304 * GNU GPL.
1305 *
1306 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1307 * and Adar II is 14. In a non-leap year, Adar is 6.
1308 *
1309 * @param $ts string
1310 *
1311 * @return string
1312 */
1314 # Parse date
1319 # Calculate Hebrew year
1322 # Month number when September = 1, August = 12
1325 # Next year
1329 }
1331 # Calculate day of year from 1 September
1335 # February
1337 # Check if the year is leap
1340 }
1345 }
1346 }
1348 # Calculate the start of the Hebrew year
1351 # Calculate next year's start
1353 # Day is before the start of the year - it is the previous year
1354 # Next year's start
1356 # Previous year
1359 # Add days since previous year's 1 September
1362 # Leap year
1364 }
1365 # Start of the new (previous) year
1368 # Next year's start
1370 }
1372 # Calculate Hebrew day of year
1375 # Difference between year's days
1377 # Add 12 (or 13 for leap years) days to ignore the difference between
1378 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1379 # difference is only about the year type
1384 }
1386 # Check the year pattern, and is leap year
1387 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1388 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1389 # and non-leap years
1391 # Check if leap year
1394 # Calculate day in the month from number of day in the Hebrew year
1395 # Don't check Adar - if the day is not in Adar, we will stop before;
1396 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1401 # Calculate days in this month
1403 # Adar in a leap year
1405 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1408 # Day in Adar I
1411 # Subtract the days of Adar I
1413 # Try Adar II
1416 # Day in Adar II
1418 }
1419 }
1420 }
1422 # Cheshvan in a complete year (otherwise as the rule below)
1425 # Kislev in an incomplete year (otherwise as the rule below)
1428 # Odd months have 30 days, even have 29
1430 }
1432 # In the current month
1435 # Subtract the days of the current month
1437 # Try in the next month
1439 }
1440 }
1443 }
1445 /**
1446 * This calculates the Hebrew year start, as days since 1 September.
1447 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1448 * Used for Hebrew date.
1449 *
1450 * @param $year int
1451 *
1452 * @return string
1453 */
1460 }
1464 }
1474 }
1478 }
1480 /**
1481 * Algorithm to convert Gregorian dates to Thai solar dates,
1482 * Minguo dates or Minguo dates.
1483 *
1484 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1485 * http://en.wikipedia.org/wiki/Minguo_calendar
1486 * http://en.wikipedia.org/wiki/Japanese_era_name
1487 *
1488 * @param $ts String: 14-character timestamp
1489 * @param $cName String: calender name
1490 * @return Array: converted year, month, day
1491 */
1498 # Thai solar dates
1499 # Add 543 years to the Gregorian calendar
1500 # Months and days are identical
1503 # Minguo dates
1504 # Deduct 1911 years from the Gregorian calendar
1505 # Months and days are identical
1508 # Nengō dates up to Meiji period
1509 # Deduct years from the Gregorian calendar
1510 # depending on the nengo periods
1511 # Months and days are identical
1512 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1513 # Meiji period
1518 }
1526 )
1527 {
1528 # Taishō period
1533 }
1539 )
1540 {
1541 # Shōwa period
1546 }
1549 # Heisei period
1554 }
1556 }
1559 }
1562 }
1564 /**
1565 * Roman number formatting up to 3000
1566 *
1567 * @param $num int
1568 *
1569 * @return string
1570 */
1577 );
1582 }
1588 }
1590 }
1592 }
1594 /**
1595 * Hebrew Gematria number formatting up to 9999
1596 *
1597 * @param $num int
1598 *
1599 * @return string
1600 */
1607 );
1612 }
1624 }
1625 }
1626 }
1628 }
1634 }
1653 }
1655 }
1657 /**
1658 * Used by date() and time() to adjust the time output.
1659 *
1660 * @param $ts Int the time in date('YmdHis') format
1661 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1662 * get user timecorrection setting)
1663 * @return int
1664 */
1670 }
1683 }
1684 # Unrecognized timezone, default to 'Offset' with the stored offset.
1686 }
1690 # Global offset in minutes.
1693 }
1704 }
1707 }
1708 }
1710 # No difference ? Return time unchanged
1713 }
1716 # Generate an adjusted date; take advantage of the fact that mktime
1717 # will normalize out-of-range values so we don't have to split $minDiff
1718 # into hours and minutes.
1731 }
1733 /**
1734 * This is meant to be used by time(), date(), and timeanddate() to get
1735 * the date preference they're supposed to use, it should be used in
1736 * all children.
1737 *
1738 *<code>
1739 * function timeanddate([...], $format = true) {
1740 * $datePreference = $this->dateFormat($format);
1741 * [...]
1742 * }
1743 *</code>
1744 *
1745 * @param $usePrefs Mixed: if true, the user's preference is used
1746 * if false, the site/language default is used
1747 * if int/string, assumed to be a format.
1748 * @return string
1749 */
1758 }
1761 }
1763 // return int
1766 }
1769 }
1771 /**
1772 * Get a format string for a given type and preference
1773 * @param $type string May be date, time or both
1774 * @param $pref string The format name as it appears in Messages*.php
1775 *
1776 * @return string
1777 */
1788 }
1789 }
1791 }
1793 }
1795 /**
1796 * @param $ts Mixed: the time format which needs to be turned into a
1797 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1798 * @param $adj Bool: whether to adjust the time output according to the
1799 * user configured offset ($timecorrection)
1800 * @param $format Mixed: true to use user's date format preference
1801 * @param $timecorrection String|bool the time offset as returned by
1802 * validateTimeZone() in Special:Preferences
1803 * @return string
1804 */
1809 }
1812 }
1814 /**
1815 * @param $ts Mixed: the time format which needs to be turned into a
1816 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1817 * @param $adj Bool: whether to adjust the time output according to the
1818 * user configured offset ($timecorrection)
1819 * @param $format Mixed: true to use user's date format preference
1820 * @param $timecorrection String|bool the time offset as returned by
1821 * validateTimeZone() in Special:Preferences
1822 * @return string
1823 */
1828 }
1831 }
1833 /**
1834 * @param $ts Mixed: the time format which needs to be turned into a
1835 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1836 * @param $adj Bool: whether to adjust the time output according to the
1837 * user configured offset ($timecorrection)
1838 * @param $format Mixed: what format to return, if it's false output the
1839 * default one (default true)
1840 * @param $timecorrection String|bool the time offset as returned by
1841 * validateTimeZone() in Special:Preferences
1842 * @return string
1843 */
1848 }
1851 }
1853 /**
1854 * Internal helper function for userDate(), userTime() and userTimeAndDate()
1855 *
1856 * @param $type String: can be 'date', 'time' or 'both'
1857 * @param $ts Mixed: the time format which needs to be turned into a
1858 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1859 * @param $user User object used to get preferences for timezone and format
1860 * @param $options Array, can contain the following keys:
1861 * - 'timecorrection': time correction, can have the following values:
1862 * - true: use user's preference
1863 * - false: don't use time correction
1864 * - integer: value of time correction in minutes
1865 * - 'format': format to use, can have the following values:
1866 * - true: use user's preference
1867 * - false: use default preference
1868 * - string: format to use
1869 * @since 1.19
1870 * @return String
1871 */
1880 }
1882 }
1887 }
1890 }
1892 /**
1893 * Get the formatted date for the given timestamp and formatted for
1894 * the given user.
1895 *
1896 * @param $ts Mixed: the time format which needs to be turned into a
1897 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1898 * @param $user User object used to get preferences for timezone and format
1899 * @param $options Array, can contain the following keys:
1900 * - 'timecorrection': time correction, can have the following values:
1901 * - true: use user's preference
1902 * - false: don't use time correction
1903 * - integer: value of time correction in minutes
1904 * - 'format': format to use, can have the following values:
1905 * - true: use user's preference
1906 * - false: use default preference
1907 * - string: format to use
1908 * @since 1.19
1909 * @return String
1910 */
1913 }
1915 /**
1916 * Get the formatted time for the given timestamp and formatted for
1917 * the given user.
1918 *
1919 * @param $ts Mixed: the time format which needs to be turned into a
1920 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1921 * @param $user User object used to get preferences for timezone and format
1922 * @param $options Array, can contain the following keys:
1923 * - 'timecorrection': time correction, can have the following values:
1924 * - true: use user's preference
1925 * - false: don't use time correction
1926 * - integer: value of time correction in minutes
1927 * - 'format': format to use, can have the following values:
1928 * - true: use user's preference
1929 * - false: use default preference
1930 * - string: format to use
1931 * @since 1.19
1932 * @return String
1933 */
1936 }
1938 /**
1939 * Get the formatted date and time for the given timestamp and formatted for
1940 * the given user.
1941 *
1942 * @param $ts Mixed: the time format which needs to be turned into a
1943 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1944 * @param $user User object used to get preferences for timezone and format
1945 * @param $options Array, can contain the following keys:
1946 * - 'timecorrection': time correction, can have the following values:
1947 * - true: use user's preference
1948 * - false: don't use time correction
1949 * - integer: value of time correction in minutes
1950 * - 'format': format to use, can have the following values:
1951 * - true: use user's preference
1952 * - false: use default preference
1953 * - string: format to use
1954 * @since 1.19
1955 * @return String
1956 */
1959 }
1961 /**
1962 * @param $key string
1963 * @return array|null
1964 */
1967 }
1969 /**
1970 * @return array
1971 */
1974 }
1976 /**
1977 * @param $in
1978 * @param $out
1979 * @param $string
1980 * @return string
1981 */
1983 # This is a wrapper for iconv in all languages except esperanto,
1984 # which does some nasty x-conversions beforehand
1986 # Even with //IGNORE iconv can whine about illegal characters in
1987 # *input* string. We just ignore those too.
1988 # REF: http://bugs.php.net/bug.php?id=37166
1989 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1994 }
1996 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1998 /**
1999 * @param $matches array
2000 * @return mixed|string
2001 */
2004 }
2006 /**
2007 * @param $matches array
2008 * @return string
2009 */
2012 }
2014 /**
2015 * @param $matches array
2016 * @return string
2017 */
2021 }
2023 /**
2024 * @param $matches array
2025 * @return string
2026 */
2030 }
2032 /**
2033 * @param $matches array
2034 * @return string
2035 */
2038 }
2040 /**
2041 * @param $matches array
2042 * @return string
2043 */
2047 }
2049 /**
2050 * Make a string's first character uppercase
2051 *
2052 * @param $str string
2053 *
2054 * @return string
2055 */
2063 // fall back to more complex logic in case of multibyte strings
2065 }
2066 }
2068 /**
2069 * Convert a string to uppercase
2070 *
2071 * @param $str string
2072 * @param $first bool
2073 *
2074 * @return string
2075 */
2083 }
2086 }
2093 $str
2094 );
2097 }
2098 }
2099 }
2101 /**
2102 * @param $str string
2103 * @return mixed|string
2104 */
2116 }
2117 }
2119 /**
2120 * @param $str string
2121 * @param $first bool
2122 * @return mixed|string
2123 */
2131 }
2134 }
2141 $str
2142 );
2145 }
2146 }
2147 }
2149 /**
2150 * @param $str string
2151 * @return bool
2152 */
2155 }
2157 /**
2158 * @param $str string
2159 * @return mixed|string
2160 */
2165 // regexp to find first letter in each word (i.e. after each space)
2166 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2168 // function to use to capitalize a single char
2173 $str
2174 );
2179 $str
2180 );
2181 }
2184 }
2185 }
2187 /**
2188 * capitalize words at word breaks
2189 *
2190 * @param $str string
2191 * @return mixed
2192 */
2197 // since \b doesn't work for UTF-8, we explicitely define word break chars
2200 // find first letter after word break
2201 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2207 $str
2208 );
2213 $str
2214 );
2215 }
2220 $str
2221 );
2222 }
2223 }
2225 /**
2226 * Return a case-folded representation of $s
2227 *
2228 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2229 * and $s2 are the same except for the case of their characters. It is not
2230 * necessary for the value returned to make sense when displayed.
2231 *
2232 * Do *not* perform any other normalisation in this function. If a caller
2233 * uses this function when it should be using a more general normalisation
2234 * function, then fix the caller.
2235 *
2236 * @param $s string
2237 *
2238 * @return string
2239 */
2242 }
2244 /**
2245 * @param $s string
2246 * @return string
2247 */
2251 }
2252 # Check for non-UTF-8 URLs
2256 }
2262 }
2265 }
2267 /**
2268 * @return array
2269 */
2272 }
2274 /**
2275 * Most writing systems use whitespace to break up words.
2276 * Some languages such as Chinese don't conventionally do this,
2277 * which requires special handling when breaking up words for
2278 * searching etc.
2279 *
2280 * @return bool
2281 */
2284 }
2286 /**
2287 * Some languages such as Chinese require word segmentation,
2288 * Specify such segmentation when overridden in derived class.
2289 *
2290 * @param $string String
2291 * @return String
2292 */
2295 }
2297 /**
2298 * Some languages have special punctuation need to be normalized.
2299 * Make such changes here.
2300 *
2301 * @param $string String
2302 * @return String
2303 */
2306 }
2308 /**
2309 * convert double-width roman characters to single-width.
2310 * range: ff00-ff5f ~= 0020-007f
2311 *
2312 * @param $string string
2313 *
2314 * @return string
2315 */
2325 }
2329 }
2331 /**
2332 * @param $string string
2333 * @param $pattern string
2334 * @return string
2335 */
2340 }
2342 /**
2343 * @param $termsArray array
2344 * @return array
2345 */
2347 # some languages, e.g. Chinese, need to do a conversion
2348 # in order for search results to be displayed correctly
2350 }
2352 /**
2353 * Get the first character of a string.
2354 *
2355 * @param $s string
2356 * @return string
2357 */
2364 $matches
2365 );
2370 }
2372 // Break down Hangul syllables to grab the first jamo
2404 }
2407 }
2408 }
2411 # Some languages may have an alternate char encoding option
2412 # (Esperanto X-coding, Japanese furigana conversion, etc)
2413 # If this language is used as the primary content language,
2414 # an override to the defaults can be set here on startup.
2415 }
2417 /**
2418 * @param $s string
2419 * @return string
2420 */
2422 # For some languages we'll want to explicitly specify
2423 # which characters make it into the edit box raw
2424 # or are converted in some way or another.
2430 }
2431 }
2433 /**
2434 * @param $s string
2435 * @return string
2436 */
2438 # Take the previous into account.
2444 }
2449 }
2450 }
2452 /**
2453 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2454 * also cleans up certain backwards-compatible sequences, converting them
2455 * to the modern Unicode equivalent.
2456 *
2457 * This is language-specific for performance reasons only.
2458 *
2459 * @param $s string
2460 *
2461 * @return string
2462 */
2469 }
2472 }
2474 /**
2475 * Transform a string using serialized data stored in the given file (which
2476 * must be in the serialized subdirectory of $IP). The file contains pairs
2477 * mapping source characters to destination characters.
2478 *
2479 * The data is cached in process memory. This will go faster if you have the
2480 * FastStringSearch extension.
2481 *
2482 * @param $file string
2483 * @param $string string
2484 *
2485 * @return string
2486 */
2492 }
2494 }
2496 }
2498 /**
2499 * For right-to-left language support
2500 *
2501 * @return bool
2502 */
2505 }
2507 /**
2508 * Return the correct HTML 'dir' attribute value for this language.
2509 * @return String
2510 */
2513 }
2515 /**
2516 * Return 'left' or 'right' as appropriate alignment for line-start
2517 * for this language's text direction.
2518 *
2519 * Should be equivalent to CSS3 'start' text-align value....
2520 *
2521 * @return String
2522 */
2525 }
2527 /**
2528 * Return 'right' or 'left' as appropriate alignment for line-end
2529 * for this language's text direction.
2530 *
2531 * Should be equivalent to CSS3 'end' text-align value....
2532 *
2533 * @return String
2534 */
2537 }
2539 /**
2540 * A hidden direction mark (LRM or RLM), depending on the language direction
2541 *
2542 * @param $opposite Boolean Get the direction mark opposite to your language
2543 * @return string
2544 */
2550 }
2552 /**
2553 * @return array
2554 */
2557 }
2559 /**
2560 * An arrow, depending on the language direction
2561 *
2562 * @return string
2563 */
2566 }
2568 /**
2569 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2570 *
2571 * @return bool
2572 */
2575 }
2577 /**
2578 * @return array
2579 */
2582 }
2587 }
2592 }
2594 /**
2595 * Fill a MagicWord object with data from here
2596 *
2597 * @param $mw
2598 */
2610 }
2611 }
2618 }
2619 }
2621 /**
2622 * Add magic words to the extension array
2623 *
2624 * @param $newWords array
2625 */
2632 }
2633 }
2634 }
2636 /**
2637 * Get special page names, as an associative array
2638 * case folded alias => real name
2639 */
2641 // Cache aliases because it may be slow to load them
2643 // Initialise array
2648 }
2651 }
2653 /**
2654 * Italic is unsuitable for some languages
2655 *
2656 * @param $text String: the text to be emphasized.
2657 * @return string
2658 */
2661 }
2663 /**
2664 * Normally we output all numbers in plain en_US style, that is
2665 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2666 * point twohundredthirtyfive. However this is not suitable for all
2667 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2668 * Icelandic just want to use commas instead of dots, and dots instead
2669 * of commas like "293.291,235".
2670 *
2671 * An example of this function being called:
2672 * <code>
2673 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2674 * </code>
2675 *
2676 * See LanguageGu.php for the Gujarati implementation and
2677 * $separatorTransformTable on MessageIs.php for
2678 * the , => . and . => , implementation.
2679 *
2680 * @todo check if it's viable to use localeconv() for the decimal
2681 * separator thing.
2682 * @param $number Mixed: the string to be formatted, should be an integer
2683 * or a floating point number.
2684 * @param $nocommafy Bool: set to true for special numbers like dates
2685 * @return string
2686 */
2694 }
2695 }
2701 }
2702 }
2705 }
2707 /**
2708 * @param $number string
2709 * @return string
2710 */
2715 }
2720 }
2724 }
2726 /**
2727 * Adds commas to a given number
2728 * @since 1.19
2729 * @param $_ mixed
2730 * @return string
2731 */
2736 }
2739 // default grouping is at thousands, use the same for ###,###,### pattern too.
2742 // Ref: http://cldr.unicode.org/translation/number-patterns
2745 // For negative numbers apply the algorithm like positive number and add sign.
2748 }
2756 // the string does not have any number part. Eg: .12345
2758 }
2766 }
2770 // use the last pattern for the rest of the number
2772 }
2775 }
2776 }
2778 }
2779 }
2780 /**
2781 * @return String
2782 */
2785 }
2787 /**
2788 * @return array
2789 */
2792 }
2794 /**
2795 * @return array
2796 */
2799 }
2801 /**
2802 * Take a list of strings and build a locale-friendly comma-separated
2803 * list, using the local comma-separator message.
2804 * The last two strings are chained with an "and".
2805 *
2806 * @param $l Array
2807 * @return string
2808 */
2813 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2819 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2822 }
2823 }
2825 }
2826 }
2828 /**
2829 * Take a list of strings and build a locale-friendly comma-separated
2830 * list, using the local comma-separator message.
2831 * @param $list array of strings to put in a comma list
2832 * @return string
2833 */
2839 ),
2840 $list
2841 );
2842 }
2844 /**
2845 * Take a list of strings and build a locale-friendly semicolon-separated
2846 * list, using the local semicolon-separator message.
2847 * @param $list array of strings to put in a semicolon list
2848 * @return string
2849 */
2855 ),
2856 $list
2857 );
2858 }
2860 /**
2861 * Same as commaList, but separate it with the pipe instead.
2862 * @param $list array of strings to put in a pipe list
2863 * @return string
2864 */
2870 ),
2871 $list
2872 );
2873 }
2875 /**
2876 * Truncate a string to a specified length in bytes, appending an optional
2877 * string (e.g. for ellipses)
2878 *
2879 * The database offers limited byte lengths for some columns in the database;
2880 * multi-byte character sets mean we need to ensure that only whole characters
2881 * are included, otherwise broken characters can be passed to the user
2882 *
2883 * If $length is negative, the string will be truncated from the beginning
2884 *
2885 * @param $string String to truncate
2886 * @param $length Int: maximum length (including ellipses)
2887 * @param $ellipsis String to append to the truncated text
2888 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
2889 * $adjustLength was introduced in 1.18, before that behaved as if false.
2890 * @return string
2891 */
2893 # Use the localized ellipsis character
2896 }
2897 # Check if there is no need to truncate
2902 }
2904 # If ellipsis length is >= $length then we can't apply $adjustLength
2907 # Otherwise, truncate and add ellipsis...
2920 }
2921 }
2922 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
2923 # This check is *not* redundant if $adjustLength, due to the single case where
2924 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
2929 }
2930 }
2932 /**
2933 * Remove bytes that represent an incomplete Unicode character
2934 * at the end of string (e.g. bytes of the char are missing)
2935 *
2936 * @param $string String
2937 * @return string
2938 */
2944 # We got the first byte only of a multibyte char; remove it.
2949 {
2950 # We chopped in the middle of a character; remove it
2952 }
2953 }
2955 }
2957 /**
2958 * Remove bytes that represent an incomplete Unicode character
2959 * at the start of string (e.g. bytes of the char are missing)
2960 *
2961 * @param $string String
2962 * @return string
2963 */
2968 # We chopped in the middle of a character; remove the whole thing
2970 }
2971 }
2973 }
2975 /**
2976 * Truncate a string of valid HTML to a specified length in bytes,
2977 * appending an optional string (e.g. for ellipses), and return valid HTML
2978 *
2979 * This is only intended for styled/linked text, such as HTML with
2980 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
2981 * Also, this will not detect things like "display:none" CSS.
2982 *
2983 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
2984 *
2985 * @param string $text HTML string to truncate
2986 * @param int $length (zero/positive) Maximum length (including ellipses)
2987 * @param string $ellipsis String to append to the truncated text
2988 * @return string
2989 */
2991 # Use the localized ellipsis character
2994 }
2995 # Check if there is clearly no need to truncate
3000 }
3014 # Consider truncation once the display length has reached the maximim.
3015 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3016 # Check that we're not in the middle of a bracket/entity...
3020 # Save where we are; we will truncate here unless there turn out to
3021 # be so few remaining characters that truncation is not necessary.
3024 }
3026 # String in fact does need truncation, the truncation point was OK.
3031 }
3032 }
3035 # Read the next char...
3053 }
3059 // Name found (e.g. "<a href=..."), add on tag attributes...
3061 }
3067 }
3070 // Save state without $ch. We want to *hit* the first
3071 // display char (to get tags) but not *use* it if truncating.
3073 }
3078 // Add the next $max display text chars after this in one swoop...
3083 }
3084 }
3085 }
3086 }
3087 // Close the last tag if left unclosed by bad HTML
3091 }
3093 }
3095 /**
3096 * truncateHtml() helper function
3097 * like strcspn() but adds the skipped chars to $ret
3098 *
3099 * @param $ret
3100 * @param $text
3101 * @param $search
3102 * @param $start
3103 * @param $len
3104 * @return int
3105 */
3111 }
3116 }
3118 }
3120 /**
3121 * truncateHtml() helper function
3122 * (a) push or pop $tag from $openTags as needed
3123 * (b) clear $tag value
3124 * @param &$tag string Current HTML tag name we are looking at
3125 * @param $tagType int (0-open tag, 1-close tag)
3126 * @param $lastCh char|string Character before the '>' that ended this tag
3127 * @param &$openTags array Open tag stack (not accounting for $tag)
3128 */
3137 }
3138 }
3140 }
3141 }
3143 /**
3144 * Grammatical transformations, needed for inflected languages
3145 * Invoked by putting {{grammar:case|word}} in a message
3146 *
3147 * @param $word string
3148 * @param $case string
3149 * @return string
3150 */
3155 }
3157 }
3159 /**
3160 * Provides an alternative text depending on specified gender.
3161 * Usage {{gender:username|masculine|feminine|neutral}}.
3162 * username is optional, in which case the gender of current user is used,
3163 * but only in (some) interface messages; otherwise default gender is used.
3164 * If second or third parameter are not specified, masculine is used.
3165 * These details may be overriden per language.
3166 *
3167 * @param $gender string
3168 * @param $forms array
3169 *
3170 * @return string
3171 */
3175 }
3179 }
3182 }
3184 }
3186 /**
3187 * Plural form transformations, needed for some languages.
3188 * For example, there are 3 form of plural in Russian and Polish,
3189 * depending on "count mod 10". See [[w:Plural]]
3190 * For English it is pretty simple.
3191 *
3192 * Invoked by putting {{plural:count|wordform1|wordform2}}
3193 * or {{plural:count|wordform1|wordform2|wordform3}}
3194 *
3195 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3196 *
3197 * @param $count Integer: non-localized number
3198 * @param $forms Array: different plural forms
3199 * @return string Correct form of plural for $count in this language
3200 */
3204 }
3208 }
3210 /**
3211 * Checks that convertPlural was given an array and pads it to requested
3212 * amount of forms by copying the last one.
3213 *
3214 * @param $count Integer: How many forms should there be at least
3215 * @param $forms Array of forms given to convertPlural
3216 * @return array Padded array of forms or an exception if not an array
3217 */
3221 }
3223 }
3225 /**
3226 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3227 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3228 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3229 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3230 * match up with it.
3231 *
3232 * @param $str String: the validated block duration in English
3233 * @return Somehow translated block duration
3234 * @see LanguageFi.php for example implementation
3235 */
3241 }
3242 }
3244 // Since usually only infinite or indefinite is only on list, so try
3245 // equivalents if still here.
3252 }
3253 }
3254 }
3255 // If all else fails, return the original string.
3257 }
3259 /**
3260 * languages like Chinese need to be segmented in order for the diff
3261 * to be of any use
3262 *
3263 * @param $text String
3264 * @return String
3265 */
3268 }
3270 /**
3271 * and unsegment to show the result
3272 *
3273 * @param $text String
3274 * @return String
3275 */
3278 }
3280 /**
3281 * Return the LanguageConverter used in the Language
3282 * @return LanguageConverter
3283 */
3286 }
3288 /**
3289 * convert text to all supported variants
3290 *
3291 * @param $text string
3292 * @return array
3293 */
3296 }
3298 /**
3299 * convert text to different variants of a language.
3300 *
3301 * @param $text string
3302 * @return string
3303 */
3306 }
3308 /**
3309 * Convert a Title object to a string in the preferred variant
3310 *
3311 * @param $title Title
3312 * @return string
3313 */
3316 }
3318 /**
3319 * Check if this is a language with variants
3320 *
3321 * @return bool
3322 */
3325 }
3327 /**
3328 * Check if the language has the specific variant
3329 * @param $variant string
3330 * @return bool
3331 */
3334 }
3336 /**
3337 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3338 *
3339 * @param $text string
3340 * @return string
3341 */
3344 }
3346 /**
3347 * Perform output conversion on a string, and encode for safe HTML output.
3348 * @param $text String text to be converted
3349 * @param $isTitle Bool whether this conversion is for the article title
3350 * @return string
3351 * @todo this should get integrated somewhere sane
3352 */
3355 }
3357 /**
3358 * @param $key string
3359 * @return string
3360 */
3363 }
3365 /**
3366 * Get the list of variants supported by this language
3367 * see sample implementation in LanguageZh.php
3368 *
3369 * @return array an array of language codes
3370 */
3373 }
3375 /**
3376 * @return string
3377 */
3380 }
3382 /**
3383 * @return string
3384 */
3387 }
3389 /**
3390 * @return string
3391 */
3394 }
3396 /**
3397 * If a language supports multiple variants, it is
3398 * possible that non-existing link in one variant
3399 * actually exists in another variant. this function
3400 * tries to find it. See e.g. LanguageZh.php
3401 *
3402 * @param $link String: the name of the link
3403 * @param $nt Mixed: the title object of the link
3404 * @param $ignoreOtherCond Boolean: to disable other conditions when
3405 * we need to transclude a template or update a category's link
3406 * @return null the input parameters may be modified upon return
3407 */
3410 }
3412 /**
3413 * If a language supports multiple variants, converts text
3414 * into an array of all possible variants of the text:
3415 * 'variant' => text in that variant
3416 *
3417 * @deprecated since 1.17 Use autoConvertToAllVariants()
3418 *
3419 * @param $text string
3420 *
3421 * @return string
3422 */
3425 }
3427 /**
3428 * returns language specific options used by User::getPageRenderHash()
3429 * for example, the preferred language variant
3430 *
3431 * @return string
3432 */
3435 }
3437 /**
3438 * For languages that support multiple variants, the title of an
3439 * article may be displayed differently in different variants. this
3440 * function returns the apporiate title defined in the body of the article.
3441 *
3442 * @return string
3443 */
3446 }
3448 /**
3449 * Enclose a string with the "no conversion" tag. This is used by
3450 * various functions in the Parser
3451 *
3452 * @param $text String: text to be tagged for no conversion
3453 * @param $noParse bool
3454 * @return string the tagged text
3455 */
3458 }
3460 /**
3461 * A regular expression to match legal word-trailing characters
3462 * which should be merged onto a link of the form [[foo]]bar.
3463 *
3464 * @return string
3465 */
3468 }
3470 /**
3471 * @return Language
3472 */
3475 }
3477 /**
3478 * Get the RFC 3066 code for this language object
3479 *
3480 * @return string
3481 */
3484 }
3486 /**
3487 * Get the code in Bcp47 format which we can use
3488 * inside of html lang="" tags.
3489 * @since 1.19
3490 * @return string
3491 */
3495 }
3497 }
3499 /**
3500 * @param $code string
3501 */
3504 // Ensure we don't leave an incorrect html code lying around
3506 }
3508 /**
3509 * Get the name of a file for a certain language code
3510 * @param $prefix string Prepend this to the filename
3511 * @param $code string Language code
3512 * @param $suffix string Append this to the filename
3513 * @return string $prefix . $mangledCode . $suffix
3514 */
3516 // Protect against path traversal
3519 {
3521 }
3524 }
3526 /**
3527 * Get the language code from a file name. Inverse of getFileName()
3528 * @param $filename string $prefix . $languageCode . $suffix
3529 * @param $prefix string Prefix before the language code
3530 * @param $suffix string Suffix after the language code
3531 * @return string Language code, or false if $prefix or $suffix isn't found
3532 */
3533 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3539 }
3541 }
3543 /**
3544 * @param $code string
3545 * @return string
3546 */
3552 }
3554 /**
3555 * @param $code string
3556 * @return string
3557 */
3561 }
3563 /**
3564 * Get the first fallback for a given language.
3565 *
3566 * @param $code string
3567 *
3568 * @return false|string
3569 */
3577 }
3578 }
3580 /**
3581 * Get the ordered list of fallback languages.
3582 *
3583 * @since 1.19
3584 * @param $code string Language code
3585 * @return array
3586 */
3595 }
3597 }
3598 }
3600 /**
3601 * Get all messages for a given language
3602 * WARNING: this may take a long time. If you just need all message *keys*
3603 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3604 *
3605 * @param $code string
3606 *
3607 * @return array
3608 */
3611 }
3613 /**
3614 * Get a message for a given language
3615 *
3616 * @param $key string
3617 * @param $code string
3618 *
3619 * @return string
3620 */
3623 }
3625 /**
3626 * Get all message keys for a given language. This is a faster alternative to
3627 * array_keys( Language::getMessagesFor( $code ) )
3628 *
3629 * @since 1.19
3630 * @param $code string Language code
3631 * @return array of message keys (strings)
3632 */
3635 }
3637 /**
3638 * @param $talk
3639 * @return mixed
3640 */
3644 }
3649 # Allow grammar transformations
3650 # Allowing full message-style parsing would make simple requests
3651 # such as action=raw much more expensive than they need to be.
3652 # This will hopefully cover most cases.
3656 }
3658 /**
3659 * @param $m string
3660 * @return string
3661 */
3664 }
3666 /**
3667 * @throws MWException
3668 * @return array
3669 */
3674 }
3681 }
3686 }
3688 /**
3689 * Decode an expiry (block, protection, etc) which has come from the DB
3690 *
3691 * @param $expiry String: Database expiry String
3692 * @param $format Bool|Int true to process using language functions, or TS_ constant
3693 * to return the expiry in a given timestamp
3694 * @return String
3695 */
3701 }
3705 ? $infinityMsg
3711 }
3712 }
3714 /**
3715 * @todo Document
3716 * @param $seconds int|float
3717 * @param $format Array Optional
3718 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
3719 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
3720 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
3721 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
3722 * @return string
3723 */
3727 }
3730 }
3733 }
3755 }
3766 }
3770 }
3776 }
3784 }
3794 }
3798 }
3808 }
3809 }
3811 }
3813 /**
3814 * Format a bitrate for output, using an appropriate
3815 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
3816 *
3817 * This use base 1000. For base 1024 use formatSize(), for another base
3818 * see formatComputingNumbers()
3819 *
3820 * @param $bps int
3821 * @return string
3822 */
3825 }
3827 /**
3828 * @param $size int Size of the unit
3829 * @param $boundary int Size boundary (1000, or 1024 in most cases)
3830 * @param $messageKey string Message key to be uesd
3831 * @return string
3832 */
3837 );
3838 }
3846 }
3848 // For small sizes no decimal places necessary
3851 // For MB and bigger two decimal places are smarter
3853 }
3859 }
3861 /**
3862 * Format a size in bytes for output, using an appropriate
3863 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
3864 *
3865 * This method use base 1024. For base 1000 use formatBitrate(), for
3866 * another base see formatComputingNumbers()
3867 *
3868 * @param $size int Size to format
3869 * @return string Plain text (not HTML)
3870 */
3873 }
3875 /**
3876 * Make a list item, used by various special pages
3877 *
3878 * @param $page String Page link
3879 * @param $details String Text between brackets
3880 * @param $oppositedm Boolean Add the direction mark opposite to your
3881 * language, to display text properly
3882 * @return String
3883 */
3888 wfMsgExt( 'parentheses', array( 'escape', 'replaceafter', 'language' => $this ), $details ) : '';
3890 }
3892 /**
3893 * Generate (prev x| next x) (20|50|100...) type links for paging
3894 *
3895 * @param $title Title object to link
3896 * @param $offset Integer offset parameter
3897 * @param $limit Integer limit parameter
3898 * @param $query String optional URL query parameter string
3899 * @param $atend Bool optional param for specified if this is the last page
3900 * @return String
3901 */
3902 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
3903 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
3905 # Make 'previous' link
3906 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3912 }
3914 # Make 'next' link
3915 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3921 }
3923 # Make links to set number of items per page
3928 }
3932 }
3934 /**
3935 * Helper function for viewPrevNext() that generates links
3936 *
3937 * @param $title Title object to link
3938 * @param $offset Integer offset parameter
3939 * @param $limit Integer limit parameter
3940 * @param $query Array extra query parameters
3941 * @param $link String text to use for the link; will be escaped
3942 * @param $tooltipMsg String name of the message to use as tooltip
3943 * @param $class String value of the "class" attribute of the link
3944 * @return String HTML fragment
3945 */
3946 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
3948 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3951 }
3953 /**
3954 * Get the conversion rule title, if any.
3955 *
3956 * @return string
3957 */
3960 }
3961 }