| blob | df1b156a83ab4973713d3f35f664005347d9f3bb |
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 }
33 # Read language names
39 }
41 /**
42 * a fake language converter
43 *
44 * @ingroup Language
45 */
47 /**
48 * @var Language
49 */
69 }
71 /**
72 * Internationalisation code
73 * @ingroup Language
74 */
77 /**
78 * @var LanguageConverter
79 */
91 /**
92 * ReplacementArray object caches
93 */
96 /**
97 * @var LocalisationCache
98 */
106 );
110 );
115 'december'
116 );
120 'december-gen'
121 );
125 );
132 );
140 );
148 );
155 );
157 /**
158 * @since 1.20
159 * @var array
160 */
171 );
173 /**
174 * Get a cached or new language object for a given language code
175 * @param $code String
176 * @return Language
177 */
183 }
185 // get the language object to process
190 // merge the language object in to get it up front in the cache
192 // get rid of the oldest ones in case we have an overflow
196 }
198 /**
199 * Create a language object for a given language code
200 * @param $code String
201 * @throws MWException
202 * @return Language
203 */
205 // Protect against path traversal below
208 {
210 }
213 // It's not possible to customise this code with class files, so
214 // just return a Language object. This is to support uselang= hacks.
218 }
220 // Check if there is a language class for the code
226 }
228 // Keep trying the fallback list until we find an existing class
233 }
241 }
242 }
245 }
247 /**
248 * Checks whether any localisation is available for that language tag
249 * in MediaWiki (MessagesXx.php exists).
250 *
251 * @param string $code Language tag (in lower case)
252 * @return bool Whether language is supported
253 * @since 1.21
254 */
257 }
259 /**
260 * Returns true if a language code string is a well-formed language tag
261 * according to RFC 5646.
262 * This function only checks well-formedness; it doesn't check that
263 * language, script or variant codes actually exist in the repositories.
264 *
265 * Based on regexes by Mark Davis of the Unicode Consortium:
266 * http://unicode.org/repos/cldr/trunk/tools/java/org/unicode/cldr/util/data/langtagRegex.txt
267 *
268 * @param $code string
269 * @param $lenient boolean Whether to allow '_' as separator. The default is only '-'.
270 *
271 * @return bool
272 * @since 1.21
273 */
289 # Define certain grandfathered codes, since otherwise the regex is pretty useless.
290 # Since these are limited, this is safe even later changes to the registry --
291 # the only oddity is that it might change the type of the tag, and thus
292 # the results from the capturing groups.
293 # http://www.iana.org/assignments/language-subtag-registry
311 # The final breakdown, with capturing groups for each of these components
312 # The variants, extensions, grandfathered, and private-use may have interior '-'
317 }
319 /**
320 * Returns true if a language code string is of a valid form, whether or
321 * not it exists. This includes codes which are used solely for
322 * customisation via the MediaWiki namespace.
323 *
324 * @param $code string
325 *
326 * @return bool
327 */
329 return
330 // People think language codes are html safe, so enforce it.
331 // Ideally we should only allow a-zA-Z0-9-
332 // but, .+ and other chars are often used for {{int:}} hacks
333 // see bugs 37564, 37587, 36938
336 }
338 /**
339 * Returns true if a language code is of a valid form for the purposes of
340 * internal customisation of MediaWiki, via Messages*.php.
341 *
342 * @param $code string
343 *
344 * @throws MWException
345 * @since 1.18
346 * @return bool
347 */
355 }
358 }
361 }
363 /**
364 * Returns true if a language code is an IETF tag known to MediaWiki.
365 *
366 * @param $code string
367 *
368 * @since 1.21
369 * @return bool
370 */
376 }
380 ) {
382 }
385 }
387 /**
388 * @param $code
389 * @return String Name of the language class
390 */
396 }
397 }
399 /**
400 * Includes language class files
401 *
402 * @param $class string Name of the language class
403 */
409 }
414 }
415 }
416 }
418 /**
419 * Get the LocalisationCache instance
420 *
421 * @return LocalisationCache
422 */
428 }
430 }
434 // Set the code to the name of the descendant
439 }
441 }
443 /**
444 * Reduce memory usage
445 */
449 }
450 }
452 /**
453 * Hook which will be called if this is the content language.
454 * Descendants can use this to register hook functions or modify globals
455 */
458 /**
459 * Same as getFallbacksFor for current language.
460 * @return array|bool
461 * @deprecated in 1.19
462 */
466 }
468 /**
469 * @return array
470 * @since 1.19
471 */
474 }
476 /**
477 * Exports $wgBookstoreListEn
478 * @return array
479 */
482 }
484 /**
485 * Returns an array of localised namespaces indexed by their numbers. If the namespace is not
486 * available in localised form, it will be included in English.
487 *
488 * @return array
489 */
506 }
508 # Sometimes a language will be localised but not actually exist on this wiki.
512 }
513 }
515 # The above mixing may leave namespaces out of canonical order.
516 # Re-order by namespace ID number...
520 }
522 }
524 /**
525 * Arbitrarily set all of the namespace names at once. Mainly used for testing
526 * @param $namespaces Array of namespaces (id => name)
527 */
531 }
533 /**
534 * Resets all of the namespace caches. Mainly used for testing
535 */
540 }
542 /**
543 * A convenience function that returns the same thing as
544 * getNamespaces() except with the array values changed to ' '
545 * where it found '_', useful for producing output to be displayed
546 * e.g. in <select> forms.
547 *
548 * @return array
549 */
554 }
556 }
558 /**
559 * Get a namespace value by key
560 * <code>
561 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
562 * echo $mw_ns; // prints 'MediaWiki'
563 * </code>
564 *
565 * @param $index Int: the array key of the namespace to return
566 * @return mixed, string if the namespace value exists, otherwise false
567 */
571 }
573 /**
574 * A convenience function that returns the same thing as
575 * getNsText() except with '_' changed to ' ', useful for
576 * producing output.
577 *
578 * <code>
579 * $mw_ns = $wgContLang->getFormattedNsText( NS_MEDIAWIKI_TALK );
580 * echo $mw_ns; // prints 'MediaWiki talk'
581 * </code>
582 *
583 * @param int $index The array key of the namespace to return
584 * @return string Namespace name without underscores (empty string if namespace does not exist)
585 */
589 }
591 /**
592 * Returns gender-dependent namespace alias if available.
593 * @param $index Int: namespace index
594 * @param $gender String: gender key (male, female... )
595 * @return String
596 * @since 1.18
597 */
601 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
603 }
605 /**
606 * Whether this language makes distinguishes genders for example in
607 * namespaces.
608 * @return bool
609 * @since 1.18
610 */
614 // $wgExtraGenderNamespaces overrides everything
616 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
617 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
618 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
621 // Check what is in i18n files
624 }
625 }
627 /**
628 * Get a namespace key by value, case insensitive.
629 * Only matches namespace names for the current language, not the
630 * canonical ones defined in Namespace.php.
631 *
632 * @param $text String
633 * @return mixed An integer if $text is a valid value otherwise false
634 */
639 }
641 /**
642 * @return array
643 */
655 }
656 }
657 }
660 $genders = $wgExtraGenderNamespaces + (array)self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
664 }
665 }
668 }
670 }
672 /**
673 * @return array
674 */
678 # Put namespace names and aliases into a hashtable.
679 # If this is too slow, then we should arrange it so that it is done
680 # before caching. The catch is that at pre-cache time, the above
681 # class-specific fixup hasn't been done.
685 }
688 }
692 }
693 }
694 }
696 }
698 /**
699 * Get a namespace key by value, case insensitive. Canonical namespace
700 * names override custom ones defined for the current language.
701 *
702 * @param $text String
703 * @return mixed An integer if $text is a valid value otherwise false
704 */
710 }
713 }
715 /**
716 * short names for language variants used for language conversion links.
717 *
718 * @param $code String
719 * @param $usemsg bool Use the "variantname-xyz" message if it exists
720 * @return string
721 */
726 }
731 # otherwise, output the language code
733 }
734 }
736 /**
737 * @param $name string
738 * @return string
739 */
744 }
746 }
748 /**
749 * @return array
750 */
753 }
755 /**
756 * @return array
757 */
760 }
762 /**
763 * @return array|string
764 */
772 }
773 }
775 /**
776 * @return array
777 */
780 }
782 /**
783 * @param $image
784 * @return array|null
785 */
788 }
790 /**
791 * @return array
792 */
795 }
797 /**
798 * @param $tog
799 * @return string
800 */
803 }
805 /**
806 * Get native language names, indexed by code.
807 * Only those defined in MediaWiki, no other data like CLDR.
808 * If $customisedOnly is true, only returns codes with a messages file
809 *
810 * @param $customisedOnly bool
811 *
812 * @return array
813 * @deprecated in 1.20, use fetchLanguageNames()
814 */
817 }
819 /**
820 * Get translated language names. This is done on best effort and
821 * by default this is exactly the same as Language::getLanguageNames.
822 * The CLDR extension provides translated names.
823 * @param $code String Language code.
824 * @return Array language code => language name
825 * @since 1.18.0
826 * @deprecated in 1.20, use fetchLanguageNames()
827 */
830 }
832 /**
833 * Get an array of language names, indexed by code.
834 * @param $inLanguage null|string: Code of language in which to return the names
835 * Use null for autonyms (native names)
836 * @param $include string:
837 * 'all' all available languages
838 * 'mw' only if the language is defined in MediaWiki or wgExtraLanguageNames (default)
839 * 'mwfile' only if the language is in 'mw' *and* has a message file
840 * @return array: language code => language name
841 * @since 1.20
842 */
849 }
854 # TODO: also include when $inLanguage is null, when this code is more efficient
856 }
860 # - Prefer own MediaWiki native name when not using the hook
861 # - For other names just add if not added through the hook
864 }
865 }
869 }
875 }
879 # We do this using a foreach over the codes instead of a directory
880 # loop so that messages files in extensions will work correctly.
884 }
885 }
887 }
888 # 'mw' option; default if it's not one of the other two options (all/mwfile)
890 }
892 /**
893 * @param $code string: The code of the language for which to get the name
894 * @param $inLanguage null|string: Code of language in which to return the name (null for autonyms)
895 * @param $include string: 'all', 'mw' or 'mwfile'; see fetchLanguageNames()
896 * @return string: Language name or empty
897 * @since 1.20
898 */
902 }
904 /**
905 * Get a message from the MediaWiki namespace.
906 *
907 * @param $msg String: message name
908 * @return string
909 */
912 }
914 /**
915 * Get the native language name of $code.
916 * Only if defined in MediaWiki, no other data like CLDR.
917 * @param $code string
918 * @return string
919 * @deprecated in 1.20, use fetchLanguageName()
920 */
923 }
925 /**
926 * @param $key string
927 * @return string
928 */
931 }
933 /**
934 * @return array
935 */
940 }
942 }
944 /**
945 * @param $key string
946 * @return string
947 */
950 }
952 /**
953 * @param $key string
954 * @return string
955 */
958 }
960 /**
961 * @return array
962 */
967 }
969 }
971 /**
972 * @param $key string
973 * @return string
974 */
977 }
979 /**
980 * @param $key string
981 * @return string
982 */
985 }
987 /**
988 * @param $key string
989 * @return string
990 */
993 }
995 /**
996 * @param $key string
997 * @return string
998 */
1001 }
1003 /**
1004 * @param $key string
1005 * @return string
1006 */
1009 }
1011 /**
1012 * @param $key string
1013 * @return string
1014 */
1017 }
1019 /**
1020 * This is a workalike of PHP's date() function, but with better
1021 * internationalisation, a reduced set of format characters, and a better
1022 * escaping format.
1023 *
1024 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrUeIOPTZ. See
1025 * the PHP manual for definitions. There are a number of extensions, which
1026 * start with "x":
1027 *
1028 * xn Do not translate digits of the next numeric format character
1029 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
1030 * xr Use roman numerals for the next numeric format character
1031 * xh Use hebrew numerals for the next numeric format character
1032 * xx Literal x
1033 * xg Genitive month name
1034 *
1035 * xij j (day number) in Iranian calendar
1036 * xiF F (month name) in Iranian calendar
1037 * xin n (month number) in Iranian calendar
1038 * xiy y (two digit year) in Iranian calendar
1039 * xiY Y (full year) in Iranian calendar
1040 *
1041 * xjj j (day number) in Hebrew calendar
1042 * xjF F (month name) in Hebrew calendar
1043 * xjt t (days in month) in Hebrew calendar
1044 * xjx xg (genitive month name) in Hebrew calendar
1045 * xjn n (month number) in Hebrew calendar
1046 * xjY Y (full year) in Hebrew calendar
1047 *
1048 * xmj j (day number) in Hijri calendar
1049 * xmF F (month name) in Hijri calendar
1050 * xmn n (month number) in Hijri calendar
1051 * xmY Y (full year) in Hijri calendar
1052 *
1053 * xkY Y (full year) in Thai solar calendar. Months and days are
1054 * identical to the Gregorian calendar
1055 * xoY Y (full year) in Minguo calendar or Juche year.
1056 * Months and days are identical to the
1057 * Gregorian calendar
1058 * xtY Y (full year) in Japanese nengo. Months and days are
1059 * identical to the Gregorian calendar
1060 *
1061 * Characters enclosed in double quotes will be considered literal (with
1062 * the quotes themselves removed). Unmatched quotes will be considered
1063 * literal quotes. Example:
1064 *
1065 * "The month is" F => The month is January
1066 * i's" => 20'11"
1067 *
1068 * Backslash escaping is also supported.
1069 *
1070 * Input timestamp is assumed to be pre-normalized to the desired local
1071 * time zone, if any. Note that the format characters crUeIOPTZ will assume
1072 * $ts is UTC if $zone is not given.
1073 *
1074 * @param $format String
1075 * @param $ts String: 14-character timestamp
1076 * YYYYMMDDHHMMSS
1077 * 01234567890123
1078 * @param $zone DateTimeZone: Timezone of $ts
1079 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
1080 *
1081 * @return string
1082 */
1101 }
1103 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
1105 }
1129 }
1139 );
1140 }
1149 }
1155 }
1161 }
1168 );
1169 }
1178 }
1184 }
1190 }
1205 }
1211 }
1217 }
1223 }
1232 }
1238 }
1244 }
1250 }
1256 }
1262 }
1271 }
1306 // Pass through string from $dateTimeObj->format()
1310 );
1311 }
1324 // Pass through number from $dateTimeObj->format()
1328 );
1329 }
1333 # Backslash escaping
1338 }
1341 # Quoted literal
1345 # No terminating quote, assume literal "
1350 }
1352 # Quote at end of string, assume literal "
1354 }
1358 }
1371 }
1372 }
1373 }
1375 }
1380 /**
1381 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1382 * Gregorian dates to Iranian dates. Originally written in C, it
1383 * is released under the terms of GNU Lesser General Public
1384 * License. Conversion to PHP was performed by Niklas Laxström.
1385 *
1386 * Link: http://www.farsiweb.info/jalali/jalali.c
1387 *
1388 * @param $ts string
1389 *
1390 * @return string
1391 */
1397 # Days passed from the beginning (including leap years)
1403 // Add days of the past months of this year
1406 }
1408 // Leap years
1411 }
1413 // Days passed in current month
1427 }
1431 }
1437 }
1439 /**
1440 * Converting Gregorian dates to Hijri dates.
1441 *
1442 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1443 *
1444 * @see http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1445 *
1446 * @param $ts string
1447 *
1448 * @return string
1449 */
1463 )
1464 {
1472 }
1477 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1478 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1484 }
1486 /**
1487 * Converting Gregorian dates to Hebrew dates.
1488 *
1489 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1490 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1491 * to translate the relevant functions into PHP and release them under
1492 * GNU GPL.
1493 *
1494 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1495 * and Adar II is 14. In a non-leap year, Adar is 6.
1496 *
1497 * @param $ts string
1498 *
1499 * @return string
1500 */
1502 # Parse date
1507 # Calculate Hebrew year
1510 # Month number when September = 1, August = 12
1513 # Next year
1517 }
1519 # Calculate day of year from 1 September
1523 # February
1525 # Check if the year is leap
1528 }
1533 }
1534 }
1536 # Calculate the start of the Hebrew year
1539 # Calculate next year's start
1541 # Day is before the start of the year - it is the previous year
1542 # Next year's start
1544 # Previous year
1547 # Add days since previous year's 1 September
1550 # Leap year
1552 }
1553 # Start of the new (previous) year
1556 # Next year's start
1558 }
1560 # Calculate Hebrew day of year
1563 # Difference between year's days
1565 # Add 12 (or 13 for leap years) days to ignore the difference between
1566 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1567 # difference is only about the year type
1572 }
1574 # Check the year pattern, and is leap year
1575 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1576 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1577 # and non-leap years
1579 # Check if leap year
1582 # Calculate day in the month from number of day in the Hebrew year
1583 # Don't check Adar - if the day is not in Adar, we will stop before;
1584 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1589 # Calculate days in this month
1591 # Adar in a leap year
1593 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1596 # Day in Adar I
1599 # Subtract the days of Adar I
1601 # Try Adar II
1604 # Day in Adar II
1606 }
1607 }
1608 }
1610 # Cheshvan in a complete year (otherwise as the rule below)
1613 # Kislev in an incomplete year (otherwise as the rule below)
1616 # Odd months have 30 days, even have 29
1618 }
1620 # In the current month
1623 # Subtract the days of the current month
1625 # Try in the next month
1627 }
1628 }
1631 }
1633 /**
1634 * This calculates the Hebrew year start, as days since 1 September.
1635 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1636 * Used for Hebrew date.
1637 *
1638 * @param $year int
1639 *
1640 * @return string
1641 */
1648 }
1652 }
1662 }
1666 }
1668 /**
1669 * Algorithm to convert Gregorian dates to Thai solar dates,
1670 * Minguo dates or Minguo dates.
1671 *
1672 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1673 * http://en.wikipedia.org/wiki/Minguo_calendar
1674 * http://en.wikipedia.org/wiki/Japanese_era_name
1675 *
1676 * @param $ts String: 14-character timestamp
1677 * @param $cName String: calender name
1678 * @return Array: converted year, month, day
1679 */
1686 # Thai solar dates
1687 # Add 543 years to the Gregorian calendar
1688 # Months and days are identical
1691 # Minguo dates
1692 # Deduct 1911 years from the Gregorian calendar
1693 # Months and days are identical
1696 # Nengō dates up to Meiji period
1697 # Deduct years from the Gregorian calendar
1698 # depending on the nengo periods
1699 # Months and days are identical
1700 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1701 # Meiji period
1706 }
1714 )
1715 {
1716 # Taishō period
1721 }
1727 )
1728 {
1729 # Shōwa period
1734 }
1737 # Heisei period
1742 }
1744 }
1747 }
1750 }
1752 /**
1753 * Roman number formatting up to 10000
1754 *
1755 * @param $num int
1756 *
1757 * @return string
1758 */
1764 array( '', 'M', 'MM', 'MMM', 'MMMM', 'MMMMM', 'MMMMMM', 'MMMMMMM', 'MMMMMMMM', 'MMMMMMMMM', 'MMMMMMMMMM' )
1765 );
1770 }
1776 }
1778 }
1780 }
1782 /**
1783 * Hebrew Gematria number formatting up to 9999
1784 *
1785 * @param $num int
1786 *
1787 * @return string
1788 */
1795 );
1800 }
1812 }
1813 }
1814 }
1816 }
1822 }
1841 }
1843 }
1845 /**
1846 * Used by date() and time() to adjust the time output.
1847 *
1848 * @param $ts Int the time in date('YmdHis') format
1849 * @param $tz Mixed: adjust the time by this amount (default false, mean we
1850 * get user timecorrection setting)
1851 * @return int
1852 */
1858 }
1871 }
1872 # Unrecognized timezone, default to 'Offset' with the stored offset.
1874 }
1878 # Global offset in minutes.
1881 }
1892 }
1895 }
1896 }
1898 # No difference ? Return time unchanged
1901 }
1904 # Generate an adjusted date; take advantage of the fact that mktime
1905 # will normalize out-of-range values so we don't have to split $minDiff
1906 # into hours and minutes.
1919 }
1921 /**
1922 * This is meant to be used by time(), date(), and timeanddate() to get
1923 * the date preference they're supposed to use, it should be used in
1924 * all children.
1925 *
1926 *<code>
1927 * function timeanddate([...], $format = true) {
1928 * $datePreference = $this->dateFormat($format);
1929 * [...]
1930 * }
1931 *</code>
1932 *
1933 * @param $usePrefs Mixed: if true, the user's preference is used
1934 * if false, the site/language default is used
1935 * if int/string, assumed to be a format.
1936 * @return string
1937 */
1946 }
1949 }
1951 // return int
1954 }
1957 }
1959 /**
1960 * Get a format string for a given type and preference
1961 * @param $type string May be date, time or both
1962 * @param $pref string The format name as it appears in Messages*.php
1963 *
1964 * @return string
1965 */
1976 }
1977 }
1979 }
1981 }
1983 /**
1984 * @param $ts Mixed: the time format which needs to be turned into a
1985 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1986 * @param $adj Bool: whether to adjust the time output according to the
1987 * user configured offset ($timecorrection)
1988 * @param $format Mixed: true to use user's date format preference
1989 * @param $timecorrection String|bool the time offset as returned by
1990 * validateTimeZone() in Special:Preferences
1991 * @return string
1992 */
1997 }
2000 }
2002 /**
2003 * @param $ts Mixed: the time format which needs to be turned into a
2004 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2005 * @param $adj Bool: whether to adjust the time output according to the
2006 * user configured offset ($timecorrection)
2007 * @param $format Mixed: true to use user's date format preference
2008 * @param $timecorrection String|bool the time offset as returned by
2009 * validateTimeZone() in Special:Preferences
2010 * @return string
2011 */
2016 }
2019 }
2021 /**
2022 * @param $ts Mixed: the time format which needs to be turned into a
2023 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2024 * @param $adj Bool: whether to adjust the time output according to the
2025 * user configured offset ($timecorrection)
2026 * @param $format Mixed: what format to return, if it's false output the
2027 * default one (default true)
2028 * @param $timecorrection String|bool the time offset as returned by
2029 * validateTimeZone() in Special:Preferences
2030 * @return string
2031 */
2036 }
2039 }
2041 /**
2042 * Takes a number of seconds and turns it into a text using values such as hours and minutes.
2043 *
2044 * @since 1.20
2045 *
2046 * @param integer $seconds The amount of seconds.
2047 * @param array $chosenIntervals The intervals to enable.
2048 *
2049 * @return string
2050 */
2059 }
2062 }
2064 /**
2065 * Takes a number of seconds and returns an array with a set of corresponding intervals.
2066 * For example 65 will be turned into array( minutes => 1, seconds => 5 ).
2067 *
2068 * @since 1.20
2069 *
2070 * @param integer $seconds The amount of seconds.
2071 * @param array $chosenIntervals The intervals to enable.
2072 *
2073 * @return array
2074 */
2077 $chosenIntervals = array( 'millennia', 'centuries', 'decades', 'years', 'days', 'hours', 'minutes', 'seconds' );
2078 }
2092 }
2093 }
2096 }
2098 /**
2099 * Internal helper function for userDate(), userTime() and userTimeAndDate()
2100 *
2101 * @param $type String: can be 'date', 'time' or 'both'
2102 * @param $ts Mixed: the time format which needs to be turned into a
2103 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2104 * @param $user User object used to get preferences for timezone and format
2105 * @param $options Array, can contain the following keys:
2106 * - 'timecorrection': time correction, can have the following values:
2107 * - true: use user's preference
2108 * - false: don't use time correction
2109 * - integer: value of time correction in minutes
2110 * - 'format': format to use, can have the following values:
2111 * - true: use user's preference
2112 * - false: use default preference
2113 * - string: format to use
2114 * @since 1.19
2115 * @return String
2116 */
2125 }
2127 }
2132 }
2135 }
2137 /**
2138 * Get the formatted date for the given timestamp and formatted for
2139 * the given user.
2140 *
2141 * @param $ts Mixed: the time format which needs to be turned into a
2142 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2143 * @param $user User object used to get preferences for timezone and format
2144 * @param $options Array, can contain the following keys:
2145 * - 'timecorrection': time correction, can have the following values:
2146 * - true: use user's preference
2147 * - false: don't use time correction
2148 * - integer: value of time correction in minutes
2149 * - 'format': format to use, can have the following values:
2150 * - true: use user's preference
2151 * - false: use default preference
2152 * - string: format to use
2153 * @since 1.19
2154 * @return String
2155 */
2158 }
2160 /**
2161 * Get the formatted time for the given timestamp and formatted for
2162 * the given user.
2163 *
2164 * @param $ts Mixed: the time format which needs to be turned into a
2165 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2166 * @param $user User object used to get preferences for timezone and format
2167 * @param $options Array, can contain the following keys:
2168 * - 'timecorrection': time correction, can have the following values:
2169 * - true: use user's preference
2170 * - false: don't use time correction
2171 * - integer: value of time correction in minutes
2172 * - 'format': format to use, can have the following values:
2173 * - true: use user's preference
2174 * - false: use default preference
2175 * - string: format to use
2176 * @since 1.19
2177 * @return String
2178 */
2181 }
2183 /**
2184 * Get the formatted date and time for the given timestamp and formatted for
2185 * the given user.
2186 *
2187 * @param $ts Mixed: the time format which needs to be turned into a
2188 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
2189 * @param $user User object used to get preferences for timezone and format
2190 * @param $options Array, can contain the following keys:
2191 * - 'timecorrection': time correction, can have the following values:
2192 * - true: use user's preference
2193 * - false: don't use time correction
2194 * - integer: value of time correction in minutes
2195 * - 'format': format to use, can have the following values:
2196 * - true: use user's preference
2197 * - false: use default preference
2198 * - string: format to use
2199 * @since 1.19
2200 * @return String
2201 */
2204 }
2206 /**
2207 * @param $key string
2208 * @return array|null
2209 */
2212 }
2214 /**
2215 * @return array
2216 */
2219 }
2221 /**
2222 * @param $in
2223 * @param $out
2224 * @param $string
2225 * @return string
2226 */
2228 # This is a wrapper for iconv in all languages except esperanto,
2229 # which does some nasty x-conversions beforehand
2231 # Even with //IGNORE iconv can whine about illegal characters in
2232 # *input* string. We just ignore those too.
2233 # REF: http://bugs.php.net/bug.php?id=37166
2234 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
2239 }
2241 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
2243 /**
2244 * @param $matches array
2245 * @return mixed|string
2246 */
2249 }
2251 /**
2252 * @param $matches array
2253 * @return string
2254 */
2257 }
2259 /**
2260 * @param $matches array
2261 * @return string
2262 */
2266 }
2268 /**
2269 * @param $matches array
2270 * @return string
2271 */
2275 }
2277 /**
2278 * @param $matches array
2279 * @return string
2280 */
2283 }
2285 /**
2286 * @param $matches array
2287 * @return string
2288 */
2292 }
2294 /**
2295 * Make a string's first character uppercase
2296 *
2297 * @param $str string
2298 *
2299 * @return string
2300 */
2308 // fall back to more complex logic in case of multibyte strings
2310 }
2311 }
2313 /**
2314 * Convert a string to uppercase
2315 *
2316 * @param $str string
2317 * @param $first bool
2318 *
2319 * @return string
2320 */
2328 }
2331 }
2338 $str
2339 );
2342 }
2343 }
2344 }
2346 /**
2347 * @param $str string
2348 * @return mixed|string
2349 */
2361 }
2362 }
2364 /**
2365 * @param $str string
2366 * @param $first bool
2367 * @return mixed|string
2368 */
2376 }
2379 }
2386 $str
2387 );
2390 }
2391 }
2392 }
2394 /**
2395 * @param $str string
2396 * @return bool
2397 */
2400 }
2402 /**
2403 * @param $str string
2404 * @return mixed|string
2405 */
2410 // regexp to find first letter in each word (i.e. after each space)
2411 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2413 // function to use to capitalize a single char
2418 $str
2419 );
2424 $str
2425 );
2426 }
2429 }
2430 }
2432 /**
2433 * capitalize words at word breaks
2434 *
2435 * @param $str string
2436 * @return mixed
2437 */
2442 // since \b doesn't work for UTF-8, we explicitely define word break chars
2445 // find first letter after word break
2446 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2452 $str
2453 );
2458 $str
2459 );
2460 }
2465 $str
2466 );
2467 }
2468 }
2470 /**
2471 * Return a case-folded representation of $s
2472 *
2473 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2474 * and $s2 are the same except for the case of their characters. It is not
2475 * necessary for the value returned to make sense when displayed.
2476 *
2477 * Do *not* perform any other normalisation in this function. If a caller
2478 * uses this function when it should be using a more general normalisation
2479 * function, then fix the caller.
2480 *
2481 * @param $s string
2482 *
2483 * @return string
2484 */
2487 }
2489 /**
2490 * @param $s string
2491 * @return string
2492 */
2496 }
2499 }
2502 }
2504 /**
2505 * @return array
2506 */
2509 }
2511 /**
2512 * Most writing systems use whitespace to break up words.
2513 * Some languages such as Chinese don't conventionally do this,
2514 * which requires special handling when breaking up words for
2515 * searching etc.
2516 *
2517 * @return bool
2518 */
2521 }
2523 /**
2524 * Some languages such as Chinese require word segmentation,
2525 * Specify such segmentation when overridden in derived class.
2526 *
2527 * @param $string String
2528 * @return String
2529 */
2532 }
2534 /**
2535 * Some languages have special punctuation need to be normalized.
2536 * Make such changes here.
2537 *
2538 * @param $string String
2539 * @return String
2540 */
2543 }
2545 /**
2546 * convert double-width roman characters to single-width.
2547 * range: ff00-ff5f ~= 0020-007f
2548 *
2549 * @param $string string
2550 *
2551 * @return string
2552 */
2562 }
2566 }
2568 /**
2569 * @param $string string
2570 * @param $pattern string
2571 * @return string
2572 */
2577 }
2579 /**
2580 * @param $termsArray array
2581 * @return array
2582 */
2584 # some languages, e.g. Chinese, need to do a conversion
2585 # in order for search results to be displayed correctly
2587 }
2589 /**
2590 * Get the first character of a string.
2591 *
2592 * @param $s string
2593 * @return string
2594 */
2601 $matches
2602 );
2607 }
2609 // Break down Hangul syllables to grab the first jamo
2641 }
2644 }
2645 }
2648 # Some languages may have an alternate char encoding option
2649 # (Esperanto X-coding, Japanese furigana conversion, etc)
2650 # If this language is used as the primary content language,
2651 # an override to the defaults can be set here on startup.
2652 }
2654 /**
2655 * @param $s string
2656 * @return string
2657 */
2659 # For some languages we'll want to explicitly specify
2660 # which characters make it into the edit box raw
2661 # or are converted in some way or another.
2667 }
2668 }
2670 /**
2671 * @param $s string
2672 * @return string
2673 */
2675 # Take the previous into account.
2681 }
2686 }
2687 }
2689 /**
2690 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2691 * also cleans up certain backwards-compatible sequences, converting them
2692 * to the modern Unicode equivalent.
2693 *
2694 * This is language-specific for performance reasons only.
2695 *
2696 * @param $s string
2697 *
2698 * @return string
2699 */
2706 }
2709 }
2711 /**
2712 * Transform a string using serialized data stored in the given file (which
2713 * must be in the serialized subdirectory of $IP). The file contains pairs
2714 * mapping source characters to destination characters.
2715 *
2716 * The data is cached in process memory. This will go faster if you have the
2717 * FastStringSearch extension.
2718 *
2719 * @param $file string
2720 * @param $string string
2721 *
2722 * @throws MWException
2723 * @return string
2724 */
2730 }
2732 }
2734 }
2736 /**
2737 * For right-to-left language support
2738 *
2739 * @return bool
2740 */
2743 }
2745 /**
2746 * Return the correct HTML 'dir' attribute value for this language.
2747 * @return String
2748 */
2751 }
2753 /**
2754 * Return 'left' or 'right' as appropriate alignment for line-start
2755 * for this language's text direction.
2756 *
2757 * Should be equivalent to CSS3 'start' text-align value....
2758 *
2759 * @return String
2760 */
2763 }
2765 /**
2766 * Return 'right' or 'left' as appropriate alignment for line-end
2767 * for this language's text direction.
2768 *
2769 * Should be equivalent to CSS3 'end' text-align value....
2770 *
2771 * @return String
2772 */
2775 }
2777 /**
2778 * A hidden direction mark (LRM or RLM), depending on the language direction.
2779 * Unlike getDirMark(), this function returns the character as an HTML entity.
2780 * This function should be used when the output is guaranteed to be HTML,
2781 * because it makes the output HTML source code more readable. When
2782 * the output is plain text or can be escaped, getDirMark() should be used.
2783 *
2784 * @param $opposite Boolean Get the direction mark opposite to your language
2785 * @return string
2786 * @since 1.20
2787 */
2791 }
2793 }
2795 /**
2796 * A hidden direction mark (LRM or RLM), depending on the language direction.
2797 * This function produces them as invisible Unicode characters and
2798 * the output may be hard to read and debug, so it should only be used
2799 * when the output is plain text or can be escaped. When the output is
2800 * HTML, use getDirMarkEntity() instead.
2801 *
2802 * @param $opposite Boolean Get the direction mark opposite to your language
2803 * @return string
2804 */
2810 }
2812 }
2814 /**
2815 * @return array
2816 */
2819 }
2821 /**
2822 * An arrow, depending on the language direction.
2823 *
2824 * @param $direction String: the direction of the arrow: forwards (default), backwards, left, right, up, down.
2825 * @return string
2826 */
2841 }
2842 }
2844 /**
2845 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2846 *
2847 * @return bool
2848 */
2851 }
2853 /**
2854 * @return array
2855 */
2858 }
2863 }
2868 }
2870 /**
2871 * Fill a MagicWord object with data from here
2872 *
2873 * @param $mw
2874 */
2886 }
2887 }
2894 }
2895 }
2897 /**
2898 * Add magic words to the extension array
2899 *
2900 * @param $newWords array
2901 */
2908 }
2909 }
2910 }
2912 /**
2913 * Get special page names, as an associative array
2914 * case folded alias => real name
2915 */
2917 // Cache aliases because it may be slow to load them
2919 // Initialise array
2924 }
2927 }
2929 /**
2930 * Italic is unsuitable for some languages
2931 *
2932 * @param $text String: the text to be emphasized.
2933 * @return string
2934 */
2937 }
2939 /**
2940 * Normally we output all numbers in plain en_US style, that is
2941 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2942 * point twohundredthirtyfive. However this is not suitable for all
2943 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2944 * Icelandic just want to use commas instead of dots, and dots instead
2945 * of commas like "293.291,235".
2946 *
2947 * An example of this function being called:
2948 * <code>
2949 * wfMessage( 'message' )->numParams( $num )->text()
2950 * </code>
2951 *
2952 * See LanguageGu.php for the Gujarati implementation and
2953 * $separatorTransformTable on MessageIs.php for
2954 * the , => . and . => , implementation.
2955 *
2956 * @todo check if it's viable to use localeconv() for the decimal
2957 * separator thing.
2958 * @param $number Mixed: the string to be formatted, should be an integer
2959 * or a floating point number.
2960 * @param $nocommafy Bool: set to true for special numbers like dates
2961 * @return string
2962 */
2970 }
2971 }
2977 }
2978 }
2981 }
2983 /**
2984 * Front-end for non-commafied formatNum
2985 *
2986 * @param mixed $number the string to be formatted, should be an integer
2987 * or a floating point number.
2988 * @since 1.21
2989 * @return string
2990 */
2993 }
2995 /**
2996 * @param $number string
2997 * @return string
2998 */
3003 }
3008 }
3012 }
3014 /**
3015 * Adds commas to a given number
3016 * @since 1.19
3017 * @param $number mixed
3018 * @return string
3019 */
3024 }
3027 // default grouping is at thousands, use the same for ###,###,### pattern too.
3030 // Ref: http://cldr.unicode.org/translation/number-patterns
3033 // For negative numbers apply the algorithm like positive number and add sign.
3036 }
3044 // the string does not have any number part. Eg: .12345
3046 }
3054 }
3058 // use the last pattern for the rest of the number
3060 }
3063 }
3064 }
3066 }
3067 }
3069 /**
3070 * @return String
3071 */
3074 }
3076 /**
3077 * @return array
3078 */
3081 }
3083 /**
3084 * @return array
3085 */
3088 }
3090 /**
3091 * Take a list of strings and build a locale-friendly comma-separated
3092 * list, using the local comma-separator message.
3093 * The last two strings are chained with an "and".
3094 * NOTE: This function will only work with standard numeric array keys (0, 1, 2…)
3095 *
3096 * @param $l Array
3097 * @return string
3098 */
3103 }
3109 }
3110 }
3117 }
3118 }
3120 }
3122 /**
3123 * Take a list of strings and build a locale-friendly comma-separated
3124 * list, using the local comma-separator message.
3125 * @param $list array of strings to put in a comma list
3126 * @return string
3127 */
3131 $list
3132 );
3133 }
3135 /**
3136 * Take a list of strings and build a locale-friendly semicolon-separated
3137 * list, using the local semicolon-separator message.
3138 * @param $list array of strings to put in a semicolon list
3139 * @return string
3140 */
3144 $list
3145 );
3146 }
3148 /**
3149 * Same as commaList, but separate it with the pipe instead.
3150 * @param $list array of strings to put in a pipe list
3151 * @return string
3152 */
3156 $list
3157 );
3158 }
3160 /**
3161 * Truncate a string to a specified length in bytes, appending an optional
3162 * string (e.g. for ellipses)
3163 *
3164 * The database offers limited byte lengths for some columns in the database;
3165 * multi-byte character sets mean we need to ensure that only whole characters
3166 * are included, otherwise broken characters can be passed to the user
3167 *
3168 * If $length is negative, the string will be truncated from the beginning
3169 *
3170 * @param $string String to truncate
3171 * @param $length Int: maximum length (including ellipses)
3172 * @param $ellipsis String to append to the truncated text
3173 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
3174 * $adjustLength was introduced in 1.18, before that behaved as if false.
3175 * @return string
3176 */
3178 # Use the localized ellipsis character
3181 }
3182 # Check if there is no need to truncate
3187 }
3189 # If ellipsis length is >= $length then we can't apply $adjustLength
3192 # Otherwise, truncate and add ellipsis...
3205 }
3206 }
3207 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
3208 # This check is *not* redundant if $adjustLength, due to the single case where
3209 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
3214 }
3215 }
3217 /**
3218 * Remove bytes that represent an incomplete Unicode character
3219 * at the end of string (e.g. bytes of the char are missing)
3220 *
3221 * @param $string String
3222 * @return string
3223 */
3229 # We got the first byte only of a multibyte char; remove it.
3234 ) {
3235 # We chopped in the middle of a character; remove it
3237 }
3238 }
3240 }
3242 /**
3243 * Remove bytes that represent an incomplete Unicode character
3244 * at the start of string (e.g. bytes of the char are missing)
3245 *
3246 * @param $string String
3247 * @return string
3248 */
3253 # We chopped in the middle of a character; remove the whole thing
3255 }
3256 }
3258 }
3260 /**
3261 * Truncate a string of valid HTML to a specified length in bytes,
3262 * appending an optional string (e.g. for ellipses), and return valid HTML
3263 *
3264 * This is only intended for styled/linked text, such as HTML with
3265 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
3266 * Also, this will not detect things like "display:none" CSS.
3267 *
3268 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
3269 *
3270 * @param string $text HTML string to truncate
3271 * @param int $length (zero/positive) Maximum length (including ellipses)
3272 * @param string $ellipsis String to append to the truncated text
3273 * @return string
3274 */
3276 # Use the localized ellipsis character
3279 }
3280 # Check if there is clearly no need to truncate
3285 }
3299 # Consider truncation once the display length has reached the maximim.
3300 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
3301 # Check that we're not in the middle of a bracket/entity...
3305 # Save where we are; we will truncate here unless there turn out to
3306 # be so few remaining characters that truncation is not necessary.
3309 }
3311 # String in fact does need truncation, the truncation point was OK.
3316 }
3317 }
3320 }
3322 # Read the next char...
3340 }
3346 // Name found (e.g. "<a href=..."), add on tag attributes...
3348 }
3354 }
3357 // Save state without $ch. We want to *hit* the first
3358 // display char (to get tags) but not *use* it if truncating.
3360 }
3365 // Add the next $max display text chars after this in one swoop...
3370 }
3371 }
3372 }
3373 }
3374 // Close the last tag if left unclosed by bad HTML
3378 }
3380 }
3382 /**
3383 * truncateHtml() helper function
3384 * like strcspn() but adds the skipped chars to $ret
3385 *
3386 * @param $ret
3387 * @param $text
3388 * @param $search
3389 * @param $start
3390 * @param $len
3391 * @return int
3392 */
3398 }
3403 }
3405 }
3407 /**
3408 * truncateHtml() helper function
3409 * (a) push or pop $tag from $openTags as needed
3410 * (b) clear $tag value
3411 * @param &$tag string Current HTML tag name we are looking at
3412 * @param $tagType int (0-open tag, 1-close tag)
3413 * @param $lastCh string Character before the '>' that ended this tag
3414 * @param &$openTags array Open tag stack (not accounting for $tag)
3415 */
3424 }
3425 }
3427 }
3428 }
3430 /**
3431 * Grammatical transformations, needed for inflected languages
3432 * Invoked by putting {{grammar:case|word}} in a message
3433 *
3434 * @param $word string
3435 * @param $case string
3436 * @return string
3437 */
3442 }
3444 }
3445 /**
3446 * Get the grammar forms for the content language
3447 * @return array of grammar forms
3448 * @since 1.20
3449 */
3452 if ( isset( $wgGrammarForms[$this->getCode()] ) && is_array( $wgGrammarForms[$this->getCode()] ) ) {
3454 }
3456 }
3457 /**
3458 * Provides an alternative text depending on specified gender.
3459 * Usage {{gender:username|masculine|feminine|neutral}}.
3460 * username is optional, in which case the gender of current user is used,
3461 * but only in (some) interface messages; otherwise default gender is used.
3462 *
3463 * If no forms are given, an empty string is returned. If only one form is
3464 * given, it will be returned unconditionally. These details are implied by
3465 * the caller and cannot be overridden in subclasses.
3466 *
3467 * If more than one form is given, the default is to use the neutral one
3468 * if it is specified, and to use the masculine one otherwise. These
3469 * details can be overridden in subclasses.
3470 *
3471 * @param $gender string
3472 * @param $forms array
3473 *
3474 * @return string
3475 */
3479 }
3483 }
3486 }
3488 }
3490 /**
3491 * Plural form transformations, needed for some languages.
3492 * For example, there are 3 form of plural in Russian and Polish,
3493 * depending on "count mod 10". See [[w:Plural]]
3494 * For English it is pretty simple.
3495 *
3496 * Invoked by putting {{plural:count|wordform1|wordform2}}
3497 * or {{plural:count|wordform1|wordform2|wordform3}}
3498 *
3499 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3500 *
3501 * @param $count Integer: non-localized number
3502 * @param $forms Array: different plural forms
3503 * @return string Correct form of plural for $count in this language
3504 */
3508 }
3510 // Handle explicit n=pluralform cases
3516 }
3518 }
3519 }
3525 }
3527 /**
3528 * Checks that convertPlural was given an array and pads it to requested
3529 * amount of forms by copying the last one.
3530 *
3531 * @param $count Integer: How many forms should there be at least
3532 * @param $forms Array of forms given to convertPlural
3533 * @return array Padded array of forms or an exception if not an array
3534 */
3538 }
3540 }
3542 /**
3543 * @todo Maybe translate block durations. Note that this function is somewhat misnamed: it
3544 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
3545 * (which is an absolute timestamp). Please note: do NOT add this blindly, as it is used
3546 * on old expiry lengths recorded in log entries. You'd need to provide the start date to
3547 * match up with it.
3548 *
3549 * @param $str String: the validated block duration in English
3550 * @return string Somehow translated block duration
3551 * @see LanguageFi.php for example implementation
3552 */
3558 }
3559 }
3561 // Since usually only infinite or indefinite is only on list, so try
3562 // equivalents if still here.
3569 }
3570 }
3571 }
3573 // If all else fails, return a standard duration or timestamp description.
3578 // $time is relative to 0 so it's a duration length.
3582 // wfTimestamp() handles 0 as current time instead of epoch.
3586 }
3587 }
3588 }
3590 /**
3591 * languages like Chinese need to be segmented in order for the diff
3592 * to be of any use
3593 *
3594 * @param $text String
3595 * @return String
3596 */
3599 }
3601 /**
3602 * and unsegment to show the result
3603 *
3604 * @param $text String
3605 * @return String
3606 */
3609 }
3611 /**
3612 * Return the LanguageConverter used in the Language
3613 *
3614 * @since 1.19
3615 * @return LanguageConverter
3616 */
3619 }
3621 /**
3622 * convert text to all supported variants
3623 *
3624 * @param $text string
3625 * @return array
3626 */
3629 }
3631 /**
3632 * convert text to different variants of a language.
3633 *
3634 * @param $text string
3635 * @return string
3636 */
3639 }
3641 /**
3642 * Convert a Title object to a string in the preferred variant
3643 *
3644 * @param $title Title
3645 * @return string
3646 */
3649 }
3651 /**
3652 * Convert a namespace index to a string in the preferred variant
3653 *
3654 * @param $ns int
3655 * @return string
3656 */
3659 }
3661 /**
3662 * Check if this is a language with variants
3663 *
3664 * @return bool
3665 */
3668 }
3670 /**
3671 * Check if the language has the specific variant
3672 *
3673 * @since 1.19
3674 * @param $variant string
3675 * @return bool
3676 */
3679 }
3681 /**
3682 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3683 *
3684 * @param $text string
3685 * @return string
3686 */
3689 }
3691 /**
3692 * Perform output conversion on a string, and encode for safe HTML output.
3693 * @param $text String text to be converted
3694 * @param $isTitle Bool whether this conversion is for the article title
3695 * @return string
3696 * @todo this should get integrated somewhere sane
3697 */
3700 }
3702 /**
3703 * @param $key string
3704 * @return string
3705 */
3708 }
3710 /**
3711 * Get the list of variants supported by this language
3712 * see sample implementation in LanguageZh.php
3713 *
3714 * @return array an array of language codes
3715 */
3718 }
3720 /**
3721 * @return string
3722 */
3725 }
3727 /**
3728 * @return string
3729 */
3732 }
3734 /**
3735 * @return string
3736 */
3739 }
3741 /**
3742 * If a language supports multiple variants, it is
3743 * possible that non-existing link in one variant
3744 * actually exists in another variant. this function
3745 * tries to find it. See e.g. LanguageZh.php
3746 *
3747 * @param $link String: the name of the link
3748 * @param $nt Mixed: the title object of the link
3749 * @param $ignoreOtherCond Boolean: to disable other conditions when
3750 * we need to transclude a template or update a category's link
3751 * @return null the input parameters may be modified upon return
3752 */
3755 }
3757 /**
3758 * If a language supports multiple variants, converts text
3759 * into an array of all possible variants of the text:
3760 * 'variant' => text in that variant
3761 *
3762 * @deprecated since 1.17 Use autoConvertToAllVariants()
3763 *
3764 * @param $text string
3765 *
3766 * @return string
3767 */
3770 }
3772 /**
3773 * returns language specific options used by User::getPageRenderHash()
3774 * for example, the preferred language variant
3775 *
3776 * @return string
3777 */
3780 }
3782 /**
3783 * For languages that support multiple variants, the title of an
3784 * article may be displayed differently in different variants. this
3785 * function returns the apporiate title defined in the body of the article.
3786 *
3787 * @return string
3788 */
3791 }
3793 /**
3794 * Prepare external link text for conversion. When the text is
3795 * a URL, it shouldn't be converted, and it'll be wrapped in
3796 * the "raw" tag (-{R| }-) to prevent conversion.
3797 *
3798 * This function is called "markNoConversion" for historical
3799 * reasons.
3800 *
3801 * @param $text String: text to be used for external link
3802 * @param $noParse bool: wrap it without confirming it's a real URL first
3803 * @return string the tagged text
3804 */
3806 // Excluding protocal-relative URLs may avoid many false positives.
3811 }
3812 }
3814 /**
3815 * A regular expression to match legal word-trailing characters
3816 * which should be merged onto a link of the form [[foo]]bar.
3817 *
3818 * @return string
3819 */
3822 }
3824 /**
3825 * @return Language
3826 */
3829 }
3831 /**
3832 * Get the RFC 3066 code for this language object
3833 *
3834 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3835 * htmlspecialchars() or similar
3836 *
3837 * @return string
3838 */
3841 }
3843 /**
3844 * Get the code in Bcp47 format which we can use
3845 * inside of html lang="" tags.
3846 *
3847 * NOTE: The return value of this function is NOT HTML-safe and must be escaped with
3848 * htmlspecialchars() or similar.
3849 *
3850 * @since 1.19
3851 * @return string
3852 */
3856 }
3858 }
3860 /**
3861 * @param $code string
3862 */
3865 // Ensure we don't leave an incorrect html code lying around
3867 }
3869 /**
3870 * Get the name of a file for a certain language code
3871 * @param $prefix string Prepend this to the filename
3872 * @param $code string Language code
3873 * @param $suffix string Append this to the filename
3874 * @throws MWException
3875 * @return string $prefix . $mangledCode . $suffix
3876 */
3878 // Protect against path traversal
3881 {
3883 }
3886 }
3888 /**
3889 * Get the language code from a file name. Inverse of getFileName()
3890 * @param $filename string $prefix . $languageCode . $suffix
3891 * @param $prefix string Prefix before the language code
3892 * @param $suffix string Suffix after the language code
3893 * @return string Language code, or false if $prefix or $suffix isn't found
3894 */
3895 public static function getCodeFromFileName( $filename, $prefix = 'Language', $suffix = '.php' ) {
3901 }
3903 }
3905 /**
3906 * @param $code string
3907 * @return string
3908 */
3914 }
3916 /**
3917 * @param $code string
3918 * @return string
3919 */
3923 }
3925 /**
3926 * Get the first fallback for a given language.
3927 *
3928 * @param $code string
3929 *
3930 * @return bool|string
3931 */
3939 }
3940 }
3942 /**
3943 * Get the ordered list of fallback languages.
3944 *
3945 * @since 1.19
3946 * @param $code string Language code
3947 * @return array
3948 */
3957 }
3959 }
3960 }
3962 /**
3963 * Get all messages for a given language
3964 * WARNING: this may take a long time. If you just need all message *keys*
3965 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3966 *
3967 * @param $code string
3968 *
3969 * @return array
3970 */
3973 }
3975 /**
3976 * Get a message for a given language
3977 *
3978 * @param $key string
3979 * @param $code string
3980 *
3981 * @return string
3982 */
3985 }
3987 /**
3988 * Get all message keys for a given language. This is a faster alternative to
3989 * array_keys( Language::getMessagesFor( $code ) )
3990 *
3991 * @since 1.19
3992 * @param $code string Language code
3993 * @return array of message keys (strings)
3994 */
3997 }
3999 /**
4000 * @param $talk
4001 * @return mixed
4002 */
4006 }
4011 # Allow grammar transformations
4012 # Allowing full message-style parsing would make simple requests
4013 # such as action=raw much more expensive than they need to be.
4014 # This will hopefully cover most cases.
4018 }
4020 /**
4021 * @param $m string
4022 * @return string
4023 */
4026 }
4028 /**
4029 * @throws MWException
4030 * @return array
4031 */
4036 }
4043 }
4048 }
4050 /**
4051 * Decode an expiry (block, protection, etc) which has come from the DB
4052 *
4053 * @todo FIXME: why are we returnings DBMS-dependent strings???
4054 *
4055 * @param $expiry String: Database expiry String
4056 * @param $format Bool|Int true to process using language functions, or TS_ constant
4057 * to return the expiry in a given timestamp
4058 * @return String
4059 * @since 1.18
4060 */
4066 }
4070 ? $infinityMsg
4076 }
4077 }
4079 /**
4080 * @todo Document
4081 * @param $seconds int|float
4082 * @param $format Array Optional
4083 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
4084 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
4085 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
4086 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
4087 * @return string
4088 */
4092 }
4095 }
4098 }
4120 }
4131 }
4135 }
4141 }
4149 }
4159 }
4163 }
4173 }
4174 }
4176 }
4178 /**
4179 * Format a bitrate for output, using an appropriate
4180 * unit (bps, kbps, Mbps, Gbps, Tbps, Pbps, Ebps, Zbps or Ybps) according to the magnitude in question
4181 *
4182 * This use base 1000. For base 1024 use formatSize(), for another base
4183 * see formatComputingNumbers()
4184 *
4185 * @param $bps int
4186 * @return string
4187 */
4190 }
4192 /**
4193 * @param $size int Size of the unit
4194 * @param $boundary int Size boundary (1000, or 1024 in most cases)
4195 * @param $messageKey string Message key to be uesd
4196 * @return string
4197 */
4202 );
4203 }
4211 }
4213 // For small sizes no decimal places necessary
4216 // For MB and bigger two decimal places are smarter
4218 }
4224 }
4226 /**
4227 * Format a size in bytes for output, using an appropriate
4228 * unit (B, KB, MB, GB, TB, PB, EB, ZB or YB) according to the magnitude in question
4229 *
4230 * This method use base 1024. For base 1000 use formatBitrate(), for
4231 * another base see formatComputingNumbers()
4232 *
4233 * @param $size int Size to format
4234 * @return string Plain text (not HTML)
4235 */
4238 }
4240 /**
4241 * Make a list item, used by various special pages
4242 *
4243 * @param $page String Page link
4244 * @param $details String Text between brackets
4245 * @param $oppositedm Boolean Add the direction mark opposite to your
4246 * language, to display text properly
4247 * @return String
4248 */
4255 }
4257 /**
4258 * Generate (prev x| next x) (20|50|100...) type links for paging
4259 *
4260 * @param $title Title object to link
4261 * @param $offset Integer offset parameter
4262 * @param $limit Integer limit parameter
4263 * @param $query array|String optional URL query parameter string
4264 * @param $atend Bool optional param for specified if this is the last page
4265 * @return String
4266 */
4267 public function viewPrevNext( Title $title, $offset, $limit, array $query = array(), $atend = false ) {
4268 // @todo FIXME: Why on earth this needs one message for the text and another one for tooltip?
4270 # Make 'previous' link
4271 $prev = wfMessage( 'prevn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4277 }
4279 # Make 'next' link
4280 $next = wfMessage( 'nextn' )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4286 }
4288 # Make links to set number of items per page
4293 }
4297 }
4299 /**
4300 * Helper function for viewPrevNext() that generates links
4301 *
4302 * @param $title Title object to link
4303 * @param $offset Integer offset parameter
4304 * @param $limit Integer limit parameter
4305 * @param $query Array extra query parameters
4306 * @param $link String text to use for the link; will be escaped
4307 * @param $tooltipMsg String name of the message to use as tooltip
4308 * @param $class String value of the "class" attribute of the link
4309 * @return String HTML fragment
4310 */
4311 private function numLink( Title $title, $offset, $limit, array $query, $link, $tooltipMsg, $class ) {
4313 $tooltip = wfMessage( $tooltipMsg )->inLanguage( $this )->title( $title )->numParams( $limit )->text();
4316 }
4318 /**
4319 * Get the conversion rule title, if any.
4320 *
4321 * @return string
4322 */
4325 }
4327 /**
4328 * Get the compiled plural rules for the language
4329 * @since 1.20
4330 * @return array Associative array with plural form, and plural rule as key-value pairs
4331 */
4337 $pluralRules = self::$dataCache->getItem( strtolower( $fallbackCode ), 'compiledPluralRules' );
4340 }
4341 }
4342 }
4344 }
4346 /**
4347 * Get the plural rules for the language
4348 * @since 1.20
4349 * @return array Associative array with plural form number and plural rule as key-value pairs
4350 */
4359 }
4360 }
4361 }
4363 }
4365 /**
4366 * Get the plural rule types for the language
4367 * @since 1.21
4368 * @return array Associative array with plural form number and plural rule type as key-value pairs
4369 */
4375 $pluralRuleTypes = self::$dataCache->getItem( strtolower( $fallbackCode ), 'pluralRuleTypes' );
4378 }
4379 }
4380 }
4382 }
4384 /**
4385 * Find the index number of the plural rule appropriate for the given number
4386 * @return int The index number of the plural rule
4387 */
4392 }
4394 /**
4395 * Find the plural rule type appropriate for the given number
4396 * For example, if the language is set to Arabic, getPluralType(5) should
4397 * return 'few'.
4398 * @since 1.21
4399 * @return string The name of the plural rule type, e.g. one, two, few, many
4400 */
4408 }
4409 }
4410 }