| blob | c8a7533cbe1cc051b10ba839f03fa58567de9614 |
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 /**
25 * These are always UTF-8, they exist only for backwards compatibility
26 */
32 }
34 /**
35 * a fake language converter
36 *
37 * @ingroup Language
38 */
55 }
57 /**
58 * Internationalisation code
59 * @ingroup Language
60 */
69 /**
70 * ReplacementArray object caches
71 */
80 );
84 );
89 'december'
90 );
94 'december-gen'
95 );
99 );
106 );
114 );
122 );
129 );
131 /**
132 * Get a cached language object for a given language code
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 */
155 // Preload base classes to work around APC/PHP5 bug
158 }
161 }
162 }
166 }
176 }
178 }
180 /**
181 * Get the LocalisationCache instance
182 */
188 }
190 }
194 // Set the code to the name of the descendant
199 }
201 }
203 /**
204 * Reduce memory usage
205 */
209 }
210 }
212 /**
213 * Hook which will be called if this is the content language.
214 * Descendants can use this to register hook functions or modify globals
215 */
218 /**
219 * @deprecated Use User::getDefaultOptions()
220 * @return array
221 */
225 }
232 }
233 }
235 /**
236 * Exports $wgBookstoreListEn
237 * @return array
238 */
241 }
243 /**
244 * @return array
245 */
262 }
264 # Sometimes a language will be localised but not actually exist on this wiki.
268 }
269 }
271 # The above mixing may leave namespaces out of canonical order.
272 # Re-order by namespace ID number...
274 }
276 }
278 /**
279 * A convenience function that returns the same thing as
280 * getNamespaces() except with the array values changed to ' '
281 * where it found '_', useful for producing output to be displayed
282 * e.g. in <select> forms.
283 *
284 * @return array
285 */
290 }
292 }
294 /**
295 * Get a namespace value by key
296 * <code>
297 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
298 * echo $mw_ns; // prints 'MediaWiki'
299 * </code>
300 *
301 * @param $index Int: the array key of the namespace to return
302 * @return mixed, string if the namespace value exists, otherwise false
303 */
307 }
309 /**
310 * A convenience function that returns the same thing as
311 * getNsText() except with '_' changed to ' ', useful for
312 * producing output.
313 *
314 * @return array
315 */
319 }
321 /**
322 * Get a namespace key by value, case insensitive.
323 * Only matches namespace names for the current language, not the
324 * canonical ones defined in Namespace.php.
325 *
326 * @param $text String
327 * @return mixed An integer if $text is a valid value otherwise false
328 */
333 }
346 }
347 }
348 }
350 }
352 }
357 # Put namespace names and aliases into a hashtable.
358 # If this is too slow, then we should arrange it so that it is done
359 # before caching. The catch is that at pre-cache time, the above
360 # class-specific fixup hasn't been done.
364 }
367 }
371 }
372 }
373 }
375 }
378 /**
379 * Get a namespace key by value, case insensitive. Canonical namespace
380 * names override custom ones defined for the current language.
381 *
382 * @param $text String
383 * @return mixed An integer if $text is a valid value otherwise false
384 */
389 }
392 }
394 /**
395 * short names for language variants used for language conversion links.
396 *
397 * @param $code String
398 * @return string
399 */
402 }
408 }
410 }
419 );
420 }
424 }
428 }
432 }
441 }
442 }
446 }
450 }
454 }
458 }
462 }
464 /**
465 * Get language names, indexed by code.
466 * If $customisedOnly is true, only returns codes with a messages file
467 */
473 }
482 }
483 }
486 }
488 /**
489 * Get a message from the MediaWiki namespace.
490 *
491 * @param $msg String: message name
492 * @return string
493 */
496 }
502 }
504 }
508 }
512 }
516 }
520 }
524 }
528 }
532 }
536 }
540 }
542 /**
543 * Used by date() and time() to adjust the time output.
544 *
545 * @param $ts Int the time in date('YmdHis') format
546 * @param $tz Mixed: adjust the time by this amount (default false, mean we
547 * get user timecorrection setting)
548 * @return int
549 */
555 }
565 }
566 # Unrecognized timezone, default to 'Offset' with the stored offset.
568 }
572 # Global offset in minutes.
575 }
586 }
589 }
590 }
592 # No difference ? Return time unchanged
595 }
598 # Generate an adjusted date; take advantage of the fact that mktime
599 # will normalize out-of-range values so we don't have to split $minDiff
600 # into hours and minutes.
613 }
615 /**
616 * This is a workalike of PHP's date() function, but with better
617 * internationalisation, a reduced set of format characters, and a better
618 * escaping format.
619 *
620 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
621 * PHP manual for definitions. "o" format character is supported since
622 * PHP 5.1.0, previous versions return literal o.
623 * There are a number of extensions, which start with "x":
624 *
625 * xn Do not translate digits of the next numeric format character
626 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
627 * xr Use roman numerals for the next numeric format character
628 * xh Use hebrew numerals for the next numeric format character
629 * xx Literal x
630 * xg Genitive month name
631 *
632 * xij j (day number) in Iranian calendar
633 * xiF F (month name) in Iranian calendar
634 * xin n (month number) in Iranian calendar
635 * xiY Y (full year) in Iranian calendar
636 *
637 * xjj j (day number) in Hebrew calendar
638 * xjF F (month name) in Hebrew calendar
639 * xjt t (days in month) in Hebrew calendar
640 * xjx xg (genitive month name) in Hebrew calendar
641 * xjn n (month number) in Hebrew calendar
642 * xjY Y (full year) in Hebrew calendar
643 *
644 * xmj j (day number) in Hijri calendar
645 * xmF F (month name) in Hijri calendar
646 * xmn n (month number) in Hijri calendar
647 * xmY Y (full year) in Hijri calendar
648 *
649 * xkY Y (full year) in Thai solar calendar. Months and days are
650 * identical to the Gregorian calendar
651 * xoY Y (full year) in Minguo calendar or Juche year.
652 * Months and days are identical to the
653 * Gregorian calendar
654 * xtY Y (full year) in Japanese nengo. Months and days are
655 * identical to the Gregorian calendar
656 *
657 * Characters enclosed in double quotes will be considered literal (with
658 * the quotes themselves removed). Unmatched quotes will be considered
659 * literal quotes. Example:
660 *
661 * "The month is" F => The month is January
662 * i's" => 20'11"
663 *
664 * Backslash escaping is also supported.
665 *
666 * Input timestamp is assumed to be pre-normalized to the desired local
667 * time zone, if any.
668 *
669 * @param $format String
670 * @param $ts String: 14-character timestamp
671 * YYYYMMDDHHMMSS
672 * 01234567890123
673 * @todo emulation of "o" format character for PHP pre 5.1.0
674 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
675 */
694 }
696 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
698 }
736 }
742 }
748 }
754 }
760 }
767 }
773 }
779 }
788 }
794 }
800 }
815 }
821 }
827 }
833 }
839 }
845 }
848 # 'o' is supported since PHP 5.1.0
849 # return literal if not supported
850 # TODO: emulation for pre 5.1.0 versions
854 }
859 }
867 }
873 }
879 }
885 }
891 }
897 }
932 }
938 }
944 }
948 # Backslash escaping
953 }
956 # Quoted literal
960 # No terminating quote, assume literal "
965 }
967 # Quote at end of string, assume literal "
969 }
973 }
986 }
988 }
989 }
991 }
995 /**
996 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
997 * Gregorian dates to Iranian dates. Originally written in C, it
998 * is released under the terms of GNU Lesser General Public
999 * License. Conversion to PHP was performed by Niklas Laxström.
1000 *
1001 * Link: http://www.farsiweb.info/jalali/jalali.c
1002 */
1008 # Days passed from the beginning (including leap years)
1015 // Add days of the past months of this year
1018 }
1020 // Leap years
1023 }
1025 // Days passed in current month
1039 }
1043 }
1049 }
1051 /**
1052 * Converting Gregorian dates to Hijri dates.
1053 *
1054 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1055 *
1056 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1057 */
1071 )
1072 {
1080 }
1085 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1086 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1092 }
1094 /**
1095 * Converting Gregorian dates to Hebrew dates.
1096 *
1097 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1098 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1099 * to translate the relevant functions into PHP and release them under
1100 * GNU GPL.
1101 *
1102 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1103 * and Adar II is 14. In a non-leap year, Adar is 6.
1104 */
1106 # Parse date
1111 # Calculate Hebrew year
1114 # Month number when September = 1, August = 12
1117 # Next year
1121 }
1123 # Calculate day of year from 1 September
1127 # February
1129 # Check if the year is leap
1132 }
1137 }
1138 }
1140 # Calculate the start of the Hebrew year
1143 # Calculate next year's start
1145 # Day is before the start of the year - it is the previous year
1146 # Next year's start
1148 # Previous year
1151 # Add days since previous year's 1 September
1154 # Leap year
1156 }
1157 # Start of the new (previous) year
1160 # Next year's start
1162 }
1164 # Calculate Hebrew day of year
1167 # Difference between year's days
1169 # Add 12 (or 13 for leap years) days to ignore the difference between
1170 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1171 # difference is only about the year type
1176 }
1178 # Check the year pattern, and is leap year
1179 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1180 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1181 # and non-leap years
1183 # Check if leap year
1186 # Calculate day in the month from number of day in the Hebrew year
1187 # Don't check Adar - if the day is not in Adar, we will stop before;
1188 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1193 # Calculate days in this month
1195 # Adar in a leap year
1197 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1200 # Day in Adar I
1203 # Subtract the days of Adar I
1205 # Try Adar II
1208 # Day in Adar II
1210 }
1211 }
1212 }
1214 # Cheshvan in a complete year (otherwise as the rule below)
1217 # Kislev in an incomplete year (otherwise as the rule below)
1220 # Odd months have 30 days, even have 29
1222 }
1224 # In the current month
1227 # Subtract the days of the current month
1229 # Try in the next month
1231 }
1232 }
1235 }
1237 /**
1238 * This calculates the Hebrew year start, as days since 1 September.
1239 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1240 * Used for Hebrew date.
1241 */
1248 }
1252 }
1262 }
1266 }
1268 /**
1269 * Algorithm to convert Gregorian dates to Thai solar dates,
1270 * Minguo dates or Minguo dates.
1271 *
1272 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1273 * http://en.wikipedia.org/wiki/Minguo_calendar
1274 * http://en.wikipedia.org/wiki/Japanese_era_name
1275 *
1276 * @param $ts String: 14-character timestamp
1277 * @param $cName String: calender name
1278 * @return Array: converted year, month, day
1279 */
1286 # Thai solar dates
1287 # Add 543 years to the Gregorian calendar
1288 # Months and days are identical
1291 # Minguo dates
1292 # Deduct 1911 years from the Gregorian calendar
1293 # Months and days are identical
1296 # Nengō dates up to Meiji period
1297 # Deduct years from the Gregorian calendar
1298 # depending on the nengo periods
1299 # Months and days are identical
1300 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1301 # Meiji period
1306 }
1314 )
1315 {
1316 # Taishō period
1321 }
1327 )
1328 {
1329 # Shōwa period
1334 }
1337 # Heisei period
1342 }
1344 }
1347 }
1350 }
1352 /**
1353 * Roman number formatting up to 3000
1354 */
1361 );
1366 }
1372 }
1374 }
1376 }
1378 /**
1379 * Hebrew Gematria number formatting up to 9999
1380 */
1387 );
1392 }
1404 }
1405 }
1406 }
1408 }
1414 }
1433 }
1435 }
1437 /**
1438 * This is meant to be used by time(), date(), and timeanddate() to get
1439 * the date preference they're supposed to use, it should be used in
1440 * all children.
1441 *
1442 *<code>
1443 * function timeanddate([...], $format = true) {
1444 * $datePreference = $this->dateFormat($format);
1445 * [...]
1446 * }
1447 *</code>
1448 *
1449 * @param $usePrefs Mixed: if true, the user's preference is used
1450 * if false, the site/language default is used
1451 * if int/string, assumed to be a format.
1452 * @return string
1453 */
1462 }
1465 }
1467 // return int
1470 }
1473 }
1475 /**
1476 * Get a format string for a given type and preference
1477 * @param $type May be date, time or both
1478 * @param $pref The format name as it appears in Messages*.php
1479 */
1490 }
1491 }
1493 }
1495 }
1497 /**
1498 * @param $ts Mixed: the time format which needs to be turned into a
1499 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1500 * @param $adj Bool: whether to adjust the time output according to the
1501 * user configured offset ($timecorrection)
1502 * @param $format Mixed: true to use user's date format preference
1503 * @param $timecorrection String: the time offset as returned by
1504 * validateTimeZone() in Special:Preferences
1505 * @return string
1506 */
1510 }
1513 }
1515 /**
1516 * @param $ts Mixed: the time format which needs to be turned into a
1517 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1518 * @param $adj Bool: whether to adjust the time output according to the
1519 * user configured offset ($timecorrection)
1520 * @param $format Mixed: true to use user's date format preference
1521 * @param $timecorrection String: the time offset as returned by
1522 * validateTimeZone() in Special:Preferences
1523 * @return string
1524 */
1528 }
1531 }
1533 /**
1534 * @param $ts Mixed: the time format which needs to be turned into a
1535 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1536 * @param $adj Bool: whether to adjust the time output according to the
1537 * user configured offset ($timecorrection)
1538 * @param $format Mixed: what format to return, if it's false output the
1539 * default one (default true)
1540 * @param $timecorrection String: the time offset as returned by
1541 * validateTimeZone() in Special:Preferences
1542 * @return string
1543 */
1548 }
1551 }
1555 }
1559 }
1562 # This is a wrapper for iconv in all languages except esperanto,
1563 # which does some nasty x-conversions beforehand
1565 # Even with //IGNORE iconv can whine about illegal characters in
1566 # *input* string. We just ignore those too.
1567 # REF: http://bugs.php.net/bug.php?id=37166
1568 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1573 }
1575 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1578 }
1582 }
1587 }
1592 }
1596 }
1601 }
1603 /**
1604 * Make a string's first character uppercase
1605 */
1613 // fall back to more complex logic in case of multibyte strings
1615 }
1616 }
1618 /**
1619 * Convert a string to uppercase
1620 */
1628 }
1631 }
1638 $str
1639 );
1642 }
1643 }
1644 }
1657 }
1658 }
1667 }
1670 }
1677 $str
1678 );
1681 }
1682 }
1683 }
1687 }
1693 // regexp to find first letter in each word (i.e. after each space)
1694 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1696 // function to use to capitalize a single char
1701 $str
1702 );
1707 $str
1708 );
1709 }
1712 }
1713 }
1715 # capitalize words at word breaks
1720 // since \b doesn't work for UTF-8, we explicitely define word break chars
1723 // find first letter after word break
1724 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1730 $str
1731 );
1736 $str
1737 );
1738 }
1743 $str
1744 );
1745 }
1746 }
1748 /**
1749 * Return a case-folded representation of $s
1750 *
1751 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1752 * and $s2 are the same except for the case of their characters. It is not
1753 * necessary for the value returned to make sense when displayed.
1754 *
1755 * Do *not* perform any other normalisation in this function. If a caller
1756 * uses this function when it should be using a more general normalisation
1757 * function, then fix the caller.
1758 */
1761 }
1766 }
1767 # Check for non-UTF-8 URLs
1771 }
1777 }
1780 }
1784 }
1786 /**
1787 * Most writing systems use whitespace to break up words.
1788 * Some languages such as Chinese don't conventionally do this,
1789 * which requires special handling when breaking up words for
1790 * searching etc.
1791 */
1794 }
1796 /**
1797 * Some languages such as Chinese require word segmentation,
1798 * Specify such segmentation when overridden in derived class.
1799 *
1800 * @param $string String
1801 * @return String
1802 */
1805 }
1807 /**
1808 * Some languages have special punctuation need to be normalized.
1809 * Make such changes here.
1810 *
1811 * @param $string String
1812 * @return String
1813 */
1816 }
1818 /**
1819 * convert double-width roman characters to single-width.
1820 * range: ff00-ff5f ~= 0020-007f
1821 */
1831 }
1835 }
1841 }
1844 # some languages, e.g. Chinese, need to do a conversion
1845 # in order for search results to be displayed correctly
1847 }
1849 /**
1850 * Get the first character of a string.
1851 *
1852 * @param $s string
1853 * @return string
1854 */
1861 $matches
1862 );
1867 }
1869 // Break down Hangul syllables to grab the first jamo
1901 }
1904 }
1905 }
1908 # Some languages may have an alternate char encoding option
1909 # (Esperanto X-coding, Japanese furigana conversion, etc)
1910 # If this language is used as the primary content language,
1911 # an override to the defaults can be set here on startup.
1912 }
1915 # For some languages we'll want to explicitly specify
1916 # which characters make it into the edit box raw
1917 # or are converted in some way or another.
1918 # Note that if wgOutputEncoding is different from
1919 # wgInputEncoding, this text will be further converted
1920 # to wgOutputEncoding.
1926 }
1927 }
1930 # Take the previous into account.
1936 }
1941 }
1942 }
1944 /**
1945 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
1946 * also cleans up certain backwards-compatible sequences, converting them
1947 * to the modern Unicode equivalent.
1948 *
1949 * This is language-specific for performance reasons only.
1950 */
1957 }
1960 }
1962 /**
1963 * Transform a string using serialized data stored in the given file (which
1964 * must be in the serialized subdirectory of $IP). The file contains pairs
1965 * mapping source characters to destination characters.
1966 *
1967 * The data is cached in process memory. This will go faster if you have the
1968 * FastStringSearch extension.
1969 */
1975 }
1977 }
1979 }
1981 /**
1982 * For right-to-left language support
1983 *
1984 * @return bool
1985 */
1988 }
1990 /**
1991 * Return the correct HTML 'dir' attribute value for this language.
1992 * @return String
1993 */
1996 }
1998 /**
1999 * Return 'left' or 'right' as appropriate alignment for line-start
2000 * for this language's text direction.
2001 *
2002 * Should be equivalent to CSS3 'start' text-align value....
2003 *
2004 * @return String
2005 */
2008 }
2010 /**
2011 * Return 'right' or 'left' as appropriate alignment for line-end
2012 * for this language's text direction.
2013 *
2014 * Should be equivalent to CSS3 'end' text-align value....
2015 *
2016 * @return String
2017 */
2020 }
2022 /**
2023 * A hidden direction mark (LRM or RLM), depending on the language direction
2024 *
2025 * @return string
2026 */
2029 }
2033 }
2035 /**
2036 * An arrow, depending on the language direction
2037 *
2038 * @return string
2039 */
2042 }
2044 /**
2045 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2046 *
2047 * @return bool
2048 */
2051 }
2055 }
2057 # Fill a MagicWord object with data from here
2064 }
2073 }
2074 }
2081 }
2082 }
2084 /**
2085 * Add magic words to the extension array
2086 */
2093 }
2096 }
2101 }
2102 }
2103 }
2105 /**
2106 * Get special page names, as an associative array
2107 * case folded alias => real name
2108 */
2110 // Cache aliases because it may be slow to load them
2112 // Initialise array
2117 }
2120 }
2122 /**
2123 * Italic is unsuitable for some languages
2124 *
2125 * @param $text String: the text to be emphasized.
2126 * @return string
2127 */
2130 }
2132 /**
2133 * Normally we output all numbers in plain en_US style, that is
2134 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2135 * point twohundredthirtyfive. However this is not sutable for all
2136 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2137 * Icelandic just want to use commas instead of dots, and dots instead
2138 * of commas like "293.291,235".
2139 *
2140 * An example of this function being called:
2141 * <code>
2142 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2143 * </code>
2144 *
2145 * See LanguageGu.php for the Gujarati implementation and
2146 * $separatorTransformTable on MessageIs.php for
2147 * the , => . and . => , implementation.
2148 *
2149 * @todo check if it's viable to use localeconv() for the decimal
2150 * separator thing.
2151 * @param $number Mixed: the string to be formatted, should be an integer
2152 * or a floating point number.
2153 * @param $nocommafy Bool: set to true for special numbers like dates
2154 * @return string
2155 */
2163 }
2164 }
2170 }
2171 }
2174 }
2180 }
2185 }
2189 }
2191 /**
2192 * Adds commas to a given number
2193 *
2194 * @param $_ mixed
2195 * @return string
2196 */
2199 }
2203 }
2207 }
2209 /**
2210 * Take a list of strings and build a locale-friendly comma-separated
2211 * list, using the local comma-separator message.
2212 * The last two strings are chained with an "and".
2213 *
2214 * @param $l Array
2215 * @return string
2216 */
2221 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2227 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2230 }
2231 }
2233 }
2234 }
2236 /**
2237 * Take a list of strings and build a locale-friendly comma-separated
2238 * list, using the local comma-separator message.
2239 * @param $list array of strings to put in a comma list
2240 * @return string
2241 */
2248 )
2249 );
2250 }
2252 /**
2253 * Take a list of strings and build a locale-friendly semicolon-separated
2254 * list, using the local semicolon-separator message.
2255 * @param $list array of strings to put in a semicolon list
2256 * @return string
2257 */
2264 )
2265 );
2266 }
2268 /**
2269 * Same as commaList, but separate it with the pipe instead.
2270 * @param $list array of strings to put in a pipe list
2271 * @return string
2272 */
2279 )
2280 );
2281 }
2283 /**
2284 * Truncate a string to a specified length in bytes, appending an optional
2285 * string (e.g. for ellipses)
2286 *
2287 * The database offers limited byte lengths for some columns in the database;
2288 * multi-byte character sets mean we need to ensure that only whole characters
2289 * are included, otherwise broken characters can be passed to the user
2290 *
2291 * If $length is negative, the string will be truncated from the beginning
2292 *
2293 * @param $string String to truncate
2294 * @param $length Int: maximum length (excluding ellipses)
2295 * @param $ellipsis String to append to the truncated text
2296 * @return string
2297 */
2299 # Use the localized ellipsis character
2302 }
2303 # Check if there is no need to truncate
2308 }
2318 }
2319 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181)
2324 }
2325 }
2327 /**
2328 * Remove bytes that represent an incomplete Unicode character
2329 * at the end of string (e.g. bytes of the char are missing)
2330 *
2331 * @param $string String
2332 * @return string
2333 */
2338 # We got the first byte only of a multibyte char; remove it.
2343 {
2344 # We chopped in the middle of a character; remove it
2346 }
2348 }
2350 /**
2351 * Remove bytes that represent an incomplete Unicode character
2352 * at the start of string (e.g. bytes of the char are missing)
2353 *
2354 * @param $string String
2355 * @return string
2356 */
2360 # We chopped in the middle of a character; remove the whole thing
2362 }
2364 }
2366 /*
2367 * Truncate a string of valid HTML to a specified length in bytes,
2368 * appending an optional string (e.g. for ellipses), and return valid HTML
2369 *
2370 * This is only intended for styled/linked text, such as HTML with
2371 * tags like <span> and <a>, were the tags are self-contained (valid HTML)
2372 *
2373 * Note: tries to fix broken HTML with MWTidy
2374 *
2375 * @param string $text String to truncate
2376 * @param int $length (zero/positive) Maximum length (excluding ellipses)
2377 * @param string $ellipsis String to append to the truncated text
2378 * @returns string
2379 */
2381 # Use the localized ellipsis character
2384 }
2385 # Check if there is no need to truncate
2390 }
2418 }
2424 // Name found (e.g. "<a href=..."), add on tag attributes...
2426 }
2432 }
2438 // Add on the other display text after this...
2443 }
2444 }
2445 }
2446 # Consider truncation once the display length has reached the maximim.
2447 # Double-check that we're not in the middle of a bracket/entity...
2451 # Save where we are; we will truncate here unless
2452 # the ellipsis actually makes the string longer.
2456 # Ellipsis won't make string longer/equal, the truncation point was OK.
2461 }
2462 }
2463 }
2466 }
2470 }
2472 }
2474 // truncateHtml() helper function
2475 // like strcspn() but adds the skipped chars to $ret
2481 }
2483 }
2485 // truncateHtml() helper function
2486 // (a) push or pop $tag from $openTags as needed
2487 // (b) clear $tag value
2496 }
2497 }
2499 }
2500 }
2502 /**
2503 * Grammatical transformations, needed for inflected languages
2504 * Invoked by putting {{grammar:case|word}} in a message
2505 *
2506 * @param $word string
2507 * @param $case string
2508 * @return string
2509 */
2514 }
2516 }
2518 /**
2519 * Provides an alternative text depending on specified gender.
2520 * Usage {{gender:username|masculine|feminine|neutral}}.
2521 * username is optional, in which case the gender of current user is used,
2522 * but only in (some) interface messages; otherwise default gender is used.
2523 * If second or third parameter are not specified, masculine is used.
2524 * These details may be overriden per language.
2525 */
2529 }
2533 }
2536 }
2538 }
2540 /**
2541 * Plural form transformations, needed for some languages.
2542 * For example, there are 3 form of plural in Russian and Polish,
2543 * depending on "count mod 10". See [[w:Plural]]
2544 * For English it is pretty simple.
2545 *
2546 * Invoked by putting {{plural:count|wordform1|wordform2}}
2547 * or {{plural:count|wordform1|wordform2|wordform3}}
2548 *
2549 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2550 *
2551 * @param $count Integer: non-localized number
2552 * @param $forms Array: different plural forms
2553 * @return string Correct form of plural for $count in this language
2554 */
2558 }
2562 }
2564 /**
2565 * Checks that convertPlural was given an array and pads it to requested
2566 * amound of forms by copying the last one.
2567 *
2568 * @param $count Integer: How many forms should there be at least
2569 * @param $forms Array of forms given to convertPlural
2570 * @return array Padded array of forms or an exception if not an array
2571 */
2575 }
2577 }
2579 /**
2580 * For translating of expiry times
2581 * @param $str String: the validated block time in English
2582 * @return Somehow translated block time
2583 * @see LanguageFi.php for example implementation
2584 */
2590 }
2595 }
2599 }
2600 }
2603 }
2605 /**
2606 * languages like Chinese need to be segmented in order for the diff
2607 * to be of any use
2608 *
2609 * @param $text String
2610 * @return String
2611 */
2614 }
2616 /**
2617 * and unsegment to show the result
2618 *
2619 * @param $text String
2620 * @return String
2621 */
2624 }
2626 # convert text to all supported variants
2629 }
2631 # convert text to different variants of a language.
2634 }
2636 # Convert a Title object to a string in the preferred variant
2639 }
2641 # Check if this is a language with variants
2644 }
2646 # Put custom tags (e.g. -{ }-) around math to prevent conversion
2649 }
2651 /**
2652 * Perform output conversion on a string, and encode for safe HTML output.
2653 * @param $text String text to be converted
2654 * @param $isTitle Bool whether this conversion is for the article title
2655 * @return string
2656 * @todo this should get integrated somewhere sane
2657 */
2660 }
2664 }
2666 /**
2667 * Get the list of variants supported by this langauge
2668 * see sample implementation in LanguageZh.php
2669 *
2670 * @return array an array of language codes
2671 */
2674 }
2678 }
2680 /**
2681 * If a language supports multiple variants, it is
2682 * possible that non-existing link in one variant
2683 * actually exists in another variant. this function
2684 * tries to find it. See e.g. LanguageZh.php
2685 *
2686 * @param $link String: the name of the link
2687 * @param $nt Mixed: the title object of the link
2688 * @param $ignoreOtherCond Boolean: to disable other conditions when
2689 * we need to transclude a template or update a category's link
2690 * @return null the input parameters may be modified upon return
2691 */
2694 }
2696 /**
2697 * If a language supports multiple variants, converts text
2698 * into an array of all possible variants of the text:
2699 * 'variant' => text in that variant
2700 */
2703 }
2705 /**
2706 * returns language specific options used by User::getPageRenderHash()
2707 * for example, the preferred language variant
2708 *
2709 * @return string
2710 */
2713 }
2715 /**
2716 * For languages that support multiple variants, the title of an
2717 * article may be displayed differently in different variants. this
2718 * function returns the apporiate title defined in the body of the article.
2719 *
2720 * @return string
2721 */
2724 }
2726 /**
2727 * Enclose a string with the "no conversion" tag. This is used by
2728 * various functions in the Parser
2729 *
2730 * @param $text String: text to be tagged for no conversion
2731 * @param $noParse
2732 * @return string the tagged text
2733 */
2736 }
2738 /**
2739 * A regular expression to match legal word-trailing characters
2740 * which should be merged onto a link of the form [[foo]]bar.
2741 *
2742 * @return string
2743 */
2746 }
2750 }
2752 /**
2753 * Get the RFC 3066 code for this language object
2754 */
2757 }
2761 }
2763 /**
2764 * Get the name of a file for a certain language code
2765 * @param $prefix string Prepend this to the filename
2766 * @param $code string Language code
2767 * @param $suffix string Append this to the filename
2768 * @return string $prefix . $mangledCode . $suffix
2769 */
2772 }
2774 /**
2775 * Get the language code from a file name. Inverse of getFileName()
2776 * @param $filename string $prefix . $languageCode . $suffix
2777 * @param $prefix string Prefix before the language code
2778 * @param $suffix string Suffix after the language code
2779 * @return Language code, or false if $prefix or $suffix isn't found
2780 */
2787 }
2789 }
2794 }
2799 }
2801 /**
2802 * Get the fallback for a given language
2803 */
2806 // Shortcut
2810 }
2811 }
2813 /**
2814 * Get all messages for a given language
2815 * WARNING: this may take a long time
2816 */
2819 }
2821 /**
2822 * Get a message for a given language
2823 */
2826 }
2831 }
2836 # Allow grammar transformations
2837 # Allowing full message-style parsing would make simple requests
2838 # such as action=raw much more expensive than they need to be.
2839 # This will hopefully cover most cases.
2843 }
2847 }
2853 }
2860 }
2864 }
2868 return $this->formatNum( sprintf( "%.1f", $seconds ) ) . $this->getMessageFromDB( 'seconds-abbrev' );
2877 }
2887 }
2891 }
2895 }
2896 }
2902 }
2909 }
2911 }
2913 /**
2914 * Format a size in bytes for output, using an appropriate
2915 * unit (B, KB, MB or GB) according to the magnitude in question
2916 *
2917 * @param $size Size to format
2918 * @return string Plain text (not HTML)
2919 */
2921 // For small sizes no decimal places necessary
2927 // For MB and bigger two decimal places are smarter
2934 }
2937 }
2940 }
2944 }
2946 /**
2947 * Get the conversion rule title, if any.
2948 */
2951 }
2953 /**
2954 * Given a string, convert it to a (hopefully short) key that can be used
2955 * for efficient sorting. A binary sort according to the sortkeys
2956 * corresponds to a logical sort of the corresponding strings. Current
2957 * code expects that a null character should sort before all others, but
2958 * has no other particular expectations (and that one can be changed if
2959 * necessary).
2960 *
2961 * @param string $string UTF-8 string
2962 * @return string Binary sortkey
2963 */
2965 # Fake function for now
2967 }
2969 /**
2970 * Given a string, return the logical "first letter" to be used for
2971 * grouping on category pages and so on. This has to be coordinated
2972 * carefully with convertToSortkey(), or else the sorted list might jump
2973 * back and forth between the same "initial letters" or other pathological
2974 * behavior. For instance, if you just return the first character, but "a"
2975 * sorts the same as "A" based on convertToSortkey(), then you might get a
2976 * list like
2977 *
2978 * == A ==
2979 * * [[Aardvark]]
2980 *
2981 * == a ==
2982 * * [[antelope]]
2983 *
2984 * == A ==
2985 * * [[Ape]]
2986 *
2987 * etc., assuming for the sake of argument that $wgCapitalLinks is false.
2988 *
2989 * @param string $string UTF-8 string
2990 * @return string UTF-8 string corresponding to the first letter of input
2991 */
2995 }
2997 }
2998 }