| blob | e6feb45edf10375b82ab67d52d17482051628734 |
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 * @since 1.20
144 * @var array
145 */
156 );
158 /**
159 * Get a cached language object for a given language code
160 * @param $code String
161 * @return Language
162 */
166 // Don't keep a billion objects around, that's stupid.
168 }
170 }
172 }
174 /**
175 * Create a language object for a given language code
176 * @param $code String
177 * @throws MWException
178 * @return Language
179 */
181 // Protect against path traversal below
184 {
186 }
189 // It's not possible to customise this code with class files, so
190 // just return a Language object. This is to support uselang= hacks.
194 }
196 // Check if there is a language class for the code
202 }
204 // Keep trying the fallback list until we find an existing class
209 }
217 }
218 }
221 }
223 /**
224 * Returns true if a language code string is of a valid form, whether or
225 * not it exists. This includes codes which are used solely for
226 * customisation via the MediaWiki namespace.
227 *
228 * @param $code string
229 *
230 * @return bool
231 */
233 return
236 }
238 /**
239 * Returns true if a language code is of a valid form for the purposes of
240 * internal customisation of MediaWiki, via Messages*.php.
241 *
242 * @param $code string
243 *
244 * @since 1.18
245 * @return bool
246 */
249 }
251 /**
252 * @param $code
253 * @return String Name of the language class
254 */
260 }
261 }
263 /**
264 * Includes language class files
265 *
266 * @param $class string Name of the language class
267 */
273 }
276 // Preload base classes to work around APC/PHP5 bug
279 }
282 }
283 }
284 }
286 /**
287 * Get the LocalisationCache instance
288 *
289 * @return LocalisationCache
290 */
296 }
298 }
302 // Set the code to the name of the descendant
307 }
309 }
311 /**
312 * Reduce memory usage
313 */
317 }
318 }
320 /**
321 * Hook which will be called if this is the content language.
322 * Descendants can use this to register hook functions or modify globals
323 */
326 /**
327 * Same as getFallbacksFor for current language.
328 * @return array|bool
329 * @deprecated in 1.19
330 */
334 }
336 /**
337 * @return array
338 * @since 1.19
339 */
342 }
344 /**
345 * Exports $wgBookstoreListEn
346 * @return array
347 */
350 }
352 /**
353 * @return array
354 */
371 }
373 # Sometimes a language will be localised but not actually exist on this wiki.
377 }
378 }
380 # The above mixing may leave namespaces out of canonical order.
381 # Re-order by namespace ID number...
385 }
387 }
389 /**
390 * Arbitrarily set all of the namespace names at once. Mainly used for testing
391 * @param $namespaces Array of namespaces (id => name)
392 */
395 }
397 /**
398 * A convenience function that returns the same thing as
399 * getNamespaces() except with the array values changed to ' '
400 * where it found '_', useful for producing output to be displayed
401 * e.g. in <select> forms.
402 *
403 * @return array
404 */
409 }
411 }
413 /**
414 * Get a namespace value by key
415 * <code>
416 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
417 * echo $mw_ns; // prints 'MediaWiki'
418 * </code>
419 *
420 * @param $index Int: the array key of the namespace to return
421 * @return mixed, string if the namespace value exists, otherwise false
422 */
426 }
428 /**
429 * A convenience function that returns the same thing as
430 * getNsText() except with '_' changed to ' ', useful for
431 * producing output.
432 *
433 * @param $index string
434 *
435 * @return array
436 */
440 }
442 /**
443 * Returns gender-dependent namespace alias if available.
444 * @param $index Int: namespace index
445 * @param $gender String: gender key (male, female... )
446 * @return String
447 * @since 1.18
448 */
452 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
454 }
456 /**
457 * Whether this language makes distinguishes genders for example in
458 * namespaces.
459 * @return bool
460 * @since 1.18
461 */
465 // $wgExtraGenderNamespaces overrides everything
467 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
468 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
469 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
472 // Check what is in i18n files
475 }
476 }
478 /**
479 * Get a namespace key by value, case insensitive.
480 * Only matches namespace names for the current language, not the
481 * canonical ones defined in Namespace.php.
482 *
483 * @param $text String
484 * @return mixed An integer if $text is a valid value otherwise false
485 */
490 }
492 /**
493 * @return array
494 */
506 }
507 }
508 }
511 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
515 }
516 }
519 }
521 }
523 /**
524 * @return array
525 */
529 # Put namespace names and aliases into a hashtable.
530 # If this is too slow, then we should arrange it so that it is done
531 # before caching. The catch is that at pre-cache time, the above
532 # class-specific fixup hasn't been done.
536 }
539 }
543 }
544 }
545 }
547 }
549 /**
550 * Get a namespace key by value, case insensitive. Canonical namespace
551 * names override custom ones defined for the current language.
552 *
553 * @param $text String
554 * @return mixed An integer if $text is a valid value otherwise false
555 */
561 }
564 }
566 /**
567 * short names for language variants used for language conversion links.
568 *
569 * @param $code String
570 * @param $usemsg bool Use the "variantname-xyz" message if it exists
571 * @return string
572 */
577 }
582 # otherwise, output the language code
584 }
585 }
587 /**
588 * @param $name string
589 * @return string
590 */
595 }
597 }
599 /**
600 * @return array
601 */
610 );
611 }
613 /**
614 * @return array
615 */
618 }
620 /**
621 * @return array
622 */
625 }
627 /**
628 * @return array|string
629 */
637 }
638 }
640 /**
641 * @return array
642 */
645 }
647 /**
648 * @param $image
649 * @return array|null
650 */
653 }
655 /**
656 * @return array
657 */
660 }
662 /**
663 * @param $tog
664 * @return string
665 */
668 }
670 /**
671 * Get native language names, indexed by code.
672 * Only those defined in MediaWiki, no other data like CLDR.
673 * If $customisedOnly is true, only returns codes with a messages file
674 *
675 * @param $customisedOnly bool
676 *
677 * @return array
678 * @deprecated in 1.20, use fetchLanguageNames()
679 */
682 }
684 /**
685 * Get translated language names. This is done on best effort and
686 * by default this is exactly the same as Language::getLanguageNames.
687 * The CLDR extension provides translated names.
688 * @param $code String Language code.
689 * @return Array language code => language name
690 * @since 1.18.0
691 * @deprecated in 1.20, use fetchLanguageNames()
692 */
695 }
697 /**
698 * Get an array of language names, indexed by code.
699 * @param $inLanguage null|string: Code of language in which to return the names
700 * Use null for autonyms (native names)
701 * @param $include string:
702 * 'all' all available languages
703 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames
704 * 'mwfile' only if the language is in 'mw' *and* has a message file
705 * @return array|bool: language code => language name, false if $include is wrong
706 * @since 1.20
707 */
714 }
719 # TODO: also include when $inLanguage is null, when this code is more efficient
721 }
725 # - Prefer own MediaWiki native name when not using the hook
726 # TODO: prefer it always to make it consistent, but casing is different in CLDR
727 # - For other names just add if not added through the hook
730 }
731 }
735 }
741 }
747 # We do this using a foreach over the codes instead of a directory
748 # loop so that messages files in extensions will work correctly.
752 }
753 }
755 }
757 }
759 /**
760 * @param $code string: The code of the language for which to get the name
761 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
762 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
763 * @return string: Language name or empty
764 * @since 1.20
765 */
769 }
771 /**
772 * Get a message from the MediaWiki namespace.
773 *
774 * @param $msg String: message name
775 * @return string
776 */
779 }
781 /**
782 * Get the native language name of $code.
783 * Only if defined in MediaWiki, no other data like CLDR.
784 * @param $code string
785 * @return string
786 * @deprecated in 1.20, use fetchLanguageName()
787 */
790 }
792 /**
793 * @param $key string
794 * @return string
795 */
798 }
800 /**
801 * @return array
802 */
807 }
809 }
811 /**
812 * @param $key string
813 * @return string
814 */
817 }
819 /**
820 * @param $key string
821 * @return string
822 */
825 }
827 /**
828 * @return array
829 */
834 }
836 }
838 /**
839 * @param $key string
840 * @return string
841 */
844 }
846 /**
847 * @param $key string
848 * @return string
849 */
852 }
854 /**
855 * @param $key string
856 * @return string
857 */
860 }
862 /**
863 * @param $key string
864 * @return string
865 */
868 }
870 /**
871 * @param $key string
872 * @return string
873 */
876 }
878 /**
879 * @param $key string
880 * @return string
881 */
884 }
886 /**
887 * This is a workalike of PHP's date() function, but with better
888 * internationalisation, a reduced set of format characters, and a better
889 * escaping format.
890 *
891 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
892 * PHP manual for definitions. There are a number of extensions, which
893 * start with "x":
894 *
895 * xn Do not translate digits of the next numeric format character
896 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
897 * xr Use roman numerals for the next numeric format character
898 * xh Use hebrew numerals for the next numeric format character
899 * xx Literal x
900 * xg Genitive month name
901 *
902 * xij j (day number) in Iranian calendar
903 * xiF F (month name) in Iranian calendar
904 * xin n (month number) in Iranian calendar
905 * xiy y (two digit year) in Iranian calendar
906 * xiY Y (full year) in Iranian calendar
907 *
908 * xjj j (day number) in Hebrew calendar
909 * xjF F (month name) in Hebrew calendar
910 * xjt t (days in month) in Hebrew calendar
911 * xjx xg (genitive month name) in Hebrew calendar
912 * xjn n (month number) in Hebrew calendar
913 * xjY Y (full year) in Hebrew calendar
914 *
915 * xmj j (day number) in Hijri calendar
916 * xmF F (month name) in Hijri calendar
917 * xmn n (month number) in Hijri calendar
918 * xmY Y (full year) in Hijri calendar
919 *
920 * xkY Y (full year) in Thai solar calendar. Months and days are
921 * identical to the Gregorian calendar
922 * xoY Y (full year) in Minguo calendar or Juche year.
923 * Months and days are identical to the
924 * Gregorian calendar
925 * xtY Y (full year) in Japanese nengo. Months and days are
926 * identical to the Gregorian calendar
927 *
928 * Characters enclosed in double quotes will be considered literal (with
929 * the quotes themselves removed). Unmatched quotes will be considered
930 * literal quotes. Example:
931 *
932 * "The month is" F => The month is January
933 * i's" => 20'11"
934 *
935 * Backslash escaping is also supported.
936 *
937 * Input timestamp is assumed to be pre-normalized to the desired local
938 * time zone, if any.
939 *
940 * @param $format String
941 * @param $ts String: 14-character timestamp
942 * YYYYMMDDHHMMSS
943 * 01234567890123
944 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
945 *
946 * @return string
947 */
966 }
968 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
970 }
1008 }
1014 }
1020 }
1026 }
1032 }
1039 }
1045 }
1051 }
1060 }
1066 }
1072 }
1087 }
1093 }
1099 }
1105 }
1111 }
1117 }
1123 }
1132 }
1138 }
1144 }
1150 }
1156 }
1162 }
1171 }
1203 }
1209 }
1215 }
1219 # Backslash escaping
1224 }
1227 # Quoted literal
1231 # No terminating quote, assume literal "
1236 }
1238 # Quote at end of string, assume literal "
1240 }
1244 }
1257 }
1258 }
1259 }
1261 }
1266 /**
1267 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1268 * Gregorian dates to Iranian dates. Originally written in C, it
1269 * is released under the terms of GNU Lesser General Public
1270 * License. Conversion to PHP was performed by Niklas Laxström.
1271 *
1272 * Link: http://www.farsiweb.info/jalali/jalali.c
1273 *
1274 * @param $ts string
1275 *
1276 * @return string
1277 */
1283 # Days passed from the beginning (including leap years)
1289 // Add days of the past months of this year
1292 }
1294 // Leap years
1297 }
1299 // Days passed in current month
1313 }
1317 }
1323 }
1325 /**
1326 * Converting Gregorian dates to Hijri dates.
1327 *
1328 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1329 *
1330 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1331 *
1332 * @param $ts string
1333 *
1334 * @return string
1335 */
1349 )
1350 {
1358 }
1363 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1364 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1370 }
1372 /**
1373 * Converting Gregorian dates to Hebrew dates.
1374 *
1375 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1376 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1377 * to translate the relevant functions into PHP and release them under
1378 * GNU GPL.
1379 *
1380 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1381 * and Adar II is 14. In a non-leap year, Adar is 6.
1382 *
1383 * @param $ts string
1384 *
1385 * @return string
1386 */
1388 # Parse date
1393 # Calculate Hebrew year
1396 # Month number when September = 1, August = 12
1399 # Next year
1403 }
1405 # Calculate day of year from 1 September
1409 # February
1411 # Check if the year is leap
1414 }
1419 }
1420 }
1422 # Calculate the start of the Hebrew year
1425 # Calculate next year's start
1427 # Day is before the start of the year - it is the previous year
1428 # Next year's start
1430 # Previous year
1433 # Add days since previous year's 1 September
1436 # Leap year
1438 }
1439 # Start of the new (previous) year
1442 # Next year's start
1444 }
1446 # Calculate Hebrew day of year
1449 # Difference between year's days
1451 # Add 12 (or 13 for leap years) days to ignore the difference between
1452 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1453 # difference is only about the year type
1458 }
1460 # Check the year pattern, and is leap year
1461 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1462 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1463 # and non-leap years
1465 # Check if leap year
1468 # Calculate day in the month from number of day in the Hebrew year
1469 # Don't check Adar - if the day is not in Adar, we will stop before;
1470 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1475 # Calculate days in this month
1477 # Adar in a leap year
1479 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1482 # Day in Adar I
1485 # Subtract the days of Adar I
1487 # Try Adar II
1490 # Day in Adar II
1492 }
1493 }
1494 }
1496 # Cheshvan in a complete year (otherwise as the rule below)
1499 # Kislev in an incomplete year (otherwise as the rule below)
1502 # Odd months have 30 days, even have 29
1504 }
1506 # In the current month
1509 # Subtract the days of the current month
1511 # Try in the next month
1513 }
1514 }
1517 }
1519 /**
1520 * This calculates the Hebrew year start, as days since 1 September.
1521 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1522 * Used for Hebrew date.
1523 *
1524 * @param $year int
1525 *
1526 * @return string
1527 */
1534 }
1538 }
1548 }
1552 }
1554 /**
1555 * Algorithm to convert Gregorian dates to Thai solar dates,
1556 * Minguo dates or Minguo dates.
1557 *
1558 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1559 * http://en.wikipedia.org/wiki/Minguo_calendar
1560 * http://en.wikipedia.org/wiki/Japanese_era_name
1561 *
1562 * @param $ts String: 14-character timestamp
1563 * @param $cName String: calender name
1564 * @return Array: converted year, month, day
1565 */
1572 # Thai solar dates
1573 # Add 543 years to the Gregorian calendar
1574 # Months and days are identical
1577 # Minguo dates
1578 # Deduct 1911 years from the Gregorian calendar
1579 # Months and days are identical
1582 # Nengō dates up to Meiji period
1583 # Deduct years from the Gregorian calendar
1584 # depending on the nengo periods
1585 # Months and days are identical
1586 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1587 # Meiji period
1592 }
1600 )
1601 {
1602 # Taishō period
1607 }
1613 )
1614 {
1615 # Shōwa period
1620 }
1623 # Heisei period
1628 }
1630 }
1633 }
1636 }
1638 /**
1639 * Roman number formatting up to 3000
1640 *
1641 * @param $num int
1642 *
1643 * @return string
1644 */
1651 );
1656 }
1662 }
1664 }
1666 }
1668 /**
1669 * Hebrew Gematria number formatting up to 9999
1670 *
1671 * @param $num int
1672 *
1673 * @return string
1674 */
1681 );
1686 }
1698 }
1699 }
1700 }
1702 }
1708 }
1727 }
1729 }
1731 /**
1732 * Used by date() and time() to adjust the time output.
1733 *
1734 * @param $ts Int the time in date('YmdHis') format
1735 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1736 * get user timecorrection setting)
1737 * @return int
1738 */
1744 }
1757 }
1758 # Unrecognized timezone, default to 'Offset' with the stored offset.
1760 }
1764 # Global offset in minutes.
1767 }
1778 }
1781 }
1782 }
1784 # No difference ? Return time unchanged
1787 }
1790 # Generate an adjusted date; take advantage of the fact that mktime
1791 # will normalize out-of-range values so we don't have to split $minDiff
1792 # into hours and minutes.
1805 }
1807 /**
1808 * This is meant to be used by time(), date(), and timeanddate() to get
1809 * the date preference they're supposed to use, it should be used in
1810 * all children.
1811 *
1812 *<code>
1813 * function timeanddate([...], $format = true) {
1814 * $datePreference = $this->dateFormat($format);
1815 * [...]
1816 * }
1817 *</code>
1818 *
1819 * @param $usePrefs Mixed: if true, the user's preference is used
1820 * if false, the site/language default is used
1821 * if int/string, assumed to be a format.
1822 * @return string
1823 */
1832 }
1835 }
1837 // return int
1840 }
1843 }
1845 /**
1846 * Get a format string for a given type and preference
1847 * @param $type string May be date, time or both
1848 * @param $pref string The format name as it appears in Messages*.php
1849 *
1850 * @return string
1851 */
1862 }
1863 }
1865 }
1867 }
1869 /**
1870 * @param $ts Mixed: the time format which needs to be turned into a
1871 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1872 * @param $adj Bool: whether to adjust the time output according to the
1873 * user configured offset ($timecorrection)
1874 * @param $format Mixed: true to use user's date format preference
1875 * @param $timecorrection String|bool the time offset as returned by
1876 * validateTimeZone() in Special:Preferences
1877 * @return string
1878 */
1883 }
1886 }
1888 /**
1889 * @param $ts Mixed: the time format which needs to be turned into a
1890 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1891 * @param $adj Bool: whether to adjust the time output according to the
1892 * user configured offset ($timecorrection)
1893 * @param $format Mixed: true to use user's date format preference
1894 * @param $timecorrection String|bool the time offset as returned by
1895 * validateTimeZone() in Special:Preferences
1896 * @return string
1897 */
1902 }
1905 }
1907 /**
1908 * @param $ts Mixed: the time format which needs to be turned into a
1909 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1910 * @param $adj Bool: whether to adjust the time output according to the
1911 * user configured offset ($timecorrection)
1912 * @param $format Mixed: what format to return, if it's false output the
1913 * default one (default true)
1914 * @param $timecorrection String|bool the time offset as returned by
1915 * validateTimeZone() in Special:Preferences
1916 * @return string
1917 */
1922 }
1925 }
1927 /**
1928 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
1929 *
1930 * @since 1.20
1931 *
1932 * @param integer $seconds The amount of seconds.
1933 * @param array $chosenIntervals The intervals to enable.
1934 *
1935 * @return string
1936 */
1945 }
1948 }
1950 /**
1951 * Takes a number of seconds and returns an array with a set of corresponding intervals.
1952 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
1953 *
1954 * @since 1.20
1955 *
1956 * @param integer $seconds The amount of seconds.
1957 * @param array $chosenIntervals The intervals to enable.
1958 *
1959 * @return array
1960 */
1963 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
1964 }
1978 }
1979 }
1982 }
1984 /**
1985 * Internal helper function for userDate(), userTime() and userTimeAndDate()
1986 *
1987 * @param $type String: can be 'date', 'time' or 'both'
1988 * @param $ts Mixed: the time format which needs to be turned into a
1989 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1990 * @param $user User object used to get preferences for timezone and format
1991 * @param $options Array, can contain the following keys:
1992 * - 'timecorrection': time correction, can have the following values:
1993 * - true: use user's preference
1994 * - false: don't use time correction
1995 * - integer: value of time correction in minutes
1996 * - 'format': format to use, can have the following values:
1997 * - true: use user's preference
1998 * - false: use default preference
1999 * - string: format to use
2000 * @since 1.19
2001 * @return String
2002 */
2011 }
2013 }
2018 }
2021 }
2023 /**
2024 * Get the formatted date for the given timestamp and formatted for
2025 * the given user.
2026 *
2027 * @param $ts Mixed: the time format which needs to be turned into a
2028 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2029 * @param $user User object used to get preferences for timezone and format
2030 * @param $options Array, can contain the following keys:
2031 * - 'timecorrection': time correction, can have the following values:
2032 * - true: use user's preference
2033 * - false: don't use time correction
2034 * - integer: value of time correction in minutes
2035 * - 'format': format to use, can have the following values:
2036 * - true: use user's preference
2037 * - false: use default preference
2038 * - string: format to use
2039 * @since 1.19
2040 * @return String
2041 */
2044 }
2046 /**
2047 * Get the formatted time for the given timestamp and formatted for
2048 * the given user.
2049 *
2050 * @param $ts Mixed: the time format which needs to be turned into a
2051 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2052 * @param $user User object used to get preferences for timezone and format
2053 * @param $options Array, can contain the following keys:
2054 * - 'timecorrection': time correction, can have the following values:
2055 * - true: use user's preference
2056 * - false: don't use time correction
2057 * - integer: value of time correction in minutes
2058 * - 'format': format to use, can have the following values:
2059 * - true: use user's preference
2060 * - false: use default preference
2061 * - string: format to use
2062 * @since 1.19
2063 * @return String
2064 */
2067 }
2069 /**
2070 * Get the formatted date and time for the given timestamp and formatted for
2071 * the given user.
2072 *
2073 * @param $ts Mixed: the time format which needs to be turned into a
2074 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2075 * @param $user User object used to get preferences for timezone and format
2076 * @param $options Array, can contain the following keys:
2077 * - 'timecorrection': time correction, can have the following values:
2078 * - true: use user's preference
2079 * - false: don't use time correction
2080 * - integer: value of time correction in minutes
2081 * - 'format': format to use, can have the following values:
2082 * - true: use user's preference
2083 * - false: use default preference
2084 * - string: format to use
2085 * @since 1.19
2086 * @return String
2087 */
2090 }
2092 /**
2093 * @param $key string
2094 * @return array|null
2095 */
2098 }
2100 /**
2101 * @return array
2102 */
2105 }
2107 /**
2108 * @param $in
2109 * @param $out
2110 * @param $string
2111 * @return string
2112 */
2114 # This is a wrapper for iconv in all languages except esperanto,
2115 # which does some nasty x-conversions beforehand
2117 # Even with //IGNORE iconv can whine about illegal characters in
2118 # *input* string. We just ignore those too.
2119 # REF: http://bugs.php.net/bug.php?id=37166
2120 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2125 }
2127 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2129 /**
2130 * @param $matches array
2131 * @return mixed|string
2132 */
2135 }
2137 /**
2138 * @param $matches array
2139 * @return string
2140 */
2143 }
2145 /**
2146 * @param $matches array
2147 * @return string
2148 */
2152 }
2154 /**
2155 * @param $matches array
2156 * @return string
2157 */
2161 }
2163 /**
2164 * @param $matches array
2165 * @return string
2166 */
2169 }
2171 /**
2172 * @param $matches array
2173 * @return string
2174 */
2178 }
2180 /**
2181 * Make a string's first character uppercase
2182 *
2183 * @param $str string
2184 *
2185 * @return string
2186 */
2194 // fall back to more complex logic in case of multibyte strings
2196 }
2197 }
2199 /**
2200 * Convert a string to uppercase
2201 *
2202 * @param $str string
2203 * @param $first bool
2204 *
2205 * @return string
2206 */
2214 }
2217 }
2224 $str
2225 );
2228 }
2229 }
2230 }
2232 /**
2233 * @param $str string
2234 * @return mixed|string
2235 */
2247 }
2248 }
2250 /**
2251 * @param $str string
2252 * @param $first bool
2253 * @return mixed|string
2254 */
2262 }
2265 }
2272 $str
2273 );
2276 }
2277 }
2278 }
2280 /**
2281 * @param $str string
2282 * @return bool
2283 */
2286 }
2288 /**
2289 * @param $str string
2290 * @return mixed|string
2291 */
2296 // regexp to find first letter in each word (i.e. after each space)
2297 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2299 // function to use to capitalize a single char
2304 $str
2305 );
2310 $str
2311 );
2312 }
2315 }
2316 }
2318 /**
2319 * capitalize words at word breaks
2320 *
2321 * @param $str string
2322 * @return mixed
2323 */
2328 // since \b doesn't work for UTF-8, we explicitely define word break chars
2331 // find first letter after word break
2332 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2338 $str
2339 );
2344 $str
2345 );
2346 }
2351 $str
2352 );
2353 }
2354 }
2356 /**
2357 * Return a case-folded representation of $s
2358 *
2359 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2360 * and $s2 are the same except for the case of their characters. It is not
2361 * necessary for the value returned to make sense when displayed.
2362 *
2363 * Do *not* perform any other normalisation in this function. If a caller
2364 * uses this function when it should be using a more general normalisation
2365 * function, then fix the caller.
2366 *
2367 * @param $s string
2368 *
2369 * @return string
2370 */
2373 }
2375 /**
2376 * @param $s string
2377 * @return string
2378 */
2382 }
2383 # Check for non-UTF-8 URLs
2387 }
2393 }
2396 }
2398 /**
2399 * @return array
2400 */
2403 }
2405 /**
2406 * Most writing systems use whitespace to break up words.
2407 * Some languages such as Chinese don't conventionally do this,
2408 * which requires special handling when breaking up words for
2409 * searching etc.
2410 *
2411 * @return bool
2412 */
2415 }
2417 /**
2418 * Some languages such as Chinese require word segmentation,
2419 * Specify such segmentation when overridden in derived class.
2420 *
2421 * @param $string String
2422 * @return String
2423 */
2426 }
2428 /**
2429 * Some languages have special punctuation need to be normalized.
2430 * Make such changes here.
2431 *
2432 * @param $string String
2433 * @return String
2434 */
2437 }
2439 /**
2440 * convert double-width roman characters to single-width.
2441 * range: ff00-ff5f ~= 0020-007f
2442 *
2443 * @param $string string
2444 *
2445 * @return string
2446 */
2456 }
2460 }
2462 /**
2463 * @param $string string
2464 * @param $pattern string
2465 * @return string
2466 */
2471 }
2473 /**
2474 * @param $termsArray array
2475 * @return array
2476 */
2478 # some languages, e.g. Chinese, need to do a conversion
2479 # in order for search results to be displayed correctly
2481 }
2483 /**
2484 * Get the first character of a string.
2485 *
2486 * @param $s string
2487 * @return string
2488 */
2495 $matches
2496 );
2501 }
2503 // Break down Hangul syllables to grab the first jamo
2535 }
2538 }
2539 }
2542 # Some languages may have an alternate char encoding option
2543 # (Esperanto X-coding, Japanese furigana conversion, etc)
2544 # If this language is used as the primary content language,
2545 # an override to the defaults can be set here on startup.
2546 }
2548 /**
2549 * @param $s string
2550 * @return string
2551 */
2553 # For some languages we'll want to explicitly specify
2554 # which characters make it into the edit box raw
2555 # or are converted in some way or another.
2561 }
2562 }
2564 /**
2565 * @param $s string
2566 * @return string
2567 */
2569 # Take the previous into account.
2575 }
2580 }
2581 }
2583 /**
2584 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2585 * also cleans up certain backwards-compatible sequences, converting them
2586 * to the modern Unicode equivalent.
2587 *
2588 * This is language-specific for performance reasons only.
2589 *
2590 * @param $s string
2591 *
2592 * @return string
2593 */
2600 }
2603 }
2605 /**
2606 * Transform a string using serialized data stored in the given file (which
2607 * must be in the serialized subdirectory of $IP). The file contains pairs
2608 * mapping source characters to destination characters.
2609 *
2610 * The data is cached in process memory. This will go faster if you have the
2611 * FastStringSearch extension.
2612 *
2613 * @param $file string
2614 * @param $string string
2615 *
2616 * @throws MWException
2617 * @return string
2618 */
2624 }
2626 }
2628 }
2630 /**
2631 * For right-to-left language support
2632 *
2633 * @return bool
2634 */
2637 }
2639 /**
2640 * Return the correct HTML 'dir' attribute value for this language.
2641 * @return String
2642 */
2645 }
2647 /**
2648 * Return 'left' or 'right' as appropriate alignment for line-start
2649 * for this language's text direction.
2650 *
2651 * Should be equivalent to CSS3 'start' text-align value....
2652 *
2653 * @return String
2654 */
2657 }
2659 /**
2660 * Return 'right' or 'left' as appropriate alignment for line-end
2661 * for this language's text direction.
2662 *
2663 * Should be equivalent to CSS3 'end' text-align value....
2664 *
2665 * @return String
2666 */
2669 }
2671 /**
2672 * A hidden direction mark (LRM or RLM), depending on the language direction.
2673 * Unlike getDirMark(), this function returns the character as an HTML entity.
2674 * This function should be used when the output is guaranteed to be HTML,
2675 * because it makes the output HTML source code more readable. When
2676 * the output is plain text or can be escaped, getDirMark() should be used.
2677 *
2678 * @param $opposite Boolean Get the direction mark opposite to your language
2679 * @return string
2680 */
2684 }
2686 /**
2687 * A hidden direction mark (LRM or RLM), depending on the language direction.
2688 * This function produces them as invisible Unicode characters and
2689 * the output may be hard to read and debug, so it should only be used
2690 * when the output is plain text or can be escaped. When the output is
2691 * HTML, use getDirMarkEntity() instead.
2692 *
2693 * @param $opposite Boolean Get the direction mark opposite to your language
2694 * @return string
2695 */
2701 }
2703 /**
2704 * @return array
2705 */
2708 }
2710 /**
2711 * An arrow, depending on the language direction
2712 *
2713 * @return string
2714 */
2717 }
2719 /**
2720 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2721 *
2722 * @return bool
2723 */
2726 }
2728 /**
2729 * @return array
2730 */
2733 }
2738 }
2743 }
2745 /**
2746 * Fill a MagicWord object with data from here
2747 *
2748 * @param $mw
2749 */
2761 }
2762 }
2769 }
2770 }
2772 /**
2773 * Add magic words to the extension array
2774 *
2775 * @param $newWords array
2776 */
2783 }
2784 }
2785 }
2787 /**
2788 * Get special page names, as an associative array
2789 * case folded alias => real name
2790 */
2792 // Cache aliases because it may be slow to load them
2794 // Initialise array
2799 }
2802 }
2804 /**
2805 * Italic is unsuitable for some languages
2806 *
2807 * @param $text String: the text to be emphasized.
2808 * @return string
2809 */
2812 }
2814 /**
2815 * Normally we output all numbers in plain en_US style, that is
2816 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2817 * point twohundredthirtyfive. However this is not suitable for all
2818 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2819 * Icelandic just want to use commas instead of dots, and dots instead
2820 * of commas like "293.291,235".
2821 *
2822 * An example of this function being called:
2823 * <code>
2824 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2825 * </code>
2826 *
2827 * See LanguageGu.php for the Gujarati implementation and
2828 * $separatorTransformTable on MessageIs.php for
2829 * the , => . and . => , implementation.
2830 *
2831 * @todo check if it's viable to use localeconv() for the decimal
2832 * separator thing.
2833 * @param $number Mixed: the string to be formatted, should be an integer
2834 * or a floating point number.
2835 * @param $nocommafy Bool: set to true for special numbers like dates
2836 * @return string
2837 */
2845 }
2846 }
2852 }
2853 }
2856 }
2858 /**
2859 * @param $number string
2860 * @return string
2861 */
2866 }
2871 }
2875 }
2877 /**
2878 * Adds commas to a given number
2879 * @since 1.19
2880 * @param $_ mixed
2881 * @return string
2882 */
2887 }
2890 // default grouping is at thousands, use the same for ###,###,### pattern too.
2893 // Ref: http://cldr.unicode.org/translation/number-patterns
2896 // For negative numbers apply the algorithm like positive number and add sign.
2899 }
2907 // the string does not have any number part. Eg: .12345
2909 }
2917 }
2921 // use the last pattern for the rest of the number
2923 }
2926 }
2927 }
2929 }
2930 }
2931 /**
2932 * @return String
2933 */
2936 }
2938 /**
2939 * @return array
2940 */
2943 }
2945 /**
2946 * @return array
2947 */
2950 }
2952 /**
2953 * Take a list of strings and build a locale-friendly comma-separated
2954 * list, using the local comma-separator message.
2955 * The last two strings are chained with an "and".
2956 *
2957 * @param $l Array
2958 * @return string
2959 */
2964 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2970 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2973 }
2974 }
2976 }
2977 }
2979 /**
2980 * Take a list of strings and build a locale-friendly comma-separated
2981 * list, using the local comma-separator message.
2982 * @param $list array of strings to put in a comma list
2983 * @return string
2984 */
2990 ),
2991 $list
2992 );
2993 }
2995 /**
2996 * Take a list of strings and build a locale-friendly semicolon-separated
2997 * list, using the local semicolon-separator message.
2998 * @param $list array of strings to put in a semicolon list
2999 * @return string
3000 */
3006 ),
3007 $list
3008 );
3009 }
3011 /**
3012 * Same as commaList, but separate it with the pipe instead.
3013 * @param $list array of strings to put in a pipe list
3014 * @return string
3015 */
3021 ),
3022 $list
3023 );
3024 }
3026 /**
3027 * Truncate a string to a specified length in bytes, appending an optional
3028 * string (e.g. for ellipses)
3029 *
3030 * The database offers limited byte lengths for some columns in the database;
3031 * multi-byte character sets mean we need to ensure that only whole characters
3032 * are included, otherwise broken characters can be passed to the user
3033 *
3034 * If $length is negative, the string will be truncated from the beginning
3035 *
3036 * @param $string String to truncate
3037 * @param $length Int: maximum length (including ellipses)
3038 * @param $ellipsis String to append to the truncated text
3039 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3040 * $adjustLength was introduced in 1.18, before that behaved as if false.
3041 * @return string
3042 */
3044 # Use the localized ellipsis character
3047 }
3048 # Check if there is no need to truncate
3053 }
3055 # If ellipsis length is >= $length then we can't apply $adjustLength
3058 # Otherwise, truncate and add ellipsis...
3071 }
3072 }
3073 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3074 # This check is *not* redundant if $adjustLength, due to the single case where
3075 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3080 }
3081 }
3083 /**
3084 * Remove bytes that represent an incomplete Unicode character
3085 * at the end of string (e.g. bytes of the char are missing)
3086 *
3087 * @param $string String
3088 * @return string
3089 */
3095 # We got the first byte only of a multibyte char; remove it.
3100 {
3101 # We chopped in the middle of a character; remove it
3103 }
3104 }
3106 }
3108 /**
3109 * Remove bytes that represent an incomplete Unicode character
3110 * at the start of string (e.g. bytes of the char are missing)
3111 *
3112 * @param $string String
3113 * @return string
3114 */
3119 # We chopped in the middle of a character; remove the whole thing
3121 }
3122 }
3124 }
3126 /**
3127 * Truncate a string of valid HTML to a specified length in bytes,
3128 * appending an optional string (e.g. for ellipses), and return valid HTML
3129 *
3130 * This is only intended for styled/linked text, such as HTML with
3131 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3132 * Also, this will not detect things like "display:none" CSS.
3133 *
3134 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3135 *
3136 * @param string $text HTML string to truncate
3137 * @param int $length (zero/positive) Maximum length (including ellipses)
3138 * @param string $ellipsis String to append to the truncated text
3139 * @return string
3140 */
3142 # Use the localized ellipsis character
3145 }
3146 # Check if there is clearly no need to truncate
3151 }
3165 # Consider truncation once the display length has reached the maximim.
3166 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3167 # Check that we're not in the middle of a bracket/entity...
3171 # Save where we are; we will truncate here unless there turn out to
3172 # be so few remaining characters that truncation is not necessary.
3175 }
3177 # String in fact does need truncation, the truncation point was OK.
3182 }
3183 }
3186 # Read the next char...
3204 }
3210 // Name found (e.g. "<a href=..."), add on tag attributes...
3212 }
3218 }
3221 // Save state without $ch. We want to *hit* the first
3222 // display char (to get tags) but not *use* it if truncating.
3224 }
3229 // Add the next $max display text chars after this in one swoop...
3234 }
3235 }
3236 }
3237 }
3238 // Close the last tag if left unclosed by bad HTML
3242 }
3244 }
3246 /**
3247 * truncateHtml() helper function
3248 * like strcspn() but adds the skipped chars to $ret
3249 *
3250 * @param $ret
3251 * @param $text
3252 * @param $search
3253 * @param $start
3254 * @param $len
3255 * @return int
3256 */
3262 }
3267 }
3269 }
3271 /**
3272 * truncateHtml() helper function
3273 * (a) push or pop $tag from $openTags as needed
3274 * (b) clear $tag value
3275 * @param &$tag string Current HTML tag name we are looking at
3276 * @param $tagType int (0-open tag, 1-close tag)
3277 * @param $lastCh string Character before the '>' that ended this tag
3278 * @param &$openTags array Open tag stack (not accounting for $tag)
3279 */
3288 }
3289 }
3291 }
3292 }
3294 /**
3295 * Grammatical transformations, needed for inflected languages
3296 * Invoked by putting {{grammar:case|word}} in a message
3297 *
3298 * @param $word string
3299 * @param $case string
3300 * @return string
3301 */
3306 }
3308 }
3309 /**
3310 * Get the grammar forms for the content language
3311 * @return array of grammar forms
3312 * @since 1.20
3313 */
3316 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3318 }
3320 }
3321 /**
3322 * Provides an alternative text depending on specified gender.
3323 * Usage {{gender:username|masculine|feminine|neutral}}.
3324 * username is optional, in which case the gender of current user is used,
3325 * but only in (some) interface messages; otherwise default gender is used.
3326 *
3327 * If no forms are given, an empty string is returned. If only one form is
3328 * given, it will be returned unconditionally. These details are implied by
3329 * the caller and cannot be overridden in subclasses.
3330 *
3331 * If more than one form is given, the default is to use the neutral one
3332 * if it is specified, and to use the masculine one otherwise. These
3333 * details can be overridden in subclasses.
3334 *
3335 * @param $gender string
3336 * @param $forms array
3337 *
3338 * @return string
3339 */
3343 }
3347 }
3350 }
3352 }
3354 /**
3355 * Plural form transformations, needed for some languages.
3356 * For example, there are 3 form of plural in Russian and Polish,
3357 * depending on "count mod 10". See [[w:Plural]]
3358 * For English it is pretty simple.
3359 *
3360 * Invoked by putting {{plural:count|wordform1|wordform2}}
3361 * or {{plural:count|wordform1|wordform2|wordform3}}
3362 *
3363 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3364 *
3365 * @param $count Integer: non-localized number
3366 * @param $forms Array: different plural forms
3367 * @return string Correct form of plural for $count in this language
3368 */
3372 }
3376 }
3378 /**
3379 * Checks that convertPlural was given an array and pads it to requested
3380 * amount of forms by copying the last one.
3381 *
3382 * @param $count Integer: How many forms should there be at least
3383 * @param $forms Array of forms given to convertPlural
3384 * @return array Padded array of forms or an exception if not an array
3385 */
3389 }
3391 }
3393 /**
3394 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3395 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3396 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3397 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3398 * match up with it.
3399 *
3400 * @param $str String: the validated block duration in English
3401 * @return string Somehow translated block duration
3402 * @see LanguageFi.php for example implementation
3403 */
3409 }
3410 }
3412 // Since usually only infinite or indefinite is only on list, so try
3413 // equivalents if still here.
3420 }
3421 }
3422 }
3423 // If all else fails, return the original string.
3425 }
3427 /**
3428 * languages like Chinese need to be segmented in order for the diff
3429 * to be of any use
3430 *
3431 * @param $text String
3432 * @return String
3433 */
3436 }
3438 /**
3439 * and unsegment to show the result
3440 *
3441 * @param $text String
3442 * @return String
3443 */
3446 }
3448 /**
3449 * Return the LanguageConverter used in the Language
3450 *
3451 * @since 1.19
3452 * @return LanguageConverter
3453 */
3456 }
3458 /**
3459 * convert text to all supported variants
3460 *
3461 * @param $text string
3462 * @return array
3463 */
3466 }
3468 /**
3469 * convert text to different variants of a language.
3470 *
3471 * @param $text string
3472 * @return string
3473 */
3476 }
3478 /**
3479 * Convert a Title object to a string in the preferred variant
3480 *
3481 * @param $title Title
3482 * @return string
3483 */
3486 }
3488 /**
3489 * Check if this is a language with variants
3490 *
3491 * @return bool
3492 */
3495 }
3497 /**
3498 * Check if the language has the specific variant
3499 *
3500 * @since 1.19
3501 * @param $variant string
3502 * @return bool
3503 */
3506 }
3508 /**
3509 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3510 *
3511 * @param $text string
3512 * @return string
3513 */
3516 }
3518 /**
3519 * Perform output conversion on a string, and encode for safe HTML output.
3520 * @param $text String text to be converted
3521 * @param $isTitle Bool whether this conversion is for the article title
3522 * @return string
3523 * @todo this should get integrated somewhere sane
3524 */
3527 }
3529 /**
3530 * @param $key string
3531 * @return string
3532 */
3535 }
3537 /**
3538 * Get the list of variants supported by this language
3539 * see sample implementation in LanguageZh.php
3540 *
3541 * @return array an array of language codes
3542 */
3545 }
3547 /**
3548 * @return string
3549 */
3552 }
3554 /**
3555 * @return string
3556 */
3559 }
3561 /**
3562 * @return string
3563 */
3566 }
3568 /**
3569 * If a language supports multiple variants, it is
3570 * possible that non-existing link in one variant
3571 * actually exists in another variant. this function
3572 * tries to find it. See e.g. LanguageZh.php
3573 *
3574 * @param $link String: the name of the link
3575 * @param $nt Mixed: the title object of the link
3576 * @param $ignoreOtherCond Boolean: to disable other conditions when
3577 * we need to transclude a template or update a category's link
3578 * @return null the input parameters may be modified upon return
3579 */
3582 }
3584 /**
3585 * If a language supports multiple variants, converts text
3586 * into an array of all possible variants of the text:
3587 * 'variant' => text in that variant
3588 *
3589 * @deprecated since 1.17 Use autoConvertToAllVariants()
3590 *
3591 * @param $text string
3592 *
3593 * @return string
3594 */
3597 }
3599 /**
3600 * returns language specific options used by User::getPageRenderHash()
3601 * for example, the preferred language variant
3602 *
3603 * @return string
3604 */
3607 }
3609 /**
3610 * For languages that support multiple variants, the title of an
3611 * article may be displayed differently in different variants. this
3612 * function returns the apporiate title defined in the body of the article.
3613 *
3614 * @return string
3615 */
3618 }
3620 /**
3621 * Enclose a string with the "no conversion" tag. This is used by
3622 * various functions in the Parser
3623 *
3624 * @param $text String: text to be tagged for no conversion
3625 * @param $noParse bool
3626 * @return string the tagged text
3627 */
3630 }
3632 /**
3633 * A regular expression to match legal word-trailing characters
3634 * which should be merged onto a link of the form [[foo]]bar.
3635 *
3636 * @return string
3637 */
3640 }
3642 /**
3643 * @return Language
3644 */
3647 }
3649 /**
3650 * Get the RFC 3066 code for this language object
3651 *
3652 * @return string
3653 */
3656 }
3658 /**
3659 * Get the code in Bcp47 format which we can use
3660 * inside of html lang="" tags.
3661 * @since 1.19
3662 * @return string
3663 */
3667 }
3669 }
3671 /**
3672 * @param $code string
3673 */
3676 // Ensure we don't leave an incorrect html code lying around
3678 }
3680 /**
3681 * Get the name of a file for a certain language code
3682 * @param $prefix string Prepend this to the filename
3683 * @param $code string Language code
3684 * @param $suffix string Append this to the filename
3685 * @throws MWException
3686 * @return string $prefix . $mangledCode . $suffix
3687 */
3689 // Protect against path traversal
3692 {
3694 }
3697 }
3699 /**
3700 * Get the language code from a file name. Inverse of getFileName()
3701 * @param $filename string $prefix . $languageCode . $suffix
3702 * @param $prefix string Prefix before the language code
3703 * @param $suffix string Suffix after the language code
3704 * @return string Language code, or false if $prefix or $suffix isn't found
3705 */
3706 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3712 }
3714 }
3716 /**
3717 * @param $code string
3718 * @return string
3719 */
3725 }
3727 /**
3728 * @param $code string
3729 * @return string
3730 */
3734 }
3736 /**
3737 * Get the first fallback for a given language.
3738 *
3739 * @param $code string
3740 *
3741 * @return bool|string
3742 */
3750 }
3751 }
3753 /**
3754 * Get the ordered list of fallback languages.
3755 *
3756 * @since 1.19
3757 * @param $code string Language code
3758 * @return array
3759 */
3768 }
3770 }
3771 }
3773 /**
3774 * Get all messages for a given language
3775 * WARNING: this may take a long time. If you just need all message *keys*
3776 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3777 *
3778 * @param $code string
3779 *
3780 * @return array
3781 */
3784 }
3786 /**
3787 * Get a message for a given language
3788 *
3789 * @param $key string
3790 * @param $code string
3791 *
3792 * @return string
3793 */
3796 }
3798 /**
3799 * Get all message keys for a given language. This is a faster alternative to
3800 * array_keys( Language::getMessagesFor( $code ) )
3801 *
3802 * @since 1.19
3803 * @param $code string Language code
3804 * @return array of message keys (strings)
3805 */
3808 }
3810 /**
3811 * @param $talk
3812 * @return mixed
3813 */
3817 }
3822 # Allow grammar transformations
3823 # Allowing full message-style parsing would make simple requests
3824 # such as action=raw much more expensive than they need to be.
3825 # This will hopefully cover most cases.
3829 }
3831 /**
3832 * @param $m string
3833 * @return string
3834 */
3837 }
3839 /**
3840 * @throws MWException
3841 * @return array
3842 */
3847 }
3854 }
3859 }
3861 /**
3862 * Decode an expiry (block, protection, etc) which has come from the DB
3863 *
3864 * @FIXME: why are we returnings DBMS-dependent strings???
3865 *
3866 * @param $expiry String: Database expiry String
3867 * @param $format Bool|Int true to process using language functions, or TS_ constant
3868 * to return the expiry in a given timestamp
3869 * @return String
3870 */
3876 }
3880 ? $infinityMsg
3886 }
3887 }
3889 /**
3890 * @todo Document
3891 * @param $seconds int|float
3892 * @param $format Array Optional
3893 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
3894 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
3895 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
3896 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
3897 * @return string
3898 */
3902 }
3905 }
3908 }
3930 }
3941 }
3945 }
3951 }
3959 }
3969 }
3973 }
3983 }
3984 }
3986 }
3988 /**
3989 * Format a bitrate for output, using an appropriate
3990 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
3991 *
3992 * This use base 1000. For base 1024 use formatSize(), for another base
3993 * see formatComputingNumbers()
3994 *
3995 * @param $bps int
3996 * @return string
3997 */
4000 }
4002 /**
4003 * @param $size int Size of the unit
4004 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4005 * @param $messageKey string Message key to be uesd
4006 * @return string
4007 */
4012 );
4013 }
4021 }
4023 // For small sizes no decimal places necessary
4026 // For MB and bigger two decimal places are smarter
4028 }
4034 }
4036 /**
4037 * Format a size in bytes for output, using an appropriate
4038 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4039 *
4040 * This method use base 1024. For base 1000 use formatBitrate(), for
4041 * another base see formatComputingNumbers()
4042 *
4043 * @param $size int Size to format
4044 * @return string Plain text (not HTML)
4045 */
4048 }
4050 /**
4051 * Make a list item, used by various special pages
4052 *
4053 * @param $page String Page link
4054 * @param $details String Text between brackets
4055 * @param $oppositedm Boolean Add the direction mark opposite to your
4056 * language, to display text properly
4057 * @return String
4058 */
4063 wfMsgExt( 'parentheses', array( 'escape', 'replaceafter', 'language' => $this ), $details ) : '';
4065 }
4067 /**
4068 * Generate (prev x| next x) (20|50|100...) type links for paging
4069 *
4070 * @param $title Title object to link
4071 * @param $offset Integer offset parameter
4072 * @param $limit Integer limit parameter
4073 * @param $query String optional URL query parameter string
4074 * @param $atend Bool optional param for specified if this is the last page
4075 * @return String
4076 */
4077 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4078 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4080 # Make 'previous' link
4081 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4087 }
4089 # Make 'next' link
4090 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4096 }
4098 # Make links to set number of items per page
4103 }
4107 }
4109 /**
4110 * Helper function for viewPrevNext() that generates links
4111 *
4112 * @param $title Title object to link
4113 * @param $offset Integer offset parameter
4114 * @param $limit Integer limit parameter
4115 * @param $query Array extra query parameters
4116 * @param $link String text to use for the link; will be escaped
4117 * @param $tooltipMsg String name of the message to use as tooltip
4118 * @param $class String value of the "class" attribute of the link
4119 * @return String HTML fragment
4120 */
4121 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4123 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4126 }
4128 /**
4129 * Get the conversion rule title, if any.
4130 *
4131 * @return string
4132 */
4135 }
4136 }