| blob | bf3045516938145043690208b066a02acfc4ee29 |
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 * Same as getFallbacksFor for current language.
448 * @return array|bool
449 * @deprecated since 1.19
450 */
455 }
457 /**
458 * @return array
459 * @since 1.19
460 */
463 }
465 /**
466 * Exports $wgBookstoreListEn
467 * @return array
468 */
471 }
473 /**
474 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
475 * available in localised form, it will be included in English.
476 *
477 * @return array
478 */
495 }
497 # Sometimes a language will be localised but not actually exist on this wiki.
501 }
502 }
504 # The above mixing may leave namespaces out of canonical order.
505 # Re-order by namespace ID number...
509 }
512 }
514 /**
515 * Arbitrarily set all of the namespace names at once. Mainly used for testing
516 * @param array $namespaces Array of namespaces (id => name)
517 */
521 }
523 /**
524 * Resets all of the namespace caches. Mainly used for testing
525 */
530 }
532 /**
533 * A convenience function that returns the same thing as
534 * getNamespaces() except with the array values changed to ' '
535 * where it found '_', useful for producing output to be displayed
536 * e.g. in <select> forms.
537 *
538 * @return array
539 */
544 }
546 }
548 /**
549 * Get a namespace value by key
550 * <code>
551 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
552 * echo $mw_ns; // prints 'MediaWiki'
553 * </code>
554 *
555 * @param int $index The array key of the namespace to return
556 * @return string|bool String if the namespace value exists, otherwise false
557 */
562 }
564 /**
565 * A convenience function that returns the same thing as
566 * getNsText() except with '_' changed to ' ', useful for
567 * producing output.
568 *
569 * <code>
570 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
571 * echo $mw_ns; // prints 'MediaWiki talk'
572 * </code>
573 *
574 * @param int $index The array key of the namespace to return
575 * @return string Namespace name without underscores (empty string if namespace does not exist)
576 */
581 }
583 /**
584 * Returns gender-dependent namespace alias if available.
585 * See https://www.mediawiki.org/wiki/Manual:$wgExtraGenderNamespaces
586 * @param int $index Namespace index
587 * @param string $gender Gender key (male, female... )
588 * @return string
589 * @since 1.18
590 */
598 }
600 /**
601 * Whether this language uses gender-dependent namespace aliases.
602 * See https://www.mediawiki.org/wiki/Manual:$wgExtraGenderNamespaces
603 * @return bool
604 * @since 1.18
605 */
609 // $wgExtraGenderNamespaces overrides everything
611 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
612 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
613 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
616 // Check what is in i18n files
619 }
620 }
622 /**
623 * Get a namespace key by value, case insensitive.
624 * Only matches namespace names for the current language, not the
625 * canonical ones defined in Namespace.php.
626 *
627 * @param string $text
628 * @return int|bool An integer if $text is a valid value otherwise false
629 */
634 }
636 /**
637 * @return array
638 */
650 }
651 }
652 }
660 }
661 }
663 # Also add converted namespace names as aliases, to avoid confusion.
668 }
671 }
672 }
675 }
678 }
680 /**
681 * @return array
682 */
686 # Put namespace names and aliases into a hashtable.
687 # If this is too slow, then we should arrange it so that it is done
688 # before caching. The catch is that at pre-cache time, the above
689 # class-specific fixup hasn't been done.
693 }
696 }
700 }
701 }
702 }
704 }
706 /**
707 * Get a namespace key by value, case insensitive. Canonical namespace
708 * names override custom ones defined for the current language.
709 *
710 * @param string $text
711 * @return int|bool An integer if $text is a valid value otherwise false
712 */
718 }
721 }
723 /**
724 * short names for language variants used for language conversion links.
725 *
726 * @param string $code
727 * @param bool $usemsg Use the "variantname-xyz" message if it exists
728 * @return string
729 */
734 }
739 # otherwise, output the language code
741 }
742 }
744 /**
745 * @param string $name
746 * @return string
747 */
752 }
754 }
756 /**
757 * @return array
758 */
761 }
763 /**
764 * @return array
765 */
768 }
770 /**
771 * @return array|string
772 */
780 }
781 }
783 /**
784 * @return array
785 */
788 }
790 /**
791 * @param string $image
792 * @return array|null
793 */
796 }
798 /**
799 * @return array
800 */
803 }
805 /**
806 * @param string $tog
807 * @return string
808 */
811 }
813 /**
814 * Get native language names, indexed by code.
815 * Only those defined in MediaWiki, no other data like CLDR.
816 * If $customisedOnly is true, only returns codes with a messages file
817 *
818 * @param bool $customisedOnly
819 *
820 * @return array
821 * @deprecated since 1.20, use fetchLanguageNames()
822 */
825 }
827 /**
828 * Get translated language names. This is done on best effort and
829 * by default this is exactly the same as Language::getLanguageNames.
830 * The CLDR extension provides translated names.
831 * @param string $code Language code.
832 * @return array Language code => language name
833 * @since 1.18.0
834 * @deprecated since 1.20, use fetchLanguageNames()
835 */
838 }
840 /**
841 * Get an array of language names, indexed by code.
842 * @param null|string $inLanguage Code of language in which to return the names
843 * Use null for autonyms (native names)
844 * @param string $include One of:
845 * 'all' all available languages
846 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
847 * 'mwfile' only if the language is in 'mw' *and* has a message file
848 * @return array Language code => language name
849 * @since 1.20
850 */
858 }
863 # TODO: also include when $inLanguage is null, when this code is more efficient
865 }
869 # - Prefer own MediaWiki native name when not using the hook
870 # - For other names just add if not added through the hook
873 }
874 }
878 }
884 }
888 # We do this using a foreach over the codes instead of a directory
889 # loop so that messages files in extensions will work correctly.
893 ) {
895 }
896 }
899 }
901 # 'mw' option; default if it's not one of the other two options (all/mwfile)
903 }
905 /**
906 * @param string $code The code of the language for which to get the name
907 * @param null|string $inLanguage Code of language in which to return the name (null for autonyms)
908 * @param string $include 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
909 * @return string Language name or empty
910 * @since 1.20
911 */
916 }
918 /**
919 * Get a message from the MediaWiki namespace.
920 *
921 * @param string $msg Message name
922 * @return string
923 */
926 }
928 /**
929 * Get the native language name of $code.
930 * Only if defined in MediaWiki, no other data like CLDR.
931 * @param string $code
932 * @return string
933 * @deprecated since 1.20, use fetchLanguageName()
934 */
937 }
939 /**
940 * @param string $key
941 * @return string
942 */
945 }
947 /**
948 * @return array
949 */
954 }
956 }
958 /**
959 * @param string $key
960 * @return string
961 */
964 }
966 /**
967 * @param string $key
968 * @return string
969 */
972 }
974 /**
975 * @return array
976 */
981 }
983 }
985 /**
986 * @param string $key
987 * @return string
988 */
991 }
993 /**
994 * @param string $key
995 * @return string
996 */
999 }
1001 /**
1002 * @param string $key
1003 * @return string
1004 */
1007 }
1009 /**
1010 * @param string $key
1011 * @return string
1012 */
1015 }
1017 /**
1018 * @param string $key
1019 * @return string
1020 */
1023 }
1025 /**
1026 * @param string $key
1027 * @return string
1028 */
1031 }
1033 /**
1034 * Pass through result from $dateTimeObj->format()
1035 */
1040 );
1041 }
1043 }
1045 /**
1046 * This is a workalike of PHP's date() function, but with better
1047 * internationalisation, a reduced set of format characters, and a better
1048 * escaping format.
1049 *
1050 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1051 * the PHP manual for definitions. There are a number of extensions, which
1052 * start with "x":
1053 *
1054 * xn Do not translate digits of the next numeric format character
1055 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1056 * xr Use roman numerals for the next numeric format character
1057 * xh Use hebrew numerals for the next numeric format character
1058 * xx Literal x
1059 * xg Genitive month name
1060 *
1061 * xij j (day number) in Iranian calendar
1062 * xiF F (month name) in Iranian calendar
1063 * xin n (month number) in Iranian calendar
1064 * xiy y (two digit year) in Iranian calendar
1065 * xiY Y (full year) in Iranian calendar
1066 *
1067 * xjj j (day number) in Hebrew calendar
1068 * xjF F (month name) in Hebrew calendar
1069 * xjt t (days in month) in Hebrew calendar
1070 * xjx xg (genitive month name) in Hebrew calendar
1071 * xjn n (month number) in Hebrew calendar
1072 * xjY Y (full year) in Hebrew calendar
1073 *
1074 * xmj j (day number) in Hijri calendar
1075 * xmF F (month name) in Hijri calendar
1076 * xmn n (month number) in Hijri calendar
1077 * xmY Y (full year) in Hijri calendar
1078 *
1079 * xkY Y (full year) in Thai solar calendar. Months and days are
1080 * identical to the Gregorian calendar
1081 * xoY Y (full year) in Minguo calendar or Juche year.
1082 * Months and days are identical to the
1083 * Gregorian calendar
1084 * xtY Y (full year) in Japanese nengo. Months and days are
1085 * identical to the Gregorian calendar
1086 *
1087 * Characters enclosed in double quotes will be considered literal (with
1088 * the quotes themselves removed). Unmatched quotes will be considered
1089 * literal quotes. Example:
1090 *
1091 * "The month is" F => The month is January
1092 * i's" => 20'11"
1093 *
1094 * Backslash escaping is also supported.
1095 *
1096 * Input timestamp is assumed to be pre-normalized to the desired local
1097 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1098 * $ts is UTC if $zone is not given.
1099 *
1100 * @param string $format
1101 * @param string $ts 14-character timestamp
1102 * YYYYMMDDHHMMSS
1103 * 01234567890123
1104 * @param DateTimeZone $zone Timezone of $ts
1105 * @param[out] int $ttl The amount of time (in seconds) the output may be cached for.
1106 * Only makes sense if $ts is the current time.
1107 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1108 *
1109 * @throws MWException
1110 * @return string
1111 */
1147 }
1151 }
1159 }
1169 }
1195 }
1204 $s .= $this->getWeekdayAbbreviation( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1 );
1214 }
1221 }
1228 }
1233 $s .= $this->getWeekdayName( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1 );
1243 }
1250 }
1257 }
1276 }
1283 }
1290 }
1297 }
1308 }
1315 }
1322 }
1329 }
1336 }
1343 }
1354 }
1394 // fall through
1425 // fall through
1431 # Backslash escaping
1436 }
1439 # Quoted literal
1443 # No terminating quote, assume literal "
1448 }
1450 # Quote at end of string, assume literal "
1452 }
1456 }
1469 }
1470 }
1471 }
1480 $ttl = 43200 - ( substr( $ts, 8, 2 ) % 12 ) * 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1481 } elseif ( $usedDay || $usedHebrewMonth || $usedIranianMonth || $usedHijriMonth || $usedHebrewYear || $usedIranianYear || $usedHijriYear || $usedTennoYear ) {
1482 // @todo Someone who understands the non-Gregorian calendars should write proper logic for them
1483 // so that they don't need purged every day.
1487 $timeRemainingInDay = 86400 - substr( $ts, 8, 2 ) * 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1489 $possibleTtls[] = ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 + $timeRemainingInDay;
1491 // December 28th falls on the last ISO week of the year, every year.
1492 // The last ISO week of a year can be 52 or 53.
1493 $lastWeekOfISOYear = DateTime::createFromFormat( 'Ymd', substr( $ts, 0, 4 ) . '1228', $zone ?: new DateTimeZone( 'UTC' ) )->format( 'W' );
1496 $timeRemainingInWeek = ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 + $timeRemainingInDay;
1498 }
1501 $possibleTtls[] = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 't' ) - substr( $ts, 6, 2 ) ) * 86400 + $timeRemainingInDay;
1503 $possibleTtls[] = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1507 $timeRemainingInYear = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1511 // this isn't a leap year. see when the next one starts
1517 }
1519 // this is a leap year, so the next year isn't
1521 }
1522 }
1526 }
1527 }
1530 }
1535 /**
1536 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1537 * Gregorian dates to Iranian dates. Originally written in C, it
1538 * is released under the terms of GNU Lesser General Public
1539 * License. Conversion to PHP was performed by Niklas Laxström.
1540 *
1541 * Link: http://www.farsiweb.info/jalali/jalali.c
1542 *
1543 * @param string $ts
1544 *
1545 * @return string
1546 */
1552 # Days passed from the beginning (including leap years)
1558 // Add days of the past months of this year
1561 }
1563 // Leap years
1566 }
1568 // Days passed in current month
1582 }
1586 }
1592 }
1594 /**
1595 * Converting Gregorian dates to Hijri dates.
1596 *
1597 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1598 *
1599 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1600 *
1601 * @param string $ts
1602 *
1603 * @return string
1604 */
1618 ) {
1626 }
1640 }
1642 /**
1643 * Converting Gregorian dates to Hebrew dates.
1644 *
1645 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1646 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1647 * to translate the relevant functions into PHP and release them under
1648 * GNU GPL.
1649 *
1650 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1651 * and Adar II is 14. In a non-leap year, Adar is 6.
1652 *
1653 * @param string $ts
1654 *
1655 * @return string
1656 */
1658 # Parse date
1663 # Calculate Hebrew year
1666 # Month number when September = 1, August = 12
1669 # Next year
1673 }
1675 # Calculate day of year from 1 September
1679 # February
1681 # Check if the year is leap
1684 }
1689 }
1690 }
1692 # Calculate the start of the Hebrew year
1695 # Calculate next year's start
1697 # Day is before the start of the year - it is the previous year
1698 # Next year's start
1700 # Previous year
1703 # Add days since previous year's 1 September
1706 # Leap year
1708 }
1709 # Start of the new (previous) year
1712 # Next year's start
1714 }
1716 # Calculate Hebrew day of year
1719 # Difference between year's days
1721 # Add 12 (or 13 for leap years) days to ignore the difference between
1722 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1723 # difference is only about the year type
1728 }
1730 # Check the year pattern, and is leap year
1731 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1732 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1733 # and non-leap years
1735 # Check if leap year
1738 # Calculate day in the month from number of day in the Hebrew year
1739 # Don't check Adar - if the day is not in Adar, we will stop before;
1740 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1745 # Calculate days in this month
1747 # Adar in a leap year
1749 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1752 # Day in Adar I
1755 # Subtract the days of Adar I
1757 # Try Adar II
1760 # Day in Adar II
1762 }
1763 }
1764 }
1766 # Cheshvan in a complete year (otherwise as the rule below)
1769 # Kislev in an incomplete year (otherwise as the rule below)
1772 # Odd months have 30 days, even have 29
1774 }
1776 # In the current month
1779 # Subtract the days of the current month
1781 # Try in the next month
1783 }
1784 }
1787 }
1789 /**
1790 * This calculates the Hebrew year start, as days since 1 September.
1791 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1792 * Used for Hebrew date.
1793 *
1794 * @param int $year
1795 *
1796 * @return string
1797 */
1804 }
1808 }
1818 }
1822 }
1824 /**
1825 * Algorithm to convert Gregorian dates to Thai solar dates,
1826 * Minguo dates or Minguo dates.
1827 *
1828 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1829 * http://en.wikipedia.org/wiki/Minguo_calendar
1830 * http://en.wikipedia.org/wiki/Japanese_era_name
1831 *
1832 * @param string $ts 14-character timestamp
1833 * @param string $cName Calender name
1834 * @return array Converted year, month, day
1835 */
1842 # Thai solar dates
1843 # Add 543 years to the Gregorian calendar
1844 # Months and days are identical
1847 # Minguo dates
1848 # Deduct 1911 years from the Gregorian calendar
1849 # Months and days are identical
1852 # Nengō dates up to Meiji period
1853 # Deduct years from the Gregorian calendar
1854 # depending on the nengo periods
1855 # Months and days are identical
1859 ) {
1860 # Meiji period
1865 }
1873 ) {
1874 # Taishō period
1879 }
1885 ) {
1886 # Shōwa period
1891 }
1894 # Heisei period
1899 }
1901 }
1904 }
1907 }
1909 /**
1910 * Roman number formatting up to 10000
1911 *
1912 * @param int $num
1913 *
1914 * @return string
1915 */
1923 );
1928 }
1934 }
1936 }
1938 }
1940 /**
1941 * Hebrew Gematria number formatting up to 9999
1942 *
1943 * @param int $num
1944 *
1945 * @return string
1946 */
1953 );
1958 }
1970 }
1971 }
1972 }
1974 }
1980 }
1999 }
2001 }
2003 /**
2004 * Used by date() and time() to adjust the time output.
2005 *
2006 * @param string $ts The time in date('YmdHis') format
2007 * @param mixed $tz Adjust the time by this amount (default false, mean we
2008 * get user timecorrection setting)
2009 * @return int
2010 */
2016 }
2029 }
2030 # Unrecognized timezone, default to 'Offset' with the stored offset.
2032 }
2035 # Global offset in minutes.
2047 }
2050 }
2051 }
2053 # No difference ? Return time unchanged
2056 }
2059 # Generate an adjusted date; take advantage of the fact that mktime
2060 # will normalize out-of-range values so we don't have to split $minDiff
2061 # into hours and minutes.
2074 }
2076 /**
2077 * This is meant to be used by time(), date(), and timeanddate() to get
2078 * the date preference they're supposed to use, it should be used in
2079 * all children.
2080 *
2081 *<code>
2082 * function timeanddate([...], $format = true) {
2083 * $datePreference = $this->dateFormat($format);
2084 * [...]
2085 * }
2086 *</code>
2087 *
2088 * @param int|string|bool $usePrefs If true, the user's preference is used
2089 * if false, the site/language default is used
2090 * if int/string, assumed to be a format.
2091 * @return string
2092 */
2101 }
2104 }
2106 // return int
2109 }
2112 }
2114 /**
2115 * Get a format string for a given type and preference
2116 * @param string $type May be date, time or both
2117 * @param string $pref The format name as it appears in Messages*.php
2118 *
2119 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2120 *
2121 * @return string
2122 */
2133 }
2138 }
2139 }
2141 }
2143 }
2145 /**
2146 * @param string $ts The time format which needs to be turned into a
2147 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2148 * @param bool $adj Whether to adjust the time output according to the
2149 * user configured offset ($timecorrection)
2150 * @param mixed $format True to use user's date format preference
2151 * @param string|bool $timecorrection The time offset as returned by
2152 * validateTimeZone() in Special:Preferences
2153 * @return string
2154 */
2159 }
2162 }
2164 /**
2165 * @param string $ts The time format which needs to be turned into a
2166 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2167 * @param bool $adj Whether to adjust the time output according to the
2168 * user configured offset ($timecorrection)
2169 * @param mixed $format True to use user's date format preference
2170 * @param string|bool $timecorrection The time offset as returned by
2171 * validateTimeZone() in Special:Preferences
2172 * @return string
2173 */
2178 }
2181 }
2183 /**
2184 * @param string $ts The time format which needs to be turned into a
2185 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2186 * @param bool $adj Whether to adjust the time output according to the
2187 * user configured offset ($timecorrection)
2188 * @param mixed $format What format to return, if it's false output the
2189 * default one (default true)
2190 * @param string|bool $timecorrection The time offset as returned by
2191 * validateTimeZone() in Special:Preferences
2192 * @return string
2193 */
2198 }
2201 }
2203 /**
2204 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2205 *
2206 * @since 1.20
2207 *
2208 * @param int $seconds The amount of seconds.
2209 * @param array $chosenIntervals The intervals to enable.
2210 *
2211 * @return string
2212 */
2219 // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2220 // duration-years, duration-decades, duration-centuries, duration-millennia
2223 }
2226 }
2228 /**
2229 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2230 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2231 *
2232 * @since 1.20
2233 *
2234 * @param int $seconds The amount of seconds.
2235 * @param array $chosenIntervals The intervals to enable.
2236 *
2237 * @return array
2238 */
2249 'seconds'
2250 );
2251 }
2265 }
2266 }
2269 }
2271 /**
2272 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2273 *
2274 * @param string $type Can be 'date', 'time' or 'both'
2275 * @param string $ts The time format which needs to be turned into a
2276 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2277 * @param User $user User object used to get preferences for timezone and format
2278 * @param array $options Array, can contain the following keys:
2279 * - 'timecorrection': time correction, can have the following values:
2280 * - true: use user's preference
2281 * - false: don't use time correction
2282 * - int: value of time correction in minutes
2283 * - 'format': format to use, can have the following values:
2284 * - true: use user's preference
2285 * - false: use default preference
2286 * - string: format to use
2287 * @since 1.19
2288 * @return string
2289 */
2298 }
2300 }
2305 }
2308 }
2310 /**
2311 * Get the formatted date for the given timestamp and formatted for
2312 * the given user.
2313 *
2314 * @param mixed $ts Mixed: the time format which needs to be turned into a
2315 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2316 * @param User $user User object used to get preferences for timezone and format
2317 * @param array $options Array, can contain the following keys:
2318 * - 'timecorrection': time correction, can have the following values:
2319 * - true: use user's preference
2320 * - false: don't use time correction
2321 * - int: value of time correction in minutes
2322 * - 'format': format to use, can have the following values:
2323 * - true: use user's preference
2324 * - false: use default preference
2325 * - string: format to use
2326 * @since 1.19
2327 * @return string
2328 */
2331 }
2333 /**
2334 * Get the formatted time for the given timestamp and formatted for
2335 * the given user.
2336 *
2337 * @param mixed $ts The time format which needs to be turned into a
2338 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2339 * @param User $user User object used to get preferences for timezone and format
2340 * @param array $options Array, can contain the following keys:
2341 * - 'timecorrection': time correction, can have the following values:
2342 * - true: use user's preference
2343 * - false: don't use time correction
2344 * - int: value of time correction in minutes
2345 * - 'format': format to use, can have the following values:
2346 * - true: use user's preference
2347 * - false: use default preference
2348 * - string: format to use
2349 * @since 1.19
2350 * @return string
2351 */
2354 }
2356 /**
2357 * Get the formatted date and time for the given timestamp and formatted for
2358 * the given user.
2359 *
2360 * @param mixed $ts the time format which needs to be turned into a
2361 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2362 * @param User $user User object used to get preferences for timezone and format
2363 * @param array $options Array, can contain the following keys:
2364 * - 'timecorrection': time correction, can have the following values:
2365 * - true: use user's preference
2366 * - false: don't use time correction
2367 * - int: value of time correction in minutes
2368 * - 'format': format to use, can have the following values:
2369 * - true: use user's preference
2370 * - false: use default preference
2371 * - string: format to use
2372 * @since 1.19
2373 * @return string
2374 */
2377 }
2379 /**
2380 * Convert an MWTimestamp into a pretty human-readable timestamp using
2381 * the given user preferences and relative base time.
2382 *
2383 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2384 * on your timestamp object, which will then call this function. Calling
2385 * this function directly will cause hooks to be skipped over.
2386 *
2387 * @see MWTimestamp::getHumanTimestamp
2388 * @param MWTimestamp $ts Timestamp to prettify
2389 * @param MWTimestamp $relativeTo Base timestamp
2390 * @param User $user User preferences to use
2391 * @return string Human timestamp
2392 * @since 1.22
2393 */
2401 ) {
2402 // Timestamps are in different years: use full timestamp
2403 // Also do full timestamp for future dates
2404 /**
2405 * @FIXME Add better handling of future timestamps.
2406 */
2410 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2414 // Timestamp within the past week: show the day of the week and time
2417 // Messages:
2418 // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2424 // Timestamp was yesterday: say 'yesterday' and the time.
2431 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2438 // From here on in, the timestamp was soon enough ago so that we can simply say
2439 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2441 // Less than 90 minutes, but more than an hour ago.
2444 // A few minutes ago.
2447 // Less than a minute, but more than 30 sec ago.
2450 // Less than 30 seconds ago.
2452 }
2455 }
2457 /**
2458 * @param string $key
2459 * @return array|null
2460 */
2463 }
2465 /**
2466 * @return array
2467 */
2470 }
2472 /**
2473 * @param string $in
2474 * @param string $out
2475 * @param string $string
2476 * @return string
2477 */
2479 # This is a wrapper for iconv in all languages except esperanto,
2480 # which does some nasty x-conversions beforehand
2482 # Even with //IGNORE iconv can whine about illegal characters in
2483 # *input* string. We just ignore those too.
2484 # REF: http://bugs.php.net/bug.php?id=37166
2485 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2490 }
2492 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2494 /**
2495 * @param array $matches
2496 * @return mixed|string
2497 */
2500 }
2502 /**
2503 * @param array $matches
2504 * @return string
2505 */
2508 }
2510 /**
2511 * @param array $matches
2512 * @return string
2513 */
2517 }
2519 /**
2520 * @param array $matches
2521 * @return string
2522 */
2526 }
2528 /**
2529 * @param array $matches
2530 * @return string
2531 */
2534 }
2536 /**
2537 * @param array $matches
2538 * @return string
2539 */
2543 }
2545 /**
2546 * Make a string's first character uppercase
2547 *
2548 * @param string $str
2549 *
2550 * @return string
2551 */
2559 // fall back to more complex logic in case of multibyte strings
2561 }
2562 }
2564 /**
2565 * Convert a string to uppercase
2566 *
2567 * @param string $str
2568 * @param bool $first
2569 *
2570 * @return string
2571 */
2579 }
2582 }
2589 $str
2590 );
2593 }
2594 }
2595 }
2597 /**
2598 * @param string $str
2599 * @return mixed|string
2600 */
2612 }
2613 }
2615 /**
2616 * @param string $str
2617 * @param bool $first
2618 * @return mixed|string
2619 */
2627 }
2630 }
2637 $str
2638 );
2641 }
2642 }
2643 }
2645 /**
2646 * @param string $str
2647 * @return bool
2648 */
2651 }
2653 /**
2654 * @param string $str
2655 * @return mixed|string
2656 */
2661 // regexp to find first letter in each word (i.e. after each space)
2662 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2664 // function to use to capitalize a single char
2669 $str
2670 );
2675 $str
2676 );
2677 }
2680 }
2681 }
2683 /**
2684 * capitalize words at word breaks
2685 *
2686 * @param string $str
2687 * @return mixed
2688 */
2693 // since \b doesn't work for UTF-8, we explicitely define word break chars
2696 // find first letter after word break
2704 $str
2705 );
2710 $str
2711 );
2712 }
2717 $str
2718 );
2719 }
2720 }
2722 /**
2723 * Return a case-folded representation of $s
2724 *
2725 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2726 * and $s2 are the same except for the case of their characters. It is not
2727 * necessary for the value returned to make sense when displayed.
2728 *
2729 * Do *not* perform any other normalisation in this function. If a caller
2730 * uses this function when it should be using a more general normalisation
2731 * function, then fix the caller.
2732 *
2733 * @param string $s
2734 *
2735 * @return string
2736 */
2739 }
2741 /**
2742 * @param string $s
2743 * @return string
2744 */
2748 }
2751 }
2754 }
2756 /**
2757 * @return array
2758 */
2761 }
2763 /**
2764 * Most writing systems use whitespace to break up words.
2765 * Some languages such as Chinese don't conventionally do this,
2766 * which requires special handling when breaking up words for
2767 * searching etc.
2768 *
2769 * @return bool
2770 */
2773 }
2775 /**
2776 * Some languages such as Chinese require word segmentation,
2777 * Specify such segmentation when overridden in derived class.
2778 *
2779 * @param string $string
2780 * @return string
2781 */
2784 }
2786 /**
2787 * Some languages have special punctuation need to be normalized.
2788 * Make such changes here.
2789 *
2790 * @param string $string
2791 * @return string
2792 */
2795 }
2797 /**
2798 * convert double-width roman characters to single-width.
2799 * range: ff00-ff5f ~= 0020-007f
2800 *
2801 * @param string $string
2802 *
2803 * @return string
2804 */
2814 }
2818 }
2820 /**
2821 * @param string $string
2822 * @param string $pattern
2823 * @return string
2824 */
2829 }
2831 /**
2832 * @param array $termsArray
2833 * @return array
2834 */
2836 # some languages, e.g. Chinese, need to do a conversion
2837 # in order for search results to be displayed correctly
2839 }
2841 /**
2842 * Get the first character of a string.
2843 *
2844 * @param string $s
2845 * @return string
2846 */
2853 $matches
2854 );
2859 }
2861 // Break down Hangul syllables to grab the first jamo
2893 }
2896 }
2897 }
2900 # Some languages may have an alternate char encoding option
2901 # (Esperanto X-coding, Japanese furigana conversion, etc)
2902 # If this language is used as the primary content language,
2903 # an override to the defaults can be set here on startup.
2904 }
2906 /**
2907 * @param string $s
2908 * @return string
2909 */
2911 # For some languages we'll want to explicitly specify
2912 # which characters make it into the edit box raw
2913 # or are converted in some way or another.
2919 }
2920 }
2922 /**
2923 * @param string $s
2924 * @return string
2925 */
2927 # Take the previous into account.
2933 }
2938 }
2939 }
2941 /**
2942 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2943 * also cleans up certain backwards-compatible sequences, converting them
2944 * to the modern Unicode equivalent.
2945 *
2946 * This is language-specific for performance reasons only.
2947 *
2948 * @param string $s
2949 *
2950 * @return string
2951 */
2958 }
2961 }
2963 /**
2964 * Transform a string using serialized data stored in the given file (which
2965 * must be in the serialized subdirectory of $IP). The file contains pairs
2966 * mapping source characters to destination characters.
2967 *
2968 * The data is cached in process memory. This will go faster if you have the
2969 * FastStringSearch extension.
2970 *
2971 * @param string $file
2972 * @param string $string
2973 *
2974 * @throws MWException
2975 * @return string
2976 */
2982 }
2984 }
2986 }
2988 /**
2989 * For right-to-left language support
2990 *
2991 * @return bool
2992 */
2995 }
2997 /**
2998 * Return the correct HTML 'dir' attribute value for this language.
2999 * @return string
3000 */
3003 }
3005 /**
3006 * Return 'left' or 'right' as appropriate alignment for line-start
3007 * for this language's text direction.
3008 *
3009 * Should be equivalent to CSS3 'start' text-align value....
3010 *
3011 * @return string
3012 */
3015 }
3017 /**
3018 * Return 'right' or 'left' as appropriate alignment for line-end
3019 * for this language's text direction.
3020 *
3021 * Should be equivalent to CSS3 'end' text-align value....
3022 *
3023 * @return string
3024 */
3027 }
3029 /**
3030 * A hidden direction mark (LRM or RLM), depending on the language direction.
3031 * Unlike getDirMark(), this function returns the character as an HTML entity.
3032 * This function should be used when the output is guaranteed to be HTML,
3033 * because it makes the output HTML source code more readable. When
3034 * the output is plain text or can be escaped, getDirMark() should be used.
3035 *
3036 * @param bool $opposite Get the direction mark opposite to your language
3037 * @return string
3038 * @since 1.20
3039 */
3043 }
3045 }
3047 /**
3048 * A hidden direction mark (LRM or RLM), depending on the language direction.
3049 * This function produces them as invisible Unicode characters and
3050 * the output may be hard to read and debug, so it should only be used
3051 * when the output is plain text or can be escaped. When the output is
3052 * HTML, use getDirMarkEntity() instead.
3053 *
3054 * @param bool $opposite Get the direction mark opposite to your language
3055 * @return string
3056 */
3062 }
3064 }
3066 /**
3067 * @return array
3068 */
3071 }
3073 /**
3074 * An arrow, depending on the language direction.
3075 *
3076 * @param string $direction The direction of the arrow: forwards (default),
3077 * backwards, left, right, up, down.
3078 * @return string
3079 */
3094 }
3095 }
3097 /**
3098 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
3099 *
3100 * @return bool
3101 */
3104 }
3106 /**
3107 * Get all magic words from cache.
3108 * @return array
3109 */
3112 }
3114 /**
3115 * Run the LanguageGetMagic hook once.
3116 */
3120 }
3125 }
3127 /**
3128 * Fill a MagicWord object with data from here
3129 *
3130 * @param MagicWord $mw
3131 */
3133 // Saves a function call
3136 }
3143 }
3150 }
3151 }
3153 /**
3154 * Add magic words to the extension array
3155 *
3156 * @param array $newWords
3157 */
3164 }
3165 }
3166 }
3168 /**
3169 * Get special page names, as an associative array
3170 * case folded alias => real name
3171 * @return array
3172 */
3174 // Cache aliases because it may be slow to load them
3176 // Initialise array
3181 }
3184 }
3186 /**
3187 * Italic is unsuitable for some languages
3188 *
3189 * @param string $text The text to be emphasized.
3190 * @return string
3191 */
3194 }
3196 /**
3197 * Normally we output all numbers in plain en_US style, that is
3198 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3199 * point twohundredthirtyfive. However this is not suitable for all
3200 * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3201 * Icelandic just want to use commas instead of dots, and dots instead
3202 * of commas like "293.291,235".
3203 *
3204 * An example of this function being called:
3205 * <code>
3206 * wfMessage( 'message' )->numParams( $num )->text()
3207 * </code>
3208 *
3209 * See $separatorTransformTable on MessageIs.php for
3210 * the , => . and . => , implementation.
3211 *
3212 * @todo check if it's viable to use localeconv() for the decimal separator thing.
3213 * @param int|float $number The string to be formatted, should be an integer
3214 * or a floating point number.
3215 * @param bool $nocommafy Set to true for special numbers like dates
3216 * @return string
3217 */
3225 }
3226 }
3232 }
3233 }
3236 }
3238 /**
3239 * Front-end for non-commafied formatNum
3240 *
3241 * @param int|float $number The string to be formatted, should be an integer
3242 * or a floating point number.
3243 * @since 1.21
3244 * @return string
3245 */
3248 }
3250 /**
3251 * @param string $number
3252 * @return string
3253 */
3257 // eliminate empty array values such as ''. (bug 64347)
3260 }
3264 // eliminate empty array values such as ''. (bug 64347)
3267 }
3271 }
3273 /**
3274 * Adds commas to a given number
3275 * @since 1.19
3276 * @param mixed $number
3277 * @return string
3278 */
3283 }
3286 // default grouping is at thousands, use the same for ###,###,### pattern too.
3289 // Ref: http://cldr.unicode.org/translation/number-patterns
3292 // For negative numbers apply the algorithm like positive number and add sign.
3295 }
3303 // the string does not have any number part. Eg: .12345
3305 }
3313 }
3317 // use the last pattern for the rest of the number
3319 }
3322 }
3323 }
3325 }
3326 }
3328 /**
3329 * @return string
3330 */
3333 }
3335 /**
3336 * @return array
3337 */
3340 }
3342 /**
3343 * @return array
3344 */
3347 }
3349 /**
3350 * Take a list of strings and build a locale-friendly comma-separated
3351 * list, using the local comma-separator message.
3352 * The last two strings are chained with an "and".
3353 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3354 *
3355 * @param string[] $l
3356 * @return string
3357 */
3362 }
3368 }
3369 }
3376 }
3377 }
3379 }
3381 /**
3382 * Take a list of strings and build a locale-friendly comma-separated
3383 * list, using the local comma-separator message.
3384 * @param string[] $list Array of strings to put in a comma list
3385 * @return string
3386 */
3390 $list
3391 );
3392 }
3394 /**
3395 * Take a list of strings and build a locale-friendly semicolon-separated
3396 * list, using the local semicolon-separator message.
3397 * @param string[] $list Array of strings to put in a semicolon list
3398 * @return string
3399 */
3403 $list
3404 );
3405 }
3407 /**
3408 * Same as commaList, but separate it with the pipe instead.
3409 * @param string[] $list Array of strings to put in a pipe list
3410 * @return string
3411 */
3415 $list
3416 );
3417 }
3419 /**
3420 * Truncate a string to a specified length in bytes, appending an optional
3421 * string (e.g. for ellipses)
3422 *
3423 * The database offers limited byte lengths for some columns in the database;
3424 * multi-byte character sets mean we need to ensure that only whole characters
3425 * are included, otherwise broken characters can be passed to the user
3426 *
3427 * If $length is negative, the string will be truncated from the beginning
3428 *
3429 * @param string $string String to truncate
3430 * @param int $length Maximum length (including ellipses)
3431 * @param string $ellipsis String to append to the truncated text
3432 * @param bool $adjustLength Subtract length of ellipsis from $length.
3433 * $adjustLength was introduced in 1.18, before that behaved as if false.
3434 * @return string
3435 */
3437 # Use the localized ellipsis character
3440 }
3441 # Check if there is no need to truncate
3446 }
3448 # If ellipsis length is >= $length then we can't apply $adjustLength
3451 # Otherwise, truncate and add ellipsis...
3466 }
3467 }
3468 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3469 # This check is *not* redundant if $adjustLength, due to the single case where
3470 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3475 }
3476 }
3478 /**
3479 * Remove bytes that represent an incomplete Unicode character
3480 * at the end of string (e.g. bytes of the char are missing)
3481 *
3482 * @param string $string
3483 * @return string
3484 */
3490 # We got the first byte only of a multibyte char; remove it.
3495 ) {
3496 # We chopped in the middle of a character; remove it
3498 }
3499 }
3501 }
3503 /**
3504 * Remove bytes that represent an incomplete Unicode character
3505 * at the start of string (e.g. bytes of the char are missing)
3506 *
3507 * @param string $string
3508 * @return string
3509 */
3514 # We chopped in the middle of a character; remove the whole thing
3516 }
3517 }
3519 }
3521 /**
3522 * Truncate a string of valid HTML to a specified length in bytes,
3523 * appending an optional string (e.g. for ellipses), and return valid HTML
3524 *
3525 * This is only intended for styled/linked text, such as HTML with
3526 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3527 * Also, this will not detect things like "display:none" CSS.
3528 *
3529 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3530 *
3531 * @param string $text HTML string to truncate
3532 * @param int $length (zero/positive) Maximum length (including ellipses)
3533 * @param string $ellipsis String to append to the truncated text
3534 * @return string
3535 */
3537 # Use the localized ellipsis character
3540 }
3541 # Check if there is clearly no need to truncate
3546 }
3560 # Consider truncation once the display length has reached the maximim.
3561 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3562 # Check that we're not in the middle of a bracket/entity...
3566 # Save where we are; we will truncate here unless there turn out to
3567 # be so few remaining characters that truncation is not necessary.
3570 }
3572 # String in fact does need truncation, the truncation point was OK.
3577 }
3578 }
3581 }
3583 # Read the next char...
3601 }
3607 // Name found (e.g. "<a href=..."), add on tag attributes...
3609 }
3615 }
3618 // Save state without $ch. We want to *hit* the first
3619 // display char (to get tags) but not *use* it if truncating.
3621 }
3626 // Add the next $max display text chars after this in one swoop...
3631 }
3632 }
3633 }
3634 }
3635 // Close the last tag if left unclosed by bad HTML
3639 }
3641 }
3643 /**
3644 * truncateHtml() helper function
3645 * like strcspn() but adds the skipped chars to $ret
3646 *
3647 * @param string $ret
3648 * @param string $text
3649 * @param string $search
3650 * @param int $start
3651 * @param null|int $len
3652 * @return int
3653 */
3659 }
3664 }
3666 }
3668 /**
3669 * truncateHtml() helper function
3670 * (a) push or pop $tag from $openTags as needed
3671 * (b) clear $tag value
3672 * @param string &$tag Current HTML tag name we are looking at
3673 * @param int $tagType (0-open tag, 1-close tag)
3674 * @param string $lastCh Character before the '>' that ended this tag
3675 * @param array &$openTags Open tag stack (not accounting for $tag)
3676 */
3685 }
3686 }
3688 }
3689 }
3691 /**
3692 * Grammatical transformations, needed for inflected languages
3693 * Invoked by putting {{grammar:case|word}} in a message
3694 *
3695 * @param string $word
3696 * @param string $case
3697 * @return string
3698 */
3703 }
3706 }
3707 /**
3708 * Get the grammar forms for the content language
3709 * @return array Array of grammar forms
3710 * @since 1.20
3711 */
3716 ) {
3718 }
3721 }
3722 /**
3723 * Provides an alternative text depending on specified gender.
3724 * Usage {{gender:username|masculine|feminine|unknown}}.
3725 * username is optional, in which case the gender of current user is used,
3726 * but only in (some) interface messages; otherwise default gender is used.
3727 *
3728 * If no forms are given, an empty string is returned. If only one form is
3729 * given, it will be returned unconditionally. These details are implied by
3730 * the caller and cannot be overridden in subclasses.
3731 *
3732 * If three forms are given, the default is to use the third (unknown) form.
3733 * If fewer than three forms are given, the default is to use the first (masculine) form.
3734 * These details can be overridden in subclasses.
3735 *
3736 * @param string $gender
3737 * @param array $forms
3738 *
3739 * @return string
3740 */
3744 }
3748 }
3751 }
3753 }
3755 /**
3756 * Plural form transformations, needed for some languages.
3757 * For example, there are 3 form of plural in Russian and Polish,
3758 * depending on "count mod 10". See [[w:Plural]]
3759 * For English it is pretty simple.
3760 *
3761 * Invoked by putting {{plural:count|wordform1|wordform2}}
3762 * or {{plural:count|wordform1|wordform2|wordform3}}
3763 *
3764 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3765 *
3766 * @param int $count Non-localized number
3767 * @param array $forms Different plural forms
3768 * @return string Correct form of plural for $count in this language
3769 */
3771 // Handle explicit n=pluralform cases
3775 }
3778 }
3783 }
3785 /**
3786 * Handles explicit plural forms for Language::convertPlural()
3787 *
3788 * In {{PLURAL:$1|0=nothing|one|many}}, 0=nothing will be returned if $1 equals zero.
3789 * If an explicitly defined plural form matches the $count, then
3790 * string value returned, otherwise array returned for further consideration
3791 * by CLDR rules or overridden convertPlural().
3792 *
3793 * @since 1.23
3794 *
3795 * @param int $count non-localized number
3796 * @param array $forms different plural forms
3797 *
3798 * @return array|string
3799 */
3806 }
3808 }
3809 }
3811 }
3813 /**
3814 * Checks that convertPlural was given an array and pads it to requested
3815 * amount of forms by copying the last one.
3816 *
3817 * @param int $count How many forms should there be at least
3818 * @param array $forms Array of forms given to convertPlural
3819 * @return array Padded array of forms or an exception if not an array
3820 */
3824 }
3826 }
3828 /**
3829 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3830 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3831 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3832 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3833 * match up with it.
3834 *
3835 * @param string $str The validated block duration in English
3836 * @return string Somehow translated block duration
3837 * @see LanguageFi.php for example implementation
3838 */
3844 }
3845 }
3847 // Since usually only infinite or indefinite is only on list, so try
3848 // equivalents if still here.
3855 }
3856 }
3857 }
3859 // If all else fails, return a standard duration or timestamp description.
3864 // $time is relative to 0 so it's a duration length.
3868 // wfTimestamp() handles 0 as current time instead of epoch.
3872 }
3873 }
3874 }
3876 /**
3877 * languages like Chinese need to be segmented in order for the diff
3878 * to be of any use
3879 *
3880 * @param string $text
3881 * @return string
3882 */
3885 }
3887 /**
3888 * and unsegment to show the result
3889 *
3890 * @param string $text
3891 * @return string
3892 */
3895 }
3897 /**
3898 * Return the LanguageConverter used in the Language
3899 *
3900 * @since 1.19
3901 * @return LanguageConverter
3902 */
3905 }
3907 /**
3908 * convert text to all supported variants
3909 *
3910 * @param string $text
3911 * @return array
3912 */
3915 }
3917 /**
3918 * convert text to different variants of a language.
3919 *
3920 * @param string $text
3921 * @return string
3922 */
3925 }
3927 /**
3928 * Convert a Title object to a string in the preferred variant
3929 *
3930 * @param Title $title
3931 * @return string
3932 */
3935 }
3937 /**
3938 * Convert a namespace index to a string in the preferred variant
3939 *
3940 * @param int $ns
3941 * @return string
3942 */
3945 }
3947 /**
3948 * Check if this is a language with variants
3949 *
3950 * @return bool
3951 */
3954 }
3956 /**
3957 * Check if the language has the specific variant
3958 *
3959 * @since 1.19
3960 * @param string $variant
3961 * @return bool
3962 */
3965 }
3967 /**
3968 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3969 *
3970 * @param string $text
3971 * @return string
3972 * @deprecated since 1.22 is no longer used
3973 */
3976 }
3978 /**
3979 * Perform output conversion on a string, and encode for safe HTML output.
3980 * @param string $text Text to be converted
3981 * @param bool $isTitle Whether this conversion is for the article title
3982 * @return string
3983 * @todo this should get integrated somewhere sane
3984 */
3987 }
3989 /**
3990 * @param string $key
3991 * @return string
3992 */
3995 }
3997 /**
3998 * Get the list of variants supported by this language
3999 * see sample implementation in LanguageZh.php
4000 *
4001 * @return array an array of language codes
4002 */
4005 }
4007 /**
4008 * @return string
4009 */
4012 }
4014 /**
4015 * @return string
4016 */
4019 }
4021 /**
4022 * @return string
4023 */
4026 }
4028 /**
4029 * If a language supports multiple variants, it is
4030 * possible that non-existing link in one variant
4031 * actually exists in another variant. this function
4032 * tries to find it. See e.g. LanguageZh.php
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 * @return null the input parameters may be modified upon return
4039 */
4042 }
4044 /**
4045 * returns language specific options used by User::getPageRenderHash()
4046 * for example, the preferred language variant
4047 *
4048 * @return string
4049 */
4052 }
4054 /**
4055 * For languages that support multiple variants, the title of an
4056 * article may be displayed differently in different variants. this
4057 * function returns the apporiate title defined in the body of the article.
4058 *
4059 * @return string
4060 */
4063 }
4065 /**
4066 * Prepare external link text for conversion. When the text is
4067 * a URL, it shouldn't be converted, and it'll be wrapped in
4068 * the "raw" tag (-{R| }-) to prevent conversion.
4069 *
4070 * This function is called "markNoConversion" for historical
4071 * reasons.
4072 *
4073 * @param string $text Text to be used for external link
4074 * @param bool $noParse Wrap it without confirming it's a real URL first
4075 * @return string The tagged text
4076 */
4078 // Excluding protocal-relative URLs may avoid many false positives.
4083 }
4084 }
4086 /**
4087 * A regular expression to match legal word-trailing characters
4088 * which should be merged onto a link of the form [[foo]]bar.
4089 *
4090 * @return string
4091 */
4094 }
4096 /**
4097 * A regular expression character set to match legal word-prefixing
4098 * characters which should be merged onto a link of the form foo[[bar]].
4099 *
4100 * @return string
4101 */
4104 }
4106 /**
4107 * @deprecated since 1.24, will be removed in 1.25
4108 * @return Language
4109 */
4113 }
4115 /**
4116 * Get the "parent" language which has a converter to convert a "compatible" language
4117 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
4118 *
4119 * @return Language|null
4120 * @since 1.22
4121 */
4125 }
4132 }
4137 }
4141 }
4143 /**
4144 * Get the RFC 3066 code for this language object
4145 *
4146 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4147 * htmlspecialchars() or similar
4148 *
4149 * @return string
4150 */
4153 }
4155 /**
4156 * Get the code in Bcp47 format which we can use
4157 * inside of html lang="" tags.
4158 *
4159 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4160 * htmlspecialchars() or similar.
4161 *
4162 * @since 1.19
4163 * @return string
4164 */
4168 }
4170 }
4172 /**
4173 * @param string $code
4174 */
4177 // Ensure we don't leave incorrect cached data lying around
4180 }
4182 /**
4183 * Get the name of a file for a certain language code
4184 * @param string $prefix Prepend this to the filename
4185 * @param string $code Language code
4186 * @param string $suffix Append this to the filename
4187 * @throws MWException
4188 * @return string $prefix . $mangledCode . $suffix
4189 */
4193 }
4196 }
4198 /**
4199 * Get the language code from a file name. Inverse of getFileName()
4200 * @param string $filename $prefix . $languageCode . $suffix
4201 * @param string $prefix Prefix before the language code
4202 * @param string $suffix Suffix after the language code
4203 * @return string Language code, or false if $prefix or $suffix isn't found
4204 */
4205 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4211 }
4213 }
4215 /**
4216 * @param string $code
4217 * @return string
4218 */
4224 }
4226 /**
4227 * @param string $code
4228 * @return string
4229 * @since 1.23
4230 */
4236 }
4239 }
4241 /**
4242 * @param string $code
4243 * @return string
4244 */
4248 }
4250 /**
4251 * Get the first fallback for a given language.
4252 *
4253 * @param string $code
4254 *
4255 * @return bool|string
4256 */
4264 }
4265 }
4267 /**
4268 * Get the ordered list of fallback languages.
4269 *
4270 * @since 1.19
4271 * @param string $code Language code
4272 * @return array
4273 */
4282 }
4284 }
4285 }
4287 /**
4288 * Get the ordered list of fallback languages, ending with the fallback
4289 * language chain for the site language.
4290 *
4291 * @since 1.22
4292 * @param string $code Language code
4293 * @return array array( fallbacks, site fallbacks )
4294 */
4298 // Usually, we will only store a tiny number of fallback chains, so we
4299 // keep them in static memory.
4305 // Append the site's fallback chain, including the site language itself
4309 // Eliminate any languages already included in the chain
4313 }
4315 }
4317 /**
4318 * Get all messages for a given language
4319 * WARNING: this may take a long time. If you just need all message *keys*
4320 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4321 *
4322 * @param string $code
4323 *
4324 * @return array
4325 */
4328 }
4330 /**
4331 * Get a message for a given language
4332 *
4333 * @param string $key
4334 * @param string $code
4335 *
4336 * @return string
4337 */
4340 }
4342 /**
4343 * Get all message keys for a given language. This is a faster alternative to
4344 * array_keys( Language::getMessagesFor( $code ) )
4345 *
4346 * @since 1.19
4347 * @param string $code Language code
4348 * @return array of message keys (strings)
4349 */
4352 }
4354 /**
4355 * @param string $talk
4356 * @return mixed
4357 */
4361 }
4366 # Allow grammar transformations
4367 # Allowing full message-style parsing would make simple requests
4368 # such as action=raw much more expensive than they need to be.
4369 # This will hopefully cover most cases.
4373 }
4375 /**
4376 * @param string $m
4377 * @return string
4378 */
4381 }
4383 /**
4384 * @throws MWException
4385 * @return array
4386 */
4391 }
4398 }
4403 }
4405 /**
4406 * Decode an expiry (block, protection, etc) which has come from the DB
4407 *
4408 * @todo FIXME: why are we returnings DBMS-dependent strings???
4409 *
4410 * @param string $expiry Database expiry String
4411 * @param bool|int $format True to process using language functions, or TS_ constant
4412 * to return the expiry in a given timestamp
4413 * @return string
4414 * @since 1.18
4415 */
4420 }
4430 }
4431 }
4433 /**
4434 * @todo Document
4435 * @param int|float $seconds
4436 * @param array $format Optional
4437 * If $format['avoid'] === 'avoidseconds': don't mention seconds if $seconds >= 1 hour.
4438 * If $format['avoid'] === 'avoidminutes': don't mention seconds/minutes if $seconds > 48 hours.
4439 * If $format['noabbrevs'] is true: use 'seconds' and friends instead of 'seconds-abbrev'
4440 * and friends.
4441 * For backwards compatibility, $format may also be one of the strings 'avoidseconds'
4442 * or 'avoidminutes'.
4443 * @return string
4444 */
4448 }
4451 }
4454 }
4476 }
4487 }
4491 }
4497 }
4505 }
4515 }
4519 }
4529 }
4530 }
4532 }
4534 /**
4535 * Format a bitrate for output, using an appropriate
4536 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to
4537 * the magnitude in question.
4538 *
4539 * This use base 1000. For base 1024 use formatSize(), for another base
4540 * see formatComputingNumbers().
4541 *
4542 * @param int $bps
4543 * @return string
4544 */
4547 }
4549 /**
4550 * @param int $size Size of the unit
4551 * @param int $boundary Size boundary (1000, or 1024 in most cases)
4552 * @param string $messageKey Message key to be uesd
4553 * @return string
4554 */
4559 );
4560 }
4568 }
4570 // For small sizes no decimal places necessary
4573 // For MB and bigger two decimal places are smarter
4575 }
4581 }
4583 /**
4584 * Format a size in bytes for output, using an appropriate
4585 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4586 *
4587 * This method use base 1024. For base 1000 use formatBitrate(), for
4588 * another base see formatComputingNumbers()
4589 *
4590 * @param int $size Size to format
4591 * @return string Plain text (not HTML)
4592 */
4595 }
4597 /**
4598 * Make a list item, used by various special pages
4599 *
4600 * @param string $page Page link
4601 * @param string $details Text between brackets
4602 * @param bool $oppositedm Add the direction mark opposite to your
4603 * language, to display text properly
4604 * @return string
4605 */
4612 }
4614 /**
4615 * Generate (prev x| next x) (20|50|100...) type links for paging
4616 *
4617 * @param Title $title Title object to link
4618 * @param int $offset
4619 * @param int $limit
4620 * @param array|string $query Optional URL query parameter string
4621 * @param bool $atend Optional param for specified if this is the last page
4622 * @return string
4623 */
4626 ) {
4627 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4629 # Make 'previous' link
4630 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4636 }
4638 # Make 'next' link
4639 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4645 }
4647 # Make links to set number of items per page
4652 }
4656 }
4658 /**
4659 * Helper function for viewPrevNext() that generates links
4660 *
4661 * @param Title $title Title object to link
4662 * @param int $offset
4663 * @param int $limit
4664 * @param array $query Extra query parameters
4665 * @param string $link Text to use for the link; will be escaped
4666 * @param string $tooltipMsg Name of the message to use as tooltip
4667 * @param string $class Value of the "class" attribute of the link
4668 * @return string HTML fragment
4669 */
4672 ) {
4679 }
4681 /**
4682 * Get the conversion rule title, if any.
4683 *
4684 * @return string
4685 */
4688 }
4690 /**
4691 * Get the compiled plural rules for the language
4692 * @since 1.20
4693 * @return array Associative array with plural form, and plural rule as key-value pairs
4694 */
4700 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4703 }
4704 }
4705 }
4707 }
4709 /**
4710 * Get the plural rules for the language
4711 * @since 1.20
4712 * @return array Associative array with plural form number and plural rule as key-value pairs
4713 */
4722 }
4723 }
4724 }
4726 }
4728 /**
4729 * Get the plural rule types for the language
4730 * @since 1.22
4731 * @return array Associative array with plural form number and plural rule type as key-value pairs
4732 */
4738 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4741 }
4742 }
4743 }
4745 }
4747 /**
4748 * Find the index number of the plural rule appropriate for the given 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 * @return string The name of the plural rule type, e.g. one, two, few, many
4763 */
4771 }
4772 }
4773 }