| blob | 57d456a6d76365e1972f0851ed121de430415f42 |
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 */
47 /**
48 * @var Language
49 */
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 or new language object for a given language code
175 * @param $code String
176 * @return Language
177 */
183 }
185 // get the language object to process
190 // merge the language object in to get it up front in the cache
192 // get rid of the oldest ones in case we have an overflow
196 }
198 /**
199 * Create a language object for a given language code
200 * @param $code String
201 * @throws MWException
202 * @return Language
203 */
205 // Protect against path traversal below
208 {
210 }
213 // It's not possible to customise this code with class files, so
214 // just return a Language object. This is to support uselang= hacks.
218 }
220 // Check if there is a language class for the code
226 }
228 // Keep trying the fallback list until we find an existing class
233 }
241 }
242 }
245 }
247 /**
248 * Checks whether any localisation is available for that language tag
249 * in MediaWiki (MessagesXx.php exists).
250 *
251 * @param string $code Language tag (in lower case)
252 * @return bool Whether language is supported
253 * @since 1.21
254 */
257 }
259 /**
260 * Returns true if a language code string is a well-formed language tag
261 * according to RFC 5646.
262 * This function only checks well-formedness; it doesn't check that
263 * language, script or variant codes actually exist in the repositories.
264 *
265 * Based on regexes by Mark Davis of the Unicode Consortium:
266 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
267 *
268 * @param $code string
269 * @param $lenient boolean Whether to allow '_' as separator. The default is only '-'.
270 *
271 * @return bool
272 * @since 1.21
273 */
289 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
290 # Since these are limited, this is safe even later changes to the registry --
291 # the only oddity is that it might change the type of the tag, and thus
292 # the results from the capturing groups.
293 # http://www.iana.org/assignments/language-subtag-registry
311 # The final breakdown, with capturing groups for each of these components
312 # The variants, extensions, grandfathered, and private-use may have interior '-'
317 }
319 /**
320 * Returns true if a language code string is of a valid form, whether or
321 * not it exists. This includes codes which are used solely for
322 * customisation via the MediaWiki namespace.
323 *
324 * @param $code string
325 *
326 * @return bool
327 */
329 return
330 // People think language codes are html safe, so enforce it.
331 // Ideally we should only allow a-zA-Z0-9-
332 // but, .+ and other chars are often used for {{int:}} hacks
333 // see bugs 37564, 37587, 36938
336 }
338 /**
339 * Returns true if a language code is of a valid form for the purposes of
340 * internal customisation of MediaWiki, via Messages*.php.
341 *
342 * @param $code string
343 *
344 * @throws MWException
345 * @since 1.18
346 * @return bool
347 */
355 }
358 }
361 }
363 /**
364 * Returns true if a language code is an IETF tag known to MediaWiki.
365 *
366 * @param $code string
367 *
368 * @since 1.21
369 * @return bool
370 */
376 }
380 ) {
382 }
385 }
387 /**
388 * @param $code
389 * @return String Name of the language class
390 */
396 }
397 }
399 /**
400 * Includes language class files
401 *
402 * @param $class string Name of the language class
403 */
409 }
414 }
415 }
416 }
418 /**
419 * Get the LocalisationCache instance
420 *
421 * @return LocalisationCache
422 */
428 }
430 }
434 // Set the code to the name of the descendant
439 }
441 }
443 /**
444 * Reduce memory usage
445 */
449 }
450 }
452 /**
453 * Hook which will be called if this is the content language.
454 * Descendants can use this to register hook functions or modify globals
455 */
458 /**
459 * Same as getFallbacksFor for current language.
460 * @return array|bool
461 * @deprecated in 1.19
462 */
466 }
468 /**
469 * @return array
470 * @since 1.19
471 */
474 }
476 /**
477 * Exports $wgBookstoreListEn
478 * @return array
479 */
482 }
484 /**
485 * @return array
486 */
503 }
505 # Sometimes a language will be localised but not actually exist on this wiki.
509 }
510 }
512 # The above mixing may leave namespaces out of canonical order.
513 # Re-order by namespace ID number...
517 }
519 }
521 /**
522 * Arbitrarily set all of the namespace names at once. Mainly used for testing
523 * @param $namespaces Array of namespaces (id => name)
524 */
528 }
530 /**
531 * Resets all of the namespace caches. Mainly used for testing
532 */
537 }
539 /**
540 * A convenience function that returns the same thing as
541 * getNamespaces() except with the array values changed to ' '
542 * where it found '_', useful for producing output to be displayed
543 * e.g. in <select> forms.
544 *
545 * @return array
546 */
551 }
553 }
555 /**
556 * Get a namespace value by key
557 * <code>
558 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
559 * echo $mw_ns; // prints 'MediaWiki'
560 * </code>
561 *
562 * @param $index Int: the array key of the namespace to return
563 * @return mixed, string if the namespace value exists, otherwise false
564 */
568 }
570 /**
571 * A convenience function that returns the same thing as
572 * getNsText() except with '_' changed to ' ', useful for
573 * producing output.
574 *
575 * <code>
576 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
577 * echo $mw_ns; // prints 'MediaWiki talk'
578 * </code>
579 *
580 * @param int $index The array key of the namespace to return
581 * @return string Namespace name without underscores (empty string if namespace does not exist)
582 */
586 }
588 /**
589 * Returns gender-dependent namespace alias if available.
590 * @param $index Int: namespace index
591 * @param $gender String: gender key (male, female... )
592 * @return String
593 * @since 1.18
594 */
598 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
600 }
602 /**
603 * Whether this language makes distinguishes genders for example in
604 * namespaces.
605 * @return bool
606 * @since 1.18
607 */
611 // $wgExtraGenderNamespaces overrides everything
613 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
614 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
615 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
618 // Check what is in i18n files
621 }
622 }
624 /**
625 * Get a namespace key by value, case insensitive.
626 * Only matches namespace names for the current language, not the
627 * canonical ones defined in Namespace.php.
628 *
629 * @param $text String
630 * @return mixed An integer if $text is a valid value otherwise false
631 */
636 }
638 /**
639 * @return array
640 */
652 }
653 }
654 }
657 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
661 }
662 }
665 }
667 }
669 /**
670 * @return array
671 */
675 # Put namespace names and aliases into a hashtable.
676 # If this is too slow, then we should arrange it so that it is done
677 # before caching. The catch is that at pre-cache time, the above
678 # class-specific fixup hasn't been done.
682 }
685 }
689 }
690 }
691 }
693 }
695 /**
696 * Get a namespace key by value, case insensitive. Canonical namespace
697 * names override custom ones defined for the current language.
698 *
699 * @param $text String
700 * @return mixed An integer if $text is a valid value otherwise false
701 */
707 }
710 }
712 /**
713 * short names for language variants used for language conversion links.
714 *
715 * @param $code String
716 * @param $usemsg bool Use the "variantname-xyz" message if it exists
717 * @return string
718 */
723 }
728 # otherwise, output the language code
730 }
731 }
733 /**
734 * @param $name string
735 * @return string
736 */
741 }
743 }
745 /**
746 * @return array
747 */
756 );
757 }
759 /**
760 * @return array
761 */
764 }
766 /**
767 * @return array
768 */
771 }
773 /**
774 * @return array|string
775 */
783 }
784 }
786 /**
787 * @return array
788 */
791 }
793 /**
794 * @param $image
795 * @return array|null
796 */
799 }
801 /**
802 * @return array
803 */
806 }
808 /**
809 * @param $tog
810 * @return string
811 */
814 }
816 /**
817 * Get native language names, indexed by code.
818 * Only those defined in MediaWiki, no other data like CLDR.
819 * If $customisedOnly is true, only returns codes with a messages file
820 *
821 * @param $customisedOnly bool
822 *
823 * @return array
824 * @deprecated in 1.20, use fetchLanguageNames()
825 */
828 }
830 /**
831 * Get translated language names. This is done on best effort and
832 * by default this is exactly the same as Language::getLanguageNames.
833 * The CLDR extension provides translated names.
834 * @param $code String Language code.
835 * @return Array language code => language name
836 * @since 1.18.0
837 * @deprecated in 1.20, use fetchLanguageNames()
838 */
841 }
843 /**
844 * Get an array of language names, indexed by code.
845 * @param $inLanguage null|string: Code of language in which to return the names
846 * Use null for autonyms (native names)
847 * @param $include string:
848 * 'all' all available languages
849 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
850 * 'mwfile' only if the language is in 'mw' *and* has a message file
851 * @return array: language code => language name
852 * @since 1.20
853 */
860 }
865 # TODO: also include when $inLanguage is null, when this code is more efficient
867 }
871 # - Prefer own MediaWiki native name when not using the hook
872 # - For other names just add if not added through the hook
875 }
876 }
880 }
886 }
890 # We do this using a foreach over the codes instead of a directory
891 # loop so that messages files in extensions will work correctly.
895 }
896 }
898 }
899 # 'mw' option; default if it's not one of the other two options (all/mwfile)
901 }
903 /**
904 * @param $code string: The code of the language for which to get the name
905 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
906 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
907 * @return string: Language name or empty
908 * @since 1.20
909 */
913 }
915 /**
916 * Get a message from the MediaWiki namespace.
917 *
918 * @param $msg String: message name
919 * @return string
920 */
923 }
925 /**
926 * Get the native language name of $code.
927 * Only if defined in MediaWiki, no other data like CLDR.
928 * @param $code string
929 * @return string
930 * @deprecated in 1.20, use fetchLanguageName()
931 */
934 }
936 /**
937 * @param $key string
938 * @return string
939 */
942 }
944 /**
945 * @return array
946 */
951 }
953 }
955 /**
956 * @param $key string
957 * @return string
958 */
961 }
963 /**
964 * @param $key string
965 * @return string
966 */
969 }
971 /**
972 * @return array
973 */
978 }
980 }
982 /**
983 * @param $key string
984 * @return string
985 */
988 }
990 /**
991 * @param $key string
992 * @return string
993 */
996 }
998 /**
999 * @param $key string
1000 * @return string
1001 */
1004 }
1006 /**
1007 * @param $key string
1008 * @return string
1009 */
1012 }
1014 /**
1015 * @param $key string
1016 * @return string
1017 */
1020 }
1022 /**
1023 * @param $key string
1024 * @return string
1025 */
1028 }
1030 /**
1031 * This is a workalike of PHP's date() function, but with better
1032 * internationalisation, a reduced set of format characters, and a better
1033 * escaping format.
1034 *
1035 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
1036 * PHP manual for definitions. There are a number of extensions, which
1037 * start with "x":
1038 *
1039 * xn Do not translate digits of the next numeric format character
1040 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1041 * xr Use roman numerals for the next numeric format character
1042 * xh Use hebrew numerals for the next numeric format character
1043 * xx Literal x
1044 * xg Genitive month name
1045 *
1046 * xij j (day number) in Iranian calendar
1047 * xiF F (month name) in Iranian calendar
1048 * xin n (month number) in Iranian calendar
1049 * xiy y (two digit year) in Iranian calendar
1050 * xiY Y (full year) in Iranian calendar
1051 *
1052 * xjj j (day number) in Hebrew calendar
1053 * xjF F (month name) in Hebrew calendar
1054 * xjt t (days in month) in Hebrew calendar
1055 * xjx xg (genitive month name) in Hebrew calendar
1056 * xjn n (month number) in Hebrew calendar
1057 * xjY Y (full year) in Hebrew calendar
1058 *
1059 * xmj j (day number) in Hijri calendar
1060 * xmF F (month name) in Hijri calendar
1061 * xmn n (month number) in Hijri calendar
1062 * xmY Y (full year) in Hijri calendar
1063 *
1064 * xkY Y (full year) in Thai solar calendar. Months and days are
1065 * identical to the Gregorian calendar
1066 * xoY Y (full year) in Minguo calendar or Juche year.
1067 * Months and days are identical to the
1068 * Gregorian calendar
1069 * xtY Y (full year) in Japanese nengo. Months and days are
1070 * identical to the Gregorian calendar
1071 *
1072 * Characters enclosed in double quotes will be considered literal (with
1073 * the quotes themselves removed). Unmatched quotes will be considered
1074 * literal quotes. Example:
1075 *
1076 * "The month is" F => The month is January
1077 * i's" => 20'11"
1078 *
1079 * Backslash escaping is also supported.
1080 *
1081 * Input timestamp is assumed to be pre-normalized to the desired local
1082 * time zone, if any.
1083 *
1084 * @param $format String
1085 * @param $ts String: 14-character timestamp
1086 * YYYYMMDDHHMMSS
1087 * 01234567890123
1088 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1089 *
1090 * @return string
1091 */
1110 }
1112 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1114 }
1152 }
1158 }
1164 }
1170 }
1176 }
1183 }
1189 }
1195 }
1204 }
1210 }
1216 }
1231 }
1237 }
1243 }
1249 }
1255 }
1261 }
1267 }
1276 }
1282 }
1288 }
1294 }
1300 }
1306 }
1315 }
1347 }
1353 }
1359 }
1363 # Backslash escaping
1368 }
1371 # Quoted literal
1375 # No terminating quote, assume literal "
1380 }
1382 # Quote at end of string, assume literal "
1384 }
1388 }
1401 }
1402 }
1403 }
1405 }
1410 /**
1411 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1412 * Gregorian dates to Iranian dates. Originally written in C, it
1413 * is released under the terms of GNU Lesser General Public
1414 * License. Conversion to PHP was performed by Niklas Laxström.
1415 *
1416 * Link: http://www.farsiweb.info/jalali/jalali.c
1417 *
1418 * @param $ts string
1419 *
1420 * @return string
1421 */
1427 # Days passed from the beginning (including leap years)
1433 // Add days of the past months of this year
1436 }
1438 // Leap years
1441 }
1443 // Days passed in current month
1457 }
1461 }
1467 }
1469 /**
1470 * Converting Gregorian dates to Hijri dates.
1471 *
1472 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1473 *
1474 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1475 *
1476 * @param $ts string
1477 *
1478 * @return string
1479 */
1493 )
1494 {
1502 }
1507 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1508 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1514 }
1516 /**
1517 * Converting Gregorian dates to Hebrew dates.
1518 *
1519 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1520 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1521 * to translate the relevant functions into PHP and release them under
1522 * GNU GPL.
1523 *
1524 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1525 * and Adar II is 14. In a non-leap year, Adar is 6.
1526 *
1527 * @param $ts string
1528 *
1529 * @return string
1530 */
1532 # Parse date
1537 # Calculate Hebrew year
1540 # Month number when September = 1, August = 12
1543 # Next year
1547 }
1549 # Calculate day of year from 1 September
1553 # February
1555 # Check if the year is leap
1558 }
1563 }
1564 }
1566 # Calculate the start of the Hebrew year
1569 # Calculate next year's start
1571 # Day is before the start of the year - it is the previous year
1572 # Next year's start
1574 # Previous year
1577 # Add days since previous year's 1 September
1580 # Leap year
1582 }
1583 # Start of the new (previous) year
1586 # Next year's start
1588 }
1590 # Calculate Hebrew day of year
1593 # Difference between year's days
1595 # Add 12 (or 13 for leap years) days to ignore the difference between
1596 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1597 # difference is only about the year type
1602 }
1604 # Check the year pattern, and is leap year
1605 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1606 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1607 # and non-leap years
1609 # Check if leap year
1612 # Calculate day in the month from number of day in the Hebrew year
1613 # Don't check Adar - if the day is not in Adar, we will stop before;
1614 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1619 # Calculate days in this month
1621 # Adar in a leap year
1623 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1626 # Day in Adar I
1629 # Subtract the days of Adar I
1631 # Try Adar II
1634 # Day in Adar II
1636 }
1637 }
1638 }
1640 # Cheshvan in a complete year (otherwise as the rule below)
1643 # Kislev in an incomplete year (otherwise as the rule below)
1646 # Odd months have 30 days, even have 29
1648 }
1650 # In the current month
1653 # Subtract the days of the current month
1655 # Try in the next month
1657 }
1658 }
1661 }
1663 /**
1664 * This calculates the Hebrew year start, as days since 1 September.
1665 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1666 * Used for Hebrew date.
1667 *
1668 * @param $year int
1669 *
1670 * @return string
1671 */
1678 }
1682 }
1692 }
1696 }
1698 /**
1699 * Algorithm to convert Gregorian dates to Thai solar dates,
1700 * Minguo dates or Minguo dates.
1701 *
1702 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1703 * http://en.wikipedia.org/wiki/Minguo_calendar
1704 * http://en.wikipedia.org/wiki/Japanese_era_name
1705 *
1706 * @param $ts String: 14-character timestamp
1707 * @param $cName String: calender name
1708 * @return Array: converted year, month, day
1709 */
1716 # Thai solar dates
1717 # Add 543 years to the Gregorian calendar
1718 # Months and days are identical
1721 # Minguo dates
1722 # Deduct 1911 years from the Gregorian calendar
1723 # Months and days are identical
1726 # Nengō dates up to Meiji period
1727 # Deduct years from the Gregorian calendar
1728 # depending on the nengo periods
1729 # Months and days are identical
1730 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1731 # Meiji period
1736 }
1744 )
1745 {
1746 # Taishō period
1751 }
1757 )
1758 {
1759 # Shōwa period
1764 }
1767 # Heisei period
1772 }
1774 }
1777 }
1780 }
1782 /**
1783 * Roman number formatting up to 10000
1784 *
1785 * @param $num int
1786 *
1787 * @return string
1788 */
1794 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1795 );
1800 }
1806 }
1808 }
1810 }
1812 /**
1813 * Hebrew Gematria number formatting up to 9999
1814 *
1815 * @param $num int
1816 *
1817 * @return string
1818 */
1825 );
1830 }
1842 }
1843 }
1844 }
1846 }
1852 }
1871 }
1873 }
1875 /**
1876 * Used by date() and time() to adjust the time output.
1877 *
1878 * @param $ts Int the time in date('YmdHis') format
1879 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1880 * get user timecorrection setting)
1881 * @return int
1882 */
1888 }
1901 }
1902 # Unrecognized timezone, default to 'Offset' with the stored offset.
1904 }
1908 # Global offset in minutes.
1911 }
1922 }
1925 }
1926 }
1928 # No difference ? Return time unchanged
1931 }
1934 # Generate an adjusted date; take advantage of the fact that mktime
1935 # will normalize out-of-range values so we don't have to split $minDiff
1936 # into hours and minutes.
1949 }
1951 /**
1952 * This is meant to be used by time(), date(), and timeanddate() to get
1953 * the date preference they're supposed to use, it should be used in
1954 * all children.
1955 *
1956 *<code>
1957 * function timeanddate([...], $format = true) {
1958 * $datePreference = $this->dateFormat($format);
1959 * [...]
1960 * }
1961 *</code>
1962 *
1963 * @param $usePrefs Mixed: if true, the user's preference is used
1964 * if false, the site/language default is used
1965 * if int/string, assumed to be a format.
1966 * @return string
1967 */
1976 }
1979 }
1981 // return int
1984 }
1987 }
1989 /**
1990 * Get a format string for a given type and preference
1991 * @param $type string May be date, time or both
1992 * @param $pref string The format name as it appears in Messages*.php
1993 *
1994 * @return string
1995 */
2006 }
2007 }
2009 }
2011 }
2013 /**
2014 * @param $ts Mixed: the time format which needs to be turned into a
2015 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2016 * @param $adj Bool: whether to adjust the time output according to the
2017 * user configured offset ($timecorrection)
2018 * @param $format Mixed: true to use user's date format preference
2019 * @param $timecorrection String|bool the time offset as returned by
2020 * validateTimeZone() in Special:Preferences
2021 * @return string
2022 */
2027 }
2030 }
2032 /**
2033 * @param $ts Mixed: the time format which needs to be turned into a
2034 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2035 * @param $adj Bool: whether to adjust the time output according to the
2036 * user configured offset ($timecorrection)
2037 * @param $format Mixed: true to use user's date format preference
2038 * @param $timecorrection String|bool the time offset as returned by
2039 * validateTimeZone() in Special:Preferences
2040 * @return string
2041 */
2046 }
2049 }
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 $adj Bool: whether to adjust the time output according to the
2055 * user configured offset ($timecorrection)
2056 * @param $format Mixed: what format to return, if it's false output the
2057 * default one (default true)
2058 * @param $timecorrection String|bool the time offset as returned by
2059 * validateTimeZone() in Special:Preferences
2060 * @return string
2061 */
2066 }
2069 }
2071 /**
2072 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2073 *
2074 * @since 1.20
2075 *
2076 * @param integer $seconds The amount of seconds.
2077 * @param array $chosenIntervals The intervals to enable.
2078 *
2079 * @return string
2080 */
2089 }
2092 }
2094 /**
2095 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2096 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2097 *
2098 * @since 1.20
2099 *
2100 * @param integer $seconds The amount of seconds.
2101 * @param array $chosenIntervals The intervals to enable.
2102 *
2103 * @return array
2104 */
2107 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2108 }
2122 }
2123 }
2126 }
2128 /**
2129 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2130 *
2131 * @param $type String: can be 'date', 'time' or 'both'
2132 * @param $ts Mixed: the time format which needs to be turned into a
2133 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2134 * @param $user User object used to get preferences for timezone and format
2135 * @param $options Array, can contain the following keys:
2136 * - 'timecorrection': time correction, can have the following values:
2137 * - true: use user's preference
2138 * - false: don't use time correction
2139 * - integer: value of time correction in minutes
2140 * - 'format': format to use, can have the following values:
2141 * - true: use user's preference
2142 * - false: use default preference
2143 * - string: format to use
2144 * @since 1.19
2145 * @return String
2146 */
2155 }
2157 }
2162 }
2165 }
2167 /**
2168 * Get the formatted date for the given timestamp and formatted for
2169 * the given user.
2170 *
2171 * @param $ts Mixed: the time format which needs to be turned into a
2172 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2173 * @param $user User object used to get preferences for timezone and format
2174 * @param $options Array, can contain the following keys:
2175 * - 'timecorrection': time correction, can have the following values:
2176 * - true: use user's preference
2177 * - false: don't use time correction
2178 * - integer: value of time correction in minutes
2179 * - 'format': format to use, can have the following values:
2180 * - true: use user's preference
2181 * - false: use default preference
2182 * - string: format to use
2183 * @since 1.19
2184 * @return String
2185 */
2188 }
2190 /**
2191 * Get the formatted time for the given timestamp and formatted for
2192 * the given user.
2193 *
2194 * @param $ts Mixed: the time format which needs to be turned into a
2195 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2196 * @param $user User object used to get preferences for timezone and format
2197 * @param $options Array, can contain the following keys:
2198 * - 'timecorrection': time correction, can have the following values:
2199 * - true: use user's preference
2200 * - false: don't use time correction
2201 * - integer: value of time correction in minutes
2202 * - 'format': format to use, can have the following values:
2203 * - true: use user's preference
2204 * - false: use default preference
2205 * - string: format to use
2206 * @since 1.19
2207 * @return String
2208 */
2211 }
2213 /**
2214 * Get the formatted date and time for the given timestamp and formatted for
2215 * the given user.
2216 *
2217 * @param $ts Mixed: the time format which needs to be turned into a
2218 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2219 * @param $user User object used to get preferences for timezone and format
2220 * @param $options Array, can contain the following keys:
2221 * - 'timecorrection': time correction, can have the following values:
2222 * - true: use user's preference
2223 * - false: don't use time correction
2224 * - integer: value of time correction in minutes
2225 * - 'format': format to use, can have the following values:
2226 * - true: use user's preference
2227 * - false: use default preference
2228 * - string: format to use
2229 * @since 1.19
2230 * @return String
2231 */
2234 }
2236 /**
2237 * @param $key string
2238 * @return array|null
2239 */
2242 }
2244 /**
2245 * @return array
2246 */
2249 }
2251 /**
2252 * @param $in
2253 * @param $out
2254 * @param $string
2255 * @return string
2256 */
2258 # This is a wrapper for iconv in all languages except esperanto,
2259 # which does some nasty x-conversions beforehand
2261 # Even with //IGNORE iconv can whine about illegal characters in
2262 # *input* string. We just ignore those too.
2263 # REF: http://bugs.php.net/bug.php?id=37166
2264 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2269 }
2271 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2273 /**
2274 * @param $matches array
2275 * @return mixed|string
2276 */
2279 }
2281 /**
2282 * @param $matches array
2283 * @return string
2284 */
2287 }
2289 /**
2290 * @param $matches array
2291 * @return string
2292 */
2296 }
2298 /**
2299 * @param $matches array
2300 * @return string
2301 */
2305 }
2307 /**
2308 * @param $matches array
2309 * @return string
2310 */
2313 }
2315 /**
2316 * @param $matches array
2317 * @return string
2318 */
2322 }
2324 /**
2325 * Make a string's first character uppercase
2326 *
2327 * @param $str string
2328 *
2329 * @return string
2330 */
2338 // fall back to more complex logic in case of multibyte strings
2340 }
2341 }
2343 /**
2344 * Convert a string to uppercase
2345 *
2346 * @param $str string
2347 * @param $first bool
2348 *
2349 * @return string
2350 */
2358 }
2361 }
2368 $str
2369 );
2372 }
2373 }
2374 }
2376 /**
2377 * @param $str string
2378 * @return mixed|string
2379 */
2391 }
2392 }
2394 /**
2395 * @param $str string
2396 * @param $first bool
2397 * @return mixed|string
2398 */
2406 }
2409 }
2416 $str
2417 );
2420 }
2421 }
2422 }
2424 /**
2425 * @param $str string
2426 * @return bool
2427 */
2430 }
2432 /**
2433 * @param $str string
2434 * @return mixed|string
2435 */
2440 // regexp to find first letter in each word (i.e. after each space)
2441 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2443 // function to use to capitalize a single char
2448 $str
2449 );
2454 $str
2455 );
2456 }
2459 }
2460 }
2462 /**
2463 * capitalize words at word breaks
2464 *
2465 * @param $str string
2466 * @return mixed
2467 */
2472 // since \b doesn't work for UTF-8, we explicitely define word break chars
2475 // find first letter after word break
2476 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2482 $str
2483 );
2488 $str
2489 );
2490 }
2495 $str
2496 );
2497 }
2498 }
2500 /**
2501 * Return a case-folded representation of $s
2502 *
2503 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2504 * and $s2 are the same except for the case of their characters. It is not
2505 * necessary for the value returned to make sense when displayed.
2506 *
2507 * Do *not* perform any other normalisation in this function. If a caller
2508 * uses this function when it should be using a more general normalisation
2509 * function, then fix the caller.
2510 *
2511 * @param $s string
2512 *
2513 * @return string
2514 */
2517 }
2519 /**
2520 * @param $s string
2521 * @return string
2522 */
2526 }
2529 }
2532 }
2534 /**
2535 * @return array
2536 */
2539 }
2541 /**
2542 * Most writing systems use whitespace to break up words.
2543 * Some languages such as Chinese don't conventionally do this,
2544 * which requires special handling when breaking up words for
2545 * searching etc.
2546 *
2547 * @return bool
2548 */
2551 }
2553 /**
2554 * Some languages such as Chinese require word segmentation,
2555 * Specify such segmentation when overridden in derived class.
2556 *
2557 * @param $string String
2558 * @return String
2559 */
2562 }
2564 /**
2565 * Some languages have special punctuation need to be normalized.
2566 * Make such changes here.
2567 *
2568 * @param $string String
2569 * @return String
2570 */
2573 }
2575 /**
2576 * convert double-width roman characters to single-width.
2577 * range: ff00-ff5f ~= 0020-007f
2578 *
2579 * @param $string string
2580 *
2581 * @return string
2582 */
2592 }
2596 }
2598 /**
2599 * @param $string string
2600 * @param $pattern string
2601 * @return string
2602 */
2607 }
2609 /**
2610 * @param $termsArray array
2611 * @return array
2612 */
2614 # some languages, e.g. Chinese, need to do a conversion
2615 # in order for search results to be displayed correctly
2617 }
2619 /**
2620 * Get the first character of a string.
2621 *
2622 * @param $s string
2623 * @return string
2624 */
2631 $matches
2632 );
2637 }
2639 // Break down Hangul syllables to grab the first jamo
2671 }
2674 }
2675 }
2678 # Some languages may have an alternate char encoding option
2679 # (Esperanto X-coding, Japanese furigana conversion, etc)
2680 # If this language is used as the primary content language,
2681 # an override to the defaults can be set here on startup.
2682 }
2684 /**
2685 * @param $s string
2686 * @return string
2687 */
2689 # For some languages we'll want to explicitly specify
2690 # which characters make it into the edit box raw
2691 # or are converted in some way or another.
2697 }
2698 }
2700 /**
2701 * @param $s string
2702 * @return string
2703 */
2705 # Take the previous into account.
2711 }
2716 }
2717 }
2719 /**
2720 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2721 * also cleans up certain backwards-compatible sequences, converting them
2722 * to the modern Unicode equivalent.
2723 *
2724 * This is language-specific for performance reasons only.
2725 *
2726 * @param $s string
2727 *
2728 * @return string
2729 */
2736 }
2739 }
2741 /**
2742 * Transform a string using serialized data stored in the given file (which
2743 * must be in the serialized subdirectory of $IP). The file contains pairs
2744 * mapping source characters to destination characters.
2745 *
2746 * The data is cached in process memory. This will go faster if you have the
2747 * FastStringSearch extension.
2748 *
2749 * @param $file string
2750 * @param $string string
2751 *
2752 * @throws MWException
2753 * @return string
2754 */
2760 }
2762 }
2764 }
2766 /**
2767 * For right-to-left language support
2768 *
2769 * @return bool
2770 */
2773 }
2775 /**
2776 * Return the correct HTML 'dir' attribute value for this language.
2777 * @return String
2778 */
2781 }
2783 /**
2784 * Return 'left' or 'right' as appropriate alignment for line-start
2785 * for this language's text direction.
2786 *
2787 * Should be equivalent to CSS3 'start' text-align value....
2788 *
2789 * @return String
2790 */
2793 }
2795 /**
2796 * Return 'right' or 'left' as appropriate alignment for line-end
2797 * for this language's text direction.
2798 *
2799 * Should be equivalent to CSS3 'end' text-align value....
2800 *
2801 * @return String
2802 */
2805 }
2807 /**
2808 * A hidden direction mark (LRM or RLM), depending on the language direction.
2809 * Unlike getDirMark(), this function returns the character as an HTML entity.
2810 * This function should be used when the output is guaranteed to be HTML,
2811 * because it makes the output HTML source code more readable. When
2812 * the output is plain text or can be escaped, getDirMark() should be used.
2813 *
2814 * @param $opposite Boolean Get the direction mark opposite to your language
2815 * @return string
2816 * @since 1.20
2817 */
2821 }
2823 /**
2824 * A hidden direction mark (LRM or RLM), depending on the language direction.
2825 * This function produces them as invisible Unicode characters and
2826 * the output may be hard to read and debug, so it should only be used
2827 * when the output is plain text or can be escaped. When the output is
2828 * HTML, use getDirMarkEntity() instead.
2829 *
2830 * @param $opposite Boolean Get the direction mark opposite to your language
2831 * @return string
2832 */
2838 }
2840 /**
2841 * @return array
2842 */
2845 }
2847 /**
2848 * An arrow, depending on the language direction.
2849 *
2850 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2851 * @return string
2852 */
2867 }
2868 }
2870 /**
2871 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2872 *
2873 * @return bool
2874 */
2877 }
2879 /**
2880 * @return array
2881 */
2884 }
2889 }
2894 }
2896 /**
2897 * Fill a MagicWord object with data from here
2898 *
2899 * @param $mw
2900 */
2912 }
2913 }
2920 }
2921 }
2923 /**
2924 * Add magic words to the extension array
2925 *
2926 * @param $newWords array
2927 */
2934 }
2935 }
2936 }
2938 /**
2939 * Get special page names, as an associative array
2940 * case folded alias => real name
2941 */
2943 // Cache aliases because it may be slow to load them
2945 // Initialise array
2950 }
2953 }
2955 /**
2956 * Italic is unsuitable for some languages
2957 *
2958 * @param $text String: the text to be emphasized.
2959 * @return string
2960 */
2963 }
2965 /**
2966 * Normally we output all numbers in plain en_US style, that is
2967 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2968 * point twohundredthirtyfive. However this is not suitable for all
2969 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2970 * Icelandic just want to use commas instead of dots, and dots instead
2971 * of commas like "293.291,235".
2972 *
2973 * An example of this function being called:
2974 * <code>
2975 * wfMessage( 'message' )->numParams( $num )->text()
2976 * </code>
2977 *
2978 * See LanguageGu.php for the Gujarati implementation and
2979 * $separatorTransformTable on MessageIs.php for
2980 * the , => . and . => , implementation.
2981 *
2982 * @todo check if it's viable to use localeconv() for the decimal
2983 * separator thing.
2984 * @param $number Mixed: the string to be formatted, should be an integer
2985 * or a floating point number.
2986 * @param $nocommafy Bool: set to true for special numbers like dates
2987 * @return string
2988 */
2996 }
2997 }
3003 }
3004 }
3007 }
3009 /**
3010 * Front-end for non-commafied formatNum
3011 *
3012 * @param mixed $number the string to be formatted, should be an integer
3013 * or a floating point number.
3014 * @since 1.21
3015 * @return string
3016 */
3019 }
3021 /**
3022 * @param $number string
3023 * @return string
3024 */
3029 }
3034 }
3038 }
3040 /**
3041 * Adds commas to a given number
3042 * @since 1.19
3043 * @param $number mixed
3044 * @return string
3045 */
3050 }
3053 // default grouping is at thousands, use the same for ###,###,### pattern too.
3056 // Ref: http://cldr.unicode.org/translation/number-patterns
3059 // For negative numbers apply the algorithm like positive number and add sign.
3062 }
3070 // the string does not have any number part. Eg: .12345
3072 }
3080 }
3084 // use the last pattern for the rest of the number
3086 }
3089 }
3090 }
3092 }
3093 }
3095 /**
3096 * @return String
3097 */
3100 }
3102 /**
3103 * @return array
3104 */
3107 }
3109 /**
3110 * @return array
3111 */
3114 }
3116 /**
3117 * Take a list of strings and build a locale-friendly comma-separated
3118 * list, using the local comma-separator message.
3119 * The last two strings are chained with an "and".
3120 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3121 *
3122 * @param $l Array
3123 * @return string
3124 */
3129 }
3135 }
3136 }
3143 }
3144 }
3146 }
3148 /**
3149 * Take a list of strings and build a locale-friendly comma-separated
3150 * list, using the local comma-separator message.
3151 * @param $list array of strings to put in a comma list
3152 * @return string
3153 */
3157 $list
3158 );
3159 }
3161 /**
3162 * Take a list of strings and build a locale-friendly semicolon-separated
3163 * list, using the local semicolon-separator message.
3164 * @param $list array of strings to put in a semicolon list
3165 * @return string
3166 */
3170 $list
3171 );
3172 }
3174 /**
3175 * Same as commaList, but separate it with the pipe instead.
3176 * @param $list array of strings to put in a pipe list
3177 * @return string
3178 */
3182 $list
3183 );
3184 }
3186 /**
3187 * Truncate a string to a specified length in bytes, appending an optional
3188 * string (e.g. for ellipses)
3189 *
3190 * The database offers limited byte lengths for some columns in the database;
3191 * multi-byte character sets mean we need to ensure that only whole characters
3192 * are included, otherwise broken characters can be passed to the user
3193 *
3194 * If $length is negative, the string will be truncated from the beginning
3195 *
3196 * @param $string String to truncate
3197 * @param $length Int: maximum length (including ellipses)
3198 * @param $ellipsis String to append to the truncated text
3199 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3200 * $adjustLength was introduced in 1.18, before that behaved as if false.
3201 * @return string
3202 */
3204 # Use the localized ellipsis character
3207 }
3208 # Check if there is no need to truncate
3213 }
3215 # If ellipsis length is >= $length then we can't apply $adjustLength
3218 # Otherwise, truncate and add ellipsis...
3231 }
3232 }
3233 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3234 # This check is *not* redundant if $adjustLength, due to the single case where
3235 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3240 }
3241 }
3243 /**
3244 * Remove bytes that represent an incomplete Unicode character
3245 * at the end of string (e.g. bytes of the char are missing)
3246 *
3247 * @param $string String
3248 * @return string
3249 */
3255 # We got the first byte only of a multibyte char; remove it.
3260 {
3261 # We chopped in the middle of a character; remove it
3263 }
3264 }
3266 }
3268 /**
3269 * Remove bytes that represent an incomplete Unicode character
3270 * at the start of string (e.g. bytes of the char are missing)
3271 *
3272 * @param $string String
3273 * @return string
3274 */
3279 # We chopped in the middle of a character; remove the whole thing
3281 }
3282 }
3284 }
3286 /**
3287 * Truncate a string of valid HTML to a specified length in bytes,
3288 * appending an optional string (e.g. for ellipses), and return valid HTML
3289 *
3290 * This is only intended for styled/linked text, such as HTML with
3291 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3292 * Also, this will not detect things like "display:none" CSS.
3293 *
3294 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3295 *
3296 * @param string $text HTML string to truncate
3297 * @param int $length (zero/positive) Maximum length (including ellipses)
3298 * @param string $ellipsis String to append to the truncated text
3299 * @return string
3300 */
3302 # Use the localized ellipsis character
3305 }
3306 # Check if there is clearly no need to truncate
3311 }
3325 # Consider truncation once the display length has reached the maximim.
3326 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3327 # Check that we're not in the middle of a bracket/entity...
3331 # Save where we are; we will truncate here unless there turn out to
3332 # be so few remaining characters that truncation is not necessary.
3335 }
3337 # String in fact does need truncation, the truncation point was OK.
3342 }
3343 }
3346 # Read the next char...
3364 }
3370 // Name found (e.g. "<a href=..."), add on tag attributes...
3372 }
3378 }
3381 // Save state without $ch. We want to *hit* the first
3382 // display char (to get tags) but not *use* it if truncating.
3384 }
3389 // Add the next $max display text chars after this in one swoop...
3394 }
3395 }
3396 }
3397 }
3398 // Close the last tag if left unclosed by bad HTML
3402 }
3404 }
3406 /**
3407 * truncateHtml() helper function
3408 * like strcspn() but adds the skipped chars to $ret
3409 *
3410 * @param $ret
3411 * @param $text
3412 * @param $search
3413 * @param $start
3414 * @param $len
3415 * @return int
3416 */
3422 }
3427 }
3429 }
3431 /**
3432 * truncateHtml() helper function
3433 * (a) push or pop $tag from $openTags as needed
3434 * (b) clear $tag value
3435 * @param &$tag string Current HTML tag name we are looking at
3436 * @param $tagType int (0-open tag, 1-close tag)
3437 * @param $lastCh string Character before the '>' that ended this tag
3438 * @param &$openTags array Open tag stack (not accounting for $tag)
3439 */
3448 }
3449 }
3451 }
3452 }
3454 /**
3455 * Grammatical transformations, needed for inflected languages
3456 * Invoked by putting {{grammar:case|word}} in a message
3457 *
3458 * @param $word string
3459 * @param $case string
3460 * @return string
3461 */
3466 }
3468 }
3469 /**
3470 * Get the grammar forms for the content language
3471 * @return array of grammar forms
3472 * @since 1.20
3473 */
3476 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3478 }
3480 }
3481 /**
3482 * Provides an alternative text depending on specified gender.
3483 * Usage {{gender:username|masculine|feminine|neutral}}.
3484 * username is optional, in which case the gender of current user is used,
3485 * but only in (some) interface messages; otherwise default gender is used.
3486 *
3487 * If no forms are given, an empty string is returned. If only one form is
3488 * given, it will be returned unconditionally. These details are implied by
3489 * the caller and cannot be overridden in subclasses.
3490 *
3491 * If more than one form is given, the default is to use the neutral one
3492 * if it is specified, and to use the masculine one otherwise. These
3493 * details can be overridden in subclasses.
3494 *
3495 * @param $gender string
3496 * @param $forms array
3497 *
3498 * @return string
3499 */
3503 }
3507 }
3510 }
3512 }
3514 /**
3515 * Plural form transformations, needed for some languages.
3516 * For example, there are 3 form of plural in Russian and Polish,
3517 * depending on "count mod 10". See [[w:Plural]]
3518 * For English it is pretty simple.
3519 *
3520 * Invoked by putting {{plural:count|wordform1|wordform2}}
3521 * or {{plural:count|wordform1|wordform2|wordform3}}
3522 *
3523 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3524 *
3525 * @param $count Integer: non-localized number
3526 * @param $forms Array: different plural forms
3527 * @return string Correct form of plural for $count in this language
3528 */
3532 }
3534 // Handle explicit n=pluralform cases
3540 }
3542 }
3543 }
3549 }
3551 /**
3552 * Checks that convertPlural was given an array and pads it to requested
3553 * amount of forms by copying the last one.
3554 *
3555 * @param $count Integer: How many forms should there be at least
3556 * @param $forms Array of forms given to convertPlural
3557 * @return array Padded array of forms or an exception if not an array
3558 */
3562 }
3564 }
3566 /**
3567 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3568 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3569 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3570 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3571 * match up with it.
3572 *
3573 * @param $str String: the validated block duration in English
3574 * @return string Somehow translated block duration
3575 * @see LanguageFi.php for example implementation
3576 */
3582 }
3583 }
3585 // Since usually only infinite or indefinite is only on list, so try
3586 // equivalents if still here.
3593 }
3594 }
3595 }
3597 // If all else fails, return a standard duration or timestamp description.
3602 // $time is relative to 0 so it's a duration length.
3606 // wfTimestamp() handles 0 as current time instead of epoch.
3610 }
3611 }
3612 }
3614 /**
3615 * languages like Chinese need to be segmented in order for the diff
3616 * to be of any use
3617 *
3618 * @param $text String
3619 * @return String
3620 */
3623 }
3625 /**
3626 * and unsegment to show the result
3627 *
3628 * @param $text String
3629 * @return String
3630 */
3633 }
3635 /**
3636 * Return the LanguageConverter used in the Language
3637 *
3638 * @since 1.19
3639 * @return LanguageConverter
3640 */
3643 }
3645 /**
3646 * convert text to all supported variants
3647 *
3648 * @param $text string
3649 * @return array
3650 */
3653 }
3655 /**
3656 * convert text to different variants of a language.
3657 *
3658 * @param $text string
3659 * @return string
3660 */
3663 }
3665 /**
3666 * Convert a Title object to a string in the preferred variant
3667 *
3668 * @param $title Title
3669 * @return string
3670 */
3673 }
3675 /**
3676 * Convert a namespace index to a string in the preferred variant
3677 *
3678 * @param $ns int
3679 * @return string
3680 */
3683 }
3685 /**
3686 * Check if this is a language with variants
3687 *
3688 * @return bool
3689 */
3692 }
3694 /**
3695 * Check if the language has the specific variant
3696 *
3697 * @since 1.19
3698 * @param $variant string
3699 * @return bool
3700 */
3703 }
3705 /**
3706 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3707 *
3708 * @param $text string
3709 * @return string
3710 */
3713 }
3715 /**
3716 * Perform output conversion on a string, and encode for safe HTML output.
3717 * @param $text String text to be converted
3718 * @param $isTitle Bool whether this conversion is for the article title
3719 * @return string
3720 * @todo this should get integrated somewhere sane
3721 */
3724 }
3726 /**
3727 * @param $key string
3728 * @return string
3729 */
3732 }
3734 /**
3735 * Get the list of variants supported by this language
3736 * see sample implementation in LanguageZh.php
3737 *
3738 * @return array an array of language codes
3739 */
3742 }
3744 /**
3745 * @return string
3746 */
3749 }
3751 /**
3752 * @return string
3753 */
3756 }
3758 /**
3759 * @return string
3760 */
3763 }
3765 /**
3766 * If a language supports multiple variants, it is
3767 * possible that non-existing link in one variant
3768 * actually exists in another variant. this function
3769 * tries to find it. See e.g. LanguageZh.php
3770 *
3771 * @param $link String: the name of the link
3772 * @param $nt Mixed: the title object of the link
3773 * @param $ignoreOtherCond Boolean: to disable other conditions when
3774 * we need to transclude a template or update a category's link
3775 * @return null the input parameters may be modified upon return
3776 */
3779 }
3781 /**
3782 * If a language supports multiple variants, converts text
3783 * into an array of all possible variants of the text:
3784 * 'variant' => text in that variant
3785 *
3786 * @deprecated since 1.17 Use autoConvertToAllVariants()
3787 *
3788 * @param $text string
3789 *
3790 * @return string
3791 */
3794 }
3796 /**
3797 * returns language specific options used by User::getPageRenderHash()
3798 * for example, the preferred language variant
3799 *
3800 * @return string
3801 */
3804 }
3806 /**
3807 * For languages that support multiple variants, the title of an
3808 * article may be displayed differently in different variants. this
3809 * function returns the apporiate title defined in the body of the article.
3810 *
3811 * @return string
3812 */
3815 }
3817 /**
3818 * Prepare external link text for conversion. When the text is
3819 * a URL, it shouldn't be converted, and it'll be wrapped in
3820 * the "raw" tag (-{R| }-) to prevent conversion.
3821 *
3822 * This function is called "markNoConversion" for historical
3823 * reasons.
3824 *
3825 * @param $text String: text to be used for external link
3826 * @param $noParse bool: wrap it without confirming it's a real URL first
3827 * @return string the tagged text
3828 */
3830 // Excluding protocal-relative URLs may avoid many false positives.
3835 }
3836 }
3838 /**
3839 * A regular expression to match legal word-trailing characters
3840 * which should be merged onto a link of the form [[foo]]bar.
3841 *
3842 * @return string
3843 */
3846 }
3848 /**
3849 * @return Language
3850 */
3853 }
3855 /**
3856 * Get the RFC 3066 code for this language object
3857 *
3858 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3859 * htmlspecialchars() or similar
3860 *
3861 * @return string
3862 */
3865 }
3867 /**
3868 * Get the code in Bcp47 format which we can use
3869 * inside of html lang="" tags.
3870 *
3871 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3872 * htmlspecialchars() or similar.
3873 *
3874 * @since 1.19
3875 * @return string
3876 */
3880 }
3882 }
3884 /**
3885 * @param $code string
3886 */
3889 // Ensure we don't leave an incorrect html code lying around
3891 }
3893 /**
3894 * Get the name of a file for a certain language code
3895 * @param $prefix string Prepend this to the filename
3896 * @param $code string Language code
3897 * @param $suffix string Append this to the filename
3898 * @throws MWException
3899 * @return string $prefix . $mangledCode . $suffix
3900 */
3902 // Protect against path traversal
3905 {
3907 }
3910 }
3912 /**
3913 * Get the language code from a file name. Inverse of getFileName()
3914 * @param $filename string $prefix . $languageCode . $suffix
3915 * @param $prefix string Prefix before the language code
3916 * @param $suffix string Suffix after the language code
3917 * @return string Language code, or false if $prefix or $suffix isn't found
3918 */
3919 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3925 }
3927 }
3929 /**
3930 * @param $code string
3931 * @return string
3932 */
3938 }
3940 /**
3941 * @param $code string
3942 * @return string
3943 */
3947 }
3949 /**
3950 * Get the first fallback for a given language.
3951 *
3952 * @param $code string
3953 *
3954 * @return bool|string
3955 */
3963 }
3964 }
3966 /**
3967 * Get the ordered list of fallback languages.
3968 *
3969 * @since 1.19
3970 * @param $code string Language code
3971 * @return array
3972 */
3981 }
3983 }
3984 }
3986 /**
3987 * Get all messages for a given language
3988 * WARNING: this may take a long time. If you just need all message *keys*
3989 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3990 *
3991 * @param $code string
3992 *
3993 * @return array
3994 */
3997 }
3999 /**
4000 * Get a message for a given language
4001 *
4002 * @param $key string
4003 * @param $code string
4004 *
4005 * @return string
4006 */
4009 }
4011 /**
4012 * Get all message keys for a given language. This is a faster alternative to
4013 * array_keys( Language::getMessagesFor( $code ) )
4014 *
4015 * @since 1.19
4016 * @param $code string Language code
4017 * @return array of message keys (strings)
4018 */
4021 }
4023 /**
4024 * @param $talk
4025 * @return mixed
4026 */
4030 }
4035 # Allow grammar transformations
4036 # Allowing full message-style parsing would make simple requests
4037 # such as action=raw much more expensive than they need to be.
4038 # This will hopefully cover most cases.
4042 }
4044 /**
4045 * @param $m string
4046 * @return string
4047 */
4050 }
4052 /**
4053 * @throws MWException
4054 * @return array
4055 */
4060 }
4067 }
4072 }
4074 /**
4075 * Decode an expiry (block, protection, etc) which has come from the DB
4076 *
4077 * @todo FIXME: why are we returnings DBMS-dependent strings???
4078 *
4079 * @param $expiry String: Database expiry String
4080 * @param $format Bool|Int true to process using language functions, or TS_ constant
4081 * to return the expiry in a given timestamp
4082 * @return String
4083 * @since 1.18
4084 */
4090 }
4094 ? $infinityMsg
4100 }
4101 }
4103 /**
4104 * @todo Document
4105 * @param $seconds int|float
4106 * @param $format Array Optional
4107 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4108 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4109 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4110 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4111 * @return string
4112 */
4116 }
4119 }
4122 }
4144 }
4155 }
4159 }
4165 }
4173 }
4183 }
4187 }
4197 }
4198 }
4200 }
4202 /**
4203 * Format a bitrate for output, using an appropriate
4204 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4205 *
4206 * This use base 1000. For base 1024 use formatSize(), for another base
4207 * see formatComputingNumbers()
4208 *
4209 * @param $bps int
4210 * @return string
4211 */
4214 }
4216 /**
4217 * @param $size int Size of the unit
4218 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4219 * @param $messageKey string Message key to be uesd
4220 * @return string
4221 */
4226 );
4227 }
4235 }
4237 // For small sizes no decimal places necessary
4240 // For MB and bigger two decimal places are smarter
4242 }
4248 }
4250 /**
4251 * Format a size in bytes for output, using an appropriate
4252 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4253 *
4254 * This method use base 1024. For base 1000 use formatBitrate(), for
4255 * another base see formatComputingNumbers()
4256 *
4257 * @param $size int Size to format
4258 * @return string Plain text (not HTML)
4259 */
4262 }
4264 /**
4265 * Make a list item, used by various special pages
4266 *
4267 * @param $page String Page link
4268 * @param $details String Text between brackets
4269 * @param $oppositedm Boolean Add the direction mark opposite to your
4270 * language, to display text properly
4271 * @return String
4272 */
4279 }
4281 /**
4282 * Generate (prev x| next x) (20|50|100...) type links for paging
4283 *
4284 * @param $title Title object to link
4285 * @param $offset Integer offset parameter
4286 * @param $limit Integer limit parameter
4287 * @param $query array|String optional URL query parameter string
4288 * @param $atend Bool optional param for specified if this is the last page
4289 * @return String
4290 */
4291 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4292 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4294 # Make 'previous' link
4295 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4301 }
4303 # Make 'next' link
4304 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4310 }
4312 # Make links to set number of items per page
4317 }
4321 }
4323 /**
4324 * Helper function for viewPrevNext() that generates links
4325 *
4326 * @param $title Title object to link
4327 * @param $offset Integer offset parameter
4328 * @param $limit Integer limit parameter
4329 * @param $query Array extra query parameters
4330 * @param $link String text to use for the link; will be escaped
4331 * @param $tooltipMsg String name of the message to use as tooltip
4332 * @param $class String value of the "class" attribute of the link
4333 * @return String HTML fragment
4334 */
4335 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4337 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4340 }
4342 /**
4343 * Get the conversion rule title, if any.
4344 *
4345 * @return string
4346 */
4349 }
4351 /**
4352 * Get the compiled plural rules for the language
4353 * @since 1.20
4354 * @return array Associative array with plural form, and plural rule as key-value pairs
4355 */
4361 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4364 }
4365 }
4366 }
4368 }
4370 /**
4371 * Get the plural rules for the language
4372 * @since 1.20
4373 * @return array Associative array with plural form number and plural rule as key-value pairs
4374 */
4383 }
4384 }
4385 }
4387 }
4389 /**
4390 * Get the plural rule types for the language
4391 * @since 1.21
4392 * @return array Associative array with plural form number and plural rule type as key-value pairs
4393 */
4399 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4402 }
4403 }
4404 }
4406 }
4408 /**
4409 * Find the index number of the plural rule appropriate for the given number
4410 * @return int The index number of the plural rule
4411 */
4416 }
4418 /**
4419 * Find the plural rule type appropriate for the given number
4420 * For example, if the language is set to Arabic, getPluralType(5) should
4421 * return 'few'.
4422 * @since 1.21
4423 * @return string The name of the plural rule type, e.g. one, two, few, many
4424 */
4432 }
4433 }
4434 }