| blob | 437d3c47ca9ace58cfb48a121b99668ac280f3dd |
1 <?php
2 /**
3 * Internationalisation code.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
19 *
20 * @file
21 * @ingroup Language
22 */
24 /**
25 * @defgroup Language Language
26 */
31 }
33 # Read language names
39 }
41 /**
42 * a fake language converter
43 *
44 * @ingroup Language
45 */
48 /**
49 * @var Language
50 */
70 }
72 /**
73 * Internationalisation code
74 * @ingroup Language
75 */
78 /**
79 * @var LanguageConverter
80 */
92 /**
93 * ReplacementArray object caches
94 */
97 /**
98 * @var LocalisationCache
99 */
107 );
111 );
116 'december'
117 );
121 'december-gen'
122 );
126 );
133 );
141 );
149 );
156 );
158 /**
159 * @since 1.20
160 * @var array
161 */
172 );
174 /**
175 * Get a cached language object for a given language code
176 * @param $code String
177 * @return Language
178 */
182 // Don't keep a billion objects around, that's stupid.
184 }
186 }
188 }
190 /**
191 * Create a language object for a given language code
192 * @param $code String
193 * @throws MWException
194 * @return Language
195 */
197 // Protect against path traversal below
200 {
202 }
205 // It's not possible to customise this code with class files, so
206 // just return a Language object. This is to support uselang= hacks.
210 }
212 // Check if there is a language class for the code
218 }
220 // Keep trying the fallback list until we find an existing class
225 }
233 }
234 }
237 }
239 /**
240 * Returns true if a language code string is of a valid form, whether or
241 * not it exists. This includes codes which are used solely for
242 * customisation via the MediaWiki namespace.
243 *
244 * @param $code string
245 *
246 * @return bool
247 */
249 return
250 // People think language codes are html safe, so enforce it.
251 // Ideally we should only allow a-zA-Z0-9-
252 // but, .+ and other chars are often used for {{int:}} hacks
253 // see bugs 37564, 37587, 36938
256 }
258 /**
259 * Returns true if a language code is of a valid form for the purposes of
260 * internal customisation of MediaWiki, via Messages*.php.
261 *
262 * @param $code string
263 *
264 * @throws MWException
265 * @since 1.18
266 * @return bool
267 */
276 }
278 }
281 }
283 /**
284 * @param $code
285 * @return String Name of the language class
286 */
292 }
293 }
295 /**
296 * Includes language class files
297 *
298 * @param $class string Name of the language class
299 */
305 }
310 }
311 }
312 }
314 /**
315 * Get the LocalisationCache instance
316 *
317 * @return LocalisationCache
318 */
324 }
326 }
330 // Set the code to the name of the descendant
335 }
337 }
339 /**
340 * Reduce memory usage
341 */
345 }
346 }
348 /**
349 * Hook which will be called if this is the content language.
350 * Descendants can use this to register hook functions or modify globals
351 */
354 /**
355 * Same as getFallbacksFor for current language.
356 * @return array|bool
357 * @deprecated in 1.19
358 */
362 }
364 /**
365 * @return array
366 * @since 1.19
367 */
370 }
372 /**
373 * Exports $wgBookstoreListEn
374 * @return array
375 */
378 }
380 /**
381 * @return array
382 */
399 }
401 # Sometimes a language will be localised but not actually exist on this wiki.
405 }
406 }
408 # The above mixing may leave namespaces out of canonical order.
409 # Re-order by namespace ID number...
413 }
415 }
417 /**
418 * Arbitrarily set all of the namespace names at once. Mainly used for testing
419 * @param $namespaces Array of namespaces (id => name)
420 */
424 }
426 /**
427 * Resets all of the namespace caches. Mainly used for testing
428 */
433 }
435 /**
436 * A convenience function that returns the same thing as
437 * getNamespaces() except with the array values changed to ' '
438 * where it found '_', useful for producing output to be displayed
439 * e.g. in <select> forms.
440 *
441 * @return array
442 */
447 }
449 }
451 /**
452 * Get a namespace value by key
453 * <code>
454 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
455 * echo $mw_ns; // prints 'MediaWiki'
456 * </code>
457 *
458 * @param $index Int: the array key of the namespace to return
459 * @return mixed, string if the namespace value exists, otherwise false
460 */
464 }
466 /**
467 * A convenience function that returns the same thing as
468 * getNsText() except with '_' changed to ' ', useful for
469 * producing output.
470 *
471 * @param $index string
472 *
473 * @return array
474 */
478 }
480 /**
481 * Returns gender-dependent namespace alias if available.
482 * @param $index Int: namespace index
483 * @param $gender String: gender key (male, female... )
484 * @return String
485 * @since 1.18
486 */
490 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
492 }
494 /**
495 * Whether this language makes distinguishes genders for example in
496 * namespaces.
497 * @return bool
498 * @since 1.18
499 */
503 // $wgExtraGenderNamespaces overrides everything
505 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
506 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
507 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
510 // Check what is in i18n files
513 }
514 }
516 /**
517 * Get a namespace key by value, case insensitive.
518 * Only matches namespace names for the current language, not the
519 * canonical ones defined in Namespace.php.
520 *
521 * @param $text String
522 * @return mixed An integer if $text is a valid value otherwise false
523 */
528 }
530 /**
531 * @return array
532 */
544 }
545 }
546 }
549 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
553 }
554 }
557 }
559 }
561 /**
562 * @return array
563 */
567 # Put namespace names and aliases into a hashtable.
568 # If this is too slow, then we should arrange it so that it is done
569 # before caching. The catch is that at pre-cache time, the above
570 # class-specific fixup hasn't been done.
574 }
577 }
581 }
582 }
583 }
585 }
587 /**
588 * Get a namespace key by value, case insensitive. Canonical namespace
589 * names override custom ones defined for the current language.
590 *
591 * @param $text String
592 * @return mixed An integer if $text is a valid value otherwise false
593 */
599 }
602 }
604 /**
605 * short names for language variants used for language conversion links.
606 *
607 * @param $code String
608 * @param $usemsg bool Use the "variantname-xyz" message if it exists
609 * @return string
610 */
615 }
620 # otherwise, output the language code
622 }
623 }
625 /**
626 * @param $name string
627 * @return string
628 */
633 }
635 }
637 /**
638 * @return array
639 */
648 );
649 }
651 /**
652 * @return array
653 */
656 }
658 /**
659 * @return array
660 */
663 }
665 /**
666 * @return array|string
667 */
675 }
676 }
678 /**
679 * @return array
680 */
683 }
685 /**
686 * @param $image
687 * @return array|null
688 */
691 }
693 /**
694 * @return array
695 */
698 }
700 /**
701 * @param $tog
702 * @return string
703 */
706 }
708 /**
709 * Get native language names, indexed by code.
710 * Only those defined in MediaWiki, no other data like CLDR.
711 * If $customisedOnly is true, only returns codes with a messages file
712 *
713 * @param $customisedOnly bool
714 *
715 * @return array
716 * @deprecated in 1.20, use fetchLanguageNames()
717 */
720 }
722 /**
723 * Get translated language names. This is done on best effort and
724 * by default this is exactly the same as Language::getLanguageNames.
725 * The CLDR extension provides translated names.
726 * @param $code String Language code.
727 * @return Array language code => language name
728 * @since 1.18.0
729 * @deprecated in 1.20, use fetchLanguageNames()
730 */
733 }
735 /**
736 * Get an array of language names, indexed by code.
737 * @param $inLanguage null|string: Code of language in which to return the names
738 * Use null for autonyms (native names)
739 * @param $include string:
740 * 'all' all available languages
741 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
742 * 'mwfile' only if the language is in 'mw' *and* has a message file
743 * @return array: language code => language name
744 * @since 1.20
745 */
752 }
757 # TODO: also include when $inLanguage is null, when this code is more efficient
759 }
763 # - Prefer own MediaWiki native name when not using the hook
764 # - For other names just add if not added through the hook
767 }
768 }
772 }
778 }
782 # We do this using a foreach over the codes instead of a directory
783 # loop so that messages files in extensions will work correctly.
787 }
788 }
790 }
791 # 'mw' option; default if it's not one of the other two options (all/mwfile)
793 }
795 /**
796 * @param $code string: The code of the language for which to get the name
797 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
798 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
799 * @return string: Language name or empty
800 * @since 1.20
801 */
805 }
807 /**
808 * Get a message from the MediaWiki namespace.
809 *
810 * @param $msg String: message name
811 * @return string
812 */
815 }
817 /**
818 * Get the native language name of $code.
819 * Only if defined in MediaWiki, no other data like CLDR.
820 * @param $code string
821 * @return string
822 * @deprecated in 1.20, use fetchLanguageName()
823 */
826 }
828 /**
829 * @param $key string
830 * @return string
831 */
834 }
836 /**
837 * @return array
838 */
843 }
845 }
847 /**
848 * @param $key string
849 * @return string
850 */
853 }
855 /**
856 * @param $key string
857 * @return string
858 */
861 }
863 /**
864 * @return array
865 */
870 }
872 }
874 /**
875 * @param $key string
876 * @return string
877 */
880 }
882 /**
883 * @param $key string
884 * @return string
885 */
888 }
890 /**
891 * @param $key string
892 * @return string
893 */
896 }
898 /**
899 * @param $key string
900 * @return string
901 */
904 }
906 /**
907 * @param $key string
908 * @return string
909 */
912 }
914 /**
915 * @param $key string
916 * @return string
917 */
920 }
922 /**
923 * This is a workalike of PHP's date() function, but with better
924 * internationalisation, a reduced set of format characters, and a better
925 * escaping format.
926 *
927 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
928 * PHP manual for definitions. There are a number of extensions, which
929 * start with "x":
930 *
931 * xn Do not translate digits of the next numeric format character
932 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
933 * xr Use roman numerals for the next numeric format character
934 * xh Use hebrew numerals for the next numeric format character
935 * xx Literal x
936 * xg Genitive month name
937 *
938 * xij j (day number) in Iranian calendar
939 * xiF F (month name) in Iranian calendar
940 * xin n (month number) in Iranian calendar
941 * xiy y (two digit year) in Iranian calendar
942 * xiY Y (full year) in Iranian calendar
943 *
944 * xjj j (day number) in Hebrew calendar
945 * xjF F (month name) in Hebrew calendar
946 * xjt t (days in month) in Hebrew calendar
947 * xjx xg (genitive month name) in Hebrew calendar
948 * xjn n (month number) in Hebrew calendar
949 * xjY Y (full year) in Hebrew calendar
950 *
951 * xmj j (day number) in Hijri calendar
952 * xmF F (month name) in Hijri calendar
953 * xmn n (month number) in Hijri calendar
954 * xmY Y (full year) in Hijri calendar
955 *
956 * xkY Y (full year) in Thai solar calendar. Months and days are
957 * identical to the Gregorian calendar
958 * xoY Y (full year) in Minguo calendar or Juche year.
959 * Months and days are identical to the
960 * Gregorian calendar
961 * xtY Y (full year) in Japanese nengo. Months and days are
962 * identical to the Gregorian calendar
963 *
964 * Characters enclosed in double quotes will be considered literal (with
965 * the quotes themselves removed). Unmatched quotes will be considered
966 * literal quotes. Example:
967 *
968 * "The month is" F => The month is January
969 * i's" => 20'11"
970 *
971 * Backslash escaping is also supported.
972 *
973 * Input timestamp is assumed to be pre-normalized to the desired local
974 * time zone, if any.
975 *
976 * @param $format String
977 * @param $ts String: 14-character timestamp
978 * YYYYMMDDHHMMSS
979 * 01234567890123
980 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
981 *
982 * @return string
983 */
1002 }
1004 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1006 }
1044 }
1050 }
1056 }
1062 }
1068 }
1075 }
1081 }
1087 }
1096 }
1102 }
1108 }
1123 }
1129 }
1135 }
1141 }
1147 }
1153 }
1159 }
1168 }
1174 }
1180 }
1186 }
1192 }
1198 }
1207 }
1239 }
1245 }
1251 }
1255 # Backslash escaping
1260 }
1263 # Quoted literal
1267 # No terminating quote, assume literal "
1272 }
1274 # Quote at end of string, assume literal "
1276 }
1280 }
1293 }
1294 }
1295 }
1297 }
1302 /**
1303 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1304 * Gregorian dates to Iranian dates. Originally written in C, it
1305 * is released under the terms of GNU Lesser General Public
1306 * License. Conversion to PHP was performed by Niklas Laxström.
1307 *
1308 * Link: http://www.farsiweb.info/jalali/jalali.c
1309 *
1310 * @param $ts string
1311 *
1312 * @return string
1313 */
1319 # Days passed from the beginning (including leap years)
1325 // Add days of the past months of this year
1328 }
1330 // Leap years
1333 }
1335 // Days passed in current month
1349 }
1353 }
1359 }
1361 /**
1362 * Converting Gregorian dates to Hijri dates.
1363 *
1364 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1365 *
1366 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1367 *
1368 * @param $ts string
1369 *
1370 * @return string
1371 */
1385 )
1386 {
1394 }
1399 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1400 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1406 }
1408 /**
1409 * Converting Gregorian dates to Hebrew dates.
1410 *
1411 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1412 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1413 * to translate the relevant functions into PHP and release them under
1414 * GNU GPL.
1415 *
1416 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1417 * and Adar II is 14. In a non-leap year, Adar is 6.
1418 *
1419 * @param $ts string
1420 *
1421 * @return string
1422 */
1424 # Parse date
1429 # Calculate Hebrew year
1432 # Month number when September = 1, August = 12
1435 # Next year
1439 }
1441 # Calculate day of year from 1 September
1445 # February
1447 # Check if the year is leap
1450 }
1455 }
1456 }
1458 # Calculate the start of the Hebrew year
1461 # Calculate next year's start
1463 # Day is before the start of the year - it is the previous year
1464 # Next year's start
1466 # Previous year
1469 # Add days since previous year's 1 September
1472 # Leap year
1474 }
1475 # Start of the new (previous) year
1478 # Next year's start
1480 }
1482 # Calculate Hebrew day of year
1485 # Difference between year's days
1487 # Add 12 (or 13 for leap years) days to ignore the difference between
1488 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1489 # difference is only about the year type
1494 }
1496 # Check the year pattern, and is leap year
1497 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1498 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1499 # and non-leap years
1501 # Check if leap year
1504 # Calculate day in the month from number of day in the Hebrew year
1505 # Don't check Adar - if the day is not in Adar, we will stop before;
1506 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1511 # Calculate days in this month
1513 # Adar in a leap year
1515 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1518 # Day in Adar I
1521 # Subtract the days of Adar I
1523 # Try Adar II
1526 # Day in Adar II
1528 }
1529 }
1530 }
1532 # Cheshvan in a complete year (otherwise as the rule below)
1535 # Kislev in an incomplete year (otherwise as the rule below)
1538 # Odd months have 30 days, even have 29
1540 }
1542 # In the current month
1545 # Subtract the days of the current month
1547 # Try in the next month
1549 }
1550 }
1553 }
1555 /**
1556 * This calculates the Hebrew year start, as days since 1 September.
1557 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1558 * Used for Hebrew date.
1559 *
1560 * @param $year int
1561 *
1562 * @return string
1563 */
1570 }
1574 }
1584 }
1588 }
1590 /**
1591 * Algorithm to convert Gregorian dates to Thai solar dates,
1592 * Minguo dates or Minguo dates.
1593 *
1594 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1595 * http://en.wikipedia.org/wiki/Minguo_calendar
1596 * http://en.wikipedia.org/wiki/Japanese_era_name
1597 *
1598 * @param $ts String: 14-character timestamp
1599 * @param $cName String: calender name
1600 * @return Array: converted year, month, day
1601 */
1608 # Thai solar dates
1609 # Add 543 years to the Gregorian calendar
1610 # Months and days are identical
1613 # Minguo dates
1614 # Deduct 1911 years from the Gregorian calendar
1615 # Months and days are identical
1618 # Nengō dates up to Meiji period
1619 # Deduct years from the Gregorian calendar
1620 # depending on the nengo periods
1621 # Months and days are identical
1622 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1623 # Meiji period
1628 }
1636 )
1637 {
1638 # Taishō period
1643 }
1649 )
1650 {
1651 # Shōwa period
1656 }
1659 # Heisei period
1664 }
1666 }
1669 }
1672 }
1674 /**
1675 * Roman number formatting up to 10000
1676 *
1677 * @param $num int
1678 *
1679 * @return string
1680 */
1686 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1687 );
1692 }
1698 }
1700 }
1702 }
1704 /**
1705 * Hebrew Gematria number formatting up to 9999
1706 *
1707 * @param $num int
1708 *
1709 * @return string
1710 */
1717 );
1722 }
1734 }
1735 }
1736 }
1738 }
1744 }
1763 }
1765 }
1767 /**
1768 * Used by date() and time() to adjust the time output.
1769 *
1770 * @param $ts Int the time in date('YmdHis') format
1771 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1772 * get user timecorrection setting)
1773 * @return int
1774 */
1780 }
1793 }
1794 # Unrecognized timezone, default to 'Offset' with the stored offset.
1796 }
1800 # Global offset in minutes.
1803 }
1814 }
1817 }
1818 }
1820 # No difference ? Return time unchanged
1823 }
1826 # Generate an adjusted date; take advantage of the fact that mktime
1827 # will normalize out-of-range values so we don't have to split $minDiff
1828 # into hours and minutes.
1841 }
1843 /**
1844 * This is meant to be used by time(), date(), and timeanddate() to get
1845 * the date preference they're supposed to use, it should be used in
1846 * all children.
1847 *
1848 *<code>
1849 * function timeanddate([...], $format = true) {
1850 * $datePreference = $this->dateFormat($format);
1851 * [...]
1852 * }
1853 *</code>
1854 *
1855 * @param $usePrefs Mixed: if true, the user's preference is used
1856 * if false, the site/language default is used
1857 * if int/string, assumed to be a format.
1858 * @return string
1859 */
1868 }
1871 }
1873 // return int
1876 }
1879 }
1881 /**
1882 * Get a format string for a given type and preference
1883 * @param $type string May be date, time or both
1884 * @param $pref string The format name as it appears in Messages*.php
1885 *
1886 * @return string
1887 */
1898 }
1899 }
1901 }
1903 }
1905 /**
1906 * @param $ts Mixed: the time format which needs to be turned into a
1907 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1908 * @param $adj Bool: whether to adjust the time output according to the
1909 * user configured offset ($timecorrection)
1910 * @param $format Mixed: true to use user's date format preference
1911 * @param $timecorrection String|bool the time offset as returned by
1912 * validateTimeZone() in Special:Preferences
1913 * @return string
1914 */
1919 }
1922 }
1924 /**
1925 * @param $ts Mixed: the time format which needs to be turned into a
1926 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1927 * @param $adj Bool: whether to adjust the time output according to the
1928 * user configured offset ($timecorrection)
1929 * @param $format Mixed: true to use user's date format preference
1930 * @param $timecorrection String|bool the time offset as returned by
1931 * validateTimeZone() in Special:Preferences
1932 * @return string
1933 */
1938 }
1941 }
1943 /**
1944 * @param $ts Mixed: the time format which needs to be turned into a
1945 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1946 * @param $adj Bool: whether to adjust the time output according to the
1947 * user configured offset ($timecorrection)
1948 * @param $format Mixed: what format to return, if it's false output the
1949 * default one (default true)
1950 * @param $timecorrection String|bool the time offset as returned by
1951 * validateTimeZone() in Special:Preferences
1952 * @return string
1953 */
1958 }
1961 }
1963 /**
1964 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
1965 *
1966 * @since 1.20
1967 *
1968 * @param integer $seconds The amount of seconds.
1969 * @param array $chosenIntervals The intervals to enable.
1970 *
1971 * @return string
1972 */
1981 }
1984 }
1986 /**
1987 * Takes a number of seconds and returns an array with a set of corresponding intervals.
1988 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
1989 *
1990 * @since 1.20
1991 *
1992 * @param integer $seconds The amount of seconds.
1993 * @param array $chosenIntervals The intervals to enable.
1994 *
1995 * @return array
1996 */
1999 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2000 }
2014 }
2015 }
2018 }
2020 /**
2021 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2022 *
2023 * @param $type String: can be 'date', 'time' or 'both'
2024 * @param $ts Mixed: the time format which needs to be turned into a
2025 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2026 * @param $user User object used to get preferences for timezone and format
2027 * @param $options Array, can contain the following keys:
2028 * - 'timecorrection': time correction, can have the following values:
2029 * - true: use user's preference
2030 * - false: don't use time correction
2031 * - integer: value of time correction in minutes
2032 * - 'format': format to use, can have the following values:
2033 * - true: use user's preference
2034 * - false: use default preference
2035 * - string: format to use
2036 * @since 1.19
2037 * @return String
2038 */
2047 }
2049 }
2054 }
2057 }
2059 /**
2060 * Get the formatted date for the given timestamp and formatted for
2061 * the given user.
2062 *
2063 * @param $ts Mixed: the time format which needs to be turned into a
2064 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2065 * @param $user User object used to get preferences for timezone and format
2066 * @param $options Array, can contain the following keys:
2067 * - 'timecorrection': time correction, can have the following values:
2068 * - true: use user's preference
2069 * - false: don't use time correction
2070 * - integer: value of time correction in minutes
2071 * - 'format': format to use, can have the following values:
2072 * - true: use user's preference
2073 * - false: use default preference
2074 * - string: format to use
2075 * @since 1.19
2076 * @return String
2077 */
2080 }
2082 /**
2083 * Get the formatted time for the given timestamp and formatted for
2084 * the given user.
2085 *
2086 * @param $ts Mixed: the time format which needs to be turned into a
2087 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2088 * @param $user User object used to get preferences for timezone and format
2089 * @param $options Array, can contain the following keys:
2090 * - 'timecorrection': time correction, can have the following values:
2091 * - true: use user's preference
2092 * - false: don't use time correction
2093 * - integer: value of time correction in minutes
2094 * - 'format': format to use, can have the following values:
2095 * - true: use user's preference
2096 * - false: use default preference
2097 * - string: format to use
2098 * @since 1.19
2099 * @return String
2100 */
2103 }
2105 /**
2106 * Get the formatted date and time for the given timestamp and formatted for
2107 * the given user.
2108 *
2109 * @param $ts Mixed: the time format which needs to be turned into a
2110 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2111 * @param $user User object used to get preferences for timezone and format
2112 * @param $options Array, can contain the following keys:
2113 * - 'timecorrection': time correction, can have the following values:
2114 * - true: use user's preference
2115 * - false: don't use time correction
2116 * - integer: value of time correction in minutes
2117 * - 'format': format to use, can have the following values:
2118 * - true: use user's preference
2119 * - false: use default preference
2120 * - string: format to use
2121 * @since 1.19
2122 * @return String
2123 */
2126 }
2128 /**
2129 * @param $key string
2130 * @return array|null
2131 */
2134 }
2136 /**
2137 * @return array
2138 */
2141 }
2143 /**
2144 * @param $in
2145 * @param $out
2146 * @param $string
2147 * @return string
2148 */
2150 # This is a wrapper for iconv in all languages except esperanto,
2151 # which does some nasty x-conversions beforehand
2153 # Even with //IGNORE iconv can whine about illegal characters in
2154 # *input* string. We just ignore those too.
2155 # REF: http://bugs.php.net/bug.php?id=37166
2156 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2161 }
2163 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2165 /**
2166 * @param $matches array
2167 * @return mixed|string
2168 */
2171 }
2173 /**
2174 * @param $matches array
2175 * @return string
2176 */
2179 }
2181 /**
2182 * @param $matches array
2183 * @return string
2184 */
2188 }
2190 /**
2191 * @param $matches array
2192 * @return string
2193 */
2197 }
2199 /**
2200 * @param $matches array
2201 * @return string
2202 */
2205 }
2207 /**
2208 * @param $matches array
2209 * @return string
2210 */
2214 }
2216 /**
2217 * Make a string's first character uppercase
2218 *
2219 * @param $str string
2220 *
2221 * @return string
2222 */
2230 // fall back to more complex logic in case of multibyte strings
2232 }
2233 }
2235 /**
2236 * Convert a string to uppercase
2237 *
2238 * @param $str string
2239 * @param $first bool
2240 *
2241 * @return string
2242 */
2250 }
2253 }
2260 $str
2261 );
2264 }
2265 }
2266 }
2268 /**
2269 * @param $str string
2270 * @return mixed|string
2271 */
2283 }
2284 }
2286 /**
2287 * @param $str string
2288 * @param $first bool
2289 * @return mixed|string
2290 */
2298 }
2301 }
2308 $str
2309 );
2312 }
2313 }
2314 }
2316 /**
2317 * @param $str string
2318 * @return bool
2319 */
2322 }
2324 /**
2325 * @param $str string
2326 * @return mixed|string
2327 */
2332 // regexp to find first letter in each word (i.e. after each space)
2333 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2335 // function to use to capitalize a single char
2340 $str
2341 );
2346 $str
2347 );
2348 }
2351 }
2352 }
2354 /**
2355 * capitalize words at word breaks
2356 *
2357 * @param $str string
2358 * @return mixed
2359 */
2364 // since \b doesn't work for UTF-8, we explicitely define word break chars
2367 // find first letter after word break
2368 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2374 $str
2375 );
2380 $str
2381 );
2382 }
2387 $str
2388 );
2389 }
2390 }
2392 /**
2393 * Return a case-folded representation of $s
2394 *
2395 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2396 * and $s2 are the same except for the case of their characters. It is not
2397 * necessary for the value returned to make sense when displayed.
2398 *
2399 * Do *not* perform any other normalisation in this function. If a caller
2400 * uses this function when it should be using a more general normalisation
2401 * function, then fix the caller.
2402 *
2403 * @param $s string
2404 *
2405 * @return string
2406 */
2409 }
2411 /**
2412 * @param $s string
2413 * @return string
2414 */
2418 }
2419 # Check for non-UTF-8 URLs
2423 }
2430 }
2433 }
2436 }
2438 /**
2439 * @return array
2440 */
2443 }
2445 /**
2446 * Most writing systems use whitespace to break up words.
2447 * Some languages such as Chinese don't conventionally do this,
2448 * which requires special handling when breaking up words for
2449 * searching etc.
2450 *
2451 * @return bool
2452 */
2455 }
2457 /**
2458 * Some languages such as Chinese require word segmentation,
2459 * Specify such segmentation when overridden in derived class.
2460 *
2461 * @param $string String
2462 * @return String
2463 */
2466 }
2468 /**
2469 * Some languages have special punctuation need to be normalized.
2470 * Make such changes here.
2471 *
2472 * @param $string String
2473 * @return String
2474 */
2477 }
2479 /**
2480 * convert double-width roman characters to single-width.
2481 * range: ff00-ff5f ~= 0020-007f
2482 *
2483 * @param $string string
2484 *
2485 * @return string
2486 */
2496 }
2500 }
2502 /**
2503 * @param $string string
2504 * @param $pattern string
2505 * @return string
2506 */
2511 }
2513 /**
2514 * @param $termsArray array
2515 * @return array
2516 */
2518 # some languages, e.g. Chinese, need to do a conversion
2519 # in order for search results to be displayed correctly
2521 }
2523 /**
2524 * Get the first character of a string.
2525 *
2526 * @param $s string
2527 * @return string
2528 */
2535 $matches
2536 );
2541 }
2543 // Break down Hangul syllables to grab the first jamo
2575 }
2578 }
2579 }
2582 # Some languages may have an alternate char encoding option
2583 # (Esperanto X-coding, Japanese furigana conversion, etc)
2584 # If this language is used as the primary content language,
2585 # an override to the defaults can be set here on startup.
2586 }
2588 /**
2589 * @param $s string
2590 * @return string
2591 */
2593 # For some languages we'll want to explicitly specify
2594 # which characters make it into the edit box raw
2595 # or are converted in some way or another.
2601 }
2602 }
2604 /**
2605 * @param $s string
2606 * @return string
2607 */
2609 # Take the previous into account.
2615 }
2620 }
2621 }
2623 /**
2624 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2625 * also cleans up certain backwards-compatible sequences, converting them
2626 * to the modern Unicode equivalent.
2627 *
2628 * This is language-specific for performance reasons only.
2629 *
2630 * @param $s string
2631 *
2632 * @return string
2633 */
2640 }
2643 }
2645 /**
2646 * Transform a string using serialized data stored in the given file (which
2647 * must be in the serialized subdirectory of $IP). The file contains pairs
2648 * mapping source characters to destination characters.
2649 *
2650 * The data is cached in process memory. This will go faster if you have the
2651 * FastStringSearch extension.
2652 *
2653 * @param $file string
2654 * @param $string string
2655 *
2656 * @throws MWException
2657 * @return string
2658 */
2664 }
2666 }
2668 }
2670 /**
2671 * For right-to-left language support
2672 *
2673 * @return bool
2674 */
2677 }
2679 /**
2680 * Return the correct HTML 'dir' attribute value for this language.
2681 * @return String
2682 */
2685 }
2687 /**
2688 * Return 'left' or 'right' as appropriate alignment for line-start
2689 * for this language's text direction.
2690 *
2691 * Should be equivalent to CSS3 'start' text-align value....
2692 *
2693 * @return String
2694 */
2697 }
2699 /**
2700 * Return 'right' or 'left' as appropriate alignment for line-end
2701 * for this language's text direction.
2702 *
2703 * Should be equivalent to CSS3 'end' text-align value....
2704 *
2705 * @return String
2706 */
2709 }
2711 /**
2712 * A hidden direction mark (LRM or RLM), depending on the language direction.
2713 * Unlike getDirMark(), this function returns the character as an HTML entity.
2714 * This function should be used when the output is guaranteed to be HTML,
2715 * because it makes the output HTML source code more readable. When
2716 * the output is plain text or can be escaped, getDirMark() should be used.
2717 *
2718 * @param $opposite Boolean Get the direction mark opposite to your language
2719 * @return string
2720 * @since 1.20
2721 */
2725 }
2727 /**
2728 * A hidden direction mark (LRM or RLM), depending on the language direction.
2729 * This function produces them as invisible Unicode characters and
2730 * the output may be hard to read and debug, so it should only be used
2731 * when the output is plain text or can be escaped. When the output is
2732 * HTML, use getDirMarkEntity() instead.
2733 *
2734 * @param $opposite Boolean Get the direction mark opposite to your language
2735 * @return string
2736 */
2742 }
2744 /**
2745 * @return array
2746 */
2749 }
2751 /**
2752 * An arrow, depending on the language direction.
2753 *
2754 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2755 * @return string
2756 */
2771 }
2772 }
2774 /**
2775 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2776 *
2777 * @return bool
2778 */
2781 }
2783 /**
2784 * @return array
2785 */
2788 }
2793 }
2798 }
2800 /**
2801 * Fill a MagicWord object with data from here
2802 *
2803 * @param $mw
2804 */
2816 }
2817 }
2824 }
2825 }
2827 /**
2828 * Add magic words to the extension array
2829 *
2830 * @param $newWords array
2831 */
2838 }
2839 }
2840 }
2842 /**
2843 * Get special page names, as an associative array
2844 * case folded alias => real name
2845 */
2847 // Cache aliases because it may be slow to load them
2849 // Initialise array
2854 }
2857 }
2859 /**
2860 * Italic is unsuitable for some languages
2861 *
2862 * @param $text String: the text to be emphasized.
2863 * @return string
2864 */
2867 }
2869 /**
2870 * Normally we output all numbers in plain en_US style, that is
2871 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2872 * point twohundredthirtyfive. However this is not suitable for all
2873 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2874 * Icelandic just want to use commas instead of dots, and dots instead
2875 * of commas like "293.291,235".
2876 *
2877 * An example of this function being called:
2878 * <code>
2879 * wfMessage( 'message' )->numParams( $num )->text()
2880 * </code>
2881 *
2882 * See LanguageGu.php for the Gujarati implementation and
2883 * $separatorTransformTable on MessageIs.php for
2884 * the , => . and . => , implementation.
2885 *
2886 * @todo check if it's viable to use localeconv() for the decimal
2887 * separator thing.
2888 * @param $number Mixed: the string to be formatted, should be an integer
2889 * or a floating point number.
2890 * @param $nocommafy Bool: set to true for special numbers like dates
2891 * @return string
2892 */
2900 }
2901 }
2907 }
2908 }
2911 }
2913 /**
2914 * @param $number string
2915 * @return string
2916 */
2921 }
2926 }
2930 }
2932 /**
2933 * Adds commas to a given number
2934 * @since 1.19
2935 * @param $_ mixed
2936 * @return string
2937 */
2942 }
2945 // default grouping is at thousands, use the same for ###,###,### pattern too.
2948 // Ref: http://cldr.unicode.org/translation/number-patterns
2951 // For negative numbers apply the algorithm like positive number and add sign.
2954 }
2962 // the string does not have any number part. Eg: .12345
2964 }
2972 }
2976 // use the last pattern for the rest of the number
2978 }
2981 }
2982 }
2984 }
2985 }
2986 /**
2987 * @return String
2988 */
2991 }
2993 /**
2994 * @return array
2995 */
2998 }
3000 /**
3001 * @return array
3002 */
3005 }
3007 /**
3008 * Take a list of strings and build a locale-friendly comma-separated
3009 * list, using the local comma-separator message.
3010 * The last two strings are chained with an "and".
3011 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3012 *
3013 * @param $l Array
3014 * @return string
3015 */
3023 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
3029 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
3032 }
3033 }
3035 }
3036 }
3038 /**
3039 * Take a list of strings and build a locale-friendly comma-separated
3040 * list, using the local comma-separator message.
3041 * @param $list array of strings to put in a comma list
3042 * @return string
3043 */
3047 $list
3048 );
3049 }
3051 /**
3052 * Take a list of strings and build a locale-friendly semicolon-separated
3053 * list, using the local semicolon-separator message.
3054 * @param $list array of strings to put in a semicolon list
3055 * @return string
3056 */
3060 $list
3061 );
3062 }
3064 /**
3065 * Same as commaList, but separate it with the pipe instead.
3066 * @param $list array of strings to put in a pipe list
3067 * @return string
3068 */
3072 $list
3073 );
3074 }
3076 /**
3077 * Truncate a string to a specified length in bytes, appending an optional
3078 * string (e.g. for ellipses)
3079 *
3080 * The database offers limited byte lengths for some columns in the database;
3081 * multi-byte character sets mean we need to ensure that only whole characters
3082 * are included, otherwise broken characters can be passed to the user
3083 *
3084 * If $length is negative, the string will be truncated from the beginning
3085 *
3086 * @param $string String to truncate
3087 * @param $length Int: maximum length (including ellipses)
3088 * @param $ellipsis String to append to the truncated text
3089 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3090 * $adjustLength was introduced in 1.18, before that behaved as if false.
3091 * @return string
3092 */
3094 # Use the localized ellipsis character
3097 }
3098 # Check if there is no need to truncate
3103 }
3105 # If ellipsis length is >= $length then we can't apply $adjustLength
3108 # Otherwise, truncate and add ellipsis...
3121 }
3122 }
3123 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3124 # This check is *not* redundant if $adjustLength, due to the single case where
3125 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3130 }
3131 }
3133 /**
3134 * Remove bytes that represent an incomplete Unicode character
3135 * at the end of string (e.g. bytes of the char are missing)
3136 *
3137 * @param $string String
3138 * @return string
3139 */
3145 # We got the first byte only of a multibyte char; remove it.
3150 {
3151 # We chopped in the middle of a character; remove it
3153 }
3154 }
3156 }
3158 /**
3159 * Remove bytes that represent an incomplete Unicode character
3160 * at the start of string (e.g. bytes of the char are missing)
3161 *
3162 * @param $string String
3163 * @return string
3164 */
3169 # We chopped in the middle of a character; remove the whole thing
3171 }
3172 }
3174 }
3176 /**
3177 * Truncate a string of valid HTML to a specified length in bytes,
3178 * appending an optional string (e.g. for ellipses), and return valid HTML
3179 *
3180 * This is only intended for styled/linked text, such as HTML with
3181 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3182 * Also, this will not detect things like "display:none" CSS.
3183 *
3184 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3185 *
3186 * @param string $text HTML string to truncate
3187 * @param int $length (zero/positive) Maximum length (including ellipses)
3188 * @param string $ellipsis String to append to the truncated text
3189 * @return string
3190 */
3192 # Use the localized ellipsis character
3195 }
3196 # Check if there is clearly no need to truncate
3201 }
3215 # Consider truncation once the display length has reached the maximim.
3216 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3217 # Check that we're not in the middle of a bracket/entity...
3221 # Save where we are; we will truncate here unless there turn out to
3222 # be so few remaining characters that truncation is not necessary.
3225 }
3227 # String in fact does need truncation, the truncation point was OK.
3232 }
3233 }
3236 # Read the next char...
3254 }
3260 // Name found (e.g. "<a href=..."), add on tag attributes...
3262 }
3268 }
3271 // Save state without $ch. We want to *hit* the first
3272 // display char (to get tags) but not *use* it if truncating.
3274 }
3279 // Add the next $max display text chars after this in one swoop...
3284 }
3285 }
3286 }
3287 }
3288 // Close the last tag if left unclosed by bad HTML
3292 }
3294 }
3296 /**
3297 * truncateHtml() helper function
3298 * like strcspn() but adds the skipped chars to $ret
3299 *
3300 * @param $ret
3301 * @param $text
3302 * @param $search
3303 * @param $start
3304 * @param $len
3305 * @return int
3306 */
3312 }
3317 }
3319 }
3321 /**
3322 * truncateHtml() helper function
3323 * (a) push or pop $tag from $openTags as needed
3324 * (b) clear $tag value
3325 * @param &$tag string Current HTML tag name we are looking at
3326 * @param $tagType int (0-open tag, 1-close tag)
3327 * @param $lastCh string Character before the '>' that ended this tag
3328 * @param &$openTags array Open tag stack (not accounting for $tag)
3329 */
3338 }
3339 }
3341 }
3342 }
3344 /**
3345 * Grammatical transformations, needed for inflected languages
3346 * Invoked by putting {{grammar:case|word}} in a message
3347 *
3348 * @param $word string
3349 * @param $case string
3350 * @return string
3351 */
3356 }
3358 }
3359 /**
3360 * Get the grammar forms for the content language
3361 * @return array of grammar forms
3362 * @since 1.20
3363 */
3366 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3368 }
3370 }
3371 /**
3372 * Provides an alternative text depending on specified gender.
3373 * Usage {{gender:username|masculine|feminine|neutral}}.
3374 * username is optional, in which case the gender of current user is used,
3375 * but only in (some) interface messages; otherwise default gender is used.
3376 *
3377 * If no forms are given, an empty string is returned. If only one form is
3378 * given, it will be returned unconditionally. These details are implied by
3379 * the caller and cannot be overridden in subclasses.
3380 *
3381 * If more than one form is given, the default is to use the neutral one
3382 * if it is specified, and to use the masculine one otherwise. These
3383 * details can be overridden in subclasses.
3384 *
3385 * @param $gender string
3386 * @param $forms array
3387 *
3388 * @return string
3389 */
3393 }
3397 }
3400 }
3402 }
3404 /**
3405 * Plural form transformations, needed for some languages.
3406 * For example, there are 3 form of plural in Russian and Polish,
3407 * depending on "count mod 10". See [[w:Plural]]
3408 * For English it is pretty simple.
3409 *
3410 * Invoked by putting {{plural:count|wordform1|wordform2}}
3411 * or {{plural:count|wordform1|wordform2|wordform3}}
3412 *
3413 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3414 *
3415 * @param $count Integer: non-localized number
3416 * @param $forms Array: different plural forms
3417 * @return string Correct form of plural for $count in this language
3418 */
3422 }
3424 // Handle explicit 0= and 1= forms
3429 }
3431 }
3432 }
3438 }
3440 /**
3441 * Checks that convertPlural was given an array and pads it to requested
3442 * amount of forms by copying the last one.
3443 *
3444 * @param $count Integer: How many forms should there be at least
3445 * @param $forms Array of forms given to convertPlural
3446 * @return array Padded array of forms or an exception if not an array
3447 */
3451 }
3453 }
3455 /**
3456 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3457 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3458 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3459 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3460 * match up with it.
3461 *
3462 * @param $str String: the validated block duration in English
3463 * @return string Somehow translated block duration
3464 * @see LanguageFi.php for example implementation
3465 */
3471 }
3472 }
3474 // Since usually only infinite or indefinite is only on list, so try
3475 // equivalents if still here.
3482 }
3483 }
3484 }
3486 // If all else fails, return a standard duration or timestamp description.
3491 // $time is relative to 0 so it's a duration length.
3495 // wfTimestamp() handles 0 as current time instead of epoch.
3499 }
3500 }
3501 }
3503 /**
3504 * languages like Chinese need to be segmented in order for the diff
3505 * to be of any use
3506 *
3507 * @param $text String
3508 * @return String
3509 */
3512 }
3514 /**
3515 * and unsegment to show the result
3516 *
3517 * @param $text String
3518 * @return String
3519 */
3522 }
3524 /**
3525 * Return the LanguageConverter used in the Language
3526 *
3527 * @since 1.19
3528 * @return LanguageConverter
3529 */
3532 }
3534 /**
3535 * convert text to all supported variants
3536 *
3537 * @param $text string
3538 * @return array
3539 */
3542 }
3544 /**
3545 * convert text to different variants of a language.
3546 *
3547 * @param $text string
3548 * @return string
3549 */
3552 }
3554 /**
3555 * Convert a Title object to a string in the preferred variant
3556 *
3557 * @param $title Title
3558 * @return string
3559 */
3562 }
3564 /**
3565 * Convert a namespace index to a string in the preferred variant
3566 *
3567 * @param $ns int
3568 * @return string
3569 */
3572 }
3574 /**
3575 * Check if this is a language with variants
3576 *
3577 * @return bool
3578 */
3581 }
3583 /**
3584 * Check if the language has the specific variant
3585 *
3586 * @since 1.19
3587 * @param $variant string
3588 * @return bool
3589 */
3592 }
3594 /**
3595 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3596 *
3597 * @param $text string
3598 * @return string
3599 */
3602 }
3604 /**
3605 * Perform output conversion on a string, and encode for safe HTML output.
3606 * @param $text String text to be converted
3607 * @param $isTitle Bool whether this conversion is for the article title
3608 * @return string
3609 * @todo this should get integrated somewhere sane
3610 */
3613 }
3615 /**
3616 * @param $key string
3617 * @return string
3618 */
3621 }
3623 /**
3624 * Get the list of variants supported by this language
3625 * see sample implementation in LanguageZh.php
3626 *
3627 * @return array an array of language codes
3628 */
3631 }
3633 /**
3634 * @return string
3635 */
3638 }
3640 /**
3641 * @return string
3642 */
3645 }
3647 /**
3648 * @return string
3649 */
3652 }
3654 /**
3655 * If a language supports multiple variants, it is
3656 * possible that non-existing link in one variant
3657 * actually exists in another variant. this function
3658 * tries to find it. See e.g. LanguageZh.php
3659 *
3660 * @param $link String: the name of the link
3661 * @param $nt Mixed: the title object of the link
3662 * @param $ignoreOtherCond Boolean: to disable other conditions when
3663 * we need to transclude a template or update a category's link
3664 * @return null the input parameters may be modified upon return
3665 */
3668 }
3670 /**
3671 * If a language supports multiple variants, converts text
3672 * into an array of all possible variants of the text:
3673 * 'variant' => text in that variant
3674 *
3675 * @deprecated since 1.17 Use autoConvertToAllVariants()
3676 *
3677 * @param $text string
3678 *
3679 * @return string
3680 */
3683 }
3685 /**
3686 * returns language specific options used by User::getPageRenderHash()
3687 * for example, the preferred language variant
3688 *
3689 * @return string
3690 */
3693 }
3695 /**
3696 * For languages that support multiple variants, the title of an
3697 * article may be displayed differently in different variants. this
3698 * function returns the apporiate title defined in the body of the article.
3699 *
3700 * @return string
3701 */
3704 }
3706 /**
3707 * Enclose a string with the "no conversion" tag. This is used by
3708 * various functions in the Parser
3709 *
3710 * @param $text String: text to be tagged for no conversion
3711 * @param $noParse bool
3712 * @return string the tagged text
3713 */
3716 }
3718 /**
3719 * A regular expression to match legal word-trailing characters
3720 * which should be merged onto a link of the form [[foo]]bar.
3721 *
3722 * @return string
3723 */
3726 }
3728 /**
3729 * @return Language
3730 */
3733 }
3735 /**
3736 * Get the RFC 3066 code for this language object
3737 *
3738 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3739 * htmlspecialchars() or similar
3740 *
3741 * @return string
3742 */
3745 }
3747 /**
3748 * Get the code in Bcp47 format which we can use
3749 * inside of html lang="" tags.
3750 *
3751 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3752 * htmlspecialchars() or similar.
3753 *
3754 * @since 1.19
3755 * @return string
3756 */
3760 }
3762 }
3764 /**
3765 * @param $code string
3766 */
3769 // Ensure we don't leave an incorrect html code lying around
3771 }
3773 /**
3774 * Get the name of a file for a certain language code
3775 * @param $prefix string Prepend this to the filename
3776 * @param $code string Language code
3777 * @param $suffix string Append this to the filename
3778 * @throws MWException
3779 * @return string $prefix . $mangledCode . $suffix
3780 */
3782 // Protect against path traversal
3785 {
3787 }
3790 }
3792 /**
3793 * Get the language code from a file name. Inverse of getFileName()
3794 * @param $filename string $prefix . $languageCode . $suffix
3795 * @param $prefix string Prefix before the language code
3796 * @param $suffix string Suffix after the language code
3797 * @return string Language code, or false if $prefix or $suffix isn't found
3798 */
3799 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3805 }
3807 }
3809 /**
3810 * @param $code string
3811 * @return string
3812 */
3818 }
3820 /**
3821 * @param $code string
3822 * @return string
3823 */
3827 }
3829 /**
3830 * Get the first fallback for a given language.
3831 *
3832 * @param $code string
3833 *
3834 * @return bool|string
3835 */
3843 }
3844 }
3846 /**
3847 * Get the ordered list of fallback languages.
3848 *
3849 * @since 1.19
3850 * @param $code string Language code
3851 * @return array
3852 */
3861 }
3863 }
3864 }
3866 /**
3867 * Get all messages for a given language
3868 * WARNING: this may take a long time. If you just need all message *keys*
3869 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3870 *
3871 * @param $code string
3872 *
3873 * @return array
3874 */
3877 }
3879 /**
3880 * Get a message for a given language
3881 *
3882 * @param $key string
3883 * @param $code string
3884 *
3885 * @return string
3886 */
3889 }
3891 /**
3892 * Get all message keys for a given language. This is a faster alternative to
3893 * array_keys( Language::getMessagesFor( $code ) )
3894 *
3895 * @since 1.19
3896 * @param $code string Language code
3897 * @return array of message keys (strings)
3898 */
3901 }
3903 /**
3904 * @param $talk
3905 * @return mixed
3906 */
3910 }
3915 # Allow grammar transformations
3916 # Allowing full message-style parsing would make simple requests
3917 # such as action=raw much more expensive than they need to be.
3918 # This will hopefully cover most cases.
3922 }
3924 /**
3925 * @param $m string
3926 * @return string
3927 */
3930 }
3932 /**
3933 * @throws MWException
3934 * @return array
3935 */
3940 }
3947 }
3952 }
3954 /**
3955 * Decode an expiry (block, protection, etc) which has come from the DB
3956 *
3957 * @todo FIXME: why are we returnings DBMS-dependent strings???
3958 *
3959 * @param $expiry String: Database expiry String
3960 * @param $format Bool|Int true to process using language functions, or TS_ constant
3961 * to return the expiry in a given timestamp
3962 * @return String
3963 * @since 1.18
3964 */
3970 }
3974 ? $infinityMsg
3980 }
3981 }
3983 /**
3984 * @todo Document
3985 * @param $seconds int|float
3986 * @param $format Array Optional
3987 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
3988 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
3989 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
3990 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
3991 * @return string
3992 */
3996 }
3999 }
4002 }
4024 }
4035 }
4039 }
4045 }
4053 }
4063 }
4067 }
4077 }
4078 }
4080 }
4082 /**
4083 * Format a bitrate for output, using an appropriate
4084 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4085 *
4086 * This use base 1000. For base 1024 use formatSize(), for another base
4087 * see formatComputingNumbers()
4088 *
4089 * @param $bps int
4090 * @return string
4091 */
4094 }
4096 /**
4097 * @param $size int Size of the unit
4098 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4099 * @param $messageKey string Message key to be uesd
4100 * @return string
4101 */
4106 );
4107 }
4115 }
4117 // For small sizes no decimal places necessary
4120 // For MB and bigger two decimal places are smarter
4122 }
4128 }
4130 /**
4131 * Format a size in bytes for output, using an appropriate
4132 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4133 *
4134 * This method use base 1024. For base 1000 use formatBitrate(), for
4135 * another base see formatComputingNumbers()
4136 *
4137 * @param $size int Size to format
4138 * @return string Plain text (not HTML)
4139 */
4142 }
4144 /**
4145 * Make a list item, used by various special pages
4146 *
4147 * @param $page String Page link
4148 * @param $details String Text between brackets
4149 * @param $oppositedm Boolean Add the direction mark opposite to your
4150 * language, to display text properly
4151 * @return String
4152 */
4159 }
4161 /**
4162 * Generate (prev x| next x) (20|50|100...) type links for paging
4163 *
4164 * @param $title Title object to link
4165 * @param $offset Integer offset parameter
4166 * @param $limit Integer limit parameter
4167 * @param $query array|String optional URL query parameter string
4168 * @param $atend Bool optional param for specified if this is the last page
4169 * @return String
4170 */
4171 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4172 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4174 # Make 'previous' link
4175 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4181 }
4183 # Make 'next' link
4184 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4190 }
4192 # Make links to set number of items per page
4197 }
4201 }
4203 /**
4204 * Helper function for viewPrevNext() that generates links
4205 *
4206 * @param $title Title object to link
4207 * @param $offset Integer offset parameter
4208 * @param $limit Integer limit parameter
4209 * @param $query Array extra query parameters
4210 * @param $link String text to use for the link; will be escaped
4211 * @param $tooltipMsg String name of the message to use as tooltip
4212 * @param $class String value of the "class" attribute of the link
4213 * @return String HTML fragment
4214 */
4215 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4217 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4220 }
4222 /**
4223 * Get the conversion rule title, if any.
4224 *
4225 * @return string
4226 */
4229 }
4231 /**
4232 * Get the compiled plural rules for the language
4233 * @since 1.20
4234 * @return array Associative array with plural form, and plural rule as key-value pairs
4235 */
4241 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4244 }
4245 }
4246 }
4248 }
4250 /**
4251 * Get the plural rules for the language
4252 * @since 1.20
4253 * @return array Associative array with plural form, and plural rule as key-value pairs
4254 */
4263 }
4264 }
4265 }
4267 }
4269 /**
4270 * Find the plural form matching to the given number
4271 * It return the form index.
4272 * @return int The index of the plural form
4273 */
4278 }
4280 }