| blob | 2829153fda6ffe71669ddfb9d38a0f71be99ed00 |
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 */
57 }
59 /**
60 * Internationalisation code
61 * @ingroup Language
62 */
71 /**
72 * ReplacementArray object caches
73 */
82 );
86 );
91 'december'
92 );
96 'december-gen'
97 );
101 );
108 );
116 );
124 );
131 );
133 /**
134 * Get a cached language object for a given language code
135 */
139 // Don't keep a billion objects around, that's stupid.
141 }
143 }
145 }
147 /**
148 * Create a language object for a given language code
149 */
157 // Preload base classes to work around APC/PHP5 bug
160 }
163 }
164 }
168 }
178 }
180 }
182 /**
183 * Get the LocalisationCache instance
184 */
190 }
192 }
196 // Set the code to the name of the descendant
201 }
203 }
205 /**
206 * Reduce memory usage
207 */
211 }
212 }
214 /**
215 * Hook which will be called if this is the content language.
216 * Descendants can use this to register hook functions or modify globals
217 */
220 /**
221 * @deprecated Use User::getDefaultOptions()
222 * @return array
223 */
227 }
234 }
235 }
237 /**
238 * Exports $wgBookstoreListEn
239 * @return array
240 */
243 }
245 /**
246 * @return array
247 */
264 }
266 # Sometimes a language will be localised but not actually exist on this wiki.
270 }
271 }
273 # The above mixing may leave namespaces out of canonical order.
274 # Re-order by namespace ID number...
276 }
278 }
280 /**
281 * A convenience function that returns the same thing as
282 * getNamespaces() except with the array values changed to ' '
283 * where it found '_', useful for producing output to be displayed
284 * e.g. in <select> forms.
285 *
286 * @return array
287 */
292 }
294 }
296 /**
297 * Get a namespace value by key
298 * <code>
299 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
300 * echo $mw_ns; // prints 'MediaWiki'
301 * </code>
302 *
303 * @param $index Int: the array key of the namespace to return
304 * @return mixed, string if the namespace value exists, otherwise false
305 */
309 }
311 /**
312 * A convenience function that returns the same thing as
313 * getNsText() except with '_' changed to ' ', useful for
314 * producing output.
315 *
316 * @return array
317 */
321 }
323 /**
324 * Get a namespace key by value, case insensitive.
325 * Only matches namespace names for the current language, not the
326 * canonical ones defined in Namespace.php.
327 *
328 * @param $text String
329 * @return mixed An integer if $text is a valid value otherwise false
330 */
335 }
348 }
349 }
350 }
352 }
354 }
359 # Put namespace names and aliases into a hashtable.
360 # If this is too slow, then we should arrange it so that it is done
361 # before caching. The catch is that at pre-cache time, the above
362 # class-specific fixup hasn't been done.
366 }
369 }
373 }
374 }
375 }
377 }
380 /**
381 * Get a namespace key by value, case insensitive. Canonical namespace
382 * names override custom ones defined for the current language.
383 *
384 * @param $text String
385 * @return mixed An integer if $text is a valid value otherwise false
386 */
391 }
394 }
396 /**
397 * short names for language variants used for language conversion links.
398 *
399 * @param $code String
400 * @return string
401 */
404 }
410 }
412 }
421 );
422 }
426 }
430 }
434 }
443 }
444 }
448 }
452 }
456 }
460 }
464 }
466 /**
467 * Get language names, indexed by code.
468 * If $customisedOnly is true, only returns codes with a messages file
469 */
475 }
484 }
485 }
488 }
490 /**
491 * Get a message from the MediaWiki namespace.
492 *
493 * @param $msg String: message name
494 * @return string
495 */
498 }
504 }
506 }
510 }
514 }
518 }
522 }
526 }
530 }
534 }
538 }
542 }
544 /**
545 * Used by date() and time() to adjust the time output.
546 *
547 * @param $ts Int the time in date('YmdHis') format
548 * @param $tz Mixed: adjust the time by this amount (default false, mean we
549 * get user timecorrection setting)
550 * @return int
551 */
557 }
567 }
568 # Unrecognized timezone, default to 'Offset' with the stored offset.
570 }
574 # Global offset in minutes.
577 }
588 }
591 }
592 }
594 # No difference ? Return time unchanged
597 }
600 # Generate an adjusted date; take advantage of the fact that mktime
601 # will normalize out-of-range values so we don't have to split $minDiff
602 # into hours and minutes.
615 }
617 /**
618 * This is a workalike of PHP's date() function, but with better
619 * internationalisation, a reduced set of format characters, and a better
620 * escaping format.
621 *
622 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
623 * PHP manual for definitions. There are a number of extensions, which
624 * start with "x":
625 *
626 * xn Do not translate digits of the next numeric format character
627 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
628 * xr Use roman numerals for the next numeric format character
629 * xh Use hebrew numerals for the next numeric format character
630 * xx Literal x
631 * xg Genitive month name
632 *
633 * xij j (day number) in Iranian calendar
634 * xiF F (month name) in Iranian calendar
635 * xin n (month number) in Iranian calendar
636 * xiY Y (full year) in Iranian calendar
637 *
638 * xjj j (day number) in Hebrew calendar
639 * xjF F (month name) in Hebrew calendar
640 * xjt t (days in month) in Hebrew calendar
641 * xjx xg (genitive month name) in Hebrew calendar
642 * xjn n (month number) in Hebrew calendar
643 * xjY Y (full year) in Hebrew calendar
644 *
645 * xmj j (day number) in Hijri calendar
646 * xmF F (month name) in Hijri calendar
647 * xmn n (month number) in Hijri calendar
648 * xmY Y (full year) in Hijri calendar
649 *
650 * xkY Y (full year) in Thai solar calendar. Months and days are
651 * identical to the Gregorian calendar
652 * xoY Y (full year) in Minguo calendar or Juche year.
653 * Months and days are identical to the
654 * Gregorian calendar
655 * xtY Y (full year) in Japanese nengo. Months and days are
656 * identical to the Gregorian calendar
657 *
658 * Characters enclosed in double quotes will be considered literal (with
659 * the quotes themselves removed). Unmatched quotes will be considered
660 * literal quotes. Example:
661 *
662 * "The month is" F => The month is January
663 * i's" => 20'11"
664 *
665 * Backslash escaping is also supported.
666 *
667 * Input timestamp is assumed to be pre-normalized to the desired local
668 * time zone, if any.
669 *
670 * @param $format String
671 * @param $ts String: 14-character timestamp
672 * YYYYMMDDHHMMSS
673 * 01234567890123
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 }
851 }
860 }
866 }
872 }
878 }
884 }
890 }
925 }
931 }
937 }
941 # Backslash escaping
946 }
949 # Quoted literal
953 # No terminating quote, assume literal "
958 }
960 # Quote at end of string, assume literal "
962 }
966 }
979 }
980 }
981 }
983 }
987 /**
988 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
989 * Gregorian dates to Iranian dates. Originally written in C, it
990 * is released under the terms of GNU Lesser General Public
991 * License. Conversion to PHP was performed by Niklas Laxström.
992 *
993 * Link: http://www.farsiweb.info/jalali/jalali.c
994 */
1000 # Days passed from the beginning (including leap years)
1007 // Add days of the past months of this year
1010 }
1012 // Leap years
1015 }
1017 // Days passed in current month
1031 }
1035 }
1041 }
1043 /**
1044 * Converting Gregorian dates to Hijri dates.
1045 *
1046 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1047 *
1048 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1049 */
1063 )
1064 {
1072 }
1077 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1078 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1084 }
1086 /**
1087 * Converting Gregorian dates to Hebrew dates.
1088 *
1089 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1090 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1091 * to translate the relevant functions into PHP and release them under
1092 * GNU GPL.
1093 *
1094 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1095 * and Adar II is 14. In a non-leap year, Adar is 6.
1096 */
1098 # Parse date
1103 # Calculate Hebrew year
1106 # Month number when September = 1, August = 12
1109 # Next year
1113 }
1115 # Calculate day of year from 1 September
1119 # February
1121 # Check if the year is leap
1124 }
1129 }
1130 }
1132 # Calculate the start of the Hebrew year
1135 # Calculate next year's start
1137 # Day is before the start of the year - it is the previous year
1138 # Next year's start
1140 # Previous year
1143 # Add days since previous year's 1 September
1146 # Leap year
1148 }
1149 # Start of the new (previous) year
1152 # Next year's start
1154 }
1156 # Calculate Hebrew day of year
1159 # Difference between year's days
1161 # Add 12 (or 13 for leap years) days to ignore the difference between
1162 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1163 # difference is only about the year type
1168 }
1170 # Check the year pattern, and is leap year
1171 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1172 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1173 # and non-leap years
1175 # Check if leap year
1178 # Calculate day in the month from number of day in the Hebrew year
1179 # Don't check Adar - if the day is not in Adar, we will stop before;
1180 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1185 # Calculate days in this month
1187 # Adar in a leap year
1189 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1192 # Day in Adar I
1195 # Subtract the days of Adar I
1197 # Try Adar II
1200 # Day in Adar II
1202 }
1203 }
1204 }
1206 # Cheshvan in a complete year (otherwise as the rule below)
1209 # Kislev in an incomplete year (otherwise as the rule below)
1212 # Odd months have 30 days, even have 29
1214 }
1216 # In the current month
1219 # Subtract the days of the current month
1221 # Try in the next month
1223 }
1224 }
1227 }
1229 /**
1230 * This calculates the Hebrew year start, as days since 1 September.
1231 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1232 * Used for Hebrew date.
1233 */
1240 }
1244 }
1254 }
1258 }
1260 /**
1261 * Algorithm to convert Gregorian dates to Thai solar dates,
1262 * Minguo dates or Minguo dates.
1263 *
1264 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1265 * http://en.wikipedia.org/wiki/Minguo_calendar
1266 * http://en.wikipedia.org/wiki/Japanese_era_name
1267 *
1268 * @param $ts String: 14-character timestamp
1269 * @param $cName String: calender name
1270 * @return Array: converted year, month, day
1271 */
1278 # Thai solar dates
1279 # Add 543 years to the Gregorian calendar
1280 # Months and days are identical
1283 # Minguo dates
1284 # Deduct 1911 years from the Gregorian calendar
1285 # Months and days are identical
1288 # Nengō dates up to Meiji period
1289 # Deduct years from the Gregorian calendar
1290 # depending on the nengo periods
1291 # Months and days are identical
1292 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1293 # Meiji period
1298 }
1306 )
1307 {
1308 # Taishō period
1313 }
1319 )
1320 {
1321 # Shōwa period
1326 }
1329 # Heisei period
1334 }
1336 }
1339 }
1342 }
1344 /**
1345 * Roman number formatting up to 3000
1346 */
1353 );
1358 }
1364 }
1366 }
1368 }
1370 /**
1371 * Hebrew Gematria number formatting up to 9999
1372 */
1379 );
1384 }
1396 }
1397 }
1398 }
1400 }
1406 }
1425 }
1427 }
1429 /**
1430 * This is meant to be used by time(), date(), and timeanddate() to get
1431 * the date preference they're supposed to use, it should be used in
1432 * all children.
1433 *
1434 *<code>
1435 * function timeanddate([...], $format = true) {
1436 * $datePreference = $this->dateFormat($format);
1437 * [...]
1438 * }
1439 *</code>
1440 *
1441 * @param $usePrefs Mixed: if true, the user's preference is used
1442 * if false, the site/language default is used
1443 * if int/string, assumed to be a format.
1444 * @return string
1445 */
1454 }
1457 }
1459 // return int
1462 }
1465 }
1467 /**
1468 * Get a format string for a given type and preference
1469 * @param $type May be date, time or both
1470 * @param $pref The format name as it appears in Messages*.php
1471 */
1482 }
1483 }
1485 }
1487 }
1489 /**
1490 * @param $ts Mixed: the time format which needs to be turned into a
1491 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1492 * @param $adj Bool: whether to adjust the time output according to the
1493 * user configured offset ($timecorrection)
1494 * @param $format Mixed: true to use user's date format preference
1495 * @param $timecorrection String: the time offset as returned by
1496 * validateTimeZone() in Special:Preferences
1497 * @return string
1498 */
1503 }
1506 }
1508 /**
1509 * @param $ts Mixed: the time format which needs to be turned into a
1510 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1511 * @param $adj Bool: whether to adjust the time output according to the
1512 * user configured offset ($timecorrection)
1513 * @param $format Mixed: true to use user's date format preference
1514 * @param $timecorrection String: the time offset as returned by
1515 * validateTimeZone() in Special:Preferences
1516 * @return string
1517 */
1522 }
1525 }
1527 /**
1528 * @param $ts Mixed: the time format which needs to be turned into a
1529 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1530 * @param $adj Bool: whether to adjust the time output according to the
1531 * user configured offset ($timecorrection)
1532 * @param $format Mixed: what format to return, if it's false output the
1533 * default one (default true)
1534 * @param $timecorrection String: the time offset as returned by
1535 * validateTimeZone() in Special:Preferences
1536 * @return string
1537 */
1542 }
1545 }
1549 }
1553 }
1556 # This is a wrapper for iconv in all languages except esperanto,
1557 # which does some nasty x-conversions beforehand
1559 # Even with //IGNORE iconv can whine about illegal characters in
1560 # *input* string. We just ignore those too.
1561 # REF: http://bugs.php.net/bug.php?id=37166
1562 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1567 }
1569 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1572 }
1576 }
1581 }
1586 }
1590 }
1595 }
1597 /**
1598 * Make a string's first character uppercase
1599 */
1607 // fall back to more complex logic in case of multibyte strings
1609 }
1610 }
1612 /**
1613 * Convert a string to uppercase
1614 */
1622 }
1625 }
1632 $str
1633 );
1636 }
1637 }
1638 }
1651 }
1652 }
1661 }
1664 }
1671 $str
1672 );
1675 }
1676 }
1677 }
1681 }
1687 // regexp to find first letter in each word (i.e. after each space)
1688 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1690 // function to use to capitalize a single char
1695 $str
1696 );
1701 $str
1702 );
1703 }
1706 }
1707 }
1709 # capitalize words at word breaks
1714 // since \b doesn't work for UTF-8, we explicitely define word break chars
1717 // find first letter after word break
1718 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1724 $str
1725 );
1730 $str
1731 );
1732 }
1737 $str
1738 );
1739 }
1740 }
1742 /**
1743 * Return a case-folded representation of $s
1744 *
1745 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1746 * and $s2 are the same except for the case of their characters. It is not
1747 * necessary for the value returned to make sense when displayed.
1748 *
1749 * Do *not* perform any other normalisation in this function. If a caller
1750 * uses this function when it should be using a more general normalisation
1751 * function, then fix the caller.
1752 */
1755 }
1760 }
1761 # Check for non-UTF-8 URLs
1765 }
1771 }
1774 }
1778 }
1780 /**
1781 * Most writing systems use whitespace to break up words.
1782 * Some languages such as Chinese don't conventionally do this,
1783 * which requires special handling when breaking up words for
1784 * searching etc.
1785 */
1788 }
1790 /**
1791 * Some languages such as Chinese require word segmentation,
1792 * Specify such segmentation when overridden in derived class.
1793 *
1794 * @param $string String
1795 * @return String
1796 */
1799 }
1801 /**
1802 * Some languages have special punctuation need to be normalized.
1803 * Make such changes here.
1804 *
1805 * @param $string String
1806 * @return String
1807 */
1810 }
1812 /**
1813 * convert double-width roman characters to single-width.
1814 * range: ff00-ff5f ~= 0020-007f
1815 */
1825 }
1829 }
1835 }
1838 # some languages, e.g. Chinese, need to do a conversion
1839 # in order for search results to be displayed correctly
1841 }
1843 /**
1844 * Get the first character of a string.
1845 *
1846 * @param $s string
1847 * @return string
1848 */
1855 $matches
1856 );
1861 }
1863 // Break down Hangul syllables to grab the first jamo
1895 }
1898 }
1899 }
1902 # Some languages may have an alternate char encoding option
1903 # (Esperanto X-coding, Japanese furigana conversion, etc)
1904 # If this language is used as the primary content language,
1905 # an override to the defaults can be set here on startup.
1906 }
1909 # For some languages we'll want to explicitly specify
1910 # which characters make it into the edit box raw
1911 # or are converted in some way or another.
1912 # Note that if wgOutputEncoding is different from
1913 # wgInputEncoding, this text will be further converted
1914 # to wgOutputEncoding.
1920 }
1921 }
1924 # Take the previous into account.
1930 }
1935 }
1936 }
1938 /**
1939 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
1940 * also cleans up certain backwards-compatible sequences, converting them
1941 * to the modern Unicode equivalent.
1942 *
1943 * This is language-specific for performance reasons only.
1944 */
1951 }
1954 }
1956 /**
1957 * Transform a string using serialized data stored in the given file (which
1958 * must be in the serialized subdirectory of $IP). The file contains pairs
1959 * mapping source characters to destination characters.
1960 *
1961 * The data is cached in process memory. This will go faster if you have the
1962 * FastStringSearch extension.
1963 */
1969 }
1971 }
1973 }
1975 /**
1976 * For right-to-left language support
1977 *
1978 * @return bool
1979 */
1982 }
1984 /**
1985 * Return the correct HTML 'dir' attribute value for this language.
1986 * @return String
1987 */
1990 }
1992 /**
1993 * Return 'left' or 'right' as appropriate alignment for line-start
1994 * for this language's text direction.
1995 *
1996 * Should be equivalent to CSS3 'start' text-align value....
1997 *
1998 * @return String
1999 */
2002 }
2004 /**
2005 * Return 'right' or 'left' as appropriate alignment for line-end
2006 * for this language's text direction.
2007 *
2008 * Should be equivalent to CSS3 'end' text-align value....
2009 *
2010 * @return String
2011 */
2014 }
2016 /**
2017 * A hidden direction mark (LRM or RLM), depending on the language direction
2018 *
2019 * @return string
2020 */
2023 }
2027 }
2029 /**
2030 * An arrow, depending on the language direction
2031 *
2032 * @return string
2033 */
2036 }
2038 /**
2039 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2040 *
2041 * @return bool
2042 */
2045 }
2049 }
2051 # Fill a MagicWord object with data from here
2058 }
2067 }
2068 }
2075 }
2076 }
2078 /**
2079 * Add magic words to the extension array
2080 */
2087 }
2090 }
2095 }
2096 }
2097 }
2099 /**
2100 * Get special page names, as an associative array
2101 * case folded alias => real name
2102 */
2104 // Cache aliases because it may be slow to load them
2106 // Initialise array
2111 }
2114 }
2116 /**
2117 * Italic is unsuitable for some languages
2118 *
2119 * @param $text String: the text to be emphasized.
2120 * @return string
2121 */
2124 }
2126 /**
2127 * Normally we output all numbers in plain en_US style, that is
2128 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2129 * point twohundredthirtyfive. However this is not sutable for all
2130 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2131 * Icelandic just want to use commas instead of dots, and dots instead
2132 * of commas like "293.291,235".
2133 *
2134 * An example of this function being called:
2135 * <code>
2136 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2137 * </code>
2138 *
2139 * See LanguageGu.php for the Gujarati implementation and
2140 * $separatorTransformTable on MessageIs.php for
2141 * the , => . and . => , implementation.
2142 *
2143 * @todo check if it's viable to use localeconv() for the decimal
2144 * separator thing.
2145 * @param $number Mixed: the string to be formatted, should be an integer
2146 * or a floating point number.
2147 * @param $nocommafy Bool: set to true for special numbers like dates
2148 * @return string
2149 */
2157 }
2158 }
2164 }
2165 }
2168 }
2174 }
2179 }
2183 }
2185 /**
2186 * Adds commas to a given number
2187 *
2188 * @param $_ mixed
2189 * @return string
2190 */
2193 }
2197 }
2201 }
2203 /**
2204 * Take a list of strings and build a locale-friendly comma-separated
2205 * list, using the local comma-separator message.
2206 * The last two strings are chained with an "and".
2207 *
2208 * @param $l Array
2209 * @return string
2210 */
2215 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2221 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2224 }
2225 }
2227 }
2228 }
2230 /**
2231 * Take a list of strings and build a locale-friendly comma-separated
2232 * list, using the local comma-separator message.
2233 * @param $list array of strings to put in a comma list
2234 * @return string
2235 */
2242 )
2243 );
2244 }
2246 /**
2247 * Take a list of strings and build a locale-friendly semicolon-separated
2248 * list, using the local semicolon-separator message.
2249 * @param $list array of strings to put in a semicolon list
2250 * @return string
2251 */
2258 )
2259 );
2260 }
2262 /**
2263 * Same as commaList, but separate it with the pipe instead.
2264 * @param $list array of strings to put in a pipe list
2265 * @return string
2266 */
2273 )
2274 );
2275 }
2277 /**
2278 * Truncate a string to a specified length in bytes, appending an optional
2279 * string (e.g. for ellipses)
2280 *
2281 * The database offers limited byte lengths for some columns in the database;
2282 * multi-byte character sets mean we need to ensure that only whole characters
2283 * are included, otherwise broken characters can be passed to the user
2284 *
2285 * If $length is negative, the string will be truncated from the beginning
2286 *
2287 * @param $string String to truncate
2288 * @param $length Int: maximum length (excluding ellipses)
2289 * @param $ellipsis String to append to the truncated text
2290 * @return string
2291 */
2293 # Use the localized ellipsis character
2296 }
2297 # Check if there is no need to truncate
2302 }
2312 }
2313 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181)
2318 }
2319 }
2321 /**
2322 * Remove bytes that represent an incomplete Unicode character
2323 * at the end of string (e.g. bytes of the char are missing)
2324 *
2325 * @param $string String
2326 * @return string
2327 */
2332 # We got the first byte only of a multibyte char; remove it.
2337 {
2338 # We chopped in the middle of a character; remove it
2340 }
2342 }
2344 /**
2345 * Remove bytes that represent an incomplete Unicode character
2346 * at the start of string (e.g. bytes of the char are missing)
2347 *
2348 * @param $string String
2349 * @return string
2350 */
2354 # We chopped in the middle of a character; remove the whole thing
2356 }
2358 }
2360 /*
2361 * Truncate a string of valid HTML to a specified length in bytes,
2362 * appending an optional string (e.g. for ellipses), and return valid HTML
2363 *
2364 * This is only intended for styled/linked text, such as HTML with
2365 * tags like <span> and <a>, were the tags are self-contained (valid HTML)
2366 *
2367 * Note: tries to fix broken HTML with MWTidy
2368 *
2369 * @param string $text HTML string to truncate
2370 * @param int $length (zero/positive) Maximum length (excluding ellipses)
2371 * @param string $ellipsis String to append to the truncated text
2372 * @returns string
2373 */
2375 # Use the localized ellipsis character
2378 }
2379 # Check if there is no need to truncate
2384 }
2412 }
2418 // Name found (e.g. "<a href=..."), add on tag attributes...
2420 }
2426 }
2432 // Add on the other display text after this...
2437 }
2438 }
2439 }
2440 # Consider truncation once the display length has reached the maximim.
2441 # Double-check that we're not in the middle of a bracket/entity...
2445 # Save where we are; we will truncate here unless
2446 # the ellipsis actually makes the string longer.
2450 # Ellipsis won't make string longer/equal, the truncation point was OK.
2455 }
2456 }
2457 }
2460 }
2461 // Close the last tag if left unclosed by bad HTML
2465 }
2467 }
2469 // truncateHtml() helper function
2470 // like strcspn() but adds the skipped chars to $ret
2476 }
2478 }
2480 /*
2481 * truncateHtml() helper function
2482 * (a) push or pop $tag from $openTags as needed
2483 * (b) clear $tag value
2484 * @param String &$tag Current HTML tag name we are looking at
2485 * @param int $tagType (0-open tag, 1-close tag)
2486 * @param char $lastCh Character before the '>' that ended this tag
2487 * @param array &$openTags Open tag stack (not accounting for $tag)
2488 */
2497 }
2498 }
2500 }
2501 }
2503 /**
2504 * Grammatical transformations, needed for inflected languages
2505 * Invoked by putting {{grammar:case|word}} in a message
2506 *
2507 * @param $word string
2508 * @param $case string
2509 * @return string
2510 */
2515 }
2517 }
2519 /**
2520 * Provides an alternative text depending on specified gender.
2521 * Usage {{gender:username|masculine|feminine|neutral}}.
2522 * username is optional, in which case the gender of current user is used,
2523 * but only in (some) interface messages; otherwise default gender is used.
2524 * If second or third parameter are not specified, masculine is used.
2525 * These details may be overriden per language.
2526 */
2530 }
2534 }
2537 }
2539 }
2541 /**
2542 * Plural form transformations, needed for some languages.
2543 * For example, there are 3 form of plural in Russian and Polish,
2544 * depending on "count mod 10". See [[w:Plural]]
2545 * For English it is pretty simple.
2546 *
2547 * Invoked by putting {{plural:count|wordform1|wordform2}}
2548 * or {{plural:count|wordform1|wordform2|wordform3}}
2549 *
2550 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2551 *
2552 * @param $count Integer: non-localized number
2553 * @param $forms Array: different plural forms
2554 * @return string Correct form of plural for $count in this language
2555 */
2559 }
2563 }
2565 /**
2566 * Checks that convertPlural was given an array and pads it to requested
2567 * amound of forms by copying the last one.
2568 *
2569 * @param $count Integer: How many forms should there be at least
2570 * @param $forms Array of forms given to convertPlural
2571 * @return array Padded array of forms or an exception if not an array
2572 */
2576 }
2578 }
2580 /**
2581 * For translating of expiry times
2582 * @param $str String: the validated block time in English
2583 * @return Somehow translated block time
2584 * @see LanguageFi.php for example implementation
2585 */
2591 }
2596 }
2600 }
2601 }
2604 }
2606 /**
2607 * languages like Chinese need to be segmented in order for the diff
2608 * to be of any use
2609 *
2610 * @param $text String
2611 * @return String
2612 */
2615 }
2617 /**
2618 * and unsegment to show the result
2619 *
2620 * @param $text String
2621 * @return String
2622 */
2625 }
2627 # convert text to all supported variants
2630 }
2632 # convert text to different variants of a language.
2635 }
2637 # Convert a Title object to a string in the preferred variant
2640 }
2642 # Check if this is a language with variants
2645 }
2647 # Put custom tags (e.g. -{ }-) around math to prevent conversion
2650 }
2652 /**
2653 * Perform output conversion on a string, and encode for safe HTML output.
2654 * @param $text String text to be converted
2655 * @param $isTitle Bool whether this conversion is for the article title
2656 * @return string
2657 * @todo this should get integrated somewhere sane
2658 */
2661 }
2665 }
2667 /**
2668 * Get the list of variants supported by this langauge
2669 * see sample implementation in LanguageZh.php
2670 *
2671 * @return array an array of language codes
2672 */
2675 }
2679 }
2683 }
2687 }
2689 /**
2690 * If a language supports multiple variants, it is
2691 * possible that non-existing link in one variant
2692 * actually exists in another variant. this function
2693 * tries to find it. See e.g. LanguageZh.php
2694 *
2695 * @param $link String: the name of the link
2696 * @param $nt Mixed: the title object of the link
2697 * @param $ignoreOtherCond Boolean: to disable other conditions when
2698 * we need to transclude a template or update a category's link
2699 * @return null the input parameters may be modified upon return
2700 */
2703 }
2705 /**
2706 * If a language supports multiple variants, converts text
2707 * into an array of all possible variants of the text:
2708 * 'variant' => text in that variant
2709 *
2710 * @deprecated Use autoConvertToAllVariants()
2711 */
2714 }
2716 /**
2717 * returns language specific options used by User::getPageRenderHash()
2718 * for example, the preferred language variant
2719 *
2720 * @return string
2721 */
2724 }
2726 /**
2727 * For languages that support multiple variants, the title of an
2728 * article may be displayed differently in different variants. this
2729 * function returns the apporiate title defined in the body of the article.
2730 *
2731 * @return string
2732 */
2735 }
2737 /**
2738 * Enclose a string with the "no conversion" tag. This is used by
2739 * various functions in the Parser
2740 *
2741 * @param $text String: text to be tagged for no conversion
2742 * @param $noParse
2743 * @return string the tagged text
2744 */
2747 }
2749 /**
2750 * A regular expression to match legal word-trailing characters
2751 * which should be merged onto a link of the form [[foo]]bar.
2752 *
2753 * @return string
2754 */
2757 }
2761 }
2763 /**
2764 * Get the RFC 3066 code for this language object
2765 */
2768 }
2770 /**
2771 * Get langcode for message
2772 * Some language, like Chinese (zh, without any suffix), has multiple
2773 * interface languages, we could choose a better one for user.
2774 * Inherit class can override this function if necessary.
2775 *
2776 * @return string
2777 */
2780 }
2784 }
2786 /**
2787 * Get the name of a file for a certain language code
2788 * @param $prefix string Prepend this to the filename
2789 * @param $code string Language code
2790 * @param $suffix string Append this to the filename
2791 * @return string $prefix . $mangledCode . $suffix
2792 */
2795 }
2797 /**
2798 * Get the language code from a file name. Inverse of getFileName()
2799 * @param $filename string $prefix . $languageCode . $suffix
2800 * @param $prefix string Prefix before the language code
2801 * @param $suffix string Suffix after the language code
2802 * @return Language code, or false if $prefix or $suffix isn't found
2803 */
2810 }
2812 }
2817 }
2822 }
2824 /**
2825 * Get the fallback for a given language
2826 */
2829 // Shortcut
2833 }
2834 }
2836 /**
2837 * Get all messages for a given language
2838 * WARNING: this may take a long time
2839 */
2842 }
2844 /**
2845 * Get a message for a given language
2846 */
2849 }
2854 }
2859 # Allow grammar transformations
2860 # Allowing full message-style parsing would make simple requests
2861 # such as action=raw much more expensive than they need to be.
2862 # This will hopefully cover most cases.
2866 }
2870 }
2876 }
2883 }
2887 }
2891 return $this->formatNum( sprintf( "%.1f", round( $seconds * 10 ) / 10 ) ) . $this->getMessageFromDB( 'seconds-abbrev' );
2900 }
2910 }
2914 }
2918 }
2919 }
2925 }
2932 }
2934 }
2936 /**
2937 * Format a size in bytes for output, using an appropriate
2938 * unit (B, KB, MB or GB) according to the magnitude in question
2939 *
2940 * @param $size Size to format
2941 * @return string Plain text (not HTML)
2942 */
2944 // For small sizes no decimal places necessary
2950 // For MB and bigger two decimal places are smarter
2957 }
2960 }
2963 }
2967 }
2969 /**
2970 * Get the conversion rule title, if any.
2971 */
2974 }
2976 /**
2977 * Given a string, convert it to a (hopefully short) key that can be used
2978 * for efficient sorting. A binary sort according to the sortkeys
2979 * corresponds to a logical sort of the corresponding strings. Current
2980 * code expects that a null character should sort before all others, but
2981 * has no other particular expectations (and that one can be changed if
2982 * necessary).
2983 *
2984 * @param string $string UTF-8 string
2985 * @return string Binary sortkey
2986 */
2988 # Fake function for now
2990 }
2992 /**
2993 * Given a string, return the logical "first letter" to be used for
2994 * grouping on category pages and so on. This has to be coordinated
2995 * carefully with convertToSortkey(), or else the sorted list might jump
2996 * back and forth between the same "initial letters" or other pathological
2997 * behavior. For instance, if you just return the first character, but "a"
2998 * sorts the same as "A" based on convertToSortkey(), then you might get a
2999 * list like
3000 *
3001 * == A ==
3002 * * [[Aardvark]]
3003 *
3004 * == a ==
3005 * * [[antelope]]
3006 *
3007 * == A ==
3008 * * [[Ape]]
3009 *
3010 * etc., assuming for the sake of argument that $wgCapitalLinks is false.
3011 *
3012 * @param string $string UTF-8 string
3013 * @return string UTF-8 string corresponding to the first letter of input
3014 */
3018 }
3020 }
3021 }