| blob | fbd4f6dddad915bb5d0b2b601420b77d3360a9fa |
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 */
861 }
867 }
869 }
871 /**
872 * Uncached helper for fetchLanguageNames
873 * @param null|string $inLanguage Code of language in which to return the names
874 * Use null for autonyms (native names)
875 * @param string $include One of:
876 * 'all' all available languages
877 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
878 * 'mwfile' only if the language is in 'mw' *and* has a message file
879 * @return array Language code => language name
880 */
888 }
890 // If passed an invalid language code to use, fallback to en
893 }
898 # TODO: also include when $inLanguage is null, when this code is more efficient
900 }
904 # - Prefer own MediaWiki native name when not using the hook
905 # - For other names just add if not added through the hook
908 }
909 }
914 }
920 }
924 # We do this using a foreach over the codes instead of a directory
925 # loop so that messages files in extensions will work correctly.
929 ) {
931 }
932 }
936 }
939 # 'mw' option; default if it's not one of the other two options (all/mwfile)
941 }
943 /**
944 * @param string $code The code of the language for which to get the name
945 * @param null|string $inLanguage Code of language in which to return the name (null for autonyms)
946 * @param string $include 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
947 * @return string Language name or empty
948 * @since 1.20
949 */
954 }
956 /**
957 * Get a message from the MediaWiki namespace.
958 *
959 * @param string $msg Message name
960 * @return string
961 */
964 }
966 /**
967 * Get message object in this language. Only for use inside this class.
968 *
969 * @param string $msg Message name
970 * @return Message
971 */
974 }
976 /**
977 * Get the native language name of $code.
978 * Only if defined in MediaWiki, no other data like CLDR.
979 * @param string $code
980 * @return string
981 * @deprecated since 1.20, use fetchLanguageName()
982 */
985 }
987 /**
988 * @param string $key
989 * @return string
990 */
993 }
995 /**
996 * @return array
997 */
1002 }
1004 }
1006 /**
1007 * @param string $key
1008 * @return string
1009 */
1012 }
1014 /**
1015 * @param string $key
1016 * @return string
1017 */
1020 }
1022 /**
1023 * @return array
1024 */
1029 }
1031 }
1033 /**
1034 * @param string $key
1035 * @return string
1036 */
1039 }
1041 /**
1042 * @param string $key
1043 * @return string
1044 */
1047 }
1049 /**
1050 * @param string $key
1051 * @return string
1052 */
1055 }
1057 /**
1058 * @param string $key
1059 * @return string
1060 */
1063 }
1065 /**
1066 * @param string $key
1067 * @return string
1068 */
1071 }
1073 /**
1074 * @param string $key
1075 * @return string
1076 */
1079 }
1081 /**
1082 * Pass through result from $dateTimeObj->format()
1083 * @param DateTime|bool|null &$dateTimeObj
1084 * @param string $ts
1085 * @param DateTimeZone|bool|null $zone
1086 * @param string $code
1087 * @return string
1088 */
1093 );
1094 }
1096 }
1098 /**
1099 * This is a workalike of PHP's date() function, but with better
1100 * internationalisation, a reduced set of format characters, and a better
1101 * escaping format.
1102 *
1103 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1104 * the PHP manual for definitions. There are a number of extensions, which
1105 * start with "x":
1106 *
1107 * xn Do not translate digits of the next numeric format character
1108 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1109 * xr Use roman numerals for the next numeric format character
1110 * xh Use hebrew numerals for the next numeric format character
1111 * xx Literal x
1112 * xg Genitive month name
1113 *
1114 * xij j (day number) in Iranian calendar
1115 * xiF F (month name) in Iranian calendar
1116 * xin n (month number) in Iranian calendar
1117 * xiy y (two digit year) in Iranian calendar
1118 * xiY Y (full year) in Iranian calendar
1119 *
1120 * xjj j (day number) in Hebrew calendar
1121 * xjF F (month name) in Hebrew calendar
1122 * xjt t (days in month) in Hebrew calendar
1123 * xjx xg (genitive month name) in Hebrew calendar
1124 * xjn n (month number) in Hebrew calendar
1125 * xjY Y (full year) in Hebrew calendar
1126 *
1127 * xmj j (day number) in Hijri calendar
1128 * xmF F (month name) in Hijri calendar
1129 * xmn n (month number) in Hijri calendar
1130 * xmY Y (full year) in Hijri calendar
1131 *
1132 * xkY Y (full year) in Thai solar calendar. Months and days are
1133 * identical to the Gregorian calendar
1134 * xoY Y (full year) in Minguo calendar or Juche year.
1135 * Months and days are identical to the
1136 * Gregorian calendar
1137 * xtY Y (full year) in Japanese nengo. Months and days are
1138 * identical to the Gregorian calendar
1139 *
1140 * Characters enclosed in double quotes will be considered literal (with
1141 * the quotes themselves removed). Unmatched quotes will be considered
1142 * literal quotes. Example:
1143 *
1144 * "The month is" F => The month is January
1145 * i's" => 20'11"
1146 *
1147 * Backslash escaping is also supported.
1148 *
1149 * Input timestamp is assumed to be pre-normalized to the desired local
1150 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1151 * $ts is UTC if $zone is not given.
1152 *
1153 * @param string $format
1154 * @param string $ts 14-character timestamp
1155 * YYYYMMDDHHMMSS
1156 * 01234567890123
1157 * @param DateTimeZone $zone Timezone of $ts
1158 * @param[out] int $ttl The amount of time (in seconds) the output may be cached for.
1159 * Only makes sense if $ts is the current time.
1160 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1161 *
1162 * @throws MWException
1163 * @return string
1164 */
1200 }
1204 }
1212 }
1222 }
1248 }
1257 $s .= $this->getWeekdayAbbreviation( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1 );
1267 }
1274 }
1281 }
1286 $s .= $this->getWeekdayName( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1 );
1296 }
1303 }
1310 }
1329 }
1336 }
1343 }
1350 }
1361 }
1368 }
1375 }
1382 }
1389 }
1396 }
1407 }
1447 // fall through
1478 // fall through
1484 # Backslash escaping
1489 }
1492 # Quoted literal
1496 # No terminating quote, assume literal "
1501 }
1503 # Quote at end of string, assume literal "
1505 }
1509 }
1522 }
1523 }
1524 }
1533 $ttl = 43200 - ( substr( $ts, 8, 2 ) % 12 ) * 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1534 } elseif ( $usedDay || $usedHebrewMonth || $usedIranianMonth || $usedHijriMonth || $usedHebrewYear || $usedIranianYear || $usedHijriYear || $usedTennoYear ) {
1535 // @todo Someone who understands the non-Gregorian calendars should write proper logic for them
1536 // so that they don't need purged every day.
1540 $timeRemainingInDay = 86400 - substr( $ts, 8, 2 ) * 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1542 $possibleTtls[] = ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 + $timeRemainingInDay;
1544 // December 28th falls on the last ISO week of the year, every year.
1545 // The last ISO week of a year can be 52 or 53.
1546 $lastWeekOfISOYear = DateTime::createFromFormat( 'Ymd', substr( $ts, 0, 4 ) . '1228', $zone ?: new DateTimeZone( 'UTC' ) )->format( 'W' );
1549 $timeRemainingInWeek = ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 + $timeRemainingInDay;
1551 }
1554 $possibleTtls[] = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 't' ) - substr( $ts, 6, 2 ) ) * 86400 + $timeRemainingInDay;
1556 $possibleTtls[] = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1560 $timeRemainingInYear = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1564 // this isn't a leap year. see when the next one starts
1570 }
1572 // this is a leap year, so the next year isn't
1574 }
1575 }
1579 }
1580 }
1583 }
1588 /**
1589 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1590 * Gregorian dates to Iranian dates. Originally written in C, it
1591 * is released under the terms of GNU Lesser General Public
1592 * License. Conversion to PHP was performed by Niklas Laxström.
1593 *
1594 * Link: http://www.farsiweb.info/jalali/jalali.c
1595 *
1596 * @param string $ts
1597 *
1598 * @return string
1599 */
1605 # Days passed from the beginning (including leap years)
1611 // Add days of the past months of this year
1614 }
1616 // Leap years
1619 }
1621 // Days passed in current month
1635 }
1639 }
1645 }
1647 /**
1648 * Converting Gregorian dates to Hijri dates.
1649 *
1650 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1651 *
1652 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1653 *
1654 * @param string $ts
1655 *
1656 * @return string
1657 */
1671 ) {
1679 }
1693 }
1695 /**
1696 * Converting Gregorian dates to Hebrew dates.
1697 *
1698 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1699 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1700 * to translate the relevant functions into PHP and release them under
1701 * GNU GPL.
1702 *
1703 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1704 * and Adar II is 14. In a non-leap year, Adar is 6.
1705 *
1706 * @param string $ts
1707 *
1708 * @return string
1709 */
1711 # Parse date
1716 # Calculate Hebrew year
1719 # Month number when September = 1, August = 12
1722 # Next year
1726 }
1728 # Calculate day of year from 1 September
1732 # February
1734 # Check if the year is leap
1737 }
1742 }
1743 }
1745 # Calculate the start of the Hebrew year
1748 # Calculate next year's start
1750 # Day is before the start of the year - it is the previous year
1751 # Next year's start
1753 # Previous year
1756 # Add days since previous year's 1 September
1759 # Leap year
1761 }
1762 # Start of the new (previous) year
1765 # Next year's start
1767 }
1769 # Calculate Hebrew day of year
1772 # Difference between year's days
1774 # Add 12 (or 13 for leap years) days to ignore the difference between
1775 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1776 # difference is only about the year type
1781 }
1783 # Check the year pattern, and is leap year
1784 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1785 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1786 # and non-leap years
1788 # Check if leap year
1791 # Calculate day in the month from number of day in the Hebrew year
1792 # Don't check Adar - if the day is not in Adar, we will stop before;
1793 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1798 # Calculate days in this month
1800 # Adar in a leap year
1802 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1805 # Day in Adar I
1808 # Subtract the days of Adar I
1810 # Try Adar II
1813 # Day in Adar II
1815 }
1816 }
1817 }
1819 # Cheshvan in a complete year (otherwise as the rule below)
1822 # Kislev in an incomplete year (otherwise as the rule below)
1825 # Odd months have 30 days, even have 29
1827 }
1829 # In the current month
1832 # Subtract the days of the current month
1834 # Try in the next month
1836 }
1837 }
1840 }
1842 /**
1843 * This calculates the Hebrew year start, as days since 1 September.
1844 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1845 * Used for Hebrew date.
1846 *
1847 * @param int $year
1848 *
1849 * @return string
1850 */
1857 }
1861 }
1871 }
1875 }
1877 /**
1878 * Algorithm to convert Gregorian dates to Thai solar dates,
1879 * Minguo dates or Minguo dates.
1880 *
1881 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1882 * http://en.wikipedia.org/wiki/Minguo_calendar
1883 * http://en.wikipedia.org/wiki/Japanese_era_name
1884 *
1885 * @param string $ts 14-character timestamp
1886 * @param string $cName Calender name
1887 * @return array Converted year, month, day
1888 */
1895 # Thai solar dates
1896 # Add 543 years to the Gregorian calendar
1897 # Months and days are identical
1900 # Minguo dates
1901 # Deduct 1911 years from the Gregorian calendar
1902 # Months and days are identical
1905 # Nengō dates up to Meiji period
1906 # Deduct years from the Gregorian calendar
1907 # depending on the nengo periods
1908 # Months and days are identical
1912 ) {
1913 # Meiji period
1918 }
1926 ) {
1927 # Taishō period
1932 }
1938 ) {
1939 # Shōwa period
1944 }
1947 # Heisei period
1952 }
1954 }
1957 }
1960 }
1962 /**
1963 * Roman number formatting up to 10000
1964 *
1965 * @param int $num
1966 *
1967 * @return string
1968 */
1976 );
1981 }
1987 }
1989 }
1991 }
1993 /**
1994 * Hebrew Gematria number formatting up to 9999
1995 *
1996 * @param int $num
1997 *
1998 * @return string
1999 */
2006 );
2011 }
2023 }
2024 }
2025 }
2027 }
2033 }
2052 }
2054 }
2056 /**
2057 * Used by date() and time() to adjust the time output.
2058 *
2059 * @param string $ts The time in date('YmdHis') format
2060 * @param mixed $tz Adjust the time by this amount (default false, mean we
2061 * get user timecorrection setting)
2062 * @return int
2063 */
2069 }
2082 }
2083 # Unrecognized timezone, default to 'Offset' with the stored offset.
2085 }
2088 # Global offset in minutes.
2100 }
2103 }
2104 }
2106 # No difference ? Return time unchanged
2109 }
2112 # Generate an adjusted date; take advantage of the fact that mktime
2113 # will normalize out-of-range values so we don't have to split $minDiff
2114 # into hours and minutes.
2127 }
2129 /**
2130 * This is meant to be used by time(), date(), and timeanddate() to get
2131 * the date preference they're supposed to use, it should be used in
2132 * all children.
2133 *
2134 *<code>
2135 * function timeanddate([...], $format = true) {
2136 * $datePreference = $this->dateFormat($format);
2137 * [...]
2138 * }
2139 *</code>
2140 *
2141 * @param int|string|bool $usePrefs If true, the user's preference is used
2142 * if false, the site/language default is used
2143 * if int/string, assumed to be a format.
2144 * @return string
2145 */
2154 }
2157 }
2159 // return int
2162 }
2165 }
2167 /**
2168 * Get a format string for a given type and preference
2169 * @param string $type May be date, time or both
2170 * @param string $pref The format name as it appears in Messages*.php
2171 *
2172 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2173 *
2174 * @return string
2175 */
2186 }
2191 }
2192 }
2194 }
2196 }
2198 /**
2199 * @param string $ts The time format which needs to be turned into a
2200 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2201 * @param bool $adj Whether to adjust the time output according to the
2202 * user configured offset ($timecorrection)
2203 * @param mixed $format True to use user's date format preference
2204 * @param string|bool $timecorrection The time offset as returned by
2205 * validateTimeZone() in Special:Preferences
2206 * @return string
2207 */
2212 }
2215 }
2217 /**
2218 * @param string $ts The time format which needs to be turned into a
2219 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2220 * @param bool $adj Whether to adjust the time output according to the
2221 * user configured offset ($timecorrection)
2222 * @param mixed $format True to use user's date format preference
2223 * @param string|bool $timecorrection The time offset as returned by
2224 * validateTimeZone() in Special:Preferences
2225 * @return string
2226 */
2231 }
2234 }
2236 /**
2237 * @param string $ts The time format which needs to be turned into a
2238 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2239 * @param bool $adj Whether to adjust the time output according to the
2240 * user configured offset ($timecorrection)
2241 * @param mixed $format What format to return, if it's false output the
2242 * default one (default true)
2243 * @param string|bool $timecorrection The time offset as returned by
2244 * validateTimeZone() in Special:Preferences
2245 * @return string
2246 */
2251 }
2254 }
2256 /**
2257 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2258 *
2259 * @since 1.20
2260 *
2261 * @param int $seconds The amount of seconds.
2262 * @param array $chosenIntervals The intervals to enable.
2263 *
2264 * @return string
2265 */
2272 // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2273 // duration-years, duration-decades, duration-centuries, duration-millennia
2276 }
2279 }
2281 /**
2282 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2283 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2284 *
2285 * @since 1.20
2286 *
2287 * @param int $seconds The amount of seconds.
2288 * @param array $chosenIntervals The intervals to enable.
2289 *
2290 * @return array
2291 */
2302 'seconds'
2303 );
2304 }
2318 }
2319 }
2322 }
2324 /**
2325 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2326 *
2327 * @param string $type Can be 'date', 'time' or 'both'
2328 * @param string $ts The time format which needs to be turned into a
2329 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2330 * @param User $user User object used to get preferences for timezone and format
2331 * @param array $options Array, can contain the following keys:
2332 * - 'timecorrection': time correction, can have the following values:
2333 * - true: use user's preference
2334 * - false: don't use time correction
2335 * - int: value of time correction in minutes
2336 * - 'format': format to use, can have the following values:
2337 * - true: use user's preference
2338 * - false: use default preference
2339 * - string: format to use
2340 * @since 1.19
2341 * @return string
2342 */
2351 }
2353 }
2358 }
2361 }
2363 /**
2364 * Get the formatted date for the given timestamp and formatted for
2365 * the given user.
2366 *
2367 * @param mixed $ts Mixed: the time format which needs to be turned into a
2368 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2369 * @param User $user User object used to get preferences for timezone and format
2370 * @param array $options Array, can contain the following keys:
2371 * - 'timecorrection': time correction, can have the following values:
2372 * - true: use user's preference
2373 * - false: don't use time correction
2374 * - int: value of time correction in minutes
2375 * - 'format': format to use, can have the following values:
2376 * - true: use user's preference
2377 * - false: use default preference
2378 * - string: format to use
2379 * @since 1.19
2380 * @return string
2381 */
2384 }
2386 /**
2387 * Get the formatted time for the given timestamp and formatted for
2388 * the given user.
2389 *
2390 * @param mixed $ts The time format which needs to be turned into a
2391 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2392 * @param User $user User object used to get preferences for timezone and format
2393 * @param array $options Array, can contain the following keys:
2394 * - 'timecorrection': time correction, can have the following values:
2395 * - true: use user's preference
2396 * - false: don't use time correction
2397 * - int: value of time correction in minutes
2398 * - 'format': format to use, can have the following values:
2399 * - true: use user's preference
2400 * - false: use default preference
2401 * - string: format to use
2402 * @since 1.19
2403 * @return string
2404 */
2407 }
2409 /**
2410 * Get the formatted date and time for the given timestamp and formatted for
2411 * the given user.
2412 *
2413 * @param mixed $ts The time format which needs to be turned into a
2414 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2415 * @param User $user User object used to get preferences for timezone and format
2416 * @param array $options Array, can contain the following keys:
2417 * - 'timecorrection': time correction, can have the following values:
2418 * - true: use user's preference
2419 * - false: don't use time correction
2420 * - int: value of time correction in minutes
2421 * - 'format': format to use, can have the following values:
2422 * - true: use user's preference
2423 * - false: use default preference
2424 * - string: format to use
2425 * @since 1.19
2426 * @return string
2427 */
2430 }
2432 /**
2433 * Convert an MWTimestamp into a pretty human-readable timestamp using
2434 * the given user preferences and relative base time.
2435 *
2436 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2437 * on your timestamp object, which will then call this function. Calling
2438 * this function directly will cause hooks to be skipped over.
2439 *
2440 * @see MWTimestamp::getHumanTimestamp
2441 * @param MWTimestamp $ts Timestamp to prettify
2442 * @param MWTimestamp $relativeTo Base timestamp
2443 * @param User $user User preferences to use
2444 * @return string Human timestamp
2445 * @since 1.22
2446 */
2454 ) {
2455 // Timestamps are in different years: use full timestamp
2456 // Also do full timestamp for future dates
2457 /**
2458 * @todo FIXME: Add better handling of future timestamps.
2459 */
2463 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2467 // Timestamp within the past week: show the day of the week and time
2470 // Messages:
2471 // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2477 // Timestamp was yesterday: say 'yesterday' and the time.
2484 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2491 // From here on in, the timestamp was soon enough ago so that we can simply say
2492 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2494 // Less than 90 minutes, but more than an hour ago.
2497 // A few minutes ago.
2500 // Less than a minute, but more than 30 sec ago.
2503 // Less than 30 seconds ago.
2505 }
2508 }
2510 /**
2511 * @param string $key
2512 * @return array|null
2513 */
2516 }
2518 /**
2519 * @return array
2520 */
2523 }
2525 /**
2526 * @param string $in
2527 * @param string $out
2528 * @param string $string
2529 * @return string
2530 */
2532 # This is a wrapper for iconv in all languages except esperanto,
2533 # which does some nasty x-conversions beforehand
2535 # Even with //IGNORE iconv can whine about illegal characters in
2536 # *input* string. We just ignore those too.
2537 # REF: http://bugs.php.net/bug.php?id=37166
2538 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2543 }
2545 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2547 /**
2548 * @param array $matches
2549 * @return mixed|string
2550 */
2553 }
2555 /**
2556 * @param array $matches
2557 * @return string
2558 */
2561 }
2563 /**
2564 * @param array $matches
2565 * @return string
2566 */
2570 }
2572 /**
2573 * @param array $matches
2574 * @return string
2575 */
2579 }
2581 /**
2582 * @param array $matches
2583 * @return string
2584 */
2587 }
2589 /**
2590 * @param array $matches
2591 * @return string
2592 */
2596 }
2598 /**
2599 * Make a string's first character uppercase
2600 *
2601 * @param string $str
2602 *
2603 * @return string
2604 */
2612 // fall back to more complex logic in case of multibyte strings
2614 }
2615 }
2617 /**
2618 * Convert a string to uppercase
2619 *
2620 * @param string $str
2621 * @param bool $first
2622 *
2623 * @return string
2624 */
2632 }
2635 }
2642 $str
2643 );
2646 }
2647 }
2648 }
2650 /**
2651 * @param string $str
2652 * @return mixed|string
2653 */
2665 }
2666 }
2668 /**
2669 * @param string $str
2670 * @param bool $first
2671 * @return mixed|string
2672 */
2680 }
2683 }
2690 $str
2691 );
2694 }
2695 }
2696 }
2698 /**
2699 * @param string $str
2700 * @return bool
2701 */
2704 }
2706 /**
2707 * @param string $str
2708 * @return mixed|string
2709 */
2714 // regexp to find first letter in each word (i.e. after each space)
2715 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2717 // function to use to capitalize a single char
2722 $str
2723 );
2728 $str
2729 );
2730 }
2733 }
2734 }
2736 /**
2737 * capitalize words at word breaks
2738 *
2739 * @param string $str
2740 * @return mixed
2741 */
2746 // since \b doesn't work for UTF-8, we explicitely define word break chars
2749 // find first letter after word break
2757 $str
2758 );
2763 $str
2764 );
2765 }
2770 $str
2771 );
2772 }
2773 }
2775 /**
2776 * Return a case-folded representation of $s
2777 *
2778 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2779 * and $s2 are the same except for the case of their characters. It is not
2780 * necessary for the value returned to make sense when displayed.
2781 *
2782 * Do *not* perform any other normalisation in this function. If a caller
2783 * uses this function when it should be using a more general normalisation
2784 * function, then fix the caller.
2785 *
2786 * @param string $s
2787 *
2788 * @return string
2789 */
2792 }
2794 /**
2795 * @param string $s
2796 * @return string
2797 */
2801 }
2804 }
2807 }
2809 /**
2810 * @return array
2811 */
2814 }
2816 /**
2817 * Most writing systems use whitespace to break up words.
2818 * Some languages such as Chinese don't conventionally do this,
2819 * which requires special handling when breaking up words for
2820 * searching etc.
2821 *
2822 * @return bool
2823 */
2826 }
2828 /**
2829 * Some languages such as Chinese require word segmentation,
2830 * Specify such segmentation when overridden in derived class.
2831 *
2832 * @param string $string
2833 * @return string
2834 */
2837 }
2839 /**
2840 * Some languages have special punctuation need to be normalized.
2841 * Make such changes here.
2842 *
2843 * @param string $string
2844 * @return string
2845 */
2848 }
2850 /**
2851 * convert double-width roman characters to single-width.
2852 * range: ff00-ff5f ~= 0020-007f
2853 *
2854 * @param string $string
2855 *
2856 * @return string
2857 */
2867 }
2871 }
2873 /**
2874 * @param string $string
2875 * @param string $pattern
2876 * @return string
2877 */
2882 }
2884 /**
2885 * @param array $termsArray
2886 * @return array
2887 */
2889 # some languages, e.g. Chinese, need to do a conversion
2890 # in order for search results to be displayed correctly
2892 }
2894 /**
2895 * Get the first character of a string.
2896 *
2897 * @param string $s
2898 * @return string
2899 */
2906 $matches
2907 );
2912 }
2914 // Break down Hangul syllables to grab the first jamo
2946 }
2949 }
2950 }
2953 # Some languages may have an alternate char encoding option
2954 # (Esperanto X-coding, Japanese furigana conversion, etc)
2955 # If this language is used as the primary content language,
2956 # an override to the defaults can be set here on startup.
2957 }
2959 /**
2960 * @param string $s
2961 * @return string
2962 */
2964 # For some languages we'll want to explicitly specify
2965 # which characters make it into the edit box raw
2966 # or are converted in some way or another.
2972 }
2973 }
2975 /**
2976 * @param string $s
2977 * @return string
2978 */
2980 # Take the previous into account.
2986 }
2991 }
2992 }
2994 /**
2995 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2996 * also cleans up certain backwards-compatible sequences, converting them
2997 * to the modern Unicode equivalent.
2998 *
2999 * This is language-specific for performance reasons only.
3000 *
3001 * @param string $s
3002 *
3003 * @return string
3004 */
3011 }
3014 }
3016 /**
3017 * Transform a string using serialized data stored in the given file (which
3018 * must be in the serialized subdirectory of $IP). The file contains pairs
3019 * mapping source characters to destination characters.
3020 *
3021 * The data is cached in process memory. This will go faster if you have the
3022 * FastStringSearch extension.
3023 *
3024 * @param string $file
3025 * @param string $string
3026 *
3027 * @throws MWException
3028 * @return string
3029 */
3035 }
3037 }
3039 }
3041 /**
3042 * For right-to-left language support
3043 *
3044 * @return bool
3045 */
3048 }
3050 /**
3051 * Return the correct HTML 'dir' attribute value for this language.
3052 * @return string
3053 */
3056 }
3058 /**
3059 * Return 'left' or 'right' as appropriate alignment for line-start
3060 * for this language's text direction.
3061 *
3062 * Should be equivalent to CSS3 'start' text-align value....
3063 *
3064 * @return string
3065 */
3068 }
3070 /**
3071 * Return 'right' or 'left' as appropriate alignment for line-end
3072 * for this language's text direction.
3073 *
3074 * Should be equivalent to CSS3 'end' text-align value....
3075 *
3076 * @return string
3077 */
3080 }
3082 /**
3083 * A hidden direction mark (LRM or RLM), depending on the language direction.
3084 * Unlike getDirMark(), this function returns the character as an HTML entity.
3085 * This function should be used when the output is guaranteed to be HTML,
3086 * because it makes the output HTML source code more readable. When
3087 * the output is plain text or can be escaped, getDirMark() should be used.
3088 *
3089 * @param bool $opposite Get the direction mark opposite to your language
3090 * @return string
3091 * @since 1.20
3092 */
3096 }
3098 }
3100 /**
3101 * A hidden direction mark (LRM or RLM), depending on the language direction.
3102 * This function produces them as invisible Unicode characters and
3103 * the output may be hard to read and debug, so it should only be used
3104 * when the output is plain text or can be escaped. When the output is
3105 * HTML, use getDirMarkEntity() instead.
3106 *
3107 * @param bool $opposite Get the direction mark opposite to your language
3108 * @return string
3109 */
3115 }
3117 }
3119 /**
3120 * @return array
3121 */
3124 }
3126 /**
3127 * An arrow, depending on the language direction.
3128 *
3129 * @param string $direction The direction of the arrow: forwards (default),
3130 * backwards, left, right, up, down.
3131 * @return string
3132 */
3147 }
3148 }
3150 /**
3151 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
3152 *
3153 * @return bool
3154 */
3157 }
3159 /**
3160 * Get all magic words from cache.
3161 * @return array
3162 */
3165 }
3167 /**
3168 * Run the LanguageGetMagic hook once.
3169 */
3173 }
3178 }
3180 /**
3181 * Fill a MagicWord object with data from here
3182 *
3183 * @param MagicWord $mw
3184 */
3186 // Saves a function call
3189 }
3196 }
3203 }
3204 }
3206 /**
3207 * Add magic words to the extension array
3208 *
3209 * @param array $newWords
3210 */
3217 }
3218 }
3219 }
3221 /**
3222 * Get special page names, as an associative array
3223 * canonical name => array of valid names, including aliases
3224 * @return array
3225 */
3227 // Cache aliases because it may be slow to load them
3229 // Initialise array
3234 }
3237 }
3239 /**
3240 * Italic is unsuitable for some languages
3241 *
3242 * @param string $text The text to be emphasized.
3243 * @return string
3244 */
3247 }
3249 /**
3250 * Normally we output all numbers in plain en_US style, that is
3251 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3252 * point twohundredthirtyfive. However this is not suitable for all
3253 * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3254 * Icelandic just want to use commas instead of dots, and dots instead
3255 * of commas like "293.291,235".
3256 *
3257 * An example of this function being called:
3258 * <code>
3259 * wfMessage( 'message' )->numParams( $num )->text()
3260 * </code>
3261 *
3262 * See $separatorTransformTable on MessageIs.php for
3263 * the , => . and . => , implementation.
3264 *
3265 * @todo check if it's viable to use localeconv() for the decimal separator thing.
3266 * @param int|float $number The string to be formatted, should be an integer
3267 * or a floating point number.
3268 * @param bool $nocommafy Set to true for special numbers like dates
3269 * @return string
3270 */
3278 }
3279 }
3285 }
3286 }
3289 }
3291 /**
3292 * Front-end for non-commafied formatNum
3293 *
3294 * @param int|float $number The string to be formatted, should be an integer
3295 * or a floating point number.
3296 * @since 1.21
3297 * @return string
3298 */
3301 }
3303 /**
3304 * @param string $number
3305 * @return string
3306 */
3310 // eliminate empty array values such as ''. (bug 64347)
3313 }
3317 // eliminate empty array values such as ''. (bug 64347)
3320 }
3324 }
3326 /**
3327 * Adds commas to a given number
3328 * @since 1.19
3329 * @param mixed $number
3330 * @return string
3331 */
3336 }
3339 // default grouping is at thousands, use the same for ###,###,### pattern too.
3342 // Ref: http://cldr.unicode.org/translation/number-patterns
3345 // For negative numbers apply the algorithm like positive number and add sign.
3348 }
3356 // the string does not have any number part. Eg: .12345
3358 }
3366 }
3370 // use the last pattern for the rest of the number
3372 }
3375 }
3376 }
3378 }
3379 }
3381 /**
3382 * @return string
3383 */
3386 }
3388 /**
3389 * @return array
3390 */
3393 }
3395 /**
3396 * @return array
3397 */
3400 }
3402 /**
3403 * Take a list of strings and build a locale-friendly comma-separated
3404 * list, using the local comma-separator message.
3405 * The last two strings are chained with an "and".
3406 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3407 *
3408 * @param string[] $l
3409 * @return string
3410 */
3415 }
3421 }
3422 }
3429 }
3430 }
3432 }
3434 /**
3435 * Take a list of strings and build a locale-friendly comma-separated
3436 * list, using the local comma-separator message.
3437 * @param string[] $list Array of strings to put in a comma list
3438 * @return string
3439 */
3443 $list
3444 );
3445 }
3447 /**
3448 * Take a list of strings and build a locale-friendly semicolon-separated
3449 * list, using the local semicolon-separator message.
3450 * @param string[] $list Array of strings to put in a semicolon list
3451 * @return string
3452 */
3456 $list
3457 );
3458 }
3460 /**
3461 * Same as commaList, but separate it with the pipe instead.
3462 * @param string[] $list Array of strings to put in a pipe list
3463 * @return string
3464 */
3468 $list
3469 );
3470 }
3472 /**
3473 * Truncate a string to a specified length in bytes, appending an optional
3474 * string (e.g. for ellipses)
3475 *
3476 * The database offers limited byte lengths for some columns in the database;
3477 * multi-byte character sets mean we need to ensure that only whole characters
3478 * are included, otherwise broken characters can be passed to the user
3479 *
3480 * If $length is negative, the string will be truncated from the beginning
3481 *
3482 * @param string $string String to truncate
3483 * @param int $length Maximum length (including ellipses)
3484 * @param string $ellipsis String to append to the truncated text
3485 * @param bool $adjustLength Subtract length of ellipsis from $length.
3486 * $adjustLength was introduced in 1.18, before that behaved as if false.
3487 * @return string
3488 */
3490 # Use the localized ellipsis character
3493 }
3494 # Check if there is no need to truncate
3499 }
3501 # If ellipsis length is >= $length then we can't apply $adjustLength
3504 # Otherwise, truncate and add ellipsis...
3519 }
3520 }
3521 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3522 # This check is *not* redundant if $adjustLength, due to the single case where
3523 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3528 }
3529 }
3531 /**
3532 * Remove bytes that represent an incomplete Unicode character
3533 * at the end of string (e.g. bytes of the char are missing)
3534 *
3535 * @param string $string
3536 * @return string
3537 */
3543 # We got the first byte only of a multibyte char; remove it.
3548 ) {
3549 # We chopped in the middle of a character; remove it
3551 }
3552 }
3554 }
3556 /**
3557 * Remove bytes that represent an incomplete Unicode character
3558 * at the start of string (e.g. bytes of the char are missing)
3559 *
3560 * @param string $string
3561 * @return string
3562 */
3567 # We chopped in the middle of a character; remove the whole thing
3569 }
3570 }
3572 }
3574 /**
3575 * Truncate a string of valid HTML to a specified length in bytes,
3576 * appending an optional string (e.g. for ellipses), and return valid HTML
3577 *
3578 * This is only intended for styled/linked text, such as HTML with
3579 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3580 * Also, this will not detect things like "display:none" CSS.
3581 *
3582 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3583 *
3584 * @param string $text HTML string to truncate
3585 * @param int $length (zero/positive) Maximum length (including ellipses)
3586 * @param string $ellipsis String to append to the truncated text
3587 * @return string
3588 */
3590 # Use the localized ellipsis character
3593 }
3594 # Check if there is clearly no need to truncate
3599 }
3613 # Consider truncation once the display length has reached the maximim.
3614 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3615 # Check that we're not in the middle of a bracket/entity...
3619 # Save where we are; we will truncate here unless there turn out to
3620 # be so few remaining characters that truncation is not necessary.
3623 }
3625 # String in fact does need truncation, the truncation point was OK.
3630 }
3631 }
3634 }
3636 # Read the next char...
3654 }
3660 // Name found (e.g. "<a href=..."), add on tag attributes...
3662 }
3668 }
3671 // Save state without $ch. We want to *hit* the first
3672 // display char (to get tags) but not *use* it if truncating.
3674 }
3679 // Add the next $max display text chars after this in one swoop...
3684 }
3685 }
3686 }
3687 }
3688 // Close the last tag if left unclosed by bad HTML
3692 }
3694 }
3696 /**
3697 * truncateHtml() helper function
3698 * like strcspn() but adds the skipped chars to $ret
3699 *
3700 * @param string $ret
3701 * @param string $text
3702 * @param string $search
3703 * @param int $start
3704 * @param null|int $len
3705 * @return int
3706 */
3712 }
3717 }
3719 }
3721 /**
3722 * truncateHtml() helper function
3723 * (a) push or pop $tag from $openTags as needed
3724 * (b) clear $tag value
3725 * @param string &$tag Current HTML tag name we are looking at
3726 * @param int $tagType (0-open tag, 1-close tag)
3727 * @param string $lastCh Character before the '>' that ended this tag
3728 * @param array &$openTags Open tag stack (not accounting for $tag)
3729 */
3738 }
3739 }
3741 }
3742 }
3744 /**
3745 * Grammatical transformations, needed for inflected languages
3746 * Invoked by putting {{grammar:case|word}} in a message
3747 *
3748 * @param string $word
3749 * @param string $case
3750 * @return string
3751 */
3756 }
3759 }
3760 /**
3761 * Get the grammar forms for the content language
3762 * @return array Array of grammar forms
3763 * @since 1.20
3764 */
3769 ) {
3771 }
3774 }
3775 /**
3776 * Provides an alternative text depending on specified gender.
3777 * Usage {{gender:username|masculine|feminine|unknown}}.
3778 * username is optional, in which case the gender of current user is used,
3779 * but only in (some) interface messages; otherwise default gender is used.
3780 *
3781 * If no forms are given, an empty string is returned. If only one form is
3782 * given, it will be returned unconditionally. These details are implied by
3783 * the caller and cannot be overridden in subclasses.
3784 *
3785 * If three forms are given, the default is to use the third (unknown) form.
3786 * If fewer than three forms are given, the default is to use the first (masculine) form.
3787 * These details can be overridden in subclasses.
3788 *
3789 * @param string $gender
3790 * @param array $forms
3791 *
3792 * @return string
3793 */
3797 }
3801 }
3804 }
3806 }
3808 /**
3809 * Plural form transformations, needed for some languages.
3810 * For example, there are 3 form of plural in Russian and Polish,
3811 * depending on "count mod 10". See [[w:Plural]]
3812 * For English it is pretty simple.
3813 *
3814 * Invoked by putting {{plural:count|wordform1|wordform2}}
3815 * or {{plural:count|wordform1|wordform2|wordform3}}
3816 *
3817 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3818 *
3819 * @param int $count Non-localized number
3820 * @param array $forms Different plural forms
3821 * @return string Correct form of plural for $count in this language
3822 */
3824 // Handle explicit n=pluralform cases
3828 }
3831 }
3836 }
3838 /**
3839 * Handles explicit plural forms for Language::convertPlural()
3840 *
3841 * In {{PLURAL:$1|0=nothing|one|many}}, 0=nothing will be returned if $1 equals zero.
3842 * If an explicitly defined plural form matches the $count, then
3843 * string value returned, otherwise array returned for further consideration
3844 * by CLDR rules or overridden convertPlural().
3845 *
3846 * @since 1.23
3847 *
3848 * @param int $count Non-localized number
3849 * @param array $forms Different plural forms
3850 *
3851 * @return array|string
3852 */
3859 }
3861 }
3862 }
3864 }
3866 /**
3867 * Checks that convertPlural was given an array and pads it to requested
3868 * amount of forms by copying the last one.
3869 *
3870 * @param array $forms Array of forms given to convertPlural
3871 * @param int $count How many forms should there be at least
3872 * @return array Padded array of forms or an exception if not an array
3873 */
3877 }
3879 }
3881 /**
3882 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3883 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3884 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3885 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3886 * match up with it.
3887 *
3888 * @param string $str The validated block duration in English
3889 * @return string Somehow translated block duration
3890 * @see LanguageFi.php for example implementation
3891 */
3897 }
3898 }
3900 // Since usually only infinite or indefinite is only on list, so try
3901 // equivalents if still here.
3908 }
3909 }
3910 }
3912 // If all else fails, return a standard duration or timestamp description.
3917 // $time is relative to 0 so it's a duration length.
3921 // wfTimestamp() handles 0 as current time instead of epoch.
3925 }
3926 }
3927 }
3929 /**
3930 * languages like Chinese need to be segmented in order for the diff
3931 * to be of any use
3932 *
3933 * @param string $text
3934 * @return string
3935 */
3938 }
3940 /**
3941 * and unsegment to show the result
3942 *
3943 * @param string $text
3944 * @return string
3945 */
3948 }
3950 /**
3951 * Return the LanguageConverter used in the Language
3952 *
3953 * @since 1.19
3954 * @return LanguageConverter
3955 */
3958 }
3960 /**
3961 * convert text to all supported variants
3962 *
3963 * @param string $text
3964 * @return array
3965 */
3968 }
3970 /**
3971 * convert text to different variants of a language.
3972 *
3973 * @param string $text
3974 * @return string
3975 */
3978 }
3980 /**
3981 * Convert a Title object to a string in the preferred variant
3982 *
3983 * @param Title $title
3984 * @return string
3985 */
3988 }
3990 /**
3991 * Convert a namespace index to a string in the preferred variant
3992 *
3993 * @param int $ns
3994 * @return string
3995 */
3998 }
4000 /**
4001 * Check if this is a language with variants
4002 *
4003 * @return bool
4004 */
4007 }
4009 /**
4010 * Check if the language has the specific variant
4011 *
4012 * @since 1.19
4013 * @param string $variant
4014 * @return bool
4015 */
4018 }
4020 /**
4021 * Put custom tags (e.g. -{ }-) around math to prevent conversion
4022 *
4023 * @param string $text
4024 * @return string
4025 * @deprecated since 1.22 is no longer used
4026 */
4029 }
4031 /**
4032 * Perform output conversion on a string, and encode for safe HTML output.
4033 * @param string $text Text to be converted
4034 * @param bool $isTitle Whether this conversion is for the article title
4035 * @return string
4036 * @todo this should get integrated somewhere sane
4037 */
4040 }
4042 /**
4043 * @param string $key
4044 * @return string
4045 */
4048 }
4050 /**
4051 * Get the list of variants supported by this language
4052 * see sample implementation in LanguageZh.php
4053 *
4054 * @return array An array of language codes
4055 */
4058 }
4060 /**
4061 * @return string
4062 */
4065 }
4067 /**
4068 * @return string
4069 */
4072 }
4074 /**
4075 * @return string
4076 */
4079 }
4081 /**
4082 * If a language supports multiple variants, it is
4083 * possible that non-existing link in one variant
4084 * actually exists in another variant. this function
4085 * tries to find it. See e.g. LanguageZh.php
4086 * The input parameters may be modified upon return
4087 *
4088 * @param string &$link The name of the link
4089 * @param Title &$nt The title object of the link
4090 * @param bool $ignoreOtherCond To disable other conditions when
4091 * we need to transclude a template or update a category's link
4092 */
4095 }
4097 /**
4098 * returns language specific options used by User::getPageRenderHash()
4099 * for example, the preferred language variant
4100 *
4101 * @return string
4102 */
4105 }
4107 /**
4108 * For languages that support multiple variants, the title of an
4109 * article may be displayed differently in different variants. this
4110 * function returns the apporiate title defined in the body of the article.
4111 *
4112 * @return string
4113 */
4116 }
4118 /**
4119 * Prepare external link text for conversion. When the text is
4120 * a URL, it shouldn't be converted, and it'll be wrapped in
4121 * the "raw" tag (-{R| }-) to prevent conversion.
4122 *
4123 * This function is called "markNoConversion" for historical
4124 * reasons.
4125 *
4126 * @param string $text Text to be used for external link
4127 * @param bool $noParse Wrap it without confirming it's a real URL first
4128 * @return string The tagged text
4129 */
4131 // Excluding protocal-relative URLs may avoid many false positives.
4136 }
4137 }
4139 /**
4140 * A regular expression to match legal word-trailing characters
4141 * which should be merged onto a link of the form [[foo]]bar.
4142 *
4143 * @return string
4144 */
4147 }
4149 /**
4150 * A regular expression character set to match legal word-prefixing
4151 * characters which should be merged onto a link of the form foo[[bar]].
4152 *
4153 * @return string
4154 */
4157 }
4159 /**
4160 * @deprecated since 1.24, will be removed in 1.25
4161 * @return Language
4162 */
4166 }
4168 /**
4169 * Get the "parent" language which has a converter to convert a "compatible" language
4170 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
4171 *
4172 * @return Language|null
4173 * @since 1.22
4174 */
4178 }
4185 }
4190 }
4194 }
4196 /**
4197 * Get the RFC 3066 code for this language object
4198 *
4199 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4200 * htmlspecialchars() or similar
4201 *
4202 * @return string
4203 */
4206 }
4208 /**
4209 * Get the code in Bcp47 format which we can use
4210 * inside of html lang="" tags.
4211 *
4212 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4213 * htmlspecialchars() or similar.
4214 *
4215 * @since 1.19
4216 * @return string
4217 */
4221 }
4223 }
4225 /**
4226 * @param string $code
4227 */
4230 // Ensure we don't leave incorrect cached data lying around
4233 }
4235 /**
4236 * Get the name of a file for a certain language code
4237 * @param string $prefix Prepend this to the filename
4238 * @param string $code Language code
4239 * @param string $suffix Append this to the filename
4240 * @throws MWException
4241 * @return string $prefix . $mangledCode . $suffix
4242 */
4246 }
4249 }
4251 /**
4252 * Get the language code from a file name. Inverse of getFileName()
4253 * @param string $filename $prefix . $languageCode . $suffix
4254 * @param string $prefix Prefix before the language code
4255 * @param string $suffix Suffix after the language code
4256 * @return string Language code, or false if $prefix or $suffix isn't found
4257 */
4258 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4264 }
4266 }
4268 /**
4269 * @param string $code
4270 * @return string
4271 */
4277 }
4279 /**
4280 * @param string $code
4281 * @return string
4282 * @since 1.23
4283 */
4289 }
4292 }
4294 /**
4295 * @param string $code
4296 * @return string
4297 */
4301 }
4303 /**
4304 * Get the first fallback for a given language.
4305 *
4306 * @param string $code
4307 *
4308 * @return bool|string
4309 */
4317 }
4318 }
4320 /**
4321 * Get the ordered list of fallback languages.
4322 *
4323 * @since 1.19
4324 * @param string $code Language code
4325 * @return array
4326 */
4335 }
4337 }
4338 }
4340 /**
4341 * Get the ordered list of fallback languages, ending with the fallback
4342 * language chain for the site language.
4343 *
4344 * @since 1.22
4345 * @param string $code Language code
4346 * @return array Array( fallbacks, site fallbacks )
4347 */
4351 // Usually, we will only store a tiny number of fallback chains, so we
4352 // keep them in static memory.
4358 // Append the site's fallback chain, including the site language itself
4362 // Eliminate any languages already included in the chain
4366 }
4368 }
4370 /**
4371 * Get all messages for a given language
4372 * WARNING: this may take a long time. If you just need all message *keys*
4373 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4374 *
4375 * @param string $code
4376 *
4377 * @return array
4378 */
4381 }
4383 /**
4384 * Get a message for a given language
4385 *
4386 * @param string $key
4387 * @param string $code
4388 *
4389 * @return string
4390 */
4393 }
4395 /**
4396 * Get all message keys for a given language. This is a faster alternative to
4397 * array_keys( Language::getMessagesFor( $code ) )
4398 *
4399 * @since 1.19
4400 * @param string $code Language code
4401 * @return array Array of message keys (strings)
4402 */
4405 }
4407 /**
4408 * @param string $talk
4409 * @return mixed
4410 */
4414 }
4419 # Allow grammar transformations
4420 # Allowing full message-style parsing would make simple requests
4421 # such as action=raw much more expensive than they need to be.
4422 # This will hopefully cover most cases.
4426 }
4428 /**
4429 * @param string $m
4430 * @return string
4431 */
4434 }
4436 /**
4437 * @throws MWException
4438 * @return array
4439 */
4444 }
4450 }
4454 }
4456 /**
4457 * Decode an expiry (block, protection, etc) which has come from the DB
4458 *
4459 * @todo FIXME: why are we returnings DBMS-dependent strings???
4460 *
4461 * @param string $expiry Database expiry String
4462 * @param bool|int $format True to process using language functions, or TS_ constant
4463 * to return the expiry in a given timestamp
4464 * @return string
4465 * @since 1.18
4466 */
4471 }
4481 }
4482 }
4484 /**
4485 * @todo Document
4486 * @param int|float $seconds
4487 * @param array $format Optional
4488 * If $format['avoid'] === 'avoidseconds': don't mention seconds if $seconds >= 1 hour.
4489 * If $format['avoid'] === 'avoidminutes': don't mention seconds/minutes if $seconds > 48 hours.
4490 * If $format['noabbrevs'] is true: use 'seconds' and friends instead of 'seconds-abbrev'
4491 * and friends.
4492 * For backwards compatibility, $format may also be one of the strings 'avoidseconds'
4493 * or 'avoidminutes'.
4494 * @return string
4495 */
4499 }
4502 }
4505 }
4527 }
4538 }
4542 }
4548 }
4556 }
4566 }
4570 }
4580 }
4581 }
4583 }
4585 /**
4586 * Format a bitrate for output, using an appropriate
4587 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to
4588 * the magnitude in question.
4589 *
4590 * This use base 1000. For base 1024 use formatSize(), for another base
4591 * see formatComputingNumbers().
4592 *
4593 * @param int $bps
4594 * @return string
4595 */
4598 }
4600 /**
4601 * @param int $size Size of the unit
4602 * @param int $boundary Size boundary (1000, or 1024 in most cases)
4603 * @param string $messageKey Message key to be uesd
4604 * @return string
4605 */
4610 );
4611 }
4619 }
4621 // For small sizes no decimal places necessary
4624 // For MB and bigger two decimal places are smarter
4626 }
4632 }
4634 /**
4635 * Format a size in bytes for output, using an appropriate
4636 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4637 *
4638 * This method use base 1024. For base 1000 use formatBitrate(), for
4639 * another base see formatComputingNumbers()
4640 *
4641 * @param int $size Size to format
4642 * @return string Plain text (not HTML)
4643 */
4646 }
4648 /**
4649 * Make a list item, used by various special pages
4650 *
4651 * @param string $page Page link
4652 * @param string $details HTML safe text between brackets
4653 * @param bool $oppositedm Add the direction mark opposite to your
4654 * language, to display text properly
4655 * @return HTML escaped string
4656 */
4660 }
4663 return
4668 }
4670 /**
4671 * Generate (prev x| next x) (20|50|100...) type links for paging
4672 *
4673 * @param Title $title Title object to link
4674 * @param int $offset
4675 * @param int $limit
4676 * @param array $query Optional URL query parameter string
4677 * @param bool $atend Optional param for specified if this is the last page
4678 * @return string
4679 */
4682 ) {
4683 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4685 # Make 'previous' link
4686 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4692 }
4694 # Make 'next' link
4695 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4701 }
4703 # Make links to set number of items per page
4708 }
4712 }
4714 /**
4715 * Helper function for viewPrevNext() that generates links
4716 *
4717 * @param Title $title Title object to link
4718 * @param int $offset
4719 * @param int $limit
4720 * @param array $query Extra query parameters
4721 * @param string $link Text to use for the link; will be escaped
4722 * @param string $tooltipMsg Name of the message to use as tooltip
4723 * @param string $class Value of the "class" attribute of the link
4724 * @return string HTML fragment
4725 */
4728 ) {
4735 }
4737 /**
4738 * Get the conversion rule title, if any.
4739 *
4740 * @return string
4741 */
4744 }
4746 /**
4747 * Get the compiled plural rules for the language
4748 * @since 1.20
4749 * @return array Associative array with plural form, and plural rule as key-value pairs
4750 */
4756 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4759 }
4760 }
4761 }
4763 }
4765 /**
4766 * Get the plural rules for the language
4767 * @since 1.20
4768 * @return array Associative array with plural form number and plural rule as key-value pairs
4769 */
4778 }
4779 }
4780 }
4782 }
4784 /**
4785 * Get the plural rule types for the language
4786 * @since 1.22
4787 * @return array Associative array with plural form number and plural rule type as key-value pairs
4788 */
4794 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4797 }
4798 }
4799 }
4801 }
4803 /**
4804 * Find the index number of the plural rule appropriate for the given number
4805 * @param int $number
4806 * @return int The index number of the plural rule
4807 */
4812 }
4814 /**
4815 * Find the plural rule type appropriate for the given number
4816 * For example, if the language is set to Arabic, getPluralType(5) should
4817 * return 'few'.
4818 * @since 1.22
4819 * @param int $number
4820 * @return string The name of the plural rule type, e.g. one, two, few, many
4821 */
4829 }
4830 }
4831 }