| blob | 2bc4554e5dc711050ffb787d6e5d645fa82d2d5f |
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 $tag
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 * @param DateTime|bool|null &$dateTimeObj
1030 * @param string $ts
1031 * @param DateTimeZone|bool|null $zone
1032 * @param string $code
1033 * @return string
1034 */
1039 );
1040 }
1042 }
1044 /**
1045 * This is a workalike of PHP's date() function, but with better
1046 * internationalisation, a reduced set of format characters, and a better
1047 * escaping format.
1048 *
1049 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1050 * the PHP manual for definitions. There are a number of extensions, which
1051 * start with "x":
1052 *
1053 * xn Do not translate digits of the next numeric format character
1054 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1055 * xr Use roman numerals for the next numeric format character
1056 * xh Use hebrew numerals for the next numeric format character
1057 * xx Literal x
1058 * xg Genitive month name
1059 *
1060 * xij j (day number) in Iranian calendar
1061 * xiF F (month name) in Iranian calendar
1062 * xin n (month number) in Iranian calendar
1063 * xiy y (two digit year) in Iranian calendar
1064 * xiY Y (full year) in Iranian calendar
1065 *
1066 * xjj j (day number) in Hebrew calendar
1067 * xjF F (month name) in Hebrew calendar
1068 * xjt t (days in month) in Hebrew calendar
1069 * xjx xg (genitive month name) in Hebrew calendar
1070 * xjn n (month number) in Hebrew calendar
1071 * xjY Y (full year) in Hebrew calendar
1072 *
1073 * xmj j (day number) in Hijri calendar
1074 * xmF F (month name) in Hijri calendar
1075 * xmn n (month number) in Hijri calendar
1076 * xmY Y (full year) in Hijri calendar
1077 *
1078 * xkY Y (full year) in Thai solar calendar. Months and days are
1079 * identical to the Gregorian calendar
1080 * xoY Y (full year) in Minguo calendar or Juche year.
1081 * Months and days are identical to the
1082 * Gregorian calendar
1083 * xtY Y (full year) in Japanese nengo. Months and days are
1084 * identical to the Gregorian calendar
1085 *
1086 * Characters enclosed in double quotes will be considered literal (with
1087 * the quotes themselves removed). Unmatched quotes will be considered
1088 * literal quotes. Example:
1089 *
1090 * "The month is" F => The month is January
1091 * i's" => 20'11"
1092 *
1093 * Backslash escaping is also supported.
1094 *
1095 * Input timestamp is assumed to be pre-normalized to the desired local
1096 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1097 * $ts is UTC if $zone is not given.
1098 *
1099 * @param string $format
1100 * @param string $ts 14-character timestamp
1101 * YYYYMMDDHHMMSS
1102 * 01234567890123
1103 * @param DateTimeZone $zone Timezone of $ts
1104 * @param[out] int $ttl The amount of time (in seconds) the output may be cached for.
1105 * Only makes sense if $ts is the current time.
1106 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1107 *
1108 * @throws MWException
1109 * @return string
1110 */
1146 }
1150 }
1158 }
1168 }
1194 }
1203 $s .= $this->getWeekdayAbbreviation( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1 );
1213 }
1220 }
1227 }
1232 $s .= $this->getWeekdayName( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1 );
1242 }
1249 }
1256 }
1275 }
1282 }
1289 }
1296 }
1307 }
1314 }
1321 }
1328 }
1335 }
1342 }
1353 }
1393 // fall through
1424 // fall through
1430 # Backslash escaping
1435 }
1438 # Quoted literal
1442 # No terminating quote, assume literal "
1447 }
1449 # Quote at end of string, assume literal "
1451 }
1455 }
1468 }
1469 }
1470 }
1479 $ttl = 43200 - ( substr( $ts, 8, 2 ) % 12 ) * 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1480 } elseif ( $usedDay || $usedHebrewMonth || $usedIranianMonth || $usedHijriMonth || $usedHebrewYear || $usedIranianYear || $usedHijriYear || $usedTennoYear ) {
1481 // @todo Someone who understands the non-Gregorian calendars should write proper logic for them
1482 // so that they don't need purged every day.
1486 $timeRemainingInDay = 86400 - substr( $ts, 8, 2 ) * 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1488 $possibleTtls[] = ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 + $timeRemainingInDay;
1490 // December 28th falls on the last ISO week of the year, every year.
1491 // The last ISO week of a year can be 52 or 53.
1492 $lastWeekOfISOYear = DateTime::createFromFormat( 'Ymd', substr( $ts, 0, 4 ) . '1228', $zone ?: new DateTimeZone( 'UTC' ) )->format( 'W' );
1495 $timeRemainingInWeek = ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 + $timeRemainingInDay;
1497 }
1500 $possibleTtls[] = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 't' ) - substr( $ts, 6, 2 ) ) * 86400 + $timeRemainingInDay;
1502 $possibleTtls[] = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1506 $timeRemainingInYear = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1510 // this isn't a leap year. see when the next one starts
1516 }
1518 // this is a leap year, so the next year isn't
1520 }
1521 }
1525 }
1526 }
1529 }
1534 /**
1535 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1536 * Gregorian dates to Iranian dates. Originally written in C, it
1537 * is released under the terms of GNU Lesser General Public
1538 * License. Conversion to PHP was performed by Niklas Laxström.
1539 *
1540 * Link: http://www.farsiweb.info/jalali/jalali.c
1541 *
1542 * @param string $ts
1543 *
1544 * @return string
1545 */
1551 # Days passed from the beginning (including leap years)
1557 // Add days of the past months of this year
1560 }
1562 // Leap years
1565 }
1567 // Days passed in current month
1581 }
1585 }
1591 }
1593 /**
1594 * Converting Gregorian dates to Hijri dates.
1595 *
1596 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1597 *
1598 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1599 *
1600 * @param string $ts
1601 *
1602 * @return string
1603 */
1617 ) {
1625 }
1639 }
1641 /**
1642 * Converting Gregorian dates to Hebrew dates.
1643 *
1644 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1645 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1646 * to translate the relevant functions into PHP and release them under
1647 * GNU GPL.
1648 *
1649 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1650 * and Adar II is 14. In a non-leap year, Adar is 6.
1651 *
1652 * @param string $ts
1653 *
1654 * @return string
1655 */
1657 # Parse date
1662 # Calculate Hebrew year
1665 # Month number when September = 1, August = 12
1668 # Next year
1672 }
1674 # Calculate day of year from 1 September
1678 # February
1680 # Check if the year is leap
1683 }
1688 }
1689 }
1691 # Calculate the start of the Hebrew year
1694 # Calculate next year's start
1696 # Day is before the start of the year - it is the previous year
1697 # Next year's start
1699 # Previous year
1702 # Add days since previous year's 1 September
1705 # Leap year
1707 }
1708 # Start of the new (previous) year
1711 # Next year's start
1713 }
1715 # Calculate Hebrew day of year
1718 # Difference between year's days
1720 # Add 12 (or 13 for leap years) days to ignore the difference between
1721 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1722 # difference is only about the year type
1727 }
1729 # Check the year pattern, and is leap year
1730 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1731 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1732 # and non-leap years
1734 # Check if leap year
1737 # Calculate day in the month from number of day in the Hebrew year
1738 # Don't check Adar - if the day is not in Adar, we will stop before;
1739 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1744 # Calculate days in this month
1746 # Adar in a leap year
1748 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1751 # Day in Adar I
1754 # Subtract the days of Adar I
1756 # Try Adar II
1759 # Day in Adar II
1761 }
1762 }
1763 }
1765 # Cheshvan in a complete year (otherwise as the rule below)
1768 # Kislev in an incomplete year (otherwise as the rule below)
1771 # Odd months have 30 days, even have 29
1773 }
1775 # In the current month
1778 # Subtract the days of the current month
1780 # Try in the next month
1782 }
1783 }
1786 }
1788 /**
1789 * This calculates the Hebrew year start, as days since 1 September.
1790 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1791 * Used for Hebrew date.
1792 *
1793 * @param int $year
1794 *
1795 * @return string
1796 */
1803 }
1807 }
1817 }
1821 }
1823 /**
1824 * Algorithm to convert Gregorian dates to Thai solar dates,
1825 * Minguo dates or Minguo dates.
1826 *
1827 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1828 * http://en.wikipedia.org/wiki/Minguo_calendar
1829 * http://en.wikipedia.org/wiki/Japanese_era_name
1830 *
1831 * @param string $ts 14-character timestamp
1832 * @param string $cName Calender name
1833 * @return array Converted year, month, day
1834 */
1841 # Thai solar dates
1842 # Add 543 years to the Gregorian calendar
1843 # Months and days are identical
1846 # Minguo dates
1847 # Deduct 1911 years from the Gregorian calendar
1848 # Months and days are identical
1851 # Nengō dates up to Meiji period
1852 # Deduct years from the Gregorian calendar
1853 # depending on the nengo periods
1854 # Months and days are identical
1858 ) {
1859 # Meiji period
1864 }
1872 ) {
1873 # Taishō period
1878 }
1884 ) {
1885 # Shōwa period
1890 }
1893 # Heisei period
1898 }
1900 }
1903 }
1906 }
1908 /**
1909 * Roman number formatting up to 10000
1910 *
1911 * @param int $num
1912 *
1913 * @return string
1914 */
1922 );
1927 }
1933 }
1935 }
1937 }
1939 /**
1940 * Hebrew Gematria number formatting up to 9999
1941 *
1942 * @param int $num
1943 *
1944 * @return string
1945 */
1952 );
1957 }
1969 }
1970 }
1971 }
1973 }
1979 }
1998 }
2000 }
2002 /**
2003 * Used by date() and time() to adjust the time output.
2004 *
2005 * @param string $ts The time in date('YmdHis') format
2006 * @param mixed $tz Adjust the time by this amount (default false, mean we
2007 * get user timecorrection setting)
2008 * @return int
2009 */
2015 }
2028 }
2029 # Unrecognized timezone, default to 'Offset' with the stored offset.
2031 }
2034 # Global offset in minutes.
2046 }
2049 }
2050 }
2052 # No difference ? Return time unchanged
2055 }
2058 # Generate an adjusted date; take advantage of the fact that mktime
2059 # will normalize out-of-range values so we don't have to split $minDiff
2060 # into hours and minutes.
2073 }
2075 /**
2076 * This is meant to be used by time(), date(), and timeanddate() to get
2077 * the date preference they're supposed to use, it should be used in
2078 * all children.
2079 *
2080 *<code>
2081 * function timeanddate([...], $format = true) {
2082 * $datePreference = $this->dateFormat($format);
2083 * [...]
2084 * }
2085 *</code>
2086 *
2087 * @param int|string|bool $usePrefs If true, the user's preference is used
2088 * if false, the site/language default is used
2089 * if int/string, assumed to be a format.
2090 * @return string
2091 */
2100 }
2103 }
2105 // return int
2108 }
2111 }
2113 /**
2114 * Get a format string for a given type and preference
2115 * @param string $type May be date, time or both
2116 * @param string $pref The format name as it appears in Messages*.php
2117 *
2118 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2119 *
2120 * @return string
2121 */
2132 }
2137 }
2138 }
2140 }
2142 }
2144 /**
2145 * @param string $ts The time format which needs to be turned into a
2146 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2147 * @param bool $adj Whether to adjust the time output according to the
2148 * user configured offset ($timecorrection)
2149 * @param mixed $format True to use user's date format preference
2150 * @param string|bool $timecorrection The time offset as returned by
2151 * validateTimeZone() in Special:Preferences
2152 * @return string
2153 */
2158 }
2161 }
2163 /**
2164 * @param string $ts The time format which needs to be turned into a
2165 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2166 * @param bool $adj Whether to adjust the time output according to the
2167 * user configured offset ($timecorrection)
2168 * @param mixed $format True to use user's date format preference
2169 * @param string|bool $timecorrection The time offset as returned by
2170 * validateTimeZone() in Special:Preferences
2171 * @return string
2172 */
2177 }
2180 }
2182 /**
2183 * @param string $ts The time format which needs to be turned into a
2184 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2185 * @param bool $adj Whether to adjust the time output according to the
2186 * user configured offset ($timecorrection)
2187 * @param mixed $format What format to return, if it's false output the
2188 * default one (default true)
2189 * @param string|bool $timecorrection The time offset as returned by
2190 * validateTimeZone() in Special:Preferences
2191 * @return string
2192 */
2197 }
2200 }
2202 /**
2203 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2204 *
2205 * @since 1.20
2206 *
2207 * @param int $seconds The amount of seconds.
2208 * @param array $chosenIntervals The intervals to enable.
2209 *
2210 * @return string
2211 */
2218 // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2219 // duration-years, duration-decades, duration-centuries, duration-millennia
2222 }
2225 }
2227 /**
2228 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2229 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2230 *
2231 * @since 1.20
2232 *
2233 * @param int $seconds The amount of seconds.
2234 * @param array $chosenIntervals The intervals to enable.
2235 *
2236 * @return array
2237 */
2248 'seconds'
2249 );
2250 }
2264 }
2265 }
2268 }
2270 /**
2271 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2272 *
2273 * @param string $type Can be 'date', 'time' or 'both'
2274 * @param string $ts The time format which needs to be turned into a
2275 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2276 * @param User $user User object used to get preferences for timezone and format
2277 * @param array $options Array, can contain the following keys:
2278 * - 'timecorrection': time correction, can have the following values:
2279 * - true: use user's preference
2280 * - false: don't use time correction
2281 * - int: value of time correction in minutes
2282 * - 'format': format to use, can have the following values:
2283 * - true: use user's preference
2284 * - false: use default preference
2285 * - string: format to use
2286 * @since 1.19
2287 * @return string
2288 */
2297 }
2299 }
2304 }
2307 }
2309 /**
2310 * Get the formatted date for the given timestamp and formatted for
2311 * the given user.
2312 *
2313 * @param mixed $ts Mixed: the time format which needs to be turned into a
2314 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2315 * @param User $user User object used to get preferences for timezone and format
2316 * @param array $options Array, can contain the following keys:
2317 * - 'timecorrection': time correction, can have the following values:
2318 * - true: use user's preference
2319 * - false: don't use time correction
2320 * - int: value of time correction in minutes
2321 * - 'format': format to use, can have the following values:
2322 * - true: use user's preference
2323 * - false: use default preference
2324 * - string: format to use
2325 * @since 1.19
2326 * @return string
2327 */
2330 }
2332 /**
2333 * Get the formatted time for the given timestamp and formatted for
2334 * the given user.
2335 *
2336 * @param mixed $ts The time format which needs to be turned into a
2337 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2338 * @param User $user User object used to get preferences for timezone and format
2339 * @param array $options Array, can contain the following keys:
2340 * - 'timecorrection': time correction, can have the following values:
2341 * - true: use user's preference
2342 * - false: don't use time correction
2343 * - int: value of time correction in minutes
2344 * - 'format': format to use, can have the following values:
2345 * - true: use user's preference
2346 * - false: use default preference
2347 * - string: format to use
2348 * @since 1.19
2349 * @return string
2350 */
2353 }
2355 /**
2356 * Get the formatted date and time for the given timestamp and formatted for
2357 * the given user.
2358 *
2359 * @param mixed $ts The time format which needs to be turned into a
2360 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2361 * @param User $user User object used to get preferences for timezone and format
2362 * @param array $options Array, can contain the following keys:
2363 * - 'timecorrection': time correction, can have the following values:
2364 * - true: use user's preference
2365 * - false: don't use time correction
2366 * - int: value of time correction in minutes
2367 * - 'format': format to use, can have the following values:
2368 * - true: use user's preference
2369 * - false: use default preference
2370 * - string: format to use
2371 * @since 1.19
2372 * @return string
2373 */
2376 }
2378 /**
2379 * Convert an MWTimestamp into a pretty human-readable timestamp using
2380 * the given user preferences and relative base time.
2381 *
2382 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2383 * on your timestamp object, which will then call this function. Calling
2384 * this function directly will cause hooks to be skipped over.
2385 *
2386 * @see MWTimestamp::getHumanTimestamp
2387 * @param MWTimestamp $ts Timestamp to prettify
2388 * @param MWTimestamp $relativeTo Base timestamp
2389 * @param User $user User preferences to use
2390 * @return string Human timestamp
2391 * @since 1.22
2392 */
2400 ) {
2401 // Timestamps are in different years: use full timestamp
2402 // Also do full timestamp for future dates
2403 /**
2404 * @todo FIXME: Add better handling of future timestamps.
2405 */
2409 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2413 // Timestamp within the past week: show the day of the week and time
2416 // Messages:
2417 // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2423 // Timestamp was yesterday: say 'yesterday' and the time.
2430 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2437 // From here on in, the timestamp was soon enough ago so that we can simply say
2438 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2440 // Less than 90 minutes, but more than an hour ago.
2443 // A few minutes ago.
2446 // Less than a minute, but more than 30 sec ago.
2449 // Less than 30 seconds ago.
2451 }
2454 }
2456 /**
2457 * @param string $key
2458 * @return array|null
2459 */
2462 }
2464 /**
2465 * @return array
2466 */
2469 }
2471 /**
2472 * @param string $in
2473 * @param string $out
2474 * @param string $string
2475 * @return string
2476 */
2478 # This is a wrapper for iconv in all languages except esperanto,
2479 # which does some nasty x-conversions beforehand
2481 # Even with //IGNORE iconv can whine about illegal characters in
2482 # *input* string. We just ignore those too.
2483 # REF: http://bugs.php.net/bug.php?id=37166
2484 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2489 }
2491 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2493 /**
2494 * @param array $matches
2495 * @return mixed|string
2496 */
2499 }
2501 /**
2502 * @param array $matches
2503 * @return string
2504 */
2507 }
2509 /**
2510 * @param array $matches
2511 * @return string
2512 */
2516 }
2518 /**
2519 * @param array $matches
2520 * @return string
2521 */
2525 }
2527 /**
2528 * @param array $matches
2529 * @return string
2530 */
2533 }
2535 /**
2536 * @param array $matches
2537 * @return string
2538 */
2542 }
2544 /**
2545 * Make a string's first character uppercase
2546 *
2547 * @param string $str
2548 *
2549 * @return string
2550 */
2558 // fall back to more complex logic in case of multibyte strings
2560 }
2561 }
2563 /**
2564 * Convert a string to uppercase
2565 *
2566 * @param string $str
2567 * @param bool $first
2568 *
2569 * @return string
2570 */
2578 }
2581 }
2588 $str
2589 );
2592 }
2593 }
2594 }
2596 /**
2597 * @param string $str
2598 * @return mixed|string
2599 */
2611 }
2612 }
2614 /**
2615 * @param string $str
2616 * @param bool $first
2617 * @return mixed|string
2618 */
2626 }
2629 }
2636 $str
2637 );
2640 }
2641 }
2642 }
2644 /**
2645 * @param string $str
2646 * @return bool
2647 */
2650 }
2652 /**
2653 * @param string $str
2654 * @return mixed|string
2655 */
2660 // regexp to find first letter in each word (i.e. after each space)
2661 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2663 // function to use to capitalize a single char
2668 $str
2669 );
2674 $str
2675 );
2676 }
2679 }
2680 }
2682 /**
2683 * capitalize words at word breaks
2684 *
2685 * @param string $str
2686 * @return mixed
2687 */
2692 // since \b doesn't work for UTF-8, we explicitely define word break chars
2695 // find first letter after word break
2703 $str
2704 );
2709 $str
2710 );
2711 }
2716 $str
2717 );
2718 }
2719 }
2721 /**
2722 * Return a case-folded representation of $s
2723 *
2724 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2725 * and $s2 are the same except for the case of their characters. It is not
2726 * necessary for the value returned to make sense when displayed.
2727 *
2728 * Do *not* perform any other normalisation in this function. If a caller
2729 * uses this function when it should be using a more general normalisation
2730 * function, then fix the caller.
2731 *
2732 * @param string $s
2733 *
2734 * @return string
2735 */
2738 }
2740 /**
2741 * @param string $s
2742 * @return string
2743 */
2747 }
2750 }
2753 }
2755 /**
2756 * @return array
2757 */
2760 }
2762 /**
2763 * Most writing systems use whitespace to break up words.
2764 * Some languages such as Chinese don't conventionally do this,
2765 * which requires special handling when breaking up words for
2766 * searching etc.
2767 *
2768 * @return bool
2769 */
2772 }
2774 /**
2775 * Some languages such as Chinese require word segmentation,
2776 * Specify such segmentation when overridden in derived class.
2777 *
2778 * @param string $string
2779 * @return string
2780 */
2783 }
2785 /**
2786 * Some languages have special punctuation need to be normalized.
2787 * Make such changes here.
2788 *
2789 * @param string $string
2790 * @return string
2791 */
2794 }
2796 /**
2797 * convert double-width roman characters to single-width.
2798 * range: ff00-ff5f ~= 0020-007f
2799 *
2800 * @param string $string
2801 *
2802 * @return string
2803 */
2813 }
2817 }
2819 /**
2820 * @param string $string
2821 * @param string $pattern
2822 * @return string
2823 */
2828 }
2830 /**
2831 * @param array $termsArray
2832 * @return array
2833 */
2835 # some languages, e.g. Chinese, need to do a conversion
2836 # in order for search results to be displayed correctly
2838 }
2840 /**
2841 * Get the first character of a string.
2842 *
2843 * @param string $s
2844 * @return string
2845 */
2852 $matches
2853 );
2858 }
2860 // Break down Hangul syllables to grab the first jamo
2892 }
2895 }
2896 }
2899 # Some languages may have an alternate char encoding option
2900 # (Esperanto X-coding, Japanese furigana conversion, etc)
2901 # If this language is used as the primary content language,
2902 # an override to the defaults can be set here on startup.
2903 }
2905 /**
2906 * @param string $s
2907 * @return string
2908 */
2910 # For some languages we'll want to explicitly specify
2911 # which characters make it into the edit box raw
2912 # or are converted in some way or another.
2918 }
2919 }
2921 /**
2922 * @param string $s
2923 * @return string
2924 */
2926 # Take the previous into account.
2932 }
2937 }
2938 }
2940 /**
2941 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2942 * also cleans up certain backwards-compatible sequences, converting them
2943 * to the modern Unicode equivalent.
2944 *
2945 * This is language-specific for performance reasons only.
2946 *
2947 * @param string $s
2948 *
2949 * @return string
2950 */
2957 }
2960 }
2962 /**
2963 * Transform a string using serialized data stored in the given file (which
2964 * must be in the serialized subdirectory of $IP). The file contains pairs
2965 * mapping source characters to destination characters.
2966 *
2967 * The data is cached in process memory. This will go faster if you have the
2968 * FastStringSearch extension.
2969 *
2970 * @param string $file
2971 * @param string $string
2972 *
2973 * @throws MWException
2974 * @return string
2975 */
2981 }
2983 }
2985 }
2987 /**
2988 * For right-to-left language support
2989 *
2990 * @return bool
2991 */
2994 }
2996 /**
2997 * Return the correct HTML 'dir' attribute value for this language.
2998 * @return string
2999 */
3002 }
3004 /**
3005 * Return 'left' or 'right' as appropriate alignment for line-start
3006 * for this language's text direction.
3007 *
3008 * Should be equivalent to CSS3 'start' text-align value....
3009 *
3010 * @return string
3011 */
3014 }
3016 /**
3017 * Return 'right' or 'left' as appropriate alignment for line-end
3018 * for this language's text direction.
3019 *
3020 * Should be equivalent to CSS3 'end' text-align value....
3021 *
3022 * @return string
3023 */
3026 }
3028 /**
3029 * A hidden direction mark (LRM or RLM), depending on the language direction.
3030 * Unlike getDirMark(), this function returns the character as an HTML entity.
3031 * This function should be used when the output is guaranteed to be HTML,
3032 * because it makes the output HTML source code more readable. When
3033 * the output is plain text or can be escaped, getDirMark() should be used.
3034 *
3035 * @param bool $opposite Get the direction mark opposite to your language
3036 * @return string
3037 * @since 1.20
3038 */
3042 }
3044 }
3046 /**
3047 * A hidden direction mark (LRM or RLM), depending on the language direction.
3048 * This function produces them as invisible Unicode characters and
3049 * the output may be hard to read and debug, so it should only be used
3050 * when the output is plain text or can be escaped. When the output is
3051 * HTML, use getDirMarkEntity() instead.
3052 *
3053 * @param bool $opposite Get the direction mark opposite to your language
3054 * @return string
3055 */
3061 }
3063 }
3065 /**
3066 * @return array
3067 */
3070 }
3072 /**
3073 * An arrow, depending on the language direction.
3074 *
3075 * @param string $direction The direction of the arrow: forwards (default),
3076 * backwards, left, right, up, down.
3077 * @return string
3078 */
3093 }
3094 }
3096 /**
3097 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
3098 *
3099 * @return bool
3100 */
3103 }
3105 /**
3106 * Get all magic words from cache.
3107 * @return array
3108 */
3111 }
3113 /**
3114 * Run the LanguageGetMagic hook once.
3115 */
3119 }
3124 }
3126 /**
3127 * Fill a MagicWord object with data from here
3128 *
3129 * @param MagicWord $mw
3130 */
3132 // Saves a function call
3135 }
3142 }
3149 }
3150 }
3152 /**
3153 * Add magic words to the extension array
3154 *
3155 * @param array $newWords
3156 */
3163 }
3164 }
3165 }
3167 /**
3168 * Get special page names, as an associative array
3169 * case folded alias => real name
3170 * @return array
3171 */
3173 // Cache aliases because it may be slow to load them
3175 // Initialise array
3180 }
3183 }
3185 /**
3186 * Italic is unsuitable for some languages
3187 *
3188 * @param string $text The text to be emphasized.
3189 * @return string
3190 */
3193 }
3195 /**
3196 * Normally we output all numbers in plain en_US style, that is
3197 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3198 * point twohundredthirtyfive. However this is not suitable for all
3199 * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3200 * Icelandic just want to use commas instead of dots, and dots instead
3201 * of commas like "293.291,235".
3202 *
3203 * An example of this function being called:
3204 * <code>
3205 * wfMessage( 'message' )->numParams( $num )->text()
3206 * </code>
3207 *
3208 * See $separatorTransformTable on MessageIs.php for
3209 * the , => . and . => , implementation.
3210 *
3211 * @todo check if it's viable to use localeconv() for the decimal separator thing.
3212 * @param int|float $number The string to be formatted, should be an integer
3213 * or a floating point number.
3214 * @param bool $nocommafy Set to true for special numbers like dates
3215 * @return string
3216 */
3224 }
3225 }
3231 }
3232 }
3235 }
3237 /**
3238 * Front-end for non-commafied formatNum
3239 *
3240 * @param int|float $number The string to be formatted, should be an integer
3241 * or a floating point number.
3242 * @since 1.21
3243 * @return string
3244 */
3247 }
3249 /**
3250 * @param string $number
3251 * @return string
3252 */
3256 // eliminate empty array values such as ''. (bug 64347)
3259 }
3263 // eliminate empty array values such as ''. (bug 64347)
3266 }
3270 }
3272 /**
3273 * Adds commas to a given number
3274 * @since 1.19
3275 * @param mixed $number
3276 * @return string
3277 */
3282 }
3285 // default grouping is at thousands, use the same for ###,###,### pattern too.
3288 // Ref: http://cldr.unicode.org/translation/number-patterns
3291 // For negative numbers apply the algorithm like positive number and add sign.
3294 }
3302 // the string does not have any number part. Eg: .12345
3304 }
3312 }
3316 // use the last pattern for the rest of the number
3318 }
3321 }
3322 }
3324 }
3325 }
3327 /**
3328 * @return string
3329 */
3332 }
3334 /**
3335 * @return array
3336 */
3339 }
3341 /**
3342 * @return array
3343 */
3346 }
3348 /**
3349 * Take a list of strings and build a locale-friendly comma-separated
3350 * list, using the local comma-separator message.
3351 * The last two strings are chained with an "and".
3352 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3353 *
3354 * @param string[] $l
3355 * @return string
3356 */
3361 }
3367 }
3368 }
3375 }
3376 }
3378 }
3380 /**
3381 * Take a list of strings and build a locale-friendly comma-separated
3382 * list, using the local comma-separator message.
3383 * @param string[] $list Array of strings to put in a comma list
3384 * @return string
3385 */
3389 $list
3390 );
3391 }
3393 /**
3394 * Take a list of strings and build a locale-friendly semicolon-separated
3395 * list, using the local semicolon-separator message.
3396 * @param string[] $list Array of strings to put in a semicolon list
3397 * @return string
3398 */
3402 $list
3403 );
3404 }
3406 /**
3407 * Same as commaList, but separate it with the pipe instead.
3408 * @param string[] $list Array of strings to put in a pipe list
3409 * @return string
3410 */
3414 $list
3415 );
3416 }
3418 /**
3419 * Truncate a string to a specified length in bytes, appending an optional
3420 * string (e.g. for ellipses)
3421 *
3422 * The database offers limited byte lengths for some columns in the database;
3423 * multi-byte character sets mean we need to ensure that only whole characters
3424 * are included, otherwise broken characters can be passed to the user
3425 *
3426 * If $length is negative, the string will be truncated from the beginning
3427 *
3428 * @param string $string String to truncate
3429 * @param int $length Maximum length (including ellipses)
3430 * @param string $ellipsis String to append to the truncated text
3431 * @param bool $adjustLength Subtract length of ellipsis from $length.
3432 * $adjustLength was introduced in 1.18, before that behaved as if false.
3433 * @return string
3434 */
3436 # Use the localized ellipsis character
3439 }
3440 # Check if there is no need to truncate
3445 }
3447 # If ellipsis length is >= $length then we can't apply $adjustLength
3450 # Otherwise, truncate and add ellipsis...
3465 }
3466 }
3467 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3468 # This check is *not* redundant if $adjustLength, due to the single case where
3469 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3474 }
3475 }
3477 /**
3478 * Remove bytes that represent an incomplete Unicode character
3479 * at the end of string (e.g. bytes of the char are missing)
3480 *
3481 * @param string $string
3482 * @return string
3483 */
3489 # We got the first byte only of a multibyte char; remove it.
3494 ) {
3495 # We chopped in the middle of a character; remove it
3497 }
3498 }
3500 }
3502 /**
3503 * Remove bytes that represent an incomplete Unicode character
3504 * at the start of string (e.g. bytes of the char are missing)
3505 *
3506 * @param string $string
3507 * @return string
3508 */
3513 # We chopped in the middle of a character; remove the whole thing
3515 }
3516 }
3518 }
3520 /**
3521 * Truncate a string of valid HTML to a specified length in bytes,
3522 * appending an optional string (e.g. for ellipses), and return valid HTML
3523 *
3524 * This is only intended for styled/linked text, such as HTML with
3525 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3526 * Also, this will not detect things like "display:none" CSS.
3527 *
3528 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3529 *
3530 * @param string $text HTML string to truncate
3531 * @param int $length (zero/positive) Maximum length (including ellipses)
3532 * @param string $ellipsis String to append to the truncated text
3533 * @return string
3534 */
3536 # Use the localized ellipsis character
3539 }
3540 # Check if there is clearly no need to truncate
3545 }
3559 # Consider truncation once the display length has reached the maximim.
3560 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3561 # Check that we're not in the middle of a bracket/entity...
3565 # Save where we are; we will truncate here unless there turn out to
3566 # be so few remaining characters that truncation is not necessary.
3569 }
3571 # String in fact does need truncation, the truncation point was OK.
3576 }
3577 }
3580 }
3582 # Read the next char...
3600 }
3606 // Name found (e.g. "<a href=..."), add on tag attributes...
3608 }
3614 }
3617 // Save state without $ch. We want to *hit* the first
3618 // display char (to get tags) but not *use* it if truncating.
3620 }
3625 // Add the next $max display text chars after this in one swoop...
3630 }
3631 }
3632 }
3633 }
3634 // Close the last tag if left unclosed by bad HTML
3638 }
3640 }
3642 /**
3643 * truncateHtml() helper function
3644 * like strcspn() but adds the skipped chars to $ret
3645 *
3646 * @param string $ret
3647 * @param string $text
3648 * @param string $search
3649 * @param int $start
3650 * @param null|int $len
3651 * @return int
3652 */
3658 }
3663 }
3665 }
3667 /**
3668 * truncateHtml() helper function
3669 * (a) push or pop $tag from $openTags as needed
3670 * (b) clear $tag value
3671 * @param string &$tag Current HTML tag name we are looking at
3672 * @param int $tagType (0-open tag, 1-close tag)
3673 * @param string $lastCh Character before the '>' that ended this tag
3674 * @param array &$openTags Open tag stack (not accounting for $tag)
3675 */
3684 }
3685 }
3687 }
3688 }
3690 /**
3691 * Grammatical transformations, needed for inflected languages
3692 * Invoked by putting {{grammar:case|word}} in a message
3693 *
3694 * @param string $word
3695 * @param string $case
3696 * @return string
3697 */
3702 }
3705 }
3706 /**
3707 * Get the grammar forms for the content language
3708 * @return array Array of grammar forms
3709 * @since 1.20
3710 */
3715 ) {
3717 }
3720 }
3721 /**
3722 * Provides an alternative text depending on specified gender.
3723 * Usage {{gender:username|masculine|feminine|unknown}}.
3724 * username is optional, in which case the gender of current user is used,
3725 * but only in (some) interface messages; otherwise default gender is used.
3726 *
3727 * If no forms are given, an empty string is returned. If only one form is
3728 * given, it will be returned unconditionally. These details are implied by
3729 * the caller and cannot be overridden in subclasses.
3730 *
3731 * If three forms are given, the default is to use the third (unknown) form.
3732 * If fewer than three forms are given, the default is to use the first (masculine) form.
3733 * These details can be overridden in subclasses.
3734 *
3735 * @param string $gender
3736 * @param array $forms
3737 *
3738 * @return string
3739 */
3743 }
3747 }
3750 }
3752 }
3754 /**
3755 * Plural form transformations, needed for some languages.
3756 * For example, there are 3 form of plural in Russian and Polish,
3757 * depending on "count mod 10". See [[w:Plural]]
3758 * For English it is pretty simple.
3759 *
3760 * Invoked by putting {{plural:count|wordform1|wordform2}}
3761 * or {{plural:count|wordform1|wordform2|wordform3}}
3762 *
3763 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3764 *
3765 * @param int $count Non-localized number
3766 * @param array $forms Different plural forms
3767 * @return string Correct form of plural for $count in this language
3768 */
3770 // Handle explicit n=pluralform cases
3774 }
3777 }
3782 }
3784 /**
3785 * Handles explicit plural forms for Language::convertPlural()
3786 *
3787 * In {{PLURAL:$1|0=nothing|one|many}}, 0=nothing will be returned if $1 equals zero.
3788 * If an explicitly defined plural form matches the $count, then
3789 * string value returned, otherwise array returned for further consideration
3790 * by CLDR rules or overridden convertPlural().
3791 *
3792 * @since 1.23
3793 *
3794 * @param int $count Non-localized number
3795 * @param array $forms Different plural forms
3796 *
3797 * @return array|string
3798 */
3805 }
3807 }
3808 }
3810 }
3812 /**
3813 * Checks that convertPlural was given an array and pads it to requested
3814 * amount of forms by copying the last one.
3815 *
3816 * @param array $forms Array of forms given to convertPlural
3817 * @param int $count How many forms should there be at least
3818 * @return array Padded array of forms or an exception if not an array
3819 */
3823 }
3825 }
3827 /**
3828 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3829 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3830 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3831 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3832 * match up with it.
3833 *
3834 * @param string $str The validated block duration in English
3835 * @return string Somehow translated block duration
3836 * @see LanguageFi.php for example implementation
3837 */
3843 }
3844 }
3846 // Since usually only infinite or indefinite is only on list, so try
3847 // equivalents if still here.
3854 }
3855 }
3856 }
3858 // If all else fails, return a standard duration or timestamp description.
3863 // $time is relative to 0 so it's a duration length.
3867 // wfTimestamp() handles 0 as current time instead of epoch.
3871 }
3872 }
3873 }
3875 /**
3876 * languages like Chinese need to be segmented in order for the diff
3877 * to be of any use
3878 *
3879 * @param string $text
3880 * @return string
3881 */
3884 }
3886 /**
3887 * and unsegment to show the result
3888 *
3889 * @param string $text
3890 * @return string
3891 */
3894 }
3896 /**
3897 * Return the LanguageConverter used in the Language
3898 *
3899 * @since 1.19
3900 * @return LanguageConverter
3901 */
3904 }
3906 /**
3907 * convert text to all supported variants
3908 *
3909 * @param string $text
3910 * @return array
3911 */
3914 }
3916 /**
3917 * convert text to different variants of a language.
3918 *
3919 * @param string $text
3920 * @return string
3921 */
3924 }
3926 /**
3927 * Convert a Title object to a string in the preferred variant
3928 *
3929 * @param Title $title
3930 * @return string
3931 */
3934 }
3936 /**
3937 * Convert a namespace index to a string in the preferred variant
3938 *
3939 * @param int $ns
3940 * @return string
3941 */
3944 }
3946 /**
3947 * Check if this is a language with variants
3948 *
3949 * @return bool
3950 */
3953 }
3955 /**
3956 * Check if the language has the specific variant
3957 *
3958 * @since 1.19
3959 * @param string $variant
3960 * @return bool
3961 */
3964 }
3966 /**
3967 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3968 *
3969 * @param string $text
3970 * @return string
3971 * @deprecated since 1.22 is no longer used
3972 */
3975 }
3977 /**
3978 * Perform output conversion on a string, and encode for safe HTML output.
3979 * @param string $text Text to be converted
3980 * @param bool $isTitle Whether this conversion is for the article title
3981 * @return string
3982 * @todo this should get integrated somewhere sane
3983 */
3986 }
3988 /**
3989 * @param string $key
3990 * @return string
3991 */
3994 }
3996 /**
3997 * Get the list of variants supported by this language
3998 * see sample implementation in LanguageZh.php
3999 *
4000 * @return array An array of language codes
4001 */
4004 }
4006 /**
4007 * @return string
4008 */
4011 }
4013 /**
4014 * @return string
4015 */
4018 }
4020 /**
4021 * @return string
4022 */
4025 }
4027 /**
4028 * If a language supports multiple variants, it is
4029 * possible that non-existing link in one variant
4030 * actually exists in another variant. this function
4031 * tries to find it. See e.g. LanguageZh.php
4032 * The input parameters may be modified upon return
4033 *
4034 * @param string &$link The name of the link
4035 * @param Title &$nt The title object of the link
4036 * @param bool $ignoreOtherCond To disable other conditions when
4037 * we need to transclude a template or update a category's link
4038 */
4041 }
4043 /**
4044 * returns language specific options used by User::getPageRenderHash()
4045 * for example, the preferred language variant
4046 *
4047 * @return string
4048 */
4051 }
4053 /**
4054 * For languages that support multiple variants, the title of an
4055 * article may be displayed differently in different variants. this
4056 * function returns the apporiate title defined in the body of the article.
4057 *
4058 * @return string
4059 */
4062 }
4064 /**
4065 * Prepare external link text for conversion. When the text is
4066 * a URL, it shouldn't be converted, and it'll be wrapped in
4067 * the "raw" tag (-{R| }-) to prevent conversion.
4068 *
4069 * This function is called "markNoConversion" for historical
4070 * reasons.
4071 *
4072 * @param string $text Text to be used for external link
4073 * @param bool $noParse Wrap it without confirming it's a real URL first
4074 * @return string The tagged text
4075 */
4077 // Excluding protocal-relative URLs may avoid many false positives.
4082 }
4083 }
4085 /**
4086 * A regular expression to match legal word-trailing characters
4087 * which should be merged onto a link of the form [[foo]]bar.
4088 *
4089 * @return string
4090 */
4093 }
4095 /**
4096 * A regular expression character set to match legal word-prefixing
4097 * characters which should be merged onto a link of the form foo[[bar]].
4098 *
4099 * @return string
4100 */
4103 }
4105 /**
4106 * @deprecated since 1.24, will be removed in 1.25
4107 * @return Language
4108 */
4112 }
4114 /**
4115 * Get the "parent" language which has a converter to convert a "compatible" language
4116 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
4117 *
4118 * @return Language|null
4119 * @since 1.22
4120 */
4124 }
4131 }
4136 }
4140 }
4142 /**
4143 * Get the RFC 3066 code for this language object
4144 *
4145 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4146 * htmlspecialchars() or similar
4147 *
4148 * @return string
4149 */
4152 }
4154 /**
4155 * Get the code in Bcp47 format which we can use
4156 * inside of html lang="" tags.
4157 *
4158 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4159 * htmlspecialchars() or similar.
4160 *
4161 * @since 1.19
4162 * @return string
4163 */
4167 }
4169 }
4171 /**
4172 * @param string $code
4173 */
4176 // Ensure we don't leave incorrect cached data lying around
4179 }
4181 /**
4182 * Get the name of a file for a certain language code
4183 * @param string $prefix Prepend this to the filename
4184 * @param string $code Language code
4185 * @param string $suffix Append this to the filename
4186 * @throws MWException
4187 * @return string $prefix . $mangledCode . $suffix
4188 */
4192 }
4195 }
4197 /**
4198 * Get the language code from a file name. Inverse of getFileName()
4199 * @param string $filename $prefix . $languageCode . $suffix
4200 * @param string $prefix Prefix before the language code
4201 * @param string $suffix Suffix after the language code
4202 * @return string Language code, or false if $prefix or $suffix isn't found
4203 */
4204 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4210 }
4212 }
4214 /**
4215 * @param string $code
4216 * @return string
4217 */
4223 }
4225 /**
4226 * @param string $code
4227 * @return string
4228 * @since 1.23
4229 */
4235 }
4238 }
4240 /**
4241 * @param string $code
4242 * @return string
4243 */
4247 }
4249 /**
4250 * Get the first fallback for a given language.
4251 *
4252 * @param string $code
4253 *
4254 * @return bool|string
4255 */
4263 }
4264 }
4266 /**
4267 * Get the ordered list of fallback languages.
4268 *
4269 * @since 1.19
4270 * @param string $code Language code
4271 * @return array
4272 */
4281 }
4283 }
4284 }
4286 /**
4287 * Get the ordered list of fallback languages, ending with the fallback
4288 * language chain for the site language.
4289 *
4290 * @since 1.22
4291 * @param string $code Language code
4292 * @return array Array( fallbacks, site fallbacks )
4293 */
4297 // Usually, we will only store a tiny number of fallback chains, so we
4298 // keep them in static memory.
4304 // Append the site's fallback chain, including the site language itself
4308 // Eliminate any languages already included in the chain
4312 }
4314 }
4316 /**
4317 * Get all messages for a given language
4318 * WARNING: this may take a long time. If you just need all message *keys*
4319 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4320 *
4321 * @param string $code
4322 *
4323 * @return array
4324 */
4327 }
4329 /**
4330 * Get a message for a given language
4331 *
4332 * @param string $key
4333 * @param string $code
4334 *
4335 * @return string
4336 */
4339 }
4341 /**
4342 * Get all message keys for a given language. This is a faster alternative to
4343 * array_keys( Language::getMessagesFor( $code ) )
4344 *
4345 * @since 1.19
4346 * @param string $code Language code
4347 * @return array Array of message keys (strings)
4348 */
4351 }
4353 /**
4354 * @param string $talk
4355 * @return mixed
4356 */
4360 }
4365 # Allow grammar transformations
4366 # Allowing full message-style parsing would make simple requests
4367 # such as action=raw much more expensive than they need to be.
4368 # This will hopefully cover most cases.
4372 }
4374 /**
4375 * @param string $m
4376 * @return string
4377 */
4380 }
4382 /**
4383 * @throws MWException
4384 * @return array
4385 */
4390 }
4397 }
4402 }
4404 /**
4405 * Decode an expiry (block, protection, etc) which has come from the DB
4406 *
4407 * @todo FIXME: why are we returnings DBMS-dependent strings???
4408 *
4409 * @param string $expiry Database expiry String
4410 * @param bool|int $format True to process using language functions, or TS_ constant
4411 * to return the expiry in a given timestamp
4412 * @return string
4413 * @since 1.18
4414 */
4419 }
4429 }
4430 }
4432 /**
4433 * @todo Document
4434 * @param int|float $seconds
4435 * @param array $format Optional
4436 * If $format['avoid'] === 'avoidseconds': don't mention seconds if $seconds >= 1 hour.
4437 * If $format['avoid'] === 'avoidminutes': don't mention seconds/minutes if $seconds > 48 hours.
4438 * If $format['noabbrevs'] is true: use 'seconds' and friends instead of 'seconds-abbrev'
4439 * and friends.
4440 * For backwards compatibility, $format may also be one of the strings 'avoidseconds'
4441 * or 'avoidminutes'.
4442 * @return string
4443 */
4447 }
4450 }
4453 }
4475 }
4486 }
4490 }
4496 }
4504 }
4514 }
4518 }
4528 }
4529 }
4531 }
4533 /**
4534 * Format a bitrate for output, using an appropriate
4535 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to
4536 * the magnitude in question.
4537 *
4538 * This use base 1000. For base 1024 use formatSize(), for another base
4539 * see formatComputingNumbers().
4540 *
4541 * @param int $bps
4542 * @return string
4543 */
4546 }
4548 /**
4549 * @param int $size Size of the unit
4550 * @param int $boundary Size boundary (1000, or 1024 in most cases)
4551 * @param string $messageKey Message key to be uesd
4552 * @return string
4553 */
4558 );
4559 }
4567 }
4569 // For small sizes no decimal places necessary
4572 // For MB and bigger two decimal places are smarter
4574 }
4580 }
4582 /**
4583 * Format a size in bytes for output, using an appropriate
4584 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4585 *
4586 * This method use base 1024. For base 1000 use formatBitrate(), for
4587 * another base see formatComputingNumbers()
4588 *
4589 * @param int $size Size to format
4590 * @return string Plain text (not HTML)
4591 */
4594 }
4596 /**
4597 * Make a list item, used by various special pages
4598 *
4599 * @param string $page Page link
4600 * @param string $details Text between brackets
4601 * @param bool $oppositedm Add the direction mark opposite to your
4602 * language, to display text properly
4603 * @return string
4604 */
4611 }
4613 /**
4614 * Generate (prev x| next x) (20|50|100...) type links for paging
4615 *
4616 * @param Title $title Title object to link
4617 * @param int $offset
4618 * @param int $limit
4619 * @param array $query Optional URL query parameter string
4620 * @param bool $atend Optional param for specified if this is the last page
4621 * @return string
4622 */
4625 ) {
4626 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4628 # Make 'previous' link
4629 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4635 }
4637 # Make 'next' link
4638 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4644 }
4646 # Make links to set number of items per page
4651 }
4655 }
4657 /**
4658 * Helper function for viewPrevNext() that generates links
4659 *
4660 * @param Title $title Title object to link
4661 * @param int $offset
4662 * @param int $limit
4663 * @param array $query Extra query parameters
4664 * @param string $link Text to use for the link; will be escaped
4665 * @param string $tooltipMsg Name of the message to use as tooltip
4666 * @param string $class Value of the "class" attribute of the link
4667 * @return string HTML fragment
4668 */
4671 ) {
4678 }
4680 /**
4681 * Get the conversion rule title, if any.
4682 *
4683 * @return string
4684 */
4687 }
4689 /**
4690 * Get the compiled plural rules for the language
4691 * @since 1.20
4692 * @return array Associative array with plural form, and plural rule as key-value pairs
4693 */
4699 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4702 }
4703 }
4704 }
4706 }
4708 /**
4709 * Get the plural rules for the language
4710 * @since 1.20
4711 * @return array Associative array with plural form number and plural rule as key-value pairs
4712 */
4721 }
4722 }
4723 }
4725 }
4727 /**
4728 * Get the plural rule types for the language
4729 * @since 1.22
4730 * @return array Associative array with plural form number and plural rule type as key-value pairs
4731 */
4737 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4740 }
4741 }
4742 }
4744 }
4746 /**
4747 * Find the index number of the plural rule appropriate for the given number
4748 * @param int $number
4749 * @return int The index number of the plural rule
4750 */
4755 }
4757 /**
4758 * Find the plural rule type appropriate for the given number
4759 * For example, if the language is set to Arabic, getPluralType(5) should
4760 * return 'few'.
4761 * @since 1.22
4762 * @param int $number
4763 * @return string The name of the plural rule type, e.g. one, two, few, many
4764 */
4772 }
4773 }
4774 }