| blob | 6327caec374f0c0faa2757f2294e8dbfb039f9db |
1 <?php
2 /**
3 * Internationalisation code
4 *
5 * @file
6 * @ingroup Language
7 */
9 /**
10 * @defgroup Language Language
11 */
16 }
18 # Read language names
24 }
26 /**
27 * a fake language converter
28 *
29 * @ingroup Language
30 */
49 }
51 /**
52 * Internationalisation code
53 * @ingroup Language
54 */
57 /**
58 * @var LanguageConverter
59 */
69 /**
70 * ReplacementArray object caches
71 */
74 /**
75 * @var LocalisationCache
76 */
84 );
88 );
93 'december'
94 );
98 'december-gen'
99 );
103 );
110 );
118 );
126 );
133 );
135 /**
136 * Get a cached language object for a given language code
137 * @param $code String
138 * @return Language
139 */
143 // Don't keep a billion objects around, that's stupid.
145 }
147 }
149 }
151 /**
152 * Create a language object for a given language code
153 * @param $code String
154 * @return Language
155 */
157 // Protect against path traversal below
160 {
162 }
165 // It's not possible to customise this code with class files, so
166 // just return a Language object. This is to support uselang= hacks.
170 }
172 // Check if there is a language class for the code
178 }
180 // Keep trying the fallback list until we find an existing class
185 }
193 }
194 }
197 }
199 /**
200 * Returns true if a language code string is of a valid form, whether or
201 * not it exists. This includes codes which are used solely for
202 * customisation via the MediaWiki namespace.
203 *
204 * @param $code string
205 *
206 * @return bool
207 */
209 return
212 }
214 /**
215 * Returns true if a language code is of a valid form for the purposes of
216 * internal customisation of MediaWiki, via Messages*.php.
217 *
218 * @param $code string
219 *
220 * @since 1.18
221 * @return bool
222 */
225 }
227 /**
228 * @param $code
229 * @return String Name of the language class
230 */
236 }
237 }
239 /**
240 * Includes language class files
241 *
242 * @param $class Name of the language class
243 */
249 }
252 // Preload base classes to work around APC/PHP5 bug
255 }
258 }
259 }
260 }
262 /**
263 * Get the LocalisationCache instance
264 *
265 * @return LocalisationCache
266 */
272 }
274 }
278 // Set the code to the name of the descendant
283 }
285 }
287 /**
288 * Reduce memory usage
289 */
293 }
294 }
296 /**
297 * Hook which will be called if this is the content language.
298 * Descendants can use this to register hook functions or modify globals
299 */
302 /**
303 * Same as getFallbacksFor for current language.
304 * @return array|bool
305 * @deprecated in 1.19
306 */
310 }
312 /**
313 * @return array
314 * @since 1.19
315 */
318 }
320 /**
321 * Exports $wgBookstoreListEn
322 * @return array
323 */
326 }
328 /**
329 * @return array
330 */
347 }
349 # Sometimes a language will be localised but not actually exist on this wiki.
353 }
354 }
356 # The above mixing may leave namespaces out of canonical order.
357 # Re-order by namespace ID number...
361 }
363 }
365 /**
366 * A convenience function that returns the same thing as
367 * getNamespaces() except with the array values changed to ' '
368 * where it found '_', useful for producing output to be displayed
369 * e.g. in <select> forms.
370 *
371 * @return array
372 */
377 }
379 }
381 /**
382 * Get a namespace value by key
383 * <code>
384 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
385 * echo $mw_ns; // prints 'MediaWiki'
386 * </code>
387 *
388 * @param $index Int: the array key of the namespace to return
389 * @return mixed, string if the namespace value exists, otherwise false
390 */
394 }
396 /**
397 * A convenience function that returns the same thing as
398 * getNsText() except with '_' changed to ' ', useful for
399 * producing output.
400 *
401 * @param $index string
402 *
403 * @return array
404 */
408 }
410 /**
411 * Returns gender-dependent namespace alias if available.
412 * @param $index Int: namespace index
413 * @param $gender String: gender key (male, female... )
414 * @return String
415 * @since 1.18
416 */
420 $ns = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
422 }
424 /**
425 * Whether this language makes distinguishes genders for example in
426 * namespaces.
427 * @return bool
428 * @since 1.18
429 */
433 // $wgExtraGenderNamespaces overrides everything
435 } elseif ( isset( $wgExtraNamespaces[NS_USER] ) && isset( $wgExtraNamespaces[NS_USER_TALK] ) ) {
436 /// @todo There may be other gender namespace than NS_USER & NS_USER_TALK in the future
437 // $wgExtraNamespaces overrides any gender aliases specified in i18n files
440 // Check what is in i18n files
443 }
444 }
446 /**
447 * Get a namespace key by value, case insensitive.
448 * Only matches namespace names for the current language, not the
449 * canonical ones defined in Namespace.php.
450 *
451 * @param $text String
452 * @return mixed An integer if $text is a valid value otherwise false
453 */
458 }
460 /**
461 * @return array
462 */
474 }
475 }
476 }
479 $genders = $wgExtraGenderNamespaces + self::$dataCache->getItem( $this->mCode, 'namespaceGenderAliases' );
483 }
484 }
487 }
489 }
491 /**
492 * @return array
493 */
497 # Put namespace names and aliases into a hashtable.
498 # If this is too slow, then we should arrange it so that it is done
499 # before caching. The catch is that at pre-cache time, the above
500 # class-specific fixup hasn't been done.
504 }
507 }
511 }
512 }
513 }
515 }
517 /**
518 * Get a namespace key by value, case insensitive. Canonical namespace
519 * names override custom ones defined for the current language.
520 *
521 * @param $text String
522 * @return mixed An integer if $text is a valid value otherwise false
523 */
529 }
532 }
534 /**
535 * short names for language variants used for language conversion links.
536 *
537 * @param $code String
538 * @param $usemsg bool Use the "variantname-xyz" message if it exists
539 * @return string
540 */
546 }
551 # otherwise, output the language code
553 }
554 }
556 /**
557 * @param $name string
558 * @return string
559 */
564 }
566 }
568 /**
569 * @return array
570 */
579 );
580 }
582 /**
583 * @return array
584 */
587 }
589 /**
590 * @return array
591 */
594 }
596 /**
597 * @return array|string
598 */
606 }
607 }
609 /**
610 * @return array
611 */
614 }
616 /**
617 * @param $image
618 * @return array|null
619 */
622 }
624 /**
625 * @return array
626 */
629 }
631 /**
632 * @param $tog
633 * @return string
634 */
637 }
639 /**
640 * Get language names, indexed by code.
641 * If $customisedOnly is true, only returns codes with a messages file
642 *
643 * @param $customisedOnly bool
644 *
645 * @return array
646 */
653 }
658 }
667 }
668 }
671 }
673 /**
674 * Get translated language names. This is done on best effort and
675 * by default this is exactly the same as Language::getLanguageNames.
676 * The CLDR extension provides translated names.
677 * @param $code String Language code.
678 * @return Array language code => language name
679 * @since 1.18.0
680 */
687 }
690 }
692 /**
693 * Get a message from the MediaWiki namespace.
694 *
695 * @param $msg String: message name
696 * @return string
697 */
700 }
702 /**
703 * @param $code string
704 * @return string
705 */
710 }
712 }
714 /**
715 * @param $key string
716 * @return string
717 */
720 }
722 /**
723 * @return array
724 */
729 }
731 }
733 /**
734 * @param $key string
735 * @return string
736 */
739 }
741 /**
742 * @param $key string
743 * @return string
744 */
747 }
749 /**
750 * @return array
751 */
756 }
758 }
760 /**
761 * @param $key string
762 * @return string
763 */
766 }
768 /**
769 * @param $key string
770 * @return string
771 */
774 }
776 /**
777 * @param $key string
778 * @return string
779 */
782 }
784 /**
785 * @param $key string
786 * @return string
787 */
790 }
792 /**
793 * @param $key string
794 * @return string
795 */
798 }
800 /**
801 * @param $key string
802 * @return string
803 */
806 }
808 /**
809 * Used by date() and time() to adjust the time output.
810 *
811 * @param $ts Int the time in date('YmdHis') format
812 * @param $tz Mixed: adjust the time by this amount (default false, mean we
813 * get user timecorrection setting)
814 * @return int
815 */
821 }
834 }
835 # Unrecognized timezone, default to 'Offset' with the stored offset.
837 }
841 # Global offset in minutes.
844 }
855 }
858 }
859 }
861 # No difference ? Return time unchanged
864 }
867 # Generate an adjusted date; take advantage of the fact that mktime
868 # will normalize out-of-range values so we don't have to split $minDiff
869 # into hours and minutes.
882 }
884 /**
885 * This is a workalike of PHP's date() function, but with better
886 * internationalisation, a reduced set of format characters, and a better
887 * escaping format.
888 *
889 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
890 * PHP manual for definitions. There are a number of extensions, which
891 * start with "x":
892 *
893 * xn Do not translate digits of the next numeric format character
894 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
895 * xr Use roman numerals for the next numeric format character
896 * xh Use hebrew numerals for the next numeric format character
897 * xx Literal x
898 * xg Genitive month name
899 *
900 * xij j (day number) in Iranian calendar
901 * xiF F (month name) in Iranian calendar
902 * xin n (month number) in Iranian calendar
903 * xiY Y (full year) in Iranian calendar
904 *
905 * xjj j (day number) in Hebrew calendar
906 * xjF F (month name) in Hebrew calendar
907 * xjt t (days in month) in Hebrew calendar
908 * xjx xg (genitive month name) in Hebrew calendar
909 * xjn n (month number) in Hebrew calendar
910 * xjY Y (full year) in Hebrew calendar
911 *
912 * xmj j (day number) in Hijri calendar
913 * xmF F (month name) in Hijri calendar
914 * xmn n (month number) in Hijri calendar
915 * xmY Y (full year) in Hijri calendar
916 *
917 * xkY Y (full year) in Thai solar calendar. Months and days are
918 * identical to the Gregorian calendar
919 * xoY Y (full year) in Minguo calendar or Juche year.
920 * Months and days are identical to the
921 * Gregorian calendar
922 * xtY Y (full year) in Japanese nengo. Months and days are
923 * identical to the Gregorian calendar
924 *
925 * Characters enclosed in double quotes will be considered literal (with
926 * the quotes themselves removed). Unmatched quotes will be considered
927 * literal quotes. Example:
928 *
929 * "The month is" F => The month is January
930 * i's" => 20'11"
931 *
932 * Backslash escaping is also supported.
933 *
934 * Input timestamp is assumed to be pre-normalized to the desired local
935 * time zone, if any.
936 *
937 * @param $format String
938 * @param $ts String: 14-character timestamp
939 * YYYYMMDDHHMMSS
940 * 01234567890123
941 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
942 *
943 * @return string
944 */
963 }
965 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
967 }
1005 }
1011 }
1017 }
1023 }
1029 }
1036 }
1042 }
1048 }
1057 }
1063 }
1069 }
1084 }
1090 }
1096 }
1102 }
1108 }
1114 }
1120 }
1129 }
1135 }
1141 }
1147 }
1153 }
1159 }
1194 }
1200 }
1206 }
1210 # Backslash escaping
1215 }
1218 # Quoted literal
1222 # No terminating quote, assume literal "
1227 }
1229 # Quote at end of string, assume literal "
1231 }
1235 }
1248 }
1249 }
1250 }
1252 }
1257 /**
1258 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1259 * Gregorian dates to Iranian dates. Originally written in C, it
1260 * is released under the terms of GNU Lesser General Public
1261 * License. Conversion to PHP was performed by Niklas Laxström.
1262 *
1263 * Link: http://www.farsiweb.info/jalali/jalali.c
1264 *
1265 * @param $ts string
1266 *
1267 * @return string
1268 */
1274 # Days passed from the beginning (including leap years)
1280 // Add days of the past months of this year
1283 }
1285 // Leap years
1288 }
1290 // Days passed in current month
1304 }
1308 }
1314 }
1316 /**
1317 * Converting Gregorian dates to Hijri dates.
1318 *
1319 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1320 *
1321 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1322 *
1323 * @param $ts string
1324 *
1325 * @return string
1326 */
1340 )
1341 {
1349 }
1354 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1355 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1361 }
1363 /**
1364 * Converting Gregorian dates to Hebrew dates.
1365 *
1366 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1367 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1368 * to translate the relevant functions into PHP and release them under
1369 * GNU GPL.
1370 *
1371 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1372 * and Adar II is 14. In a non-leap year, Adar is 6.
1373 *
1374 * @param $ts string
1375 *
1376 * @return string
1377 */
1379 # Parse date
1384 # Calculate Hebrew year
1387 # Month number when September = 1, August = 12
1390 # Next year
1394 }
1396 # Calculate day of year from 1 September
1400 # February
1402 # Check if the year is leap
1405 }
1410 }
1411 }
1413 # Calculate the start of the Hebrew year
1416 # Calculate next year's start
1418 # Day is before the start of the year - it is the previous year
1419 # Next year's start
1421 # Previous year
1424 # Add days since previous year's 1 September
1427 # Leap year
1429 }
1430 # Start of the new (previous) year
1433 # Next year's start
1435 }
1437 # Calculate Hebrew day of year
1440 # Difference between year's days
1442 # Add 12 (or 13 for leap years) days to ignore the difference between
1443 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1444 # difference is only about the year type
1449 }
1451 # Check the year pattern, and is leap year
1452 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1453 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1454 # and non-leap years
1456 # Check if leap year
1459 # Calculate day in the month from number of day in the Hebrew year
1460 # Don't check Adar - if the day is not in Adar, we will stop before;
1461 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1466 # Calculate days in this month
1468 # Adar in a leap year
1470 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1473 # Day in Adar I
1476 # Subtract the days of Adar I
1478 # Try Adar II
1481 # Day in Adar II
1483 }
1484 }
1485 }
1487 # Cheshvan in a complete year (otherwise as the rule below)
1490 # Kislev in an incomplete year (otherwise as the rule below)
1493 # Odd months have 30 days, even have 29
1495 }
1497 # In the current month
1500 # Subtract the days of the current month
1502 # Try in the next month
1504 }
1505 }
1508 }
1510 /**
1511 * This calculates the Hebrew year start, as days since 1 September.
1512 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1513 * Used for Hebrew date.
1514 *
1515 * @param $year int
1516 *
1517 * @return string
1518 */
1525 }
1529 }
1539 }
1543 }
1545 /**
1546 * Algorithm to convert Gregorian dates to Thai solar dates,
1547 * Minguo dates or Minguo dates.
1548 *
1549 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1550 * http://en.wikipedia.org/wiki/Minguo_calendar
1551 * http://en.wikipedia.org/wiki/Japanese_era_name
1552 *
1553 * @param $ts String: 14-character timestamp
1554 * @param $cName String: calender name
1555 * @return Array: converted year, month, day
1556 */
1563 # Thai solar dates
1564 # Add 543 years to the Gregorian calendar
1565 # Months and days are identical
1568 # Minguo dates
1569 # Deduct 1911 years from the Gregorian calendar
1570 # Months and days are identical
1573 # Nengō dates up to Meiji period
1574 # Deduct years from the Gregorian calendar
1575 # depending on the nengo periods
1576 # Months and days are identical
1577 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1578 # Meiji period
1583 }
1591 )
1592 {
1593 # Taishō period
1598 }
1604 )
1605 {
1606 # Shōwa period
1611 }
1614 # Heisei period
1619 }
1621 }
1624 }
1627 }
1629 /**
1630 * Roman number formatting up to 3000
1631 *
1632 * @param $num int
1633 *
1634 * @return string
1635 */
1642 );
1647 }
1653 }
1655 }
1657 }
1659 /**
1660 * Hebrew Gematria number formatting up to 9999
1661 *
1662 * @param $num int
1663 *
1664 * @return string
1665 */
1672 );
1677 }
1689 }
1690 }
1691 }
1693 }
1699 }
1718 }
1720 }
1722 /**
1723 * This is meant to be used by time(), date(), and timeanddate() to get
1724 * the date preference they're supposed to use, it should be used in
1725 * all children.
1726 *
1727 *<code>
1728 * function timeanddate([...], $format = true) {
1729 * $datePreference = $this->dateFormat($format);
1730 * [...]
1731 * }
1732 *</code>
1733 *
1734 * @param $usePrefs Mixed: if true, the user's preference is used
1735 * if false, the site/language default is used
1736 * if int/string, assumed to be a format.
1737 * @return string
1738 */
1747 }
1750 }
1752 // return int
1755 }
1758 }
1760 /**
1761 * Get a format string for a given type and preference
1762 * @param $type string May be date, time or both
1763 * @param $pref string The format name as it appears in Messages*.php
1764 *
1765 * @return string
1766 */
1777 }
1778 }
1780 }
1782 }
1784 /**
1785 * @param $ts Mixed: the time format which needs to be turned into a
1786 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1787 * @param $adj Bool: whether to adjust the time output according to the
1788 * user configured offset ($timecorrection)
1789 * @param $format Mixed: true to use user's date format preference
1790 * @param $timecorrection String|bool the time offset as returned by
1791 * validateTimeZone() in Special:Preferences
1792 * @return string
1793 */
1798 }
1801 }
1803 /**
1804 * @param $ts Mixed: the time format which needs to be turned into a
1805 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1806 * @param $adj Bool: whether to adjust the time output according to the
1807 * user configured offset ($timecorrection)
1808 * @param $format Mixed: true to use user's date format preference
1809 * @param $timecorrection String|bool the time offset as returned by
1810 * validateTimeZone() in Special:Preferences
1811 * @return string
1812 */
1817 }
1820 }
1822 /**
1823 * @param $ts Mixed: the time format which needs to be turned into a
1824 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1825 * @param $adj Bool: whether to adjust the time output according to the
1826 * user configured offset ($timecorrection)
1827 * @param $format Mixed: what format to return, if it's false output the
1828 * default one (default true)
1829 * @param $timecorrection String|bool the time offset as returned by
1830 * validateTimeZone() in Special:Preferences
1831 * @return string
1832 */
1837 }
1840 }
1842 /**
1843 * @param $key string
1844 * @return array|null
1845 */
1848 }
1850 /**
1851 * @return array
1852 */
1855 }
1857 /**
1858 * @param $in
1859 * @param $out
1860 * @param $string
1861 * @return string
1862 */
1864 # This is a wrapper for iconv in all languages except esperanto,
1865 # which does some nasty x-conversions beforehand
1867 # Even with //IGNORE iconv can whine about illegal characters in
1868 # *input* string. We just ignore those too.
1869 # REF: http://bugs.php.net/bug.php?id=37166
1870 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1875 }
1877 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1879 /**
1880 * @param $matches array
1881 * @return mixed|string
1882 */
1885 }
1887 /**
1888 * @param $matches array
1889 * @return string
1890 */
1893 }
1895 /**
1896 * @param $matches array
1897 * @return string
1898 */
1902 }
1904 /**
1905 * @param $matches array
1906 * @return string
1907 */
1911 }
1913 /**
1914 * @param $matches array
1915 * @return string
1916 */
1919 }
1921 /**
1922 * @param $matches array
1923 * @return string
1924 */
1928 }
1930 /**
1931 * Make a string's first character uppercase
1932 *
1933 * @param $str string
1934 *
1935 * @return string
1936 */
1944 // fall back to more complex logic in case of multibyte strings
1946 }
1947 }
1949 /**
1950 * Convert a string to uppercase
1951 *
1952 * @param $str string
1953 * @param $first bool
1954 *
1955 * @return string
1956 */
1964 }
1967 }
1974 $str
1975 );
1978 }
1979 }
1980 }
1982 /**
1983 * @param $str string
1984 * @return mixed|string
1985 */
1997 }
1998 }
2000 /**
2001 * @param $str string
2002 * @param $first bool
2003 * @return mixed|string
2004 */
2012 }
2015 }
2022 $str
2023 );
2026 }
2027 }
2028 }
2030 /**
2031 * @param $str string
2032 * @return bool
2033 */
2036 }
2038 /**
2039 * @param $str string
2040 * @return mixed|string
2041 */
2046 // regexp to find first letter in each word (i.e. after each space)
2047 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2049 // function to use to capitalize a single char
2054 $str
2055 );
2060 $str
2061 );
2062 }
2065 }
2066 }
2068 /**
2069 * capitalize words at word breaks
2070 *
2071 * @param $str string
2072 * @return mixed
2073 */
2078 // since \b doesn't work for UTF-8, we explicitely define word break chars
2081 // find first letter after word break
2082 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2088 $str
2089 );
2094 $str
2095 );
2096 }
2101 $str
2102 );
2103 }
2104 }
2106 /**
2107 * Return a case-folded representation of $s
2108 *
2109 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2110 * and $s2 are the same except for the case of their characters. It is not
2111 * necessary for the value returned to make sense when displayed.
2112 *
2113 * Do *not* perform any other normalisation in this function. If a caller
2114 * uses this function when it should be using a more general normalisation
2115 * function, then fix the caller.
2116 *
2117 * @param $s string
2118 *
2119 * @return string
2120 */
2123 }
2125 /**
2126 * @param $s string
2127 * @return string
2128 */
2132 }
2133 # Check for non-UTF-8 URLs
2137 }
2143 }
2146 }
2148 /**
2149 * @return array
2150 */
2153 }
2155 /**
2156 * Most writing systems use whitespace to break up words.
2157 * Some languages such as Chinese don't conventionally do this,
2158 * which requires special handling when breaking up words for
2159 * searching etc.
2160 *
2161 * @return bool
2162 */
2165 }
2167 /**
2168 * Some languages such as Chinese require word segmentation,
2169 * Specify such segmentation when overridden in derived class.
2170 *
2171 * @param $string String
2172 * @return String
2173 */
2176 }
2178 /**
2179 * Some languages have special punctuation need to be normalized.
2180 * Make such changes here.
2181 *
2182 * @param $string String
2183 * @return String
2184 */
2187 }
2189 /**
2190 * convert double-width roman characters to single-width.
2191 * range: ff00-ff5f ~= 0020-007f
2192 *
2193 * @param $string string
2194 *
2195 * @return string
2196 */
2206 }
2210 }
2212 /**
2213 * @param $string string
2214 * @param $pattern string
2215 * @return string
2216 */
2221 }
2223 /**
2224 * @param $termsArray array
2225 * @return array
2226 */
2228 # some languages, e.g. Chinese, need to do a conversion
2229 # in order for search results to be displayed correctly
2231 }
2233 /**
2234 * Get the first character of a string.
2235 *
2236 * @param $s string
2237 * @return string
2238 */
2245 $matches
2246 );
2251 }
2253 // Break down Hangul syllables to grab the first jamo
2285 }
2288 }
2289 }
2292 # Some languages may have an alternate char encoding option
2293 # (Esperanto X-coding, Japanese furigana conversion, etc)
2294 # If this language is used as the primary content language,
2295 # an override to the defaults can be set here on startup.
2296 }
2298 /**
2299 * @param $s string
2300 * @return string
2301 */
2303 # For some languages we'll want to explicitly specify
2304 # which characters make it into the edit box raw
2305 # or are converted in some way or another.
2311 }
2312 }
2314 /**
2315 * @param $s string
2316 * @return string
2317 */
2319 # Take the previous into account.
2325 }
2330 }
2331 }
2333 /**
2334 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2335 * also cleans up certain backwards-compatible sequences, converting them
2336 * to the modern Unicode equivalent.
2337 *
2338 * This is language-specific for performance reasons only.
2339 *
2340 * @param $s string
2341 *
2342 * @return string
2343 */
2350 }
2353 }
2355 /**
2356 * Transform a string using serialized data stored in the given file (which
2357 * must be in the serialized subdirectory of $IP). The file contains pairs
2358 * mapping source characters to destination characters.
2359 *
2360 * The data is cached in process memory. This will go faster if you have the
2361 * FastStringSearch extension.
2362 *
2363 * @param $file string
2364 * @param $string string
2365 *
2366 * @return string
2367 */
2373 }
2375 }
2377 }
2379 /**
2380 * For right-to-left language support
2381 *
2382 * @return bool
2383 */
2386 }
2388 /**
2389 * Return the correct HTML 'dir' attribute value for this language.
2390 * @return String
2391 */
2394 }
2396 /**
2397 * Return 'left' or 'right' as appropriate alignment for line-start
2398 * for this language's text direction.
2399 *
2400 * Should be equivalent to CSS3 'start' text-align value....
2401 *
2402 * @return String
2403 */
2406 }
2408 /**
2409 * Return 'right' or 'left' as appropriate alignment for line-end
2410 * for this language's text direction.
2411 *
2412 * Should be equivalent to CSS3 'end' text-align value....
2413 *
2414 * @return String
2415 */
2418 }
2420 /**
2421 * A hidden direction mark (LRM or RLM), depending on the language direction
2422 *
2423 * @param $opposite Boolean Get the direction mark opposite to your language
2424 * @return string
2425 */
2431 }
2433 /**
2434 * @return array
2435 */
2438 }
2440 /**
2441 * An arrow, depending on the language direction
2442 *
2443 * @return string
2444 */
2447 }
2449 /**
2450 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2451 *
2452 * @return bool
2453 */
2456 }
2458 /**
2459 * @return array
2460 */
2463 }
2468 }
2473 }
2475 /**
2476 * Fill a MagicWord object with data from here
2477 *
2478 * @param $mw
2479 */
2491 }
2492 }
2499 }
2500 }
2502 /**
2503 * Add magic words to the extension array
2504 *
2505 * @param $newWords array
2506 */
2513 }
2514 }
2515 }
2517 /**
2518 * Get special page names, as an associative array
2519 * case folded alias => real name
2520 */
2522 // Cache aliases because it may be slow to load them
2524 // Initialise array
2529 }
2532 }
2534 /**
2535 * Italic is unsuitable for some languages
2536 *
2537 * @param $text String: the text to be emphasized.
2538 * @return string
2539 */
2542 }
2544 /**
2545 * Normally we output all numbers in plain en_US style, that is
2546 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2547 * point twohundredthirtyfive. However this is not suitable for all
2548 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2549 * Icelandic just want to use commas instead of dots, and dots instead
2550 * of commas like "293.291,235".
2551 *
2552 * An example of this function being called:
2553 * <code>
2554 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2555 * </code>
2556 *
2557 * See LanguageGu.php for the Gujarati implementation and
2558 * $separatorTransformTable on MessageIs.php for
2559 * the , => . and . => , implementation.
2560 *
2561 * @todo check if it's viable to use localeconv() for the decimal
2562 * separator thing.
2563 * @param $number Mixed: the string to be formatted, should be an integer
2564 * or a floating point number.
2565 * @param $nocommafy Bool: set to true for special numbers like dates
2566 * @return string
2567 */
2575 }
2576 }
2582 }
2583 }
2586 }
2588 /**
2589 * @param $number string
2590 * @return string
2591 */
2596 }
2601 }
2605 }
2607 /**
2608 * Adds commas to a given number
2609 * @since 1.19
2610 * @param $_ mixed
2611 * @return string
2612 */
2617 // default grouping is at thousands, use the same for ###,###,### pattern too.
2620 // Ref: http://cldr.unicode.org/translation/number-patterns
2628 // the string does not have any number part. Eg: .12345
2630 }
2638 }
2642 // use the last pattern for the rest of the number
2644 }
2647 }
2648 }
2650 }
2651 }
2652 /**
2653 * @return String
2654 */
2657 }
2659 /**
2660 * @return array
2661 */
2664 }
2666 /**
2667 * @return array
2668 */
2671 }
2673 /**
2674 * Take a list of strings and build a locale-friendly comma-separated
2675 * list, using the local comma-separator message.
2676 * The last two strings are chained with an "and".
2677 *
2678 * @param $l Array
2679 * @return string
2680 */
2685 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2691 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2694 }
2695 }
2697 }
2698 }
2700 /**
2701 * Take a list of strings and build a locale-friendly comma-separated
2702 * list, using the local comma-separator message.
2703 * @param $list array of strings to put in a comma list
2704 * @return string
2705 */
2712 )
2713 );
2714 }
2716 /**
2717 * Take a list of strings and build a locale-friendly semicolon-separated
2718 * list, using the local semicolon-separator message.
2719 * @param $list array of strings to put in a semicolon list
2720 * @return string
2721 */
2728 )
2729 );
2730 }
2732 /**
2733 * Same as commaList, but separate it with the pipe instead.
2734 * @param $list array of strings to put in a pipe list
2735 * @return string
2736 */
2743 )
2744 );
2745 }
2747 /**
2748 * Truncate a string to a specified length in bytes, appending an optional
2749 * string (e.g. for ellipses)
2750 *
2751 * The database offers limited byte lengths for some columns in the database;
2752 * multi-byte character sets mean we need to ensure that only whole characters
2753 * are included, otherwise broken characters can be passed to the user
2754 *
2755 * If $length is negative, the string will be truncated from the beginning
2756 *
2757 * @param $string String to truncate
2758 * @param $length Int: maximum length (including ellipses)
2759 * @param $ellipsis String to append to the truncated text
2760 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
2761 * $adjustLength was introduced in 1.18, before that behaved as if false.
2762 * @return string
2763 */
2765 # Use the localized ellipsis character
2768 }
2769 # Check if there is no need to truncate
2774 }
2776 # If ellipsis length is >= $length then we can't apply $adjustLength
2779 # Otherwise, truncate and add ellipsis...
2792 }
2793 }
2794 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
2795 # This check is *not* redundant if $adjustLength, due to the single case where
2796 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
2801 }
2802 }
2804 /**
2805 * Remove bytes that represent an incomplete Unicode character
2806 * at the end of string (e.g. bytes of the char are missing)
2807 *
2808 * @param $string String
2809 * @return string
2810 */
2816 # We got the first byte only of a multibyte char; remove it.
2821 {
2822 # We chopped in the middle of a character; remove it
2824 }
2825 }
2827 }
2829 /**
2830 * Remove bytes that represent an incomplete Unicode character
2831 * at the start of string (e.g. bytes of the char are missing)
2832 *
2833 * @param $string String
2834 * @return string
2835 */
2840 # We chopped in the middle of a character; remove the whole thing
2842 }
2843 }
2845 }
2847 /**
2848 * Truncate a string of valid HTML to a specified length in bytes,
2849 * appending an optional string (e.g. for ellipses), and return valid HTML
2850 *
2851 * This is only intended for styled/linked text, such as HTML with
2852 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
2853 * Also, this will not detect things like "display:none" CSS.
2854 *
2855 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
2856 *
2857 * @param string $text HTML string to truncate
2858 * @param int $length (zero/positive) Maximum length (including ellipses)
2859 * @param string $ellipsis String to append to the truncated text
2860 * @return string
2861 */
2863 # Use the localized ellipsis character
2866 }
2867 # Check if there is clearly no need to truncate
2872 }
2886 # Consider truncation once the display length has reached the maximim.
2887 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
2888 # Check that we're not in the middle of a bracket/entity...
2892 # Save where we are; we will truncate here unless there turn out to
2893 # be so few remaining characters that truncation is not necessary.
2896 }
2898 # String in fact does need truncation, the truncation point was OK.
2903 }
2904 }
2907 # Read the next char...
2925 }
2931 // Name found (e.g. "<a href=..."), add on tag attributes...
2933 }
2939 }
2942 // Save state without $ch. We want to *hit* the first
2943 // display char (to get tags) but not *use* it if truncating.
2945 }
2950 // Add the next $max display text chars after this in one swoop...
2955 }
2956 }
2957 }
2958 }
2959 // Close the last tag if left unclosed by bad HTML
2963 }
2965 }
2967 /**
2968 * truncateHtml() helper function
2969 * like strcspn() but adds the skipped chars to $ret
2970 *
2971 * @param $ret
2972 * @param $text
2973 * @param $search
2974 * @param $start
2975 * @param $len
2976 * @return int
2977 */
2983 }
2988 }
2990 }
2992 /**
2993 * truncateHtml() helper function
2994 * (a) push or pop $tag from $openTags as needed
2995 * (b) clear $tag value
2996 * @param String &$tag Current HTML tag name we are looking at
2997 * @param int $tagType (0-open tag, 1-close tag)
2998 * @param char $lastCh Character before the '>' that ended this tag
2999 * @param array &$openTags Open tag stack (not accounting for $tag)
3000 */
3009 }
3010 }
3012 }
3013 }
3015 /**
3016 * Grammatical transformations, needed for inflected languages
3017 * Invoked by putting {{grammar:case|word}} in a message
3018 *
3019 * @param $word string
3020 * @param $case string
3021 * @return string
3022 */
3027 }
3029 }
3031 /**
3032 * Provides an alternative text depending on specified gender.
3033 * Usage {{gender:username|masculine|feminine|neutral}}.
3034 * username is optional, in which case the gender of current user is used,
3035 * but only in (some) interface messages; otherwise default gender is used.
3036 * If second or third parameter are not specified, masculine is used.
3037 * These details may be overriden per language.
3038 *
3039 * @param $gender string
3040 * @param $forms array
3041 *
3042 * @return string
3043 */
3047 }
3051 }
3054 }
3056 }
3058 /**
3059 * Plural form transformations, needed for some languages.
3060 * For example, there are 3 form of plural in Russian and Polish,
3061 * depending on "count mod 10". See [[w:Plural]]
3062 * For English it is pretty simple.
3063 *
3064 * Invoked by putting {{plural:count|wordform1|wordform2}}
3065 * or {{plural:count|wordform1|wordform2|wordform3}}
3066 *
3067 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
3068 *
3069 * @param $count Integer: non-localized number
3070 * @param $forms Array: different plural forms
3071 * @return string Correct form of plural for $count in this language
3072 */
3076 }
3080 }
3082 /**
3083 * Checks that convertPlural was given an array and pads it to requested
3084 * amount of forms by copying the last one.
3085 *
3086 * @param $count Integer: How many forms should there be at least
3087 * @param $forms Array of forms given to convertPlural
3088 * @return array Padded array of forms or an exception if not an array
3089 */
3093 }
3095 }
3097 /**
3098 * This translates the duration ("1 week", "4 days", etc)
3099 * as well as the expiry time (which is an absolute timestamp).
3100 * @param $str String: the validated block duration in English
3101 * @return Somehow translated block duration
3102 * @see LanguageFi.php for example implementation
3103 */
3109 }
3110 }
3112 // Since usually only infinite or indefinite is only on list, so try
3113 // equivalents if still here.
3120 }
3121 }
3122 }
3123 // If no duration is given, but a timestamp, display that
3125 }
3127 /**
3128 * languages like Chinese need to be segmented in order for the diff
3129 * to be of any use
3130 *
3131 * @param $text String
3132 * @return String
3133 */
3136 }
3138 /**
3139 * and unsegment to show the result
3140 *
3141 * @param $text String
3142 * @return String
3143 */
3146 }
3148 /**
3149 * convert text to all supported variants
3150 *
3151 * @param $text string
3152 * @return array
3153 */
3156 }
3158 /**
3159 * convert text to different variants of a language.
3160 *
3161 * @param $text string
3162 * @return string
3163 */
3166 }
3169 /**
3170 * Convert a Title object to a string in the preferred variant
3171 *
3172 * @param $title Title
3173 * @return string
3174 */
3177 }
3179 /**
3180 * Check if this is a language with variants
3181 *
3182 * @return bool
3183 */
3186 }
3188 /**
3189 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3190 *
3191 * @param $text string
3192 * @return string
3193 */
3196 }
3198 /**
3199 * Perform output conversion on a string, and encode for safe HTML output.
3200 * @param $text String text to be converted
3201 * @param $isTitle Bool whether this conversion is for the article title
3202 * @return string
3203 * @todo this should get integrated somewhere sane
3204 */
3207 }
3209 /**
3210 * @param $key string
3211 * @return string
3212 */
3215 }
3217 /**
3218 * Get the list of variants supported by this language
3219 * see sample implementation in LanguageZh.php
3220 *
3221 * @return array an array of language codes
3222 */
3225 }
3227 /**
3228 * @return string
3229 */
3232 }
3234 /**
3235 * @return string
3236 */
3239 }
3241 /**
3242 * @return string
3243 */
3246 }
3248 /**
3249 * If a language supports multiple variants, it is
3250 * possible that non-existing link in one variant
3251 * actually exists in another variant. this function
3252 * tries to find it. See e.g. LanguageZh.php
3253 *
3254 * @param $link String: the name of the link
3255 * @param $nt Mixed: the title object of the link
3256 * @param $ignoreOtherCond Boolean: to disable other conditions when
3257 * we need to transclude a template or update a category's link
3258 * @return null the input parameters may be modified upon return
3259 */
3262 }
3264 /**
3265 * If a language supports multiple variants, converts text
3266 * into an array of all possible variants of the text:
3267 * 'variant' => text in that variant
3268 *
3269 * @deprecated since 1.17 Use autoConvertToAllVariants()
3270 *
3271 * @param $text string
3272 *
3273 * @return string
3274 */
3277 }
3279 /**
3280 * returns language specific options used by User::getPageRenderHash()
3281 * for example, the preferred language variant
3282 *
3283 * @return string
3284 */
3287 }
3289 /**
3290 * For languages that support multiple variants, the title of an
3291 * article may be displayed differently in different variants. this
3292 * function returns the apporiate title defined in the body of the article.
3293 *
3294 * @return string
3295 */
3298 }
3300 /**
3301 * Enclose a string with the "no conversion" tag. This is used by
3302 * various functions in the Parser
3303 *
3304 * @param $text String: text to be tagged for no conversion
3305 * @param $noParse bool
3306 * @return string the tagged text
3307 */
3310 }
3312 /**
3313 * A regular expression to match legal word-trailing characters
3314 * which should be merged onto a link of the form [[foo]]bar.
3315 *
3316 * @return string
3317 */
3320 }
3322 /**
3323 * @return Language
3324 */
3327 }
3329 /**
3330 * Get the RFC 3066 code for this language object
3331 *
3332 * @return string
3333 */
3336 }
3338 /**
3339 * @param $code string
3340 */
3343 }
3345 /**
3346 * Get the name of a file for a certain language code
3347 * @param $prefix string Prepend this to the filename
3348 * @param $code string Language code
3349 * @param $suffix string Append this to the filename
3350 * @return string $prefix . $mangledCode . $suffix
3351 */
3353 // Protect against path traversal
3356 {
3358 }
3361 }
3363 /**
3364 * Get the language code from a file name. Inverse of getFileName()
3365 * @param $filename string $prefix . $languageCode . $suffix
3366 * @param $prefix string Prefix before the language code
3367 * @param $suffix string Suffix after the language code
3368 * @return string Language code, or false if $prefix or $suffix isn't found
3369 */
3376 }
3378 }
3380 /**
3381 * @param $code string
3382 * @return string
3383 */
3387 }
3389 /**
3390 * @param $code string
3391 * @return string
3392 */
3396 }
3398 /**
3399 * Get the first fallback for a given language.
3400 *
3401 * @param $code string
3402 *
3403 * @return false|string
3404 */
3412 }
3413 }
3415 /**
3416 * Get the ordered list of fallback languages.
3417 *
3418 * @since 1.19
3419 * @param $code string Language code
3420 * @return array
3421 */
3430 }
3432 }
3433 }
3435 /**
3436 * Get all messages for a given language
3437 * WARNING: this may take a long time. If you just need all message *keys*
3438 * but need the *contents* of only a few messages, consider using getMessageKeysFor().
3439 *
3440 * @param $code string
3441 *
3442 * @return array
3443 */
3446 }
3448 /**
3449 * Get a message for a given language
3450 *
3451 * @param $key string
3452 * @param $code string
3453 *
3454 * @return string
3455 */
3458 }
3460 /**
3461 * Get all message keys for a given language. This is a faster alternative to
3462 * array_keys( Language::getMessagesFor( $code ) )
3463 *
3464 * @since 1.19
3465 * @param $code string Language code
3466 * @return array of message keys (strings)
3467 */
3470 }
3472 /**
3473 * @param $talk
3474 * @return mixed
3475 */
3479 }
3484 # Allow grammar transformations
3485 # Allowing full message-style parsing would make simple requests
3486 # such as action=raw much more expensive than they need to be.
3487 # This will hopefully cover most cases.
3491 }
3493 /**
3494 * @param $m string
3495 * @return string
3496 */
3499 }
3501 /**
3502 * @throws MWException
3503 * @return array
3504 */
3509 }
3516 }
3521 }
3523 /**
3524 * Decode an expiry (block, protection, etc) which has come from the DB
3525 *
3526 * @param $expiry String: Database expiry String
3527 * @param $format Bool|Int true to process using language functions, or TS_ constant
3528 * to return the expiry in a given timestamp
3529 * @return String
3530 */
3536 }
3540 ? $infinityMsg
3546 }
3547 }
3549 /**
3550 * @todo Document
3551 * @param $seconds int|float
3552 * @param $format Array Optional
3553 * If $format['avoid'] == 'avoidseconds' - don't mention seconds if $seconds >= 1 hour
3554 * If $format['avoid'] == 'avoidminutes' - don't mention seconds/minutes if $seconds > 48 hours
3555 * If $format['noabbrevs'] is true - use 'seconds' and friends instead of 'seconds-abbrev' and friends
3556 * For backwards compatibility, $format may also be one of the strings 'avoidseconds' or 'avoidminutes'
3557 * @return string
3558 */
3562 }
3565 }
3568 }
3590 }
3601 }
3605 }
3611 }
3619 }
3629 }
3633 }
3643 }
3644 }
3646 }
3648 /**
3649 * @param $bps int
3650 * @return string
3651 */
3656 }
3663 }
3665 }
3667 /**
3668 * Format a size in bytes for output, using an appropriate
3669 * unit (B, KB, MB or GB) according to the magnitude in question
3670 *
3671 * @param $size int Size to format
3672 * @return string Plain text (not HTML)
3673 */
3675 // For small sizes no decimal places necessary
3681 // For MB and bigger two decimal places are smarter
3688 }
3691 }
3694 }
3698 }
3700 /**
3701 * Get the conversion rule title, if any.
3702 *
3703 * @return string
3704 */
3707 }
3708 }