| blob | 40d1f36cd9a42901482cebda703b4e8d2978a824 |
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 */
69 }
71 /**
72 * Internationalisation code
73 * @ingroup Language
74 */
77 /**
78 * @var LanguageConverter
79 */
91 /**
92 * ReplacementArray object caches
93 */
96 /**
97 * @var LocalisationCache
98 */
106 );
110 );
115 'december'
116 );
120 'december-gen'
121 );
125 );
132 );
140 );
148 );
155 );
157 /**
158 * @since 1.20
159 * @var array
160 */
171 );
173 /**
174 * Get a cached language object for a given language code
175 * @param $code String
176 * @return Language
177 */
181 // Don't keep a billion objects around, that's stupid.
183 }
185 }
187 }
189 /**
190 * Create a language object for a given language code
191 * @param $code String
192 * @throws MWException
193 * @return Language
194 */
196 // Protect against path traversal below
199 {
201 }
204 // It's not possible to customise this code with class files, so
205 // just return a Language object. This is to support uselang= hacks.
209 }
211 // Check if there is a language class for the code
217 }
219 // Keep trying the fallback list until we find an existing class
224 }
232 }
233 }
236 }
238 /**
239 * Returns true if a language code string is of a valid form, whether or
240 * not it exists. This includes codes which are used solely for
241 * customisation via the MediaWiki namespace.
242 *
243 * @param $code string
244 *
245 * @return bool
246 */
248 return
249 // People think language codes are html safe, so enforce it.
250 // Ideally we should only allow a-zA-Z0-9-
251 // but, .+ and other chars are often used for {{int:}} hacks
252 // see bugs 37564, 37587, 36938
255 }
257 /**
258 * Returns true if a language code is of a valid form for the purposes of
259 * internal customisation of MediaWiki, via Messages*.php.
260 *
261 * @param $code string
262 *
263 * @throws MWException
264 * @since 1.18
265 * @return bool
266 */
275 }
277 }
280 }
282 /**
283 * @param $code
284 * @return String Name of the language class
285 */
291 }
292 }
294 /**
295 * Includes language class files
296 *
297 * @param $class string Name of the language class
298 */
304 }
309 }
310 }
311 }
313 /**
314 * Get the LocalisationCache instance
315 *
316 * @return LocalisationCache
317 */
323 }
325 }
329 // Set the code to the name of the descendant
334 }
336 }
338 /**
339 * Reduce memory usage
340 */
344 }
345 }
347 /**
348 * Hook which will be called if this is the content language.
349 * Descendants can use this to register hook functions or modify globals
350 */
353 /**
354 * Same as getFallbacksFor for current language.
355 * @return array|bool
356 * @deprecated in 1.19
357 */
361 }
363 /**
364 * @return array
365 * @since 1.19
366 */
369 }
371 /**
372 * Exports $wgBookstoreListEn
373 * @return array
374 */
377 }
379 /**
380 * @return array
381 */
398 }
400 # Sometimes a language will be localised but not actually exist on this wiki.
404 }
405 }
407 # The above mixing may leave namespaces out of canonical order.
408 # Re-order by namespace ID number...
412 }
414 }
416 /**
417 * Arbitrarily set all of the namespace names at once. Mainly used for testing
418 * @param $namespaces Array of namespaces (id => name)
419 */
422 }
424 /**
425 * A convenience function that returns the same thing as
426 * getNamespaces() except with the array values changed to ' '
427 * where it found '_', useful for producing output to be displayed
428 * e.g. in <select> forms.
429 *
430 * @return array
431 */
436 }
438 }
440 /**
441 * Get a namespace value by key
442 * <code>
443 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
444 * echo $mw_ns; // prints 'MediaWiki'
445 * </code>
446 *
447 * @param $index Int: the array key of the namespace to return
448 * @return mixed, string if the namespace value exists, otherwise false
449 */
453 }
455 /**
456 * A convenience function that returns the same thing as
457 * getNsText() except with '_' changed to ' ', useful for
458 * producing output.
459 *
460 * @param $index string
461 *
462 * @return array
463 */
467 }
469 /**
470 * Returns gender-dependent namespace alias if available.
471 * @param $index Int: namespace index
472 * @param $gender String: gender key (male, female... )
473 * @return String
474 * @since 1.18
475 */
479 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
481 }
483 /**
484 * Whether this language makes distinguishes genders for example in
485 * namespaces.
486 * @return bool
487 * @since 1.18
488 */
492 // $wgExtraGenderNamespaces overrides everything
494 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
495 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
496 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
499 // Check what is in i18n files
502 }
503 }
505 /**
506 * Get a namespace key by value, case insensitive.
507 * Only matches namespace names for the current language, not the
508 * canonical ones defined in Namespace.php.
509 *
510 * @param $text String
511 * @return mixed An integer if $text is a valid value otherwise false
512 */
517 }
519 /**
520 * @return array
521 */
533 }
534 }
535 }
538 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
542 }
543 }
546 }
548 }
550 /**
551 * @return array
552 */
556 # Put namespace names and aliases into a hashtable.
557 # If this is too slow, then we should arrange it so that it is done
558 # before caching. The catch is that at pre-cache time, the above
559 # class-specific fixup hasn't been done.
563 }
566 }
570 }
571 }
572 }
574 }
576 /**
577 * Get a namespace key by value, case insensitive. Canonical namespace
578 * names override custom ones defined for the current language.
579 *
580 * @param $text String
581 * @return mixed An integer if $text is a valid value otherwise false
582 */
588 }
591 }
593 /**
594 * short names for language variants used for language conversion links.
595 *
596 * @param $code String
597 * @param $usemsg bool Use the "variantname-xyz" message if it exists
598 * @return string
599 */
604 }
609 # otherwise, output the language code
611 }
612 }
614 /**
615 * @param $name string
616 * @return string
617 */
622 }
624 }
626 /**
627 * @return array
628 */
637 );
638 }
640 /**
641 * @return array
642 */
645 }
647 /**
648 * @return array
649 */
652 }
654 /**
655 * @return array|string
656 */
664 }
665 }
667 /**
668 * @return array
669 */
672 }
674 /**
675 * @param $image
676 * @return array|null
677 */
680 }
682 /**
683 * @return array
684 */
687 }
689 /**
690 * @param $tog
691 * @return string
692 */
695 }
697 /**
698 * Get native language names, indexed by code.
699 * Only those defined in MediaWiki, no other data like CLDR.
700 * If $customisedOnly is true, only returns codes with a messages file
701 *
702 * @param $customisedOnly bool
703 *
704 * @return array
705 * @deprecated in 1.20, use fetchLanguageNames()
706 */
709 }
711 /**
712 * Get translated language names. This is done on best effort and
713 * by default this is exactly the same as Language::getLanguageNames.
714 * The CLDR extension provides translated names.
715 * @param $code String Language code.
716 * @return Array language code => language name
717 * @since 1.18.0
718 * @deprecated in 1.20, use fetchLanguageNames()
719 */
722 }
724 /**
725 * Get an array of language names, indexed by code.
726 * @param $inLanguage null|string: Code of language in which to return the names
727 * Use null for autonyms (native names)
728 * @param $include string:
729 * 'all' all available languages
730 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
731 * 'mwfile' only if the language is in 'mw' *and* has a message file
732 * @return array: language code => language name
733 * @since 1.20
734 */
741 }
746 # TODO: also include when $inLanguage is null, when this code is more efficient
748 }
752 # - Prefer own MediaWiki native name when not using the hook
753 # - For other names just add if not added through the hook
756 }
757 }
761 }
767 }
771 # We do this using a foreach over the codes instead of a directory
772 # loop so that messages files in extensions will work correctly.
776 }
777 }
779 }
780 # 'mw' option; default if it's not one of the other two options (all/mwfile)
782 }
784 /**
785 * @param $code string: The code of the language for which to get the name
786 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
787 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
788 * @return string: Language name or empty
789 * @since 1.20
790 */
794 }
796 /**
797 * Get a message from the MediaWiki namespace.
798 *
799 * @param $msg String: message name
800 * @return string
801 */
804 }
806 /**
807 * Get the native language name of $code.
808 * Only if defined in MediaWiki, no other data like CLDR.
809 * @param $code string
810 * @return string
811 * @deprecated in 1.20, use fetchLanguageName()
812 */
815 }
817 /**
818 * @param $key string
819 * @return string
820 */
823 }
825 /**
826 * @return array
827 */
832 }
834 }
836 /**
837 * @param $key string
838 * @return string
839 */
842 }
844 /**
845 * @param $key string
846 * @return string
847 */
850 }
852 /**
853 * @return array
854 */
859 }
861 }
863 /**
864 * @param $key string
865 * @return string
866 */
869 }
871 /**
872 * @param $key string
873 * @return string
874 */
877 }
879 /**
880 * @param $key string
881 * @return string
882 */
885 }
887 /**
888 * @param $key string
889 * @return string
890 */
893 }
895 /**
896 * @param $key string
897 * @return string
898 */
901 }
903 /**
904 * @param $key string
905 * @return string
906 */
909 }
911 /**
912 * This is a workalike of PHP's date() function, but with better
913 * internationalisation, a reduced set of format characters, and a better
914 * escaping format.
915 *
916 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
917 * PHP manual for definitions. There are a number of extensions, which
918 * start with "x":
919 *
920 * xn Do not translate digits of the next numeric format character
921 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
922 * xr Use roman numerals for the next numeric format character
923 * xh Use hebrew numerals for the next numeric format character
924 * xx Literal x
925 * xg Genitive month name
926 *
927 * xij j (day number) in Iranian calendar
928 * xiF F (month name) in Iranian calendar
929 * xin n (month number) in Iranian calendar
930 * xiy y (two digit year) in Iranian calendar
931 * xiY Y (full year) in Iranian calendar
932 *
933 * xjj j (day number) in Hebrew calendar
934 * xjF F (month name) in Hebrew calendar
935 * xjt t (days in month) in Hebrew calendar
936 * xjx xg (genitive month name) in Hebrew calendar
937 * xjn n (month number) in Hebrew calendar
938 * xjY Y (full year) in Hebrew calendar
939 *
940 * xmj j (day number) in Hijri calendar
941 * xmF F (month name) in Hijri calendar
942 * xmn n (month number) in Hijri calendar
943 * xmY Y (full year) in Hijri calendar
944 *
945 * xkY Y (full year) in Thai solar calendar. Months and days are
946 * identical to the Gregorian calendar
947 * xoY Y (full year) in Minguo calendar or Juche year.
948 * Months and days are identical to the
949 * Gregorian calendar
950 * xtY Y (full year) in Japanese nengo. Months and days are
951 * identical to the Gregorian calendar
952 *
953 * Characters enclosed in double quotes will be considered literal (with
954 * the quotes themselves removed). Unmatched quotes will be considered
955 * literal quotes. Example:
956 *
957 * "The month is" F => The month is January
958 * i's" => 20'11"
959 *
960 * Backslash escaping is also supported.
961 *
962 * Input timestamp is assumed to be pre-normalized to the desired local
963 * time zone, if any.
964 *
965 * @param $format String
966 * @param $ts String: 14-character timestamp
967 * YYYYMMDDHHMMSS
968 * 01234567890123
969 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
970 *
971 * @return string
972 */
991 }
993 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
995 }
1033 }
1039 }
1045 }
1051 }
1057 }
1064 }
1070 }
1076 }
1085 }
1091 }
1097 }
1112 }
1118 }
1124 }
1130 }
1136 }
1142 }
1148 }
1157 }
1163 }
1169 }
1175 }
1181 }
1187 }
1196 }
1228 }
1234 }
1240 }
1244 # Backslash escaping
1249 }
1252 # Quoted literal
1256 # No terminating quote, assume literal "
1261 }
1263 # Quote at end of string, assume literal "
1265 }
1269 }
1282 }
1283 }
1284 }
1286 }
1291 /**
1292 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1293 * Gregorian dates to Iranian dates. Originally written in C, it
1294 * is released under the terms of GNU Lesser General Public
1295 * License. Conversion to PHP was performed by Niklas Laxström.
1296 *
1297 * Link: http://www.farsiweb.info/jalali/jalali.c
1298 *
1299 * @param $ts string
1300 *
1301 * @return string
1302 */
1308 # Days passed from the beginning (including leap years)
1314 // Add days of the past months of this year
1317 }
1319 // Leap years
1322 }
1324 // Days passed in current month
1338 }
1342 }
1348 }
1350 /**
1351 * Converting Gregorian dates to Hijri dates.
1352 *
1353 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1354 *
1355 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1356 *
1357 * @param $ts string
1358 *
1359 * @return string
1360 */
1374 )
1375 {
1383 }
1388 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1389 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1395 }
1397 /**
1398 * Converting Gregorian dates to Hebrew dates.
1399 *
1400 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1401 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1402 * to translate the relevant functions into PHP and release them under
1403 * GNU GPL.
1404 *
1405 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1406 * and Adar II is 14. In a non-leap year, Adar is 6.
1407 *
1408 * @param $ts string
1409 *
1410 * @return string
1411 */
1413 # Parse date
1418 # Calculate Hebrew year
1421 # Month number when September = 1, August = 12
1424 # Next year
1428 }
1430 # Calculate day of year from 1 September
1434 # February
1436 # Check if the year is leap
1439 }
1444 }
1445 }
1447 # Calculate the start of the Hebrew year
1450 # Calculate next year's start
1452 # Day is before the start of the year - it is the previous year
1453 # Next year's start
1455 # Previous year
1458 # Add days since previous year's 1 September
1461 # Leap year
1463 }
1464 # Start of the new (previous) year
1467 # Next year's start
1469 }
1471 # Calculate Hebrew day of year
1474 # Difference between year's days
1476 # Add 12 (or 13 for leap years) days to ignore the difference between
1477 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1478 # difference is only about the year type
1483 }
1485 # Check the year pattern, and is leap year
1486 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1487 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1488 # and non-leap years
1490 # Check if leap year
1493 # Calculate day in the month from number of day in the Hebrew year
1494 # Don't check Adar - if the day is not in Adar, we will stop before;
1495 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1500 # Calculate days in this month
1502 # Adar in a leap year
1504 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1507 # Day in Adar I
1510 # Subtract the days of Adar I
1512 # Try Adar II
1515 # Day in Adar II
1517 }
1518 }
1519 }
1521 # Cheshvan in a complete year (otherwise as the rule below)
1524 # Kislev in an incomplete year (otherwise as the rule below)
1527 # Odd months have 30 days, even have 29
1529 }
1531 # In the current month
1534 # Subtract the days of the current month
1536 # Try in the next month
1538 }
1539 }
1542 }
1544 /**
1545 * This calculates the Hebrew year start, as days since 1 September.
1546 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1547 * Used for Hebrew date.
1548 *
1549 * @param $year int
1550 *
1551 * @return string
1552 */
1559 }
1563 }
1573 }
1577 }
1579 /**
1580 * Algorithm to convert Gregorian dates to Thai solar dates,
1581 * Minguo dates or Minguo dates.
1582 *
1583 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1584 * http://en.wikipedia.org/wiki/Minguo_calendar
1585 * http://en.wikipedia.org/wiki/Japanese_era_name
1586 *
1587 * @param $ts String: 14-character timestamp
1588 * @param $cName String: calender name
1589 * @return Array: converted year, month, day
1590 */
1597 # Thai solar dates
1598 # Add 543 years to the Gregorian calendar
1599 # Months and days are identical
1602 # Minguo dates
1603 # Deduct 1911 years from the Gregorian calendar
1604 # Months and days are identical
1607 # Nengō dates up to Meiji period
1608 # Deduct years from the Gregorian calendar
1609 # depending on the nengo periods
1610 # Months and days are identical
1611 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1612 # Meiji period
1617 }
1625 )
1626 {
1627 # Taishō period
1632 }
1638 )
1639 {
1640 # Shōwa period
1645 }
1648 # Heisei period
1653 }
1655 }
1658 }
1661 }
1663 /**
1664 * Roman number formatting up to 10000
1665 *
1666 * @param $num int
1667 *
1668 * @return string
1669 */
1675 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1676 );
1681 }
1687 }
1689 }
1691 }
1693 /**
1694 * Hebrew Gematria number formatting up to 9999
1695 *
1696 * @param $num int
1697 *
1698 * @return string
1699 */
1706 );
1711 }
1723 }
1724 }
1725 }
1727 }
1733 }
1752 }
1754 }
1756 /**
1757 * Used by date() and time() to adjust the time output.
1758 *
1759 * @param $ts Int the time in date('YmdHis') format
1760 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1761 * get user timecorrection setting)
1762 * @return int
1763 */
1769 }
1782 }
1783 # Unrecognized timezone, default to 'Offset' with the stored offset.
1785 }
1789 # Global offset in minutes.
1792 }
1803 }
1806 }
1807 }
1809 # No difference ? Return time unchanged
1812 }
1815 # Generate an adjusted date; take advantage of the fact that mktime
1816 # will normalize out-of-range values so we don't have to split $minDiff
1817 # into hours and minutes.
1830 }
1832 /**
1833 * This is meant to be used by time(), date(), and timeanddate() to get
1834 * the date preference they're supposed to use, it should be used in
1835 * all children.
1836 *
1837 *<code>
1838 * function timeanddate([...], $format = true) {
1839 * $datePreference = $this->dateFormat($format);
1840 * [...]
1841 * }
1842 *</code>
1843 *
1844 * @param $usePrefs Mixed: if true, the user's preference is used
1845 * if false, the site/language default is used
1846 * if int/string, assumed to be a format.
1847 * @return string
1848 */
1857 }
1860 }
1862 // return int
1865 }
1868 }
1870 /**
1871 * Get a format string for a given type and preference
1872 * @param $type string May be date, time or both
1873 * @param $pref string The format name as it appears in Messages*.php
1874 *
1875 * @return string
1876 */
1887 }
1888 }
1890 }
1892 }
1894 /**
1895 * @param $ts Mixed: the time format which needs to be turned into a
1896 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1897 * @param $adj Bool: whether to adjust the time output according to the
1898 * user configured offset ($timecorrection)
1899 * @param $format Mixed: true to use user's date format preference
1900 * @param $timecorrection String|bool the time offset as returned by
1901 * validateTimeZone() in Special:Preferences
1902 * @return string
1903 */
1908 }
1911 }
1913 /**
1914 * @param $ts Mixed: the time format which needs to be turned into a
1915 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1916 * @param $adj Bool: whether to adjust the time output according to the
1917 * user configured offset ($timecorrection)
1918 * @param $format Mixed: true to use user's date format preference
1919 * @param $timecorrection String|bool the time offset as returned by
1920 * validateTimeZone() in Special:Preferences
1921 * @return string
1922 */
1927 }
1930 }
1932 /**
1933 * @param $ts Mixed: the time format which needs to be turned into a
1934 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1935 * @param $adj Bool: whether to adjust the time output according to the
1936 * user configured offset ($timecorrection)
1937 * @param $format Mixed: what format to return, if it's false output the
1938 * default one (default true)
1939 * @param $timecorrection String|bool the time offset as returned by
1940 * validateTimeZone() in Special:Preferences
1941 * @return string
1942 */
1947 }
1950 }
1952 /**
1953 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
1954 *
1955 * @since 1.20
1956 *
1957 * @param integer $seconds The amount of seconds.
1958 * @param array $chosenIntervals The intervals to enable.
1959 *
1960 * @return string
1961 */
1970 }
1973 }
1975 /**
1976 * Takes a number of seconds and returns an array with a set of corresponding intervals.
1977 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
1978 *
1979 * @since 1.20
1980 *
1981 * @param integer $seconds The amount of seconds.
1982 * @param array $chosenIntervals The intervals to enable.
1983 *
1984 * @return array
1985 */
1988 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
1989 }
2003 }
2004 }
2007 }
2009 /**
2010 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2011 *
2012 * @param $type String: can be 'date', 'time' or 'both'
2013 * @param $ts Mixed: the time format which needs to be turned into a
2014 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2015 * @param $user User object used to get preferences for timezone and format
2016 * @param $options Array, can contain the following keys:
2017 * - 'timecorrection': time correction, can have the following values:
2018 * - true: use user's preference
2019 * - false: don't use time correction
2020 * - integer: value of time correction in minutes
2021 * - 'format': format to use, can have the following values:
2022 * - true: use user's preference
2023 * - false: use default preference
2024 * - string: format to use
2025 * @since 1.19
2026 * @return String
2027 */
2036 }
2038 }
2043 }
2046 }
2048 /**
2049 * Get the formatted date for the given timestamp and formatted for
2050 * the given user.
2051 *
2052 * @param $ts Mixed: the time format which needs to be turned into a
2053 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2054 * @param $user User object used to get preferences for timezone and format
2055 * @param $options Array, can contain the following keys:
2056 * - 'timecorrection': time correction, can have the following values:
2057 * - true: use user's preference
2058 * - false: don't use time correction
2059 * - integer: value of time correction in minutes
2060 * - 'format': format to use, can have the following values:
2061 * - true: use user's preference
2062 * - false: use default preference
2063 * - string: format to use
2064 * @since 1.19
2065 * @return String
2066 */
2069 }
2071 /**
2072 * Get the formatted time for the given timestamp and formatted for
2073 * the given user.
2074 *
2075 * @param $ts Mixed: the time format which needs to be turned into a
2076 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2077 * @param $user User object used to get preferences for timezone and format
2078 * @param $options Array, can contain the following keys:
2079 * - 'timecorrection': time correction, can have the following values:
2080 * - true: use user's preference
2081 * - false: don't use time correction
2082 * - integer: value of time correction in minutes
2083 * - 'format': format to use, can have the following values:
2084 * - true: use user's preference
2085 * - false: use default preference
2086 * - string: format to use
2087 * @since 1.19
2088 * @return String
2089 */
2092 }
2094 /**
2095 * Get the formatted date and time for the given timestamp and formatted for
2096 * the given user.
2097 *
2098 * @param $ts Mixed: the time format which needs to be turned into a
2099 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2100 * @param $user User object used to get preferences for timezone and format
2101 * @param $options Array, can contain the following keys:
2102 * - 'timecorrection': time correction, can have the following values:
2103 * - true: use user's preference
2104 * - false: don't use time correction
2105 * - integer: value of time correction in minutes
2106 * - 'format': format to use, can have the following values:
2107 * - true: use user's preference
2108 * - false: use default preference
2109 * - string: format to use
2110 * @since 1.19
2111 * @return String
2112 */
2115 }
2117 /**
2118 * @param $key string
2119 * @return array|null
2120 */
2123 }
2125 /**
2126 * @return array
2127 */
2130 }
2132 /**
2133 * @param $in
2134 * @param $out
2135 * @param $string
2136 * @return string
2137 */
2139 # This is a wrapper for iconv in all languages except esperanto,
2140 # which does some nasty x-conversions beforehand
2142 # Even with //IGNORE iconv can whine about illegal characters in
2143 # *input* string. We just ignore those too.
2144 # REF: http://bugs.php.net/bug.php?id=37166
2145 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2150 }
2152 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2154 /**
2155 * @param $matches array
2156 * @return mixed|string
2157 */
2160 }
2162 /**
2163 * @param $matches array
2164 * @return string
2165 */
2168 }
2170 /**
2171 * @param $matches array
2172 * @return string
2173 */
2177 }
2179 /**
2180 * @param $matches array
2181 * @return string
2182 */
2186 }
2188 /**
2189 * @param $matches array
2190 * @return string
2191 */
2194 }
2196 /**
2197 * @param $matches array
2198 * @return string
2199 */
2203 }
2205 /**
2206 * Make a string's first character uppercase
2207 *
2208 * @param $str string
2209 *
2210 * @return string
2211 */
2219 // fall back to more complex logic in case of multibyte strings
2221 }
2222 }
2224 /**
2225 * Convert a string to uppercase
2226 *
2227 * @param $str string
2228 * @param $first bool
2229 *
2230 * @return string
2231 */
2239 }
2242 }
2249 $str
2250 );
2253 }
2254 }
2255 }
2257 /**
2258 * @param $str string
2259 * @return mixed|string
2260 */
2272 }
2273 }
2275 /**
2276 * @param $str string
2277 * @param $first bool
2278 * @return mixed|string
2279 */
2287 }
2290 }
2297 $str
2298 );
2301 }
2302 }
2303 }
2305 /**
2306 * @param $str string
2307 * @return bool
2308 */
2311 }
2313 /**
2314 * @param $str string
2315 * @return mixed|string
2316 */
2321 // regexp to find first letter in each word (i.e. after each space)
2322 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2324 // function to use to capitalize a single char
2329 $str
2330 );
2335 $str
2336 );
2337 }
2340 }
2341 }
2343 /**
2344 * capitalize words at word breaks
2345 *
2346 * @param $str string
2347 * @return mixed
2348 */
2353 // since \b doesn't work for UTF-8, we explicitely define word break chars
2356 // find first letter after word break
2357 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2363 $str
2364 );
2369 $str
2370 );
2371 }
2376 $str
2377 );
2378 }
2379 }
2381 /**
2382 * Return a case-folded representation of $s
2383 *
2384 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2385 * and $s2 are the same except for the case of their characters. It is not
2386 * necessary for the value returned to make sense when displayed.
2387 *
2388 * Do *not* perform any other normalisation in this function. If a caller
2389 * uses this function when it should be using a more general normalisation
2390 * function, then fix the caller.
2391 *
2392 * @param $s string
2393 *
2394 * @return string
2395 */
2398 }
2400 /**
2401 * @param $s string
2402 * @return string
2403 */
2407 }
2408 # Check for non-UTF-8 URLs
2412 }
2419 }
2422 }
2425 }
2427 /**
2428 * @return array
2429 */
2432 }
2434 /**
2435 * Most writing systems use whitespace to break up words.
2436 * Some languages such as Chinese don't conventionally do this,
2437 * which requires special handling when breaking up words for
2438 * searching etc.
2439 *
2440 * @return bool
2441 */
2444 }
2446 /**
2447 * Some languages such as Chinese require word segmentation,
2448 * Specify such segmentation when overridden in derived class.
2449 *
2450 * @param $string String
2451 * @return String
2452 */
2455 }
2457 /**
2458 * Some languages have special punctuation need to be normalized.
2459 * Make such changes here.
2460 *
2461 * @param $string String
2462 * @return String
2463 */
2466 }
2468 /**
2469 * convert double-width roman characters to single-width.
2470 * range: ff00-ff5f ~= 0020-007f
2471 *
2472 * @param $string string
2473 *
2474 * @return string
2475 */
2485 }
2489 }
2491 /**
2492 * @param $string string
2493 * @param $pattern string
2494 * @return string
2495 */
2500 }
2502 /**
2503 * @param $termsArray array
2504 * @return array
2505 */
2507 # some languages, e.g. Chinese, need to do a conversion
2508 # in order for search results to be displayed correctly
2510 }
2512 /**
2513 * Get the first character of a string.
2514 *
2515 * @param $s string
2516 * @return string
2517 */
2524 $matches
2525 );
2530 }
2532 // Break down Hangul syllables to grab the first jamo
2564 }
2567 }
2568 }
2571 # Some languages may have an alternate char encoding option
2572 # (Esperanto X-coding, Japanese furigana conversion, etc)
2573 # If this language is used as the primary content language,
2574 # an override to the defaults can be set here on startup.
2575 }
2577 /**
2578 * @param $s string
2579 * @return string
2580 */
2582 # For some languages we'll want to explicitly specify
2583 # which characters make it into the edit box raw
2584 # or are converted in some way or another.
2590 }
2591 }
2593 /**
2594 * @param $s string
2595 * @return string
2596 */
2598 # Take the previous into account.
2604 }
2609 }
2610 }
2612 /**
2613 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2614 * also cleans up certain backwards-compatible sequences, converting them
2615 * to the modern Unicode equivalent.
2616 *
2617 * This is language-specific for performance reasons only.
2618 *
2619 * @param $s string
2620 *
2621 * @return string
2622 */
2629 }
2632 }
2634 /**
2635 * Transform a string using serialized data stored in the given file (which
2636 * must be in the serialized subdirectory of $IP). The file contains pairs
2637 * mapping source characters to destination characters.
2638 *
2639 * The data is cached in process memory. This will go faster if you have the
2640 * FastStringSearch extension.
2641 *
2642 * @param $file string
2643 * @param $string string
2644 *
2645 * @throws MWException
2646 * @return string
2647 */
2653 }
2655 }
2657 }
2659 /**
2660 * For right-to-left language support
2661 *
2662 * @return bool
2663 */
2666 }
2668 /**
2669 * Return the correct HTML 'dir' attribute value for this language.
2670 * @return String
2671 */
2674 }
2676 /**
2677 * Return 'left' or 'right' as appropriate alignment for line-start
2678 * for this language's text direction.
2679 *
2680 * Should be equivalent to CSS3 'start' text-align value....
2681 *
2682 * @return String
2683 */
2686 }
2688 /**
2689 * Return 'right' or 'left' as appropriate alignment for line-end
2690 * for this language's text direction.
2691 *
2692 * Should be equivalent to CSS3 'end' text-align value....
2693 *
2694 * @return String
2695 */
2698 }
2700 /**
2701 * A hidden direction mark (LRM or RLM), depending on the language direction.
2702 * Unlike getDirMark(), this function returns the character as an HTML entity.
2703 * This function should be used when the output is guaranteed to be HTML,
2704 * because it makes the output HTML source code more readable. When
2705 * the output is plain text or can be escaped, getDirMark() should be used.
2706 *
2707 * @param $opposite Boolean Get the direction mark opposite to your language
2708 * @return string
2709 * @since 1.20
2710 */
2714 }
2716 /**
2717 * A hidden direction mark (LRM or RLM), depending on the language direction.
2718 * This function produces them as invisible Unicode characters and
2719 * the output may be hard to read and debug, so it should only be used
2720 * when the output is plain text or can be escaped. When the output is
2721 * HTML, use getDirMarkEntity() instead.
2722 *
2723 * @param $opposite Boolean Get the direction mark opposite to your language
2724 * @return string
2725 */
2731 }
2733 /**
2734 * @return array
2735 */
2738 }
2740 /**
2741 * An arrow, depending on the language direction.
2742 *
2743 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2744 * @return string
2745 */
2760 }
2761 }
2763 /**
2764 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2765 *
2766 * @return bool
2767 */
2770 }
2772 /**
2773 * @return array
2774 */
2777 }
2782 }
2787 }
2789 /**
2790 * Fill a MagicWord object with data from here
2791 *
2792 * @param $mw
2793 */
2805 }
2806 }
2813 }
2814 }
2816 /**
2817 * Add magic words to the extension array
2818 *
2819 * @param $newWords array
2820 */
2827 }
2828 }
2829 }
2831 /**
2832 * Get special page names, as an associative array
2833 * case folded alias => real name
2834 */
2836 // Cache aliases because it may be slow to load them
2838 // Initialise array
2843 }
2846 }
2848 /**
2849 * Italic is unsuitable for some languages
2850 *
2851 * @param $text String: the text to be emphasized.
2852 * @return string
2853 */
2856 }
2858 /**
2859 * Normally we output all numbers in plain en_US style, that is
2860 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2861 * point twohundredthirtyfive. However this is not suitable for all
2862 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2863 * Icelandic just want to use commas instead of dots, and dots instead
2864 * of commas like "293.291,235".
2865 *
2866 * An example of this function being called:
2867 * <code>
2868 * wfMessage( 'message' )->numParams( $num )->text()
2869 * </code>
2870 *
2871 * See LanguageGu.php for the Gujarati implementation and
2872 * $separatorTransformTable on MessageIs.php for
2873 * the , => . and . => , implementation.
2874 *
2875 * @todo check if it's viable to use localeconv() for the decimal
2876 * separator thing.
2877 * @param $number Mixed: the string to be formatted, should be an integer
2878 * or a floating point number.
2879 * @param $nocommafy Bool: set to true for special numbers like dates
2880 * @return string
2881 */
2889 }
2890 }
2896 }
2897 }
2900 }
2902 /**
2903 * @param $number string
2904 * @return string
2905 */
2910 }
2915 }
2919 }
2921 /**
2922 * Adds commas to a given number
2923 * @since 1.19
2924 * @param $_ mixed
2925 * @return string
2926 */
2931 }
2934 // default grouping is at thousands, use the same for ###,###,### pattern too.
2937 // Ref: http://cldr.unicode.org/translation/number-patterns
2940 // For negative numbers apply the algorithm like positive number and add sign.
2943 }
2951 // the string does not have any number part. Eg: .12345
2953 }
2961 }
2965 // use the last pattern for the rest of the number
2967 }
2970 }
2971 }
2973 }
2974 }
2975 /**
2976 * @return String
2977 */
2980 }
2982 /**
2983 * @return array
2984 */
2987 }
2989 /**
2990 * @return array
2991 */
2994 }
2996 /**
2997 * Take a list of strings and build a locale-friendly comma-separated
2998 * list, using the local comma-separator message.
2999 * The last two strings are chained with an "and".
3000 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3001 *
3002 * @param $l Array
3003 * @return string
3004 */
3012 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
3018 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
3021 }
3022 }
3024 }
3025 }
3027 /**
3028 * Take a list of strings and build a locale-friendly comma-separated
3029 * list, using the local comma-separator message.
3030 * @param $list array of strings to put in a comma list
3031 * @return string
3032 */
3036 $list
3037 );
3038 }
3040 /**
3041 * Take a list of strings and build a locale-friendly semicolon-separated
3042 * list, using the local semicolon-separator message.
3043 * @param $list array of strings to put in a semicolon list
3044 * @return string
3045 */
3049 $list
3050 );
3051 }
3053 /**
3054 * Same as commaList, but separate it with the pipe instead.
3055 * @param $list array of strings to put in a pipe list
3056 * @return string
3057 */
3061 $list
3062 );
3063 }
3065 /**
3066 * Truncate a string to a specified length in bytes, appending an optional
3067 * string (e.g. for ellipses)
3068 *
3069 * The database offers limited byte lengths for some columns in the database;
3070 * multi-byte character sets mean we need to ensure that only whole characters
3071 * are included, otherwise broken characters can be passed to the user
3072 *
3073 * If $length is negative, the string will be truncated from the beginning
3074 *
3075 * @param $string String to truncate
3076 * @param $length Int: maximum length (including ellipses)
3077 * @param $ellipsis String to append to the truncated text
3078 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3079 * $adjustLength was introduced in 1.18, before that behaved as if false.
3080 * @return string
3081 */
3083 # Use the localized ellipsis character
3086 }
3087 # Check if there is no need to truncate
3092 }
3094 # If ellipsis length is >= $length then we can't apply $adjustLength
3097 # Otherwise, truncate and add ellipsis...
3110 }
3111 }
3112 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3113 # This check is *not* redundant if $adjustLength, due to the single case where
3114 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3119 }
3120 }
3122 /**
3123 * Remove bytes that represent an incomplete Unicode character
3124 * at the end of string (e.g. bytes of the char are missing)
3125 *
3126 * @param $string String
3127 * @return string
3128 */
3134 # We got the first byte only of a multibyte char; remove it.
3139 {
3140 # We chopped in the middle of a character; remove it
3142 }
3143 }
3145 }
3147 /**
3148 * Remove bytes that represent an incomplete Unicode character
3149 * at the start of string (e.g. bytes of the char are missing)
3150 *
3151 * @param $string String
3152 * @return string
3153 */
3158 # We chopped in the middle of a character; remove the whole thing
3160 }
3161 }
3163 }
3165 /**
3166 * Truncate a string of valid HTML to a specified length in bytes,
3167 * appending an optional string (e.g. for ellipses), and return valid HTML
3168 *
3169 * This is only intended for styled/linked text, such as HTML with
3170 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3171 * Also, this will not detect things like "display:none" CSS.
3172 *
3173 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3174 *
3175 * @param string $text HTML string to truncate
3176 * @param int $length (zero/positive) Maximum length (including ellipses)
3177 * @param string $ellipsis String to append to the truncated text
3178 * @return string
3179 */
3181 # Use the localized ellipsis character
3184 }
3185 # Check if there is clearly no need to truncate
3190 }
3204 # Consider truncation once the display length has reached the maximim.
3205 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3206 # Check that we're not in the middle of a bracket/entity...
3210 # Save where we are; we will truncate here unless there turn out to
3211 # be so few remaining characters that truncation is not necessary.
3214 }
3216 # String in fact does need truncation, the truncation point was OK.
3221 }
3222 }
3225 # Read the next char...
3243 }
3249 // Name found (e.g. "<a href=..."), add on tag attributes...
3251 }
3257 }
3260 // Save state without $ch. We want to *hit* the first
3261 // display char (to get tags) but not *use* it if truncating.
3263 }
3268 // Add the next $max display text chars after this in one swoop...
3273 }
3274 }
3275 }
3276 }
3277 // Close the last tag if left unclosed by bad HTML
3281 }
3283 }
3285 /**
3286 * truncateHtml() helper function
3287 * like strcspn() but adds the skipped chars to $ret
3288 *
3289 * @param $ret
3290 * @param $text
3291 * @param $search
3292 * @param $start
3293 * @param $len
3294 * @return int
3295 */
3301 }
3306 }
3308 }
3310 /**
3311 * truncateHtml() helper function
3312 * (a) push or pop $tag from $openTags as needed
3313 * (b) clear $tag value
3314 * @param &$tag string Current HTML tag name we are looking at
3315 * @param $tagType int (0-open tag, 1-close tag)
3316 * @param $lastCh string Character before the '>' that ended this tag
3317 * @param &$openTags array Open tag stack (not accounting for $tag)
3318 */
3327 }
3328 }
3330 }
3331 }
3333 /**
3334 * Grammatical transformations, needed for inflected languages
3335 * Invoked by putting {{grammar:case|word}} in a message
3336 *
3337 * @param $word string
3338 * @param $case string
3339 * @return string
3340 */
3345 }
3347 }
3348 /**
3349 * Get the grammar forms for the content language
3350 * @return array of grammar forms
3351 * @since 1.20
3352 */
3355 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3357 }
3359 }
3360 /**
3361 * Provides an alternative text depending on specified gender.
3362 * Usage {{gender:username|masculine|feminine|neutral}}.
3363 * username is optional, in which case the gender of current user is used,
3364 * but only in (some) interface messages; otherwise default gender is used.
3365 *
3366 * If no forms are given, an empty string is returned. If only one form is
3367 * given, it will be returned unconditionally. These details are implied by
3368 * the caller and cannot be overridden in subclasses.
3369 *
3370 * If more than one form is given, the default is to use the neutral one
3371 * if it is specified, and to use the masculine one otherwise. These
3372 * details can be overridden in subclasses.
3373 *
3374 * @param $gender string
3375 * @param $forms array
3376 *
3377 * @return string
3378 */
3382 }
3386 }
3389 }
3391 }
3393 /**
3394 * Plural form transformations, needed for some languages.
3395 * For example, there are 3 form of plural in Russian and Polish,
3396 * depending on "count mod 10". See [[w:Plural]]
3397 * For English it is pretty simple.
3398 *
3399 * Invoked by putting {{plural:count|wordform1|wordform2}}
3400 * or {{plural:count|wordform1|wordform2|wordform3}}
3401 *
3402 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3403 *
3404 * @param $count Integer: non-localized number
3405 * @param $forms Array: different plural forms
3406 * @return string Correct form of plural for $count in this language
3407 */
3411 }
3415 }
3417 /**
3418 * Checks that convertPlural was given an array and pads it to requested
3419 * amount of forms by copying the last one.
3420 *
3421 * @param $count Integer: How many forms should there be at least
3422 * @param $forms Array of forms given to convertPlural
3423 * @return array Padded array of forms or an exception if not an array
3424 */
3428 }
3430 }
3432 /**
3433 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3434 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3435 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3436 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3437 * match up with it.
3438 *
3439 * @param $str String: the validated block duration in English
3440 * @return string Somehow translated block duration
3441 * @see LanguageFi.php for example implementation
3442 */
3448 }
3449 }
3451 // Since usually only infinite or indefinite is only on list, so try
3452 // equivalents if still here.
3459 }
3460 }
3461 }
3462 // If all else fails, return the original string.
3464 }
3466 /**
3467 * languages like Chinese need to be segmented in order for the diff
3468 * to be of any use
3469 *
3470 * @param $text String
3471 * @return String
3472 */
3475 }
3477 /**
3478 * and unsegment to show the result
3479 *
3480 * @param $text String
3481 * @return String
3482 */
3485 }
3487 /**
3488 * Return the LanguageConverter used in the Language
3489 *
3490 * @since 1.19
3491 * @return LanguageConverter
3492 */
3495 }
3497 /**
3498 * convert text to all supported variants
3499 *
3500 * @param $text string
3501 * @return array
3502 */
3505 }
3507 /**
3508 * convert text to different variants of a language.
3509 *
3510 * @param $text string
3511 * @return string
3512 */
3515 }
3517 /**
3518 * Convert a Title object to a string in the preferred variant
3519 *
3520 * @param $title Title
3521 * @return string
3522 */
3525 }
3527 /**
3528 * Check if this is a language with variants
3529 *
3530 * @return bool
3531 */
3534 }
3536 /**
3537 * Check if the language has the specific variant
3538 *
3539 * @since 1.19
3540 * @param $variant string
3541 * @return bool
3542 */
3545 }
3547 /**
3548 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3549 *
3550 * @param $text string
3551 * @return string
3552 */
3555 }
3557 /**
3558 * Perform output conversion on a string, and encode for safe HTML output.
3559 * @param $text String text to be converted
3560 * @param $isTitle Bool whether this conversion is for the article title
3561 * @return string
3562 * @todo this should get integrated somewhere sane
3563 */
3566 }
3568 /**
3569 * @param $key string
3570 * @return string
3571 */
3574 }
3576 /**
3577 * Get the list of variants supported by this language
3578 * see sample implementation in LanguageZh.php
3579 *
3580 * @return array an array of language codes
3581 */
3584 }
3586 /**
3587 * @return string
3588 */
3591 }
3593 /**
3594 * @return string
3595 */
3598 }
3600 /**
3601 * @return string
3602 */
3605 }
3607 /**
3608 * If a language supports multiple variants, it is
3609 * possible that non-existing link in one variant
3610 * actually exists in another variant. this function
3611 * tries to find it. See e.g. LanguageZh.php
3612 *
3613 * @param $link String: the name of the link
3614 * @param $nt Mixed: the title object of the link
3615 * @param $ignoreOtherCond Boolean: to disable other conditions when
3616 * we need to transclude a template or update a category's link
3617 * @return null the input parameters may be modified upon return
3618 */
3621 }
3623 /**
3624 * If a language supports multiple variants, converts text
3625 * into an array of all possible variants of the text:
3626 * 'variant' => text in that variant
3627 *
3628 * @deprecated since 1.17 Use autoConvertToAllVariants()
3629 *
3630 * @param $text string
3631 *
3632 * @return string
3633 */
3636 }
3638 /**
3639 * returns language specific options used by User::getPageRenderHash()
3640 * for example, the preferred language variant
3641 *
3642 * @return string
3643 */
3646 }
3648 /**
3649 * For languages that support multiple variants, the title of an
3650 * article may be displayed differently in different variants. this
3651 * function returns the apporiate title defined in the body of the article.
3652 *
3653 * @return string
3654 */
3657 }
3659 /**
3660 * Enclose a string with the "no conversion" tag. This is used by
3661 * various functions in the Parser
3662 *
3663 * @param $text String: text to be tagged for no conversion
3664 * @param $noParse bool
3665 * @return string the tagged text
3666 */
3669 }
3671 /**
3672 * A regular expression to match legal word-trailing characters
3673 * which should be merged onto a link of the form [[foo]]bar.
3674 *
3675 * @return string
3676 */
3679 }
3681 /**
3682 * @return Language
3683 */
3686 }
3688 /**
3689 * Get the RFC 3066 code for this language object
3690 *
3691 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3692 * htmlspecialchars() or similar
3693 *
3694 * @return string
3695 */
3698 }
3700 /**
3701 * Get the code in Bcp47 format which we can use
3702 * inside of html lang="" tags.
3703 *
3704 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3705 * htmlspecialchars() or similar.
3706 *
3707 * @since 1.19
3708 * @return string
3709 */
3713 }
3715 }
3717 /**
3718 * @param $code string
3719 */
3722 // Ensure we don't leave an incorrect html code lying around
3724 }
3726 /**
3727 * Get the name of a file for a certain language code
3728 * @param $prefix string Prepend this to the filename
3729 * @param $code string Language code
3730 * @param $suffix string Append this to the filename
3731 * @throws MWException
3732 * @return string $prefix . $mangledCode . $suffix
3733 */
3735 // Protect against path traversal
3738 {
3740 }
3743 }
3745 /**
3746 * Get the language code from a file name. Inverse of getFileName()
3747 * @param $filename string $prefix . $languageCode . $suffix
3748 * @param $prefix string Prefix before the language code
3749 * @param $suffix string Suffix after the language code
3750 * @return string Language code, or false if $prefix or $suffix isn't found
3751 */
3752 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3758 }
3760 }
3762 /**
3763 * @param $code string
3764 * @return string
3765 */
3771 }
3773 /**
3774 * @param $code string
3775 * @return string
3776 */
3780 }
3782 /**
3783 * Get the first fallback for a given language.
3784 *
3785 * @param $code string
3786 *
3787 * @return bool|string
3788 */
3796 }
3797 }
3799 /**
3800 * Get the ordered list of fallback languages.
3801 *
3802 * @since 1.19
3803 * @param $code string Language code
3804 * @return array
3805 */
3814 }
3816 }
3817 }
3819 /**
3820 * Get all messages for a given language
3821 * WARNING: this may take a long time. If you just need all message *keys*
3822 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3823 *
3824 * @param $code string
3825 *
3826 * @return array
3827 */
3830 }
3832 /**
3833 * Get a message for a given language
3834 *
3835 * @param $key string
3836 * @param $code string
3837 *
3838 * @return string
3839 */
3842 }
3844 /**
3845 * Get all message keys for a given language. This is a faster alternative to
3846 * array_keys( Language::getMessagesFor( $code ) )
3847 *
3848 * @since 1.19
3849 * @param $code string Language code
3850 * @return array of message keys (strings)
3851 */
3854 }
3856 /**
3857 * @param $talk
3858 * @return mixed
3859 */
3863 }
3868 # Allow grammar transformations
3869 # Allowing full message-style parsing would make simple requests
3870 # such as action=raw much more expensive than they need to be.
3871 # This will hopefully cover most cases.
3875 }
3877 /**
3878 * @param $m string
3879 * @return string
3880 */
3883 }
3885 /**
3886 * @throws MWException
3887 * @return array
3888 */
3893 }
3900 }
3905 }
3907 /**
3908 * Decode an expiry (block, protection, etc) which has come from the DB
3909 *
3910 * @todo FIXME: why are we returnings DBMS-dependent strings???
3911 *
3912 * @param $expiry String: Database expiry String
3913 * @param $format Bool|Int true to process using language functions, or TS_ constant
3914 * to return the expiry in a given timestamp
3915 * @return String
3916 * @since 1.18
3917 */
3923 }
3927 ? $infinityMsg
3933 }
3934 }
3936 /**
3937 * @todo Document
3938 * @param $seconds int|float
3939 * @param $format Array Optional
3940 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
3941 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
3942 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
3943 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
3944 * @return string
3945 */
3949 }
3952 }
3955 }
3977 }
3988 }
3992 }
3998 }
4006 }
4016 }
4020 }
4030 }
4031 }
4033 }
4035 /**
4036 * Format a bitrate for output, using an appropriate
4037 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4038 *
4039 * This use base 1000. For base 1024 use formatSize(), for another base
4040 * see formatComputingNumbers()
4041 *
4042 * @param $bps int
4043 * @return string
4044 */
4047 }
4049 /**
4050 * @param $size int Size of the unit
4051 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4052 * @param $messageKey string Message key to be uesd
4053 * @return string
4054 */
4059 );
4060 }
4068 }
4070 // For small sizes no decimal places necessary
4073 // For MB and bigger two decimal places are smarter
4075 }
4081 }
4083 /**
4084 * Format a size in bytes for output, using an appropriate
4085 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4086 *
4087 * This method use base 1024. For base 1000 use formatBitrate(), for
4088 * another base see formatComputingNumbers()
4089 *
4090 * @param $size int Size to format
4091 * @return string Plain text (not HTML)
4092 */
4095 }
4097 /**
4098 * Make a list item, used by various special pages
4099 *
4100 * @param $page String Page link
4101 * @param $details String Text between brackets
4102 * @param $oppositedm Boolean Add the direction mark opposite to your
4103 * language, to display text properly
4104 * @return String
4105 */
4112 }
4114 /**
4115 * Generate (prev x| next x) (20|50|100...) type links for paging
4116 *
4117 * @param $title Title object to link
4118 * @param $offset Integer offset parameter
4119 * @param $limit Integer limit parameter
4120 * @param $query array|String optional URL query parameter string
4121 * @param $atend Bool optional param for specified if this is the last page
4122 * @return String
4123 */
4124 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4125 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4127 # Make 'previous' link
4128 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4134 }
4136 # Make 'next' link
4137 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4143 }
4145 # Make links to set number of items per page
4150 }
4154 }
4156 /**
4157 * Helper function for viewPrevNext() that generates links
4158 *
4159 * @param $title Title object to link
4160 * @param $offset Integer offset parameter
4161 * @param $limit Integer limit parameter
4162 * @param $query Array extra query parameters
4163 * @param $link String text to use for the link; will be escaped
4164 * @param $tooltipMsg String name of the message to use as tooltip
4165 * @param $class String value of the "class" attribute of the link
4166 * @return String HTML fragment
4167 */
4168 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4170 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4173 }
4175 /**
4176 * Get the conversion rule title, if any.
4177 *
4178 * @return string
4179 */
4182 }
4184 /**
4185 * Get the compiled plural rules for the language
4186 * @since 1.20
4187 * @return array Associative array with plural form, and plural rule as key-value pairs
4188 */
4194 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4197 }
4198 }
4199 }
4201 }
4203 /**
4204 * Get the plural rules for the language
4205 * @since 1.20
4206 * @return array Associative array with plural form, and plural rule as key-value pairs
4207 */
4216 }
4217 }
4218 }
4220 }
4222 /**
4223 * Find the plural form matching to the given number
4224 * It return the form index.
4225 * @return int The index of the plural form
4226 */
4231 }
4233 }