| blob | 55a2ee792cb08143b7efe55cf2b6a5a970977151 |
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 */
509 );
510 }
512 /**
513 * @return array
514 */
517 }
519 /**
520 * @return array
521 */
524 }
526 /**
527 * @return array|string
528 */
536 }
537 }
539 /**
540 * @return array
541 */
544 }
546 /**
547 * @param $image
548 * @return array|null
549 */
552 }
554 /**
555 * @return array
556 */
559 }
561 /**
562 * @param $tog
563 * @return string
564 */
567 }
569 /**
570 * Get language names, indexed by code.
571 * If $customisedOnly is true, only returns codes with a messages file
572 *
573 * @param $customisedOnly bool
574 *
575 * @return array
576 */
583 }
588 }
597 }
598 }
601 }
603 /**
604 * Get translated language names. This is done on best effort and
605 * by default this is exactly the same as Language::getLanguageNames.
606 * The CLDR extension provides translated names.
607 * @param $code String Language code.
608 * @return Array language code => language name
609 * @since 1.18.0
610 */
617 }
620 }
622 /**
623 * Get a message from the MediaWiki namespace.
624 *
625 * @param $msg String: message name
626 * @return string
627 */
630 }
632 /**
633 * @param $code string
634 * @return string
635 */
640 }
642 }
644 /**
645 * @param $key string
646 * @return string
647 */
650 }
652 /**
653 * @return array
654 */
659 }
661 }
663 /**
664 * @param $key string
665 * @return string
666 */
669 }
671 /**
672 * @param $key string
673 * @return string
674 */
677 }
679 /**
680 * @return array
681 */
686 }
688 }
690 /**
691 * @param $key string
692 * @return string
693 */
696 }
698 /**
699 * @param $key string
700 * @return string
701 */
704 }
706 /**
707 * @param $key string
708 * @return string
709 */
712 }
714 /**
715 * @param $key string
716 * @return string
717 */
720 }
722 /**
723 * @param $key string
724 * @return string
725 */
728 }
730 /**
731 * @param $key string
732 * @return string
733 */
736 }
738 /**
739 * Used by date() and time() to adjust the time output.
740 *
741 * @param $ts Int the time in date('YmdHis') format
742 * @param $tz Mixed: adjust the time by this amount (default false, mean we
743 * get user timecorrection setting)
744 * @return int
745 */
751 }
764 }
765 # Unrecognized timezone, default to 'Offset' with the stored offset.
767 }
771 # Global offset in minutes.
774 }
785 }
788 }
789 }
791 # No difference ? Return time unchanged
794 }
797 # Generate an adjusted date; take advantage of the fact that mktime
798 # will normalize out-of-range values so we don't have to split $minDiff
799 # into hours and minutes.
812 }
814 /**
815 * This is a workalike of PHP's date() function, but with better
816 * internationalisation, a reduced set of format characters, and a better
817 * escaping format.
818 *
819 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
820 * PHP manual for definitions. There are a number of extensions, which
821 * start with "x":
822 *
823 * xn Do not translate digits of the next numeric format character
824 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
825 * xr Use roman numerals for the next numeric format character
826 * xh Use hebrew numerals for the next numeric format character
827 * xx Literal x
828 * xg Genitive month name
829 *
830 * xij j (day number) in Iranian calendar
831 * xiF F (month name) in Iranian calendar
832 * xin n (month number) in Iranian calendar
833 * xiY Y (full year) in Iranian calendar
834 *
835 * xjj j (day number) in Hebrew calendar
836 * xjF F (month name) in Hebrew calendar
837 * xjt t (days in month) in Hebrew calendar
838 * xjx xg (genitive month name) in Hebrew calendar
839 * xjn n (month number) in Hebrew calendar
840 * xjY Y (full year) in Hebrew calendar
841 *
842 * xmj j (day number) in Hijri calendar
843 * xmF F (month name) in Hijri calendar
844 * xmn n (month number) in Hijri calendar
845 * xmY Y (full year) in Hijri calendar
846 *
847 * xkY Y (full year) in Thai solar calendar. Months and days are
848 * identical to the Gregorian calendar
849 * xoY Y (full year) in Minguo calendar or Juche year.
850 * Months and days are identical to the
851 * Gregorian calendar
852 * xtY Y (full year) in Japanese nengo. Months and days are
853 * identical to the Gregorian calendar
854 *
855 * Characters enclosed in double quotes will be considered literal (with
856 * the quotes themselves removed). Unmatched quotes will be considered
857 * literal quotes. Example:
858 *
859 * "The month is" F => The month is January
860 * i's" => 20'11"
861 *
862 * Backslash escaping is also supported.
863 *
864 * Input timestamp is assumed to be pre-normalized to the desired local
865 * time zone, if any.
866 *
867 * @param $format String
868 * @param $ts String: 14-character timestamp
869 * YYYYMMDDHHMMSS
870 * 01234567890123
871 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
872 *
873 * @return string
874 */
893 }
895 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
897 }
935 }
941 }
947 }
953 }
959 }
966 }
972 }
978 }
987 }
993 }
999 }
1014 }
1020 }
1026 }
1032 }
1038 }
1044 }
1050 }
1059 }
1065 }
1071 }
1077 }
1083 }
1089 }
1124 }
1130 }
1136 }
1140 # Backslash escaping
1145 }
1148 # Quoted literal
1152 # No terminating quote, assume literal "
1157 }
1159 # Quote at end of string, assume literal "
1161 }
1165 }
1178 }
1179 }
1180 }
1182 }
1187 /**
1188 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1189 * Gregorian dates to Iranian dates. Originally written in C, it
1190 * is released under the terms of GNU Lesser General Public
1191 * License. Conversion to PHP was performed by Niklas Laxström.
1192 *
1193 * Link: http://www.farsiweb.info/jalali/jalali.c
1194 *
1195 * @param $ts string
1196 *
1197 * @return string
1198 */
1204 # Days passed from the beginning (including leap years)
1211 // Add days of the past months of this year
1214 }
1216 // Leap years
1219 }
1221 // Days passed in current month
1235 }
1239 }
1245 }
1247 /**
1248 * Converting Gregorian dates to Hijri dates.
1249 *
1250 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1251 *
1252 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1253 *
1254 * @param $ts string
1255 *
1256 * @return string
1257 */
1271 )
1272 {
1280 }
1285 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1286 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1292 }
1294 /**
1295 * Converting Gregorian dates to Hebrew dates.
1296 *
1297 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1298 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1299 * to translate the relevant functions into PHP and release them under
1300 * GNU GPL.
1301 *
1302 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1303 * and Adar II is 14. In a non-leap year, Adar is 6.
1304 *
1305 * @param $ts string
1306 *
1307 * @return string
1308 */
1310 # Parse date
1315 # Calculate Hebrew year
1318 # Month number when September = 1, August = 12
1321 # Next year
1325 }
1327 # Calculate day of year from 1 September
1331 # February
1333 # Check if the year is leap
1336 }
1341 }
1342 }
1344 # Calculate the start of the Hebrew year
1347 # Calculate next year's start
1349 # Day is before the start of the year - it is the previous year
1350 # Next year's start
1352 # Previous year
1355 # Add days since previous year's 1 September
1358 # Leap year
1360 }
1361 # Start of the new (previous) year
1364 # Next year's start
1366 }
1368 # Calculate Hebrew day of year
1371 # Difference between year's days
1373 # Add 12 (or 13 for leap years) days to ignore the difference between
1374 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1375 # difference is only about the year type
1380 }
1382 # Check the year pattern, and is leap year
1383 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1384 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1385 # and non-leap years
1387 # Check if leap year
1390 # Calculate day in the month from number of day in the Hebrew year
1391 # Don't check Adar - if the day is not in Adar, we will stop before;
1392 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1397 # Calculate days in this month
1399 # Adar in a leap year
1401 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1404 # Day in Adar I
1407 # Subtract the days of Adar I
1409 # Try Adar II
1412 # Day in Adar II
1414 }
1415 }
1416 }
1418 # Cheshvan in a complete year (otherwise as the rule below)
1421 # Kislev in an incomplete year (otherwise as the rule below)
1424 # Odd months have 30 days, even have 29
1426 }
1428 # In the current month
1431 # Subtract the days of the current month
1433 # Try in the next month
1435 }
1436 }
1439 }
1441 /**
1442 * This calculates the Hebrew year start, as days since 1 September.
1443 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1444 * Used for Hebrew date.
1445 *
1446 * @param $year int
1447 *
1448 * @return string
1449 */
1456 }
1460 }
1470 }
1474 }
1476 /**
1477 * Algorithm to convert Gregorian dates to Thai solar dates,
1478 * Minguo dates or Minguo dates.
1479 *
1480 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1481 * http://en.wikipedia.org/wiki/Minguo_calendar
1482 * http://en.wikipedia.org/wiki/Japanese_era_name
1483 *
1484 * @param $ts String: 14-character timestamp
1485 * @param $cName String: calender name
1486 * @return Array: converted year, month, day
1487 */
1494 # Thai solar dates
1495 # Add 543 years to the Gregorian calendar
1496 # Months and days are identical
1499 # Minguo dates
1500 # Deduct 1911 years from the Gregorian calendar
1501 # Months and days are identical
1504 # Nengō dates up to Meiji period
1505 # Deduct years from the Gregorian calendar
1506 # depending on the nengo periods
1507 # Months and days are identical
1508 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1509 # Meiji period
1514 }
1522 )
1523 {
1524 # Taishō period
1529 }
1535 )
1536 {
1537 # Shōwa period
1542 }
1545 # Heisei period
1550 }
1552 }
1555 }
1558 }
1560 /**
1561 * Roman number formatting up to 3000
1562 *
1563 * @param $num int
1564 *
1565 * @return string
1566 */
1573 );
1578 }
1584 }
1586 }
1588 }
1590 /**
1591 * Hebrew Gematria number formatting up to 9999
1592 *
1593 * @param $num int
1594 *
1595 * @return string
1596 */
1603 );
1608 }
1620 }
1621 }
1622 }
1624 }
1630 }
1649 }
1651 }
1653 /**
1654 * This is meant to be used by time(), date(), and timeanddate() to get
1655 * the date preference they're supposed to use, it should be used in
1656 * all children.
1657 *
1658 *<code>
1659 * function timeanddate([...], $format = true) {
1660 * $datePreference = $this->dateFormat($format);
1661 * [...]
1662 * }
1663 *</code>
1664 *
1665 * @param $usePrefs Mixed: if true, the user's preference is used
1666 * if false, the site/language default is used
1667 * if int/string, assumed to be a format.
1668 * @return string
1669 */
1678 }
1681 }
1683 // return int
1686 }
1689 }
1691 /**
1692 * Get a format string for a given type and preference
1693 * @param $type string May be date, time or both
1694 * @param $pref string The format name as it appears in Messages*.php
1695 *
1696 * @return string
1697 */
1708 }
1709 }
1711 }
1713 }
1715 /**
1716 * @param $ts Mixed: the time format which needs to be turned into a
1717 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1718 * @param $adj Bool: whether to adjust the time output according to the
1719 * user configured offset ($timecorrection)
1720 * @param $format Mixed: true to use user's date format preference
1721 * @param $timecorrection String|bool the time offset as returned by
1722 * validateTimeZone() in Special:Preferences
1723 * @return string
1724 */
1729 }
1732 }
1734 /**
1735 * @param $ts Mixed: the time format which needs to be turned into a
1736 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1737 * @param $adj Bool: whether to adjust the time output according to the
1738 * user configured offset ($timecorrection)
1739 * @param $format Mixed: true to use user's date format preference
1740 * @param $timecorrection String|bool the time offset as returned by
1741 * validateTimeZone() in Special:Preferences
1742 * @return string
1743 */
1748 }
1751 }
1753 /**
1754 * @param $ts Mixed: the time format which needs to be turned into a
1755 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1756 * @param $adj Bool: whether to adjust the time output according to the
1757 * user configured offset ($timecorrection)
1758 * @param $format Mixed: what format to return, if it's false output the
1759 * default one (default true)
1760 * @param $timecorrection String|bool the time offset as returned by
1761 * validateTimeZone() in Special:Preferences
1762 * @return string
1763 */
1768 }
1771 }
1773 /**
1774 * @param $key string
1775 * @return array|null
1776 */
1779 }
1781 /**
1782 * @return array
1783 */
1786 }
1788 /**
1789 * @param $in
1790 * @param $out
1791 * @param $string
1792 * @return string
1793 */
1795 # This is a wrapper for iconv in all languages except esperanto,
1796 # which does some nasty x-conversions beforehand
1798 # Even with //IGNORE iconv can whine about illegal characters in
1799 # *input* string. We just ignore those too.
1800 # REF: http://bugs.php.net/bug.php?id=37166
1801 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1806 }
1808 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1810 /**
1811 * @param $matches array
1812 * @return mixed|string
1813 */
1816 }
1818 /**
1819 * @param $matches array
1820 * @return string
1821 */
1824 }
1826 /**
1827 * @param $matches array
1828 * @return string
1829 */
1833 }
1835 /**
1836 * @param $matches array
1837 * @return string
1838 */
1842 }
1844 /**
1845 * @param $matches array
1846 * @return string
1847 */
1850 }
1852 /**
1853 * @param $matches array
1854 * @return string
1855 */
1859 }
1861 /**
1862 * Make a string's first character uppercase
1863 *
1864 * @param $str string
1865 *
1866 * @return string
1867 */
1875 // fall back to more complex logic in case of multibyte strings
1877 }
1878 }
1880 /**
1881 * Convert a string to uppercase
1882 *
1883 * @param $str string
1884 * @param $first bool
1885 *
1886 * @return string
1887 */
1895 }
1898 }
1905 $str
1906 );
1909 }
1910 }
1911 }
1913 /**
1914 * @param $str string
1915 * @return mixed|string
1916 */
1928 }
1929 }
1931 /**
1932 * @param $str string
1933 * @param $first bool
1934 * @return mixed|string
1935 */
1943 }
1946 }
1953 $str
1954 );
1957 }
1958 }
1959 }
1961 /**
1962 * @param $str string
1963 * @return bool
1964 */
1967 }
1969 /**
1970 * @param $str string
1971 * @return mixed|string
1972 */
1977 // regexp to find first letter in each word (i.e. after each space)
1978 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1980 // function to use to capitalize a single char
1985 $str
1986 );
1991 $str
1992 );
1993 }
1996 }
1997 }
1999 /**
2000 * capitalize words at word breaks
2001 *
2002 * @param $str string
2003 * @return mixed
2004 */
2009 // since \b doesn't work for UTF-8, we explicitely define word break chars
2012 // find first letter after word break
2013 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
2019 $str
2020 );
2025 $str
2026 );
2027 }
2032 $str
2033 );
2034 }
2035 }
2037 /**
2038 * Return a case-folded representation of $s
2039 *
2040 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
2041 * and $s2 are the same except for the case of their characters. It is not
2042 * necessary for the value returned to make sense when displayed.
2043 *
2044 * Do *not* perform any other normalisation in this function. If a caller
2045 * uses this function when it should be using a more general normalisation
2046 * function, then fix the caller.
2047 *
2048 * @param $s string
2049 *
2050 * @return string
2051 */
2054 }
2056 /**
2057 * @param $s string
2058 * @return string
2059 */
2063 }
2064 # Check for non-UTF-8 URLs
2068 }
2074 }
2077 }
2079 /**
2080 * @return array
2081 */
2084 }
2086 /**
2087 * Most writing systems use whitespace to break up words.
2088 * Some languages such as Chinese don't conventionally do this,
2089 * which requires special handling when breaking up words for
2090 * searching etc.
2091 *
2092 * @return bool
2093 */
2096 }
2098 /**
2099 * Some languages such as Chinese require word segmentation,
2100 * Specify such segmentation when overridden in derived class.
2101 *
2102 * @param $string String
2103 * @return String
2104 */
2107 }
2109 /**
2110 * Some languages have special punctuation need to be normalized.
2111 * Make such changes here.
2112 *
2113 * @param $string String
2114 * @return String
2115 */
2118 }
2120 /**
2121 * convert double-width roman characters to single-width.
2122 * range: ff00-ff5f ~= 0020-007f
2123 *
2124 * @param $string string
2125 *
2126 * @return string
2127 */
2137 }
2141 }
2143 /**
2144 * @param $string string
2145 * @param $pattern string
2146 * @return string
2147 */
2152 }
2154 /**
2155 * @param $termsArray array
2156 * @return array
2157 */
2159 # some languages, e.g. Chinese, need to do a conversion
2160 # in order for search results to be displayed correctly
2162 }
2164 /**
2165 * Get the first character of a string.
2166 *
2167 * @param $s string
2168 * @return string
2169 */
2176 $matches
2177 );
2182 }
2184 // Break down Hangul syllables to grab the first jamo
2216 }
2219 }
2220 }
2223 # Some languages may have an alternate char encoding option
2224 # (Esperanto X-coding, Japanese furigana conversion, etc)
2225 # If this language is used as the primary content language,
2226 # an override to the defaults can be set here on startup.
2227 }
2229 /**
2230 * @param $s string
2231 * @return string
2232 */
2234 # For some languages we'll want to explicitly specify
2235 # which characters make it into the edit box raw
2236 # or are converted in some way or another.
2242 }
2243 }
2245 /**
2246 * @param $s string
2247 * @return string
2248 */
2250 # Take the previous into account.
2256 }
2261 }
2262 }
2264 /**
2265 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2266 * also cleans up certain backwards-compatible sequences, converting them
2267 * to the modern Unicode equivalent.
2268 *
2269 * This is language-specific for performance reasons only.
2270 *
2271 * @param $s string
2272 *
2273 * @return string
2274 */
2281 }
2284 }
2286 /**
2287 * Transform a string using serialized data stored in the given file (which
2288 * must be in the serialized subdirectory of $IP). The file contains pairs
2289 * mapping source characters to destination characters.
2290 *
2291 * The data is cached in process memory. This will go faster if you have the
2292 * FastStringSearch extension.
2293 *
2294 * @param $file string
2295 * @param $string string
2296 *
2297 * @return string
2298 */
2304 }
2306 }
2308 }
2310 /**
2311 * For right-to-left language support
2312 *
2313 * @return bool
2314 */
2317 }
2319 /**
2320 * Return the correct HTML 'dir' attribute value for this language.
2321 * @return String
2322 */
2325 }
2327 /**
2328 * Return 'left' or 'right' as appropriate alignment for line-start
2329 * for this language's text direction.
2330 *
2331 * Should be equivalent to CSS3 'start' text-align value....
2332 *
2333 * @return String
2334 */
2337 }
2339 /**
2340 * Return 'right' or 'left' as appropriate alignment for line-end
2341 * for this language's text direction.
2342 *
2343 * Should be equivalent to CSS3 'end' text-align value....
2344 *
2345 * @return String
2346 */
2349 }
2351 /**
2352 * A hidden direction mark (LRM or RLM), depending on the language direction
2353 *
2354 * @param $opposite Boolean Get the direction mark opposite to your language
2355 * @return string
2356 */
2362 }
2364 /**
2365 * @return array
2366 */
2369 }
2371 /**
2372 * An arrow, depending on the language direction
2373 *
2374 * @return string
2375 */
2378 }
2380 /**
2381 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2382 *
2383 * @return bool
2384 */
2387 }
2389 /**
2390 * @return array
2391 */
2394 }
2399 }
2404 }
2406 /**
2407 * Fill a MagicWord object with data from here
2408 *
2409 * @param $mw
2410 */
2422 }
2423 }
2430 }
2431 }
2433 /**
2434 * Add magic words to the extension array
2435 *
2436 * @param $newWords array
2437 */
2444 }
2447 }
2452 }
2453 }
2454 }
2456 /**
2457 * Get special page names, as an associative array
2458 * case folded alias => real name
2459 */
2461 // Cache aliases because it may be slow to load them
2463 // Initialise array
2468 }
2471 }
2473 /**
2474 * Italic is unsuitable for some languages
2475 *
2476 * @param $text String: the text to be emphasized.
2477 * @return string
2478 */
2481 }
2483 /**
2484 * Normally we output all numbers in plain en_US style, that is
2485 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2486 * point twohundredthirtyfive. However this is not sutable for all
2487 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2488 * Icelandic just want to use commas instead of dots, and dots instead
2489 * of commas like "293.291,235".
2490 *
2491 * An example of this function being called:
2492 * <code>
2493 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2494 * </code>
2495 *
2496 * See LanguageGu.php for the Gujarati implementation and
2497 * $separatorTransformTable on MessageIs.php for
2498 * the , => . and . => , implementation.
2499 *
2500 * @todo check if it's viable to use localeconv() for the decimal
2501 * separator thing.
2502 * @param $number Mixed: the string to be formatted, should be an integer
2503 * or a floating point number.
2504 * @param $nocommafy Bool: set to true for special numbers like dates
2505 * @return string
2506 */
2514 }
2515 }
2521 }
2522 }
2525 }
2527 /**
2528 * @param $number string
2529 * @return string
2530 */
2535 }
2540 }
2544 }
2546 /**
2547 * Adds commas to a given number
2548 *
2549 * @param $_ mixed
2550 * @return string
2551 */
2554 }
2556 /**
2557 * @return array
2558 */
2561 }
2563 /**
2564 * @return array
2565 */
2568 }
2570 /**
2571 * Take a list of strings and build a locale-friendly comma-separated
2572 * list, using the local comma-separator message.
2573 * The last two strings are chained with an "and".
2574 *
2575 * @param $l Array
2576 * @return string
2577 */
2582 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2588 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2591 }
2592 }
2594 }
2595 }
2597 /**
2598 * Take a list of strings and build a locale-friendly comma-separated
2599 * list, using the local comma-separator message.
2600 * @param $list array of strings to put in a comma list
2601 * @return string
2602 */
2609 )
2610 );
2611 }
2613 /**
2614 * Take a list of strings and build a locale-friendly semicolon-separated
2615 * list, using the local semicolon-separator message.
2616 * @param $list array of strings to put in a semicolon list
2617 * @return string
2618 */
2625 )
2626 );
2627 }
2629 /**
2630 * Same as commaList, but separate it with the pipe instead.
2631 * @param $list array of strings to put in a pipe list
2632 * @return string
2633 */
2640 )
2641 );
2642 }
2644 /**
2645 * Truncate a string to a specified length in bytes, appending an optional
2646 * string (e.g. for ellipses)
2647 *
2648 * The database offers limited byte lengths for some columns in the database;
2649 * multi-byte character sets mean we need to ensure that only whole characters
2650 * are included, otherwise broken characters can be passed to the user
2651 *
2652 * If $length is negative, the string will be truncated from the beginning
2653 *
2654 * @param $string String to truncate
2655 * @param $length Int: maximum length (including ellipses)
2656 * @param $ellipsis String to append to the truncated text
2657 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
2658 * $adjustLength was introduced in 1.18, before that behaved as if false.
2659 * @return string
2660 */
2662 # Use the localized ellipsis character
2665 }
2666 # Check if there is no need to truncate
2671 }
2673 # If ellipsis length is >= $length then we can't apply $adjustLength
2676 # Otherwise, truncate and add ellipsis...
2689 }
2690 }
2691 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
2692 # This check is *not* redundant if $adjustLength, due to the single case where
2693 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
2698 }
2699 }
2701 /**
2702 * Remove bytes that represent an incomplete Unicode character
2703 * at the end of string (e.g. bytes of the char are missing)
2704 *
2705 * @param $string String
2706 * @return string
2707 */
2713 # We got the first byte only of a multibyte char; remove it.
2718 {
2719 # We chopped in the middle of a character; remove it
2721 }
2722 }
2724 }
2726 /**
2727 * Remove bytes that represent an incomplete Unicode character
2728 * at the start of string (e.g. bytes of the char are missing)
2729 *
2730 * @param $string String
2731 * @return string
2732 */
2737 # We chopped in the middle of a character; remove the whole thing
2739 }
2740 }
2742 }
2744 /**
2745 * Truncate a string of valid HTML to a specified length in bytes,
2746 * appending an optional string (e.g. for ellipses), and return valid HTML
2747 *
2748 * This is only intended for styled/linked text, such as HTML with
2749 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
2750 * Also, this will not detect things like "display:none" CSS.
2751 *
2752 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
2753 *
2754 * @param string $text HTML string to truncate
2755 * @param int $length (zero/positive) Maximum length (including ellipses)
2756 * @param string $ellipsis String to append to the truncated text
2757 * @return string
2758 */
2760 # Use the localized ellipsis character
2763 }
2764 # Check if there is clearly no need to truncate
2769 }
2783 # Consider truncation once the display length has reached the maximim.
2784 # We check if $dispLen > 0 to grab tags for the $neLength = 0 case.
2785 # Check that we're not in the middle of a bracket/entity...
2789 # Save where we are; we will truncate here unless there turn out to
2790 # be so few remaining characters that truncation is not necessary.
2793 }
2795 # String in fact does need truncation, the truncation point was OK.
2800 }
2801 }
2804 # Read the next char...
2822 }
2828 // Name found (e.g. "<a href=..."), add on tag attributes...
2830 }
2836 }
2839 // Save state without $ch. We want to *hit* the first
2840 // display char (to get tags) but not *use* it if truncating.
2842 }
2847 // Add the next $max display text chars after this in one swoop...
2852 }
2853 }
2854 }
2855 }
2856 // Close the last tag if left unclosed by bad HTML
2860 }
2862 }
2864 /**
2865 * truncateHtml() helper function
2866 * like strcspn() but adds the skipped chars to $ret
2867 *
2868 * @param $ret
2869 * @param $text
2870 * @param $search
2871 * @param $start
2872 * @param $len
2873 * @return int
2874 */
2880 }
2885 }
2887 }
2889 /**
2890 * truncateHtml() helper function
2891 * (a) push or pop $tag from $openTags as needed
2892 * (b) clear $tag value
2893 * @param String &$tag Current HTML tag name we are looking at
2894 * @param int $tagType (0-open tag, 1-close tag)
2895 * @param char $lastCh Character before the '>' that ended this tag
2896 * @param array &$openTags Open tag stack (not accounting for $tag)
2897 */
2906 }
2907 }
2909 }
2910 }
2912 /**
2913 * Grammatical transformations, needed for inflected languages
2914 * Invoked by putting {{grammar:case|word}} in a message
2915 *
2916 * @param $word string
2917 * @param $case string
2918 * @return string
2919 */
2924 }
2926 }
2928 /**
2929 * Provides an alternative text depending on specified gender.
2930 * Usage {{gender:username|masculine|feminine|neutral}}.
2931 * username is optional, in which case the gender of current user is used,
2932 * but only in (some) interface messages; otherwise default gender is used.
2933 * If second or third parameter are not specified, masculine is used.
2934 * These details may be overriden per language.
2935 *
2936 * @param $gender string
2937 * @param $forms array
2938 *
2939 * @return string
2940 */
2944 }
2948 }
2951 }
2953 }
2955 /**
2956 * Plural form transformations, needed for some languages.
2957 * For example, there are 3 form of plural in Russian and Polish,
2958 * depending on "count mod 10". See [[w:Plural]]
2959 * For English it is pretty simple.
2960 *
2961 * Invoked by putting {{plural:count|wordform1|wordform2}}
2962 * or {{plural:count|wordform1|wordform2|wordform3}}
2963 *
2964 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2965 *
2966 * @param $count Integer: non-localized number
2967 * @param $forms Array: different plural forms
2968 * @return string Correct form of plural for $count in this language
2969 */
2973 }
2977 }
2979 /**
2980 * Checks that convertPlural was given an array and pads it to requested
2981 * amount of forms by copying the last one.
2982 *
2983 * @param $count Integer: How many forms should there be at least
2984 * @param $forms Array of forms given to convertPlural
2985 * @return array Padded array of forms or an exception if not an array
2986 */
2990 }
2992 }
2994 /**
2995 * This translates the duration ("1 week", "4 days", etc)
2996 * as well as the expiry time (which is an absolute timestamp).
2997 * @param $str String: the validated block duration in English
2998 * @return Somehow translated block duration
2999 * @see LanguageFi.php for example implementation
3000 */
3006 }
3007 }
3009 // Since usually only infinite or indefinite is only on list, so try
3010 // equivalents if still here.
3017 }
3018 }
3019 }
3020 // If no duration is given, but a timestamp, display that
3022 }
3024 /**
3025 * languages like Chinese need to be segmented in order for the diff
3026 * to be of any use
3027 *
3028 * @param $text String
3029 * @return String
3030 */
3033 }
3035 /**
3036 * and unsegment to show the result
3037 *
3038 * @param $text String
3039 * @return String
3040 */
3043 }
3045 /**
3046 * convert text to all supported variants
3047 *
3048 * @param $text string
3049 * @return array
3050 */
3053 }
3055 /**
3056 * convert text to different variants of a language.
3057 *
3058 * @param $text string
3059 * @return string
3060 */
3063 }
3066 /**
3067 * Convert a Title object to a string in the preferred variant
3068 *
3069 * @param $title Title
3070 * @return string
3071 */
3074 }
3076 /**
3077 * Check if this is a language with variants
3078 *
3079 * @return bool
3080 */
3083 }
3085 /**
3086 * Put custom tags (e.g. -{ }-) around math to prevent conversion
3087 *
3088 * @param $text string
3089 * @return string
3090 */
3093 }
3095 /**
3096 * Perform output conversion on a string, and encode for safe HTML output.
3097 * @param $text String text to be converted
3098 * @param $isTitle Bool whether this conversion is for the article title
3099 * @return string
3100 * @todo this should get integrated somewhere sane
3101 */
3104 }
3106 /**
3107 * @param $key string
3108 * @return string
3109 */
3112 }
3114 /**
3115 * Get the list of variants supported by this language
3116 * see sample implementation in LanguageZh.php
3117 *
3118 * @return array an array of language codes
3119 */
3122 }
3124 /**
3125 * @return string
3126 */
3129 }
3131 /**
3132 * @return string
3133 */
3136 }
3138 /**
3139 * @return string
3140 */
3143 }
3145 /**
3146 * If a language supports multiple variants, it is
3147 * possible that non-existing link in one variant
3148 * actually exists in another variant. this function
3149 * tries to find it. See e.g. LanguageZh.php
3150 *
3151 * @param $link String: the name of the link
3152 * @param $nt Mixed: the title object of the link
3153 * @param $ignoreOtherCond Boolean: to disable other conditions when
3154 * we need to transclude a template or update a category's link
3155 * @return null the input parameters may be modified upon return
3156 */
3159 }
3161 /**
3162 * If a language supports multiple variants, converts text
3163 * into an array of all possible variants of the text:
3164 * 'variant' => text in that variant
3165 *
3166 * @deprecated since 1.17 Use autoConvertToAllVariants()
3167 *
3168 * @param $text string
3169 *
3170 * @return string
3171 */
3174 }
3176 /**
3177 * returns language specific options used by User::getPageRenderHash()
3178 * for example, the preferred language variant
3179 *
3180 * @return string
3181 */
3184 }
3186 /**
3187 * For languages that support multiple variants, the title of an
3188 * article may be displayed differently in different variants. this
3189 * function returns the apporiate title defined in the body of the article.
3190 *
3191 * @return string
3192 */
3195 }
3197 /**
3198 * Enclose a string with the "no conversion" tag. This is used by
3199 * various functions in the Parser
3200 *
3201 * @param $text String: text to be tagged for no conversion
3202 * @param $noParse bool
3203 * @return string the tagged text
3204 */
3207 }
3209 /**
3210 * A regular expression to match legal word-trailing characters
3211 * which should be merged onto a link of the form [[foo]]bar.
3212 *
3213 * @return string
3214 */
3217 }
3219 /**
3220 * @return Language
3221 */
3224 }
3226 /**
3227 * Get the RFC 3066 code for this language object
3228 *
3229 * @return string
3230 */
3233 }
3235 /**
3236 * @param $code string
3237 */
3240 }
3242 /**
3243 * Get the name of a file for a certain language code
3244 * @param $prefix string Prepend this to the filename
3245 * @param $code string Language code
3246 * @param $suffix string Append this to the filename
3247 * @return string $prefix . $mangledCode . $suffix
3248 */
3250 // Protect against path traversal
3253 {
3255 }
3258 }
3260 /**
3261 * Get the language code from a file name. Inverse of getFileName()
3262 * @param $filename string $prefix . $languageCode . $suffix
3263 * @param $prefix string Prefix before the language code
3264 * @param $suffix string Suffix after the language code
3265 * @return string Language code, or false if $prefix or $suffix isn't found
3266 */
3273 }
3275 }
3277 /**
3278 * @param $code string
3279 * @return string
3280 */
3284 }
3286 /**
3287 * @param $code string
3288 * @return string
3289 */
3293 }
3295 /**
3296 * Get the fallback for a given language
3297 *
3298 * @param $code string
3299 *
3300 * @return false|string
3301 */
3304 // Shortcut
3308 }
3309 }
3311 /**
3312 * Get all messages for a given language
3313 * WARNING: this may take a long time
3314 *
3315 * @param $code string
3316 *
3317 * @return array
3318 */
3321 }
3323 /**
3324 * Get a message for a given language
3325 *
3326 * @param $key string
3327 * @param $code string
3328 *
3329 * @return string
3330 */
3333 }
3335 /**
3336 * @param $talk
3337 * @return mixed
3338 */
3342 }
3347 # Allow grammar transformations
3348 # Allowing full message-style parsing would make simple requests
3349 # such as action=raw much more expensive than they need to be.
3350 # This will hopefully cover most cases.
3354 }
3356 /**
3357 * @param $m string
3358 * @return string
3359 */
3362 }
3364 /**
3365 * @throws MWException
3366 * @return array
3367 */
3372 }
3379 }
3384 }
3386 /**
3387 * Decode an expiry (block, protection, etc) which has come from the DB
3388 *
3389 * @param $expiry String: Database expiry String
3390 * @param $format Bool|Int true to process using language functions, or TS_ constant
3391 * to return the expiry in a given timestamp
3392 * @return String
3393 */
3399 }
3403 ? $infinityMsg
3409 }
3410 }
3412 /**
3413 * @todo Document
3414 * @param $seconds int|float
3415 * @param $format String Optional, one of ("avoidseconds","avoidminutes"):
3416 * "avoidseconds" - don't mention seconds if $seconds >= 1 hour
3417 * "avoidminutes" - don't mention seconds/minutes if $seconds > 48 hours
3418 * @return string
3419 */
3433 }
3444 }
3448 }
3455 }
3463 }
3473 }
3477 }
3487 }
3488 }
3490 }
3492 /**
3493 * @param $bps int
3494 * @return string
3495 */
3500 }
3507 }
3509 }
3511 /**
3512 * Format a size in bytes for output, using an appropriate
3513 * unit (B, KB, MB or GB) according to the magnitude in question
3514 *
3515 * @param $size Size to format
3516 * @return string Plain text (not HTML)
3517 */
3519 // For small sizes no decimal places necessary
3525 // For MB and bigger two decimal places are smarter
3532 }
3535 }
3538 }
3542 }
3544 /**
3545 * Get the conversion rule title, if any.
3546 *
3547 * @return string
3548 */
3551 }
3552 }