| blob | 2e357432f3c278d6adb10b093f8ac1ef696eb17f |
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 */
69 /**
70 * ReplacementArray object caches
71 */
74 /**
75 * @var LocalisationCache
76 */
84 );
88 );
93 'december'
94 );
98 'december-gen'
99 );
103 );
110 );
118 );
126 );
133 );
135 /**
136 * Get a cached language object for a given language code
137 * @param $code String
138 * @return Language
139 */
143 // Don't keep a billion objects around, that's stupid.
145 }
147 }
149 }
151 /**
152 * Create a language object for a given language code
153 * @param $code String
154 * @return Language
155 */
157 // Protect against path traversal below
160 {
162 }
165 // It's not possible to customise this code with class files, so
166 // just return a Language object. This is to support uselang= hacks.
170 }
172 // Check if there is a language class for the code
178 }
180 // Keep trying the fallback list until we find an existing class
185 }
193 }
194 }
197 }
199 /**
200 * Returns true if a language code string is of a valid form, whether or
201 * not it exists. This includes codes which are used solely for
202 * customisation via the MediaWiki namespace.
203 *
204 * @param $code string
205 *
206 * @return bool
207 */
209 return
212 }
214 /**
215 * Returns true if a language code is of a valid form for the purposes of
216 * internal customisation of MediaWiki, via Messages*.php.
217 *
218 * @param $code string
219 *
220 * @since 1.18
221 * @return bool
222 */
225 }
227 /**
228 * @param $code
229 * @return String Name of the language class
230 */
236 }
237 }
239 /**
240 * Includes language class files
241 *
242 * @param $class string Name of the language class
243 */
249 }
252 // Preload base classes to work around APC/PHP5 bug
255 }
258 }
259 }
260 }
262 /**
263 * Get the LocalisationCache instance
264 *
265 * @return LocalisationCache
266 */
272 }
274 }
278 // Set the code to the name of the descendant
283 }
285 }
287 /**
288 * Reduce memory usage
289 */
293 }
294 }
296 /**
297 * Hook which will be called if this is the content language.
298 * Descendants can use this to register hook functions or modify globals
299 */
302 /**
303 * Same as getFallbacksFor for current language.
304 * @return array|bool
305 * @deprecated in 1.19
306 */
310 }
312 /**
313 * @return array
314 * @since 1.19
315 */
318 }
320 /**
321 * Exports $wgBookstoreListEn
322 * @return array
323 */
326 }
328 /**
329 * @return array
330 */
347 }
349 # Sometimes a language will be localised but not actually exist on this wiki.
353 }
354 }
356 # The above mixing may leave namespaces out of canonical order.
357 # Re-order by namespace ID number...
361 }
363 }
365 /**
366 * A convenience function that returns the same thing as
367 * getNamespaces() except with the array values changed to ' '
368 * where it found '_', useful for producing output to be displayed
369 * e.g. in <select> forms.
370 *
371 * @return array
372 */
377 }
379 }
381 /**
382 * Get a namespace value by key
383 * <code>
384 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
385 * echo $mw_ns; // prints 'MediaWiki'
386 * </code>
387 *
388 * @param $index Int: the array key of the namespace to return
389 * @return mixed, string if the namespace value exists, otherwise false
390 */
394 }
396 /**
397 * A convenience function that returns the same thing as
398 * getNsText() except with '_' changed to ' ', useful for
399 * producing output.
400 *
401 * @param $index string
402 *
403 * @return array
404 */
408 }
410 /**
411 * Returns gender-dependent namespace alias if available.
412 * @param $index Int: namespace index
413 * @param $gender String: gender key (male, female... )
414 * @return String
415 * @since 1.18
416 */
420 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
422 }
424 /**
425 * Whether this language makes distinguishes genders for example in
426 * namespaces.
427 * @return bool
428 * @since 1.18
429 */
433 // $wgExtraGenderNamespaces overrides everything
435 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
436 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
437 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
440 // Check what is in i18n files
443 }
444 }
446 /**
447 * Get a namespace key by value, case insensitive.
448 * Only matches namespace names for the current language, not the
449 * canonical ones defined in Namespace.php.
450 *
451 * @param $text String
452 * @return mixed An integer if $text is a valid value otherwise false
453 */
458 }
460 /**
461 * @return array
462 */
474 }
475 }
476 }
479 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
483 }
484 }
487 }
489 }
491 /**
492 * @return array
493 */
497 # Put namespace names and aliases into a hashtable.
498 # If this is too slow, then we should arrange it so that it is done
499 # before caching. The catch is that at pre-cache time, the above
500 # class-specific fixup hasn't been done.
504 }
507 }
511 }
512 }
513 }
515 }
517 /**
518 * Get a namespace key by value, case insensitive. Canonical namespace
519 * names override custom ones defined for the current language.
520 *
521 * @param $text String
522 * @return mixed An integer if $text is a valid value otherwise false
523 */
529 }
532 }
534 /**
535 * short names for language variants used for language conversion links.
536 *
537 * @param $code String
538 * @param $usemsg bool Use the "variantname-xyz" message if it exists
539 * @return string
540 */
546 }
551 # otherwise, output the language code
553 }
554 }
556 /**
557 * @param $name string
558 * @return string
559 */
564 }
566 }
568 /**
569 * @return array
570 */
579 );
580 }
582 /**
583 * @return array
584 */
587 }
589 /**
590 * @return array
591 */
594 }
596 /**
597 * @return array|string
598 */
606 }
607 }
609 /**
610 * @return array
611 */
614 }
616 /**
617 * @param $image
618 * @return array|null
619 */
622 }
624 /**
625 * @return array
626 */
629 }
631 /**
632 * @param $tog
633 * @return string
634 */
637 }
639 /**
640 * Get language names, indexed by code.
641 * If $customisedOnly is true, only returns codes with a messages file
642 *
643 * @param $customisedOnly bool
644 *
645 * @return array
646 */
653 }
658 }
667 }
668 }
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 * @param $code string
704 * @return string
705 */
710 }
712 }
714 /**
715 * @param $key string
716 * @return string
717 */
720 }
722 /**
723 * @return array
724 */
729 }
731 }
733 /**
734 * @param $key string
735 * @return string
736 */
739 }
741 /**
742 * @param $key string
743 * @return string
744 */
747 }
749 /**
750 * @return array
751 */
756 }
758 }
760 /**
761 * @param $key string
762 * @return string
763 */
766 }
768 /**
769 * @param $key string
770 * @return string
771 */
774 }
776 /**
777 * @param $key string
778 * @return string
779 */
782 }
784 /**
785 * @param $key string
786 * @return string
787 */
790 }
792 /**
793 * @param $key string
794 * @return string
795 */
798 }
800 /**
801 * @param $key string
802 * @return string
803 */
806 }
808 /**
809 * This is a workalike of PHP's date() function, but with better
810 * internationalisation, a reduced set of format characters, and a better
811 * escaping format.
812 *
813 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
814 * PHP manual for definitions. There are a number of extensions, which
815 * start with "x":
816 *
817 * xn Do not translate digits of the next numeric format character
818 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
819 * xr Use roman numerals for the next numeric format character
820 * xh Use hebrew numerals for the next numeric format character
821 * xx Literal x
822 * xg Genitive month name
823 *
824 * xij j (day number) in Iranian calendar
825 * xiF F (month name) in Iranian calendar
826 * xin n (month number) in Iranian calendar
827 * xiY Y (full year) in Iranian calendar
828 *
829 * xjj j (day number) in Hebrew calendar
830 * xjF F (month name) in Hebrew calendar
831 * xjt t (days in month) in Hebrew calendar
832 * xjx xg (genitive month name) in Hebrew calendar
833 * xjn n (month number) in Hebrew calendar
834 * xjY Y (full year) in Hebrew calendar
835 *
836 * xmj j (day number) in Hijri calendar
837 * xmF F (month name) in Hijri calendar
838 * xmn n (month number) in Hijri calendar
839 * xmY Y (full year) in Hijri calendar
840 *
841 * xkY Y (full year) in Thai solar calendar. Months and days are
842 * identical to the Gregorian calendar
843 * xoY Y (full year) in Minguo calendar or Juche year.
844 * Months and days are identical to the
845 * Gregorian calendar
846 * xtY Y (full year) in Japanese nengo. Months and days are
847 * identical to the Gregorian calendar
848 *
849 * Characters enclosed in double quotes will be considered literal (with
850 * the quotes themselves removed). Unmatched quotes will be considered
851 * literal quotes. Example:
852 *
853 * "The month is" F => The month is January
854 * i's" => 20'11"
855 *
856 * Backslash escaping is also supported.
857 *
858 * Input timestamp is assumed to be pre-normalized to the desired local
859 * time zone, if any.
860 *
861 * @param $format String
862 * @param $ts String: 14-character timestamp
863 * YYYYMMDDHHMMSS
864 * 01234567890123
865 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
866 *
867 * @return string
868 */
887 }
889 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
891 }
929 }
935 }
941 }
947 }
953 }
960 }
966 }
972 }
981 }
987 }
993 }
1008 }
1014 }
1020 }
1026 }
1032 }
1038 }
1044 }
1053 }
1059 }
1065 }
1071 }
1077 }
1083 }
1118 }
1124 }
1130 }
1134 # Backslash escaping
1139 }
1142 # Quoted literal
1146 # No terminating quote, assume literal "
1151 }
1153 # Quote at end of string, assume literal "
1155 }
1159 }
1172 }
1173 }
1174 }
1176 }
1181 /**
1182 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1183 * Gregorian dates to Iranian dates. Originally written in C, it
1184 * is released under the terms of GNU Lesser General Public
1185 * License. Conversion to PHP was performed by Niklas Laxström.
1186 *
1187 * Link: http://www.farsiweb.info/jalali/jalali.c
1188 *
1189 * @param $ts string
1190 *
1191 * @return string
1192 */
1198 # Days passed from the beginning (including leap years)
1204 // Add days of the past months of this year
1207 }
1209 // Leap years
1212 }
1214 // Days passed in current month
1228 }
1232 }
1238 }
1240 /**
1241 * Converting Gregorian dates to Hijri dates.
1242 *
1243 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1244 *
1245 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1246 *
1247 * @param $ts string
1248 *
1249 * @return string
1250 */
1264 )
1265 {
1273 }
1278 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1279 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1285 }
1287 /**
1288 * Converting Gregorian dates to Hebrew dates.
1289 *
1290 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1291 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1292 * to translate the relevant functions into PHP and release them under
1293 * GNU GPL.
1294 *
1295 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1296 * and Adar II is 14. In a non-leap year, Adar is 6.
1297 *
1298 * @param $ts string
1299 *
1300 * @return string
1301 */
1303 # Parse date
1308 # Calculate Hebrew year
1311 # Month number when September = 1, August = 12
1314 # Next year
1318 }
1320 # Calculate day of year from 1 September
1324 # February
1326 # Check if the year is leap
1329 }
1334 }
1335 }
1337 # Calculate the start of the Hebrew year
1340 # Calculate next year's start
1342 # Day is before the start of the year - it is the previous year
1343 # Next year's start
1345 # Previous year
1348 # Add days since previous year's 1 September
1351 # Leap year
1353 }
1354 # Start of the new (previous) year
1357 # Next year's start
1359 }
1361 # Calculate Hebrew day of year
1364 # Difference between year's days
1366 # Add 12 (or 13 for leap years) days to ignore the difference between
1367 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1368 # difference is only about the year type
1373 }
1375 # Check the year pattern, and is leap year
1376 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1377 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1378 # and non-leap years
1380 # Check if leap year
1383 # Calculate day in the month from number of day in the Hebrew year
1384 # Don't check Adar - if the day is not in Adar, we will stop before;
1385 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1390 # Calculate days in this month
1392 # Adar in a leap year
1394 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1397 # Day in Adar I
1400 # Subtract the days of Adar I
1402 # Try Adar II
1405 # Day in Adar II
1407 }
1408 }
1409 }
1411 # Cheshvan in a complete year (otherwise as the rule below)
1414 # Kislev in an incomplete year (otherwise as the rule below)
1417 # Odd months have 30 days, even have 29
1419 }
1421 # In the current month
1424 # Subtract the days of the current month
1426 # Try in the next month
1428 }
1429 }
1432 }
1434 /**
1435 * This calculates the Hebrew year start, as days since 1 September.
1436 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1437 * Used for Hebrew date.
1438 *
1439 * @param $year int
1440 *
1441 * @return string
1442 */
1449 }
1453 }
1463 }
1467 }
1469 /**
1470 * Algorithm to convert Gregorian dates to Thai solar dates,
1471 * Minguo dates or Minguo dates.
1472 *
1473 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1474 * http://en.wikipedia.org/wiki/Minguo_calendar
1475 * http://en.wikipedia.org/wiki/Japanese_era_name
1476 *
1477 * @param $ts String: 14-character timestamp
1478 * @param $cName String: calender name
1479 * @return Array: converted year, month, day
1480 */
1487 # Thai solar dates
1488 # Add 543 years to the Gregorian calendar
1489 # Months and days are identical
1492 # Minguo dates
1493 # Deduct 1911 years from the Gregorian calendar
1494 # Months and days are identical
1497 # Nengō dates up to Meiji period
1498 # Deduct years from the Gregorian calendar
1499 # depending on the nengo periods
1500 # Months and days are identical
1501 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1502 # Meiji period
1507 }
1515 )
1516 {
1517 # Taishō period
1522 }
1528 )
1529 {
1530 # Shōwa period
1535 }
1538 # Heisei period
1543 }
1545 }
1548 }
1551 }
1553 /**
1554 * Roman number formatting up to 3000
1555 *
1556 * @param $num int
1557 *
1558 * @return string
1559 */
1566 );
1571 }
1577 }
1579 }
1581 }
1583 /**
1584 * Hebrew Gematria number formatting up to 9999
1585 *
1586 * @param $num int
1587 *
1588 * @return string
1589 */
1596 );
1601 }
1613 }
1614 }
1615 }
1617 }
1623 }
1642 }
1644 }
1646 /**
1647 * Used by date() and time() to adjust the time output.
1648 *
1649 * @param $ts Int the time in date('YmdHis') format
1650 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1651 * get user timecorrection setting)
1652 * @return int
1653 */
1659 }
1672 }
1673 # Unrecognized timezone, default to 'Offset' with the stored offset.
1675 }
1679 # Global offset in minutes.
1682 }
1693 }
1696 }
1697 }
1699 # No difference ? Return time unchanged
1702 }
1705 # Generate an adjusted date; take advantage of the fact that mktime
1706 # will normalize out-of-range values so we don't have to split $minDiff
1707 # into hours and minutes.
1720 }
1722 /**
1723 * This is meant to be used by time(), date(), and timeanddate() to get
1724 * the date preference they're supposed to use, it should be used in
1725 * all children.
1726 *
1727 *<code>
1728 * function timeanddate([...], $format = true) {
1729 * $datePreference = $this->dateFormat($format);
1730 * [...]
1731 * }
1732 *</code>
1733 *
1734 * @param $usePrefs Mixed: if true, the user's preference is used
1735 * if false, the site/language default is used
1736 * if int/string, assumed to be a format.
1737 * @return string
1738 */
1747 }
1750 }
1752 // return int
1755 }
1758 }
1760 /**
1761 * Get a format string for a given type and preference
1762 * @param $type string May be date, time or both
1763 * @param $pref string The format name as it appears in Messages*.php
1764 *
1765 * @return string
1766 */
1777 }
1778 }
1780 }
1782 }
1784 /**
1785 * @param $ts Mixed: the time format which needs to be turned into a
1786 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1787 * @param $adj Bool: whether to adjust the time output according to the
1788 * user configured offset ($timecorrection)
1789 * @param $format Mixed: true to use user's date format preference
1790 * @param $timecorrection String|bool the time offset as returned by
1791 * validateTimeZone() in Special:Preferences
1792 * @return string
1793 */
1798 }
1801 }
1803 /**
1804 * @param $ts Mixed: the time format which needs to be turned into a
1805 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1806 * @param $adj Bool: whether to adjust the time output according to the
1807 * user configured offset ($timecorrection)
1808 * @param $format Mixed: true to use user's date format preference
1809 * @param $timecorrection String|bool the time offset as returned by
1810 * validateTimeZone() in Special:Preferences
1811 * @return string
1812 */
1817 }
1820 }
1822 /**
1823 * @param $ts Mixed: the time format which needs to be turned into a
1824 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1825 * @param $adj Bool: whether to adjust the time output according to the
1826 * user configured offset ($timecorrection)
1827 * @param $format Mixed: what format to return, if it's false output the
1828 * default one (default true)
1829 * @param $timecorrection String|bool the time offset as returned by
1830 * validateTimeZone() in Special:Preferences
1831 * @return string
1832 */
1837 }
1840 }
1842 /**
1843 * Internal helper function for userDate(), userTime() and userTimeAndDate()
1844 *
1845 * @param $type String: can be 'date', 'time' or 'both'
1846 * @param $ts Mixed: the time format which needs to be turned into a
1847 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1848 * @param $user User object used to get preferences for timezone and format
1849 * @param $options Array, can contain the following keys:
1850 * - 'timecorrection': time correction, can have the following values:
1851 * - true: use user's preference
1852 * - false: don't use time correction
1853 * - integer: value of time correction in minutes
1854 * - 'format': format to use, can have the following values:
1855 * - true: use user's preference
1856 * - false: use default preference
1857 * - string: format to use
1858 * @return String
1859 */
1868 }
1870 }
1875 }
1878 }
1880 /**
1881 * Get the formatted date for the given timestamp and formatted for
1882 * the given user.
1883 *
1884 * @param $ts Mixed: the time format which needs to be turned into a
1885 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1886 * @param $user User object used to get preferences for timezone and format
1887 * @param $options Array, can contain the following keys:
1888 * - 'timecorrection': time correction, can have the following values:
1889 * - true: use user's preference
1890 * - false: don't use time correction
1891 * - integer: value of time correction in minutes
1892 * - 'format': format to use, can have the following values:
1893 * - true: use user's preference
1894 * - false: use default preference
1895 * - string: format to use
1896 * @return String
1897 */
1900 }
1902 /**
1903 * Get the formatted time for the given timestamp and formatted for
1904 * the given user.
1905 *
1906 * @param $ts Mixed: the time format which needs to be turned into a
1907 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1908 * @param $user User object used to get preferences for timezone and format
1909 * @param $options Array, can contain the following keys:
1910 * - 'timecorrection': time correction, can have the following values:
1911 * - true: use user's preference
1912 * - false: don't use time correction
1913 * - integer: value of time correction in minutes
1914 * - 'format': format to use, can have the following values:
1915 * - true: use user's preference
1916 * - false: use default preference
1917 * - string: format to use
1918 * @return String
1919 */
1922 }
1924 /**
1925 * Get the formatted date and time for the given timestamp and formatted for
1926 * the given user.
1927 *
1928 * @param $ts Mixed: the time format which needs to be turned into a
1929 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1930 * @param $user User object used to get preferences for timezone and format
1931 * @param $options Array, can contain the following keys:
1932 * - 'timecorrection': time correction, can have the following values:
1933 * - true: use user's preference
1934 * - false: don't use time correction
1935 * - integer: value of time correction in minutes
1936 * - 'format': format to use, can have the following values:
1937 * - true: use user's preference
1938 * - false: use default preference
1939 * - string: format to use
1940 * @return String
1941 */
1944 }
1946 /**
1947 * @param $key string
1948 * @return array|null
1949 */
1952 }
1954 /**
1955 * @return array
1956 */
1959 }
1961 /**
1962 * @param $in
1963 * @param $out
1964 * @param $string
1965 * @return string
1966 */
1968 # This is a wrapper for iconv in all languages except esperanto,
1969 # which does some nasty x-conversions beforehand
1971 # Even with //IGNORE iconv can whine about illegal characters in
1972 # *input* string. We just ignore those too.
1973 # REF: http://bugs.php.net/bug.php?id=37166
1974 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1979 }
1981 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1983 /**
1984 * @param $matches array
1985 * @return mixed|string
1986 */
1989 }
1991 /**
1992 * @param $matches array
1993 * @return string
1994 */
1997 }
1999 /**
2000 * @param $matches array
2001 * @return string
2002 */
2006 }
2008 /**
2009 * @param $matches array
2010 * @return string
2011 */
2015 }
2017 /**
2018 * @param $matches array
2019 * @return string
2020 */
2023 }
2025 /**
2026 * @param $matches array
2027 * @return string
2028 */
2032 }
2034 /**
2035 * Make a string's first character uppercase
2036 *
2037 * @param $str string
2038 *
2039 * @return string
2040 */
2048 // fall back to more complex logic in case of multibyte strings
2050 }
2051 }
2053 /**
2054 * Convert a string to uppercase
2055 *
2056 * @param $str string
2057 * @param $first bool
2058 *
2059 * @return string
2060 */
2068 }
2071 }
2078 $str
2079 );
2082 }
2083 }
2084 }
2086 /**
2087 * @param $str string
2088 * @return mixed|string
2089 */
2101 }
2102 }
2104 /**
2105 * @param $str string
2106 * @param $first bool
2107 * @return mixed|string
2108 */
2116 }
2119 }
2126 $str
2127 );
2130 }
2131 }
2132 }
2134 /**
2135 * @param $str string
2136 * @return bool
2137 */
2140 }
2142 /**
2143 * @param $str string
2144 * @return mixed|string
2145 */
2150 // regexp to find first letter in each word (i.e. after each space)
2151 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2153 // function to use to capitalize a single char
2158 $str
2159 );
2164 $str
2165 );
2166 }
2169 }
2170 }
2172 /**
2173 * capitalize words at word breaks
2174 *
2175 * @param $str string
2176 * @return mixed
2177 */
2182 // since \b doesn't work for UTF-8, we explicitely define word break chars
2185 // find first letter after word break
2186 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2192 $str
2193 );
2198 $str
2199 );
2200 }
2205 $str
2206 );
2207 }
2208 }
2210 /**
2211 * Return a case-folded representation of $s
2212 *
2213 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2214 * and $s2 are the same except for the case of their characters. It is not
2215 * necessary for the value returned to make sense when displayed.
2216 *
2217 * Do *not* perform any other normalisation in this function. If a caller
2218 * uses this function when it should be using a more general normalisation
2219 * function, then fix the caller.
2220 *
2221 * @param $s string
2222 *
2223 * @return string
2224 */
2227 }
2229 /**
2230 * @param $s string
2231 * @return string
2232 */
2236 }
2237 # Check for non-UTF-8 URLs
2241 }
2247 }
2250 }
2252 /**
2253 * @return array
2254 */
2257 }
2259 /**
2260 * Most writing systems use whitespace to break up words.
2261 * Some languages such as Chinese don't conventionally do this,
2262 * which requires special handling when breaking up words for
2263 * searching etc.
2264 *
2265 * @return bool
2266 */
2269 }
2271 /**
2272 * Some languages such as Chinese require word segmentation,
2273 * Specify such segmentation when overridden in derived class.
2274 *
2275 * @param $string String
2276 * @return String
2277 */
2280 }
2282 /**
2283 * Some languages have special punctuation need to be normalized.
2284 * Make such changes here.
2285 *
2286 * @param $string String
2287 * @return String
2288 */
2291 }
2293 /**
2294 * convert double-width roman characters to single-width.
2295 * range: ff00-ff5f ~= 0020-007f
2296 *
2297 * @param $string string
2298 *
2299 * @return string
2300 */
2310 }
2314 }
2316 /**
2317 * @param $string string
2318 * @param $pattern string
2319 * @return string
2320 */
2325 }
2327 /**
2328 * @param $termsArray array
2329 * @return array
2330 */
2332 # some languages, e.g. Chinese, need to do a conversion
2333 # in order for search results to be displayed correctly
2335 }
2337 /**
2338 * Get the first character of a string.
2339 *
2340 * @param $s string
2341 * @return string
2342 */
2349 $matches
2350 );
2355 }
2357 // Break down Hangul syllables to grab the first jamo
2389 }
2392 }
2393 }
2396 # Some languages may have an alternate char encoding option
2397 # (Esperanto X-coding, Japanese furigana conversion, etc)
2398 # If this language is used as the primary content language,
2399 # an override to the defaults can be set here on startup.
2400 }
2402 /**
2403 * @param $s string
2404 * @return string
2405 */
2407 # For some languages we'll want to explicitly specify
2408 # which characters make it into the edit box raw
2409 # or are converted in some way or another.
2415 }
2416 }
2418 /**
2419 * @param $s string
2420 * @return string
2421 */
2423 # Take the previous into account.
2429 }
2434 }
2435 }
2437 /**
2438 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2439 * also cleans up certain backwards-compatible sequences, converting them
2440 * to the modern Unicode equivalent.
2441 *
2442 * This is language-specific for performance reasons only.
2443 *
2444 * @param $s string
2445 *
2446 * @return string
2447 */
2454 }
2457 }
2459 /**
2460 * Transform a string using serialized data stored in the given file (which
2461 * must be in the serialized subdirectory of $IP). The file contains pairs
2462 * mapping source characters to destination characters.
2463 *
2464 * The data is cached in process memory. This will go faster if you have the
2465 * FastStringSearch extension.
2466 *
2467 * @param $file string
2468 * @param $string string
2469 *
2470 * @return string
2471 */
2477 }
2479 }
2481 }
2483 /**
2484 * For right-to-left language support
2485 *
2486 * @return bool
2487 */
2490 }
2492 /**
2493 * Return the correct HTML 'dir' attribute value for this language.
2494 * @return String
2495 */
2498 }
2500 /**
2501 * Return 'left' or 'right' as appropriate alignment for line-start
2502 * for this language's text direction.
2503 *
2504 * Should be equivalent to CSS3 'start' text-align value....
2505 *
2506 * @return String
2507 */
2510 }
2512 /**
2513 * Return 'right' or 'left' as appropriate alignment for line-end
2514 * for this language's text direction.
2515 *
2516 * Should be equivalent to CSS3 'end' text-align value....
2517 *
2518 * @return String
2519 */
2522 }
2524 /**
2525 * A hidden direction mark (LRM or RLM), depending on the language direction
2526 *
2527 * @param $opposite Boolean Get the direction mark opposite to your language
2528 * @return string
2529 */
2535 }
2537 /**
2538 * @return array
2539 */
2542 }
2544 /**
2545 * An arrow, depending on the language direction
2546 *
2547 * @return string
2548 */
2551 }
2553 /**
2554 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2555 *
2556 * @return bool
2557 */
2560 }
2562 /**
2563 * @return array
2564 */
2567 }
2572 }
2577 }
2579 /**
2580 * Fill a MagicWord object with data from here
2581 *
2582 * @param $mw
2583 */
2595 }
2596 }
2603 }
2604 }
2606 /**
2607 * Add magic words to the extension array
2608 *
2609 * @param $newWords array
2610 */
2617 }
2618 }
2619 }
2621 /**
2622 * Get special page names, as an associative array
2623 * case folded alias => real name
2624 */
2626 // Cache aliases because it may be slow to load them
2628 // Initialise array
2633 }
2636 }
2638 /**
2639 * Italic is unsuitable for some languages
2640 *
2641 * @param $text String: the text to be emphasized.
2642 * @return string
2643 */
2646 }
2648 /**
2649 * Normally we output all numbers in plain en_US style, that is
2650 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2651 * point twohundredthirtyfive. However this is not suitable for all
2652 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2653 * Icelandic just want to use commas instead of dots, and dots instead
2654 * of commas like "293.291,235".
2655 *
2656 * An example of this function being called:
2657 * <code>
2658 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2659 * </code>
2660 *
2661 * See LanguageGu.php for the Gujarati implementation and
2662 * $separatorTransformTable on MessageIs.php for
2663 * the , => . and . => , implementation.
2664 *
2665 * @todo check if it's viable to use localeconv() for the decimal
2666 * separator thing.
2667 * @param $number Mixed: the string to be formatted, should be an integer
2668 * or a floating point number.
2669 * @param $nocommafy Bool: set to true for special numbers like dates
2670 * @return string
2671 */
2679 }
2680 }
2686 }
2687 }
2690 }
2692 /**
2693 * @param $number string
2694 * @return string
2695 */
2700 }
2705 }
2709 }
2711 /**
2712 * Adds commas to a given number
2713 * @since 1.19
2714 * @param $_ mixed
2715 * @return string
2716 */
2721 // default grouping is at thousands, use the same for ###,###,### pattern too.
2724 // Ref: http://cldr.unicode.org/translation/number-patterns
2732 // the string does not have any number part. Eg: .12345
2734 }
2742 }
2746 // use the last pattern for the rest of the number
2748 }
2751 }
2752 }
2754 }
2755 }
2756 /**
2757 * @return String
2758 */
2761 }
2763 /**
2764 * @return array
2765 */
2768 }
2770 /**
2771 * @return array
2772 */
2775 }
2777 /**
2778 * Take a list of strings and build a locale-friendly comma-separated
2779 * list, using the local comma-separator message.
2780 * The last two strings are chained with an "and".
2781 *
2782 * @param $l Array
2783 * @return string
2784 */
2789 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2795 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2798 }
2799 }
2801 }
2802 }
2804 /**
2805 * Take a list of strings and build a locale-friendly comma-separated
2806 * list, using the local comma-separator message.
2807 * @param $list array of strings to put in a comma list
2808 * @return string
2809 */
2816 )
2817 );
2818 }
2820 /**
2821 * Take a list of strings and build a locale-friendly semicolon-separated
2822 * list, using the local semicolon-separator message.
2823 * @param $list array of strings to put in a semicolon list
2824 * @return string
2825 */
2832 )
2833 );
2834 }
2836 /**
2837 * Same as commaList, but separate it with the pipe instead.
2838 * @param $list array of strings to put in a pipe list
2839 * @return string
2840 */
2847 )
2848 );
2849 }
2851 /**
2852 * Truncate a string to a specified length in bytes, appending an optional
2853 * string (e.g. for ellipses)
2854 *
2855 * The database offers limited byte lengths for some columns in the database;
2856 * multi-byte character sets mean we need to ensure that only whole characters
2857 * are included, otherwise broken characters can be passed to the user
2858 *
2859 * If $length is negative, the string will be truncated from the beginning
2860 *
2861 * @param $string String to truncate
2862 * @param $length Int: maximum length (including ellipses)
2863 * @param $ellipsis String to append to the truncated text
2864 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
2865 * $adjustLength was introduced in 1.18, before that behaved as if false.
2866 * @return string
2867 */
2869 # Use the localized ellipsis character
2872 }
2873 # Check if there is no need to truncate
2878 }
2880 # If ellipsis length is >= $length then we can't apply $adjustLength
2883 # Otherwise, truncate and add ellipsis...
2896 }
2897 }
2898 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
2899 # This check is *not* redundant if $adjustLength, due to the single case where
2900 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
2905 }
2906 }
2908 /**
2909 * Remove bytes that represent an incomplete Unicode character
2910 * at the end of string (e.g. bytes of the char are missing)
2911 *
2912 * @param $string String
2913 * @return string
2914 */
2920 # We got the first byte only of a multibyte char; remove it.
2925 {
2926 # We chopped in the middle of a character; remove it
2928 }
2929 }
2931 }
2933 /**
2934 * Remove bytes that represent an incomplete Unicode character
2935 * at the start of string (e.g. bytes of the char are missing)
2936 *
2937 * @param $string String
2938 * @return string
2939 */
2944 # We chopped in the middle of a character; remove the whole thing
2946 }
2947 }
2949 }
2951 /**
2952 * Truncate a string of valid HTML to a specified length in bytes,
2953 * appending an optional string (e.g. for ellipses), and return valid HTML
2954 *
2955 * This is only intended for styled/linked text, such as HTML with
2956 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
2957 * Also, this will not detect things like "display:none" CSS.
2958 *
2959 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
2960 *
2961 * @param string $text HTML string to truncate
2962 * @param int $length (zero/positive) Maximum length (including ellipses)
2963 * @param string $ellipsis String to append to the truncated text
2964 * @return string
2965 */
2967 # Use the localized ellipsis character
2970 }
2971 # Check if there is clearly no need to truncate
2976 }
2990 # Consider truncation once the display length has reached the maximim.
2991 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
2992 # Check that we're not in the middle of a bracket/entity...
2996 # Save where we are; we will truncate here unless there turn out to
2997 # be so few remaining characters that truncation is not necessary.
3000 }
3002 # String in fact does need truncation, the truncation point was OK.
3007 }
3008 }
3011 # Read the next char...
3029 }
3035 // Name found (e.g. "<a href=..."), add on tag attributes...
3037 }
3043 }
3046 // Save state without $ch. We want to *hit* the first
3047 // display char (to get tags) but not *use* it if truncating.
3049 }
3054 // Add the next $max display text chars after this in one swoop...
3059 }
3060 }
3061 }
3062 }
3063 // Close the last tag if left unclosed by bad HTML
3067 }
3069 }
3071 /**
3072 * truncateHtml() helper function
3073 * like strcspn() but adds the skipped chars to $ret
3074 *
3075 * @param $ret
3076 * @param $text
3077 * @param $search
3078 * @param $start
3079 * @param $len
3080 * @return int
3081 */
3087 }
3092 }
3094 }
3096 /**
3097 * truncateHtml() helper function
3098 * (a) push or pop $tag from $openTags as needed
3099 * (b) clear $tag value
3100 * @param &$tag string Current HTML tag name we are looking at
3101 * @param $tagType int (0-open tag, 1-close tag)
3102 * @param $lastCh char|string Character before the '>' that ended this tag
3103 * @param &$openTags array Open tag stack (not accounting for $tag)
3104 */
3113 }
3114 }
3116 }
3117 }
3119 /**
3120 * Grammatical transformations, needed for inflected languages
3121 * Invoked by putting {{grammar:case|word}} in a message
3122 *
3123 * @param $word string
3124 * @param $case string
3125 * @return string
3126 */
3131 }
3133 }
3135 /**
3136 * Provides an alternative text depending on specified gender.
3137 * Usage {{gender:username|masculine|feminine|neutral}}.
3138 * username is optional, in which case the gender of current user is used,
3139 * but only in (some) interface messages; otherwise default gender is used.
3140 * If second or third parameter are not specified, masculine is used.
3141 * These details may be overriden per language.
3142 *
3143 * @param $gender string
3144 * @param $forms array
3145 *
3146 * @return string
3147 */
3151 }
3155 }
3158 }
3160 }
3162 /**
3163 * Plural form transformations, needed for some languages.
3164 * For example, there are 3 form of plural in Russian and Polish,
3165 * depending on "count mod 10". See [[w:Plural]]
3166 * For English it is pretty simple.
3167 *
3168 * Invoked by putting {{plural:count|wordform1|wordform2}}
3169 * or {{plural:count|wordform1|wordform2|wordform3}}
3170 *
3171 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3172 *
3173 * @param $count Integer: non-localized number
3174 * @param $forms Array: different plural forms
3175 * @return string Correct form of plural for $count in this language
3176 */
3180 }
3184 }
3186 /**
3187 * Checks that convertPlural was given an array and pads it to requested
3188 * amount of forms by copying the last one.
3189 *
3190 * @param $count Integer: How many forms should there be at least
3191 * @param $forms Array of forms given to convertPlural
3192 * @return array Padded array of forms or an exception if not an array
3193 */
3197 }
3199 }
3201 /**
3202 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3203 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3204 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3205 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3206 * match up with it.
3207 *
3208 * @param $str String: the validated block duration in English
3209 * @return Somehow translated block duration
3210 * @see LanguageFi.php for example implementation
3211 */
3217 }
3218 }
3220 // Since usually only infinite or indefinite is only on list, so try
3221 // equivalents if still here.
3228 }
3229 }
3230 }
3231 // If all else fails, return the original string.
3233 }
3235 /**
3236 * languages like Chinese need to be segmented in order for the diff
3237 * to be of any use
3238 *
3239 * @param $text String
3240 * @return String
3241 */
3244 }
3246 /**
3247 * and unsegment to show the result
3248 *
3249 * @param $text String
3250 * @return String
3251 */
3254 }
3256 /**
3257 * convert text to all supported variants
3258 *
3259 * @param $text string
3260 * @return array
3261 */
3264 }
3266 /**
3267 * convert text to different variants of a language.
3268 *
3269 * @param $text string
3270 * @return string
3271 */
3274 }
3277 /**
3278 * Convert a Title object to a string in the preferred variant
3279 *
3280 * @param $title Title
3281 * @return string
3282 */
3285 }
3287 /**
3288 * Check if this is a language with variants
3289 *
3290 * @return bool
3291 */
3294 }
3296 /**
3297 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3298 *
3299 * @param $text string
3300 * @return string
3301 */
3304 }
3306 /**
3307 * Perform output conversion on a string, and encode for safe HTML output.
3308 * @param $text String text to be converted
3309 * @param $isTitle Bool whether this conversion is for the article title
3310 * @return string
3311 * @todo this should get integrated somewhere sane
3312 */
3315 }
3317 /**
3318 * @param $key string
3319 * @return string
3320 */
3323 }
3325 /**
3326 * Get the list of variants supported by this language
3327 * see sample implementation in LanguageZh.php
3328 *
3329 * @return array an array of language codes
3330 */
3333 }
3335 /**
3336 * @return string
3337 */
3340 }
3342 /**
3343 * @return string
3344 */
3347 }
3349 /**
3350 * @return string
3351 */
3354 }
3356 /**
3357 * If a language supports multiple variants, it is
3358 * possible that non-existing link in one variant
3359 * actually exists in another variant. this function
3360 * tries to find it. See e.g. LanguageZh.php
3361 *
3362 * @param $link String: the name of the link
3363 * @param $nt Mixed: the title object of the link
3364 * @param $ignoreOtherCond Boolean: to disable other conditions when
3365 * we need to transclude a template or update a category's link
3366 * @return null the input parameters may be modified upon return
3367 */
3370 }
3372 /**
3373 * If a language supports multiple variants, converts text
3374 * into an array of all possible variants of the text:
3375 * 'variant' => text in that variant
3376 *
3377 * @deprecated since 1.17 Use autoConvertToAllVariants()
3378 *
3379 * @param $text string
3380 *
3381 * @return string
3382 */
3385 }
3387 /**
3388 * returns language specific options used by User::getPageRenderHash()
3389 * for example, the preferred language variant
3390 *
3391 * @return string
3392 */
3395 }
3397 /**
3398 * For languages that support multiple variants, the title of an
3399 * article may be displayed differently in different variants. this
3400 * function returns the apporiate title defined in the body of the article.
3401 *
3402 * @return string
3403 */
3406 }
3408 /**
3409 * Enclose a string with the "no conversion" tag. This is used by
3410 * various functions in the Parser
3411 *
3412 * @param $text String: text to be tagged for no conversion
3413 * @param $noParse bool
3414 * @return string the tagged text
3415 */
3418 }
3420 /**
3421 * A regular expression to match legal word-trailing characters
3422 * which should be merged onto a link of the form [[foo]]bar.
3423 *
3424 * @return string
3425 */
3428 }
3430 /**
3431 * @return Language
3432 */
3435 }
3437 /**
3438 * Get the RFC 3066 code for this language object
3439 *
3440 * @return string
3441 */
3444 }
3446 /**
3447 * @param $code string
3448 */
3451 }
3453 /**
3454 * Get the name of a file for a certain language code
3455 * @param $prefix string Prepend this to the filename
3456 * @param $code string Language code
3457 * @param $suffix string Append this to the filename
3458 * @return string $prefix . $mangledCode . $suffix
3459 */
3461 // Protect against path traversal
3464 {
3466 }
3469 }
3471 /**
3472 * Get the language code from a file name. Inverse of getFileName()
3473 * @param $filename string $prefix . $languageCode . $suffix
3474 * @param $prefix string Prefix before the language code
3475 * @param $suffix string Suffix after the language code
3476 * @return string Language code, or false if $prefix or $suffix isn't found
3477 */
3484 }
3486 }
3488 /**
3489 * @param $code string
3490 * @return string
3491 */
3495 }
3497 /**
3498 * @param $code string
3499 * @return string
3500 */
3504 }
3506 /**
3507 * Get the first fallback for a given language.
3508 *
3509 * @param $code string
3510 *
3511 * @return false|string
3512 */
3520 }
3521 }
3523 /**
3524 * Get the ordered list of fallback languages.
3525 *
3526 * @since 1.19
3527 * @param $code string Language code
3528 * @return array
3529 */
3538 }
3540 }
3541 }
3543 /**
3544 * Get all messages for a given language
3545 * WARNING: this may take a long time. If you just need all message *keys*
3546 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3547 *
3548 * @param $code string
3549 *
3550 * @return array
3551 */
3554 }
3556 /**
3557 * Get a message for a given language
3558 *
3559 * @param $key string
3560 * @param $code string
3561 *
3562 * @return string
3563 */
3566 }
3568 /**
3569 * Get all message keys for a given language. This is a faster alternative to
3570 * array_keys( Language::getMessagesFor( $code ) )
3571 *
3572 * @since 1.19
3573 * @param $code string Language code
3574 * @return array of message keys (strings)
3575 */
3578 }
3580 /**
3581 * @param $talk
3582 * @return mixed
3583 */
3587 }
3592 # Allow grammar transformations
3593 # Allowing full message-style parsing would make simple requests
3594 # such as action=raw much more expensive than they need to be.
3595 # This will hopefully cover most cases.
3599 }
3601 /**
3602 * @param $m string
3603 * @return string
3604 */
3607 }
3609 /**
3610 * @throws MWException
3611 * @return array
3612 */
3617 }
3624 }
3629 }
3631 /**
3632 * Decode an expiry (block, protection, etc) which has come from the DB
3633 *
3634 * @param $expiry String: Database expiry String
3635 * @param $format Bool|Int true to process using language functions, or TS_ constant
3636 * to return the expiry in a given timestamp
3637 * @return String
3638 */
3644 }
3648 ? $infinityMsg
3654 }
3655 }
3657 /**
3658 * @todo Document
3659 * @param $seconds int|float
3660 * @param $format Array Optional
3661 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
3662 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
3663 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
3664 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
3665 * @return string
3666 */
3670 }
3673 }
3676 }
3698 }
3709 }
3713 }
3719 }
3727 }
3737 }
3741 }
3751 }
3752 }
3754 }
3756 /**
3757 * @param $bps int
3758 * @return string
3759 */
3764 }
3771 }
3773 }
3775 /**
3776 * Format a size in bytes for output, using an appropriate
3777 * unit (B, KB, MB or GB) according to the magnitude in question
3778 *
3779 * @param $size int Size to format
3780 * @return string Plain text (not HTML)
3781 */
3783 // For small sizes no decimal places necessary
3789 // For MB and bigger two decimal places are smarter
3796 }
3799 }
3802 }
3806 }
3808 /**
3809 * Make a list item, used by various special pages
3810 *
3811 * @param $page String Page link
3812 * @param $details String Text between brackets
3813 * @param $oppositedm Boolean Add the direction mark opposite to your
3814 * language, to display text properly
3815 * @return String
3816 */
3821 wfMsgExt( 'parentheses', array( 'escape', 'replaceafter', 'language' => $this ), $details ) : '';
3823 }
3825 /**
3826 * Generate (prev x| next x) (20|50|100...) type links for paging
3827 *
3828 * @param $title Title object to link
3829 * @param $offset Integer offset parameter
3830 * @param $limit Integer limit parameter
3831 * @param $query String optional URL query parameter string
3832 * @param $atend Bool optional param for specified if this is the last page
3833 * @return String
3834 */
3835 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
3836 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
3838 # Make 'previous' link
3839 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3845 }
3847 # Make 'next' link
3848 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3854 }
3856 # Make links to set number of items per page
3861 }
3865 }
3867 /**
3868 * Helper function for viewPrevNext() that generates links
3869 *
3870 * @param $title Title object to link
3871 * @param $offset Integer offset parameter
3872 * @param $limit Integer limit parameter
3873 * @param $query Array extra query parameters
3874 * @param $link String text to use for the link; will be escaped
3875 * @param $tooltipMsg String name of the message to use as tooltip
3876 * @param $class String value of the "class" attribute of the link
3877 * @return String HTML fragment
3878 */
3879 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
3881 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
3884 }
3886 /**
3887 * Get the conversion rule title, if any.
3888 *
3889 * @return string
3890 */
3893 }
3894 }