| blob | d46845fb0603c23d61f61b66078cfc1ba7f433b7 |
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 * Cache for language names
148 * @var MapCacheLRU|null
149 */
152 /**
153 * Get a cached or new language object for a given language code
154 * @param string $code
155 * @return Language
156 */
162 }
164 // get the language object to process
169 // merge the language object in to get it up front in the cache
171 // get rid of the oldest ones in case we have an overflow
175 }
177 /**
178 * Create a language object for a given language code
179 * @param string $code
180 * @throws MWException
181 * @return Language
182 */
184 // Protect against path traversal below
187 ) {
189 }
192 // It's not possible to customise this code with class files, so
193 // just return a Language object. This is to support uselang= hacks.
197 }
199 // Check if there is a language class for the code
205 }
207 // Keep trying the fallback list until we find an existing class
212 }
220 }
221 }
224 }
226 /**
227 * Checks whether any localisation is available for that language tag
228 * in MediaWiki (MessagesXx.php exists).
229 *
230 * @param string $code Language tag (in lower case)
231 * @return bool Whether language is supported
232 * @since 1.21
233 */
238 );
239 }
241 /**
242 * Returns true if a language code string is a well-formed language tag
243 * according to RFC 5646.
244 * This function only checks well-formedness; it doesn't check that
245 * language, script or variant codes actually exist in the repositories.
246 *
247 * Based on regexes by Mark Davis of the Unicode Consortium:
248 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
249 *
250 * @param string $code
251 * @param bool $lenient Whether to allow '_' as separator. The default is only '-'.
252 *
253 * @return bool
254 * @since 1.21
255 */
271 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
272 # Since these are limited, this is safe even later changes to the registry --
273 # the only oddity is that it might change the type of the tag, and thus
274 # the results from the capturing groups.
275 # http://www.iana.org/assignments/language-subtag-registry
293 # The final breakdown, with capturing groups for each of these components
294 # The variants, extensions, grandfathered, and private-use may have interior '-'
299 }
301 /**
302 * Returns true if a language code string is of a valid form, whether or
303 * not it exists. This includes codes which are used solely for
304 * customisation via the MediaWiki namespace.
305 *
306 * @param string $code
307 *
308 * @return bool
309 */
314 }
315 // People think language codes are html safe, so enforce it.
316 // Ideally we should only allow a-zA-Z0-9-
317 // but, .+ and other chars are often used for {{int:}} hacks
318 // see bugs 37564, 37587, 36938
324 }
326 /**
327 * Returns true if a language code is of a valid form for the purposes of
328 * internal customisation of MediaWiki, via Messages*.php or *.json.
329 *
330 * @param string $code
331 *
332 * @throws MWException
333 * @since 1.18
334 * @return bool
335 */
343 }
346 }
349 }
351 /**
352 * Returns true if a language code is an IETF tag known to MediaWiki.
353 *
354 * @param string $tag
355 *
356 * @since 1.21
357 * @return bool
358 */
362 // Quick escape for invalid input to avoid exceptions down the line
363 // when code tries to process tags which are not valid at all.
366 }
371 }
375 ) {
377 }
380 }
382 /**
383 * @param string $code
384 * @return string Name of the language class
385 */
391 }
392 }
394 /**
395 * Includes language class files
396 *
397 * @param string $class Name of the language class
398 */
404 }
408 }
409 }
411 /**
412 * Get the LocalisationCache instance
413 *
414 * @return LocalisationCache
415 */
421 }
423 }
427 // Set the code to the name of the descendant
432 }
434 }
436 /**
437 * Reduce memory usage
438 */
442 }
443 }
445 /**
446 * Hook which will be called if this is the content language.
447 * Descendants can use this to register hook functions or modify globals
448 */
450 }
452 /**
453 * @return array
454 * @since 1.19
455 */
458 }
460 /**
461 * Exports $wgBookstoreListEn
462 * @return array
463 */
466 }
468 /**
469 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
470 * available in localised form, it will be included in English.
471 *
472 * @return array
473 */
490 }
492 # Sometimes a language will be localised but not actually exist on this wiki.
496 }
497 }
499 # The above mixing may leave namespaces out of canonical order.
500 # Re-order by namespace ID number...
504 }
507 }
509 /**
510 * Arbitrarily set all of the namespace names at once. Mainly used for testing
511 * @param array $namespaces Array of namespaces (id => name)
512 */
516 }
518 /**
519 * Resets all of the namespace caches. Mainly used for testing
520 */
525 }
527 /**
528 * A convenience function that returns the same thing as
529 * getNamespaces() except with the array values changed to ' '
530 * where it found '_', useful for producing output to be displayed
531 * e.g. in <select> forms.
532 *
533 * @return array
534 */
539 }
541 }
543 /**
544 * Get a namespace value by key
545 * <code>
546 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
547 * echo $mw_ns; // prints 'MediaWiki'
548 * </code>
549 *
550 * @param int $index The array key of the namespace to return
551 * @return string|bool String if the namespace value exists, otherwise false
552 */
557 }
559 /**
560 * A convenience function that returns the same thing as
561 * getNsText() except with '_' changed to ' ', useful for
562 * producing output.
563 *
564 * <code>
565 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
566 * echo $mw_ns; // prints 'MediaWiki talk'
567 * </code>
568 *
569 * @param int $index The array key of the namespace to return
570 * @return string Namespace name without underscores (empty string if namespace does not exist)
571 */
576 }
578 /**
579 * Returns gender-dependent namespace alias if available.
580 * See https://www.mediawiki.org/wiki/Manual:$wgExtraGenderNamespaces
581 * @param int $index Namespace index
582 * @param string $gender Gender key (male, female... )
583 * @return string
584 * @since 1.18
585 */
593 }
595 /**
596 * Whether this language uses gender-dependent namespace aliases.
597 * See https://www.mediawiki.org/wiki/Manual:$wgExtraGenderNamespaces
598 * @return bool
599 * @since 1.18
600 */
604 // $wgExtraGenderNamespaces overrides everything
606 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
607 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
608 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
611 // Check what is in i18n files
614 }
615 }
617 /**
618 * Get a namespace key by value, case insensitive.
619 * Only matches namespace names for the current language, not the
620 * canonical ones defined in Namespace.php.
621 *
622 * @param string $text
623 * @return int|bool An integer if $text is a valid value otherwise false
624 */
629 }
631 /**
632 * @return array
633 */
645 }
646 }
647 }
655 }
656 }
658 # Also add converted namespace names as aliases, to avoid confusion.
663 }
666 }
667 }
670 }
673 }
675 /**
676 * @return array
677 */
681 # Put namespace names and aliases into a hashtable.
682 # If this is too slow, then we should arrange it so that it is done
683 # before caching. The catch is that at pre-cache time, the above
684 # class-specific fixup hasn't been done.
688 }
691 }
695 }
696 }
697 }
699 }
701 /**
702 * Get a namespace key by value, case insensitive. Canonical namespace
703 * names override custom ones defined for the current language.
704 *
705 * @param string $text
706 * @return int|bool An integer if $text is a valid value otherwise false
707 */
713 }
716 }
718 /**
719 * short names for language variants used for language conversion links.
720 *
721 * @param string $code
722 * @param bool $usemsg Use the "variantname-xyz" message if it exists
723 * @return string
724 */
729 }
734 # otherwise, output the language code
736 }
737 }
739 /**
740 * @deprecated since 1.24, doesn't handle conflicting aliases. Use
741 * SpecialPageFactory::getLocalNameFor instead.
742 * @param string $name
743 * @return string
744 */
749 }
751 }
753 /**
754 * @return array
755 */
758 }
760 /**
761 * @return array
762 */
765 }
767 /**
768 * @return array|string
769 */
777 }
778 }
780 /**
781 * @return array
782 */
785 }
787 /**
788 * @param string $image
789 * @return array|null
790 */
793 }
795 /**
796 * @return array
797 * @since 1.24
798 */
801 }
803 /**
804 * @return array
805 */
808 }
810 /**
811 * @param string $tog
812 * @return string
813 */
816 }
818 /**
819 * Get native language names, indexed by code.
820 * Only those defined in MediaWiki, no other data like CLDR.
821 * If $customisedOnly is true, only returns codes with a messages file
822 *
823 * @param bool $customisedOnly
824 *
825 * @return array
826 * @deprecated since 1.20, use fetchLanguageNames()
827 */
830 }
832 /**
833 * Get translated language names. This is done on best effort and
834 * by default this is exactly the same as Language::getLanguageNames.
835 * The CLDR extension provides translated names.
836 * @param string $code Language code.
837 * @return array Language code => language name
838 * @since 1.18.0
839 * @deprecated since 1.20, use fetchLanguageNames()
840 */
843 }
845 /**
846 * Get an array of language names, indexed by code.
847 * @param null|string $inLanguage Code of language in which to return the names
848 * Use null for autonyms (native names)
849 * @param string $include One of:
850 * 'all' all available languages
851 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
852 * 'mwfile' only if the language is in 'mw' *and* has a message file
853 * @return array Language code => language name
854 * @since 1.20
855 */
862 }
868 }
871 }
873 /**
874 * Uncached helper for fetchLanguageNames
875 * @param null|string $inLanguage Code of language in which to return the names
876 * Use null for autonyms (native names)
877 * @param string $include One of:
878 * 'all' all available languages
879 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
880 * 'mwfile' only if the language is in 'mw' *and* has a message file
881 * @return array Language code => language name
882 */
890 }
892 // If passed an invalid language code to use, fallback to en
895 }
900 # TODO: also include when $inLanguage is null, when this code is more efficient
902 }
906 # - Prefer own MediaWiki native name when not using the hook
907 # - For other names just add if not added through the hook
910 }
911 }
916 }
922 }
926 # We do this using a foreach over the codes instead of a directory
927 # loop so that messages files in extensions will work correctly.
931 ) {
933 }
934 }
938 }
941 # 'mw' option; default if it's not one of the other two options (all/mwfile)
943 }
945 /**
946 * @param string $code The code of the language for which to get the name
947 * @param null|string $inLanguage Code of language in which to return the name (null for autonyms)
948 * @param string $include 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
949 * @return string Language name or empty
950 * @since 1.20
951 */
956 }
958 /**
959 * Get a message from the MediaWiki namespace.
960 *
961 * @param string $msg Message name
962 * @return string
963 */
966 }
968 /**
969 * Get message object in this language. Only for use inside this class.
970 *
971 * @param string $msg Message name
972 * @return Message
973 */
976 }
978 /**
979 * Get the native language name of $code.
980 * Only if defined in MediaWiki, no other data like CLDR.
981 * @param string $code
982 * @return string
983 * @deprecated since 1.20, use fetchLanguageName()
984 */
987 }
989 /**
990 * @param string $key
991 * @return string
992 */
995 }
997 /**
998 * @return array
999 */
1004 }
1006 }
1008 /**
1009 * @param string $key
1010 * @return string
1011 */
1014 }
1016 /**
1017 * @param string $key
1018 * @return string
1019 */
1022 }
1024 /**
1025 * @return array
1026 */
1031 }
1033 }
1035 /**
1036 * @param string $key
1037 * @return string
1038 */
1041 }
1043 /**
1044 * @param string $key
1045 * @return string
1046 */
1049 }
1051 /**
1052 * @param string $key
1053 * @return string
1054 */
1057 }
1059 /**
1060 * @param string $key
1061 * @return string
1062 */
1065 }
1067 /**
1068 * @param string $key
1069 * @return string
1070 */
1073 }
1075 /**
1076 * @param string $key
1077 * @return string
1078 */
1081 }
1083 /**
1084 * Pass through result from $dateTimeObj->format()
1085 * @param DateTime|bool|null &$dateTimeObj
1086 * @param string $ts
1087 * @param DateTimeZone|bool|null $zone
1088 * @param string $code
1089 * @return string
1090 */
1095 );
1096 }
1098 }
1100 /**
1101 * This is a workalike of PHP's date() function, but with better
1102 * internationalisation, a reduced set of format characters, and a better
1103 * escaping format.
1104 *
1105 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1106 * the PHP manual for definitions. There are a number of extensions, which
1107 * start with "x":
1108 *
1109 * xn Do not translate digits of the next numeric format character
1110 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1111 * xr Use roman numerals for the next numeric format character
1112 * xh Use hebrew numerals for the next numeric format character
1113 * xx Literal x
1114 * xg Genitive month name
1115 *
1116 * xij j (day number) in Iranian calendar
1117 * xiF F (month name) in Iranian calendar
1118 * xin n (month number) in Iranian calendar
1119 * xiy y (two digit year) in Iranian calendar
1120 * xiY Y (full year) in Iranian calendar
1121 *
1122 * xjj j (day number) in Hebrew calendar
1123 * xjF F (month name) in Hebrew calendar
1124 * xjt t (days in month) in Hebrew calendar
1125 * xjx xg (genitive month name) in Hebrew calendar
1126 * xjn n (month number) in Hebrew calendar
1127 * xjY Y (full year) in Hebrew calendar
1128 *
1129 * xmj j (day number) in Hijri calendar
1130 * xmF F (month name) in Hijri calendar
1131 * xmn n (month number) in Hijri calendar
1132 * xmY Y (full year) in Hijri calendar
1133 *
1134 * xkY Y (full year) in Thai solar calendar. Months and days are
1135 * identical to the Gregorian calendar
1136 * xoY Y (full year) in Minguo calendar or Juche year.
1137 * Months and days are identical to the
1138 * Gregorian calendar
1139 * xtY Y (full year) in Japanese nengo. Months and days are
1140 * identical to the Gregorian calendar
1141 *
1142 * Characters enclosed in double quotes will be considered literal (with
1143 * the quotes themselves removed). Unmatched quotes will be considered
1144 * literal quotes. Example:
1145 *
1146 * "The month is" F => The month is January
1147 * i's" => 20'11"
1148 *
1149 * Backslash escaping is also supported.
1150 *
1151 * Input timestamp is assumed to be pre-normalized to the desired local
1152 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1153 * $ts is UTC if $zone is not given.
1154 *
1155 * @param string $format
1156 * @param string $ts 14-character timestamp
1157 * YYYYMMDDHHMMSS
1158 * 01234567890123
1159 * @param DateTimeZone $zone Timezone of $ts
1160 * @param[out] int $ttl The amount of time (in seconds) the output may be cached for.
1161 * Only makes sense if $ts is the current time.
1162 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1163 *
1164 * @throws MWException
1165 * @return string
1166 */
1202 }
1206 }
1214 }
1224 }
1250 }
1259 $s .= $this->getWeekdayAbbreviation( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1 );
1269 }
1276 }
1283 }
1288 $s .= $this->getWeekdayName( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1 );
1298 }
1305 }
1312 }
1331 }
1338 }
1345 }
1352 }
1363 }
1370 }
1377 }
1384 }
1391 }
1398 }
1409 }
1449 // fall through
1480 // fall through
1486 # Backslash escaping
1491 }
1494 # Quoted literal
1498 # No terminating quote, assume literal "
1503 }
1505 # Quote at end of string, assume literal "
1507 }
1511 }
1524 }
1525 }
1526 }
1535 $ttl = 43200 - ( substr( $ts, 8, 2 ) % 12 ) * 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1536 } elseif ( $usedDay || $usedHebrewMonth || $usedIranianMonth || $usedHijriMonth || $usedHebrewYear || $usedIranianYear || $usedHijriYear || $usedTennoYear ) {
1537 // @todo Someone who understands the non-Gregorian calendars should write proper logic for them
1538 // so that they don't need purged every day.
1542 $timeRemainingInDay = 86400 - substr( $ts, 8, 2 ) * 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1544 $possibleTtls[] = ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 + $timeRemainingInDay;
1546 // December 28th falls on the last ISO week of the year, every year.
1547 // The last ISO week of a year can be 52 or 53.
1548 $lastWeekOfISOYear = DateTime::createFromFormat( 'Ymd', substr( $ts, 0, 4 ) . '1228', $zone ?: new DateTimeZone( 'UTC' ) )->format( 'W' );
1551 $timeRemainingInWeek = ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 + $timeRemainingInDay;
1553 }
1556 $possibleTtls[] = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 't' ) - substr( $ts, 6, 2 ) ) * 86400 + $timeRemainingInDay;
1558 $possibleTtls[] = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1562 $timeRemainingInYear = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1566 // this isn't a leap year. see when the next one starts
1572 }
1574 // this is a leap year, so the next year isn't
1576 }
1577 }
1581 }
1582 }
1585 }
1590 /**
1591 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1592 * Gregorian dates to Iranian dates. Originally written in C, it
1593 * is released under the terms of GNU Lesser General Public
1594 * License. Conversion to PHP was performed by Niklas Laxström.
1595 *
1596 * Link: http://www.farsiweb.info/jalali/jalali.c
1597 *
1598 * @param string $ts
1599 *
1600 * @return string
1601 */
1607 # Days passed from the beginning (including leap years)
1613 // Add days of the past months of this year
1616 }
1618 // Leap years
1621 }
1623 // Days passed in current month
1637 }
1641 }
1647 }
1649 /**
1650 * Converting Gregorian dates to Hijri dates.
1651 *
1652 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1653 *
1654 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1655 *
1656 * @param string $ts
1657 *
1658 * @return string
1659 */
1673 ) {
1681 }
1695 }
1697 /**
1698 * Converting Gregorian dates to Hebrew dates.
1699 *
1700 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1701 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1702 * to translate the relevant functions into PHP and release them under
1703 * GNU GPL.
1704 *
1705 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1706 * and Adar II is 14. In a non-leap year, Adar is 6.
1707 *
1708 * @param string $ts
1709 *
1710 * @return string
1711 */
1713 # Parse date
1718 # Calculate Hebrew year
1721 # Month number when September = 1, August = 12
1724 # Next year
1728 }
1730 # Calculate day of year from 1 September
1734 # February
1736 # Check if the year is leap
1739 }
1744 }
1745 }
1747 # Calculate the start of the Hebrew year
1750 # Calculate next year's start
1752 # Day is before the start of the year - it is the previous year
1753 # Next year's start
1755 # Previous year
1758 # Add days since previous year's 1 September
1761 # Leap year
1763 }
1764 # Start of the new (previous) year
1767 # Next year's start
1769 }
1771 # Calculate Hebrew day of year
1774 # Difference between year's days
1776 # Add 12 (or 13 for leap years) days to ignore the difference between
1777 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1778 # difference is only about the year type
1783 }
1785 # Check the year pattern, and is leap year
1786 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1787 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1788 # and non-leap years
1790 # Check if leap year
1793 # Calculate day in the month from number of day in the Hebrew year
1794 # Don't check Adar - if the day is not in Adar, we will stop before;
1795 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1800 # Calculate days in this month
1802 # Adar in a leap year
1804 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1807 # Day in Adar I
1810 # Subtract the days of Adar I
1812 # Try Adar II
1815 # Day in Adar II
1817 }
1818 }
1819 }
1821 # Cheshvan in a complete year (otherwise as the rule below)
1824 # Kislev in an incomplete year (otherwise as the rule below)
1827 # Odd months have 30 days, even have 29
1829 }
1831 # In the current month
1834 # Subtract the days of the current month
1836 # Try in the next month
1838 }
1839 }
1842 }
1844 /**
1845 * This calculates the Hebrew year start, as days since 1 September.
1846 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1847 * Used for Hebrew date.
1848 *
1849 * @param int $year
1850 *
1851 * @return string
1852 */
1859 }
1863 }
1873 }
1877 }
1879 /**
1880 * Algorithm to convert Gregorian dates to Thai solar dates,
1881 * Minguo dates or Minguo dates.
1882 *
1883 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1884 * http://en.wikipedia.org/wiki/Minguo_calendar
1885 * http://en.wikipedia.org/wiki/Japanese_era_name
1886 *
1887 * @param string $ts 14-character timestamp
1888 * @param string $cName Calender name
1889 * @return array Converted year, month, day
1890 */
1897 # Thai solar dates
1898 # Add 543 years to the Gregorian calendar
1899 # Months and days are identical
1902 # Minguo dates
1903 # Deduct 1911 years from the Gregorian calendar
1904 # Months and days are identical
1907 # Nengō dates up to Meiji period
1908 # Deduct years from the Gregorian calendar
1909 # depending on the nengo periods
1910 # Months and days are identical
1914 ) {
1915 # Meiji period
1920 }
1928 ) {
1929 # Taishō period
1934 }
1940 ) {
1941 # Shōwa period
1946 }
1949 # Heisei period
1954 }
1956 }
1959 }
1962 }
1964 /**
1965 * Roman number formatting up to 10000
1966 *
1967 * @param int $num
1968 *
1969 * @return string
1970 */
1978 );
1983 }
1989 }
1991 }
1993 }
1995 /**
1996 * Hebrew Gematria number formatting up to 9999
1997 *
1998 * @param int $num
1999 *
2000 * @return string
2001 */
2008 );
2013 }
2025 }
2026 }
2027 }
2029 }
2035 }
2054 }
2056 }
2058 /**
2059 * Used by date() and time() to adjust the time output.
2060 *
2061 * @param string $ts The time in date('YmdHis') format
2062 * @param mixed $tz Adjust the time by this amount (default false, mean we
2063 * get user timecorrection setting)
2064 * @return int
2065 */
2071 }
2084 }
2085 # Unrecognized timezone, default to 'Offset' with the stored offset.
2087 }
2090 # Global offset in minutes.
2102 }
2105 }
2106 }
2108 # No difference ? Return time unchanged
2111 }
2114 # Generate an adjusted date; take advantage of the fact that mktime
2115 # will normalize out-of-range values so we don't have to split $minDiff
2116 # into hours and minutes.
2129 }
2131 /**
2132 * This is meant to be used by time(), date(), and timeanddate() to get
2133 * the date preference they're supposed to use, it should be used in
2134 * all children.
2135 *
2136 *<code>
2137 * function timeanddate([...], $format = true) {
2138 * $datePreference = $this->dateFormat($format);
2139 * [...]
2140 * }
2141 *</code>
2142 *
2143 * @param int|string|bool $usePrefs If true, the user's preference is used
2144 * if false, the site/language default is used
2145 * if int/string, assumed to be a format.
2146 * @return string
2147 */
2156 }
2159 }
2161 // return int
2164 }
2167 }
2169 /**
2170 * Get a format string for a given type and preference
2171 * @param string $type May be date, time or both
2172 * @param string $pref The format name as it appears in Messages*.php
2173 *
2174 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2175 *
2176 * @return string
2177 */
2188 }
2193 }
2194 }
2196 }
2198 }
2200 /**
2201 * @param string $ts The time format which needs to be turned into a
2202 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2203 * @param bool $adj Whether to adjust the time output according to the
2204 * user configured offset ($timecorrection)
2205 * @param mixed $format True to use user's date format preference
2206 * @param string|bool $timecorrection The time offset as returned by
2207 * validateTimeZone() in Special:Preferences
2208 * @return string
2209 */
2214 }
2217 }
2219 /**
2220 * @param string $ts The time format which needs to be turned into a
2221 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2222 * @param bool $adj Whether to adjust the time output according to the
2223 * user configured offset ($timecorrection)
2224 * @param mixed $format True to use user's date format preference
2225 * @param string|bool $timecorrection The time offset as returned by
2226 * validateTimeZone() in Special:Preferences
2227 * @return string
2228 */
2233 }
2236 }
2238 /**
2239 * @param string $ts The time format which needs to be turned into a
2240 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2241 * @param bool $adj Whether to adjust the time output according to the
2242 * user configured offset ($timecorrection)
2243 * @param mixed $format What format to return, if it's false output the
2244 * default one (default true)
2245 * @param string|bool $timecorrection The time offset as returned by
2246 * validateTimeZone() in Special:Preferences
2247 * @return string
2248 */
2253 }
2256 }
2258 /**
2259 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2260 *
2261 * @since 1.20
2262 *
2263 * @param int $seconds The amount of seconds.
2264 * @param array $chosenIntervals The intervals to enable.
2265 *
2266 * @return string
2267 */
2274 // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2275 // duration-years, duration-decades, duration-centuries, duration-millennia
2278 }
2281 }
2283 /**
2284 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2285 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2286 *
2287 * @since 1.20
2288 *
2289 * @param int $seconds The amount of seconds.
2290 * @param array $chosenIntervals The intervals to enable.
2291 *
2292 * @return array
2293 */
2304 'seconds'
2305 );
2306 }
2320 }
2321 }
2324 }
2326 /**
2327 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2328 *
2329 * @param string $type Can be 'date', 'time' or 'both'
2330 * @param string $ts The time format which needs to be turned into a
2331 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2332 * @param User $user User object used to get preferences for timezone and format
2333 * @param array $options Array, can contain the following keys:
2334 * - 'timecorrection': time correction, can have the following values:
2335 * - true: use user's preference
2336 * - false: don't use time correction
2337 * - int: value of time correction in minutes
2338 * - 'format': format to use, can have the following values:
2339 * - true: use user's preference
2340 * - false: use default preference
2341 * - string: format to use
2342 * @since 1.19
2343 * @return string
2344 */
2353 }
2355 }
2360 }
2363 }
2365 /**
2366 * Get the formatted date for the given timestamp and formatted for
2367 * the given user.
2368 *
2369 * @param mixed $ts Mixed: the time format which needs to be turned into a
2370 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2371 * @param User $user User object used to get preferences for timezone and format
2372 * @param array $options Array, can contain the following keys:
2373 * - 'timecorrection': time correction, can have the following values:
2374 * - true: use user's preference
2375 * - false: don't use time correction
2376 * - int: value of time correction in minutes
2377 * - 'format': format to use, can have the following values:
2378 * - true: use user's preference
2379 * - false: use default preference
2380 * - string: format to use
2381 * @since 1.19
2382 * @return string
2383 */
2386 }
2388 /**
2389 * Get the formatted time for the given timestamp and formatted for
2390 * the given user.
2391 *
2392 * @param mixed $ts The time format which needs to be turned into a
2393 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2394 * @param User $user User object used to get preferences for timezone and format
2395 * @param array $options Array, can contain the following keys:
2396 * - 'timecorrection': time correction, can have the following values:
2397 * - true: use user's preference
2398 * - false: don't use time correction
2399 * - int: value of time correction in minutes
2400 * - 'format': format to use, can have the following values:
2401 * - true: use user's preference
2402 * - false: use default preference
2403 * - string: format to use
2404 * @since 1.19
2405 * @return string
2406 */
2409 }
2411 /**
2412 * Get the formatted date and time for the given timestamp and formatted for
2413 * the given user.
2414 *
2415 * @param mixed $ts The time format which needs to be turned into a
2416 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2417 * @param User $user User object used to get preferences for timezone and format
2418 * @param array $options Array, can contain the following keys:
2419 * - 'timecorrection': time correction, can have the following values:
2420 * - true: use user's preference
2421 * - false: don't use time correction
2422 * - int: value of time correction in minutes
2423 * - 'format': format to use, can have the following values:
2424 * - true: use user's preference
2425 * - false: use default preference
2426 * - string: format to use
2427 * @since 1.19
2428 * @return string
2429 */
2432 }
2434 /**
2435 * Convert an MWTimestamp into a pretty human-readable timestamp using
2436 * the given user preferences and relative base time.
2437 *
2438 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2439 * on your timestamp object, which will then call this function. Calling
2440 * this function directly will cause hooks to be skipped over.
2441 *
2442 * @see MWTimestamp::getHumanTimestamp
2443 * @param MWTimestamp $ts Timestamp to prettify
2444 * @param MWTimestamp $relativeTo Base timestamp
2445 * @param User $user User preferences to use
2446 * @return string Human timestamp
2447 * @since 1.22
2448 */
2456 ) {
2457 // Timestamps are in different years: use full timestamp
2458 // Also do full timestamp for future dates
2459 /**
2460 * @todo FIXME: Add better handling of future timestamps.
2461 */
2465 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2469 // Timestamp within the past week: show the day of the week and time
2472 // Messages:
2473 // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2479 // Timestamp was yesterday: say 'yesterday' and the time.
2486 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2493 // From here on in, the timestamp was soon enough ago so that we can simply say
2494 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2496 // Less than 90 minutes, but more than an hour ago.
2499 // A few minutes ago.
2502 // Less than a minute, but more than 30 sec ago.
2505 // Less than 30 seconds ago.
2507 }
2510 }
2512 /**
2513 * @param string $key
2514 * @return array|null
2515 */
2518 }
2520 /**
2521 * @return array
2522 */
2525 }
2527 /**
2528 * @param string $in
2529 * @param string $out
2530 * @param string $string
2531 * @return string
2532 */
2534 # This is a wrapper for iconv in all languages except esperanto,
2535 # which does some nasty x-conversions beforehand
2537 # Even with //IGNORE iconv can whine about illegal characters in
2538 # *input* string. We just ignore those too.
2539 # REF: http://bugs.php.net/bug.php?id=37166
2540 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2545 }
2547 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2549 /**
2550 * @param array $matches
2551 * @return mixed|string
2552 */
2555 }
2557 /**
2558 * @param array $matches
2559 * @return string
2560 */
2563 }
2565 /**
2566 * @param array $matches
2567 * @return string
2568 */
2572 }
2574 /**
2575 * @param array $matches
2576 * @return string
2577 */
2581 }
2583 /**
2584 * @param array $matches
2585 * @return string
2586 */
2589 }
2591 /**
2592 * @param array $matches
2593 * @return string
2594 */
2598 }
2600 /**
2601 * Make a string's first character uppercase
2602 *
2603 * @param string $str
2604 *
2605 * @return string
2606 */
2614 // fall back to more complex logic in case of multibyte strings
2616 }
2617 }
2619 /**
2620 * Convert a string to uppercase
2621 *
2622 * @param string $str
2623 * @param bool $first
2624 *
2625 * @return string
2626 */
2634 }
2637 }
2644 $str
2645 );
2648 }
2649 }
2650 }
2652 /**
2653 * @param string $str
2654 * @return mixed|string
2655 */
2667 }
2668 }
2670 /**
2671 * @param string $str
2672 * @param bool $first
2673 * @return mixed|string
2674 */
2682 }
2685 }
2692 $str
2693 );
2696 }
2697 }
2698 }
2700 /**
2701 * @param string $str
2702 * @return bool
2703 */
2706 }
2708 /**
2709 * @param string $str
2710 * @return mixed|string
2711 */
2716 // regexp to find first letter in each word (i.e. after each space)
2717 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2719 // function to use to capitalize a single char
2724 $str
2725 );
2730 $str
2731 );
2732 }
2735 }
2736 }
2738 /**
2739 * capitalize words at word breaks
2740 *
2741 * @param string $str
2742 * @return mixed
2743 */
2748 // since \b doesn't work for UTF-8, we explicitely define word break chars
2751 // find first letter after word break
2759 $str
2760 );
2765 $str
2766 );
2767 }
2772 $str
2773 );
2774 }
2775 }
2777 /**
2778 * Return a case-folded representation of $s
2779 *
2780 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2781 * and $s2 are the same except for the case of their characters. It is not
2782 * necessary for the value returned to make sense when displayed.
2783 *
2784 * Do *not* perform any other normalisation in this function. If a caller
2785 * uses this function when it should be using a more general normalisation
2786 * function, then fix the caller.
2787 *
2788 * @param string $s
2789 *
2790 * @return string
2791 */
2794 }
2796 /**
2797 * @param string $s
2798 * @return string
2799 */
2803 }
2806 }
2809 }
2811 /**
2812 * @return array
2813 */
2816 }
2818 /**
2819 * Most writing systems use whitespace to break up words.
2820 * Some languages such as Chinese don't conventionally do this,
2821 * which requires special handling when breaking up words for
2822 * searching etc.
2823 *
2824 * @return bool
2825 */
2828 }
2830 /**
2831 * Some languages such as Chinese require word segmentation,
2832 * Specify such segmentation when overridden in derived class.
2833 *
2834 * @param string $string
2835 * @return string
2836 */
2839 }
2841 /**
2842 * Some languages have special punctuation need to be normalized.
2843 * Make such changes here.
2844 *
2845 * @param string $string
2846 * @return string
2847 */
2850 }
2852 /**
2853 * convert double-width roman characters to single-width.
2854 * range: ff00-ff5f ~= 0020-007f
2855 *
2856 * @param string $string
2857 *
2858 * @return string
2859 */
2869 }
2873 }
2875 /**
2876 * @param string $string
2877 * @param string $pattern
2878 * @return string
2879 */
2884 }
2886 /**
2887 * @param array $termsArray
2888 * @return array
2889 */
2891 # some languages, e.g. Chinese, need to do a conversion
2892 # in order for search results to be displayed correctly
2894 }
2896 /**
2897 * Get the first character of a string.
2898 *
2899 * @param string $s
2900 * @return string
2901 */
2908 $matches
2909 );
2914 }
2916 // Break down Hangul syllables to grab the first jamo
2948 }
2951 }
2952 }
2955 # Some languages may have an alternate char encoding option
2956 # (Esperanto X-coding, Japanese furigana conversion, etc)
2957 # If this language is used as the primary content language,
2958 # an override to the defaults can be set here on startup.
2959 }
2961 /**
2962 * @param string $s
2963 * @return string
2964 */
2966 # For some languages we'll want to explicitly specify
2967 # which characters make it into the edit box raw
2968 # or are converted in some way or another.
2974 }
2975 }
2977 /**
2978 * @param string $s
2979 * @return string
2980 */
2982 # Take the previous into account.
2988 }
2993 }
2994 }
2996 /**
2997 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2998 * also cleans up certain backwards-compatible sequences, converting them
2999 * to the modern Unicode equivalent.
3000 *
3001 * This is language-specific for performance reasons only.
3002 *
3003 * @param string $s
3004 *
3005 * @return string
3006 */
3013 }
3016 }
3018 /**
3019 * Transform a string using serialized data stored in the given file (which
3020 * must be in the serialized subdirectory of $IP). The file contains pairs
3021 * mapping source characters to destination characters.
3022 *
3023 * The data is cached in process memory. This will go faster if you have the
3024 * FastStringSearch extension.
3025 *
3026 * @param string $file
3027 * @param string $string
3028 *
3029 * @throws MWException
3030 * @return string
3031 */
3037 }
3039 }
3041 }
3043 /**
3044 * For right-to-left language support
3045 *
3046 * @return bool
3047 */
3050 }
3052 /**
3053 * Return the correct HTML 'dir' attribute value for this language.
3054 * @return string
3055 */
3058 }
3060 /**
3061 * Return 'left' or 'right' as appropriate alignment for line-start
3062 * for this language's text direction.
3063 *
3064 * Should be equivalent to CSS3 'start' text-align value....
3065 *
3066 * @return string
3067 */
3070 }
3072 /**
3073 * Return 'right' or 'left' as appropriate alignment for line-end
3074 * for this language's text direction.
3075 *
3076 * Should be equivalent to CSS3 'end' text-align value....
3077 *
3078 * @return string
3079 */
3082 }
3084 /**
3085 * A hidden direction mark (LRM or RLM), depending on the language direction.
3086 * Unlike getDirMark(), this function returns the character as an HTML entity.
3087 * This function should be used when the output is guaranteed to be HTML,
3088 * because it makes the output HTML source code more readable. When
3089 * the output is plain text or can be escaped, getDirMark() should be used.
3090 *
3091 * @param bool $opposite Get the direction mark opposite to your language
3092 * @return string
3093 * @since 1.20
3094 */
3098 }
3100 }
3102 /**
3103 * A hidden direction mark (LRM or RLM), depending on the language direction.
3104 * This function produces them as invisible Unicode characters and
3105 * the output may be hard to read and debug, so it should only be used
3106 * when the output is plain text or can be escaped. When the output is
3107 * HTML, use getDirMarkEntity() instead.
3108 *
3109 * @param bool $opposite Get the direction mark opposite to your language
3110 * @return string
3111 */
3117 }
3119 }
3121 /**
3122 * @return array
3123 */
3126 }
3128 /**
3129 * An arrow, depending on the language direction.
3130 *
3131 * @param string $direction The direction of the arrow: forwards (default),
3132 * backwards, left, right, up, down.
3133 * @return string
3134 */
3149 }
3150 }
3152 /**
3153 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
3154 *
3155 * @return bool
3156 */
3159 }
3161 /**
3162 * Get all magic words from cache.
3163 * @return array
3164 */
3167 }
3169 /**
3170 * Run the LanguageGetMagic hook once.
3171 */
3175 }
3180 }
3182 /**
3183 * Fill a MagicWord object with data from here
3184 *
3185 * @param MagicWord $mw
3186 */
3188 // Saves a function call
3191 }
3198 }
3205 }
3206 }
3208 /**
3209 * Add magic words to the extension array
3210 *
3211 * @param array $newWords
3212 */
3219 }
3220 }
3221 }
3223 /**
3224 * Get special page names, as an associative array
3225 * canonical name => array of valid names, including aliases
3226 * @return array
3227 */
3229 // Cache aliases because it may be slow to load them
3231 // Initialise array
3236 }
3239 }
3241 /**
3242 * Italic is unsuitable for some languages
3243 *
3244 * @param string $text The text to be emphasized.
3245 * @return string
3246 */
3249 }
3251 /**
3252 * Normally we output all numbers in plain en_US style, that is
3253 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3254 * point twohundredthirtyfive. However this is not suitable for all
3255 * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3256 * Icelandic just want to use commas instead of dots, and dots instead
3257 * of commas like "293.291,235".
3258 *
3259 * An example of this function being called:
3260 * <code>
3261 * wfMessage( 'message' )->numParams( $num )->text()
3262 * </code>
3263 *
3264 * See $separatorTransformTable on MessageIs.php for
3265 * the , => . and . => , implementation.
3266 *
3267 * @todo check if it's viable to use localeconv() for the decimal separator thing.
3268 * @param int|float $number The string to be formatted, should be an integer
3269 * or a floating point number.
3270 * @param bool $nocommafy Set to true for special numbers like dates
3271 * @return string
3272 */
3280 }
3281 }
3287 }
3288 }
3291 }
3293 /**
3294 * Front-end for non-commafied formatNum
3295 *
3296 * @param int|float $number The string to be formatted, should be an integer
3297 * or a floating point number.
3298 * @since 1.21
3299 * @return string
3300 */
3303 }
3305 /**
3306 * @param string $number
3307 * @return string
3308 */
3312 // eliminate empty array values such as ''. (bug 64347)
3315 }
3319 // eliminate empty array values such as ''. (bug 64347)
3322 }
3326 }
3328 /**
3329 * Adds commas to a given number
3330 * @since 1.19
3331 * @param mixed $number
3332 * @return string
3333 */
3338 }
3341 // default grouping is at thousands, use the same for ###,###,### pattern too.
3344 // Ref: http://cldr.unicode.org/translation/number-patterns
3347 // For negative numbers apply the algorithm like positive number and add sign.
3350 }
3358 // the string does not have any number part. Eg: .12345
3360 }
3368 }
3372 // use the last pattern for the rest of the number
3374 }
3377 }
3378 }
3380 }
3381 }
3383 /**
3384 * @return string
3385 */
3388 }
3390 /**
3391 * @return array
3392 */
3395 }
3397 /**
3398 * @return array
3399 */
3402 }
3404 /**
3405 * Take a list of strings and build a locale-friendly comma-separated
3406 * list, using the local comma-separator message.
3407 * The last two strings are chained with an "and".
3408 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3409 *
3410 * @param string[] $l
3411 * @return string
3412 */
3417 }
3423 }
3424 }
3431 }
3432 }
3434 }
3436 /**
3437 * Take a list of strings and build a locale-friendly comma-separated
3438 * list, using the local comma-separator message.
3439 * @param string[] $list Array of strings to put in a comma list
3440 * @return string
3441 */
3445 $list
3446 );
3447 }
3449 /**
3450 * Take a list of strings and build a locale-friendly semicolon-separated
3451 * list, using the local semicolon-separator message.
3452 * @param string[] $list Array of strings to put in a semicolon list
3453 * @return string
3454 */
3458 $list
3459 );
3460 }
3462 /**
3463 * Same as commaList, but separate it with the pipe instead.
3464 * @param string[] $list Array of strings to put in a pipe list
3465 * @return string
3466 */
3470 $list
3471 );
3472 }
3474 /**
3475 * Truncate a string to a specified length in bytes, appending an optional
3476 * string (e.g. for ellipses)
3477 *
3478 * The database offers limited byte lengths for some columns in the database;
3479 * multi-byte character sets mean we need to ensure that only whole characters
3480 * are included, otherwise broken characters can be passed to the user
3481 *
3482 * If $length is negative, the string will be truncated from the beginning
3483 *
3484 * @param string $string String to truncate
3485 * @param int $length Maximum length (including ellipses)
3486 * @param string $ellipsis String to append to the truncated text
3487 * @param bool $adjustLength Subtract length of ellipsis from $length.
3488 * $adjustLength was introduced in 1.18, before that behaved as if false.
3489 * @return string
3490 */
3492 # Use the localized ellipsis character
3495 }
3496 # Check if there is no need to truncate
3501 }
3503 # If ellipsis length is >= $length then we can't apply $adjustLength
3506 # Otherwise, truncate and add ellipsis...
3521 }
3522 }
3523 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3524 # This check is *not* redundant if $adjustLength, due to the single case where
3525 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3530 }
3531 }
3533 /**
3534 * Remove bytes that represent an incomplete Unicode character
3535 * at the end of string (e.g. bytes of the char are missing)
3536 *
3537 * @param string $string
3538 * @return string
3539 */
3545 # We got the first byte only of a multibyte char; remove it.
3550 ) {
3551 # We chopped in the middle of a character; remove it
3553 }
3554 }
3556 }
3558 /**
3559 * Remove bytes that represent an incomplete Unicode character
3560 * at the start of string (e.g. bytes of the char are missing)
3561 *
3562 * @param string $string
3563 * @return string
3564 */
3569 # We chopped in the middle of a character; remove the whole thing
3571 }
3572 }
3574 }
3576 /**
3577 * Truncate a string of valid HTML to a specified length in bytes,
3578 * appending an optional string (e.g. for ellipses), and return valid HTML
3579 *
3580 * This is only intended for styled/linked text, such as HTML with
3581 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3582 * Also, this will not detect things like "display:none" CSS.
3583 *
3584 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3585 *
3586 * @param string $text HTML string to truncate
3587 * @param int $length (zero/positive) Maximum length (including ellipses)
3588 * @param string $ellipsis String to append to the truncated text
3589 * @return string
3590 */
3592 # Use the localized ellipsis character
3595 }
3596 # Check if there is clearly no need to truncate
3601 }
3615 # Consider truncation once the display length has reached the maximim.
3616 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3617 # Check that we're not in the middle of a bracket/entity...
3621 # Save where we are; we will truncate here unless there turn out to
3622 # be so few remaining characters that truncation is not necessary.
3625 }
3627 # String in fact does need truncation, the truncation point was OK.
3632 }
3633 }
3636 }
3638 # Read the next char...
3656 }
3662 // Name found (e.g. "<a href=..."), add on tag attributes...
3664 }
3670 }
3673 // Save state without $ch. We want to *hit* the first
3674 // display char (to get tags) but not *use* it if truncating.
3676 }
3681 // Add the next $max display text chars after this in one swoop...
3686 }
3687 }
3688 }
3689 }
3690 // Close the last tag if left unclosed by bad HTML
3694 }
3696 }
3698 /**
3699 * truncateHtml() helper function
3700 * like strcspn() but adds the skipped chars to $ret
3701 *
3702 * @param string $ret
3703 * @param string $text
3704 * @param string $search
3705 * @param int $start
3706 * @param null|int $len
3707 * @return int
3708 */
3714 }
3719 }
3721 }
3723 /**
3724 * truncateHtml() helper function
3725 * (a) push or pop $tag from $openTags as needed
3726 * (b) clear $tag value
3727 * @param string &$tag Current HTML tag name we are looking at
3728 * @param int $tagType (0-open tag, 1-close tag)
3729 * @param string $lastCh Character before the '>' that ended this tag
3730 * @param array &$openTags Open tag stack (not accounting for $tag)
3731 */
3740 }
3741 }
3743 }
3744 }
3746 /**
3747 * Grammatical transformations, needed for inflected languages
3748 * Invoked by putting {{grammar:case|word}} in a message
3749 *
3750 * @param string $word
3751 * @param string $case
3752 * @return string
3753 */
3758 }
3761 }
3762 /**
3763 * Get the grammar forms for the content language
3764 * @return array Array of grammar forms
3765 * @since 1.20
3766 */
3771 ) {
3773 }
3776 }
3777 /**
3778 * Provides an alternative text depending on specified gender.
3779 * Usage {{gender:username|masculine|feminine|unknown}}.
3780 * username is optional, in which case the gender of current user is used,
3781 * but only in (some) interface messages; otherwise default gender is used.
3782 *
3783 * If no forms are given, an empty string is returned. If only one form is
3784 * given, it will be returned unconditionally. These details are implied by
3785 * the caller and cannot be overridden in subclasses.
3786 *
3787 * If three forms are given, the default is to use the third (unknown) form.
3788 * If fewer than three forms are given, the default is to use the first (masculine) form.
3789 * These details can be overridden in subclasses.
3790 *
3791 * @param string $gender
3792 * @param array $forms
3793 *
3794 * @return string
3795 */
3799 }
3803 }
3806 }
3808 }
3810 /**
3811 * Plural form transformations, needed for some languages.
3812 * For example, there are 3 form of plural in Russian and Polish,
3813 * depending on "count mod 10". See [[w:Plural]]
3814 * For English it is pretty simple.
3815 *
3816 * Invoked by putting {{plural:count|wordform1|wordform2}}
3817 * or {{plural:count|wordform1|wordform2|wordform3}}
3818 *
3819 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3820 *
3821 * @param int $count Non-localized number
3822 * @param array $forms Different plural forms
3823 * @return string Correct form of plural for $count in this language
3824 */
3826 // Handle explicit n=pluralform cases
3830 }
3833 }
3838 }
3840 /**
3841 * Handles explicit plural forms for Language::convertPlural()
3842 *
3843 * In {{PLURAL:$1|0=nothing|one|many}}, 0=nothing will be returned if $1 equals zero.
3844 * If an explicitly defined plural form matches the $count, then
3845 * string value returned, otherwise array returned for further consideration
3846 * by CLDR rules or overridden convertPlural().
3847 *
3848 * @since 1.23
3849 *
3850 * @param int $count Non-localized number
3851 * @param array $forms Different plural forms
3852 *
3853 * @return array|string
3854 */
3861 }
3863 }
3864 }
3866 }
3868 /**
3869 * Checks that convertPlural was given an array and pads it to requested
3870 * amount of forms by copying the last one.
3871 *
3872 * @param array $forms Array of forms given to convertPlural
3873 * @param int $count How many forms should there be at least
3874 * @return array Padded array of forms or an exception if not an array
3875 */
3879 }
3881 }
3883 /**
3884 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3885 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3886 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3887 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3888 * match up with it.
3889 *
3890 * @param string $str The validated block duration in English
3891 * @return string Somehow translated block duration
3892 * @see LanguageFi.php for example implementation
3893 */
3899 }
3900 }
3902 // Since usually only infinite or indefinite is only on list, so try
3903 // equivalents if still here.
3910 }
3911 }
3912 }
3914 // If all else fails, return a standard duration or timestamp description.
3919 // $time is relative to 0 so it's a duration length.
3923 // wfTimestamp() handles 0 as current time instead of epoch.
3927 }
3928 }
3929 }
3931 /**
3932 * languages like Chinese need to be segmented in order for the diff
3933 * to be of any use
3934 *
3935 * @param string $text
3936 * @return string
3937 */
3940 }
3942 /**
3943 * and unsegment to show the result
3944 *
3945 * @param string $text
3946 * @return string
3947 */
3950 }
3952 /**
3953 * Return the LanguageConverter used in the Language
3954 *
3955 * @since 1.19
3956 * @return LanguageConverter
3957 */
3960 }
3962 /**
3963 * convert text to all supported variants
3964 *
3965 * @param string $text
3966 * @return array
3967 */
3970 }
3972 /**
3973 * convert text to different variants of a language.
3974 *
3975 * @param string $text
3976 * @return string
3977 */
3980 }
3982 /**
3983 * Convert a Title object to a string in the preferred variant
3984 *
3985 * @param Title $title
3986 * @return string
3987 */
3990 }
3992 /**
3993 * Convert a namespace index to a string in the preferred variant
3994 *
3995 * @param int $ns
3996 * @return string
3997 */
4000 }
4002 /**
4003 * Check if this is a language with variants
4004 *
4005 * @return bool
4006 */
4009 }
4011 /**
4012 * Check if the language has the specific variant
4013 *
4014 * @since 1.19
4015 * @param string $variant
4016 * @return bool
4017 */
4020 }
4022 /**
4023 * Put custom tags (e.g. -{ }-) around math to prevent conversion
4024 *
4025 * @param string $text
4026 * @return string
4027 * @deprecated since 1.22 is no longer used
4028 */
4031 }
4033 /**
4034 * Perform output conversion on a string, and encode for safe HTML output.
4035 * @param string $text Text to be converted
4036 * @param bool $isTitle Whether this conversion is for the article title
4037 * @return string
4038 * @todo this should get integrated somewhere sane
4039 */
4042 }
4044 /**
4045 * @param string $key
4046 * @return string
4047 */
4050 }
4052 /**
4053 * Get the list of variants supported by this language
4054 * see sample implementation in LanguageZh.php
4055 *
4056 * @return array An array of language codes
4057 */
4060 }
4062 /**
4063 * @return string
4064 */
4067 }
4069 /**
4070 * @return string
4071 */
4074 }
4076 /**
4077 * @return string
4078 */
4081 }
4083 /**
4084 * If a language supports multiple variants, it is
4085 * possible that non-existing link in one variant
4086 * actually exists in another variant. this function
4087 * tries to find it. See e.g. LanguageZh.php
4088 * The input parameters may be modified upon return
4089 *
4090 * @param string &$link The name of the link
4091 * @param Title &$nt The title object of the link
4092 * @param bool $ignoreOtherCond To disable other conditions when
4093 * we need to transclude a template or update a category's link
4094 */
4097 }
4099 /**
4100 * returns language specific options used by User::getPageRenderHash()
4101 * for example, the preferred language variant
4102 *
4103 * @return string
4104 */
4107 }
4109 /**
4110 * For languages that support multiple variants, the title of an
4111 * article may be displayed differently in different variants. this
4112 * function returns the apporiate title defined in the body of the article.
4113 *
4114 * @return string
4115 */
4118 }
4120 /**
4121 * Prepare external link text for conversion. When the text is
4122 * a URL, it shouldn't be converted, and it'll be wrapped in
4123 * the "raw" tag (-{R| }-) to prevent conversion.
4124 *
4125 * This function is called "markNoConversion" for historical
4126 * reasons.
4127 *
4128 * @param string $text Text to be used for external link
4129 * @param bool $noParse Wrap it without confirming it's a real URL first
4130 * @return string The tagged text
4131 */
4133 // Excluding protocal-relative URLs may avoid many false positives.
4138 }
4139 }
4141 /**
4142 * A regular expression to match legal word-trailing characters
4143 * which should be merged onto a link of the form [[foo]]bar.
4144 *
4145 * @return string
4146 */
4149 }
4151 /**
4152 * A regular expression character set to match legal word-prefixing
4153 * characters which should be merged onto a link of the form foo[[bar]].
4154 *
4155 * @return string
4156 */
4159 }
4161 /**
4162 * @deprecated since 1.24, will be removed in 1.25
4163 * @return Language
4164 */
4168 }
4170 /**
4171 * Get the "parent" language which has a converter to convert a "compatible" language
4172 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
4173 *
4174 * @return Language|null
4175 * @since 1.22
4176 */
4180 }
4187 }
4192 }
4196 }
4198 /**
4199 * Get the RFC 3066 code for this language object
4200 *
4201 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4202 * htmlspecialchars() or similar
4203 *
4204 * @return string
4205 */
4208 }
4210 /**
4211 * Get the code in Bcp47 format which we can use
4212 * inside of html lang="" tags.
4213 *
4214 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4215 * htmlspecialchars() or similar.
4216 *
4217 * @since 1.19
4218 * @return string
4219 */
4223 }
4225 }
4227 /**
4228 * @param string $code
4229 */
4232 // Ensure we don't leave incorrect cached data lying around
4235 }
4237 /**
4238 * Get the name of a file for a certain language code
4239 * @param string $prefix Prepend this to the filename
4240 * @param string $code Language code
4241 * @param string $suffix Append this to the filename
4242 * @throws MWException
4243 * @return string $prefix . $mangledCode . $suffix
4244 */
4248 }
4251 }
4253 /**
4254 * Get the language code from a file name. Inverse of getFileName()
4255 * @param string $filename $prefix . $languageCode . $suffix
4256 * @param string $prefix Prefix before the language code
4257 * @param string $suffix Suffix after the language code
4258 * @return string Language code, or false if $prefix or $suffix isn't found
4259 */
4260 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4266 }
4268 }
4270 /**
4271 * @param string $code
4272 * @return string
4273 */
4279 }
4281 /**
4282 * @param string $code
4283 * @return string
4284 * @since 1.23
4285 */
4291 }
4294 }
4296 /**
4297 * @param string $code
4298 * @return string
4299 */
4303 }
4305 /**
4306 * Get the first fallback for a given language.
4307 *
4308 * @param string $code
4309 *
4310 * @return bool|string
4311 */
4319 }
4320 }
4322 /**
4323 * Get the ordered list of fallback languages.
4324 *
4325 * @since 1.19
4326 * @param string $code Language code
4327 * @return array
4328 */
4337 }
4339 }
4340 }
4342 /**
4343 * Get the ordered list of fallback languages, ending with the fallback
4344 * language chain for the site language.
4345 *
4346 * @since 1.22
4347 * @param string $code Language code
4348 * @return array Array( fallbacks, site fallbacks )
4349 */
4353 // Usually, we will only store a tiny number of fallback chains, so we
4354 // keep them in static memory.
4360 // Append the site's fallback chain, including the site language itself
4364 // Eliminate any languages already included in the chain
4368 }
4370 }
4372 /**
4373 * Get all messages for a given language
4374 * WARNING: this may take a long time. If you just need all message *keys*
4375 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4376 *
4377 * @param string $code
4378 *
4379 * @return array
4380 */
4383 }
4385 /**
4386 * Get a message for a given language
4387 *
4388 * @param string $key
4389 * @param string $code
4390 *
4391 * @return string
4392 */
4395 }
4397 /**
4398 * Get all message keys for a given language. This is a faster alternative to
4399 * array_keys( Language::getMessagesFor( $code ) )
4400 *
4401 * @since 1.19
4402 * @param string $code Language code
4403 * @return array Array of message keys (strings)
4404 */
4407 }
4409 /**
4410 * @param string $talk
4411 * @return mixed
4412 */
4416 }
4421 # Allow grammar transformations
4422 # Allowing full message-style parsing would make simple requests
4423 # such as action=raw much more expensive than they need to be.
4424 # This will hopefully cover most cases.
4428 }
4430 /**
4431 * @param string $m
4432 * @return string
4433 */
4436 }
4438 /**
4439 * @throws MWException
4440 * @return array
4441 */
4446 }
4453 }
4458 }
4460 /**
4461 * Decode an expiry (block, protection, etc) which has come from the DB
4462 *
4463 * @todo FIXME: why are we returnings DBMS-dependent strings???
4464 *
4465 * @param string $expiry Database expiry String
4466 * @param bool|int $format True to process using language functions, or TS_ constant
4467 * to return the expiry in a given timestamp
4468 * @return string
4469 * @since 1.18
4470 */
4475 }
4485 }
4486 }
4488 /**
4489 * @todo Document
4490 * @param int|float $seconds
4491 * @param array $format Optional
4492 * If $format['avoid'] === 'avoidseconds': don't mention seconds if $seconds >= 1 hour.
4493 * If $format['avoid'] === 'avoidminutes': don't mention seconds/minutes if $seconds > 48 hours.
4494 * If $format['noabbrevs'] is true: use 'seconds' and friends instead of 'seconds-abbrev'
4495 * and friends.
4496 * For backwards compatibility, $format may also be one of the strings 'avoidseconds'
4497 * or 'avoidminutes'.
4498 * @return string
4499 */
4503 }
4506 }
4509 }
4531 }
4542 }
4546 }
4552 }
4560 }
4570 }
4574 }
4584 }
4585 }
4587 }
4589 /**
4590 * Format a bitrate for output, using an appropriate
4591 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to
4592 * the magnitude in question.
4593 *
4594 * This use base 1000. For base 1024 use formatSize(), for another base
4595 * see formatComputingNumbers().
4596 *
4597 * @param int $bps
4598 * @return string
4599 */
4602 }
4604 /**
4605 * @param int $size Size of the unit
4606 * @param int $boundary Size boundary (1000, or 1024 in most cases)
4607 * @param string $messageKey Message key to be uesd
4608 * @return string
4609 */
4614 );
4615 }
4623 }
4625 // For small sizes no decimal places necessary
4628 // For MB and bigger two decimal places are smarter
4630 }
4636 }
4638 /**
4639 * Format a size in bytes for output, using an appropriate
4640 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4641 *
4642 * This method use base 1024. For base 1000 use formatBitrate(), for
4643 * another base see formatComputingNumbers()
4644 *
4645 * @param int $size Size to format
4646 * @return string Plain text (not HTML)
4647 */
4650 }
4652 /**
4653 * Make a list item, used by various special pages
4654 *
4655 * @param string $page Page link
4656 * @param string $details HTML safe text between brackets
4657 * @param bool $oppositedm Add the direction mark opposite to your
4658 * language, to display text properly
4659 * @return HTML escaped string
4660 */
4664 }
4667 return
4672 }
4674 /**
4675 * Generate (prev x| next x) (20|50|100...) type links for paging
4676 *
4677 * @param Title $title Title object to link
4678 * @param int $offset
4679 * @param int $limit
4680 * @param array $query Optional URL query parameter string
4681 * @param bool $atend Optional param for specified if this is the last page
4682 * @return string
4683 */
4686 ) {
4687 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4689 # Make 'previous' link
4690 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4696 }
4698 # Make 'next' link
4699 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4705 }
4707 # Make links to set number of items per page
4712 }
4716 }
4718 /**
4719 * Helper function for viewPrevNext() that generates links
4720 *
4721 * @param Title $title Title object to link
4722 * @param int $offset
4723 * @param int $limit
4724 * @param array $query Extra query parameters
4725 * @param string $link Text to use for the link; will be escaped
4726 * @param string $tooltipMsg Name of the message to use as tooltip
4727 * @param string $class Value of the "class" attribute of the link
4728 * @return string HTML fragment
4729 */
4732 ) {
4739 }
4741 /**
4742 * Get the conversion rule title, if any.
4743 *
4744 * @return string
4745 */
4748 }
4750 /**
4751 * Get the compiled plural rules for the language
4752 * @since 1.20
4753 * @return array Associative array with plural form, and plural rule as key-value pairs
4754 */
4760 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4763 }
4764 }
4765 }
4767 }
4769 /**
4770 * Get the plural rules for the language
4771 * @since 1.20
4772 * @return array Associative array with plural form number and plural rule as key-value pairs
4773 */
4782 }
4783 }
4784 }
4786 }
4788 /**
4789 * Get the plural rule types for the language
4790 * @since 1.22
4791 * @return array Associative array with plural form number and plural rule type as key-value pairs
4792 */
4798 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4801 }
4802 }
4803 }
4805 }
4807 /**
4808 * Find the index number of the plural rule appropriate for the given number
4809 * @param int $number
4810 * @return int The index number of the plural rule
4811 */
4816 }
4818 /**
4819 * Find the plural rule type appropriate for the given number
4820 * For example, if the language is set to Arabic, getPluralType(5) should
4821 * return 'few'.
4822 * @since 1.22
4823 * @param int $number
4824 * @return string The name of the plural rule type, e.g. one, two, few, many
4825 */
4833 }
4834 }
4835 }