| blob | 06b39bd3382281ca357afabbf44a87d9f245b750 |
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 */
63 /**
64 * ReplacementArray object caches
65 */
68 /**
69 * @var LocalisationCache
70 */
78 );
82 );
87 'december'
88 );
92 'december-gen'
93 );
97 );
104 );
112 );
120 );
127 );
129 /**
130 * Get a cached language object for a given language code
131 * @param $code String
132 * @return Language
133 */
137 // Don't keep a billion objects around, that's stupid.
139 }
141 }
143 }
145 /**
146 * Create a language object for a given language code
147 * @param $code String
148 * @return Language
149 */
154 // Protect against path traversal below
157 {
159 }
162 // It's not possible to customise this code with class files, so
163 // just return a Language object. This is to support uselang= hacks.
167 }
174 // Preload base classes to work around APC/PHP5 bug
177 }
180 }
181 }
182 }
186 }
196 }
198 }
200 /**
201 * Returns true if a language code string is of a valid form, whether or
202 * not it exists. This includes codes which are used solely for
203 * customisation via the MediaWiki namespace.
204 *
205 * @param $code string
206 *
207 * @return bool
208 */
210 return
213 }
215 /**
216 * Returns true if a language code is of a valid form for the purposes of
217 * internal customisation of MediaWiki, via Messages*.php.
218 *
219 * @param $code string
220 *
221 * @return bool
222 */
225 }
227 /**
228 * Get the LocalisationCache instance
229 *
230 * @return LocalisationCache
231 */
237 }
239 }
243 // Set the code to the name of the descendant
248 }
250 }
252 /**
253 * Reduce memory usage
254 */
258 }
259 }
261 /**
262 * Hook which will be called if this is the content language.
263 * Descendants can use this to register hook functions or modify globals
264 */
267 /**
268 * @return array|bool
269 */
275 }
276 }
278 /**
279 * Exports $wgBookstoreListEn
280 * @return array
281 */
284 }
286 /**
287 * @return array
288 */
305 }
307 # Sometimes a language will be localised but not actually exist on this wiki.
311 }
312 }
314 # The above mixing may leave namespaces out of canonical order.
315 # Re-order by namespace ID number...
317 }
319 }
321 /**
322 * A convenience function that returns the same thing as
323 * getNamespaces() except with the array values changed to ' '
324 * where it found '_', useful for producing output to be displayed
325 * e.g. in <select> forms.
326 *
327 * @return array
328 */
333 }
335 }
337 /**
338 * Get a namespace value by key
339 * <code>
340 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
341 * echo $mw_ns; // prints 'MediaWiki'
342 * </code>
343 *
344 * @param $index Int: the array key of the namespace to return
345 * @return mixed, string if the namespace value exists, otherwise false
346 */
350 }
352 /**
353 * A convenience function that returns the same thing as
354 * getNsText() except with '_' changed to ' ', useful for
355 * producing output.
356 *
357 * @param $index string
358 *
359 * @return array
360 */
364 }
366 /**
367 * Returns gender-dependent namespace alias if available.
368 * @param $index Int: namespace index
369 * @param $gender String: gender key (male, female... )
370 * @return String
371 * @since 1.18
372 */
376 }
378 /**
379 * Whether this language makes distinguishes genders for example in
380 * namespaces.
381 * @return bool
382 * @since 1.18
383 */
387 }
389 /**
390 * Get a namespace key by value, case insensitive.
391 * Only matches namespace names for the current language, not the
392 * canonical ones defined in Namespace.php.
393 *
394 * @param $text String
395 * @return mixed An integer if $text is a valid value otherwise false
396 */
401 }
403 /**
404 * @return array
405 */
417 }
418 }
419 }
425 }
426 }
429 }
431 }
433 /**
434 * @return array
435 */
439 # Put namespace names and aliases into a hashtable.
440 # If this is too slow, then we should arrange it so that it is done
441 # before caching. The catch is that at pre-cache time, the above
442 # class-specific fixup hasn't been done.
446 }
449 }
453 }
454 }
455 }
457 }
460 /**
461 * Get a namespace key by value, case insensitive. Canonical namespace
462 * names override custom ones defined for the current language.
463 *
464 * @param $text String
465 * @return mixed An integer if $text is a valid value otherwise false
466 */
471 }
474 }
476 /**
477 * short names for language variants used for language conversion links.
478 *
479 * @param $code String
480 * @return string
481 */
484 }
486 /**
487 * @param $name string
488 * @return string
489 */
494 }
496 }
498 /**
499 * @return array
500 */
508 );
509 }
511 /**
512 * @return array
513 */
516 }
518 /**
519 * @return array
520 */
523 }
525 /**
526 * @return array|string
527 */
535 }
536 }
538 /**
539 * @return array
540 */
543 }
545 /**
546 * @param $image
547 * @return array|null
548 */
551 }
553 /**
554 * @return array
555 */
558 }
560 /**
561 * @return array
562 */
565 }
567 /**
568 * @param $tog
569 * @return string
570 */
573 }
575 /**
576 * Get language names, indexed by code.
577 * If $customisedOnly is true, only returns codes with a messages file
578 *
579 * @param $customisedOnly bool
580 *
581 * @return array
582 */
589 }
594 }
603 }
604 }
607 }
609 /**
610 * Get translated language names. This is done on best effort and
611 * by default this is exactly the same as Language::getLanguageNames.
612 * The CLDR extension provides translated names.
613 * @param $code String Language code.
614 * @return Array language code => language name
615 * @since 1.18.0
616 */
623 }
626 }
628 /**
629 * Get a message from the MediaWiki namespace.
630 *
631 * @param $msg String: message name
632 * @return string
633 */
636 }
638 /**
639 * @param $code string
640 * @return string
641 */
646 }
648 }
650 /**
651 * @param $key string
652 * @return string
653 */
656 }
658 /**
659 * @return array
660 */
665 }
667 }
669 /**
670 * @param $key string
671 * @return string
672 */
675 }
677 /**
678 * @param $key string
679 * @return string
680 */
683 }
685 /**
686 * @return array
687 */
692 }
694 }
696 /**
697 * @param $key string
698 * @return string
699 */
702 }
704 /**
705 * @param $key string
706 * @return string
707 */
710 }
712 /**
713 * @param $key string
714 * @return string
715 */
718 }
720 /**
721 * @param $key string
722 * @return string
723 */
726 }
728 /**
729 * @param $key string
730 * @return string
731 */
734 }
736 /**
737 * @param $key string
738 * @return string
739 */
742 }
744 /**
745 * Used by date() and time() to adjust the time output.
746 *
747 * @param $ts Int the time in date('YmdHis') format
748 * @param $tz Mixed: adjust the time by this amount (default false, mean we
749 * get user timecorrection setting)
750 * @return int
751 */
757 }
770 }
771 # Unrecognized timezone, default to 'Offset' with the stored offset.
773 }
777 # Global offset in minutes.
780 }
791 }
794 }
795 }
797 # No difference ? Return time unchanged
800 }
803 # Generate an adjusted date; take advantage of the fact that mktime
804 # will normalize out-of-range values so we don't have to split $minDiff
805 # into hours and minutes.
818 }
820 /**
821 * This is a workalike of PHP's date() function, but with better
822 * internationalisation, a reduced set of format characters, and a better
823 * escaping format.
824 *
825 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
826 * PHP manual for definitions. There are a number of extensions, which
827 * start with "x":
828 *
829 * xn Do not translate digits of the next numeric format character
830 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
831 * xr Use roman numerals for the next numeric format character
832 * xh Use hebrew numerals for the next numeric format character
833 * xx Literal x
834 * xg Genitive month name
835 *
836 * xij j (day number) in Iranian calendar
837 * xiF F (month name) in Iranian calendar
838 * xin n (month number) in Iranian calendar
839 * xiY Y (full year) in Iranian calendar
840 *
841 * xjj j (day number) in Hebrew calendar
842 * xjF F (month name) in Hebrew calendar
843 * xjt t (days in month) in Hebrew calendar
844 * xjx xg (genitive month name) in Hebrew calendar
845 * xjn n (month number) in Hebrew calendar
846 * xjY Y (full year) in Hebrew calendar
847 *
848 * xmj j (day number) in Hijri calendar
849 * xmF F (month name) in Hijri calendar
850 * xmn n (month number) in Hijri calendar
851 * xmY Y (full year) in Hijri calendar
852 *
853 * xkY Y (full year) in Thai solar calendar. Months and days are
854 * identical to the Gregorian calendar
855 * xoY Y (full year) in Minguo calendar or Juche year.
856 * Months and days are identical to the
857 * Gregorian calendar
858 * xtY Y (full year) in Japanese nengo. Months and days are
859 * identical to the Gregorian calendar
860 *
861 * Characters enclosed in double quotes will be considered literal (with
862 * the quotes themselves removed). Unmatched quotes will be considered
863 * literal quotes. Example:
864 *
865 * "The month is" F => The month is January
866 * i's" => 20'11"
867 *
868 * Backslash escaping is also supported.
869 *
870 * Input timestamp is assumed to be pre-normalized to the desired local
871 * time zone, if any.
872 *
873 * @param $format String
874 * @param $ts String: 14-character timestamp
875 * YYYYMMDDHHMMSS
876 * 01234567890123
877 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
878 *
879 * @return string
880 */
899 }
901 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
903 }
941 }
947 }
953 }
959 }
965 }
972 }
978 }
984 }
993 }
999 }
1005 }
1020 }
1026 }
1032 }
1038 }
1044 }
1050 }
1056 }
1065 }
1071 }
1077 }
1083 }
1089 }
1095 }
1130 }
1136 }
1142 }
1146 # Backslash escaping
1151 }
1154 # Quoted literal
1158 # No terminating quote, assume literal "
1163 }
1165 # Quote at end of string, assume literal "
1167 }
1171 }
1184 }
1185 }
1186 }
1188 }
1193 /**
1194 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1195 * Gregorian dates to Iranian dates. Originally written in C, it
1196 * is released under the terms of GNU Lesser General Public
1197 * License. Conversion to PHP was performed by Niklas Laxström.
1198 *
1199 * Link: http://www.farsiweb.info/jalali/jalali.c
1200 *
1201 * @param $ts string
1202 *
1203 * @return string
1204 */
1210 # Days passed from the beginning (including leap years)
1217 // Add days of the past months of this year
1220 }
1222 // Leap years
1225 }
1227 // Days passed in current month
1241 }
1245 }
1251 }
1253 /**
1254 * Converting Gregorian dates to Hijri dates.
1255 *
1256 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1257 *
1258 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1259 *
1260 * @param $ts string
1261 *
1262 * @return string
1263 */
1277 )
1278 {
1286 }
1291 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1292 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1298 }
1300 /**
1301 * Converting Gregorian dates to Hebrew dates.
1302 *
1303 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1304 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1305 * to translate the relevant functions into PHP and release them under
1306 * GNU GPL.
1307 *
1308 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1309 * and Adar II is 14. In a non-leap year, Adar is 6.
1310 *
1311 * @param $ts string
1312 *
1313 * @return string
1314 */
1316 # Parse date
1321 # Calculate Hebrew year
1324 # Month number when September = 1, August = 12
1327 # Next year
1331 }
1333 # Calculate day of year from 1 September
1337 # February
1339 # Check if the year is leap
1342 }
1347 }
1348 }
1350 # Calculate the start of the Hebrew year
1353 # Calculate next year's start
1355 # Day is before the start of the year - it is the previous year
1356 # Next year's start
1358 # Previous year
1361 # Add days since previous year's 1 September
1364 # Leap year
1366 }
1367 # Start of the new (previous) year
1370 # Next year's start
1372 }
1374 # Calculate Hebrew day of year
1377 # Difference between year's days
1379 # Add 12 (or 13 for leap years) days to ignore the difference between
1380 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1381 # difference is only about the year type
1386 }
1388 # Check the year pattern, and is leap year
1389 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1390 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1391 # and non-leap years
1393 # Check if leap year
1396 # Calculate day in the month from number of day in the Hebrew year
1397 # Don't check Adar - if the day is not in Adar, we will stop before;
1398 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1403 # Calculate days in this month
1405 # Adar in a leap year
1407 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1410 # Day in Adar I
1413 # Subtract the days of Adar I
1415 # Try Adar II
1418 # Day in Adar II
1420 }
1421 }
1422 }
1424 # Cheshvan in a complete year (otherwise as the rule below)
1427 # Kislev in an incomplete year (otherwise as the rule below)
1430 # Odd months have 30 days, even have 29
1432 }
1434 # In the current month
1437 # Subtract the days of the current month
1439 # Try in the next month
1441 }
1442 }
1445 }
1447 /**
1448 * This calculates the Hebrew year start, as days since 1 September.
1449 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1450 * Used for Hebrew date.
1451 *
1452 * @param $year int
1453 *
1454 * @return string
1455 */
1462 }
1466 }
1476 }
1480 }
1482 /**
1483 * Algorithm to convert Gregorian dates to Thai solar dates,
1484 * Minguo dates or Minguo dates.
1485 *
1486 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1487 * http://en.wikipedia.org/wiki/Minguo_calendar
1488 * http://en.wikipedia.org/wiki/Japanese_era_name
1489 *
1490 * @param $ts String: 14-character timestamp
1491 * @param $cName String: calender name
1492 * @return Array: converted year, month, day
1493 */
1500 # Thai solar dates
1501 # Add 543 years to the Gregorian calendar
1502 # Months and days are identical
1505 # Minguo dates
1506 # Deduct 1911 years from the Gregorian calendar
1507 # Months and days are identical
1510 # Nengō dates up to Meiji period
1511 # Deduct years from the Gregorian calendar
1512 # depending on the nengo periods
1513 # Months and days are identical
1514 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1515 # Meiji period
1520 }
1528 )
1529 {
1530 # Taishō period
1535 }
1541 )
1542 {
1543 # Shōwa period
1548 }
1551 # Heisei period
1556 }
1558 }
1561 }
1564 }
1566 /**
1567 * Roman number formatting up to 3000
1568 *
1569 * @param $num int
1570 *
1571 * @return string
1572 */
1579 );
1584 }
1590 }
1592 }
1594 }
1596 /**
1597 * Hebrew Gematria number formatting up to 9999
1598 *
1599 * @param $num int
1600 *
1601 * @return string
1602 */
1609 );
1614 }
1626 }
1627 }
1628 }
1630 }
1636 }
1655 }
1657 }
1659 /**
1660 * This is meant to be used by time(), date(), and timeanddate() to get
1661 * the date preference they're supposed to use, it should be used in
1662 * all children.
1663 *
1664 *<code>
1665 * function timeanddate([...], $format = true) {
1666 * $datePreference = $this->dateFormat($format);
1667 * [...]
1668 * }
1669 *</code>
1670 *
1671 * @param $usePrefs Mixed: if true, the user's preference is used
1672 * if false, the site/language default is used
1673 * if int/string, assumed to be a format.
1674 * @return string
1675 */
1684 }
1687 }
1689 // return int
1692 }
1695 }
1697 /**
1698 * Get a format string for a given type and preference
1699 * @param $type string May be date, time or both
1700 * @param $pref string The format name as it appears in Messages*.php
1701 *
1702 * @return string
1703 */
1714 }
1715 }
1717 }
1719 }
1721 /**
1722 * @param $ts Mixed: the time format which needs to be turned into a
1723 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1724 * @param $adj Bool: whether to adjust the time output according to the
1725 * user configured offset ($timecorrection)
1726 * @param $format Mixed: true to use user's date format preference
1727 * @param $timecorrection String|bool the time offset as returned by
1728 * validateTimeZone() in Special:Preferences
1729 * @return string
1730 */
1735 }
1738 }
1740 /**
1741 * @param $ts Mixed: the time format which needs to be turned into a
1742 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1743 * @param $adj Bool: whether to adjust the time output according to the
1744 * user configured offset ($timecorrection)
1745 * @param $format Mixed: true to use user's date format preference
1746 * @param $timecorrection String|bool the time offset as returned by
1747 * validateTimeZone() in Special:Preferences
1748 * @return string
1749 */
1754 }
1757 }
1759 /**
1760 * @param $ts Mixed: the time format which needs to be turned into a
1761 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1762 * @param $adj Bool: whether to adjust the time output according to the
1763 * user configured offset ($timecorrection)
1764 * @param $format Mixed: what format to return, if it's false output the
1765 * default one (default true)
1766 * @param $timecorrection String|bool the time offset as returned by
1767 * validateTimeZone() in Special:Preferences
1768 * @return string
1769 */
1774 }
1777 }
1779 /**
1780 * @param $key string
1781 * @return array|null
1782 */
1785 }
1787 /**
1788 * @return array
1789 */
1792 }
1794 /**
1795 * @param $in
1796 * @param $out
1797 * @param $string
1798 * @return string
1799 */
1801 # This is a wrapper for iconv in all languages except esperanto,
1802 # which does some nasty x-conversions beforehand
1804 # Even with //IGNORE iconv can whine about illegal characters in
1805 # *input* string. We just ignore those too.
1806 # REF: http://bugs.php.net/bug.php?id=37166
1807 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1812 }
1814 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1816 /**
1817 * @param $matches array
1818 * @return mixed|string
1819 */
1822 }
1824 /**
1825 * @param $matches array
1826 * @return string
1827 */
1830 }
1832 /**
1833 * @param $matches array
1834 * @return string
1835 */
1839 }
1841 /**
1842 * @param $matches array
1843 * @return string
1844 */
1848 }
1850 /**
1851 * @param $matches array
1852 * @return string
1853 */
1856 }
1858 /**
1859 * @param $matches array
1860 * @return string
1861 */
1865 }
1867 /**
1868 * Make a string's first character uppercase
1869 *
1870 * @param $str string
1871 *
1872 * @return string
1873 */
1881 // fall back to more complex logic in case of multibyte strings
1883 }
1884 }
1886 /**
1887 * Convert a string to uppercase
1888 *
1889 * @param $str string
1890 * @param $first bool
1891 *
1892 * @return string
1893 */
1901 }
1904 }
1911 $str
1912 );
1915 }
1916 }
1917 }
1919 /**
1920 * @param $str string
1921 * @return mixed|string
1922 */
1934 }
1935 }
1937 /**
1938 * @param $str string
1939 * @param $first bool
1940 * @return mixed|string
1941 */
1949 }
1952 }
1959 $str
1960 );
1963 }
1964 }
1965 }
1967 /**
1968 * @param $str string
1969 * @return bool
1970 */
1973 }
1975 /**
1976 * @param $str string
1977 * @return mixed|string
1978 */
1983 // regexp to find first letter in each word (i.e. after each space)
1984 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1986 // function to use to capitalize a single char
1991 $str
1992 );
1997 $str
1998 );
1999 }
2002 }
2003 }
2005 /**
2006 * capitalize words at word breaks
2007 *
2008 * @param $str string
2009 * @return mixed
2010 */
2015 // since \b doesn't work for UTF-8, we explicitely define word break chars
2018 // find first letter after word break
2019 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2025 $str
2026 );
2031 $str
2032 );
2033 }
2038 $str
2039 );
2040 }
2041 }
2043 /**
2044 * Return a case-folded representation of $s
2045 *
2046 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2047 * and $s2 are the same except for the case of their characters. It is not
2048 * necessary for the value returned to make sense when displayed.
2049 *
2050 * Do *not* perform any other normalisation in this function. If a caller
2051 * uses this function when it should be using a more general normalisation
2052 * function, then fix the caller.
2053 *
2054 * @param $s string
2055 *
2056 * @return string
2057 */
2060 }
2062 /**
2063 * @param $s string
2064 * @return string
2065 */
2069 }
2070 # Check for non-UTF-8 URLs
2074 }
2080 }
2083 }
2085 /**
2086 * @return array
2087 */
2090 }
2092 /**
2093 * Most writing systems use whitespace to break up words.
2094 * Some languages such as Chinese don't conventionally do this,
2095 * which requires special handling when breaking up words for
2096 * searching etc.
2097 *
2098 * @return bool
2099 */
2102 }
2104 /**
2105 * Some languages such as Chinese require word segmentation,
2106 * Specify such segmentation when overridden in derived class.
2107 *
2108 * @param $string String
2109 * @return String
2110 */
2113 }
2115 /**
2116 * Some languages have special punctuation need to be normalized.
2117 * Make such changes here.
2118 *
2119 * @param $string String
2120 * @return String
2121 */
2124 }
2126 /**
2127 * convert double-width roman characters to single-width.
2128 * range: ff00-ff5f ~= 0020-007f
2129 *
2130 * @param $string string
2131 *
2132 * @return string
2133 */
2143 }
2147 }
2149 /**
2150 * @param $string string
2151 * @param $pattern string
2152 * @return string
2153 */
2158 }
2160 /**
2161 * @param $termsArray array
2162 * @return array
2163 */
2165 # some languages, e.g. Chinese, need to do a conversion
2166 # in order for search results to be displayed correctly
2168 }
2170 /**
2171 * Get the first character of a string.
2172 *
2173 * @param $s string
2174 * @return string
2175 */
2182 $matches
2183 );
2188 }
2190 // Break down Hangul syllables to grab the first jamo
2222 }
2225 }
2226 }
2229 # Some languages may have an alternate char encoding option
2230 # (Esperanto X-coding, Japanese furigana conversion, etc)
2231 # If this language is used as the primary content language,
2232 # an override to the defaults can be set here on startup.
2233 }
2235 /**
2236 * @param $s string
2237 * @return string
2238 */
2240 # For some languages we'll want to explicitly specify
2241 # which characters make it into the edit box raw
2242 # or are converted in some way or another.
2248 }
2249 }
2251 /**
2252 * @param $s string
2253 * @return string
2254 */
2256 # Take the previous into account.
2262 }
2267 }
2268 }
2270 /**
2271 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2272 * also cleans up certain backwards-compatible sequences, converting them
2273 * to the modern Unicode equivalent.
2274 *
2275 * This is language-specific for performance reasons only.
2276 *
2277 * @param $s string
2278 *
2279 * @return string
2280 */
2287 }
2290 }
2292 /**
2293 * Transform a string using serialized data stored in the given file (which
2294 * must be in the serialized subdirectory of $IP). The file contains pairs
2295 * mapping source characters to destination characters.
2296 *
2297 * The data is cached in process memory. This will go faster if you have the
2298 * FastStringSearch extension.
2299 *
2300 * @param $file string
2301 * @param $string string
2302 *
2303 * @return string
2304 */
2310 }
2312 }
2314 }
2316 /**
2317 * For right-to-left language support
2318 *
2319 * @return bool
2320 */
2323 }
2325 /**
2326 * Return the correct HTML 'dir' attribute value for this language.
2327 * @return String
2328 */
2331 }
2333 /**
2334 * Return 'left' or 'right' as appropriate alignment for line-start
2335 * for this language's text direction.
2336 *
2337 * Should be equivalent to CSS3 'start' text-align value....
2338 *
2339 * @return String
2340 */
2343 }
2345 /**
2346 * Return 'right' or 'left' as appropriate alignment for line-end
2347 * for this language's text direction.
2348 *
2349 * Should be equivalent to CSS3 'end' text-align value....
2350 *
2351 * @return String
2352 */
2355 }
2357 /**
2358 * A hidden direction mark (LRM or RLM), depending on the language direction
2359 *
2360 * @return string
2361 */
2364 }
2366 /**
2367 * @return array
2368 */
2371 }
2373 /**
2374 * An arrow, depending on the language direction
2375 *
2376 * @return string
2377 */
2380 }
2382 /**
2383 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2384 *
2385 * @return bool
2386 */
2389 }
2391 /**
2392 * @return array
2393 */
2396 }
2401 }
2406 }
2408 /**
2409 * Fill a MagicWord object with data from here
2410 *
2411 * @param $mw
2412 */
2424 }
2425 }
2432 }
2433 }
2435 /**
2436 * Add magic words to the extension array
2437 *
2438 * @param $newWords array
2439 */
2446 }
2449 }
2454 }
2455 }
2456 }
2458 /**
2459 * Get special page names, as an associative array
2460 * case folded alias => real name
2461 */
2463 // Cache aliases because it may be slow to load them
2465 // Initialise array
2470 }
2473 }
2475 /**
2476 * Italic is unsuitable for some languages
2477 *
2478 * @param $text String: the text to be emphasized.
2479 * @return string
2480 */
2483 }
2485 /**
2486 * Normally we output all numbers in plain en_US style, that is
2487 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2488 * point twohundredthirtyfive. However this is not sutable for all
2489 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2490 * Icelandic just want to use commas instead of dots, and dots instead
2491 * of commas like "293.291,235".
2492 *
2493 * An example of this function being called:
2494 * <code>
2495 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2496 * </code>
2497 *
2498 * See LanguageGu.php for the Gujarati implementation and
2499 * $separatorTransformTable on MessageIs.php for
2500 * the , => . and . => , implementation.
2501 *
2502 * @todo check if it's viable to use localeconv() for the decimal
2503 * separator thing.
2504 * @param $number Mixed: the string to be formatted, should be an integer
2505 * or a floating point number.
2506 * @param $nocommafy Bool: set to true for special numbers like dates
2507 * @return string
2508 */
2516 }
2517 }
2523 }
2524 }
2527 }
2529 /**
2530 * @param $number string
2531 * @return string
2532 */
2537 }
2542 }
2546 }
2548 /**
2549 * Adds commas to a given number
2550 *
2551 * @param $_ mixed
2552 * @return string
2553 */
2556 }
2558 /**
2559 * @return array
2560 */
2563 }
2565 /**
2566 * @return array
2567 */
2570 }
2572 /**
2573 * Take a list of strings and build a locale-friendly comma-separated
2574 * list, using the local comma-separator message.
2575 * The last two strings are chained with an "and".
2576 *
2577 * @param $l Array
2578 * @return string
2579 */
2584 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2590 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2593 }
2594 }
2596 }
2597 }
2599 /**
2600 * Take a list of strings and build a locale-friendly comma-separated
2601 * list, using the local comma-separator message.
2602 * @param $list array of strings to put in a comma list
2603 * @return string
2604 */
2611 )
2612 );
2613 }
2615 /**
2616 * Take a list of strings and build a locale-friendly semicolon-separated
2617 * list, using the local semicolon-separator message.
2618 * @param $list array of strings to put in a semicolon list
2619 * @return string
2620 */
2627 )
2628 );
2629 }
2631 /**
2632 * Same as commaList, but separate it with the pipe instead.
2633 * @param $list array of strings to put in a pipe list
2634 * @return string
2635 */
2642 )
2643 );
2644 }
2646 /**
2647 * Truncate a string to a specified length in bytes, appending an optional
2648 * string (e.g. for ellipses)
2649 *
2650 * The database offers limited byte lengths for some columns in the database;
2651 * multi-byte character sets mean we need to ensure that only whole characters
2652 * are included, otherwise broken characters can be passed to the user
2653 *
2654 * If $length is negative, the string will be truncated from the beginning
2655 *
2656 * @param $string String to truncate
2657 * @param $length Int: maximum length (including ellipses)
2658 * @param $ellipsis String to append to the truncated text
2659 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
2660 * $adjustLength was introduced in 1.18, before that behaved as if false.
2661 * @return string
2662 */
2664 # Use the localized ellipsis character
2667 }
2668 # Check if there is no need to truncate
2673 }
2675 # If ellipsis length is >= $length then we can't apply $adjustLength
2678 # Otherwise, truncate and add ellipsis...
2691 }
2692 }
2693 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
2694 # This check is *not* redundant if $adjustLength, due to the single case where
2695 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
2700 }
2701 }
2703 /**
2704 * Remove bytes that represent an incomplete Unicode character
2705 * at the end of string (e.g. bytes of the char are missing)
2706 *
2707 * @param $string String
2708 * @return string
2709 */
2715 # We got the first byte only of a multibyte char; remove it.
2720 {
2721 # We chopped in the middle of a character; remove it
2723 }
2724 }
2726 }
2728 /**
2729 * Remove bytes that represent an incomplete Unicode character
2730 * at the start of string (e.g. bytes of the char are missing)
2731 *
2732 * @param $string String
2733 * @return string
2734 */
2739 # We chopped in the middle of a character; remove the whole thing
2741 }
2742 }
2744 }
2746 /**
2747 * Truncate a string of valid HTML to a specified length in bytes,
2748 * appending an optional string (e.g. for ellipses), and return valid HTML
2749 *
2750 * This is only intended for styled/linked text, such as HTML with
2751 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
2752 * Also, this will not detect things like "display:none" CSS.
2753 *
2754 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
2755 *
2756 * @param string $text HTML string to truncate
2757 * @param int $length (zero/positive) Maximum length (including ellipses)
2758 * @param string $ellipsis String to append to the truncated text
2759 * @return string
2760 */
2762 # Use the localized ellipsis character
2765 }
2766 # Check if there is clearly no need to truncate
2771 }
2785 # Consider truncation once the display length has reached the maximim.
2786 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
2787 # Check that we're not in the middle of a bracket/entity...
2791 # Save where we are; we will truncate here unless there turn out to
2792 # be so few remaining characters that truncation is not necessary.
2795 }
2797 # String in fact does need truncation, the truncation point was OK.
2802 }
2803 }
2806 # Read the next char...
2824 }
2830 // Name found (e.g. "<a href=..."), add on tag attributes...
2832 }
2838 }
2841 // Save state without $ch. We want to *hit* the first
2842 // display char (to get tags) but not *use* it if truncating.
2844 }
2849 // Add the next $max display text chars after this in one swoop...
2854 }
2855 }
2856 }
2857 }
2858 // Close the last tag if left unclosed by bad HTML
2862 }
2864 }
2866 /**
2867 * truncateHtml() helper function
2868 * like strcspn() but adds the skipped chars to $ret
2869 *
2870 * @param $ret
2871 * @param $text
2872 * @param $search
2873 * @param $start
2874 * @param $len
2875 * @return int
2876 */
2882 }
2887 }
2889 }
2891 /**
2892 * truncateHtml() helper function
2893 * (a) push or pop $tag from $openTags as needed
2894 * (b) clear $tag value
2895 * @param String &$tag Current HTML tag name we are looking at
2896 * @param int $tagType (0-open tag, 1-close tag)
2897 * @param char $lastCh Character before the '>' that ended this tag
2898 * @param array &$openTags Open tag stack (not accounting for $tag)
2899 */
2908 }
2909 }
2911 }
2912 }
2914 /**
2915 * Grammatical transformations, needed for inflected languages
2916 * Invoked by putting {{grammar:case|word}} in a message
2917 *
2918 * @param $word string
2919 * @param $case string
2920 * @return string
2921 */
2926 }
2928 }
2930 /**
2931 * Provides an alternative text depending on specified gender.
2932 * Usage {{gender:username|masculine|feminine|neutral}}.
2933 * username is optional, in which case the gender of current user is used,
2934 * but only in (some) interface messages; otherwise default gender is used.
2935 * If second or third parameter are not specified, masculine is used.
2936 * These details may be overriden per language.
2937 *
2938 * @param $gender string
2939 * @param $forms array
2940 *
2941 * @return string
2942 */
2946 }
2950 }
2953 }
2955 }
2957 /**
2958 * Plural form transformations, needed for some languages.
2959 * For example, there are 3 form of plural in Russian and Polish,
2960 * depending on "count mod 10". See [[w:Plural]]
2961 * For English it is pretty simple.
2962 *
2963 * Invoked by putting {{plural:count|wordform1|wordform2}}
2964 * or {{plural:count|wordform1|wordform2|wordform3}}
2965 *
2966 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2967 *
2968 * @param $count Integer: non-localized number
2969 * @param $forms Array: different plural forms
2970 * @return string Correct form of plural for $count in this language
2971 */
2975 }
2979 }
2981 /**
2982 * Checks that convertPlural was given an array and pads it to requested
2983 * amount of forms by copying the last one.
2984 *
2985 * @param $count Integer: How many forms should there be at least
2986 * @param $forms Array of forms given to convertPlural
2987 * @return array Padded array of forms or an exception if not an array
2988 */
2992 }
2994 }
2996 /**
2997 * Maybe translate block durations. Note that this function is somewhat misnamed: it
2998 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
2999 * (which is an absolute timestamp).
3000 * @param $str String: the validated block duration in English
3001 * @return Somehow translated block duration
3002 * @see LanguageFi.php for example implementation
3003 */
3009 }
3010 }
3012 // Since usually only infinite or indefinite is only on list, so try
3013 // equivalents if still here.
3020 }
3021 }
3022 }
3023 // If all else fails, return the original string.
3025 }
3027 /**
3028 * languages like Chinese need to be segmented in order for the diff
3029 * to be of any use
3030 *
3031 * @param $text String
3032 * @return String
3033 */
3036 }
3038 /**
3039 * and unsegment to show the result
3040 *
3041 * @param $text String
3042 * @return String
3043 */
3046 }
3048 /**
3049 * convert text to all supported variants
3050 *
3051 * @param $text string
3052 * @return array
3053 */
3056 }
3058 /**
3059 * convert text to different variants of a language.
3060 *
3061 * @param $text string
3062 * @return string
3063 */
3066 }
3069 /**
3070 * Convert a Title object to a string in the preferred variant
3071 *
3072 * @param $title Title
3073 * @return string
3074 */
3077 }
3079 /**
3080 * Check if this is a language with variants
3081 *
3082 * @return bool
3083 */
3086 }
3088 /**
3089 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3090 *
3091 * @param $text string
3092 * @return string
3093 */
3096 }
3098 /**
3099 * Perform output conversion on a string, and encode for safe HTML output.
3100 * @param $text String text to be converted
3101 * @param $isTitle Bool whether this conversion is for the article title
3102 * @return string
3103 * @todo this should get integrated somewhere sane
3104 */
3107 }
3109 /**
3110 * @param $key string
3111 * @return string
3112 */
3115 }
3117 /**
3118 * Get the list of variants supported by this language
3119 * see sample implementation in LanguageZh.php
3120 *
3121 * @return array an array of language codes
3122 */
3125 }
3127 /**
3128 * @return string
3129 */
3132 }
3134 /**
3135 * @return string
3136 */
3139 }
3141 /**
3142 * @return string
3143 */
3146 }
3148 /**
3149 * If a language supports multiple variants, it is
3150 * possible that non-existing link in one variant
3151 * actually exists in another variant. this function
3152 * tries to find it. See e.g. LanguageZh.php
3153 *
3154 * @param $link String: the name of the link
3155 * @param $nt Mixed: the title object of the link
3156 * @param $ignoreOtherCond Boolean: to disable other conditions when
3157 * we need to transclude a template or update a category's link
3158 * @return null the input parameters may be modified upon return
3159 */
3162 }
3164 /**
3165 * If a language supports multiple variants, converts text
3166 * into an array of all possible variants of the text:
3167 * 'variant' => text in that variant
3168 *
3169 * @deprecated since 1.17 Use autoConvertToAllVariants()
3170 *
3171 * @param $text string
3172 *
3173 * @return string
3174 */
3177 }
3179 /**
3180 * returns language specific options used by User::getPageRenderHash()
3181 * for example, the preferred language variant
3182 *
3183 * @return string
3184 */
3187 }
3189 /**
3190 * For languages that support multiple variants, the title of an
3191 * article may be displayed differently in different variants. this
3192 * function returns the apporiate title defined in the body of the article.
3193 *
3194 * @return string
3195 */
3198 }
3200 /**
3201 * Enclose a string with the "no conversion" tag. This is used by
3202 * various functions in the Parser
3203 *
3204 * @param $text String: text to be tagged for no conversion
3205 * @param $noParse bool
3206 * @return string the tagged text
3207 */
3210 }
3212 /**
3213 * A regular expression to match legal word-trailing characters
3214 * which should be merged onto a link of the form [[foo]]bar.
3215 *
3216 * @return string
3217 */
3220 }
3222 /**
3223 * @return Language
3224 */
3227 }
3229 /**
3230 * Get the RFC 3066 code for this language object
3231 *
3232 * @return string
3233 */
3236 }
3238 /**
3239 * @param $code string
3240 */
3243 }
3245 /**
3246 * Get the name of a file for a certain language code
3247 * @param $prefix string Prepend this to the filename
3248 * @param $code string Language code
3249 * @param $suffix string Append this to the filename
3250 * @return string $prefix . $mangledCode . $suffix
3251 */
3253 // Protect against path traversal
3256 {
3258 }
3261 }
3263 /**
3264 * Get the language code from a file name. Inverse of getFileName()
3265 * @param $filename string $prefix . $languageCode . $suffix
3266 * @param $prefix string Prefix before the language code
3267 * @param $suffix string Suffix after the language code
3268 * @return string Language code, or false if $prefix or $suffix isn't found
3269 */
3276 }
3278 }
3280 /**
3281 * @param $code string
3282 * @return string
3283 */
3287 }
3289 /**
3290 * @param $code string
3291 * @return string
3292 */
3296 }
3298 /**
3299 * Get the fallback for a given language
3300 *
3301 * @param $code string
3302 *
3303 * @return false|string
3304 */
3307 // Shortcut
3311 }
3312 }
3314 /**
3315 * Get all messages for a given language
3316 * WARNING: this may take a long time
3317 *
3318 * @param $code string
3319 *
3320 * @return array
3321 */
3324 }
3326 /**
3327 * Get a message for a given language
3328 *
3329 * @param $key string
3330 * @param $code string
3331 *
3332 * @return string
3333 */
3336 }
3338 /**
3339 * @param $talk
3340 * @return mixed
3341 */
3345 }
3350 # Allow grammar transformations
3351 # Allowing full message-style parsing would make simple requests
3352 # such as action=raw much more expensive than they need to be.
3353 # This will hopefully cover most cases.
3357 }
3359 /**
3360 * @param $m string
3361 * @return string
3362 */
3365 }
3367 /**
3368 * @throws MWException
3369 * @return array
3370 */
3375 }
3382 }
3387 }
3389 /**
3390 * Decode an expiry (block, protection, etc) which has come from the DB
3391 *
3392 * @param $expiry String: Database expiry String
3393 * @param $format Bool|Int true to process using language functions, or TS_ constant
3394 * to return the expiry in a given timestamp
3395 * @return String
3396 */
3402 }
3406 ? $infinityMsg
3412 }
3413 }
3415 /**
3416 * @todo Document
3417 * @param $seconds int|float
3418 * @param $format String Optional, one of ("avoidseconds","avoidminutes"):
3419 * "avoidseconds" - don't mention seconds if $seconds >= 1 hour
3420 * "avoidminutes" - don't mention seconds/minutes if $seconds > 48 hours
3421 * @return string
3422 */
3436 }
3447 }
3451 }
3458 }
3466 }
3476 }
3480 }
3490 }
3491 }
3493 }
3495 /**
3496 * @param $bps int
3497 * @return string
3498 */
3503 }
3510 }
3512 }
3514 /**
3515 * Format a size in bytes for output, using an appropriate
3516 * unit (B, KB, MB or GB) according to the magnitude in question
3517 *
3518 * @param $size Size to format
3519 * @return string Plain text (not HTML)
3520 */
3522 // For small sizes no decimal places necessary
3528 // For MB and bigger two decimal places are smarter
3535 }
3538 }
3541 }
3545 }
3547 /**
3548 * Get the conversion rule title, if any.
3549 *
3550 * @return string
3551 */
3554 }
3555 }