| blob | 89e5230fa0ffb7798fb9b45a9240fb3c2d66e8c5 |
1 <?php
2 /**
3 * @defgroup Language Language
4 *
5 * @file
6 * @ingroup Language
7 */
12 }
14 # Read language names
20 /**
21 * These are always UTF-8, they exist only for backwards compatibility
22 */
28 }
30 /**
31 * a fake language converter
32 *
33 * @ingroup Language
34 */
51 }
53 /**
54 * Internationalisation code
55 * @ingroup Language
56 */
65 /**
66 * ReplacementArray object caches
67 */
76 );
80 );
85 'december'
86 );
90 'december-gen'
91 );
95 );
102 );
110 );
118 );
125 );
127 /**
128 * Get a cached language object for a given language code
129 */
133 // Don't keep a billion objects around, that's stupid.
135 }
137 }
139 }
141 /**
142 * Create a language object for a given language code
143 */
151 // Preload base classes to work around APC/PHP5 bug
154 }
157 }
158 }
162 }
172 }
174 }
176 /**
177 * Get the LocalisationCache instance
178 */
184 }
186 }
190 // Set the code to the name of the descendant
195 }
197 }
199 /**
200 * Reduce memory usage
201 */
205 }
206 }
208 /**
209 * Hook which will be called if this is the content language.
210 * Descendants can use this to register hook functions or modify globals
211 */
214 /**
215 * @deprecated Use User::getDefaultOptions()
216 * @return array
217 */
221 }
228 }
229 }
231 /**
232 * Exports $wgBookstoreListEn
233 * @return array
234 */
237 }
239 /**
240 * @return array
241 */
249 }
258 }
260 # The above mixing may leave namespaces out of canonical order.
261 # Re-order by namespace ID number...
263 }
265 }
267 /**
268 * A convenience function that returns the same thing as
269 * getNamespaces() except with the array values changed to ' '
270 * where it found '_', useful for producing output to be displayed
271 * e.g. in <select> forms.
272 *
273 * @return array
274 */
279 }
281 }
283 /**
284 * Get a namespace value by key
285 * <code>
286 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
287 * echo $mw_ns; // prints 'MediaWiki'
288 * </code>
289 *
290 * @param $index Int: the array key of the namespace to return
291 * @return mixed, string if the namespace value exists, otherwise false
292 */
296 }
298 /**
299 * A convenience function that returns the same thing as
300 * getNsText() except with '_' changed to ' ', useful for
301 * producing output.
302 *
303 * @return array
304 */
308 }
310 /**
311 * Get a namespace key by value, case insensitive.
312 * Only matches namespace names for the current language, not the
313 * canonical ones defined in Namespace.php.
314 *
315 * @param $text String
316 * @return mixed An integer if $text is a valid value otherwise false
317 */
322 }
335 }
336 }
337 }
339 }
341 }
346 # Put namespace names and aliases into a hashtable.
347 # If this is too slow, then we should arrange it so that it is done
348 # before caching. The catch is that at pre-cache time, the above
349 # class-specific fixup hasn't been done.
353 }
356 }
360 }
361 }
362 }
364 }
367 /**
368 * Get a namespace key by value, case insensitive. Canonical namespace
369 * names override custom ones defined for the current language.
370 *
371 * @param $text String
372 * @return mixed An integer if $text is a valid value otherwise false
373 */
378 }
381 }
383 /**
384 * short names for language variants used for language conversion links.
385 *
386 * @param $code String
387 * @return string
388 */
391 }
397 }
399 }
408 );
409 }
413 }
417 }
421 }
430 }
431 }
435 }
439 }
443 }
447 }
451 }
453 /**
454 * Get language names, indexed by code.
455 * If $customisedOnly is true, only returns codes with a messages file
456 */
462 }
471 }
472 }
475 }
477 /**
478 * Get a message from the MediaWiki namespace.
479 *
480 * @param $msg String: message name
481 * @return string
482 */
485 }
491 }
493 }
497 }
501 }
505 }
509 }
513 }
517 }
521 }
525 }
529 }
531 /**
532 * Used by date() and time() to adjust the time output.
533 *
534 * @param $ts Int the time in date('YmdHis') format
535 * @param $tz Mixed: adjust the time by this amount (default false, mean we
536 * get user timecorrection setting)
537 * @return int
538 */
544 }
554 }
555 # Unrecognized timezone, default to 'Offset' with the stored offset.
557 }
561 # Global offset in minutes.
564 }
575 }
578 }
579 }
581 # No difference ? Return time unchanged
584 }
587 # Generate an adjusted date; take advantage of the fact that mktime
588 # will normalize out-of-range values so we don't have to split $minDiff
589 # into hours and minutes.
602 }
604 /**
605 * This is a workalike of PHP's date() function, but with better
606 * internationalisation, a reduced set of format characters, and a better
607 * escaping format.
608 *
609 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
610 * PHP manual for definitions. "o" format character is supported since
611 * PHP 5.1.0, previous versions return literal o.
612 * There are a number of extensions, which start with "x":
613 *
614 * xn Do not translate digits of the next numeric format character
615 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
616 * xr Use roman numerals for the next numeric format character
617 * xh Use hebrew numerals for the next numeric format character
618 * xx Literal x
619 * xg Genitive month name
620 *
621 * xij j (day number) in Iranian calendar
622 * xiF F (month name) in Iranian calendar
623 * xin n (month number) in Iranian calendar
624 * xiY Y (full year) in Iranian calendar
625 *
626 * xjj j (day number) in Hebrew calendar
627 * xjF F (month name) in Hebrew calendar
628 * xjt t (days in month) in Hebrew calendar
629 * xjx xg (genitive month name) in Hebrew calendar
630 * xjn n (month number) in Hebrew calendar
631 * xjY Y (full year) in Hebrew calendar
632 *
633 * xmj j (day number) in Hijri calendar
634 * xmF F (month name) in Hijri calendar
635 * xmn n (month number) in Hijri calendar
636 * xmY Y (full year) in Hijri calendar
637 *
638 * xkY Y (full year) in Thai solar calendar. Months and days are
639 * identical to the Gregorian calendar
640 * xoY Y (full year) in Minguo calendar or Juche year.
641 * Months and days are identical to the
642 * Gregorian calendar
643 * xtY Y (full year) in Japanese nengo. Months and days are
644 * identical to the Gregorian calendar
645 *
646 * Characters enclosed in double quotes will be considered literal (with
647 * the quotes themselves removed). Unmatched quotes will be considered
648 * literal quotes. Example:
649 *
650 * "The month is" F => The month is January
651 * i's" => 20'11"
652 *
653 * Backslash escaping is also supported.
654 *
655 * Input timestamp is assumed to be pre-normalized to the desired local
656 * time zone, if any.
657 *
658 * @param $format String
659 * @param $ts String: 14-character timestamp
660 * YYYYMMDDHHMMSS
661 * 01234567890123
662 * @todo emulation of "o" format character for PHP pre 5.1.0
663 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
664 */
683 }
685 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
687 }
725 }
731 }
737 }
743 }
749 }
756 }
762 }
768 }
777 }
783 }
789 }
804 }
810 }
816 }
822 }
828 }
834 }
837 # 'o' is supported since PHP 5.1.0
838 # return literal if not supported
839 # TODO: emulation for pre 5.1.0 versions
843 }
848 }
856 }
862 }
868 }
874 }
880 }
886 }
921 }
927 }
933 }
937 # Backslash escaping
942 }
945 # Quoted literal
949 # No terminating quote, assume literal "
954 }
956 # Quote at end of string, assume literal "
958 }
962 }
975 }
977 }
978 }
980 }
984 /**
985 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
986 * Gregorian dates to Iranian dates. Originally written in C, it
987 * is released under the terms of GNU Lesser General Public
988 * License. Conversion to PHP was performed by Niklas Laxström.
989 *
990 * Link: http://www.farsiweb.info/jalali/jalali.c
991 */
997 # Days passed from the beginning (including leap years)
1004 // Add days of the past months of this year
1007 }
1009 // Leap years
1012 }
1014 // Days passed in current month
1028 }
1032 }
1038 }
1040 /**
1041 * Converting Gregorian dates to Hijri dates.
1042 *
1043 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1044 *
1045 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1046 */
1060 )
1061 {
1069 }
1074 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ((int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1075 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ((int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1081 }
1083 /**
1084 * Converting Gregorian dates to Hebrew dates.
1085 *
1086 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1087 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1088 * to translate the relevant functions into PHP and release them under
1089 * GNU GPL.
1090 *
1091 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1092 * and Adar II is 14. In a non-leap year, Adar is 6.
1093 */
1095 # Parse date
1100 # Calculate Hebrew year
1103 # Month number when September = 1, August = 12
1106 # Next year
1110 }
1112 # Calculate day of year from 1 September
1116 # February
1118 # Check if the year is leap
1121 }
1126 }
1127 }
1129 # Calculate the start of the Hebrew year
1132 # Calculate next year's start
1134 # Day is before the start of the year - it is the previous year
1135 # Next year's start
1137 # Previous year
1140 # Add days since previous year's 1 September
1143 # Leap year
1145 }
1146 # Start of the new (previous) year
1149 # Next year's start
1151 }
1153 # Calculate Hebrew day of year
1156 # Difference between year's days
1158 # Add 12 (or 13 for leap years) days to ignore the difference between
1159 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1160 # difference is only about the year type
1165 }
1167 # Check the year pattern, and is leap year
1168 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1169 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1170 # and non-leap years
1172 # Check if leap year
1175 # Calculate day in the month from number of day in the Hebrew year
1176 # Don't check Adar - if the day is not in Adar, we will stop before;
1177 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1182 # Calculate days in this month
1184 # Adar in a leap year
1186 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1189 # Day in Adar I
1192 # Subtract the days of Adar I
1194 # Try Adar II
1197 # Day in Adar II
1199 }
1200 }
1201 }
1203 # Cheshvan in a complete year (otherwise as the rule below)
1206 # Kislev in an incomplete year (otherwise as the rule below)
1209 # Odd months have 30 days, even have 29
1211 }
1213 # In the current month
1216 # Subtract the days of the current month
1218 # Try in the next month
1220 }
1221 }
1224 }
1226 /**
1227 * This calculates the Hebrew year start, as days since 1 September.
1228 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1229 * Used for Hebrew date.
1230 */
1237 }
1241 }
1251 }
1255 }
1257 /**
1258 * Algorithm to convert Gregorian dates to Thai solar dates,
1259 * Minguo dates or Minguo dates.
1260 *
1261 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1262 * http://en.wikipedia.org/wiki/Minguo_calendar
1263 * http://en.wikipedia.org/wiki/Japanese_era_name
1264 *
1265 * @param $ts String: 14-character timestamp
1266 * @param $cName String: calender name
1267 * @return Array: converted year, month, day
1268 */
1275 # Thai solar dates
1276 # Add 543 years to the Gregorian calendar
1277 # Months and days are identical
1280 # Minguo dates
1281 # Deduct 1911 years from the Gregorian calendar
1282 # Months and days are identical
1285 # Nengō dates up to Meiji period
1286 # Deduct years from the Gregorian calendar
1287 # depending on the nengo periods
1288 # Months and days are identical
1289 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1290 # Meiji period
1295 }
1303 )
1304 {
1305 # Taishō period
1310 }
1316 )
1317 {
1318 # Shōwa period
1323 }
1326 # Heisei period
1331 }
1333 }
1336 }
1339 }
1341 /**
1342 * Roman number formatting up to 3000
1343 */
1350 );
1355 }
1361 }
1363 }
1365 }
1367 /**
1368 * Hebrew Gematria number formatting up to 9999
1369 */
1376 );
1381 }
1393 }
1394 }
1395 }
1397 }
1403 }
1422 }
1424 }
1426 /**
1427 * This is meant to be used by time(), date(), and timeanddate() to get
1428 * the date preference they're supposed to use, it should be used in
1429 * all children.
1430 *
1431 *<code>
1432 * function timeanddate([...], $format = true) {
1433 * $datePreference = $this->dateFormat($format);
1434 * [...]
1435 * }
1436 *</code>
1437 *
1438 * @param $usePrefs Mixed: if true, the user's preference is used
1439 * if false, the site/language default is used
1440 * if int/string, assumed to be a format.
1441 * @return string
1442 */
1451 }
1454 }
1456 // return int
1459 }
1462 }
1464 /**
1465 * Get a format string for a given type and preference
1466 * @param $type May be date, time or both
1467 * @param $pref The format name as it appears in Messages*.php
1468 */
1479 }
1480 }
1482 }
1484 }
1486 /**
1487 * @param $ts Mixed: the time format which needs to be turned into a
1488 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1489 * @param $adj Bool: whether to adjust the time output according to the
1490 * user configured offset ($timecorrection)
1491 * @param $format Mixed: true to use user's date format preference
1492 * @param $timecorrection String: the time offset as returned by
1493 * validateTimeZone() in Special:Preferences
1494 * @return string
1495 */
1499 }
1502 }
1504 /**
1505 * @param $ts Mixed: the time format which needs to be turned into a
1506 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1507 * @param $adj Bool: whether to adjust the time output according to the
1508 * user configured offset ($timecorrection)
1509 * @param $format Mixed: true to use user's date format preference
1510 * @param $timecorrection String: the time offset as returned by
1511 * validateTimeZone() in Special:Preferences
1512 * @return string
1513 */
1517 }
1520 }
1522 /**
1523 * @param $ts Mixed: the time format which needs to be turned into a
1524 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1525 * @param $adj Bool: whether to adjust the time output according to the
1526 * user configured offset ($timecorrection)
1527 * @param $format Mixed: what format to return, if it's false output the
1528 * default one (default true)
1529 * @param $timecorrection String: the time offset as returned by
1530 * validateTimeZone() in Special:Preferences
1531 * @return string
1532 */
1537 }
1540 }
1544 }
1548 }
1551 # This is a wrapper for iconv in all languages except esperanto,
1552 # which does some nasty x-conversions beforehand
1554 # Even with //IGNORE iconv can whine about illegal characters in
1555 # *input* string. We just ignore those too.
1556 # REF: http://bugs.php.net/bug.php?id=37166
1557 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1562 }
1564 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1567 }
1571 }
1576 }
1581 }
1585 }
1590 }
1599 // fall back to more complex logic in case of multibyte strings
1601 }
1602 }
1611 }
1614 }
1622 $str
1623 );
1626 }
1627 }
1628 }
1641 }
1642 }
1651 }
1654 }
1662 $str
1663 );
1666 }
1667 }
1668 }
1672 }
1678 // regexp to find first letter in each word (i.e. after each space)
1679 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1681 // function to use to capitalize a single char
1686 $str
1687 );
1692 $str
1693 );
1694 }
1697 }
1698 }
1700 # capitalize words at word breaks
1705 // since \b doesn't work for UTF-8, we explicitely define word break chars
1708 // find first letter after word break
1709 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1715 $str
1716 );
1721 $str
1722 );
1723 }
1728 $str
1729 );
1730 }
1731 }
1733 /**
1734 * Return a case-folded representation of $s
1735 *
1736 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1737 * and $s2 are the same except for the case of their characters. It is not
1738 * necessary for the value returned to make sense when displayed.
1739 *
1740 * Do *not* perform any other normalisation in this function. If a caller
1741 * uses this function when it should be using a more general normalisation
1742 * function, then fix the caller.
1743 */
1746 }
1751 }
1752 # Check for non-UTF-8 URLs
1756 }
1762 }
1765 }
1769 }
1771 /**
1772 * Most writing systems use whitespace to break up words.
1773 * Some languages such as Chinese don't conventionally do this,
1774 * which requires special handling when breaking up words for
1775 * searching etc.
1776 */
1779 }
1781 /**
1782 * Some languages such as Chinese require word segmentation,
1783 * Specify such segmentation when overridden in derived class.
1784 *
1785 * @param $string String
1786 * @return String
1787 */
1790 }
1792 /**
1793 * Some languages have special punctuation need to be normalized.
1794 * Make such changes here.
1795 *
1796 * @param $string String
1797 * @return String
1798 */
1801 }
1803 /**
1804 * convert double-width roman characters to single-width.
1805 * range: ff00-ff5f ~= 0020-007f
1806 */
1816 }
1820 }
1826 }
1829 # some languages, e.g. Chinese, need to do a conversion
1830 # in order for search results to be displayed correctly
1832 }
1834 /**
1835 * Get the first character of a string.
1836 *
1837 * @param $s string
1838 * @return string
1839 */
1846 $matches
1847 );
1852 }
1854 // Break down Hangul syllables to grab the first jamo
1886 }
1889 }
1890 }
1893 # Some languages may have an alternate char encoding option
1894 # (Esperanto X-coding, Japanese furigana conversion, etc)
1895 # If this language is used as the primary content language,
1896 # an override to the defaults can be set here on startup.
1897 }
1900 # For some languages we'll want to explicitly specify
1901 # which characters make it into the edit box raw
1902 # or are converted in some way or another.
1903 # Note that if wgOutputEncoding is different from
1904 # wgInputEncoding, this text will be further converted
1905 # to wgOutputEncoding.
1911 }
1912 }
1915 # Take the previous into account.
1921 }
1926 }
1927 }
1929 /**
1930 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
1931 * also cleans up certain backwards-compatible sequences, converting them
1932 * to the modern Unicode equivalent.
1933 *
1934 * This is language-specific for performance reasons only.
1935 */
1942 }
1945 }
1947 /**
1948 * Transform a string using serialized data stored in the given file (which
1949 * must be in the serialized subdirectory of $IP). The file contains pairs
1950 * mapping source characters to destination characters.
1951 *
1952 * The data is cached in process memory. This will go faster if you have the
1953 * FastStringSearch extension.
1954 */
1960 }
1962 }
1964 }
1966 /**
1967 * For right-to-left language support
1968 *
1969 * @return bool
1970 */
1973 }
1975 /**
1976 * Return the correct HTML 'dir' attribute value for this language.
1977 * @return String
1978 */
1981 }
1983 /**
1984 * Return 'left' or 'right' as appropriate alignment for line-start
1985 * for this language's text direction.
1986 *
1987 * Should be equivalent to CSS3 'start' text-align value....
1988 *
1989 * @return String
1990 */
1993 }
1995 /**
1996 * Return 'right' or 'left' as appropriate alignment for line-end
1997 * for this language's text direction.
1998 *
1999 * Should be equivalent to CSS3 'end' text-align value....
2000 *
2001 * @return String
2002 */
2005 }
2007 /**
2008 * A hidden direction mark (LRM or RLM), depending on the language direction
2009 *
2010 * @return string
2011 */
2014 }
2018 }
2020 /**
2021 * An arrow, depending on the language direction
2022 *
2023 * @return string
2024 */
2027 }
2029 /**
2030 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2031 *
2032 * @return bool
2033 */
2036 }
2040 }
2042 # Fill a MagicWord object with data from here
2049 }
2058 }
2059 }
2066 }
2067 }
2069 /**
2070 * Add magic words to the extension array
2071 */
2078 }
2081 }
2086 }
2087 }
2088 }
2090 /**
2091 * Get special page names, as an associative array
2092 * case folded alias => real name
2093 */
2095 // Cache aliases because it may be slow to load them
2097 // Initialise array
2102 }
2105 }
2107 /**
2108 * Italic is unsuitable for some languages
2109 *
2110 * @param $text String: the text to be emphasized.
2111 * @return string
2112 */
2115 }
2117 /**
2118 * Normally we output all numbers in plain en_US style, that is
2119 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2120 * point twohundredthirtyfive. However this is not sutable for all
2121 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2122 * Icelandic just want to use commas instead of dots, and dots instead
2123 * of commas like "293.291,235".
2124 *
2125 * An example of this function being called:
2126 * <code>
2127 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2128 * </code>
2129 *
2130 * See LanguageGu.php for the Gujarati implementation and
2131 * $separatorTransformTable on MessageIs.php for
2132 * the , => . and . => , implementation.
2133 *
2134 * @todo check if it's viable to use localeconv() for the decimal
2135 * separator thing.
2136 * @param $number Mixed: the string to be formatted, should be an integer
2137 * or a floating point number.
2138 * @param $nocommafy Bool: set to true for special numbers like dates
2139 * @return string
2140 */
2148 }
2149 }
2155 }
2156 }
2159 }
2165 }
2170 }
2174 }
2176 /**
2177 * Adds commas to a given number
2178 *
2179 * @param $_ mixed
2180 * @return string
2181 */
2184 }
2188 }
2192 }
2194 /**
2195 * Take a list of strings and build a locale-friendly comma-separated
2196 * list, using the local comma-separator message.
2197 * The last two strings are chained with an "and".
2198 *
2199 * @param $l Array
2200 * @return string
2201 */
2206 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2212 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2215 }
2216 }
2218 }
2219 }
2221 /**
2222 * Take a list of strings and build a locale-friendly comma-separated
2223 * list, using the local comma-separator message.
2224 * @param $list array of strings to put in a comma list
2225 * @return string
2226 */
2233 )
2234 );
2235 }
2237 /**
2238 * Take a list of strings and build a locale-friendly semicolon-separated
2239 * list, using the local semicolon-separator message.
2240 * @param $list array of strings to put in a semicolon list
2241 * @return string
2242 */
2249 )
2250 );
2251 }
2253 /**
2254 * Same as commaList, but separate it with the pipe instead.
2255 * @param $list array of strings to put in a pipe list
2256 * @return string
2257 */
2264 )
2265 );
2266 }
2268 /**
2269 * Truncate a string to a specified length in bytes, appending an optional
2270 * string (e.g. for ellipses)
2271 *
2272 * The database offers limited byte lengths for some columns in the database;
2273 * multi-byte character sets mean we need to ensure that only whole characters
2274 * are included, otherwise broken characters can be passed to the user
2275 *
2276 * If $length is negative, the string will be truncated from the beginning
2277 *
2278 * @param $string String to truncate
2279 * @param $length Int: maximum length (excluding ellipses)
2280 * @param $ellipsis String to append to the truncated text
2281 * @return string
2282 */
2284 # Use the localized ellipsis character
2287 }
2288 # Check if there is no need to truncate
2293 }
2303 }
2304 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181)
2309 }
2310 }
2312 /**
2313 * Remove bytes that represent an incomplete Unicode character
2314 * at the end of string (e.g. bytes of the char are missing)
2315 *
2316 * @param $string String
2317 * @return string
2318 */
2323 # We got the first byte only of a multibyte char; remove it.
2328 {
2329 # We chopped in the middle of a character; remove it
2331 }
2333 }
2335 /**
2336 * Remove bytes that represent an incomplete Unicode character
2337 * at the start of string (e.g. bytes of the char are missing)
2338 *
2339 * @param $string String
2340 * @return string
2341 */
2345 # We chopped in the middle of a character; remove the whole thing
2347 }
2349 }
2351 /*
2352 * Truncate a string of valid HTML to a specified length in bytes,
2353 * appending an optional string (e.g. for ellipses), and return valid HTML
2354 *
2355 * This is only intended for styled/linked text, such as HTML with
2356 * tags like <span> and <a>, were the tags are self-contained (valid HTML)
2357 *
2358 * Note: tries to fix broken HTML with MWTidy
2359 *
2360 * @param string $text String to truncate
2361 * @param int $length (zero/positive) Maximum length (excluding ellipses)
2362 * @param string $ellipsis String to append to the truncated text
2363 * @returns string
2364 */
2366 # Use the localized ellipsis character
2369 }
2370 # Check if there is no need to truncate
2375 }
2403 }
2409 // Name found (e.g. "<a href=..."), add on tag attributes...
2411 }
2417 }
2423 // Add on the other display text after this...
2428 }
2429 }
2430 }
2431 # Consider truncation once the display length has reached the maximim.
2432 # Double-check that we're not in the middle of a bracket/entity...
2436 # Save where we are; we will truncate here unless
2437 # the ellipsis actually makes the string longer.
2441 # Ellipsis won't make string longer/equal, the truncation point was OK.
2446 }
2447 }
2448 }
2451 }
2455 }
2457 }
2459 // truncateHtml() helper function
2460 // like strcspn() but adds the skipped chars to $ret
2466 }
2468 }
2470 // truncateHtml() helper function
2471 // (a) push or pop $tag from $openTags as needed
2472 // (b) clear $tag value
2481 }
2482 }
2484 }
2485 }
2487 /**
2488 * Grammatical transformations, needed for inflected languages
2489 * Invoked by putting {{grammar:case|word}} in a message
2490 *
2491 * @param $word string
2492 * @param $case string
2493 * @return string
2494 */
2499 }
2501 }
2503 /**
2504 * Provides an alternative text depending on specified gender.
2505 * Usage {{gender:username|masculine|feminine|neutral}}.
2506 * username is optional, in which case the gender of current user is used,
2507 * but only in (some) interface messages; otherwise default gender is used.
2508 * If second or third parameter are not specified, masculine is used.
2509 * These details may be overriden per language.
2510 */
2514 }
2518 }
2521 }
2523 }
2525 /**
2526 * Plural form transformations, needed for some languages.
2527 * For example, there are 3 form of plural in Russian and Polish,
2528 * depending on "count mod 10". See [[w:Plural]]
2529 * For English it is pretty simple.
2530 *
2531 * Invoked by putting {{plural:count|wordform1|wordform2}}
2532 * or {{plural:count|wordform1|wordform2|wordform3}}
2533 *
2534 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2535 *
2536 * @param $count Integer: non-localized number
2537 * @param $forms Array: different plural forms
2538 * @return string Correct form of plural for $count in this language
2539 */
2543 }
2547 }
2549 /**
2550 * Checks that convertPlural was given an array and pads it to requested
2551 * amound of forms by copying the last one.
2552 *
2553 * @param $count Integer: How many forms should there be at least
2554 * @param $forms Array of forms given to convertPlural
2555 * @return array Padded array of forms or an exception if not an array
2556 */
2560 }
2562 }
2564 /**
2565 * For translating of expiry times
2566 * @param $str String: the validated block time in English
2567 * @return Somehow translated block time
2568 * @see LanguageFi.php for example implementation
2569 */
2575 }
2580 }
2584 }
2585 }
2588 }
2590 /**
2591 * languages like Chinese need to be segmented in order for the diff
2592 * to be of any use
2593 *
2594 * @param $text String
2595 * @return String
2596 */
2599 }
2601 /**
2602 * and unsegment to show the result
2603 *
2604 * @param $text String
2605 * @return String
2606 */
2609 }
2611 # convert text to all supported variants
2614 }
2616 # convert text to different variants of a language.
2619 }
2621 # Convert a Title object to a string in the preferred variant
2624 }
2626 # Check if this is a language with variants
2629 }
2631 # Put custom tags (e.g. -{ }-) around math to prevent conversion
2634 }
2636 /**
2637 * Perform output conversion on a string, and encode for safe HTML output.
2638 * @param $text String text to be converted
2639 * @param $isTitle Bool whether this conversion is for the article title
2640 * @return string
2641 * @todo this should get integrated somewhere sane
2642 */
2645 }
2649 }
2651 /**
2652 * Get the list of variants supported by this langauge
2653 * see sample implementation in LanguageZh.php
2654 *
2655 * @return array an array of language codes
2656 */
2659 }
2663 }
2665 /**
2666 * If a language supports multiple variants, it is
2667 * possible that non-existing link in one variant
2668 * actually exists in another variant. this function
2669 * tries to find it. See e.g. LanguageZh.php
2670 *
2671 * @param $link String: the name of the link
2672 * @param $nt Mixed: the title object of the link
2673 * @param $ignoreOtherCond Boolean: to disable other conditions when
2674 * we need to transclude a template or update a category's link
2675 * @return null the input parameters may be modified upon return
2676 */
2679 }
2681 /**
2682 * If a language supports multiple variants, converts text
2683 * into an array of all possible variants of the text:
2684 * 'variant' => text in that variant
2685 */
2688 }
2690 /**
2691 * returns language specific options used by User::getPageRenderHash()
2692 * for example, the preferred language variant
2693 *
2694 * @return string
2695 */
2698 }
2700 /**
2701 * For languages that support multiple variants, the title of an
2702 * article may be displayed differently in different variants. this
2703 * function returns the apporiate title defined in the body of the article.
2704 *
2705 * @return string
2706 */
2709 }
2711 /**
2712 * Enclose a string with the "no conversion" tag. This is used by
2713 * various functions in the Parser
2714 *
2715 * @param $text String: text to be tagged for no conversion
2716 * @param $noParse
2717 * @return string the tagged text
2718 */
2721 }
2723 /**
2724 * A regular expression to match legal word-trailing characters
2725 * which should be merged onto a link of the form [[foo]]bar.
2726 *
2727 * @return string
2728 */
2731 }
2735 }
2737 /**
2738 * Get the RFC 3066 code for this language object
2739 */
2742 }
2746 }
2748 /**
2749 * Get the name of a file for a certain language code
2750 * @param $prefix string Prepend this to the filename
2751 * @param $code string Language code
2752 * @param $suffix string Append this to the filename
2753 * @return string $prefix . $mangledCode . $suffix
2754 */
2757 }
2759 /**
2760 * Get the language code from a file name. Inverse of getFileName()
2761 * @param $filename string $prefix . $languageCode . $suffix
2762 * @param $prefix string Prefix before the language code
2763 * @param $suffix string Suffix after the language code
2764 * @return Language code, or false if $prefix or $suffix isn't found
2765 */
2772 }
2774 }
2779 }
2784 }
2786 /**
2787 * Get the fallback for a given language
2788 */
2791 // Shortcut
2795 }
2796 }
2798 /**
2799 * Get all messages for a given language
2800 * WARNING: this may take a long time
2801 */
2804 }
2806 /**
2807 * Get a message for a given language
2808 */
2811 }
2816 }
2821 # Allow grammar transformations
2822 # Allowing full message-style parsing would make simple requests
2823 # such as action=raw much more expensive than they need to be.
2824 # This will hopefully cover most cases.
2828 }
2832 }
2838 }
2845 }
2849 }
2853 return $this->formatNum( sprintf( "%.1f", $seconds ) ) . $this->getMessageFromDB( 'seconds-abbrev' );
2862 }
2872 }
2876 }
2880 }
2881 }
2887 }
2894 }
2896 }
2898 /**
2899 * Format a size in bytes for output, using an appropriate
2900 * unit (B, KB, MB or GB) according to the magnitude in question
2901 *
2902 * @param $size Size to format
2903 * @return string Plain text (not HTML)
2904 */
2906 // For small sizes no decimal places necessary
2912 // For MB and bigger two decimal places are smarter
2919 }
2922 }
2925 }
2929 }
2931 /**
2932 * Get the conversion rule title, if any.
2933 */
2936 }
2938 /**
2939 * Given a string, convert it to a (hopefully short) key that can be used
2940 * for efficient sorting. A binary sort according to the sortkeys
2941 * corresponds to a logical sort of the corresponding strings. Current
2942 * code expects that a null character should sort before all others, but
2943 * has no other particular expectations (and that one can be changed if
2944 * necessary).
2945 *
2946 * @param string $string UTF-8 string
2947 * @return string Binary sortkey
2948 */
2950 # Fake function for now
2952 }
2954 /**
2955 * Does it make sense for lists to be split up into sections based on their
2956 * first letter? Logogram-based scripts probably want to return false.
2957 *
2958 * TODO: Use this in CategoryPage.php.
2959 *
2960 * @return boolean
2961 */
2964 }
2966 /**
2967 * Given a string, return the logical "first letter" to be used for
2968 * grouping on category pages and so on. This has to be coordinated
2969 * carefully with convertToSortkey(), or else the sorted list might jump
2970 * back and forth between the same "initial letters" or other pathological
2971 * behavior. For instance, if you just return the first character, but "a"
2972 * sorts the same as "A" based on convertToSortkey(), then you might get a
2973 * list like
2974 *
2975 * == A ==
2976 * * [[Aardvark]]
2977 *
2978 * == a ==
2979 * * [[antelope]]
2980 *
2981 * == A ==
2982 * * [[Ape]]
2983 *
2984 * etc., assuming for the sake of argument that $wgCapitalLinks is false.
2985 * Obviously, this is ignored if usesFirstLettersInLists() is false.
2986 *
2987 * @param string $string UTF-8 string
2988 * @return string UTF-8 string corresponding to the first letter of input
2989 */
2993 }
2995 }
2996 }