| blob | 1ef5a74591b23cfcbd0ef181521582a4b2070bb0 |
1 <?php
2 /**
3 * Internationalisation code
4 *
5 * @file
6 * @ingroup Language
7 */
9 /**
10 * @defgroup Language Language
11 */
16 }
18 # Read language names
24 }
26 /**
27 * a fake language converter
28 *
29 * @ingroup Language
30 */
33 /**
34 * @var Language
35 */
54 }
56 /**
57 * Internationalisation code
58 * @ingroup Language
59 */
62 /**
63 * @var LanguageConverter
64 */
76 /**
77 * ReplacementArray object caches
78 */
81 /**
82 * @var LocalisationCache
83 */
91 );
95 );
100 'december'
101 );
105 'december-gen'
106 );
110 );
117 );
125 );
133 );
140 );
142 /**
143 * Get a cached language object for a given language code
144 * @param $code String
145 * @return Language
146 */
150 // Don't keep a billion objects around, that's stupid.
152 }
154 }
156 }
158 /**
159 * Create a language object for a given language code
160 * @param $code String
161 * @throws MWException
162 * @return Language
163 */
165 // Protect against path traversal below
168 {
170 }
173 // It's not possible to customise this code with class files, so
174 // just return a Language object. This is to support uselang= hacks.
178 }
180 // Check if there is a language class for the code
186 }
188 // Keep trying the fallback list until we find an existing class
193 }
201 }
202 }
205 }
207 /**
208 * Returns true if a language code string is of a valid form, whether or
209 * not it exists. This includes codes which are used solely for
210 * customisation via the MediaWiki namespace.
211 *
212 * @param $code string
213 *
214 * @return bool
215 */
217 return
220 }
222 /**
223 * Returns true if a language code is of a valid form for the purposes of
224 * internal customisation of MediaWiki, via Messages*.php.
225 *
226 * @param $code string
227 *
228 * @since 1.18
229 * @return bool
230 */
233 }
235 /**
236 * @param $code
237 * @return String Name of the language class
238 */
244 }
245 }
247 /**
248 * Includes language class files
249 *
250 * @param $class string Name of the language class
251 */
257 }
260 // Preload base classes to work around APC/PHP5 bug
263 }
266 }
267 }
268 }
270 /**
271 * Get the LocalisationCache instance
272 *
273 * @return LocalisationCache
274 */
280 }
282 }
286 // Set the code to the name of the descendant
291 }
293 }
295 /**
296 * Reduce memory usage
297 */
301 }
302 }
304 /**
305 * Hook which will be called if this is the content language.
306 * Descendants can use this to register hook functions or modify globals
307 */
310 /**
311 * Same as getFallbacksFor for current language.
312 * @return array|bool
313 * @deprecated in 1.19
314 */
318 }
320 /**
321 * @return array
322 * @since 1.19
323 */
326 }
328 /**
329 * Exports $wgBookstoreListEn
330 * @return array
331 */
334 }
336 /**
337 * @return array
338 */
355 }
357 # Sometimes a language will be localised but not actually exist on this wiki.
361 }
362 }
364 # The above mixing may leave namespaces out of canonical order.
365 # Re-order by namespace ID number...
369 }
371 }
373 /**
374 * Arbitrarily set all of the namespace names at once. Mainly used for testing
375 * @param $namespaces Array of namespaces (id => name)
376 */
379 }
381 /**
382 * A convenience function that returns the same thing as
383 * getNamespaces() except with the array values changed to ' '
384 * where it found '_', useful for producing output to be displayed
385 * e.g. in <select> forms.
386 *
387 * @return array
388 */
393 }
395 }
397 /**
398 * Get a namespace value by key
399 * <code>
400 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
401 * echo $mw_ns; // prints 'MediaWiki'
402 * </code>
403 *
404 * @param $index Int: the array key of the namespace to return
405 * @return mixed, string if the namespace value exists, otherwise false
406 */
410 }
412 /**
413 * A convenience function that returns the same thing as
414 * getNsText() except with '_' changed to ' ', useful for
415 * producing output.
416 *
417 * @param $index string
418 *
419 * @return array
420 */
424 }
426 /**
427 * Returns gender-dependent namespace alias if available.
428 * @param $index Int: namespace index
429 * @param $gender String: gender key (male, female... )
430 * @return String
431 * @since 1.18
432 */
436 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
438 }
440 /**
441 * Whether this language makes distinguishes genders for example in
442 * namespaces.
443 * @return bool
444 * @since 1.18
445 */
449 // $wgExtraGenderNamespaces overrides everything
451 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
452 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
453 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
456 // Check what is in i18n files
459 }
460 }
462 /**
463 * Get a namespace key by value, case insensitive.
464 * Only matches namespace names for the current language, not the
465 * canonical ones defined in Namespace.php.
466 *
467 * @param $text String
468 * @return mixed An integer if $text is a valid value otherwise false
469 */
474 }
476 /**
477 * @return array
478 */
490 }
491 }
492 }
495 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
499 }
500 }
503 }
505 }
507 /**
508 * @return array
509 */
513 # Put namespace names and aliases into a hashtable.
514 # If this is too slow, then we should arrange it so that it is done
515 # before caching. The catch is that at pre-cache time, the above
516 # class-specific fixup hasn't been done.
520 }
523 }
527 }
528 }
529 }
531 }
533 /**
534 * Get a namespace key by value, case insensitive. Canonical namespace
535 * names override custom ones defined for the current language.
536 *
537 * @param $text String
538 * @return mixed An integer if $text is a valid value otherwise false
539 */
545 }
548 }
550 /**
551 * short names for language variants used for language conversion links.
552 *
553 * @param $code String
554 * @param $usemsg bool Use the "variantname-xyz" message if it exists
555 * @return string
556 */
562 }
567 # otherwise, output the language code
569 }
570 }
572 /**
573 * @param $name string
574 * @return string
575 */
580 }
582 }
584 /**
585 * @return array
586 */
595 );
596 }
598 /**
599 * @return array
600 */
603 }
605 /**
606 * @return array
607 */
610 }
612 /**
613 * @return array|string
614 */
622 }
623 }
625 /**
626 * @return array
627 */
630 }
632 /**
633 * @param $image
634 * @return array|null
635 */
638 }
640 /**
641 * @return array
642 */
645 }
647 /**
648 * @param $tog
649 * @return string
650 */
653 }
655 /**
656 * Get native language names, indexed by code.
657 * Only those defined in MediaWiki, no other data like CLDR.
658 * If $customisedOnly is true, only returns codes with a messages file
659 *
660 * @param $customisedOnly bool
661 *
662 * @return array
663 * @deprecated in 1.20, use fetchLanguageNames()
664 */
667 }
669 /**
670 * Get translated language names. This is done on best effort and
671 * by default this is exactly the same as Language::getLanguageNames.
672 * The CLDR extension provides translated names.
673 * @param $code String Language code.
674 * @return Array language code => language name
675 * @since 1.18.0
676 * @deprecated in 1.20, use fetchLanguageNames()
677 */
680 }
682 /**
683 * Get an array of language names, indexed by code.
684 * @param $inLanguage null|string: Code of language in which to return the names
685 * Use null for autonyms (native names)
686 * @param $include string:
687 * 'all' all available languages
688 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames
689 * 'mwfile' only if the language is in 'mw' *and* has a message file
690 * @return array|bool: language code => language name, false if $include is wrong
691 * @since 1.20
692 */
699 }
704 # TODO: also include when $inLanguage is null, when this code is more efficient
706 }
710 # - Prefer own MediaWiki native name when not using the hook
711 # TODO: prefer it always to make it consistent, but casing is different in CLDR
712 # - For other names just add if not added through the hook
715 }
716 }
720 }
726 }
732 # We do this using a foreach over the codes instead of a directory
733 # loop so that messages files in extensions will work correctly.
737 }
738 }
740 }
742 }
744 /**
745 * @param $code string: The code of the language for which to get the name
746 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
747 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
748 * @return string: Language name or empty
749 * @since 1.20
750 */
754 }
756 /**
757 * Get a message from the MediaWiki namespace.
758 *
759 * @param $msg String: message name
760 * @return string
761 */
764 }
766 /**
767 * Get the native language name of $code.
768 * Only if defined in MediaWiki, no other data like CLDR.
769 * @param $code string
770 * @return string
771 * @deprecated in 1.20, use fetchLanguageName()
772 */
775 }
777 /**
778 * @param $key string
779 * @return string
780 */
783 }
785 /**
786 * @return array
787 */
792 }
794 }
796 /**
797 * @param $key string
798 * @return string
799 */
802 }
804 /**
805 * @param $key string
806 * @return string
807 */
810 }
812 /**
813 * @return array
814 */
819 }
821 }
823 /**
824 * @param $key string
825 * @return string
826 */
829 }
831 /**
832 * @param $key string
833 * @return string
834 */
837 }
839 /**
840 * @param $key string
841 * @return string
842 */
845 }
847 /**
848 * @param $key string
849 * @return string
850 */
853 }
855 /**
856 * @param $key string
857 * @return string
858 */
861 }
863 /**
864 * @param $key string
865 * @return string
866 */
869 }
871 /**
872 * This is a workalike of PHP's date() function, but with better
873 * internationalisation, a reduced set of format characters, and a better
874 * escaping format.
875 *
876 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
877 * PHP manual for definitions. There are a number of extensions, which
878 * start with "x":
879 *
880 * xn Do not translate digits of the next numeric format character
881 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
882 * xr Use roman numerals for the next numeric format character
883 * xh Use hebrew numerals for the next numeric format character
884 * xx Literal x
885 * xg Genitive month name
886 *
887 * xij j (day number) in Iranian calendar
888 * xiF F (month name) in Iranian calendar
889 * xin n (month number) in Iranian calendar
890 * xiy y (two digit year) in Iranian calendar
891 * xiY Y (full year) in Iranian calendar
892 *
893 * xjj j (day number) in Hebrew calendar
894 * xjF F (month name) in Hebrew calendar
895 * xjt t (days in month) in Hebrew calendar
896 * xjx xg (genitive month name) in Hebrew calendar
897 * xjn n (month number) in Hebrew calendar
898 * xjY Y (full year) in Hebrew calendar
899 *
900 * xmj j (day number) in Hijri calendar
901 * xmF F (month name) in Hijri calendar
902 * xmn n (month number) in Hijri calendar
903 * xmY Y (full year) in Hijri calendar
904 *
905 * xkY Y (full year) in Thai solar calendar. Months and days are
906 * identical to the Gregorian calendar
907 * xoY Y (full year) in Minguo calendar or Juche year.
908 * Months and days are identical to the
909 * Gregorian calendar
910 * xtY Y (full year) in Japanese nengo. Months and days are
911 * identical to the Gregorian calendar
912 *
913 * Characters enclosed in double quotes will be considered literal (with
914 * the quotes themselves removed). Unmatched quotes will be considered
915 * literal quotes. Example:
916 *
917 * "The month is" F => The month is January
918 * i's" => 20'11"
919 *
920 * Backslash escaping is also supported.
921 *
922 * Input timestamp is assumed to be pre-normalized to the desired local
923 * time zone, if any.
924 *
925 * @param $format String
926 * @param $ts String: 14-character timestamp
927 * YYYYMMDDHHMMSS
928 * 01234567890123
929 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
930 *
931 * @return string
932 */
951 }
953 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
955 }
993 }
999 }
1005 }
1011 }
1017 }
1024 }
1030 }
1036 }
1045 }
1051 }
1057 }
1072 }
1078 }
1084 }
1090 }
1096 }
1102 }
1108 }
1117 }
1123 }
1129 }
1135 }
1141 }
1147 }
1156 }
1188 }
1194 }
1200 }
1204 # Backslash escaping
1209 }
1212 # Quoted literal
1216 # No terminating quote, assume literal "
1221 }
1223 # Quote at end of string, assume literal "
1225 }
1229 }
1242 }
1243 }
1244 }
1246 }
1251 /**
1252 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1253 * Gregorian dates to Iranian dates. Originally written in C, it
1254 * is released under the terms of GNU Lesser General Public
1255 * License. Conversion to PHP was performed by Niklas Laxström.
1256 *
1257 * Link: http://www.farsiweb.info/jalali/jalali.c
1258 *
1259 * @param $ts string
1260 *
1261 * @return string
1262 */
1268 # Days passed from the beginning (including leap years)
1274 // Add days of the past months of this year
1277 }
1279 // Leap years
1282 }
1284 // Days passed in current month
1298 }
1302 }
1308 }
1310 /**
1311 * Converting Gregorian dates to Hijri dates.
1312 *
1313 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1314 *
1315 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1316 *
1317 * @param $ts string
1318 *
1319 * @return string
1320 */
1334 )
1335 {
1343 }
1348 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1349 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1355 }
1357 /**
1358 * Converting Gregorian dates to Hebrew dates.
1359 *
1360 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1361 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1362 * to translate the relevant functions into PHP and release them under
1363 * GNU GPL.
1364 *
1365 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1366 * and Adar II is 14. In a non-leap year, Adar is 6.
1367 *
1368 * @param $ts string
1369 *
1370 * @return string
1371 */
1373 # Parse date
1378 # Calculate Hebrew year
1381 # Month number when September = 1, August = 12
1384 # Next year
1388 }
1390 # Calculate day of year from 1 September
1394 # February
1396 # Check if the year is leap
1399 }
1404 }
1405 }
1407 # Calculate the start of the Hebrew year
1410 # Calculate next year's start
1412 # Day is before the start of the year - it is the previous year
1413 # Next year's start
1415 # Previous year
1418 # Add days since previous year's 1 September
1421 # Leap year
1423 }
1424 # Start of the new (previous) year
1427 # Next year's start
1429 }
1431 # Calculate Hebrew day of year
1434 # Difference between year's days
1436 # Add 12 (or 13 for leap years) days to ignore the difference between
1437 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1438 # difference is only about the year type
1443 }
1445 # Check the year pattern, and is leap year
1446 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1447 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1448 # and non-leap years
1450 # Check if leap year
1453 # Calculate day in the month from number of day in the Hebrew year
1454 # Don't check Adar - if the day is not in Adar, we will stop before;
1455 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1460 # Calculate days in this month
1462 # Adar in a leap year
1464 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1467 # Day in Adar I
1470 # Subtract the days of Adar I
1472 # Try Adar II
1475 # Day in Adar II
1477 }
1478 }
1479 }
1481 # Cheshvan in a complete year (otherwise as the rule below)
1484 # Kislev in an incomplete year (otherwise as the rule below)
1487 # Odd months have 30 days, even have 29
1489 }
1491 # In the current month
1494 # Subtract the days of the current month
1496 # Try in the next month
1498 }
1499 }
1502 }
1504 /**
1505 * This calculates the Hebrew year start, as days since 1 September.
1506 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1507 * Used for Hebrew date.
1508 *
1509 * @param $year int
1510 *
1511 * @return string
1512 */
1519 }
1523 }
1533 }
1537 }
1539 /**
1540 * Algorithm to convert Gregorian dates to Thai solar dates,
1541 * Minguo dates or Minguo dates.
1542 *
1543 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1544 * http://en.wikipedia.org/wiki/Minguo_calendar
1545 * http://en.wikipedia.org/wiki/Japanese_era_name
1546 *
1547 * @param $ts String: 14-character timestamp
1548 * @param $cName String: calender name
1549 * @return Array: converted year, month, day
1550 */
1557 # Thai solar dates
1558 # Add 543 years to the Gregorian calendar
1559 # Months and days are identical
1562 # Minguo dates
1563 # Deduct 1911 years from the Gregorian calendar
1564 # Months and days are identical
1567 # Nengō dates up to Meiji period
1568 # Deduct years from the Gregorian calendar
1569 # depending on the nengo periods
1570 # Months and days are identical
1571 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1572 # Meiji period
1577 }
1585 )
1586 {
1587 # Taishō period
1592 }
1598 )
1599 {
1600 # Shōwa period
1605 }
1608 # Heisei period
1613 }
1615 }
1618 }
1621 }
1623 /**
1624 * Roman number formatting up to 3000
1625 *
1626 * @param $num int
1627 *
1628 * @return string
1629 */
1636 );
1641 }
1647 }
1649 }
1651 }
1653 /**
1654 * Hebrew Gematria number formatting up to 9999
1655 *
1656 * @param $num int
1657 *
1658 * @return string
1659 */
1666 );
1671 }
1683 }
1684 }
1685 }
1687 }
1693 }
1712 }
1714 }
1716 /**
1717 * Used by date() and time() to adjust the time output.
1718 *
1719 * @param $ts Int the time in date('YmdHis') format
1720 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1721 * get user timecorrection setting)
1722 * @return int
1723 */
1729 }
1742 }
1743 # Unrecognized timezone, default to 'Offset' with the stored offset.
1745 }
1749 # Global offset in minutes.
1752 }
1763 }
1766 }
1767 }
1769 # No difference ? Return time unchanged
1772 }
1775 # Generate an adjusted date; take advantage of the fact that mktime
1776 # will normalize out-of-range values so we don't have to split $minDiff
1777 # into hours and minutes.
1790 }
1792 /**
1793 * This is meant to be used by time(), date(), and timeanddate() to get
1794 * the date preference they're supposed to use, it should be used in
1795 * all children.
1796 *
1797 *<code>
1798 * function timeanddate([...], $format = true) {
1799 * $datePreference = $this->dateFormat($format);
1800 * [...]
1801 * }
1802 *</code>
1803 *
1804 * @param $usePrefs Mixed: if true, the user's preference is used
1805 * if false, the site/language default is used
1806 * if int/string, assumed to be a format.
1807 * @return string
1808 */
1817 }
1820 }
1822 // return int
1825 }
1828 }
1830 /**
1831 * Get a format string for a given type and preference
1832 * @param $type string May be date, time or both
1833 * @param $pref string The format name as it appears in Messages*.php
1834 *
1835 * @return string
1836 */
1847 }
1848 }
1850 }
1852 }
1854 /**
1855 * @param $ts Mixed: the time format which needs to be turned into a
1856 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1857 * @param $adj Bool: whether to adjust the time output according to the
1858 * user configured offset ($timecorrection)
1859 * @param $format Mixed: true to use user's date format preference
1860 * @param $timecorrection String|bool the time offset as returned by
1861 * validateTimeZone() in Special:Preferences
1862 * @return string
1863 */
1868 }
1871 }
1873 /**
1874 * @param $ts Mixed: the time format which needs to be turned into a
1875 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1876 * @param $adj Bool: whether to adjust the time output according to the
1877 * user configured offset ($timecorrection)
1878 * @param $format Mixed: true to use user's date format preference
1879 * @param $timecorrection String|bool the time offset as returned by
1880 * validateTimeZone() in Special:Preferences
1881 * @return string
1882 */
1887 }
1890 }
1892 /**
1893 * @param $ts Mixed: the time format which needs to be turned into a
1894 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1895 * @param $adj Bool: whether to adjust the time output according to the
1896 * user configured offset ($timecorrection)
1897 * @param $format Mixed: what format to return, if it's false output the
1898 * default one (default true)
1899 * @param $timecorrection String|bool the time offset as returned by
1900 * validateTimeZone() in Special:Preferences
1901 * @return string
1902 */
1907 }
1910 }
1912 /**
1913 * Internal helper function for userDate(), userTime() and userTimeAndDate()
1914 *
1915 * @param $type String: can be 'date', 'time' or 'both'
1916 * @param $ts Mixed: the time format which needs to be turned into a
1917 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1918 * @param $user User object used to get preferences for timezone and format
1919 * @param $options Array, can contain the following keys:
1920 * - 'timecorrection': time correction, can have the following values:
1921 * - true: use user's preference
1922 * - false: don't use time correction
1923 * - integer: value of time correction in minutes
1924 * - 'format': format to use, can have the following values:
1925 * - true: use user's preference
1926 * - false: use default preference
1927 * - string: format to use
1928 * @since 1.19
1929 * @return String
1930 */
1939 }
1941 }
1946 }
1949 }
1951 /**
1952 * Get the formatted date for the given timestamp and formatted for
1953 * the given user.
1954 *
1955 * @param $ts Mixed: the time format which needs to be turned into a
1956 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1957 * @param $user User object used to get preferences for timezone and format
1958 * @param $options Array, can contain the following keys:
1959 * - 'timecorrection': time correction, can have the following values:
1960 * - true: use user's preference
1961 * - false: don't use time correction
1962 * - integer: value of time correction in minutes
1963 * - 'format': format to use, can have the following values:
1964 * - true: use user's preference
1965 * - false: use default preference
1966 * - string: format to use
1967 * @since 1.19
1968 * @return String
1969 */
1972 }
1974 /**
1975 * Get the formatted time for the given timestamp and formatted for
1976 * the given user.
1977 *
1978 * @param $ts Mixed: the time format which needs to be turned into a
1979 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1980 * @param $user User object used to get preferences for timezone and format
1981 * @param $options Array, can contain the following keys:
1982 * - 'timecorrection': time correction, can have the following values:
1983 * - true: use user's preference
1984 * - false: don't use time correction
1985 * - integer: value of time correction in minutes
1986 * - 'format': format to use, can have the following values:
1987 * - true: use user's preference
1988 * - false: use default preference
1989 * - string: format to use
1990 * @since 1.19
1991 * @return String
1992 */
1995 }
1997 /**
1998 * Get the formatted date and time for the given timestamp and formatted for
1999 * the given user.
2000 *
2001 * @param $ts Mixed: the time format which needs to be turned into a
2002 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2003 * @param $user User object used to get preferences for timezone and format
2004 * @param $options Array, can contain the following keys:
2005 * - 'timecorrection': time correction, can have the following values:
2006 * - true: use user's preference
2007 * - false: don't use time correction
2008 * - integer: value of time correction in minutes
2009 * - 'format': format to use, can have the following values:
2010 * - true: use user's preference
2011 * - false: use default preference
2012 * - string: format to use
2013 * @since 1.19
2014 * @return String
2015 */
2018 }
2020 /**
2021 * @param $key string
2022 * @return array|null
2023 */
2026 }
2028 /**
2029 * @return array
2030 */
2033 }
2035 /**
2036 * @param $in
2037 * @param $out
2038 * @param $string
2039 * @return string
2040 */
2042 # This is a wrapper for iconv in all languages except esperanto,
2043 # which does some nasty x-conversions beforehand
2045 # Even with //IGNORE iconv can whine about illegal characters in
2046 # *input* string. We just ignore those too.
2047 # REF: http://bugs.php.net/bug.php?id=37166
2048 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2053 }
2055 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2057 /**
2058 * @param $matches array
2059 * @return mixed|string
2060 */
2063 }
2065 /**
2066 * @param $matches array
2067 * @return string
2068 */
2071 }
2073 /**
2074 * @param $matches array
2075 * @return string
2076 */
2080 }
2082 /**
2083 * @param $matches array
2084 * @return string
2085 */
2089 }
2091 /**
2092 * @param $matches array
2093 * @return string
2094 */
2097 }
2099 /**
2100 * @param $matches array
2101 * @return string
2102 */
2106 }
2108 /**
2109 * Make a string's first character uppercase
2110 *
2111 * @param $str string
2112 *
2113 * @return string
2114 */
2122 // fall back to more complex logic in case of multibyte strings
2124 }
2125 }
2127 /**
2128 * Convert a string to uppercase
2129 *
2130 * @param $str string
2131 * @param $first bool
2132 *
2133 * @return string
2134 */
2142 }
2145 }
2152 $str
2153 );
2156 }
2157 }
2158 }
2160 /**
2161 * @param $str string
2162 * @return mixed|string
2163 */
2175 }
2176 }
2178 /**
2179 * @param $str string
2180 * @param $first bool
2181 * @return mixed|string
2182 */
2190 }
2193 }
2200 $str
2201 );
2204 }
2205 }
2206 }
2208 /**
2209 * @param $str string
2210 * @return bool
2211 */
2214 }
2216 /**
2217 * @param $str string
2218 * @return mixed|string
2219 */
2224 // regexp to find first letter in each word (i.e. after each space)
2225 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2227 // function to use to capitalize a single char
2232 $str
2233 );
2238 $str
2239 );
2240 }
2243 }
2244 }
2246 /**
2247 * capitalize words at word breaks
2248 *
2249 * @param $str string
2250 * @return mixed
2251 */
2256 // since \b doesn't work for UTF-8, we explicitely define word break chars
2259 // find first letter after word break
2260 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2266 $str
2267 );
2272 $str
2273 );
2274 }
2279 $str
2280 );
2281 }
2282 }
2284 /**
2285 * Return a case-folded representation of $s
2286 *
2287 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2288 * and $s2 are the same except for the case of their characters. It is not
2289 * necessary for the value returned to make sense when displayed.
2290 *
2291 * Do *not* perform any other normalisation in this function. If a caller
2292 * uses this function when it should be using a more general normalisation
2293 * function, then fix the caller.
2294 *
2295 * @param $s string
2296 *
2297 * @return string
2298 */
2301 }
2303 /**
2304 * @param $s string
2305 * @return string
2306 */
2310 }
2311 # Check for non-UTF-8 URLs
2315 }
2321 }
2324 }
2326 /**
2327 * @return array
2328 */
2331 }
2333 /**
2334 * Most writing systems use whitespace to break up words.
2335 * Some languages such as Chinese don't conventionally do this,
2336 * which requires special handling when breaking up words for
2337 * searching etc.
2338 *
2339 * @return bool
2340 */
2343 }
2345 /**
2346 * Some languages such as Chinese require word segmentation,
2347 * Specify such segmentation when overridden in derived class.
2348 *
2349 * @param $string String
2350 * @return String
2351 */
2354 }
2356 /**
2357 * Some languages have special punctuation need to be normalized.
2358 * Make such changes here.
2359 *
2360 * @param $string String
2361 * @return String
2362 */
2365 }
2367 /**
2368 * convert double-width roman characters to single-width.
2369 * range: ff00-ff5f ~= 0020-007f
2370 *
2371 * @param $string string
2372 *
2373 * @return string
2374 */
2384 }
2388 }
2390 /**
2391 * @param $string string
2392 * @param $pattern string
2393 * @return string
2394 */
2399 }
2401 /**
2402 * @param $termsArray array
2403 * @return array
2404 */
2406 # some languages, e.g. Chinese, need to do a conversion
2407 # in order for search results to be displayed correctly
2409 }
2411 /**
2412 * Get the first character of a string.
2413 *
2414 * @param $s string
2415 * @return string
2416 */
2423 $matches
2424 );
2429 }
2431 // Break down Hangul syllables to grab the first jamo
2463 }
2466 }
2467 }
2470 # Some languages may have an alternate char encoding option
2471 # (Esperanto X-coding, Japanese furigana conversion, etc)
2472 # If this language is used as the primary content language,
2473 # an override to the defaults can be set here on startup.
2474 }
2476 /**
2477 * @param $s string
2478 * @return string
2479 */
2481 # For some languages we'll want to explicitly specify
2482 # which characters make it into the edit box raw
2483 # or are converted in some way or another.
2489 }
2490 }
2492 /**
2493 * @param $s string
2494 * @return string
2495 */
2497 # Take the previous into account.
2503 }
2508 }
2509 }
2511 /**
2512 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2513 * also cleans up certain backwards-compatible sequences, converting them
2514 * to the modern Unicode equivalent.
2515 *
2516 * This is language-specific for performance reasons only.
2517 *
2518 * @param $s string
2519 *
2520 * @return string
2521 */
2528 }
2531 }
2533 /**
2534 * Transform a string using serialized data stored in the given file (which
2535 * must be in the serialized subdirectory of $IP). The file contains pairs
2536 * mapping source characters to destination characters.
2537 *
2538 * The data is cached in process memory. This will go faster if you have the
2539 * FastStringSearch extension.
2540 *
2541 * @param $file string
2542 * @param $string string
2543 *
2544 * @throws MWException
2545 * @return string
2546 */
2552 }
2554 }
2556 }
2558 /**
2559 * For right-to-left language support
2560 *
2561 * @return bool
2562 */
2565 }
2567 /**
2568 * Return the correct HTML 'dir' attribute value for this language.
2569 * @return String
2570 */
2573 }
2575 /**
2576 * Return 'left' or 'right' as appropriate alignment for line-start
2577 * for this language's text direction.
2578 *
2579 * Should be equivalent to CSS3 'start' text-align value....
2580 *
2581 * @return String
2582 */
2585 }
2587 /**
2588 * Return 'right' or 'left' as appropriate alignment for line-end
2589 * for this language's text direction.
2590 *
2591 * Should be equivalent to CSS3 'end' text-align value....
2592 *
2593 * @return String
2594 */
2597 }
2599 /**
2600 * A hidden direction mark (LRM or RLM), depending on the language direction.
2601 * Unlike getDirMark(), this function returns the character as an HTML entity.
2602 * This function should be used when the output is guaranteed to be HTML,
2603 * because it makes the output HTML source code more readable. When
2604 * the output is plain text or can be escaped, getDirMark() should be used.
2605 *
2606 * @param $opposite Boolean Get the direction mark opposite to your language
2607 * @return string
2608 */
2612 }
2614 /**
2615 * A hidden direction mark (LRM or RLM), depending on the language direction.
2616 * This function produces them as invisible Unicode characters and
2617 * the output may be hard to read and debug, so it should only be used
2618 * when the output is plain text or can be escaped. When the output is
2619 * HTML, use getDirMarkEntity() instead.
2620 *
2621 * @param $opposite Boolean Get the direction mark opposite to your language
2622 * @return string
2623 */
2629 }
2631 /**
2632 * @return array
2633 */
2636 }
2638 /**
2639 * An arrow, depending on the language direction
2640 *
2641 * @return string
2642 */
2645 }
2647 /**
2648 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2649 *
2650 * @return bool
2651 */
2654 }
2656 /**
2657 * @return array
2658 */
2661 }
2666 }
2671 }
2673 /**
2674 * Fill a MagicWord object with data from here
2675 *
2676 * @param $mw
2677 */
2689 }
2690 }
2697 }
2698 }
2700 /**
2701 * Add magic words to the extension array
2702 *
2703 * @param $newWords array
2704 */
2711 }
2712 }
2713 }
2715 /**
2716 * Get special page names, as an associative array
2717 * case folded alias => real name
2718 */
2720 // Cache aliases because it may be slow to load them
2722 // Initialise array
2727 }
2730 }
2732 /**
2733 * Italic is unsuitable for some languages
2734 *
2735 * @param $text String: the text to be emphasized.
2736 * @return string
2737 */
2740 }
2742 /**
2743 * Normally we output all numbers in plain en_US style, that is
2744 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2745 * point twohundredthirtyfive. However this is not suitable for all
2746 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2747 * Icelandic just want to use commas instead of dots, and dots instead
2748 * of commas like "293.291,235".
2749 *
2750 * An example of this function being called:
2751 * <code>
2752 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2753 * </code>
2754 *
2755 * See LanguageGu.php for the Gujarati implementation and
2756 * $separatorTransformTable on MessageIs.php for
2757 * the , => . and . => , implementation.
2758 *
2759 * @todo check if it's viable to use localeconv() for the decimal
2760 * separator thing.
2761 * @param $number Mixed: the string to be formatted, should be an integer
2762 * or a floating point number.
2763 * @param $nocommafy Bool: set to true for special numbers like dates
2764 * @return string
2765 */
2773 }
2774 }
2780 }
2781 }
2784 }
2786 /**
2787 * @param $number string
2788 * @return string
2789 */
2794 }
2799 }
2803 }
2805 /**
2806 * Adds commas to a given number
2807 * @since 1.19
2808 * @param $_ mixed
2809 * @return string
2810 */
2815 }
2818 // default grouping is at thousands, use the same for ###,###,### pattern too.
2821 // Ref: http://cldr.unicode.org/translation/number-patterns
2824 // For negative numbers apply the algorithm like positive number and add sign.
2827 }
2835 // the string does not have any number part. Eg: .12345
2837 }
2845 }
2849 // use the last pattern for the rest of the number
2851 }
2854 }
2855 }
2857 }
2858 }
2859 /**
2860 * @return String
2861 */
2864 }
2866 /**
2867 * @return array
2868 */
2871 }
2873 /**
2874 * @return array
2875 */
2878 }
2880 /**
2881 * Take a list of strings and build a locale-friendly comma-separated
2882 * list, using the local comma-separator message.
2883 * The last two strings are chained with an "and".
2884 *
2885 * @param $l Array
2886 * @return string
2887 */
2892 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2898 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2901 }
2902 }
2904 }
2905 }
2907 /**
2908 * Take a list of strings and build a locale-friendly comma-separated
2909 * list, using the local comma-separator message.
2910 * @param $list array of strings to put in a comma list
2911 * @return string
2912 */
2918 ),
2919 $list
2920 );
2921 }
2923 /**
2924 * Take a list of strings and build a locale-friendly semicolon-separated
2925 * list, using the local semicolon-separator message.
2926 * @param $list array of strings to put in a semicolon list
2927 * @return string
2928 */
2934 ),
2935 $list
2936 );
2937 }
2939 /**
2940 * Same as commaList, but separate it with the pipe instead.
2941 * @param $list array of strings to put in a pipe list
2942 * @return string
2943 */
2949 ),
2950 $list
2951 );
2952 }
2954 /**
2955 * Truncate a string to a specified length in bytes, appending an optional
2956 * string (e.g. for ellipses)
2957 *
2958 * The database offers limited byte lengths for some columns in the database;
2959 * multi-byte character sets mean we need to ensure that only whole characters
2960 * are included, otherwise broken characters can be passed to the user
2961 *
2962 * If $length is negative, the string will be truncated from the beginning
2963 *
2964 * @param $string String to truncate
2965 * @param $length Int: maximum length (including ellipses)
2966 * @param $ellipsis String to append to the truncated text
2967 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
2968 * $adjustLength was introduced in 1.18, before that behaved as if false.
2969 * @return string
2970 */
2972 # Use the localized ellipsis character
2975 }
2976 # Check if there is no need to truncate
2981 }
2983 # If ellipsis length is >= $length then we can't apply $adjustLength
2986 # Otherwise, truncate and add ellipsis...
2999 }
3000 }
3001 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3002 # This check is *not* redundant if $adjustLength, due to the single case where
3003 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3008 }
3009 }
3011 /**
3012 * Remove bytes that represent an incomplete Unicode character
3013 * at the end of string (e.g. bytes of the char are missing)
3014 *
3015 * @param $string String
3016 * @return string
3017 */
3023 # We got the first byte only of a multibyte char; remove it.
3028 {
3029 # We chopped in the middle of a character; remove it
3031 }
3032 }
3034 }
3036 /**
3037 * Remove bytes that represent an incomplete Unicode character
3038 * at the start of string (e.g. bytes of the char are missing)
3039 *
3040 * @param $string String
3041 * @return string
3042 */
3047 # We chopped in the middle of a character; remove the whole thing
3049 }
3050 }
3052 }
3054 /**
3055 * Truncate a string of valid HTML to a specified length in bytes,
3056 * appending an optional string (e.g. for ellipses), and return valid HTML
3057 *
3058 * This is only intended for styled/linked text, such as HTML with
3059 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3060 * Also, this will not detect things like "display:none" CSS.
3061 *
3062 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3063 *
3064 * @param string $text HTML string to truncate
3065 * @param int $length (zero/positive) Maximum length (including ellipses)
3066 * @param string $ellipsis String to append to the truncated text
3067 * @return string
3068 */
3070 # Use the localized ellipsis character
3073 }
3074 # Check if there is clearly no need to truncate
3079 }
3093 # Consider truncation once the display length has reached the maximim.
3094 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3095 # Check that we're not in the middle of a bracket/entity...
3099 # Save where we are; we will truncate here unless there turn out to
3100 # be so few remaining characters that truncation is not necessary.
3103 }
3105 # String in fact does need truncation, the truncation point was OK.
3110 }
3111 }
3114 # Read the next char...
3132 }
3138 // Name found (e.g. "<a href=..."), add on tag attributes...
3140 }
3146 }
3149 // Save state without $ch. We want to *hit* the first
3150 // display char (to get tags) but not *use* it if truncating.
3152 }
3157 // Add the next $max display text chars after this in one swoop...
3162 }
3163 }
3164 }
3165 }
3166 // Close the last tag if left unclosed by bad HTML
3170 }
3172 }
3174 /**
3175 * truncateHtml() helper function
3176 * like strcspn() but adds the skipped chars to $ret
3177 *
3178 * @param $ret
3179 * @param $text
3180 * @param $search
3181 * @param $start
3182 * @param $len
3183 * @return int
3184 */
3190 }
3195 }
3197 }
3199 /**
3200 * truncateHtml() helper function
3201 * (a) push or pop $tag from $openTags as needed
3202 * (b) clear $tag value
3203 * @param &$tag string Current HTML tag name we are looking at
3204 * @param $tagType int (0-open tag, 1-close tag)
3205 * @param $lastCh string Character before the '>' that ended this tag
3206 * @param &$openTags array Open tag stack (not accounting for $tag)
3207 */
3216 }
3217 }
3219 }
3220 }
3222 /**
3223 * Grammatical transformations, needed for inflected languages
3224 * Invoked by putting {{grammar:case|word}} in a message
3225 *
3226 * @param $word string
3227 * @param $case string
3228 * @return string
3229 */
3234 }
3236 }
3238 /**
3239 * Provides an alternative text depending on specified gender.
3240 * Usage {{gender:username|masculine|feminine|neutral}}.
3241 * username is optional, in which case the gender of current user is used,
3242 * but only in (some) interface messages; otherwise default gender is used.
3243 *
3244 * If no forms are given, an empty string is returned. If only one form is
3245 * given, it will be returned unconditionally. These details are implied by
3246 * the caller and cannot be overridden in subclasses.
3247 *
3248 * If more than one form is given, the default is to use the neutral one
3249 * if it is specified, and to use the masculine one otherwise. These
3250 * details can be overridden in subclasses.
3251 *
3252 * @param $gender string
3253 * @param $forms array
3254 *
3255 * @return string
3256 */
3260 }
3264 }
3267 }
3269 }
3271 /**
3272 * Plural form transformations, needed for some languages.
3273 * For example, there are 3 form of plural in Russian and Polish,
3274 * depending on "count mod 10". See [[w:Plural]]
3275 * For English it is pretty simple.
3276 *
3277 * Invoked by putting {{plural:count|wordform1|wordform2}}
3278 * or {{plural:count|wordform1|wordform2|wordform3}}
3279 *
3280 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3281 *
3282 * @param $count Integer: non-localized number
3283 * @param $forms Array: different plural forms
3284 * @return string Correct form of plural for $count in this language
3285 */
3289 }
3293 }
3295 /**
3296 * Checks that convertPlural was given an array and pads it to requested
3297 * amount of forms by copying the last one.
3298 *
3299 * @param $count Integer: How many forms should there be at least
3300 * @param $forms Array of forms given to convertPlural
3301 * @return array Padded array of forms or an exception if not an array
3302 */
3306 }
3308 }
3310 /**
3311 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3312 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3313 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3314 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3315 * match up with it.
3316 *
3317 * @param $str String: the validated block duration in English
3318 * @return string Somehow translated block duration
3319 * @see LanguageFi.php for example implementation
3320 */
3326 }
3327 }
3329 // Since usually only infinite or indefinite is only on list, so try
3330 // equivalents if still here.
3337 }
3338 }
3339 }
3340 // If all else fails, return the original string.
3342 }
3344 /**
3345 * languages like Chinese need to be segmented in order for the diff
3346 * to be of any use
3347 *
3348 * @param $text String
3349 * @return String
3350 */
3353 }
3355 /**
3356 * and unsegment to show the result
3357 *
3358 * @param $text String
3359 * @return String
3360 */
3363 }
3365 /**
3366 * Return the LanguageConverter used in the Language
3367 *
3368 * @since 1.19
3369 * @return LanguageConverter
3370 */
3373 }
3375 /**
3376 * convert text to all supported variants
3377 *
3378 * @param $text string
3379 * @return array
3380 */
3383 }
3385 /**
3386 * convert text to different variants of a language.
3387 *
3388 * @param $text string
3389 * @return string
3390 */
3393 }
3395 /**
3396 * Convert a Title object to a string in the preferred variant
3397 *
3398 * @param $title Title
3399 * @return string
3400 */
3403 }
3405 /**
3406 * Check if this is a language with variants
3407 *
3408 * @return bool
3409 */
3412 }
3414 /**
3415 * Check if the language has the specific variant
3416 *
3417 * @since 1.19
3418 * @param $variant string
3419 * @return bool
3420 */
3423 }
3425 /**
3426 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3427 *
3428 * @param $text string
3429 * @return string
3430 */
3433 }
3435 /**
3436 * Perform output conversion on a string, and encode for safe HTML output.
3437 * @param $text String text to be converted
3438 * @param $isTitle Bool whether this conversion is for the article title
3439 * @return string
3440 * @todo this should get integrated somewhere sane
3441 */
3444 }
3446 /**
3447 * @param $key string
3448 * @return string
3449 */
3452 }
3454 /**
3455 * Get the list of variants supported by this language
3456 * see sample implementation in LanguageZh.php
3457 *
3458 * @return array an array of language codes
3459 */
3462 }
3464 /**
3465 * @return string
3466 */
3469 }
3471 /**
3472 * @return string
3473 */
3476 }
3478 /**
3479 * @return string
3480 */
3483 }
3485 /**
3486 * If a language supports multiple variants, it is
3487 * possible that non-existing link in one variant
3488 * actually exists in another variant. this function
3489 * tries to find it. See e.g. LanguageZh.php
3490 *
3491 * @param $link String: the name of the link
3492 * @param $nt Mixed: the title object of the link
3493 * @param $ignoreOtherCond Boolean: to disable other conditions when
3494 * we need to transclude a template or update a category's link
3495 * @return null the input parameters may be modified upon return
3496 */
3499 }
3501 /**
3502 * If a language supports multiple variants, converts text
3503 * into an array of all possible variants of the text:
3504 * 'variant' => text in that variant
3505 *
3506 * @deprecated since 1.17 Use autoConvertToAllVariants()
3507 *
3508 * @param $text string
3509 *
3510 * @return string
3511 */
3514 }
3516 /**
3517 * returns language specific options used by User::getPageRenderHash()
3518 * for example, the preferred language variant
3519 *
3520 * @return string
3521 */
3524 }
3526 /**
3527 * For languages that support multiple variants, the title of an
3528 * article may be displayed differently in different variants. this
3529 * function returns the apporiate title defined in the body of the article.
3530 *
3531 * @return string
3532 */
3535 }
3537 /**
3538 * Enclose a string with the "no conversion" tag. This is used by
3539 * various functions in the Parser
3540 *
3541 * @param $text String: text to be tagged for no conversion
3542 * @param $noParse bool
3543 * @return string the tagged text
3544 */
3547 }
3549 /**
3550 * A regular expression to match legal word-trailing characters
3551 * which should be merged onto a link of the form [[foo]]bar.
3552 *
3553 * @return string
3554 */
3557 }
3559 /**
3560 * @return Language
3561 */
3564 }
3566 /**
3567 * Get the RFC 3066 code for this language object
3568 *
3569 * @return string
3570 */
3573 }
3575 /**
3576 * Get the code in Bcp47 format which we can use
3577 * inside of html lang="" tags.
3578 * @since 1.19
3579 * @return string
3580 */
3584 }
3586 }
3588 /**
3589 * @param $code string
3590 */
3593 // Ensure we don't leave an incorrect html code lying around
3595 }
3597 /**
3598 * Get the name of a file for a certain language code
3599 * @param $prefix string Prepend this to the filename
3600 * @param $code string Language code
3601 * @param $suffix string Append this to the filename
3602 * @throws MWException
3603 * @return string $prefix . $mangledCode . $suffix
3604 */
3606 // Protect against path traversal
3609 {
3611 }
3614 }
3616 /**
3617 * Get the language code from a file name. Inverse of getFileName()
3618 * @param $filename string $prefix . $languageCode . $suffix
3619 * @param $prefix string Prefix before the language code
3620 * @param $suffix string Suffix after the language code
3621 * @return string Language code, or false if $prefix or $suffix isn't found
3622 */
3623 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3629 }
3631 }
3633 /**
3634 * @param $code string
3635 * @return string
3636 */
3642 }
3644 /**
3645 * @param $code string
3646 * @return string
3647 */
3651 }
3653 /**
3654 * Get the first fallback for a given language.
3655 *
3656 * @param $code string
3657 *
3658 * @return bool|string
3659 */
3667 }
3668 }
3670 /**
3671 * Get the ordered list of fallback languages.
3672 *
3673 * @since 1.19
3674 * @param $code string Language code
3675 * @return array
3676 */
3685 }
3687 }
3688 }
3690 /**
3691 * Get all messages for a given language
3692 * WARNING: this may take a long time. If you just need all message *keys*
3693 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3694 *
3695 * @param $code string
3696 *
3697 * @return array
3698 */
3701 }
3703 /**
3704 * Get a message for a given language
3705 *
3706 * @param $key string
3707 * @param $code string
3708 *
3709 * @return string
3710 */
3713 }
3715 /**
3716 * Get all message keys for a given language. This is a faster alternative to
3717 * array_keys( Language::getMessagesFor( $code ) )
3718 *
3719 * @since 1.19
3720 * @param $code string Language code
3721 * @return array of message keys (strings)
3722 */
3725 }
3727 /**
3728 * @param $talk
3729 * @return mixed
3730 */
3734 }
3739 # Allow grammar transformations
3740 # Allowing full message-style parsing would make simple requests
3741 # such as action=raw much more expensive than they need to be.
3742 # This will hopefully cover most cases.
3746 }
3748 /**
3749 * @param $m string
3750 * @return string
3751 */
3754 }
3756 /**
3757 * @throws MWException
3758 * @return array
3759 */
3764 }
3771 }
3776 }
3778 /**
3779 * Decode an expiry (block, protection, etc) which has come from the DB
3780 *
3781 * @FIXME: why are we returnings DBMS-dependent strings???
3782 *
3783 * @param $expiry String: Database expiry String
3784 * @param $format Bool|Int true to process using language functions, or TS_ constant
3785 * to return the expiry in a given timestamp
3786 * @return String
3787 */
3793 }
3797 ? $infinityMsg
3803 }
3804 }
3806 /**
3807 * @todo Document
3808 * @param $seconds int|float
3809 * @param $format Array Optional
3810 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
3811 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
3812 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
3813 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
3814 * @return string
3815 */
3819 }
3822 }
3825 }
3847 }
3858 }
3862 }
3868 }
3876 }
3886 }
3890 }
3900 }
3901 }
3903 }
3905 /**
3906 * Format a bitrate for output, using an appropriate
3907 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
3908 *
3909 * This use base 1000. For base 1024 use formatSize(), for another base
3910 * see formatComputingNumbers()
3911 *
3912 * @param $bps int
3913 * @return string
3914 */
3917 }
3919 /**
3920 * @param $size int Size of the unit
3921 * @param $boundary int Size boundary (1000, or 1024 in most cases)
3922 * @param $messageKey string Message key to be uesd
3923 * @return string
3924 */
3929 );
3930 }
3938 }
3940 // For small sizes no decimal places necessary
3943 // For MB and bigger two decimal places are smarter
3945 }
3951 }
3953 /**
3954 * Format a size in bytes for output, using an appropriate
3955 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
3956 *
3957 * This method use base 1024. For base 1000 use formatBitrate(), for
3958 * another base see formatComputingNumbers()
3959 *
3960 * @param $size int Size to format
3961 * @return string Plain text (not HTML)
3962 */
3965 }
3967 /**
3968 * Make a list item, used by various special pages
3969 *
3970 * @param $page String Page link
3971 * @param $details String Text between brackets
3972 * @param $oppositedm Boolean Add the direction mark opposite to your
3973 * language, to display text properly
3974 * @return String
3975 */
3980 wfMsgExt( 'parentheses', array( 'escape', 'replaceafter', 'language' => $this ), $details ) : '';
3982 }
3984 /**
3985 * Generate (prev x| next x) (20|50|100...) type links for paging
3986 *
3987 * @param $title Title object to link
3988 * @param $offset Integer offset parameter
3989 * @param $limit Integer limit parameter
3990 * @param $query String optional URL query parameter string
3991 * @param $atend Bool optional param for specified if this is the last page
3992 * @return String
3993 */
3994 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
3995 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
3997 # Make 'previous' link
3998 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4004 }
4006 # Make 'next' link
4007 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4013 }
4015 # Make links to set number of items per page
4020 }
4024 }
4026 /**
4027 * Helper function for viewPrevNext() that generates links
4028 *
4029 * @param $title Title object to link
4030 * @param $offset Integer offset parameter
4031 * @param $limit Integer limit parameter
4032 * @param $query Array extra query parameters
4033 * @param $link String text to use for the link; will be escaped
4034 * @param $tooltipMsg String name of the message to use as tooltip
4035 * @param $class String value of the "class" attribute of the link
4036 * @return String HTML fragment
4037 */
4038 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4040 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4043 }
4045 /**
4046 * Get the conversion rule title, if any.
4047 *
4048 * @return string
4049 */
4052 }
4053 }