| blob | 115a918ffc62f1eca79d02f40ab8815080d76a39 |
1 <?php
2 /**
3 * Internationalisation code.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
19 *
20 * @file
21 * @ingroup Language
22 */
24 /**
25 * @defgroup Language Language
26 */
31 }
35 }
37 /**
38 * Internationalisation code
39 * @ingroup Language
40 */
42 /**
43 * @var LanguageConverter
44 */
56 /**
57 * ReplacementArray object caches
58 */
61 /**
62 * @var LocalisationCache
63 */
71 );
75 );
80 'december'
81 );
85 'december-gen'
86 );
90 );
97 );
105 );
113 );
120 );
122 /**
123 * @since 1.20
124 * @var array
125 */
136 );
138 /**
139 * Cache for language fallbacks.
140 * @see Language::getFallbacksIncludingSiteLanguage
141 * @since 1.21
142 * @var array
143 */
146 /**
147 * Get a cached or new language object for a given language code
148 * @param string $code
149 * @return Language
150 */
156 }
158 // get the language object to process
163 // merge the language object in to get it up front in the cache
165 // get rid of the oldest ones in case we have an overflow
169 }
171 /**
172 * Create a language object for a given language code
173 * @param string $code
174 * @throws MWException
175 * @return Language
176 */
178 // Protect against path traversal below
181 ) {
183 }
186 // It's not possible to customise this code with class files, so
187 // just return a Language object. This is to support uselang= hacks.
191 }
193 // Check if there is a language class for the code
199 }
201 // Keep trying the fallback list until we find an existing class
206 }
214 }
215 }
218 }
220 /**
221 * Checks whether any localisation is available for that language tag
222 * in MediaWiki (MessagesXx.php exists).
223 *
224 * @param string $code Language tag (in lower case)
225 * @return bool Whether language is supported
226 * @since 1.21
227 */
232 );
233 }
235 /**
236 * Returns true if a language code string is a well-formed language tag
237 * according to RFC 5646.
238 * This function only checks well-formedness; it doesn't check that
239 * language, script or variant codes actually exist in the repositories.
240 *
241 * Based on regexes by Mark Davis of the Unicode Consortium:
242 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
243 *
244 * @param string $code
245 * @param bool $lenient Whether to allow '_' as separator. The default is only '-'.
246 *
247 * @return bool
248 * @since 1.21
249 */
265 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
266 # Since these are limited, this is safe even later changes to the registry --
267 # the only oddity is that it might change the type of the tag, and thus
268 # the results from the capturing groups.
269 # http://www.iana.org/assignments/language-subtag-registry
287 # The final breakdown, with capturing groups for each of these components
288 # The variants, extensions, grandfathered, and private-use may have interior '-'
293 }
295 /**
296 * Returns true if a language code string is of a valid form, whether or
297 * not it exists. This includes codes which are used solely for
298 * customisation via the MediaWiki namespace.
299 *
300 * @param string $code
301 *
302 * @return bool
303 */
308 }
309 // People think language codes are html safe, so enforce it.
310 // Ideally we should only allow a-zA-Z0-9-
311 // but, .+ and other chars are often used for {{int:}} hacks
312 // see bugs 37564, 37587, 36938
318 }
320 /**
321 * Returns true if a language code is of a valid form for the purposes of
322 * internal customisation of MediaWiki, via Messages*.php or *.json.
323 *
324 * @param string $code
325 *
326 * @throws MWException
327 * @since 1.18
328 * @return bool
329 */
337 }
340 }
343 }
345 /**
346 * Returns true if a language code is an IETF tag known to MediaWiki.
347 *
348 * @param string $tag
349 *
350 * @since 1.21
351 * @return bool
352 */
356 // Quick escape for invalid input to avoid exceptions down the line
357 // when code tries to process tags which are not valid at all.
360 }
365 }
369 ) {
371 }
374 }
376 /**
377 * @param string $code
378 * @return string Name of the language class
379 */
385 }
386 }
388 /**
389 * Includes language class files
390 *
391 * @param string $class Name of the language class
392 */
398 }
402 }
403 }
405 /**
406 * Get the LocalisationCache instance
407 *
408 * @return LocalisationCache
409 */
415 }
417 }
421 // Set the code to the name of the descendant
426 }
428 }
430 /**
431 * Reduce memory usage
432 */
436 }
437 }
439 /**
440 * Hook which will be called if this is the content language.
441 * Descendants can use this to register hook functions or modify globals
442 */
444 }
446 /**
447 * @return array
448 * @since 1.19
449 */
452 }
454 /**
455 * Exports $wgBookstoreListEn
456 * @return array
457 */
460 }
462 /**
463 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
464 * available in localised form, it will be included in English.
465 *
466 * @return array
467 */
484 }
486 # Sometimes a language will be localised but not actually exist on this wiki.
490 }
491 }
493 # The above mixing may leave namespaces out of canonical order.
494 # Re-order by namespace ID number...
498 }
501 }
503 /**
504 * Arbitrarily set all of the namespace names at once. Mainly used for testing
505 * @param array $namespaces Array of namespaces (id => name)
506 */
510 }
512 /**
513 * Resets all of the namespace caches. Mainly used for testing
514 */
519 }
521 /**
522 * A convenience function that returns the same thing as
523 * getNamespaces() except with the array values changed to ' '
524 * where it found '_', useful for producing output to be displayed
525 * e.g. in <select> forms.
526 *
527 * @return array
528 */
533 }
535 }
537 /**
538 * Get a namespace value by key
539 * <code>
540 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
541 * echo $mw_ns; // prints 'MediaWiki'
542 * </code>
543 *
544 * @param int $index The array key of the namespace to return
545 * @return string|bool String if the namespace value exists, otherwise false
546 */
551 }
553 /**
554 * A convenience function that returns the same thing as
555 * getNsText() except with '_' changed to ' ', useful for
556 * producing output.
557 *
558 * <code>
559 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
560 * echo $mw_ns; // prints 'MediaWiki talk'
561 * </code>
562 *
563 * @param int $index The array key of the namespace to return
564 * @return string Namespace name without underscores (empty string if namespace does not exist)
565 */
570 }
572 /**
573 * Returns gender-dependent namespace alias if available.
574 * See https://www.mediawiki.org/wiki/Manual:$wgExtraGenderNamespaces
575 * @param int $index Namespace index
576 * @param string $gender Gender key (male, female... )
577 * @return string
578 * @since 1.18
579 */
587 }
589 /**
590 * Whether this language uses gender-dependent namespace aliases.
591 * See https://www.mediawiki.org/wiki/Manual:$wgExtraGenderNamespaces
592 * @return bool
593 * @since 1.18
594 */
598 // $wgExtraGenderNamespaces overrides everything
600 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
601 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
602 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
605 // Check what is in i18n files
608 }
609 }
611 /**
612 * Get a namespace key by value, case insensitive.
613 * Only matches namespace names for the current language, not the
614 * canonical ones defined in Namespace.php.
615 *
616 * @param string $text
617 * @return int|bool An integer if $text is a valid value otherwise false
618 */
623 }
625 /**
626 * @return array
627 */
639 }
640 }
641 }
649 }
650 }
652 # Also add converted namespace names as aliases, to avoid confusion.
657 }
660 }
661 }
664 }
667 }
669 /**
670 * @return array
671 */
675 # Put namespace names and aliases into a hashtable.
676 # If this is too slow, then we should arrange it so that it is done
677 # before caching. The catch is that at pre-cache time, the above
678 # class-specific fixup hasn't been done.
682 }
685 }
689 }
690 }
691 }
693 }
695 /**
696 * Get a namespace key by value, case insensitive. Canonical namespace
697 * names override custom ones defined for the current language.
698 *
699 * @param string $text
700 * @return int|bool An integer if $text is a valid value otherwise false
701 */
707 }
710 }
712 /**
713 * short names for language variants used for language conversion links.
714 *
715 * @param string $code
716 * @param bool $usemsg Use the "variantname-xyz" message if it exists
717 * @return string
718 */
723 }
728 # otherwise, output the language code
730 }
731 }
733 /**
734 * @param string $name
735 * @return string
736 */
741 }
743 }
745 /**
746 * @return array
747 */
750 }
752 /**
753 * @return array
754 */
757 }
759 /**
760 * @return array|string
761 */
769 }
770 }
772 /**
773 * @return array
774 */
777 }
779 /**
780 * @param string $image
781 * @return array|null
782 */
785 }
787 /**
788 * @return array
789 * @since 1.24
790 */
793 }
795 /**
796 * @return array
797 */
800 }
802 /**
803 * @param string $tog
804 * @return string
805 */
808 }
810 /**
811 * Get native language names, indexed by code.
812 * Only those defined in MediaWiki, no other data like CLDR.
813 * If $customisedOnly is true, only returns codes with a messages file
814 *
815 * @param bool $customisedOnly
816 *
817 * @return array
818 * @deprecated since 1.20, use fetchLanguageNames()
819 */
822 }
824 /**
825 * Get translated language names. This is done on best effort and
826 * by default this is exactly the same as Language::getLanguageNames.
827 * The CLDR extension provides translated names.
828 * @param string $code Language code.
829 * @return array Language code => language name
830 * @since 1.18.0
831 * @deprecated since 1.20, use fetchLanguageNames()
832 */
835 }
837 /**
838 * Get an array of language names, indexed by code.
839 * @param null|string $inLanguage Code of language in which to return the names
840 * Use null for autonyms (native names)
841 * @param string $include One of:
842 * 'all' all available languages
843 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
844 * 'mwfile' only if the language is in 'mw' *and* has a message file
845 * @return array Language code => language name
846 * @since 1.20
847 */
855 }
857 // If passed an invalid language code to use, fallback to en
860 }
865 # TODO: also include when $inLanguage is null, when this code is more efficient
867 }
871 # - Prefer own MediaWiki native name when not using the hook
872 # - For other names just add if not added through the hook
875 }
876 }
880 }
886 }
890 # We do this using a foreach over the codes instead of a directory
891 # loop so that messages files in extensions will work correctly.
895 ) {
897 }
898 }
901 }
903 # 'mw' option; default if it's not one of the other two options (all/mwfile)
905 }
907 /**
908 * @param string $code The code of the language for which to get the name
909 * @param null|string $inLanguage Code of language in which to return the name (null for autonyms)
910 * @param string $include 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
911 * @return string Language name or empty
912 * @since 1.20
913 */
918 }
920 /**
921 * Get a message from the MediaWiki namespace.
922 *
923 * @param string $msg Message name
924 * @return string
925 */
928 }
930 /**
931 * Get the native language name of $code.
932 * Only if defined in MediaWiki, no other data like CLDR.
933 * @param string $code
934 * @return string
935 * @deprecated since 1.20, use fetchLanguageName()
936 */
939 }
941 /**
942 * @param string $key
943 * @return string
944 */
947 }
949 /**
950 * @return array
951 */
956 }
958 }
960 /**
961 * @param string $key
962 * @return string
963 */
966 }
968 /**
969 * @param string $key
970 * @return string
971 */
974 }
976 /**
977 * @return array
978 */
983 }
985 }
987 /**
988 * @param string $key
989 * @return string
990 */
993 }
995 /**
996 * @param string $key
997 * @return string
998 */
1001 }
1003 /**
1004 * @param string $key
1005 * @return string
1006 */
1009 }
1011 /**
1012 * @param string $key
1013 * @return string
1014 */
1017 }
1019 /**
1020 * @param string $key
1021 * @return string
1022 */
1025 }
1027 /**
1028 * @param string $key
1029 * @return string
1030 */
1033 }
1035 /**
1036 * Pass through result from $dateTimeObj->format()
1037 * @param DateTime|bool|null &$dateTimeObj
1038 * @param string $ts
1039 * @param DateTimeZone|bool|null $zone
1040 * @param string $code
1041 * @return string
1042 */
1047 );
1048 }
1050 }
1052 /**
1053 * This is a workalike of PHP's date() function, but with better
1054 * internationalisation, a reduced set of format characters, and a better
1055 * escaping format.
1056 *
1057 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1058 * the PHP manual for definitions. There are a number of extensions, which
1059 * start with "x":
1060 *
1061 * xn Do not translate digits of the next numeric format character
1062 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1063 * xr Use roman numerals for the next numeric format character
1064 * xh Use hebrew numerals for the next numeric format character
1065 * xx Literal x
1066 * xg Genitive month name
1067 *
1068 * xij j (day number) in Iranian calendar
1069 * xiF F (month name) in Iranian calendar
1070 * xin n (month number) in Iranian calendar
1071 * xiy y (two digit year) in Iranian calendar
1072 * xiY Y (full year) in Iranian calendar
1073 *
1074 * xjj j (day number) in Hebrew calendar
1075 * xjF F (month name) in Hebrew calendar
1076 * xjt t (days in month) in Hebrew calendar
1077 * xjx xg (genitive month name) in Hebrew calendar
1078 * xjn n (month number) in Hebrew calendar
1079 * xjY Y (full year) in Hebrew calendar
1080 *
1081 * xmj j (day number) in Hijri calendar
1082 * xmF F (month name) in Hijri calendar
1083 * xmn n (month number) in Hijri calendar
1084 * xmY Y (full year) in Hijri calendar
1085 *
1086 * xkY Y (full year) in Thai solar calendar. Months and days are
1087 * identical to the Gregorian calendar
1088 * xoY Y (full year) in Minguo calendar or Juche year.
1089 * Months and days are identical to the
1090 * Gregorian calendar
1091 * xtY Y (full year) in Japanese nengo. Months and days are
1092 * identical to the Gregorian calendar
1093 *
1094 * Characters enclosed in double quotes will be considered literal (with
1095 * the quotes themselves removed). Unmatched quotes will be considered
1096 * literal quotes. Example:
1097 *
1098 * "The month is" F => The month is January
1099 * i's" => 20'11"
1100 *
1101 * Backslash escaping is also supported.
1102 *
1103 * Input timestamp is assumed to be pre-normalized to the desired local
1104 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1105 * $ts is UTC if $zone is not given.
1106 *
1107 * @param string $format
1108 * @param string $ts 14-character timestamp
1109 * YYYYMMDDHHMMSS
1110 * 01234567890123
1111 * @param DateTimeZone $zone Timezone of $ts
1112 * @param[out] int $ttl The amount of time (in seconds) the output may be cached for.
1113 * Only makes sense if $ts is the current time.
1114 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1115 *
1116 * @throws MWException
1117 * @return string
1118 */
1154 }
1158 }
1166 }
1176 }
1202 }
1211 $s .= $this->getWeekdayAbbreviation( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1 );
1221 }
1228 }
1235 }
1240 $s .= $this->getWeekdayName( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'w' ) + 1 );
1250 }
1257 }
1264 }
1283 }
1290 }
1297 }
1304 }
1315 }
1322 }
1329 }
1336 }
1343 }
1350 }
1361 }
1401 // fall through
1432 // fall through
1438 # Backslash escaping
1443 }
1446 # Quoted literal
1450 # No terminating quote, assume literal "
1455 }
1457 # Quote at end of string, assume literal "
1459 }
1463 }
1476 }
1477 }
1478 }
1487 $ttl = 43200 - ( substr( $ts, 8, 2 ) % 12 ) * 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1488 } elseif ( $usedDay || $usedHebrewMonth || $usedIranianMonth || $usedHijriMonth || $usedHebrewYear || $usedIranianYear || $usedHijriYear || $usedTennoYear ) {
1489 // @todo Someone who understands the non-Gregorian calendars should write proper logic for them
1490 // so that they don't need purged every day.
1494 $timeRemainingInDay = 86400 - substr( $ts, 8, 2 ) * 3600 - substr( $ts, 10, 2 ) * 60 - substr( $ts, 12, 2 );
1496 $possibleTtls[] = ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 + $timeRemainingInDay;
1498 // December 28th falls on the last ISO week of the year, every year.
1499 // The last ISO week of a year can be 52 or 53.
1500 $lastWeekOfISOYear = DateTime::createFromFormat( 'Ymd', substr( $ts, 0, 4 ) . '1228', $zone ?: new DateTimeZone( 'UTC' ) )->format( 'W' );
1503 $timeRemainingInWeek = ( 7 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'N' ) ) * 86400 + $timeRemainingInDay;
1505 }
1508 $possibleTtls[] = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 't' ) - substr( $ts, 6, 2 ) ) * 86400 + $timeRemainingInDay;
1510 $possibleTtls[] = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1514 $timeRemainingInYear = ( Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'L' ) + 364 - Language::dateTimeObjFormat( $dateTimeObj, $ts, $zone, 'z' ) ) * 86400
1518 // this isn't a leap year. see when the next one starts
1524 }
1526 // this is a leap year, so the next year isn't
1528 }
1529 }
1533 }
1534 }
1537 }
1542 /**
1543 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1544 * Gregorian dates to Iranian dates. Originally written in C, it
1545 * is released under the terms of GNU Lesser General Public
1546 * License. Conversion to PHP was performed by Niklas Laxström.
1547 *
1548 * Link: http://www.farsiweb.info/jalali/jalali.c
1549 *
1550 * @param string $ts
1551 *
1552 * @return string
1553 */
1559 # Days passed from the beginning (including leap years)
1565 // Add days of the past months of this year
1568 }
1570 // Leap years
1573 }
1575 // Days passed in current month
1589 }
1593 }
1599 }
1601 /**
1602 * Converting Gregorian dates to Hijri dates.
1603 *
1604 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1605 *
1606 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1607 *
1608 * @param string $ts
1609 *
1610 * @return string
1611 */
1625 ) {
1633 }
1647 }
1649 /**
1650 * Converting Gregorian dates to Hebrew dates.
1651 *
1652 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1653 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1654 * to translate the relevant functions into PHP and release them under
1655 * GNU GPL.
1656 *
1657 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1658 * and Adar II is 14. In a non-leap year, Adar is 6.
1659 *
1660 * @param string $ts
1661 *
1662 * @return string
1663 */
1665 # Parse date
1670 # Calculate Hebrew year
1673 # Month number when September = 1, August = 12
1676 # Next year
1680 }
1682 # Calculate day of year from 1 September
1686 # February
1688 # Check if the year is leap
1691 }
1696 }
1697 }
1699 # Calculate the start of the Hebrew year
1702 # Calculate next year's start
1704 # Day is before the start of the year - it is the previous year
1705 # Next year's start
1707 # Previous year
1710 # Add days since previous year's 1 September
1713 # Leap year
1715 }
1716 # Start of the new (previous) year
1719 # Next year's start
1721 }
1723 # Calculate Hebrew day of year
1726 # Difference between year's days
1728 # Add 12 (or 13 for leap years) days to ignore the difference between
1729 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1730 # difference is only about the year type
1735 }
1737 # Check the year pattern, and is leap year
1738 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1739 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1740 # and non-leap years
1742 # Check if leap year
1745 # Calculate day in the month from number of day in the Hebrew year
1746 # Don't check Adar - if the day is not in Adar, we will stop before;
1747 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1752 # Calculate days in this month
1754 # Adar in a leap year
1756 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1759 # Day in Adar I
1762 # Subtract the days of Adar I
1764 # Try Adar II
1767 # Day in Adar II
1769 }
1770 }
1771 }
1773 # Cheshvan in a complete year (otherwise as the rule below)
1776 # Kislev in an incomplete year (otherwise as the rule below)
1779 # Odd months have 30 days, even have 29
1781 }
1783 # In the current month
1786 # Subtract the days of the current month
1788 # Try in the next month
1790 }
1791 }
1794 }
1796 /**
1797 * This calculates the Hebrew year start, as days since 1 September.
1798 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1799 * Used for Hebrew date.
1800 *
1801 * @param int $year
1802 *
1803 * @return string
1804 */
1811 }
1815 }
1825 }
1829 }
1831 /**
1832 * Algorithm to convert Gregorian dates to Thai solar dates,
1833 * Minguo dates or Minguo dates.
1834 *
1835 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1836 * http://en.wikipedia.org/wiki/Minguo_calendar
1837 * http://en.wikipedia.org/wiki/Japanese_era_name
1838 *
1839 * @param string $ts 14-character timestamp
1840 * @param string $cName Calender name
1841 * @return array Converted year, month, day
1842 */
1849 # Thai solar dates
1850 # Add 543 years to the Gregorian calendar
1851 # Months and days are identical
1854 # Minguo dates
1855 # Deduct 1911 years from the Gregorian calendar
1856 # Months and days are identical
1859 # Nengō dates up to Meiji period
1860 # Deduct years from the Gregorian calendar
1861 # depending on the nengo periods
1862 # Months and days are identical
1866 ) {
1867 # Meiji period
1872 }
1880 ) {
1881 # Taishō period
1886 }
1892 ) {
1893 # Shōwa period
1898 }
1901 # Heisei period
1906 }
1908 }
1911 }
1914 }
1916 /**
1917 * Roman number formatting up to 10000
1918 *
1919 * @param int $num
1920 *
1921 * @return string
1922 */
1930 );
1935 }
1941 }
1943 }
1945 }
1947 /**
1948 * Hebrew Gematria number formatting up to 9999
1949 *
1950 * @param int $num
1951 *
1952 * @return string
1953 */
1960 );
1965 }
1977 }
1978 }
1979 }
1981 }
1987 }
2006 }
2008 }
2010 /**
2011 * Used by date() and time() to adjust the time output.
2012 *
2013 * @param string $ts The time in date('YmdHis') format
2014 * @param mixed $tz Adjust the time by this amount (default false, mean we
2015 * get user timecorrection setting)
2016 * @return int
2017 */
2023 }
2036 }
2037 # Unrecognized timezone, default to 'Offset' with the stored offset.
2039 }
2042 # Global offset in minutes.
2054 }
2057 }
2058 }
2060 # No difference ? Return time unchanged
2063 }
2066 # Generate an adjusted date; take advantage of the fact that mktime
2067 # will normalize out-of-range values so we don't have to split $minDiff
2068 # into hours and minutes.
2081 }
2083 /**
2084 * This is meant to be used by time(), date(), and timeanddate() to get
2085 * the date preference they're supposed to use, it should be used in
2086 * all children.
2087 *
2088 *<code>
2089 * function timeanddate([...], $format = true) {
2090 * $datePreference = $this->dateFormat($format);
2091 * [...]
2092 * }
2093 *</code>
2094 *
2095 * @param int|string|bool $usePrefs If true, the user's preference is used
2096 * if false, the site/language default is used
2097 * if int/string, assumed to be a format.
2098 * @return string
2099 */
2108 }
2111 }
2113 // return int
2116 }
2119 }
2121 /**
2122 * Get a format string for a given type and preference
2123 * @param string $type May be date, time or both
2124 * @param string $pref The format name as it appears in Messages*.php
2125 *
2126 * @since 1.22 New type 'pretty' that provides a more readable timestamp format
2127 *
2128 * @return string
2129 */
2140 }
2145 }
2146 }
2148 }
2150 }
2152 /**
2153 * @param string $ts The time format which needs to be turned into a
2154 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2155 * @param bool $adj Whether to adjust the time output according to the
2156 * user configured offset ($timecorrection)
2157 * @param mixed $format True to use user's date format preference
2158 * @param string|bool $timecorrection The time offset as returned by
2159 * validateTimeZone() in Special:Preferences
2160 * @return string
2161 */
2166 }
2169 }
2171 /**
2172 * @param string $ts The time format which needs to be turned into a
2173 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2174 * @param bool $adj Whether to adjust the time output according to the
2175 * user configured offset ($timecorrection)
2176 * @param mixed $format True to use user's date format preference
2177 * @param string|bool $timecorrection The time offset as returned by
2178 * validateTimeZone() in Special:Preferences
2179 * @return string
2180 */
2185 }
2188 }
2190 /**
2191 * @param string $ts The time format which needs to be turned into a
2192 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2193 * @param bool $adj Whether to adjust the time output according to the
2194 * user configured offset ($timecorrection)
2195 * @param mixed $format What format to return, if it's false output the
2196 * default one (default true)
2197 * @param string|bool $timecorrection The time offset as returned by
2198 * validateTimeZone() in Special:Preferences
2199 * @return string
2200 */
2205 }
2208 }
2210 /**
2211 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2212 *
2213 * @since 1.20
2214 *
2215 * @param int $seconds The amount of seconds.
2216 * @param array $chosenIntervals The intervals to enable.
2217 *
2218 * @return string
2219 */
2226 // Messages: duration-seconds, duration-minutes, duration-hours, duration-days, duration-weeks,
2227 // duration-years, duration-decades, duration-centuries, duration-millennia
2230 }
2233 }
2235 /**
2236 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2237 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2238 *
2239 * @since 1.20
2240 *
2241 * @param int $seconds The amount of seconds.
2242 * @param array $chosenIntervals The intervals to enable.
2243 *
2244 * @return array
2245 */
2256 'seconds'
2257 );
2258 }
2272 }
2273 }
2276 }
2278 /**
2279 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2280 *
2281 * @param string $type Can be 'date', 'time' or 'both'
2282 * @param string $ts The time format which needs to be turned into a
2283 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2284 * @param User $user User object used to get preferences for timezone and format
2285 * @param array $options Array, can contain the following keys:
2286 * - 'timecorrection': time correction, can have the following values:
2287 * - true: use user's preference
2288 * - false: don't use time correction
2289 * - int: value of time correction in minutes
2290 * - 'format': format to use, can have the following values:
2291 * - true: use user's preference
2292 * - false: use default preference
2293 * - string: format to use
2294 * @since 1.19
2295 * @return string
2296 */
2305 }
2307 }
2312 }
2315 }
2317 /**
2318 * Get the formatted date for the given timestamp and formatted for
2319 * the given user.
2320 *
2321 * @param mixed $ts Mixed: the time format which needs to be turned into a
2322 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2323 * @param User $user User object used to get preferences for timezone and format
2324 * @param array $options Array, can contain the following keys:
2325 * - 'timecorrection': time correction, can have the following values:
2326 * - true: use user's preference
2327 * - false: don't use time correction
2328 * - int: value of time correction in minutes
2329 * - 'format': format to use, can have the following values:
2330 * - true: use user's preference
2331 * - false: use default preference
2332 * - string: format to use
2333 * @since 1.19
2334 * @return string
2335 */
2338 }
2340 /**
2341 * Get the formatted time for the given timestamp and formatted for
2342 * the given user.
2343 *
2344 * @param mixed $ts The time format which needs to be turned into a
2345 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2346 * @param User $user User object used to get preferences for timezone and format
2347 * @param array $options Array, can contain the following keys:
2348 * - 'timecorrection': time correction, can have the following values:
2349 * - true: use user's preference
2350 * - false: don't use time correction
2351 * - int: value of time correction in minutes
2352 * - 'format': format to use, can have the following values:
2353 * - true: use user's preference
2354 * - false: use default preference
2355 * - string: format to use
2356 * @since 1.19
2357 * @return string
2358 */
2361 }
2363 /**
2364 * Get the formatted date and time for the given timestamp and formatted for
2365 * the given user.
2366 *
2367 * @param mixed $ts 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 * Convert an MWTimestamp into a pretty human-readable timestamp using
2388 * the given user preferences and relative base time.
2389 *
2390 * DO NOT USE THIS FUNCTION DIRECTLY. Instead, call MWTimestamp::getHumanTimestamp
2391 * on your timestamp object, which will then call this function. Calling
2392 * this function directly will cause hooks to be skipped over.
2393 *
2394 * @see MWTimestamp::getHumanTimestamp
2395 * @param MWTimestamp $ts Timestamp to prettify
2396 * @param MWTimestamp $relativeTo Base timestamp
2397 * @param User $user User preferences to use
2398 * @return string Human timestamp
2399 * @since 1.22
2400 */
2408 ) {
2409 // Timestamps are in different years: use full timestamp
2410 // Also do full timestamp for future dates
2411 /**
2412 * @todo FIXME: Add better handling of future timestamps.
2413 */
2417 // Timestamps are in same year, but more than 5 days ago: show day and month only.
2421 // Timestamp within the past week: show the day of the week and time
2424 // Messages:
2425 // sunday-at, monday-at, tuesday-at, wednesday-at, thursday-at, friday-at, saturday-at
2431 // Timestamp was yesterday: say 'yesterday' and the time.
2438 // Timestamp was today, but more than 90 minutes ago: say 'today' and the time.
2445 // From here on in, the timestamp was soon enough ago so that we can simply say
2446 // XX units ago, e.g., "2 hours ago" or "5 minutes ago"
2448 // Less than 90 minutes, but more than an hour ago.
2451 // A few minutes ago.
2454 // Less than a minute, but more than 30 sec ago.
2457 // Less than 30 seconds ago.
2459 }
2462 }
2464 /**
2465 * @param string $key
2466 * @return array|null
2467 */
2470 }
2472 /**
2473 * @return array
2474 */
2477 }
2479 /**
2480 * @param string $in
2481 * @param string $out
2482 * @param string $string
2483 * @return string
2484 */
2486 # This is a wrapper for iconv in all languages except esperanto,
2487 # which does some nasty x-conversions beforehand
2489 # Even with //IGNORE iconv can whine about illegal characters in
2490 # *input* string. We just ignore those too.
2491 # REF: http://bugs.php.net/bug.php?id=37166
2492 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2497 }
2499 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2501 /**
2502 * @param array $matches
2503 * @return mixed|string
2504 */
2507 }
2509 /**
2510 * @param array $matches
2511 * @return string
2512 */
2515 }
2517 /**
2518 * @param array $matches
2519 * @return string
2520 */
2524 }
2526 /**
2527 * @param array $matches
2528 * @return string
2529 */
2533 }
2535 /**
2536 * @param array $matches
2537 * @return string
2538 */
2541 }
2543 /**
2544 * @param array $matches
2545 * @return string
2546 */
2550 }
2552 /**
2553 * Make a string's first character uppercase
2554 *
2555 * @param string $str
2556 *
2557 * @return string
2558 */
2566 // fall back to more complex logic in case of multibyte strings
2568 }
2569 }
2571 /**
2572 * Convert a string to uppercase
2573 *
2574 * @param string $str
2575 * @param bool $first
2576 *
2577 * @return string
2578 */
2586 }
2589 }
2596 $str
2597 );
2600 }
2601 }
2602 }
2604 /**
2605 * @param string $str
2606 * @return mixed|string
2607 */
2619 }
2620 }
2622 /**
2623 * @param string $str
2624 * @param bool $first
2625 * @return mixed|string
2626 */
2634 }
2637 }
2644 $str
2645 );
2648 }
2649 }
2650 }
2652 /**
2653 * @param string $str
2654 * @return bool
2655 */
2658 }
2660 /**
2661 * @param string $str
2662 * @return mixed|string
2663 */
2668 // regexp to find first letter in each word (i.e. after each space)
2669 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2671 // function to use to capitalize a single char
2676 $str
2677 );
2682 $str
2683 );
2684 }
2687 }
2688 }
2690 /**
2691 * capitalize words at word breaks
2692 *
2693 * @param string $str
2694 * @return mixed
2695 */
2700 // since \b doesn't work for UTF-8, we explicitely define word break chars
2703 // find first letter after word break
2711 $str
2712 );
2717 $str
2718 );
2719 }
2724 $str
2725 );
2726 }
2727 }
2729 /**
2730 * Return a case-folded representation of $s
2731 *
2732 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2733 * and $s2 are the same except for the case of their characters. It is not
2734 * necessary for the value returned to make sense when displayed.
2735 *
2736 * Do *not* perform any other normalisation in this function. If a caller
2737 * uses this function when it should be using a more general normalisation
2738 * function, then fix the caller.
2739 *
2740 * @param string $s
2741 *
2742 * @return string
2743 */
2746 }
2748 /**
2749 * @param string $s
2750 * @return string
2751 */
2755 }
2758 }
2761 }
2763 /**
2764 * @return array
2765 */
2768 }
2770 /**
2771 * Most writing systems use whitespace to break up words.
2772 * Some languages such as Chinese don't conventionally do this,
2773 * which requires special handling when breaking up words for
2774 * searching etc.
2775 *
2776 * @return bool
2777 */
2780 }
2782 /**
2783 * Some languages such as Chinese require word segmentation,
2784 * Specify such segmentation when overridden in derived class.
2785 *
2786 * @param string $string
2787 * @return string
2788 */
2791 }
2793 /**
2794 * Some languages have special punctuation need to be normalized.
2795 * Make such changes here.
2796 *
2797 * @param string $string
2798 * @return string
2799 */
2802 }
2804 /**
2805 * convert double-width roman characters to single-width.
2806 * range: ff00-ff5f ~= 0020-007f
2807 *
2808 * @param string $string
2809 *
2810 * @return string
2811 */
2821 }
2825 }
2827 /**
2828 * @param string $string
2829 * @param string $pattern
2830 * @return string
2831 */
2836 }
2838 /**
2839 * @param array $termsArray
2840 * @return array
2841 */
2843 # some languages, e.g. Chinese, need to do a conversion
2844 # in order for search results to be displayed correctly
2846 }
2848 /**
2849 * Get the first character of a string.
2850 *
2851 * @param string $s
2852 * @return string
2853 */
2860 $matches
2861 );
2866 }
2868 // Break down Hangul syllables to grab the first jamo
2900 }
2903 }
2904 }
2907 # Some languages may have an alternate char encoding option
2908 # (Esperanto X-coding, Japanese furigana conversion, etc)
2909 # If this language is used as the primary content language,
2910 # an override to the defaults can be set here on startup.
2911 }
2913 /**
2914 * @param string $s
2915 * @return string
2916 */
2918 # For some languages we'll want to explicitly specify
2919 # which characters make it into the edit box raw
2920 # or are converted in some way or another.
2926 }
2927 }
2929 /**
2930 * @param string $s
2931 * @return string
2932 */
2934 # Take the previous into account.
2940 }
2945 }
2946 }
2948 /**
2949 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2950 * also cleans up certain backwards-compatible sequences, converting them
2951 * to the modern Unicode equivalent.
2952 *
2953 * This is language-specific for performance reasons only.
2954 *
2955 * @param string $s
2956 *
2957 * @return string
2958 */
2965 }
2968 }
2970 /**
2971 * Transform a string using serialized data stored in the given file (which
2972 * must be in the serialized subdirectory of $IP). The file contains pairs
2973 * mapping source characters to destination characters.
2974 *
2975 * The data is cached in process memory. This will go faster if you have the
2976 * FastStringSearch extension.
2977 *
2978 * @param string $file
2979 * @param string $string
2980 *
2981 * @throws MWException
2982 * @return string
2983 */
2989 }
2991 }
2993 }
2995 /**
2996 * For right-to-left language support
2997 *
2998 * @return bool
2999 */
3002 }
3004 /**
3005 * Return the correct HTML 'dir' attribute value for this language.
3006 * @return string
3007 */
3010 }
3012 /**
3013 * Return 'left' or 'right' as appropriate alignment for line-start
3014 * for this language's text direction.
3015 *
3016 * Should be equivalent to CSS3 'start' text-align value....
3017 *
3018 * @return string
3019 */
3022 }
3024 /**
3025 * Return 'right' or 'left' as appropriate alignment for line-end
3026 * for this language's text direction.
3027 *
3028 * Should be equivalent to CSS3 'end' text-align value....
3029 *
3030 * @return string
3031 */
3034 }
3036 /**
3037 * A hidden direction mark (LRM or RLM), depending on the language direction.
3038 * Unlike getDirMark(), this function returns the character as an HTML entity.
3039 * This function should be used when the output is guaranteed to be HTML,
3040 * because it makes the output HTML source code more readable. When
3041 * the output is plain text or can be escaped, getDirMark() should be used.
3042 *
3043 * @param bool $opposite Get the direction mark opposite to your language
3044 * @return string
3045 * @since 1.20
3046 */
3050 }
3052 }
3054 /**
3055 * A hidden direction mark (LRM or RLM), depending on the language direction.
3056 * This function produces them as invisible Unicode characters and
3057 * the output may be hard to read and debug, so it should only be used
3058 * when the output is plain text or can be escaped. When the output is
3059 * HTML, use getDirMarkEntity() instead.
3060 *
3061 * @param bool $opposite Get the direction mark opposite to your language
3062 * @return string
3063 */
3069 }
3071 }
3073 /**
3074 * @return array
3075 */
3078 }
3080 /**
3081 * An arrow, depending on the language direction.
3082 *
3083 * @param string $direction The direction of the arrow: forwards (default),
3084 * backwards, left, right, up, down.
3085 * @return string
3086 */
3101 }
3102 }
3104 /**
3105 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
3106 *
3107 * @return bool
3108 */
3111 }
3113 /**
3114 * Get all magic words from cache.
3115 * @return array
3116 */
3119 }
3121 /**
3122 * Run the LanguageGetMagic hook once.
3123 */
3127 }
3132 }
3134 /**
3135 * Fill a MagicWord object with data from here
3136 *
3137 * @param MagicWord $mw
3138 */
3140 // Saves a function call
3143 }
3150 }
3157 }
3158 }
3160 /**
3161 * Add magic words to the extension array
3162 *
3163 * @param array $newWords
3164 */
3171 }
3172 }
3173 }
3175 /**
3176 * Get special page names, as an associative array
3177 * case folded alias => real name
3178 * @return array
3179 */
3181 // Cache aliases because it may be slow to load them
3183 // Initialise array
3188 }
3191 }
3193 /**
3194 * Italic is unsuitable for some languages
3195 *
3196 * @param string $text The text to be emphasized.
3197 * @return string
3198 */
3201 }
3203 /**
3204 * Normally we output all numbers in plain en_US style, that is
3205 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
3206 * point twohundredthirtyfive. However this is not suitable for all
3207 * languages, some such as Punjabi want ੨੯੩,੨੯੫.੨੩੫ and others such as
3208 * Icelandic just want to use commas instead of dots, and dots instead
3209 * of commas like "293.291,235".
3210 *
3211 * An example of this function being called:
3212 * <code>
3213 * wfMessage( 'message' )->numParams( $num )->text()
3214 * </code>
3215 *
3216 * See $separatorTransformTable on MessageIs.php for
3217 * the , => . and . => , implementation.
3218 *
3219 * @todo check if it's viable to use localeconv() for the decimal separator thing.
3220 * @param int|float $number The string to be formatted, should be an integer
3221 * or a floating point number.
3222 * @param bool $nocommafy Set to true for special numbers like dates
3223 * @return string
3224 */
3232 }
3233 }
3239 }
3240 }
3243 }
3245 /**
3246 * Front-end for non-commafied formatNum
3247 *
3248 * @param int|float $number The string to be formatted, should be an integer
3249 * or a floating point number.
3250 * @since 1.21
3251 * @return string
3252 */
3255 }
3257 /**
3258 * @param string $number
3259 * @return string
3260 */
3264 // eliminate empty array values such as ''. (bug 64347)
3267 }
3271 // eliminate empty array values such as ''. (bug 64347)
3274 }
3278 }
3280 /**
3281 * Adds commas to a given number
3282 * @since 1.19
3283 * @param mixed $number
3284 * @return string
3285 */
3290 }
3293 // default grouping is at thousands, use the same for ###,###,### pattern too.
3296 // Ref: http://cldr.unicode.org/translation/number-patterns
3299 // For negative numbers apply the algorithm like positive number and add sign.
3302 }
3310 // the string does not have any number part. Eg: .12345
3312 }
3320 }
3324 // use the last pattern for the rest of the number
3326 }
3329 }
3330 }
3332 }
3333 }
3335 /**
3336 * @return string
3337 */
3340 }
3342 /**
3343 * @return array
3344 */
3347 }
3349 /**
3350 * @return array
3351 */
3354 }
3356 /**
3357 * Take a list of strings and build a locale-friendly comma-separated
3358 * list, using the local comma-separator message.
3359 * The last two strings are chained with an "and".
3360 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3361 *
3362 * @param string[] $l
3363 * @return string
3364 */
3369 }
3375 }
3376 }
3383 }
3384 }
3386 }
3388 /**
3389 * Take a list of strings and build a locale-friendly comma-separated
3390 * list, using the local comma-separator message.
3391 * @param string[] $list Array of strings to put in a comma list
3392 * @return string
3393 */
3397 $list
3398 );
3399 }
3401 /**
3402 * Take a list of strings and build a locale-friendly semicolon-separated
3403 * list, using the local semicolon-separator message.
3404 * @param string[] $list Array of strings to put in a semicolon list
3405 * @return string
3406 */
3410 $list
3411 );
3412 }
3414 /**
3415 * Same as commaList, but separate it with the pipe instead.
3416 * @param string[] $list Array of strings to put in a pipe list
3417 * @return string
3418 */
3422 $list
3423 );
3424 }
3426 /**
3427 * Truncate a string to a specified length in bytes, appending an optional
3428 * string (e.g. for ellipses)
3429 *
3430 * The database offers limited byte lengths for some columns in the database;
3431 * multi-byte character sets mean we need to ensure that only whole characters
3432 * are included, otherwise broken characters can be passed to the user
3433 *
3434 * If $length is negative, the string will be truncated from the beginning
3435 *
3436 * @param string $string String to truncate
3437 * @param int $length Maximum length (including ellipses)
3438 * @param string $ellipsis String to append to the truncated text
3439 * @param bool $adjustLength Subtract length of ellipsis from $length.
3440 * $adjustLength was introduced in 1.18, before that behaved as if false.
3441 * @return string
3442 */
3444 # Use the localized ellipsis character
3447 }
3448 # Check if there is no need to truncate
3453 }
3455 # If ellipsis length is >= $length then we can't apply $adjustLength
3458 # Otherwise, truncate and add ellipsis...
3473 }
3474 }
3475 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3476 # This check is *not* redundant if $adjustLength, due to the single case where
3477 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3482 }
3483 }
3485 /**
3486 * Remove bytes that represent an incomplete Unicode character
3487 * at the end of string (e.g. bytes of the char are missing)
3488 *
3489 * @param string $string
3490 * @return string
3491 */
3497 # We got the first byte only of a multibyte char; remove it.
3502 ) {
3503 # We chopped in the middle of a character; remove it
3505 }
3506 }
3508 }
3510 /**
3511 * Remove bytes that represent an incomplete Unicode character
3512 * at the start of string (e.g. bytes of the char are missing)
3513 *
3514 * @param string $string
3515 * @return string
3516 */
3521 # We chopped in the middle of a character; remove the whole thing
3523 }
3524 }
3526 }
3528 /**
3529 * Truncate a string of valid HTML to a specified length in bytes,
3530 * appending an optional string (e.g. for ellipses), and return valid HTML
3531 *
3532 * This is only intended for styled/linked text, such as HTML with
3533 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3534 * Also, this will not detect things like "display:none" CSS.
3535 *
3536 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3537 *
3538 * @param string $text HTML string to truncate
3539 * @param int $length (zero/positive) Maximum length (including ellipses)
3540 * @param string $ellipsis String to append to the truncated text
3541 * @return string
3542 */
3544 # Use the localized ellipsis character
3547 }
3548 # Check if there is clearly no need to truncate
3553 }
3567 # Consider truncation once the display length has reached the maximim.
3568 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3569 # Check that we're not in the middle of a bracket/entity...
3573 # Save where we are; we will truncate here unless there turn out to
3574 # be so few remaining characters that truncation is not necessary.
3577 }
3579 # String in fact does need truncation, the truncation point was OK.
3584 }
3585 }
3588 }
3590 # Read the next char...
3608 }
3614 // Name found (e.g. "<a href=..."), add on tag attributes...
3616 }
3622 }
3625 // Save state without $ch. We want to *hit* the first
3626 // display char (to get tags) but not *use* it if truncating.
3628 }
3633 // Add the next $max display text chars after this in one swoop...
3638 }
3639 }
3640 }
3641 }
3642 // Close the last tag if left unclosed by bad HTML
3646 }
3648 }
3650 /**
3651 * truncateHtml() helper function
3652 * like strcspn() but adds the skipped chars to $ret
3653 *
3654 * @param string $ret
3655 * @param string $text
3656 * @param string $search
3657 * @param int $start
3658 * @param null|int $len
3659 * @return int
3660 */
3666 }
3671 }
3673 }
3675 /**
3676 * truncateHtml() helper function
3677 * (a) push or pop $tag from $openTags as needed
3678 * (b) clear $tag value
3679 * @param string &$tag Current HTML tag name we are looking at
3680 * @param int $tagType (0-open tag, 1-close tag)
3681 * @param string $lastCh Character before the '>' that ended this tag
3682 * @param array &$openTags Open tag stack (not accounting for $tag)
3683 */
3692 }
3693 }
3695 }
3696 }
3698 /**
3699 * Grammatical transformations, needed for inflected languages
3700 * Invoked by putting {{grammar:case|word}} in a message
3701 *
3702 * @param string $word
3703 * @param string $case
3704 * @return string
3705 */
3710 }
3713 }
3714 /**
3715 * Get the grammar forms for the content language
3716 * @return array Array of grammar forms
3717 * @since 1.20
3718 */
3723 ) {
3725 }
3728 }
3729 /**
3730 * Provides an alternative text depending on specified gender.
3731 * Usage {{gender:username|masculine|feminine|unknown}}.
3732 * username is optional, in which case the gender of current user is used,
3733 * but only in (some) interface messages; otherwise default gender is used.
3734 *
3735 * If no forms are given, an empty string is returned. If only one form is
3736 * given, it will be returned unconditionally. These details are implied by
3737 * the caller and cannot be overridden in subclasses.
3738 *
3739 * If three forms are given, the default is to use the third (unknown) form.
3740 * If fewer than three forms are given, the default is to use the first (masculine) form.
3741 * These details can be overridden in subclasses.
3742 *
3743 * @param string $gender
3744 * @param array $forms
3745 *
3746 * @return string
3747 */
3751 }
3755 }
3758 }
3760 }
3762 /**
3763 * Plural form transformations, needed for some languages.
3764 * For example, there are 3 form of plural in Russian and Polish,
3765 * depending on "count mod 10". See [[w:Plural]]
3766 * For English it is pretty simple.
3767 *
3768 * Invoked by putting {{plural:count|wordform1|wordform2}}
3769 * or {{plural:count|wordform1|wordform2|wordform3}}
3770 *
3771 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3772 *
3773 * @param int $count Non-localized number
3774 * @param array $forms Different plural forms
3775 * @return string Correct form of plural for $count in this language
3776 */
3778 // Handle explicit n=pluralform cases
3782 }
3785 }
3790 }
3792 /**
3793 * Handles explicit plural forms for Language::convertPlural()
3794 *
3795 * In {{PLURAL:$1|0=nothing|one|many}}, 0=nothing will be returned if $1 equals zero.
3796 * If an explicitly defined plural form matches the $count, then
3797 * string value returned, otherwise array returned for further consideration
3798 * by CLDR rules or overridden convertPlural().
3799 *
3800 * @since 1.23
3801 *
3802 * @param int $count Non-localized number
3803 * @param array $forms Different plural forms
3804 *
3805 * @return array|string
3806 */
3813 }
3815 }
3816 }
3818 }
3820 /**
3821 * Checks that convertPlural was given an array and pads it to requested
3822 * amount of forms by copying the last one.
3823 *
3824 * @param array $forms Array of forms given to convertPlural
3825 * @param int $count How many forms should there be at least
3826 * @return array Padded array of forms or an exception if not an array
3827 */
3831 }
3833 }
3835 /**
3836 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3837 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3838 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3839 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3840 * match up with it.
3841 *
3842 * @param string $str The validated block duration in English
3843 * @return string Somehow translated block duration
3844 * @see LanguageFi.php for example implementation
3845 */
3851 }
3852 }
3854 // Since usually only infinite or indefinite is only on list, so try
3855 // equivalents if still here.
3862 }
3863 }
3864 }
3866 // If all else fails, return a standard duration or timestamp description.
3871 // $time is relative to 0 so it's a duration length.
3875 // wfTimestamp() handles 0 as current time instead of epoch.
3879 }
3880 }
3881 }
3883 /**
3884 * languages like Chinese need to be segmented in order for the diff
3885 * to be of any use
3886 *
3887 * @param string $text
3888 * @return string
3889 */
3892 }
3894 /**
3895 * and unsegment to show the result
3896 *
3897 * @param string $text
3898 * @return string
3899 */
3902 }
3904 /**
3905 * Return the LanguageConverter used in the Language
3906 *
3907 * @since 1.19
3908 * @return LanguageConverter
3909 */
3912 }
3914 /**
3915 * convert text to all supported variants
3916 *
3917 * @param string $text
3918 * @return array
3919 */
3922 }
3924 /**
3925 * convert text to different variants of a language.
3926 *
3927 * @param string $text
3928 * @return string
3929 */
3932 }
3934 /**
3935 * Convert a Title object to a string in the preferred variant
3936 *
3937 * @param Title $title
3938 * @return string
3939 */
3942 }
3944 /**
3945 * Convert a namespace index to a string in the preferred variant
3946 *
3947 * @param int $ns
3948 * @return string
3949 */
3952 }
3954 /**
3955 * Check if this is a language with variants
3956 *
3957 * @return bool
3958 */
3961 }
3963 /**
3964 * Check if the language has the specific variant
3965 *
3966 * @since 1.19
3967 * @param string $variant
3968 * @return bool
3969 */
3972 }
3974 /**
3975 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3976 *
3977 * @param string $text
3978 * @return string
3979 * @deprecated since 1.22 is no longer used
3980 */
3983 }
3985 /**
3986 * Perform output conversion on a string, and encode for safe HTML output.
3987 * @param string $text Text to be converted
3988 * @param bool $isTitle Whether this conversion is for the article title
3989 * @return string
3990 * @todo this should get integrated somewhere sane
3991 */
3994 }
3996 /**
3997 * @param string $key
3998 * @return string
3999 */
4002 }
4004 /**
4005 * Get the list of variants supported by this language
4006 * see sample implementation in LanguageZh.php
4007 *
4008 * @return array An array of language codes
4009 */
4012 }
4014 /**
4015 * @return string
4016 */
4019 }
4021 /**
4022 * @return string
4023 */
4026 }
4028 /**
4029 * @return string
4030 */
4033 }
4035 /**
4036 * If a language supports multiple variants, it is
4037 * possible that non-existing link in one variant
4038 * actually exists in another variant. this function
4039 * tries to find it. See e.g. LanguageZh.php
4040 * The input parameters may be modified upon return
4041 *
4042 * @param string &$link The name of the link
4043 * @param Title &$nt The title object of the link
4044 * @param bool $ignoreOtherCond To disable other conditions when
4045 * we need to transclude a template or update a category's link
4046 */
4049 }
4051 /**
4052 * returns language specific options used by User::getPageRenderHash()
4053 * for example, the preferred language variant
4054 *
4055 * @return string
4056 */
4059 }
4061 /**
4062 * For languages that support multiple variants, the title of an
4063 * article may be displayed differently in different variants. this
4064 * function returns the apporiate title defined in the body of the article.
4065 *
4066 * @return string
4067 */
4070 }
4072 /**
4073 * Prepare external link text for conversion. When the text is
4074 * a URL, it shouldn't be converted, and it'll be wrapped in
4075 * the "raw" tag (-{R| }-) to prevent conversion.
4076 *
4077 * This function is called "markNoConversion" for historical
4078 * reasons.
4079 *
4080 * @param string $text Text to be used for external link
4081 * @param bool $noParse Wrap it without confirming it's a real URL first
4082 * @return string The tagged text
4083 */
4085 // Excluding protocal-relative URLs may avoid many false positives.
4090 }
4091 }
4093 /**
4094 * A regular expression to match legal word-trailing characters
4095 * which should be merged onto a link of the form [[foo]]bar.
4096 *
4097 * @return string
4098 */
4101 }
4103 /**
4104 * A regular expression character set to match legal word-prefixing
4105 * characters which should be merged onto a link of the form foo[[bar]].
4106 *
4107 * @return string
4108 */
4111 }
4113 /**
4114 * @deprecated since 1.24, will be removed in 1.25
4115 * @return Language
4116 */
4120 }
4122 /**
4123 * Get the "parent" language which has a converter to convert a "compatible" language
4124 * (in another variant) to this language (eg. zh for zh-cn, but not en for en-gb).
4125 *
4126 * @return Language|null
4127 * @since 1.22
4128 */
4132 }
4139 }
4144 }
4148 }
4150 /**
4151 * Get the RFC 3066 code for this language object
4152 *
4153 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4154 * htmlspecialchars() or similar
4155 *
4156 * @return string
4157 */
4160 }
4162 /**
4163 * Get the code in Bcp47 format which we can use
4164 * inside of html lang="" tags.
4165 *
4166 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
4167 * htmlspecialchars() or similar.
4168 *
4169 * @since 1.19
4170 * @return string
4171 */
4175 }
4177 }
4179 /**
4180 * @param string $code
4181 */
4184 // Ensure we don't leave incorrect cached data lying around
4187 }
4189 /**
4190 * Get the name of a file for a certain language code
4191 * @param string $prefix Prepend this to the filename
4192 * @param string $code Language code
4193 * @param string $suffix Append this to the filename
4194 * @throws MWException
4195 * @return string $prefix . $mangledCode . $suffix
4196 */
4200 }
4203 }
4205 /**
4206 * Get the language code from a file name. Inverse of getFileName()
4207 * @param string $filename $prefix . $languageCode . $suffix
4208 * @param string $prefix Prefix before the language code
4209 * @param string $suffix Suffix after the language code
4210 * @return string Language code, or false if $prefix or $suffix isn't found
4211 */
4212 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
4218 }
4220 }
4222 /**
4223 * @param string $code
4224 * @return string
4225 */
4231 }
4233 /**
4234 * @param string $code
4235 * @return string
4236 * @since 1.23
4237 */
4243 }
4246 }
4248 /**
4249 * @param string $code
4250 * @return string
4251 */
4255 }
4257 /**
4258 * Get the first fallback for a given language.
4259 *
4260 * @param string $code
4261 *
4262 * @return bool|string
4263 */
4271 }
4272 }
4274 /**
4275 * Get the ordered list of fallback languages.
4276 *
4277 * @since 1.19
4278 * @param string $code Language code
4279 * @return array
4280 */
4289 }
4291 }
4292 }
4294 /**
4295 * Get the ordered list of fallback languages, ending with the fallback
4296 * language chain for the site language.
4297 *
4298 * @since 1.22
4299 * @param string $code Language code
4300 * @return array Array( fallbacks, site fallbacks )
4301 */
4305 // Usually, we will only store a tiny number of fallback chains, so we
4306 // keep them in static memory.
4312 // Append the site's fallback chain, including the site language itself
4316 // Eliminate any languages already included in the chain
4320 }
4322 }
4324 /**
4325 * Get all messages for a given language
4326 * WARNING: this may take a long time. If you just need all message *keys*
4327 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
4328 *
4329 * @param string $code
4330 *
4331 * @return array
4332 */
4335 }
4337 /**
4338 * Get a message for a given language
4339 *
4340 * @param string $key
4341 * @param string $code
4342 *
4343 * @return string
4344 */
4347 }
4349 /**
4350 * Get all message keys for a given language. This is a faster alternative to
4351 * array_keys( Language::getMessagesFor( $code ) )
4352 *
4353 * @since 1.19
4354 * @param string $code Language code
4355 * @return array Array of message keys (strings)
4356 */
4359 }
4361 /**
4362 * @param string $talk
4363 * @return mixed
4364 */
4368 }
4373 # Allow grammar transformations
4374 # Allowing full message-style parsing would make simple requests
4375 # such as action=raw much more expensive than they need to be.
4376 # This will hopefully cover most cases.
4380 }
4382 /**
4383 * @param string $m
4384 * @return string
4385 */
4388 }
4390 /**
4391 * @throws MWException
4392 * @return array
4393 */
4398 }
4405 }
4410 }
4412 /**
4413 * Decode an expiry (block, protection, etc) which has come from the DB
4414 *
4415 * @todo FIXME: why are we returnings DBMS-dependent strings???
4416 *
4417 * @param string $expiry Database expiry String
4418 * @param bool|int $format True to process using language functions, or TS_ constant
4419 * to return the expiry in a given timestamp
4420 * @return string
4421 * @since 1.18
4422 */
4427 }
4437 }
4438 }
4440 /**
4441 * @todo Document
4442 * @param int|float $seconds
4443 * @param array $format Optional
4444 * If $format['avoid'] === 'avoidseconds': don't mention seconds if $seconds >= 1 hour.
4445 * If $format['avoid'] === 'avoidminutes': don't mention seconds/minutes if $seconds > 48 hours.
4446 * If $format['noabbrevs'] is true: use 'seconds' and friends instead of 'seconds-abbrev'
4447 * and friends.
4448 * For backwards compatibility, $format may also be one of the strings 'avoidseconds'
4449 * or 'avoidminutes'.
4450 * @return string
4451 */
4455 }
4458 }
4461 }
4483 }
4494 }
4498 }
4504 }
4512 }
4522 }
4526 }
4536 }
4537 }
4539 }
4541 /**
4542 * Format a bitrate for output, using an appropriate
4543 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to
4544 * the magnitude in question.
4545 *
4546 * This use base 1000. For base 1024 use formatSize(), for another base
4547 * see formatComputingNumbers().
4548 *
4549 * @param int $bps
4550 * @return string
4551 */
4554 }
4556 /**
4557 * @param int $size Size of the unit
4558 * @param int $boundary Size boundary (1000, or 1024 in most cases)
4559 * @param string $messageKey Message key to be uesd
4560 * @return string
4561 */
4566 );
4567 }
4575 }
4577 // For small sizes no decimal places necessary
4580 // For MB and bigger two decimal places are smarter
4582 }
4588 }
4590 /**
4591 * Format a size in bytes for output, using an appropriate
4592 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4593 *
4594 * This method use base 1024. For base 1000 use formatBitrate(), for
4595 * another base see formatComputingNumbers()
4596 *
4597 * @param int $size Size to format
4598 * @return string Plain text (not HTML)
4599 */
4602 }
4604 /**
4605 * Make a list item, used by various special pages
4606 *
4607 * @param string $page Page link
4608 * @param string $details Text between brackets
4609 * @param bool $oppositedm Add the direction mark opposite to your
4610 * language, to display text properly
4611 * @return string
4612 */
4619 }
4621 /**
4622 * Generate (prev x| next x) (20|50|100...) type links for paging
4623 *
4624 * @param Title $title Title object to link
4625 * @param int $offset
4626 * @param int $limit
4627 * @param array $query Optional URL query parameter string
4628 * @param bool $atend Optional param for specified if this is the last page
4629 * @return string
4630 */
4633 ) {
4634 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4636 # Make 'previous' link
4637 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4643 }
4645 # Make 'next' link
4646 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4652 }
4654 # Make links to set number of items per page
4659 }
4663 }
4665 /**
4666 * Helper function for viewPrevNext() that generates links
4667 *
4668 * @param Title $title Title object to link
4669 * @param int $offset
4670 * @param int $limit
4671 * @param array $query Extra query parameters
4672 * @param string $link Text to use for the link; will be escaped
4673 * @param string $tooltipMsg Name of the message to use as tooltip
4674 * @param string $class Value of the "class" attribute of the link
4675 * @return string HTML fragment
4676 */
4679 ) {
4686 }
4688 /**
4689 * Get the conversion rule title, if any.
4690 *
4691 * @return string
4692 */
4695 }
4697 /**
4698 * Get the compiled plural rules for the language
4699 * @since 1.20
4700 * @return array Associative array with plural form, and plural rule as key-value pairs
4701 */
4707 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4710 }
4711 }
4712 }
4714 }
4716 /**
4717 * Get the plural rules for the language
4718 * @since 1.20
4719 * @return array Associative array with plural form number and plural rule as key-value pairs
4720 */
4729 }
4730 }
4731 }
4733 }
4735 /**
4736 * Get the plural rule types for the language
4737 * @since 1.22
4738 * @return array Associative array with plural form number and plural rule type as key-value pairs
4739 */
4745 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4748 }
4749 }
4750 }
4752 }
4754 /**
4755 * Find the index number of the plural rule appropriate for the given number
4756 * @param int $number
4757 * @return int The index number of the plural rule
4758 */
4763 }
4765 /**
4766 * Find the plural rule type appropriate for the given number
4767 * For example, if the language is set to Arabic, getPluralType(5) should
4768 * return 'few'.
4769 * @since 1.22
4770 * @param int $number
4771 * @return string The name of the plural rule type, e.g. one, two, few, many
4772 */
4780 }
4781 }
4782 }