| blob | 88d0f23eba9ae69ae5f6fd7acfbddccf835755de |
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 }
35 }
37 /**
38 * Internationalisation code
39 * @ingroup Language
40 */
42 /**
43 * @var LanguageConverter
44 */
56 /**
57 * ReplacementArray object caches
58 */
61 /**
62 * @var LocalisationCache
63 */
71 );
75 );
80 'december'
81 );
85 'december-gen'
86 );
90 );
97 );
105 );
113 );
120 );
122 /**
123 * @since 1.20
124 * @var array
125 */
136 );
138 /**
139 * Cache for language fallbacks.
140 * @see Language::getFallbacksIncludingSiteLanguage
141 * @since 1.21
142 * @var array
143 */
146 /**
147 * Get a cached or new language object for a given language code
148 * @param string $code
149 * @return Language
150 */
156 }
158 // get the language object to process
163 // merge the language object in to get it up front in the cache
165 // get rid of the oldest ones in case we have an overflow
169 }
171 /**
172 * Create a language object for a given language code
173 * @param string $code
174 * @throws MWException
175 * @return Language
176 */
178 // Protect against path traversal below
181 ) {
183 }
186 // It's not possible to customise this code with class files, so
187 // just return a Language object. This is to support uselang= hacks.
191 }
193 // Check if there is a language class for the code
199 }
201 // Keep trying the fallback list until we find an existing class
206 }
214 }
215 }
218 }
220 /**
221 * Checks whether any localisation is available for that language tag
222 * in MediaWiki (MessagesXx.php exists).
223 *
224 * @param string $code Language tag (in lower case)
225 * @return bool Whether language is supported
226 * @since 1.21
227 */
232 );
233 }
235 /**
236 * Returns true if a language code string is a well-formed language tag
237 * according to RFC 5646.
238 * This function only checks well-formedness; it doesn't check that
239 * language, script or variant codes actually exist in the repositories.
240 *
241 * Based on regexes by Mark Davis of the Unicode Consortium:
242 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
243 *
244 * @param string $code
245 * @param bool $lenient Whether to allow '_' as separator. The default is only '-'.
246 *
247 * @return bool
248 * @since 1.21
249 */
265 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
266 # Since these are limited, this is safe even later changes to the registry --
267 # the only oddity is that it might change the type of the tag, and thus
268 # the results from the capturing groups.
269 # http://www.iana.org/assignments/language-subtag-registry
287 # The final breakdown, with capturing groups for each of these components
288 # The variants, extensions, grandfathered, and private-use may have interior '-'
293 }
295 /**
296 * Returns true if a language code string is of a valid form, whether or
297 * not it exists. This includes codes which are used solely for
298 * customisation via the MediaWiki namespace.
299 *
300 * @param string $code
301 *
302 * @return bool
303 */
308 }
309 // People think language codes are html safe, so enforce it.
310 // Ideally we should only allow a-zA-Z0-9-
311 // but, .+ and other chars are often used for {{int:}} hacks
312 // see bugs 37564, 37587, 36938
318 }
320 /**
321 * Returns true if a language code is of a valid form for the purposes of
322 * internal customisation of MediaWiki, via Messages*.php or *.json.
323 *
324 * @param string $code
325 *
326 * @throws MWException
327 * @since 1.18
328 * @return bool
329 */
337 }
340 }
343 }
345 /**
346 * Returns true if a language code is an IETF tag known to MediaWiki.
347 *
348 * @param string $code
349 *
350 * @since 1.21
351 * @return bool
352 */
356 // Quick escape for invalid input to avoid exceptions down the line
357 // when code tries to process tags which are not valid at all.
360 }
365 }
369 ) {
371 }
374 }
376 /**
377 * @param string $code
378 * @return string Name of the language class
379 */
385 }
386 }
388 /**
389 * Includes language class files
390 *
391 * @param string $class Name of the language class
392 */
398 }
402 }
403 }
405 /**
406 * Get the LocalisationCache instance
407 *
408 * @return LocalisationCache
409 */
415 }
417 }
421 // Set the code to the name of the descendant
426 }
428 }
430 /**
431 * Reduce memory usage
432 */
436 }
437 }
439 /**
440 * Hook which will be called if this is the content language.
441 * Descendants can use this to register hook functions or modify globals
442 */
444 }
446 /**
447 * @return array
448 * @since 1.19
449 */
452 }
454 /**
455 * Exports $wgBookstoreListEn
456 * @return array
457 */
460 }
462 /**
463 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
464 * available in localised form, it will be included in English.
465 *
466 * @return array
467 */
484 }
486 # Sometimes a language will be localised but not actually exist on this wiki.
490 }
491 }
493 # The above mixing may leave namespaces out of canonical order.
494 # Re-order by namespace ID number...
498 }
501 }
503 /**
504 * Arbitrarily set all of the namespace names at once. Mainly used for testing
505 * @param array $namespaces Array of namespaces (id => name)
506 */
510 }
512 /**
513 * Resets all of the namespace caches. Mainly used for testing
514 */
519 }
521 /**
522 * A convenience function that returns the same thing as
523 * getNamespaces() except with the array values changed to ' '
524 * where it found '_', useful for producing output to be displayed
525 * e.g. in <select> forms.
526 *
527 * @return array
528 */
533 }
535 }
537 /**
538 * Get a namespace value by key
539 * <code>
540 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
541 * echo $mw_ns; // prints 'MediaWiki'
542 * </code>
543 *
544 * @param int $index The array key of the namespace to return
545 * @return string|bool String if the namespace value exists, otherwise false
546 */
551 }
553 /**
554 * A convenience function that returns the same thing as
555 * getNsText() except with '_' changed to ' ', useful for
556 * producing output.
557 *
558 * <code>
559 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
560 * echo $mw_ns; // prints 'MediaWiki talk'
561 * </code>
562 *
563 * @param int $index The array key of the namespace to return
564 * @return string Namespace name without underscores (empty string if namespace does not exist)
565 */
570 }
572 /**
573 * Returns gender-dependent namespace alias if available.
574 * See https://www.mediawiki.org/wiki/Manual:$wgExtraGenderNamespaces
575 * @param int $index Namespace index
576 * @param string $gender Gender key (male, female... )
577 * @return string
578 * @since 1.18
579 */
587 }
589 /**
590 * Whether this language uses gender-dependent namespace aliases.
591 * See https://www.mediawiki.org/wiki/Manual:$wgExtraGenderNamespaces
592 * @return bool
593 * @since 1.18
594 */
598 // $wgExtraGenderNamespaces overrides everything
600 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
601 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
602 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
605 // Check what is in i18n files
608 }
609 }
611 /**
612 * Get a namespace key by value, case insensitive.
613 * Only matches namespace names for the current language, not the
614 * canonical ones defined in Namespace.php.
615 *
616 * @param string $text
617 * @return int|bool An integer if $text is a valid value otherwise false
618 */
623 }
625 /**
626 * @return array
627 */
639 }
640 }
641 }
649 }
650 }
652 # Also add converted namespace names as aliases, to avoid confusion.
657 }
660 }
661 }
664 }
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 string $text
700 * @return int|bool 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 string $code
716 * @param bool $usemsg Use the "variantname-xyz" message if it exists
717 * @return string
718 */
723 }
728 # otherwise, output the language code
730 }
731 }
733 /**
734 * @param string $name
735 * @return string
736 */
741 }
743 }
745 /**
746 * @return array
747 */
750 }
752 /**
753 * @return array
754 */
757 }
759 /**
760 * @return array|string
761 */
769 }
770 }
772 /**
773 * @return array
774 */
777 }
779 /**
780 * @param string $image
781 * @return array|null
782 */
785 }
787 /**
788 * @return array
789 */
792 }
794 /**
795 * @param string $tog
796 * @return string
797 */
800 }
802 /**
803 * Get native language names, indexed by code.
804 * Only those defined in MediaWiki, no other data like CLDR.
805 * If $customisedOnly is true, only returns codes with a messages file
806 *
807 * @param bool $customisedOnly
808 *
809 * @return array
810 * @deprecated since 1.20, use fetchLanguageNames()
811 */
814 }
816 /**
817 * Get translated language names. This is done on best effort and
818 * by default this is exactly the same as Language::getLanguageNames.
819 * The CLDR extension provides translated names.
820 * @param string $code Language code.
821 * @return array Language code => language name
822 * @since 1.18.0
823 * @deprecated since 1.20, use fetchLanguageNames()
824 */
827 }
829 /**
830 * Get an array of language names, indexed by code.
831 * @param null|string $inLanguage Code of language in which to return the names
832 * Use null for autonyms (native names)
833 * @param string $include One of:
834 * 'all' all available languages
835 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
836 * 'mwfile' only if the language is in 'mw' *and* has a message file
837 * @return array Language code => language name
838 * @since 1.20
839 */
847 }
849 // If passed an invalid language code to use, fallback to en
852 }
857 # TODO: also include when $inLanguage is null, when this code is more efficient
859 }
863 # - Prefer own MediaWiki native name when not using the hook
864 # - For other names just add if not added through the hook
867 }
868 }
872 }
878 }
882 # We do this using a foreach over the codes instead of a directory
883 # loop so that messages files in extensions will work correctly.
887 ) {
889 }
890 }
893 }
895 # 'mw' option; default if it's not one of the other two options (all/mwfile)
897 }
899 /**
900 * @param string $code The code of the language for which to get the name
901 * @param null|string $inLanguage Code of language in which to return the name (null for autonyms)
902 * @param string $include 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
903 * @return string Language name or empty
904 * @since 1.20
905 */
910 }
912 /**
913 * Get a message from the MediaWiki namespace.
914 *
915 * @param string $msg Message name
916 * @return string
917 */
920 }
922 /**
923 * Get the native language name of $code.
924 * Only if defined in MediaWiki, no other data like CLDR.
925 * @param string $code
926 * @return string
927 * @deprecated since 1.20, use fetchLanguageName()
928 */
931 }
933 /**
934 * @param string $key
935 * @return string
936 */
939 }
941 /**
942 * @return array
943 */
948 }
950 }
952 /**
953 * @param string $key
954 * @return string
955 */
958 }
960 /**
961 * @param string $key
962 * @return string
963 */
966 }
968 /**
969 * @return array
970 */
975 }
977 }
979 /**
980 * @param string $key
981 * @return string
982 */
985 }
987 /**
988 * @param string $key
989 * @return string
990 */
993 }
995 /**
996 * @param string $key
997 * @return string
998 */
1001 }
1003 /**
1004 * @param string $key
1005 * @return string
1006 */
1009 }
1011 /**
1012 * @param string $key
1013 * @return string
1014 */
1017 }
1019 /**
1020 * @param string $key
1021 * @return string
1022 */
1025 }
1027 /**
1028 * Pass through result from $dateTimeObj->format()
1029 */
1034 );
1035 }
1037 }
1039 /**
1040 * This is a workalike of PHP's date() function, but with better
1041 * internationalisation, a reduced set of format characters, and a better
1042 * escaping format.
1043 *
1044 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1045 * the PHP manual for definitions. There are a number of extensions, which
1046 * start with "x":
1047 *
1048 * xn Do not translate digits of the next numeric format character
1049 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1050 * xr Use roman numerals for the next numeric format character
1051 * xh Use hebrew numerals for the next numeric format character
1052 * xx Literal x
1053 * xg Genitive month name
1054 *
1055 * xij j (day number) in Iranian calendar
1056 * xiF F (month name) in Iranian calendar
1057 * xin n (month number) in Iranian calendar
1058 * xiy y (two digit year) in Iranian calendar
1059 * xiY Y (full year) in Iranian calendar
1060 *
1061 * xjj j (day number) in Hebrew calendar
1062 * xjF F (month name) in Hebrew calendar
1063 * xjt t (days in month) in Hebrew calendar
1064 * xjx xg (genitive month name) in Hebrew calendar
1065 * xjn n (month number) in Hebrew calendar
1066 * xjY Y (full year) in Hebrew calendar
1067 *
1068 * xmj j (day number) in Hijri calendar
1069 * xmF F (month name) in Hijri calendar
1070 * xmn n (month number) in Hijri calendar
1071 * xmY Y (full year) in Hijri calendar
1072 *
1073 * xkY Y (full year) in Thai solar calendar. Months and days are
1074 * identical to the Gregorian calendar
1075 * xoY Y (full year) in Minguo calendar or Juche year.
1076 * Months and days are identical to the
1077 * Gregorian calendar
1078 * xtY Y (full year) in Japanese nengo. Months and days are
1079 * identical to the Gregorian calendar
1080 *
1081 * Characters enclosed in double quotes will be considered literal (with
1082 * the quotes themselves removed). Unmatched quotes will be considered
1083 * literal quotes. Example:
1084 *
1085 * "The month is" F => The month is January
1086 * i's" => 20'11"
1087 *
1088 * Backslash escaping is also supported.
1089 *
1090 * Input timestamp is assumed to be pre-normalized to the desired local
1091 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1092 * $ts is UTC if $zone is not given.
1093 *
1094 * @param string $format
1095 * @param string $ts 14-character timestamp
1096 * YYYYMMDDHHMMSS
1097 * 01234567890123
1098 * @param DateTimeZone $zone Timezone of $ts
1099 * @param[out] int $ttl The amount of time (in seconds) the output may be cached for.
1100 * Only makes sense if $ts is the current time.
1101 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1102 *
1103 * @throws MWException
1104 * @return string
1105 */
1141 }
1145 }
1153 }
1163 }
1189 }
1198 $s .= $this->getWeekdayAbbreviation( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1 );
1208 }
1215 }
1222 }
1227 $s .= $this->getWeekdayName( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1 );
1237 }
1244 }
1251 }
1270 }
1277 }
1284 }
1291 }
1302 }
1309 }
1316 }
1323 }
1330 }
1337 }
1348 }
1388 // fall through
1419 // fall through
1425 # Backslash escaping
1430 }
1433 # Quoted literal
1437 # No terminating quote, assume literal "
1442 }
1444 # Quote at end of string, assume literal "
1446 }
1450 }
1463 }
1464 }
1465 }
1474 $ttl = 43200 - ( substr( $ts, 8, 2 ) % 12 ) * 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1475 } elseif ( $usedDay || $usedHebrewMonth || $usedIranianMonth || $usedHijriMonth || $usedHebrewYear || $usedIranianYear || $usedHijriYear || $usedTennoYear ) {
1476 // @todo Someone who understands the non-Gregorian calendars should write proper logic for them
1477 // so that they don't need purged every day.
1481 $timeRemainingInDay = 86400 - substr( $ts, 8, 2 ) * 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1483 $possibleTtls[] = ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 + $timeRemainingInDay;
1485 // December 28th falls on the last ISO week of the year, every year.
1486 // The last ISO week of a year can be 52 or 53.
1487 $lastWeekOfISOYear = DateTime::createFromFormat( 'Ymd', substr( $ts, 0, 4 ) . '1228', $zone ?: new DateTimeZone( 'UTC' ) )->format( 'W' );
1490 $timeRemainingInWeek = ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 + $timeRemainingInDay;
1492 }
1495 $possibleTtls[] = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 't' ) - substr( $ts, 6, 2 ) ) * 86400 + $timeRemainingInDay;
1497 $possibleTtls[] = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1501 $timeRemainingInYear = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1505 // this isn't a leap year. see when the next one starts
1511 }
1513 // this is a leap year, so the next year isn't
1515 }
1516 }
1520 }
1521 }
1524 }
1529 /**
1530 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1531 * Gregorian dates to Iranian dates. Originally written in C, it
1532 * is released under the terms of GNU Lesser General Public
1533 * License. Conversion to PHP was performed by Niklas Laxström.
1534 *
1535 * Link: http://www.farsiweb.info/jalali/jalali.c
1536 *
1537 * @param string $ts
1538 *
1539 * @return string
1540 */
1546 # Days passed from the beginning (including leap years)
1552 // Add days of the past months of this year
1555 }
1557 // Leap years
1560 }
1562 // Days passed in current month
1576 }
1580 }
1586 }
1588 /**
1589 * Converting Gregorian dates to Hijri dates.
1590 *
1591 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1592 *
1593 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1594 *
1595 * @param string $ts
1596 *
1597 * @return string
1598 */
1612 ) {
1620 }
1634 }
1636 /**
1637 * Converting Gregorian dates to Hebrew dates.
1638 *
1639 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1640 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1641 * to translate the relevant functions into PHP and release them under
1642 * GNU GPL.
1643 *
1644 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1645 * and Adar II is 14. In a non-leap year, Adar is 6.
1646 *
1647 * @param string $ts
1648 *
1649 * @return string
1650 */
1652 # Parse date
1657 # Calculate Hebrew year
1660 # Month number when September = 1, August = 12
1663 # Next year
1667 }
1669 # Calculate day of year from 1 September
1673 # February
1675 # Check if the year is leap
1678 }
1683 }
1684 }
1686 # Calculate the start of the Hebrew year
1689 # Calculate next year's start
1691 # Day is before the start of the year - it is the previous year
1692 # Next year's start
1694 # Previous year
1697 # Add days since previous year's 1 September
1700 # Leap year
1702 }
1703 # Start of the new (previous) year
1706 # Next year's start
1708 }
1710 # Calculate Hebrew day of year
1713 # Difference between year's days
1715 # Add 12 (or 13 for leap years) days to ignore the difference between
1716 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1717 # difference is only about the year type
1722 }
1724 # Check the year pattern, and is leap year
1725 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1726 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1727 # and non-leap years
1729 # Check if leap year
1732 # Calculate day in the month from number of day in the Hebrew year
1733 # Don't check Adar - if the day is not in Adar, we will stop before;
1734 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1739 # Calculate days in this month
1741 # Adar in a leap year
1743 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1746 # Day in Adar I
1749 # Subtract the days of Adar I
1751 # Try Adar II
1754 # Day in Adar II
1756 }
1757 }
1758 }
1760 # Cheshvan in a complete year (otherwise as the rule below)
1763 # Kislev in an incomplete year (otherwise as the rule below)
1766 # Odd months have 30 days, even have 29
1768 }
1770 # In the current month
1773 # Subtract the days of the current month
1775 # Try in the next month
1777 }
1778 }
1781 }
1783 /**
1784 * This calculates the Hebrew year start, as days since 1 September.
1785 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1786 * Used for Hebrew date.
1787 *
1788 * @param int $year
1789 *
1790 * @return string
1791 */
1798 }
1802 }
1812 }
1816 }
1818 /**
1819 * Algorithm to convert Gregorian dates to Thai solar dates,
1820 * Minguo dates or Minguo dates.
1821 *
1822 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1823 * http://en.wikipedia.org/wiki/Minguo_calendar
1824 * http://en.wikipedia.org/wiki/Japanese_era_name
1825 *
1826 * @param string $ts 14-character timestamp
1827 * @param string $cName Calender name
1828 * @return array Converted year, month, day
1829 */
1836 # Thai solar dates
1837 # Add 543 years to the Gregorian calendar
1838 # Months and days are identical
1841 # Minguo dates
1842 # Deduct 1911 years from the Gregorian calendar
1843 # Months and days are identical
1846 # Nengō dates up to Meiji period
1847 # Deduct years from the Gregorian calendar
1848 # depending on the nengo periods
1849 # Months and days are identical
1853 ) {
1854 # Meiji period
1859 }
1867 ) {
1868 # Taishō period
1873 }
1879 ) {
1880 # Shōwa period
1885 }
1888 # Heisei period
1893 }
1895 }
1898 }
1901 }
1903 /**
1904 * Roman number formatting up to 10000
1905 *
1906 * @param int $num
1907 *
1908 * @return string
1909 */
1917 );
1922 }
1928 }
1930 }
1932 }
1934 /**
1935 * Hebrew Gematria number formatting up to 9999
1936 *
1937 * @param int $num
1938 *
1939 * @return string
1940 */
1947 );
1952 }
1964 }
1965 }
1966 }
1968 }
1974 }
1993 }
1995 }
1997 /**
1998 * Used by date() and time() to adjust the time output.
1999 *
2000 * @param string $ts The time in date('YmdHis') format
2001 * @param mixed $tz Adjust the time by this amount (default false, mean we
2002 * get user timecorrection setting)
2003 * @return int
2004 */
2010 }
2023 }
2024 # Unrecognized timezone, default to 'Offset' with the stored offset.
2026 }
2029 # Global offset in minutes.
2041 }
2044 }
2045 }
2047 # No difference ? Return time unchanged
2050 }
2053 # Generate an adjusted date; take advantage of the fact that mktime
2054 # will normalize out-of-range values so we don't have to split $minDiff
2055 # into hours and minutes.
2068 }
2070 /**
2071 * This is meant to be used by time(), date(), and timeanddate() to get
2072 * the date preference they're supposed to use, it should be used in
2073 * all children.
2074 *
2075 *<code>
2076 * function timeanddate([...], $format = true) {
2077 * $datePreference = $this->dateFormat($format);
2078 * [...]
2079 * }
2080 *</code>
2081 *
2082 * @param int|string|bool $usePrefs If true, the user's preference is used
2083 * if false, the site/language default is used
2084 * if int/string, assumed to be a format.
2085 * @return string
2086 */
2095 }
2098 }
2100 // return int
2103 }
2106 }
2108 /**
2109 * Get a format string for a given type and preference
2110 * @param string $type May be date, time or both
2111 * @param string $pref The format name as it appears in Messages*.php
2112 *
2113 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2114 *
2115 * @return string
2116 */
2127 }
2132 }
2133 }
2135 }
2137 }
2139 /**
2140 * @param string $ts The time format which needs to be turned into a
2141 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2142 * @param bool $adj Whether to adjust the time output according to the
2143 * user configured offset ($timecorrection)
2144 * @param mixed $format True to use user's date format preference
2145 * @param string|bool $timecorrection The time offset as returned by
2146 * validateTimeZone() in Special:Preferences
2147 * @return string
2148 */
2153 }
2156 }
2158 /**
2159 * @param string $ts The time format which needs to be turned into a
2160 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2161 * @param bool $adj Whether to adjust the time output according to the
2162 * user configured offset ($timecorrection)
2163 * @param mixed $format True to use user's date format preference
2164 * @param string|bool $timecorrection The time offset as returned by
2165 * validateTimeZone() in Special:Preferences
2166 * @return string
2167 */
2172 }
2175 }
2177 /**
2178 * @param string $ts The time format which needs to be turned into a
2179 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2180 * @param bool $adj Whether to adjust the time output according to the
2181 * user configured offset ($timecorrection)
2182 * @param mixed $format What format to return, if it's false output the
2183 * default one (default true)
2184 * @param string|bool $timecorrection The time offset as returned by
2185 * validateTimeZone() in Special:Preferences
2186 * @return string
2187 */
2192 }
2195 }
2197 /**
2198 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2199 *
2200 * @since 1.20
2201 *
2202 * @param int $seconds The amount of seconds.
2203 * @param array $chosenIntervals The intervals to enable.
2204 *
2205 * @return string
2206 */
2213 // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2214 // duration-years, duration-decades, duration-centuries, duration-millennia
2217 }
2220 }
2222 /**
2223 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2224 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2225 *
2226 * @since 1.20
2227 *
2228 * @param int $seconds The amount of seconds.
2229 * @param array $chosenIntervals The intervals to enable.
2230 *
2231 * @return array
2232 */
2243 'seconds'
2244 );
2245 }
2259 }
2260 }
2263 }
2265 /**
2266 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2267 *
2268 * @param string $type Can be 'date', 'time' or 'both'
2269 * @param string $ts The time format which needs to be turned into a
2270 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2271 * @param User $user User object used to get preferences for timezone and format
2272 * @param array $options Array, can contain the following keys:
2273 * - 'timecorrection': time correction, can have the following values:
2274 * - true: use user's preference
2275 * - false: don't use time correction
2276 * - int: value of time correction in minutes
2277 * - 'format': format to use, can have the following values:
2278 * - true: use user's preference
2279 * - false: use default preference
2280 * - string: format to use
2281 * @since 1.19
2282 * @return string
2283 */
2292 }
2294 }
2299 }
2302 }
2304 /**
2305 * Get the formatted date for the given timestamp and formatted for
2306 * the given user.
2307 *
2308 * @param mixed $ts Mixed: the time format which needs to be turned into a
2309 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2310 * @param User $user User object used to get preferences for timezone and format
2311 * @param array $options Array, can contain the following keys:
2312 * - 'timecorrection': time correction, can have the following values:
2313 * - true: use user's preference
2314 * - false: don't use time correction
2315 * - int: value of time correction in minutes
2316 * - 'format': format to use, can have the following values:
2317 * - true: use user's preference
2318 * - false: use default preference
2319 * - string: format to use
2320 * @since 1.19
2321 * @return string
2322 */
2325 }
2327 /**
2328 * Get the formatted time for the given timestamp and formatted for
2329 * the given user.
2330 *
2331 * @param mixed $ts The time format which needs to be turned into a
2332 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2333 * @param User $user User object used to get preferences for timezone and format
2334 * @param array $options Array, can contain the following keys:
2335 * - 'timecorrection': time correction, can have the following values:
2336 * - true: use user's preference
2337 * - false: don't use time correction
2338 * - int: value of time correction in minutes
2339 * - 'format': format to use, can have the following values:
2340 * - true: use user's preference
2341 * - false: use default preference
2342 * - string: format to use
2343 * @since 1.19
2344 * @return string
2345 */
2348 }
2350 /**
2351 * Get the formatted date and time for the given timestamp and formatted for
2352 * the given user.
2353 *
2354 * @param mixed $ts the time format which needs to be turned into a
2355 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2356 * @param User $user User object used to get preferences for timezone and format
2357 * @param array $options Array, can contain the following keys:
2358 * - 'timecorrection': time correction, can have the following values:
2359 * - true: use user's preference
2360 * - false: don't use time correction
2361 * - int: value of time correction in minutes
2362 * - 'format': format to use, can have the following values:
2363 * - true: use user's preference
2364 * - false: use default preference
2365 * - string: format to use
2366 * @since 1.19
2367 * @return string
2368 */
2371 }
2373 /**
2374 * Convert an MWTimestamp into a pretty human-readable timestamp using
2375 * the given user preferences and relative base time.
2376 *
2377 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2378 * on your timestamp object, which will then call this function. Calling
2379 * this function directly will cause hooks to be skipped over.
2380 *
2381 * @see MWTimestamp::getHumanTimestamp
2382 * @param MWTimestamp $ts Timestamp to prettify
2383 * @param MWTimestamp $relativeTo Base timestamp
2384 * @param User $user User preferences to use
2385 * @return string Human timestamp
2386 * @since 1.22
2387 */
2395 ) {
2396 // Timestamps are in different years: use full timestamp
2397 // Also do full timestamp for future dates
2398 /**
2399 * @todo FIXME: Add better handling of future timestamps.
2400 */
2404 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2408 // Timestamp within the past week: show the day of the week and time
2411 // Messages:
2412 // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2418 // Timestamp was yesterday: say 'yesterday' and the time.
2425 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2432 // From here on in, the timestamp was soon enough ago so that we can simply say
2433 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2435 // Less than 90 minutes, but more than an hour ago.
2438 // A few minutes ago.
2441 // Less than a minute, but more than 30 sec ago.
2444 // Less than 30 seconds ago.
2446 }
2449 }
2451 /**
2452 * @param string $key
2453 * @return array|null
2454 */
2457 }
2459 /**
2460 * @return array
2461 */
2464 }
2466 /**
2467 * @param string $in
2468 * @param string $out
2469 * @param string $string
2470 * @return string
2471 */
2473 # This is a wrapper for iconv in all languages except esperanto,
2474 # which does some nasty x-conversions beforehand
2476 # Even with //IGNORE iconv can whine about illegal characters in
2477 # *input* string. We just ignore those too.
2478 # REF: http://bugs.php.net/bug.php?id=37166
2479 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2484 }
2486 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2488 /**
2489 * @param array $matches
2490 * @return mixed|string
2491 */
2494 }
2496 /**
2497 * @param array $matches
2498 * @return string
2499 */
2502 }
2504 /**
2505 * @param array $matches
2506 * @return string
2507 */
2511 }
2513 /**
2514 * @param array $matches
2515 * @return string
2516 */
2520 }
2522 /**
2523 * @param array $matches
2524 * @return string
2525 */
2528 }
2530 /**
2531 * @param array $matches
2532 * @return string
2533 */
2537 }
2539 /**
2540 * Make a string's first character uppercase
2541 *
2542 * @param string $str
2543 *
2544 * @return string
2545 */
2553 // fall back to more complex logic in case of multibyte strings
2555 }
2556 }
2558 /**
2559 * Convert a string to uppercase
2560 *
2561 * @param string $str
2562 * @param bool $first
2563 *
2564 * @return string
2565 */
2573 }
2576 }
2583 $str
2584 );
2587 }
2588 }
2589 }
2591 /**
2592 * @param string $str
2593 * @return mixed|string
2594 */
2606 }
2607 }
2609 /**
2610 * @param string $str
2611 * @param bool $first
2612 * @return mixed|string
2613 */
2621 }
2624 }
2631 $str
2632 );
2635 }
2636 }
2637 }
2639 /**
2640 * @param string $str
2641 * @return bool
2642 */
2645 }
2647 /**
2648 * @param string $str
2649 * @return mixed|string
2650 */
2655 // regexp to find first letter in each word (i.e. after each space)
2656 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2658 // function to use to capitalize a single char
2663 $str
2664 );
2669 $str
2670 );
2671 }
2674 }
2675 }
2677 /**
2678 * capitalize words at word breaks
2679 *
2680 * @param string $str
2681 * @return mixed
2682 */
2687 // since \b doesn't work for UTF-8, we explicitely define word break chars
2690 // find first letter after word break
2698 $str
2699 );
2704 $str
2705 );
2706 }
2711 $str
2712 );
2713 }
2714 }
2716 /**
2717 * Return a case-folded representation of $s
2718 *
2719 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2720 * and $s2 are the same except for the case of their characters. It is not
2721 * necessary for the value returned to make sense when displayed.
2722 *
2723 * Do *not* perform any other normalisation in this function. If a caller
2724 * uses this function when it should be using a more general normalisation
2725 * function, then fix the caller.
2726 *
2727 * @param string $s
2728 *
2729 * @return string
2730 */
2733 }
2735 /**
2736 * @param string $s
2737 * @return string
2738 */
2742 }
2745 }
2748 }
2750 /**
2751 * @return array
2752 */
2755 }
2757 /**
2758 * Most writing systems use whitespace to break up words.
2759 * Some languages such as Chinese don't conventionally do this,
2760 * which requires special handling when breaking up words for
2761 * searching etc.
2762 *
2763 * @return bool
2764 */
2767 }
2769 /**
2770 * Some languages such as Chinese require word segmentation,
2771 * Specify such segmentation when overridden in derived class.
2772 *
2773 * @param string $string
2774 * @return string
2775 */
2778 }
2780 /**
2781 * Some languages have special punctuation need to be normalized.
2782 * Make such changes here.
2783 *
2784 * @param string $string
2785 * @return string
2786 */
2789 }
2791 /**
2792 * convert double-width roman characters to single-width.
2793 * range: ff00-ff5f ~= 0020-007f
2794 *
2795 * @param string $string
2796 *
2797 * @return string
2798 */
2808 }
2812 }
2814 /**
2815 * @param string $string
2816 * @param string $pattern
2817 * @return string
2818 */
2823 }
2825 /**
2826 * @param array $termsArray
2827 * @return array
2828 */
2830 # some languages, e.g. Chinese, need to do a conversion
2831 # in order for search results to be displayed correctly
2833 }
2835 /**
2836 * Get the first character of a string.
2837 *
2838 * @param string $s
2839 * @return string
2840 */
2847 $matches
2848 );
2853 }
2855 // Break down Hangul syllables to grab the first jamo
2887 }
2890 }
2891 }
2894 # Some languages may have an alternate char encoding option
2895 # (Esperanto X-coding, Japanese furigana conversion, etc)
2896 # If this language is used as the primary content language,
2897 # an override to the defaults can be set here on startup.
2898 }
2900 /**
2901 * @param string $s
2902 * @return string
2903 */
2905 # For some languages we'll want to explicitly specify
2906 # which characters make it into the edit box raw
2907 # or are converted in some way or another.
2913 }
2914 }
2916 /**
2917 * @param string $s
2918 * @return string
2919 */
2921 # Take the previous into account.
2927 }
2932 }
2933 }
2935 /**
2936 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2937 * also cleans up certain backwards-compatible sequences, converting them
2938 * to the modern Unicode equivalent.
2939 *
2940 * This is language-specific for performance reasons only.
2941 *
2942 * @param string $s
2943 *
2944 * @return string
2945 */
2952 }
2955 }
2957 /**
2958 * Transform a string using serialized data stored in the given file (which
2959 * must be in the serialized subdirectory of $IP). The file contains pairs
2960 * mapping source characters to destination characters.
2961 *
2962 * The data is cached in process memory. This will go faster if you have the
2963 * FastStringSearch extension.
2964 *
2965 * @param string $file
2966 * @param string $string
2967 *
2968 * @throws MWException
2969 * @return string
2970 */
2976 }
2978 }
2980 }
2982 /**
2983 * For right-to-left language support
2984 *
2985 * @return bool
2986 */
2989 }
2991 /**
2992 * Return the correct HTML 'dir' attribute value for this language.
2993 * @return string
2994 */
2997 }
2999 /**
3000 * Return 'left' or 'right' as appropriate alignment for line-start
3001 * for this language's text direction.
3002 *
3003 * Should be equivalent to CSS3 'start' text-align value....
3004 *
3005 * @return string
3006 */
3009 }
3011 /**
3012 * Return 'right' or 'left' as appropriate alignment for line-end
3013 * for this language's text direction.
3014 *
3015 * Should be equivalent to CSS3 'end' text-align value....
3016 *
3017 * @return string
3018 */
3021 }
3023 /**
3024 * A hidden direction mark (LRM or RLM), depending on the language direction.
3025 * Unlike getDirMark(), this function returns the character as an HTML entity.
3026 * This function should be used when the output is guaranteed to be HTML,
3027 * because it makes the output HTML source code more readable. When
3028 * the output is plain text or can be escaped, getDirMark() should be used.
3029 *
3030 * @param bool $opposite Get the direction mark opposite to your language
3031 * @return string
3032 * @since 1.20
3033 */
3037 }
3039 }
3041 /**
3042 * A hidden direction mark (LRM or RLM), depending on the language direction.
3043 * This function produces them as invisible Unicode characters and
3044 * the output may be hard to read and debug, so it should only be used
3045 * when the output is plain text or can be escaped. When the output is
3046 * HTML, use getDirMarkEntity() instead.
3047 *
3048 * @param bool $opposite Get the direction mark opposite to your language
3049 * @return string
3050 */
3056 }
3058 }
3060 /**
3061 * @return array
3062 */
3065 }
3067 /**
3068 * An arrow, depending on the language direction.
3069 *
3070 * @param string $direction The direction of the arrow: forwards (default),
3071 * backwards, left, right, up, down.
3072 * @return string
3073 */
3088 }
3089 }
3091 /**
3092 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
3093 *
3094 * @return bool
3095 */
3098 }
3100 /**
3101 * Get all magic words from cache.
3102 * @return array
3103 */
3106 }
3108 /**
3109 * Run the LanguageGetMagic hook once.
3110 */
3114 }
3119 }
3121 /**
3122 * Fill a MagicWord object with data from here
3123 *
3124 * @param MagicWord $mw
3125 */
3127 // Saves a function call
3130 }
3137 }
3144 }
3145 }
3147 /**
3148 * Add magic words to the extension array
3149 *
3150 * @param array $newWords
3151 */
3158 }
3159 }
3160 }
3162 /**
3163 * Get special page names, as an associative array
3164 * case folded alias => real name
3165 * @return array
3166 */
3168 // Cache aliases because it may be slow to load them
3170 // Initialise array
3175 }
3178 }
3180 /**
3181 * Italic is unsuitable for some languages
3182 *
3183 * @param string $text The text to be emphasized.
3184 * @return string
3185 */
3188 }
3190 /**
3191 * Normally we output all numbers in plain en_US style, that is
3192 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3193 * point twohundredthirtyfive. However this is not suitable for all
3194 * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3195 * Icelandic just want to use commas instead of dots, and dots instead
3196 * of commas like "293.291,235".
3197 *
3198 * An example of this function being called:
3199 * <code>
3200 * wfMessage( 'message' )->numParams( $num )->text()
3201 * </code>
3202 *
3203 * See $separatorTransformTable on MessageIs.php for
3204 * the , => . and . => , implementation.
3205 *
3206 * @todo check if it's viable to use localeconv() for the decimal separator thing.
3207 * @param int|float $number The string to be formatted, should be an integer
3208 * or a floating point number.
3209 * @param bool $nocommafy Set to true for special numbers like dates
3210 * @return string
3211 */
3219 }
3220 }
3226 }
3227 }
3230 }
3232 /**
3233 * Front-end for non-commafied formatNum
3234 *
3235 * @param int|float $number The string to be formatted, should be an integer
3236 * or a floating point number.
3237 * @since 1.21
3238 * @return string
3239 */
3242 }
3244 /**
3245 * @param string $number
3246 * @return string
3247 */
3251 // eliminate empty array values such as ''. (bug 64347)
3254 }
3258 // eliminate empty array values such as ''. (bug 64347)
3261 }
3265 }
3267 /**
3268 * Adds commas to a given number
3269 * @since 1.19
3270 * @param mixed $number
3271 * @return string
3272 */
3277 }
3280 // default grouping is at thousands, use the same for ###,###,### pattern too.
3283 // Ref: http://cldr.unicode.org/translation/number-patterns
3286 // For negative numbers apply the algorithm like positive number and add sign.
3289 }
3297 // the string does not have any number part. Eg: .12345
3299 }
3307 }
3311 // use the last pattern for the rest of the number
3313 }
3316 }
3317 }
3319 }
3320 }
3322 /**
3323 * @return string
3324 */
3327 }
3329 /**
3330 * @return array
3331 */
3334 }
3336 /**
3337 * @return array
3338 */
3341 }
3343 /**
3344 * Take a list of strings and build a locale-friendly comma-separated
3345 * list, using the local comma-separator message.
3346 * The last two strings are chained with an "and".
3347 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3348 *
3349 * @param string[] $l
3350 * @return string
3351 */
3356 }
3362 }
3363 }
3370 }
3371 }
3373 }
3375 /**
3376 * Take a list of strings and build a locale-friendly comma-separated
3377 * list, using the local comma-separator message.
3378 * @param string[] $list Array of strings to put in a comma list
3379 * @return string
3380 */
3384 $list
3385 );
3386 }
3388 /**
3389 * Take a list of strings and build a locale-friendly semicolon-separated
3390 * list, using the local semicolon-separator message.
3391 * @param string[] $list Array of strings to put in a semicolon list
3392 * @return string
3393 */
3397 $list
3398 );
3399 }
3401 /**
3402 * Same as commaList, but separate it with the pipe instead.
3403 * @param string[] $list Array of strings to put in a pipe list
3404 * @return string
3405 */
3409 $list
3410 );
3411 }
3413 /**
3414 * Truncate a string to a specified length in bytes, appending an optional
3415 * string (e.g. for ellipses)
3416 *
3417 * The database offers limited byte lengths for some columns in the database;
3418 * multi-byte character sets mean we need to ensure that only whole characters
3419 * are included, otherwise broken characters can be passed to the user
3420 *
3421 * If $length is negative, the string will be truncated from the beginning
3422 *
3423 * @param string $string String to truncate
3424 * @param int $length Maximum length (including ellipses)
3425 * @param string $ellipsis String to append to the truncated text
3426 * @param bool $adjustLength Subtract length of ellipsis from $length.
3427 * $adjustLength was introduced in 1.18, before that behaved as if false.
3428 * @return string
3429 */
3431 # Use the localized ellipsis character
3434 }
3435 # Check if there is no need to truncate
3440 }
3442 # If ellipsis length is >= $length then we can't apply $adjustLength
3445 # Otherwise, truncate and add ellipsis...
3460 }
3461 }
3462 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3463 # This check is *not* redundant if $adjustLength, due to the single case where
3464 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3469 }
3470 }
3472 /**
3473 * Remove bytes that represent an incomplete Unicode character
3474 * at the end of string (e.g. bytes of the char are missing)
3475 *
3476 * @param string $string
3477 * @return string
3478 */
3484 # We got the first byte only of a multibyte char; remove it.
3489 ) {
3490 # We chopped in the middle of a character; remove it
3492 }
3493 }
3495 }
3497 /**
3498 * Remove bytes that represent an incomplete Unicode character
3499 * at the start of string (e.g. bytes of the char are missing)
3500 *
3501 * @param string $string
3502 * @return string
3503 */
3508 # We chopped in the middle of a character; remove the whole thing
3510 }
3511 }
3513 }
3515 /**
3516 * Truncate a string of valid HTML to a specified length in bytes,
3517 * appending an optional string (e.g. for ellipses), and return valid HTML
3518 *
3519 * This is only intended for styled/linked text, such as HTML with
3520 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3521 * Also, this will not detect things like "display:none" CSS.
3522 *
3523 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3524 *
3525 * @param string $text HTML string to truncate
3526 * @param int $length (zero/positive) Maximum length (including ellipses)
3527 * @param string $ellipsis String to append to the truncated text
3528 * @return string
3529 */
3531 # Use the localized ellipsis character
3534 }
3535 # Check if there is clearly no need to truncate
3540 }
3554 # Consider truncation once the display length has reached the maximim.
3555 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3556 # Check that we're not in the middle of a bracket/entity...
3560 # Save where we are; we will truncate here unless there turn out to
3561 # be so few remaining characters that truncation is not necessary.
3564 }
3566 # String in fact does need truncation, the truncation point was OK.
3571 }
3572 }
3575 }
3577 # Read the next char...
3595 }
3601 // Name found (e.g. "<a href=..."), add on tag attributes...
3603 }
3609 }
3612 // Save state without $ch. We want to *hit* the first
3613 // display char (to get tags) but not *use* it if truncating.
3615 }
3620 // Add the next $max display text chars after this in one swoop...
3625 }
3626 }
3627 }
3628 }
3629 // Close the last tag if left unclosed by bad HTML
3633 }
3635 }
3637 /**
3638 * truncateHtml() helper function
3639 * like strcspn() but adds the skipped chars to $ret
3640 *
3641 * @param string $ret
3642 * @param string $text
3643 * @param string $search
3644 * @param int $start
3645 * @param null|int $len
3646 * @return int
3647 */
3653 }
3658 }
3660 }
3662 /**
3663 * truncateHtml() helper function
3664 * (a) push or pop $tag from $openTags as needed
3665 * (b) clear $tag value
3666 * @param string &$tag Current HTML tag name we are looking at
3667 * @param int $tagType (0-open tag, 1-close tag)
3668 * @param string $lastCh Character before the '>' that ended this tag
3669 * @param array &$openTags Open tag stack (not accounting for $tag)
3670 */
3679 }
3680 }
3682 }
3683 }
3685 /**
3686 * Grammatical transformations, needed for inflected languages
3687 * Invoked by putting {{grammar:case|word}} in a message
3688 *
3689 * @param string $word
3690 * @param string $case
3691 * @return string
3692 */
3697 }
3700 }
3701 /**
3702 * Get the grammar forms for the content language
3703 * @return array Array of grammar forms
3704 * @since 1.20
3705 */
3710 ) {
3712 }
3715 }
3716 /**
3717 * Provides an alternative text depending on specified gender.
3718 * Usage {{gender:username|masculine|feminine|unknown}}.
3719 * username is optional, in which case the gender of current user is used,
3720 * but only in (some) interface messages; otherwise default gender is used.
3721 *
3722 * If no forms are given, an empty string is returned. If only one form is
3723 * given, it will be returned unconditionally. These details are implied by
3724 * the caller and cannot be overridden in subclasses.
3725 *
3726 * If three forms are given, the default is to use the third (unknown) form.
3727 * If fewer than three forms are given, the default is to use the first (masculine) form.
3728 * These details can be overridden in subclasses.
3729 *
3730 * @param string $gender
3731 * @param array $forms
3732 *
3733 * @return string
3734 */
3738 }
3742 }
3745 }
3747 }
3749 /**
3750 * Plural form transformations, needed for some languages.
3751 * For example, there are 3 form of plural in Russian and Polish,
3752 * depending on "count mod 10". See [[w:Plural]]
3753 * For English it is pretty simple.
3754 *
3755 * Invoked by putting {{plural:count|wordform1|wordform2}}
3756 * or {{plural:count|wordform1|wordform2|wordform3}}
3757 *
3758 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3759 *
3760 * @param int $count Non-localized number
3761 * @param array $forms Different plural forms
3762 * @return string Correct form of plural for $count in this language
3763 */
3765 // Handle explicit n=pluralform cases
3769 }
3772 }
3777 }
3779 /**
3780 * Handles explicit plural forms for Language::convertPlural()
3781 *
3782 * In {{PLURAL:$1|0=nothing|one|many}}, 0=nothing will be returned if $1 equals zero.
3783 * If an explicitly defined plural form matches the $count, then
3784 * string value returned, otherwise array returned for further consideration
3785 * by CLDR rules or overridden convertPlural().
3786 *
3787 * @since 1.23
3788 *
3789 * @param int $count non-localized number
3790 * @param array $forms different plural forms
3791 *
3792 * @return array|string
3793 */
3800 }
3802 }
3803 }
3805 }
3807 /**
3808 * Checks that convertPlural was given an array and pads it to requested
3809 * amount of forms by copying the last one.
3810 *
3811 * @param int $count How many forms should there be at least
3812 * @param array $forms Array of forms given to convertPlural
3813 * @return array Padded array of forms or an exception if not an array
3814 */
3818 }
3820 }
3822 /**
3823 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3824 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3825 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3826 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3827 * match up with it.
3828 *
3829 * @param string $str The validated block duration in English
3830 * @return string Somehow translated block duration
3831 * @see LanguageFi.php for example implementation
3832 */
3838 }
3839 }
3841 // Since usually only infinite or indefinite is only on list, so try
3842 // equivalents if still here.
3849 }
3850 }
3851 }
3853 // If all else fails, return a standard duration or timestamp description.
3858 // $time is relative to 0 so it's a duration length.
3862 // wfTimestamp() handles 0 as current time instead of epoch.
3866 }
3867 }
3868 }
3870 /**
3871 * languages like Chinese need to be segmented in order for the diff
3872 * to be of any use
3873 *
3874 * @param string $text
3875 * @return string
3876 */
3879 }
3881 /**
3882 * and unsegment to show the result
3883 *
3884 * @param string $text
3885 * @return string
3886 */
3889 }
3891 /**
3892 * Return the LanguageConverter used in the Language
3893 *
3894 * @since 1.19
3895 * @return LanguageConverter
3896 */
3899 }
3901 /**
3902 * convert text to all supported variants
3903 *
3904 * @param string $text
3905 * @return array
3906 */
3909 }
3911 /**
3912 * convert text to different variants of a language.
3913 *
3914 * @param string $text
3915 * @return string
3916 */
3919 }
3921 /**
3922 * Convert a Title object to a string in the preferred variant
3923 *
3924 * @param Title $title
3925 * @return string
3926 */
3929 }
3931 /**
3932 * Convert a namespace index to a string in the preferred variant
3933 *
3934 * @param int $ns
3935 * @return string
3936 */
3939 }
3941 /**
3942 * Check if this is a language with variants
3943 *
3944 * @return bool
3945 */
3948 }
3950 /**
3951 * Check if the language has the specific variant
3952 *
3953 * @since 1.19
3954 * @param string $variant
3955 * @return bool
3956 */
3959 }
3961 /**
3962 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3963 *
3964 * @param string $text
3965 * @return string
3966 * @deprecated since 1.22 is no longer used
3967 */
3970 }
3972 /**
3973 * Perform output conversion on a string, and encode for safe HTML output.
3974 * @param string $text Text to be converted
3975 * @param bool $isTitle Whether this conversion is for the article title
3976 * @return string
3977 * @todo this should get integrated somewhere sane
3978 */
3981 }
3983 /**
3984 * @param string $key
3985 * @return string
3986 */
3989 }
3991 /**
3992 * Get the list of variants supported by this language
3993 * see sample implementation in LanguageZh.php
3994 *
3995 * @return array an array of language codes
3996 */
3999 }
4001 /**
4002 * @return string
4003 */
4006 }
4008 /**
4009 * @return string
4010 */
4013 }
4015 /**
4016 * @return string
4017 */
4020 }
4022 /**
4023 * If a language supports multiple variants, it is
4024 * possible that non-existing link in one variant
4025 * actually exists in another variant. this function
4026 * tries to find it. See e.g. LanguageZh.php
4027 *
4028 * @param string $link The name of the link
4029 * @param Title $nt The title object of the link
4030 * @param bool $ignoreOtherCond To disable other conditions when
4031 * we need to transclude a template or update a category's link
4032 * @return null the input parameters may be modified upon return
4033 */
4036 }
4038 /**
4039 * returns language specific options used by User::getPageRenderHash()
4040 * for example, the preferred language variant
4041 *
4042 * @return string
4043 */
4046 }
4048 /**
4049 * For languages that support multiple variants, the title of an
4050 * article may be displayed differently in different variants. this
4051 * function returns the apporiate title defined in the body of the article.
4052 *
4053 * @return string
4054 */
4057 }
4059 /**
4060 * Prepare external link text for conversion. When the text is
4061 * a URL, it shouldn't be converted, and it'll be wrapped in
4062 * the "raw" tag (-{R| }-) to prevent conversion.
4063 *
4064 * This function is called "markNoConversion" for historical
4065 * reasons.
4066 *
4067 * @param string $text Text to be used for external link
4068 * @param bool $noParse Wrap it without confirming it's a real URL first
4069 * @return string The tagged text
4070 */
4072 // Excluding protocal-relative URLs may avoid many false positives.
4077 }
4078 }
4080 /**
4081 * A regular expression to match legal word-trailing characters
4082 * which should be merged onto a link of the form [[foo]]bar.
4083 *
4084 * @return string
4085 */
4088 }
4090 /**
4091 * A regular expression character set to match legal word-prefixing
4092 * characters which should be merged onto a link of the form foo[[bar]].
4093 *
4094 * @return string
4095 */
4098 }
4100 /**
4101 * @deprecated since 1.24, will be removed in 1.25
4102 * @return Language
4103 */
4107 }
4109 /**
4110 * Get the "parent" language which has a converter to convert a "compatible" language
4111 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
4112 *
4113 * @return Language|null
4114 * @since 1.22
4115 */
4119 }
4126 }
4131 }
4135 }
4137 /**
4138 * Get the RFC 3066 code for this language object
4139 *
4140 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4141 * htmlspecialchars() or similar
4142 *
4143 * @return string
4144 */
4147 }
4149 /**
4150 * Get the code in Bcp47 format which we can use
4151 * inside of html lang="" tags.
4152 *
4153 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4154 * htmlspecialchars() or similar.
4155 *
4156 * @since 1.19
4157 * @return string
4158 */
4162 }
4164 }
4166 /**
4167 * @param string $code
4168 */
4171 // Ensure we don't leave incorrect cached data lying around
4174 }
4176 /**
4177 * Get the name of a file for a certain language code
4178 * @param string $prefix Prepend this to the filename
4179 * @param string $code Language code
4180 * @param string $suffix Append this to the filename
4181 * @throws MWException
4182 * @return string $prefix . $mangledCode . $suffix
4183 */
4187 }
4190 }
4192 /**
4193 * Get the language code from a file name. Inverse of getFileName()
4194 * @param string $filename $prefix . $languageCode . $suffix
4195 * @param string $prefix Prefix before the language code
4196 * @param string $suffix Suffix after the language code
4197 * @return string Language code, or false if $prefix or $suffix isn't found
4198 */
4199 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4205 }
4207 }
4209 /**
4210 * @param string $code
4211 * @return string
4212 */
4218 }
4220 /**
4221 * @param string $code
4222 * @return string
4223 * @since 1.23
4224 */
4230 }
4233 }
4235 /**
4236 * @param string $code
4237 * @return string
4238 */
4242 }
4244 /**
4245 * Get the first fallback for a given language.
4246 *
4247 * @param string $code
4248 *
4249 * @return bool|string
4250 */
4258 }
4259 }
4261 /**
4262 * Get the ordered list of fallback languages.
4263 *
4264 * @since 1.19
4265 * @param string $code Language code
4266 * @return array
4267 */
4276 }
4278 }
4279 }
4281 /**
4282 * Get the ordered list of fallback languages, ending with the fallback
4283 * language chain for the site language.
4284 *
4285 * @since 1.22
4286 * @param string $code Language code
4287 * @return array array( fallbacks, site fallbacks )
4288 */
4292 // Usually, we will only store a tiny number of fallback chains, so we
4293 // keep them in static memory.
4299 // Append the site's fallback chain, including the site language itself
4303 // Eliminate any languages already included in the chain
4307 }
4309 }
4311 /**
4312 * Get all messages for a given language
4313 * WARNING: this may take a long time. If you just need all message *keys*
4314 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4315 *
4316 * @param string $code
4317 *
4318 * @return array
4319 */
4322 }
4324 /**
4325 * Get a message for a given language
4326 *
4327 * @param string $key
4328 * @param string $code
4329 *
4330 * @return string
4331 */
4334 }
4336 /**
4337 * Get all message keys for a given language. This is a faster alternative to
4338 * array_keys( Language::getMessagesFor( $code ) )
4339 *
4340 * @since 1.19
4341 * @param string $code Language code
4342 * @return array of message keys (strings)
4343 */
4346 }
4348 /**
4349 * @param string $talk
4350 * @return mixed
4351 */
4355 }
4360 # Allow grammar transformations
4361 # Allowing full message-style parsing would make simple requests
4362 # such as action=raw much more expensive than they need to be.
4363 # This will hopefully cover most cases.
4367 }
4369 /**
4370 * @param string $m
4371 * @return string
4372 */
4375 }
4377 /**
4378 * @throws MWException
4379 * @return array
4380 */
4385 }
4392 }
4397 }
4399 /**
4400 * Decode an expiry (block, protection, etc) which has come from the DB
4401 *
4402 * @todo FIXME: why are we returnings DBMS-dependent strings???
4403 *
4404 * @param string $expiry Database expiry String
4405 * @param bool|int $format True to process using language functions, or TS_ constant
4406 * to return the expiry in a given timestamp
4407 * @return string
4408 * @since 1.18
4409 */
4414 }
4424 }
4425 }
4427 /**
4428 * @todo Document
4429 * @param int|float $seconds
4430 * @param array $format Optional
4431 * If $format['avoid'] === 'avoidseconds': don't mention seconds if $seconds >= 1 hour.
4432 * If $format['avoid'] === 'avoidminutes': don't mention seconds/minutes if $seconds > 48 hours.
4433 * If $format['noabbrevs'] is true: use 'seconds' and friends instead of 'seconds-abbrev'
4434 * and friends.
4435 * For backwards compatibility, $format may also be one of the strings 'avoidseconds'
4436 * or 'avoidminutes'.
4437 * @return string
4438 */
4442 }
4445 }
4448 }
4470 }
4481 }
4485 }
4491 }
4499 }
4509 }
4513 }
4523 }
4524 }
4526 }
4528 /**
4529 * Format a bitrate for output, using an appropriate
4530 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to
4531 * the magnitude in question.
4532 *
4533 * This use base 1000. For base 1024 use formatSize(), for another base
4534 * see formatComputingNumbers().
4535 *
4536 * @param int $bps
4537 * @return string
4538 */
4541 }
4543 /**
4544 * @param int $size Size of the unit
4545 * @param int $boundary Size boundary (1000, or 1024 in most cases)
4546 * @param string $messageKey Message key to be uesd
4547 * @return string
4548 */
4553 );
4554 }
4562 }
4564 // For small sizes no decimal places necessary
4567 // For MB and bigger two decimal places are smarter
4569 }
4575 }
4577 /**
4578 * Format a size in bytes for output, using an appropriate
4579 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4580 *
4581 * This method use base 1024. For base 1000 use formatBitrate(), for
4582 * another base see formatComputingNumbers()
4583 *
4584 * @param int $size Size to format
4585 * @return string Plain text (not HTML)
4586 */
4589 }
4591 /**
4592 * Make a list item, used by various special pages
4593 *
4594 * @param string $page Page link
4595 * @param string $details Text between brackets
4596 * @param bool $oppositedm Add the direction mark opposite to your
4597 * language, to display text properly
4598 * @return string
4599 */
4606 }
4608 /**
4609 * Generate (prev x| next x) (20|50|100...) type links for paging
4610 *
4611 * @param Title $title Title object to link
4612 * @param int $offset
4613 * @param int $limit
4614 * @param array|string $query Optional URL query parameter string
4615 * @param bool $atend Optional param for specified if this is the last page
4616 * @return string
4617 */
4620 ) {
4621 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4623 # Make 'previous' link
4624 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4630 }
4632 # Make 'next' link
4633 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4639 }
4641 # Make links to set number of items per page
4646 }
4650 }
4652 /**
4653 * Helper function for viewPrevNext() that generates links
4654 *
4655 * @param Title $title Title object to link
4656 * @param int $offset
4657 * @param int $limit
4658 * @param array $query Extra query parameters
4659 * @param string $link Text to use for the link; will be escaped
4660 * @param string $tooltipMsg Name of the message to use as tooltip
4661 * @param string $class Value of the "class" attribute of the link
4662 * @return string HTML fragment
4663 */
4666 ) {
4673 }
4675 /**
4676 * Get the conversion rule title, if any.
4677 *
4678 * @return string
4679 */
4682 }
4684 /**
4685 * Get the compiled plural rules for the language
4686 * @since 1.20
4687 * @return array Associative array with plural form, and plural rule as key-value pairs
4688 */
4694 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4697 }
4698 }
4699 }
4701 }
4703 /**
4704 * Get the plural rules for the language
4705 * @since 1.20
4706 * @return array Associative array with plural form number and plural rule as key-value pairs
4707 */
4716 }
4717 }
4718 }
4720 }
4722 /**
4723 * Get the plural rule types for the language
4724 * @since 1.22
4725 * @return array Associative array with plural form number and plural rule type as key-value pairs
4726 */
4732 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4735 }
4736 }
4737 }
4739 }
4741 /**
4742 * Find the index number of the plural rule appropriate for the given number
4743 * @return int The index number of the plural rule
4744 */
4749 }
4751 /**
4752 * Find the plural rule type appropriate for the given number
4753 * For example, if the language is set to Arabic, getPluralType(5) should
4754 * return 'few'.
4755 * @since 1.22
4756 * @return string The name of the plural rule type, e.g. one, two, few, many
4757 */
4765 }
4766 }
4767 }