| blob | 904d9561448d9cbc6f5caee4525a5b3cb9b2f591 |
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. There are a number of extensions, which
622 * start with "x":
623 *
624 * xn Do not translate digits of the next numeric format character
625 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
626 * xr Use roman numerals for the next numeric format character
627 * xh Use hebrew numerals for the next numeric format character
628 * xx Literal x
629 * xg Genitive month name
630 *
631 * xij j (day number) in Iranian calendar
632 * xiF F (month name) in Iranian calendar
633 * xin n (month number) in Iranian calendar
634 * xiY Y (full year) in Iranian calendar
635 *
636 * xjj j (day number) in Hebrew calendar
637 * xjF F (month name) in Hebrew calendar
638 * xjt t (days in month) in Hebrew calendar
639 * xjx xg (genitive month name) in Hebrew calendar
640 * xjn n (month number) in Hebrew calendar
641 * xjY Y (full year) in Hebrew calendar
642 *
643 * xmj j (day number) in Hijri calendar
644 * xmF F (month name) in Hijri calendar
645 * xmn n (month number) in Hijri calendar
646 * xmY Y (full year) in Hijri calendar
647 *
648 * xkY Y (full year) in Thai solar calendar. Months and days are
649 * identical to the Gregorian calendar
650 * xoY Y (full year) in Minguo calendar or Juche year.
651 * Months and days are identical to the
652 * Gregorian calendar
653 * xtY Y (full year) in Japanese nengo. Months and days are
654 * identical to the Gregorian calendar
655 *
656 * Characters enclosed in double quotes will be considered literal (with
657 * the quotes themselves removed). Unmatched quotes will be considered
658 * literal quotes. Example:
659 *
660 * "The month is" F => The month is January
661 * i's" => 20'11"
662 *
663 * Backslash escaping is also supported.
664 *
665 * Input timestamp is assumed to be pre-normalized to the desired local
666 * time zone, if any.
667 *
668 * @param $format String
669 * @param $ts String: 14-character timestamp
670 * YYYYMMDDHHMMSS
671 * 01234567890123
672 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
673 */
692 }
694 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
696 }
734 }
740 }
746 }
752 }
758 }
765 }
771 }
777 }
786 }
792 }
798 }
813 }
819 }
825 }
831 }
837 }
843 }
849 }
858 }
864 }
870 }
876 }
882 }
888 }
923 }
929 }
935 }
939 # Backslash escaping
944 }
947 # Quoted literal
951 # No terminating quote, assume literal "
956 }
958 # Quote at end of string, assume literal "
960 }
964 }
977 }
979 }
980 }
982 }
986 /**
987 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
988 * Gregorian dates to Iranian dates. Originally written in C, it
989 * is released under the terms of GNU Lesser General Public
990 * License. Conversion to PHP was performed by Niklas Laxström.
991 *
992 * Link: http://www.farsiweb.info/jalali/jalali.c
993 */
999 # Days passed from the beginning (including leap years)
1006 // Add days of the past months of this year
1009 }
1011 // Leap years
1014 }
1016 // Days passed in current month
1030 }
1034 }
1040 }
1042 /**
1043 * Converting Gregorian dates to Hijri dates.
1044 *
1045 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1046 *
1047 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1048 */
1062 )
1063 {
1071 }
1076 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1077 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1083 }
1085 /**
1086 * Converting Gregorian dates to Hebrew dates.
1087 *
1088 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1089 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1090 * to translate the relevant functions into PHP and release them under
1091 * GNU GPL.
1092 *
1093 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1094 * and Adar II is 14. In a non-leap year, Adar is 6.
1095 */
1097 # Parse date
1102 # Calculate Hebrew year
1105 # Month number when September = 1, August = 12
1108 # Next year
1112 }
1114 # Calculate day of year from 1 September
1118 # February
1120 # Check if the year is leap
1123 }
1128 }
1129 }
1131 # Calculate the start of the Hebrew year
1134 # Calculate next year's start
1136 # Day is before the start of the year - it is the previous year
1137 # Next year's start
1139 # Previous year
1142 # Add days since previous year's 1 September
1145 # Leap year
1147 }
1148 # Start of the new (previous) year
1151 # Next year's start
1153 }
1155 # Calculate Hebrew day of year
1158 # Difference between year's days
1160 # Add 12 (or 13 for leap years) days to ignore the difference between
1161 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1162 # difference is only about the year type
1167 }
1169 # Check the year pattern, and is leap year
1170 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1171 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1172 # and non-leap years
1174 # Check if leap year
1177 # Calculate day in the month from number of day in the Hebrew year
1178 # Don't check Adar - if the day is not in Adar, we will stop before;
1179 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1184 # Calculate days in this month
1186 # Adar in a leap year
1188 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1191 # Day in Adar I
1194 # Subtract the days of Adar I
1196 # Try Adar II
1199 # Day in Adar II
1201 }
1202 }
1203 }
1205 # Cheshvan in a complete year (otherwise as the rule below)
1208 # Kislev in an incomplete year (otherwise as the rule below)
1211 # Odd months have 30 days, even have 29
1213 }
1215 # In the current month
1218 # Subtract the days of the current month
1220 # Try in the next month
1222 }
1223 }
1226 }
1228 /**
1229 * This calculates the Hebrew year start, as days since 1 September.
1230 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1231 * Used for Hebrew date.
1232 */
1239 }
1243 }
1253 }
1257 }
1259 /**
1260 * Algorithm to convert Gregorian dates to Thai solar dates,
1261 * Minguo dates or Minguo dates.
1262 *
1263 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1264 * http://en.wikipedia.org/wiki/Minguo_calendar
1265 * http://en.wikipedia.org/wiki/Japanese_era_name
1266 *
1267 * @param $ts String: 14-character timestamp
1268 * @param $cName String: calender name
1269 * @return Array: converted year, month, day
1270 */
1277 # Thai solar dates
1278 # Add 543 years to the Gregorian calendar
1279 # Months and days are identical
1282 # Minguo dates
1283 # Deduct 1911 years from the Gregorian calendar
1284 # Months and days are identical
1287 # Nengō dates up to Meiji period
1288 # Deduct years from the Gregorian calendar
1289 # depending on the nengo periods
1290 # Months and days are identical
1291 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1292 # Meiji period
1297 }
1305 )
1306 {
1307 # Taishō period
1312 }
1318 )
1319 {
1320 # Shōwa period
1325 }
1328 # Heisei period
1333 }
1335 }
1338 }
1341 }
1343 /**
1344 * Roman number formatting up to 3000
1345 */
1352 );
1357 }
1363 }
1365 }
1367 }
1369 /**
1370 * Hebrew Gematria number formatting up to 9999
1371 */
1378 );
1383 }
1395 }
1396 }
1397 }
1399 }
1405 }
1424 }
1426 }
1428 /**
1429 * This is meant to be used by time(), date(), and timeanddate() to get
1430 * the date preference they're supposed to use, it should be used in
1431 * all children.
1432 *
1433 *<code>
1434 * function timeanddate([...], $format = true) {
1435 * $datePreference = $this->dateFormat($format);
1436 * [...]
1437 * }
1438 *</code>
1439 *
1440 * @param $usePrefs Mixed: if true, the user's preference is used
1441 * if false, the site/language default is used
1442 * if int/string, assumed to be a format.
1443 * @return string
1444 */
1453 }
1456 }
1458 // return int
1461 }
1464 }
1466 /**
1467 * Get a format string for a given type and preference
1468 * @param $type May be date, time or both
1469 * @param $pref The format name as it appears in Messages*.php
1470 */
1481 }
1482 }
1484 }
1486 }
1488 /**
1489 * @param $ts Mixed: the time format which needs to be turned into a
1490 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1491 * @param $adj Bool: whether to adjust the time output according to the
1492 * user configured offset ($timecorrection)
1493 * @param $format Mixed: true to use user's date format preference
1494 * @param $timecorrection String: the time offset as returned by
1495 * validateTimeZone() in Special:Preferences
1496 * @return string
1497 */
1502 }
1505 }
1507 /**
1508 * @param $ts Mixed: the time format which needs to be turned into a
1509 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1510 * @param $adj Bool: whether to adjust the time output according to the
1511 * user configured offset ($timecorrection)
1512 * @param $format Mixed: true to use user's date format preference
1513 * @param $timecorrection String: the time offset as returned by
1514 * validateTimeZone() in Special:Preferences
1515 * @return string
1516 */
1521 }
1524 }
1526 /**
1527 * @param $ts Mixed: the time format which needs to be turned into a
1528 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1529 * @param $adj Bool: whether to adjust the time output according to the
1530 * user configured offset ($timecorrection)
1531 * @param $format Mixed: what format to return, if it's false output the
1532 * default one (default true)
1533 * @param $timecorrection String: the time offset as returned by
1534 * validateTimeZone() in Special:Preferences
1535 * @return string
1536 */
1541 }
1544 }
1548 }
1552 }
1555 # This is a wrapper for iconv in all languages except esperanto,
1556 # which does some nasty x-conversions beforehand
1558 # Even with //IGNORE iconv can whine about illegal characters in
1559 # *input* string. We just ignore those too.
1560 # REF: http://bugs.php.net/bug.php?id=37166
1561 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1566 }
1568 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1571 }
1575 }
1580 }
1585 }
1589 }
1594 }
1596 /**
1597 * Make a string's first character uppercase
1598 */
1606 // fall back to more complex logic in case of multibyte strings
1608 }
1609 }
1611 /**
1612 * Convert a string to uppercase
1613 */
1621 }
1624 }
1631 $str
1632 );
1635 }
1636 }
1637 }
1650 }
1651 }
1660 }
1663 }
1670 $str
1671 );
1674 }
1675 }
1676 }
1680 }
1686 // regexp to find first letter in each word (i.e. after each space)
1687 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1689 // function to use to capitalize a single char
1694 $str
1695 );
1700 $str
1701 );
1702 }
1705 }
1706 }
1708 # capitalize words at word breaks
1713 // since \b doesn't work for UTF-8, we explicitely define word break chars
1716 // find first letter after word break
1717 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1723 $str
1724 );
1729 $str
1730 );
1731 }
1736 $str
1737 );
1738 }
1739 }
1741 /**
1742 * Return a case-folded representation of $s
1743 *
1744 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1745 * and $s2 are the same except for the case of their characters. It is not
1746 * necessary for the value returned to make sense when displayed.
1747 *
1748 * Do *not* perform any other normalisation in this function. If a caller
1749 * uses this function when it should be using a more general normalisation
1750 * function, then fix the caller.
1751 */
1754 }
1759 }
1760 # Check for non-UTF-8 URLs
1764 }
1770 }
1773 }
1777 }
1779 /**
1780 * Most writing systems use whitespace to break up words.
1781 * Some languages such as Chinese don't conventionally do this,
1782 * which requires special handling when breaking up words for
1783 * searching etc.
1784 */
1787 }
1789 /**
1790 * Some languages such as Chinese require word segmentation,
1791 * Specify such segmentation when overridden in derived class.
1792 *
1793 * @param $string String
1794 * @return String
1795 */
1798 }
1800 /**
1801 * Some languages have special punctuation need to be normalized.
1802 * Make such changes here.
1803 *
1804 * @param $string String
1805 * @return String
1806 */
1809 }
1811 /**
1812 * convert double-width roman characters to single-width.
1813 * range: ff00-ff5f ~= 0020-007f
1814 */
1824 }
1828 }
1834 }
1837 # some languages, e.g. Chinese, need to do a conversion
1838 # in order for search results to be displayed correctly
1840 }
1842 /**
1843 * Get the first character of a string.
1844 *
1845 * @param $s string
1846 * @return string
1847 */
1854 $matches
1855 );
1860 }
1862 // Break down Hangul syllables to grab the first jamo
1894 }
1897 }
1898 }
1901 # Some languages may have an alternate char encoding option
1902 # (Esperanto X-coding, Japanese furigana conversion, etc)
1903 # If this language is used as the primary content language,
1904 # an override to the defaults can be set here on startup.
1905 }
1908 # For some languages we'll want to explicitly specify
1909 # which characters make it into the edit box raw
1910 # or are converted in some way or another.
1911 # Note that if wgOutputEncoding is different from
1912 # wgInputEncoding, this text will be further converted
1913 # to wgOutputEncoding.
1919 }
1920 }
1923 # Take the previous into account.
1929 }
1934 }
1935 }
1937 /**
1938 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
1939 * also cleans up certain backwards-compatible sequences, converting them
1940 * to the modern Unicode equivalent.
1941 *
1942 * This is language-specific for performance reasons only.
1943 */
1950 }
1953 }
1955 /**
1956 * Transform a string using serialized data stored in the given file (which
1957 * must be in the serialized subdirectory of $IP). The file contains pairs
1958 * mapping source characters to destination characters.
1959 *
1960 * The data is cached in process memory. This will go faster if you have the
1961 * FastStringSearch extension.
1962 */
1968 }
1970 }
1972 }
1974 /**
1975 * For right-to-left language support
1976 *
1977 * @return bool
1978 */
1981 }
1983 /**
1984 * Return the correct HTML 'dir' attribute value for this language.
1985 * @return String
1986 */
1989 }
1991 /**
1992 * Return 'left' or 'right' as appropriate alignment for line-start
1993 * for this language's text direction.
1994 *
1995 * Should be equivalent to CSS3 'start' text-align value....
1996 *
1997 * @return String
1998 */
2001 }
2003 /**
2004 * Return 'right' or 'left' as appropriate alignment for line-end
2005 * for this language's text direction.
2006 *
2007 * Should be equivalent to CSS3 'end' text-align value....
2008 *
2009 * @return String
2010 */
2013 }
2015 /**
2016 * A hidden direction mark (LRM or RLM), depending on the language direction
2017 *
2018 * @return string
2019 */
2022 }
2026 }
2028 /**
2029 * An arrow, depending on the language direction
2030 *
2031 * @return string
2032 */
2035 }
2037 /**
2038 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2039 *
2040 * @return bool
2041 */
2044 }
2048 }
2050 # Fill a MagicWord object with data from here
2057 }
2066 }
2067 }
2074 }
2075 }
2077 /**
2078 * Add magic words to the extension array
2079 */
2086 }
2089 }
2094 }
2095 }
2096 }
2098 /**
2099 * Get special page names, as an associative array
2100 * case folded alias => real name
2101 */
2103 // Cache aliases because it may be slow to load them
2105 // Initialise array
2110 }
2113 }
2115 /**
2116 * Italic is unsuitable for some languages
2117 *
2118 * @param $text String: the text to be emphasized.
2119 * @return string
2120 */
2123 }
2125 /**
2126 * Normally we output all numbers in plain en_US style, that is
2127 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2128 * point twohundredthirtyfive. However this is not sutable for all
2129 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2130 * Icelandic just want to use commas instead of dots, and dots instead
2131 * of commas like "293.291,235".
2132 *
2133 * An example of this function being called:
2134 * <code>
2135 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2136 * </code>
2137 *
2138 * See LanguageGu.php for the Gujarati implementation and
2139 * $separatorTransformTable on MessageIs.php for
2140 * the , => . and . => , implementation.
2141 *
2142 * @todo check if it's viable to use localeconv() for the decimal
2143 * separator thing.
2144 * @param $number Mixed: the string to be formatted, should be an integer
2145 * or a floating point number.
2146 * @param $nocommafy Bool: set to true for special numbers like dates
2147 * @return string
2148 */
2156 }
2157 }
2163 }
2164 }
2167 }
2173 }
2178 }
2182 }
2184 /**
2185 * Adds commas to a given number
2186 *
2187 * @param $_ mixed
2188 * @return string
2189 */
2192 }
2196 }
2200 }
2202 /**
2203 * Take a list of strings and build a locale-friendly comma-separated
2204 * list, using the local comma-separator message.
2205 * The last two strings are chained with an "and".
2206 *
2207 * @param $l Array
2208 * @return string
2209 */
2214 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2220 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2223 }
2224 }
2226 }
2227 }
2229 /**
2230 * Take a list of strings and build a locale-friendly comma-separated
2231 * list, using the local comma-separator message.
2232 * @param $list array of strings to put in a comma list
2233 * @return string
2234 */
2241 )
2242 );
2243 }
2245 /**
2246 * Take a list of strings and build a locale-friendly semicolon-separated
2247 * list, using the local semicolon-separator message.
2248 * @param $list array of strings to put in a semicolon list
2249 * @return string
2250 */
2257 )
2258 );
2259 }
2261 /**
2262 * Same as commaList, but separate it with the pipe instead.
2263 * @param $list array of strings to put in a pipe list
2264 * @return string
2265 */
2272 )
2273 );
2274 }
2276 /**
2277 * Truncate a string to a specified length in bytes, appending an optional
2278 * string (e.g. for ellipses)
2279 *
2280 * The database offers limited byte lengths for some columns in the database;
2281 * multi-byte character sets mean we need to ensure that only whole characters
2282 * are included, otherwise broken characters can be passed to the user
2283 *
2284 * If $length is negative, the string will be truncated from the beginning
2285 *
2286 * @param $string String to truncate
2287 * @param $length Int: maximum length (excluding ellipses)
2288 * @param $ellipsis String to append to the truncated text
2289 * @return string
2290 */
2292 # Use the localized ellipsis character
2295 }
2296 # Check if there is no need to truncate
2301 }
2311 }
2312 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181)
2317 }
2318 }
2320 /**
2321 * Remove bytes that represent an incomplete Unicode character
2322 * at the end of string (e.g. bytes of the char are missing)
2323 *
2324 * @param $string String
2325 * @return string
2326 */
2331 # We got the first byte only of a multibyte char; remove it.
2336 {
2337 # We chopped in the middle of a character; remove it
2339 }
2341 }
2343 /**
2344 * Remove bytes that represent an incomplete Unicode character
2345 * at the start of string (e.g. bytes of the char are missing)
2346 *
2347 * @param $string String
2348 * @return string
2349 */
2353 # We chopped in the middle of a character; remove the whole thing
2355 }
2357 }
2359 /*
2360 * Truncate a string of valid HTML to a specified length in bytes,
2361 * appending an optional string (e.g. for ellipses), and return valid HTML
2362 *
2363 * This is only intended for styled/linked text, such as HTML with
2364 * tags like <span> and <a>, were the tags are self-contained (valid HTML)
2365 *
2366 * Note: tries to fix broken HTML with MWTidy
2367 *
2368 * @param string $text String to truncate
2369 * @param int $length (zero/positive) Maximum length (excluding ellipses)
2370 * @param string $ellipsis String to append to the truncated text
2371 * @returns string
2372 */
2374 # Use the localized ellipsis character
2377 }
2378 # Check if there is no need to truncate
2383 }
2411 }
2417 // Name found (e.g. "<a href=..."), add on tag attributes...
2419 }
2425 }
2431 // Add on the other display text after this...
2436 }
2437 }
2438 }
2439 # Consider truncation once the display length has reached the maximim.
2440 # Double-check that we're not in the middle of a bracket/entity...
2444 # Save where we are; we will truncate here unless
2445 # the ellipsis actually makes the string longer.
2449 # Ellipsis won't make string longer/equal, the truncation point was OK.
2454 }
2455 }
2456 }
2459 }
2463 }
2465 }
2467 // truncateHtml() helper function
2468 // like strcspn() but adds the skipped chars to $ret
2474 }
2476 }
2478 // truncateHtml() helper function
2479 // (a) push or pop $tag from $openTags as needed
2480 // (b) clear $tag value
2489 }
2490 }
2492 }
2493 }
2495 /**
2496 * Grammatical transformations, needed for inflected languages
2497 * Invoked by putting {{grammar:case|word}} in a message
2498 *
2499 * @param $word string
2500 * @param $case string
2501 * @return string
2502 */
2507 }
2509 }
2511 /**
2512 * Provides an alternative text depending on specified gender.
2513 * Usage {{gender:username|masculine|feminine|neutral}}.
2514 * username is optional, in which case the gender of current user is used,
2515 * but only in (some) interface messages; otherwise default gender is used.
2516 * If second or third parameter are not specified, masculine is used.
2517 * These details may be overriden per language.
2518 */
2522 }
2526 }
2529 }
2531 }
2533 /**
2534 * Plural form transformations, needed for some languages.
2535 * For example, there are 3 form of plural in Russian and Polish,
2536 * depending on "count mod 10". See [[w:Plural]]
2537 * For English it is pretty simple.
2538 *
2539 * Invoked by putting {{plural:count|wordform1|wordform2}}
2540 * or {{plural:count|wordform1|wordform2|wordform3}}
2541 *
2542 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2543 *
2544 * @param $count Integer: non-localized number
2545 * @param $forms Array: different plural forms
2546 * @return string Correct form of plural for $count in this language
2547 */
2551 }
2555 }
2557 /**
2558 * Checks that convertPlural was given an array and pads it to requested
2559 * amound of forms by copying the last one.
2560 *
2561 * @param $count Integer: How many forms should there be at least
2562 * @param $forms Array of forms given to convertPlural
2563 * @return array Padded array of forms or an exception if not an array
2564 */
2568 }
2570 }
2572 /**
2573 * For translating of expiry times
2574 * @param $str String: the validated block time in English
2575 * @return Somehow translated block time
2576 * @see LanguageFi.php for example implementation
2577 */
2583 }
2588 }
2592 }
2593 }
2596 }
2598 /**
2599 * languages like Chinese need to be segmented in order for the diff
2600 * to be of any use
2601 *
2602 * @param $text String
2603 * @return String
2604 */
2607 }
2609 /**
2610 * and unsegment to show the result
2611 *
2612 * @param $text String
2613 * @return String
2614 */
2617 }
2619 # convert text to all supported variants
2622 }
2624 # convert text to different variants of a language.
2627 }
2629 # Convert a Title object to a string in the preferred variant
2632 }
2634 # Check if this is a language with variants
2637 }
2639 # Put custom tags (e.g. -{ }-) around math to prevent conversion
2642 }
2644 /**
2645 * Perform output conversion on a string, and encode for safe HTML output.
2646 * @param $text String text to be converted
2647 * @param $isTitle Bool whether this conversion is for the article title
2648 * @return string
2649 * @todo this should get integrated somewhere sane
2650 */
2653 }
2657 }
2659 /**
2660 * Get the list of variants supported by this langauge
2661 * see sample implementation in LanguageZh.php
2662 *
2663 * @return array an array of language codes
2664 */
2667 }
2671 }
2673 /**
2674 * If a language supports multiple variants, it is
2675 * possible that non-existing link in one variant
2676 * actually exists in another variant. this function
2677 * tries to find it. See e.g. LanguageZh.php
2678 *
2679 * @param $link String: the name of the link
2680 * @param $nt Mixed: the title object of the link
2681 * @param $ignoreOtherCond Boolean: to disable other conditions when
2682 * we need to transclude a template or update a category's link
2683 * @return null the input parameters may be modified upon return
2684 */
2687 }
2689 /**
2690 * If a language supports multiple variants, converts text
2691 * into an array of all possible variants of the text:
2692 * 'variant' => text in that variant
2693 */
2696 }
2698 /**
2699 * returns language specific options used by User::getPageRenderHash()
2700 * for example, the preferred language variant
2701 *
2702 * @return string
2703 */
2706 }
2708 /**
2709 * For languages that support multiple variants, the title of an
2710 * article may be displayed differently in different variants. this
2711 * function returns the apporiate title defined in the body of the article.
2712 *
2713 * @return string
2714 */
2717 }
2719 /**
2720 * Enclose a string with the "no conversion" tag. This is used by
2721 * various functions in the Parser
2722 *
2723 * @param $text String: text to be tagged for no conversion
2724 * @param $noParse
2725 * @return string the tagged text
2726 */
2729 }
2731 /**
2732 * A regular expression to match legal word-trailing characters
2733 * which should be merged onto a link of the form [[foo]]bar.
2734 *
2735 * @return string
2736 */
2739 }
2743 }
2745 /**
2746 * Get the RFC 3066 code for this language object
2747 */
2750 }
2754 }
2756 /**
2757 * Get the name of a file for a certain language code
2758 * @param $prefix string Prepend this to the filename
2759 * @param $code string Language code
2760 * @param $suffix string Append this to the filename
2761 * @return string $prefix . $mangledCode . $suffix
2762 */
2765 }
2767 /**
2768 * Get the language code from a file name. Inverse of getFileName()
2769 * @param $filename string $prefix . $languageCode . $suffix
2770 * @param $prefix string Prefix before the language code
2771 * @param $suffix string Suffix after the language code
2772 * @return Language code, or false if $prefix or $suffix isn't found
2773 */
2780 }
2782 }
2787 }
2792 }
2794 /**
2795 * Get the fallback for a given language
2796 */
2799 // Shortcut
2803 }
2804 }
2806 /**
2807 * Get all messages for a given language
2808 * WARNING: this may take a long time
2809 */
2812 }
2814 /**
2815 * Get a message for a given language
2816 */
2819 }
2824 }
2829 # Allow grammar transformations
2830 # Allowing full message-style parsing would make simple requests
2831 # such as action=raw much more expensive than they need to be.
2832 # This will hopefully cover most cases.
2836 }
2840 }
2846 }
2853 }
2857 }
2861 return $this->formatNum( sprintf( "%.1f", $seconds ) ) . $this->getMessageFromDB( 'seconds-abbrev' );
2870 }
2880 }
2884 }
2888 }
2889 }
2895 }
2902 }
2904 }
2906 /**
2907 * Format a size in bytes for output, using an appropriate
2908 * unit (B, KB, MB or GB) according to the magnitude in question
2909 *
2910 * @param $size Size to format
2911 * @return string Plain text (not HTML)
2912 */
2914 // For small sizes no decimal places necessary
2920 // For MB and bigger two decimal places are smarter
2927 }
2930 }
2933 }
2937 }
2939 /**
2940 * Get the conversion rule title, if any.
2941 */
2944 }
2946 /**
2947 * Given a string, convert it to a (hopefully short) key that can be used
2948 * for efficient sorting. A binary sort according to the sortkeys
2949 * corresponds to a logical sort of the corresponding strings. Current
2950 * code expects that a null character should sort before all others, but
2951 * has no other particular expectations (and that one can be changed if
2952 * necessary).
2953 *
2954 * @param string $string UTF-8 string
2955 * @return string Binary sortkey
2956 */
2958 # Fake function for now
2960 }
2962 /**
2963 * Given a string, return the logical "first letter" to be used for
2964 * grouping on category pages and so on. This has to be coordinated
2965 * carefully with convertToSortkey(), or else the sorted list might jump
2966 * back and forth between the same "initial letters" or other pathological
2967 * behavior. For instance, if you just return the first character, but "a"
2968 * sorts the same as "A" based on convertToSortkey(), then you might get a
2969 * list like
2970 *
2971 * == A ==
2972 * * [[Aardvark]]
2973 *
2974 * == a ==
2975 * * [[antelope]]
2976 *
2977 * == A ==
2978 * * [[Ape]]
2979 *
2980 * etc., assuming for the sake of argument that $wgCapitalLinks is false.
2981 *
2982 * @param string $string UTF-8 string
2983 * @return string UTF-8 string corresponding to the first letter of input
2984 */
2988 }
2990 }
2991 }