| blob | 9631ce2fa74551a75f7addb216ea294469af9f5c |
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 * @param $code String
136 * @return Language
137 */
141 // Don't keep a billion objects around, that's stupid.
143 }
145 }
147 }
149 /**
150 * Create a language object for a given language code
151 * @param $code String
152 * @return Language
153 */
158 // Protect against path traversal below
161 }
167 // Preload base classes to work around APC/PHP5 bug
170 }
173 }
174 }
178 }
188 }
190 }
192 /**
193 * Returns true if a language code string is of a valid form, whether or
194 * not it exists.
195 */
198 }
200 /**
201 * Get the LocalisationCache instance
202 */
208 }
210 }
214 // Set the code to the name of the descendant
219 }
221 }
223 /**
224 * Reduce memory usage
225 */
229 }
230 }
232 /**
233 * Hook which will be called if this is the content language.
234 * Descendants can use this to register hook functions or modify globals
235 */
238 /**
239 * @deprecated Use User::getDefaultOptions()
240 * @return array
241 */
245 }
252 }
253 }
255 /**
256 * Exports $wgBookstoreListEn
257 * @return array
258 */
261 }
263 /**
264 * @return array
265 */
282 }
284 # Sometimes a language will be localised but not actually exist on this wiki.
288 }
289 }
291 # The above mixing may leave namespaces out of canonical order.
292 # Re-order by namespace ID number...
294 }
296 }
298 /**
299 * A convenience function that returns the same thing as
300 * getNamespaces() except with the array values changed to ' '
301 * where it found '_', useful for producing output to be displayed
302 * e.g. in <select> forms.
303 *
304 * @return array
305 */
310 }
312 }
314 /**
315 * Get a namespace value by key
316 * <code>
317 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
318 * echo $mw_ns; // prints 'MediaWiki'
319 * </code>
320 *
321 * @param $index Int: the array key of the namespace to return
322 * @return mixed, string if the namespace value exists, otherwise false
323 */
327 }
329 /**
330 * A convenience function that returns the same thing as
331 * getNsText() except with '_' changed to ' ', useful for
332 * producing output.
333 *
334 * @return array
335 */
339 }
341 /**
342 * Get a namespace key by value, case insensitive.
343 * Only matches namespace names for the current language, not the
344 * canonical ones defined in Namespace.php.
345 *
346 * @param $text String
347 * @return mixed An integer if $text is a valid value otherwise false
348 */
353 }
366 }
367 }
368 }
370 }
372 }
377 # Put namespace names and aliases into a hashtable.
378 # If this is too slow, then we should arrange it so that it is done
379 # before caching. The catch is that at pre-cache time, the above
380 # class-specific fixup hasn't been done.
384 }
387 }
391 }
392 }
393 }
395 }
398 /**
399 * Get a namespace key by value, case insensitive. Canonical namespace
400 * names override custom ones defined for the current language.
401 *
402 * @param $text String
403 * @return mixed An integer if $text is a valid value otherwise false
404 */
409 }
412 }
414 /**
415 * short names for language variants used for language conversion links.
416 *
417 * @param $code String
418 * @return string
419 */
422 }
428 }
430 }
439 );
440 }
444 }
448 }
452 }
461 }
462 }
466 }
470 }
474 }
478 }
482 }
484 /**
485 * Get language names, indexed by code.
486 * If $customisedOnly is true, only returns codes with a messages file
487 */
493 }
502 }
503 }
506 }
508 /**
509 * Get translated language names. This is done on best effort and
510 * by default this is exactly the same as Language::getLanguageNames.
511 * The CLDR extension provides translated names.
512 * @param $code String Language code.
513 * @return Array language code => language name
514 * @since 1.18.0
515 */
522 }
525 }
527 /**
528 * Get a message from the MediaWiki namespace.
529 *
530 * @param $msg String: message name
531 * @return string
532 */
535 }
541 }
543 }
547 }
551 }
555 }
559 }
563 }
567 }
571 }
575 }
579 }
581 /**
582 * Used by date() and time() to adjust the time output.
583 *
584 * @param $ts Int the time in date('YmdHis') format
585 * @param $tz Mixed: adjust the time by this amount (default false, mean we
586 * get user timecorrection setting)
587 * @return int
588 */
594 }
604 }
605 # Unrecognized timezone, default to 'Offset' with the stored offset.
607 }
611 # Global offset in minutes.
614 }
625 }
628 }
629 }
631 # No difference ? Return time unchanged
634 }
637 # Generate an adjusted date; take advantage of the fact that mktime
638 # will normalize out-of-range values so we don't have to split $minDiff
639 # into hours and minutes.
652 }
654 /**
655 * This is a workalike of PHP's date() function, but with better
656 * internationalisation, a reduced set of format characters, and a better
657 * escaping format.
658 *
659 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
660 * PHP manual for definitions. There are a number of extensions, which
661 * start with "x":
662 *
663 * xn Do not translate digits of the next numeric format character
664 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
665 * xr Use roman numerals for the next numeric format character
666 * xh Use hebrew numerals for the next numeric format character
667 * xx Literal x
668 * xg Genitive month name
669 *
670 * xij j (day number) in Iranian calendar
671 * xiF F (month name) in Iranian calendar
672 * xin n (month number) in Iranian calendar
673 * xiY Y (full year) in Iranian calendar
674 *
675 * xjj j (day number) in Hebrew calendar
676 * xjF F (month name) in Hebrew calendar
677 * xjt t (days in month) in Hebrew calendar
678 * xjx xg (genitive month name) in Hebrew calendar
679 * xjn n (month number) in Hebrew calendar
680 * xjY Y (full year) in Hebrew calendar
681 *
682 * xmj j (day number) in Hijri calendar
683 * xmF F (month name) in Hijri calendar
684 * xmn n (month number) in Hijri calendar
685 * xmY Y (full year) in Hijri calendar
686 *
687 * xkY Y (full year) in Thai solar calendar. Months and days are
688 * identical to the Gregorian calendar
689 * xoY Y (full year) in Minguo calendar or Juche year.
690 * Months and days are identical to the
691 * Gregorian calendar
692 * xtY Y (full year) in Japanese nengo. Months and days are
693 * identical to the Gregorian calendar
694 *
695 * Characters enclosed in double quotes will be considered literal (with
696 * the quotes themselves removed). Unmatched quotes will be considered
697 * literal quotes. Example:
698 *
699 * "The month is" F => The month is January
700 * i's" => 20'11"
701 *
702 * Backslash escaping is also supported.
703 *
704 * Input timestamp is assumed to be pre-normalized to the desired local
705 * time zone, if any.
706 *
707 * @param $format String
708 * @param $ts String: 14-character timestamp
709 * YYYYMMDDHHMMSS
710 * 01234567890123
711 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
712 */
731 }
733 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
735 }
773 }
779 }
785 }
791 }
797 }
804 }
810 }
816 }
825 }
831 }
837 }
852 }
858 }
864 }
870 }
876 }
882 }
888 }
897 }
903 }
909 }
915 }
921 }
927 }
962 }
968 }
974 }
978 # Backslash escaping
983 }
986 # Quoted literal
990 # No terminating quote, assume literal "
995 }
997 # Quote at end of string, assume literal "
999 }
1003 }
1016 }
1017 }
1018 }
1020 }
1024 /**
1025 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1026 * Gregorian dates to Iranian dates. Originally written in C, it
1027 * is released under the terms of GNU Lesser General Public
1028 * License. Conversion to PHP was performed by Niklas Laxström.
1029 *
1030 * Link: http://www.farsiweb.info/jalali/jalali.c
1031 */
1037 # Days passed from the beginning (including leap years)
1044 // Add days of the past months of this year
1047 }
1049 // Leap years
1052 }
1054 // Days passed in current month
1068 }
1072 }
1078 }
1080 /**
1081 * Converting Gregorian dates to Hijri dates.
1082 *
1083 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1084 *
1085 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1086 */
1100 )
1101 {
1109 }
1114 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1115 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1121 }
1123 /**
1124 * Converting Gregorian dates to Hebrew dates.
1125 *
1126 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1127 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1128 * to translate the relevant functions into PHP and release them under
1129 * GNU GPL.
1130 *
1131 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1132 * and Adar II is 14. In a non-leap year, Adar is 6.
1133 */
1135 # Parse date
1140 # Calculate Hebrew year
1143 # Month number when September = 1, August = 12
1146 # Next year
1150 }
1152 # Calculate day of year from 1 September
1156 # February
1158 # Check if the year is leap
1161 }
1166 }
1167 }
1169 # Calculate the start of the Hebrew year
1172 # Calculate next year's start
1174 # Day is before the start of the year - it is the previous year
1175 # Next year's start
1177 # Previous year
1180 # Add days since previous year's 1 September
1183 # Leap year
1185 }
1186 # Start of the new (previous) year
1189 # Next year's start
1191 }
1193 # Calculate Hebrew day of year
1196 # Difference between year's days
1198 # Add 12 (or 13 for leap years) days to ignore the difference between
1199 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1200 # difference is only about the year type
1205 }
1207 # Check the year pattern, and is leap year
1208 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1209 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1210 # and non-leap years
1212 # Check if leap year
1215 # Calculate day in the month from number of day in the Hebrew year
1216 # Don't check Adar - if the day is not in Adar, we will stop before;
1217 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1222 # Calculate days in this month
1224 # Adar in a leap year
1226 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1229 # Day in Adar I
1232 # Subtract the days of Adar I
1234 # Try Adar II
1237 # Day in Adar II
1239 }
1240 }
1241 }
1243 # Cheshvan in a complete year (otherwise as the rule below)
1246 # Kislev in an incomplete year (otherwise as the rule below)
1249 # Odd months have 30 days, even have 29
1251 }
1253 # In the current month
1256 # Subtract the days of the current month
1258 # Try in the next month
1260 }
1261 }
1264 }
1266 /**
1267 * This calculates the Hebrew year start, as days since 1 September.
1268 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1269 * Used for Hebrew date.
1270 */
1277 }
1281 }
1291 }
1295 }
1297 /**
1298 * Algorithm to convert Gregorian dates to Thai solar dates,
1299 * Minguo dates or Minguo dates.
1300 *
1301 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1302 * http://en.wikipedia.org/wiki/Minguo_calendar
1303 * http://en.wikipedia.org/wiki/Japanese_era_name
1304 *
1305 * @param $ts String: 14-character timestamp
1306 * @param $cName String: calender name
1307 * @return Array: converted year, month, day
1308 */
1315 # Thai solar dates
1316 # Add 543 years to the Gregorian calendar
1317 # Months and days are identical
1320 # Minguo dates
1321 # Deduct 1911 years from the Gregorian calendar
1322 # Months and days are identical
1325 # Nengō dates up to Meiji period
1326 # Deduct years from the Gregorian calendar
1327 # depending on the nengo periods
1328 # Months and days are identical
1329 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1330 # Meiji period
1335 }
1343 )
1344 {
1345 # Taishō period
1350 }
1356 )
1357 {
1358 # Shōwa period
1363 }
1366 # Heisei period
1371 }
1373 }
1376 }
1379 }
1381 /**
1382 * Roman number formatting up to 3000
1383 */
1390 );
1395 }
1401 }
1403 }
1405 }
1407 /**
1408 * Hebrew Gematria number formatting up to 9999
1409 */
1416 );
1421 }
1433 }
1434 }
1435 }
1437 }
1443 }
1462 }
1464 }
1466 /**
1467 * This is meant to be used by time(), date(), and timeanddate() to get
1468 * the date preference they're supposed to use, it should be used in
1469 * all children.
1470 *
1471 *<code>
1472 * function timeanddate([...], $format = true) {
1473 * $datePreference = $this->dateFormat($format);
1474 * [...]
1475 * }
1476 *</code>
1477 *
1478 * @param $usePrefs Mixed: if true, the user's preference is used
1479 * if false, the site/language default is used
1480 * if int/string, assumed to be a format.
1481 * @return string
1482 */
1491 }
1494 }
1496 // return int
1499 }
1502 }
1504 /**
1505 * Get a format string for a given type and preference
1506 * @param $type May be date, time or both
1507 * @param $pref The format name as it appears in Messages*.php
1508 */
1519 }
1520 }
1522 }
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: true to use user's date format preference
1532 * @param $timecorrection String: the time offset as returned by
1533 * validateTimeZone() in Special:Preferences
1534 * @return string
1535 */
1540 }
1543 }
1545 /**
1546 * @param $ts Mixed: the time format which needs to be turned into a
1547 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1548 * @param $adj Bool: whether to adjust the time output according to the
1549 * user configured offset ($timecorrection)
1550 * @param $format Mixed: true to use user's date format preference
1551 * @param $timecorrection String: the time offset as returned by
1552 * validateTimeZone() in Special:Preferences
1553 * @return string
1554 */
1559 }
1562 }
1564 /**
1565 * @param $ts Mixed: the time format which needs to be turned into a
1566 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1567 * @param $adj Bool: whether to adjust the time output according to the
1568 * user configured offset ($timecorrection)
1569 * @param $format Mixed: what format to return, if it's false output the
1570 * default one (default true)
1571 * @param $timecorrection String: the time offset as returned by
1572 * validateTimeZone() in Special:Preferences
1573 * @return string
1574 */
1579 }
1582 }
1585 // Don't change getPreferredVariant() to getCode() / mCode, because:
1587 // 1. Some language like Chinese has multiple variant languages. Only
1588 // getPreferredVariant() (in LanguageConverter) could return a
1589 // sub-language which would be more suitable for the user.
1590 // 2. To languages without multiple variants, getPreferredVariant()
1591 // (in FakeConverter) functions exactly same as getCode() / mCode,
1592 // it won't break anything.
1594 // The same below.
1596 }
1600 }
1603 # This is a wrapper for iconv in all languages except esperanto,
1604 # which does some nasty x-conversions beforehand
1606 # Even with //IGNORE iconv can whine about illegal characters in
1607 # *input* string. We just ignore those too.
1608 # REF: http://bugs.php.net/bug.php?id=37166
1609 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1614 }
1616 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1619 }
1623 }
1628 }
1633 }
1637 }
1642 }
1644 /**
1645 * Make a string's first character uppercase
1646 */
1654 // fall back to more complex logic in case of multibyte strings
1656 }
1657 }
1659 /**
1660 * Convert a string to uppercase
1661 */
1669 }
1672 }
1679 $str
1680 );
1683 }
1684 }
1685 }
1698 }
1699 }
1708 }
1711 }
1718 $str
1719 );
1722 }
1723 }
1724 }
1728 }
1734 // regexp to find first letter in each word (i.e. after each space)
1735 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1737 // function to use to capitalize a single char
1742 $str
1743 );
1748 $str
1749 );
1750 }
1753 }
1754 }
1756 # capitalize words at word breaks
1761 // since \b doesn't work for UTF-8, we explicitely define word break chars
1764 // find first letter after word break
1765 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1771 $str
1772 );
1777 $str
1778 );
1779 }
1784 $str
1785 );
1786 }
1787 }
1789 /**
1790 * Return a case-folded representation of $s
1791 *
1792 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1793 * and $s2 are the same except for the case of their characters. It is not
1794 * necessary for the value returned to make sense when displayed.
1795 *
1796 * Do *not* perform any other normalisation in this function. If a caller
1797 * uses this function when it should be using a more general normalisation
1798 * function, then fix the caller.
1799 */
1802 }
1807 }
1808 # Check for non-UTF-8 URLs
1812 }
1818 }
1821 }
1825 }
1827 /**
1828 * Most writing systems use whitespace to break up words.
1829 * Some languages such as Chinese don't conventionally do this,
1830 * which requires special handling when breaking up words for
1831 * searching etc.
1832 */
1835 }
1837 /**
1838 * Some languages such as Chinese require word segmentation,
1839 * Specify such segmentation when overridden in derived class.
1840 *
1841 * @param $string String
1842 * @return String
1843 */
1846 }
1848 /**
1849 * Some languages have special punctuation need to be normalized.
1850 * Make such changes here.
1851 *
1852 * @param $string String
1853 * @return String
1854 */
1857 }
1859 /**
1860 * convert double-width roman characters to single-width.
1861 * range: ff00-ff5f ~= 0020-007f
1862 */
1872 }
1876 }
1882 }
1885 # some languages, e.g. Chinese, need to do a conversion
1886 # in order for search results to be displayed correctly
1888 }
1890 /**
1891 * Get the first character of a string.
1892 *
1893 * @param $s string
1894 * @return string
1895 */
1902 $matches
1903 );
1908 }
1910 // Break down Hangul syllables to grab the first jamo
1942 }
1945 }
1946 }
1949 # Some languages may have an alternate char encoding option
1950 # (Esperanto X-coding, Japanese furigana conversion, etc)
1951 # If this language is used as the primary content language,
1952 # an override to the defaults can be set here on startup.
1953 }
1956 # For some languages we'll want to explicitly specify
1957 # which characters make it into the edit box raw
1958 # or are converted in some way or another.
1959 # Note that if wgOutputEncoding is different from
1960 # wgInputEncoding, this text will be further converted
1961 # to wgOutputEncoding.
1967 }
1968 }
1971 # Take the previous into account.
1977 }
1982 }
1983 }
1985 /**
1986 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
1987 * also cleans up certain backwards-compatible sequences, converting them
1988 * to the modern Unicode equivalent.
1989 *
1990 * This is language-specific for performance reasons only.
1991 */
1998 }
2001 }
2003 /**
2004 * Transform a string using serialized data stored in the given file (which
2005 * must be in the serialized subdirectory of $IP). The file contains pairs
2006 * mapping source characters to destination characters.
2007 *
2008 * The data is cached in process memory. This will go faster if you have the
2009 * FastStringSearch extension.
2010 */
2016 }
2018 }
2020 }
2022 /**
2023 * For right-to-left language support
2024 *
2025 * @return bool
2026 */
2029 }
2031 /**
2032 * Return the correct HTML 'dir' attribute value for this language.
2033 * @return String
2034 */
2037 }
2039 /**
2040 * Return 'left' or 'right' as appropriate alignment for line-start
2041 * for this language's text direction.
2042 *
2043 * Should be equivalent to CSS3 'start' text-align value....
2044 *
2045 * @return String
2046 */
2049 }
2051 /**
2052 * Return 'right' or 'left' as appropriate alignment for line-end
2053 * for this language's text direction.
2054 *
2055 * Should be equivalent to CSS3 'end' text-align value....
2056 *
2057 * @return String
2058 */
2061 }
2063 /**
2064 * A hidden direction mark (LRM or RLM), depending on the language direction
2065 *
2066 * @return string
2067 */
2070 }
2074 }
2076 /**
2077 * An arrow, depending on the language direction
2078 *
2079 * @return string
2080 */
2083 }
2085 /**
2086 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2087 *
2088 * @return bool
2089 */
2092 }
2096 }
2098 # Fill a MagicWord object with data from here
2105 }
2114 }
2115 }
2122 }
2123 }
2125 /**
2126 * Add magic words to the extension array
2127 */
2134 }
2137 }
2142 }
2143 }
2144 }
2146 /**
2147 * Get special page names, as an associative array
2148 * case folded alias => real name
2149 */
2151 // Cache aliases because it may be slow to load them
2153 // Initialise array
2158 }
2161 }
2163 /**
2164 * Italic is unsuitable for some languages
2165 *
2166 * @param $text String: the text to be emphasized.
2167 * @return string
2168 */
2171 }
2173 /**
2174 * Normally we output all numbers in plain en_US style, that is
2175 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2176 * point twohundredthirtyfive. However this is not sutable for all
2177 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2178 * Icelandic just want to use commas instead of dots, and dots instead
2179 * of commas like "293.291,235".
2180 *
2181 * An example of this function being called:
2182 * <code>
2183 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2184 * </code>
2185 *
2186 * See LanguageGu.php for the Gujarati implementation and
2187 * $separatorTransformTable on MessageIs.php for
2188 * the , => . and . => , implementation.
2189 *
2190 * @todo check if it's viable to use localeconv() for the decimal
2191 * separator thing.
2192 * @param $number Mixed: the string to be formatted, should be an integer
2193 * or a floating point number.
2194 * @param $nocommafy Bool: set to true for special numbers like dates
2195 * @return string
2196 */
2204 }
2205 }
2211 }
2212 }
2215 }
2221 }
2226 }
2230 }
2232 /**
2233 * Adds commas to a given number
2234 *
2235 * @param $_ mixed
2236 * @return string
2237 */
2240 }
2244 }
2248 }
2250 /**
2251 * Take a list of strings and build a locale-friendly comma-separated
2252 * list, using the local comma-separator message.
2253 * The last two strings are chained with an "and".
2254 *
2255 * @param $l Array
2256 * @return string
2257 */
2262 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2268 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2271 }
2272 }
2274 }
2275 }
2277 /**
2278 * Take a list of strings and build a locale-friendly comma-separated
2279 * list, using the local comma-separator message.
2280 * @param $list array of strings to put in a comma list
2281 * @return string
2282 */
2289 )
2290 );
2291 }
2293 /**
2294 * Take a list of strings and build a locale-friendly semicolon-separated
2295 * list, using the local semicolon-separator message.
2296 * @param $list array of strings to put in a semicolon list
2297 * @return string
2298 */
2305 )
2306 );
2307 }
2309 /**
2310 * Same as commaList, but separate it with the pipe instead.
2311 * @param $list array of strings to put in a pipe list
2312 * @return string
2313 */
2320 )
2321 );
2322 }
2324 /**
2325 * Truncate a string to a specified length in bytes, appending an optional
2326 * string (e.g. for ellipses)
2327 *
2328 * The database offers limited byte lengths for some columns in the database;
2329 * multi-byte character sets mean we need to ensure that only whole characters
2330 * are included, otherwise broken characters can be passed to the user
2331 *
2332 * If $length is negative, the string will be truncated from the beginning
2333 *
2334 * @param $string String to truncate
2335 * @param $length Int: maximum length (excluding ellipses)
2336 * @param $ellipsis String to append to the truncated text
2337 * @return string
2338 */
2340 # Use the localized ellipsis character
2343 }
2344 # Check if there is no need to truncate
2349 }
2359 }
2360 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181)
2365 }
2366 }
2368 /**
2369 * Remove bytes that represent an incomplete Unicode character
2370 * at the end of string (e.g. bytes of the char are missing)
2371 *
2372 * @param $string String
2373 * @return string
2374 */
2379 # We got the first byte only of a multibyte char; remove it.
2384 {
2385 # We chopped in the middle of a character; remove it
2387 }
2389 }
2391 /**
2392 * Remove bytes that represent an incomplete Unicode character
2393 * at the start of string (e.g. bytes of the char are missing)
2394 *
2395 * @param $string String
2396 * @return string
2397 */
2401 # We chopped in the middle of a character; remove the whole thing
2403 }
2405 }
2407 /*
2408 * Truncate a string of valid HTML to a specified length in bytes,
2409 * appending an optional string (e.g. for ellipses), and return valid HTML
2410 *
2411 * This is only intended for styled/linked text, such as HTML with
2412 * tags like <span> and <a>, were the tags are self-contained (valid HTML)
2413 *
2414 * Note: tries to fix broken HTML with MWTidy
2415 *
2416 * @param string $text HTML string to truncate
2417 * @param int $length (zero/positive) Maximum length (excluding ellipses)
2418 * @param string $ellipsis String to append to the truncated text
2419 * @returns string
2420 */
2422 # Use the localized ellipsis character
2425 }
2426 # Check if there is no need to truncate
2431 }
2459 }
2465 // Name found (e.g. "<a href=..."), add on tag attributes...
2467 }
2473 }
2479 // Add on the other display text after this...
2484 }
2485 }
2486 }
2487 # Consider truncation once the display length has reached the maximim.
2488 # Double-check that we're not in the middle of a bracket/entity...
2492 # Save where we are; we will truncate here unless
2493 # the ellipsis actually makes the string longer.
2497 # Ellipsis won't make string longer/equal, the truncation point was OK.
2502 }
2503 }
2504 }
2507 }
2508 // Close the last tag if left unclosed by bad HTML
2512 }
2514 }
2516 // truncateHtml() helper function
2517 // like strcspn() but adds the skipped chars to $ret
2523 }
2525 }
2527 /*
2528 * truncateHtml() helper function
2529 * (a) push or pop $tag from $openTags as needed
2530 * (b) clear $tag value
2531 * @param String &$tag Current HTML tag name we are looking at
2532 * @param int $tagType (0-open tag, 1-close tag)
2533 * @param char $lastCh Character before the '>' that ended this tag
2534 * @param array &$openTags Open tag stack (not accounting for $tag)
2535 */
2544 }
2545 }
2547 }
2548 }
2550 /**
2551 * Grammatical transformations, needed for inflected languages
2552 * Invoked by putting {{grammar:case|word}} in a message
2553 *
2554 * @param $word string
2555 * @param $case string
2556 * @return string
2557 */
2562 }
2564 }
2566 /**
2567 * Provides an alternative text depending on specified gender.
2568 * Usage {{gender:username|masculine|feminine|neutral}}.
2569 * username is optional, in which case the gender of current user is used,
2570 * but only in (some) interface messages; otherwise default gender is used.
2571 * If second or third parameter are not specified, masculine is used.
2572 * These details may be overriden per language.
2573 */
2577 }
2581 }
2584 }
2586 }
2588 /**
2589 * Plural form transformations, needed for some languages.
2590 * For example, there are 3 form of plural in Russian and Polish,
2591 * depending on "count mod 10". See [[w:Plural]]
2592 * For English it is pretty simple.
2593 *
2594 * Invoked by putting {{plural:count|wordform1|wordform2}}
2595 * or {{plural:count|wordform1|wordform2|wordform3}}
2596 *
2597 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2598 *
2599 * @param $count Integer: non-localized number
2600 * @param $forms Array: different plural forms
2601 * @return string Correct form of plural for $count in this language
2602 */
2606 }
2610 }
2612 /**
2613 * Checks that convertPlural was given an array and pads it to requested
2614 * amound of forms by copying the last one.
2615 *
2616 * @param $count Integer: How many forms should there be at least
2617 * @param $forms Array of forms given to convertPlural
2618 * @return array Padded array of forms or an exception if not an array
2619 */
2623 }
2625 }
2627 /**
2628 * For translating of expiry times
2629 * @param $str String: the validated block time in English
2630 * @return Somehow translated block time
2631 * @see LanguageFi.php for example implementation
2632 */
2638 }
2643 }
2647 }
2648 }
2651 }
2653 /**
2654 * languages like Chinese need to be segmented in order for the diff
2655 * to be of any use
2656 *
2657 * @param $text String
2658 * @return String
2659 */
2662 }
2664 /**
2665 * and unsegment to show the result
2666 *
2667 * @param $text String
2668 * @return String
2669 */
2672 }
2674 # convert text to all supported variants
2677 }
2679 # convert text to different variants of a language.
2682 }
2684 # Convert a Title object to a string in the preferred variant
2687 }
2689 # Check if this is a language with variants
2692 }
2694 # Put custom tags (e.g. -{ }-) around math to prevent conversion
2697 }
2699 /**
2700 * Perform output conversion on a string, and encode for safe HTML output.
2701 * @param $text String text to be converted
2702 * @param $isTitle Bool whether this conversion is for the article title
2703 * @return string
2704 * @todo this should get integrated somewhere sane
2705 */
2708 }
2712 }
2714 /**
2715 * Get the list of variants supported by this language
2716 * see sample implementation in LanguageZh.php
2717 *
2718 * @return array an array of language codes
2719 */
2722 }
2726 }
2730 }
2734 }
2736 /**
2737 * If a language supports multiple variants, it is
2738 * possible that non-existing link in one variant
2739 * actually exists in another variant. this function
2740 * tries to find it. See e.g. LanguageZh.php
2741 *
2742 * @param $link String: the name of the link
2743 * @param $nt Mixed: the title object of the link
2744 * @param $ignoreOtherCond Boolean: to disable other conditions when
2745 * we need to transclude a template or update a category's link
2746 * @return null the input parameters may be modified upon return
2747 */
2750 }
2752 /**
2753 * If a language supports multiple variants, converts text
2754 * into an array of all possible variants of the text:
2755 * 'variant' => text in that variant
2756 *
2757 * @deprecated Use autoConvertToAllVariants()
2758 */
2761 }
2763 /**
2764 * returns language specific options used by User::getPageRenderHash()
2765 * for example, the preferred language variant
2766 *
2767 * @return string
2768 */
2771 }
2773 /**
2774 * For languages that support multiple variants, the title of an
2775 * article may be displayed differently in different variants. this
2776 * function returns the apporiate title defined in the body of the article.
2777 *
2778 * @return string
2779 */
2782 }
2784 /**
2785 * Enclose a string with the "no conversion" tag. This is used by
2786 * various functions in the Parser
2787 *
2788 * @param $text String: text to be tagged for no conversion
2789 * @param $noParse
2790 * @return string the tagged text
2791 */
2794 }
2796 /**
2797 * A regular expression to match legal word-trailing characters
2798 * which should be merged onto a link of the form [[foo]]bar.
2799 *
2800 * @return string
2801 */
2804 }
2808 }
2810 /**
2811 * Get the RFC 3066 code for this language object
2812 */
2815 }
2819 }
2821 /**
2822 * Get the name of a file for a certain language code
2823 * @param $prefix string Prepend this to the filename
2824 * @param $code string Language code
2825 * @param $suffix string Append this to the filename
2826 * @return string $prefix . $mangledCode . $suffix
2827 */
2829 // Protect against path traversal
2832 }
2835 }
2837 /**
2838 * Get the language code from a file name. Inverse of getFileName()
2839 * @param $filename string $prefix . $languageCode . $suffix
2840 * @param $prefix string Prefix before the language code
2841 * @param $suffix string Suffix after the language code
2842 * @return Language code, or false if $prefix or $suffix isn't found
2843 */
2850 }
2852 }
2857 }
2862 }
2864 /**
2865 * Get the fallback for a given language
2866 */
2869 // Shortcut
2873 }
2874 }
2876 /**
2877 * Get all messages for a given language
2878 * WARNING: this may take a long time
2879 */
2882 }
2884 /**
2885 * Get a message for a given language
2886 */
2889 }
2894 }
2899 # Allow grammar transformations
2900 # Allowing full message-style parsing would make simple requests
2901 # such as action=raw much more expensive than they need to be.
2902 # This will hopefully cover most cases.
2906 }
2910 }
2916 }
2923 }
2928 }
2932 return $this->formatNum( sprintf( "%.1f", round( $seconds * 10 ) / 10 ) ) . $this->getMessageFromDB( 'seconds-abbrev' );
2941 }
2951 }
2955 }
2959 }
2960 }
2966 }
2973 }
2975 }
2977 /**
2978 * Format a size in bytes for output, using an appropriate
2979 * unit (B, KB, MB or GB) according to the magnitude in question
2980 *
2981 * @param $size Size to format
2982 * @return string Plain text (not HTML)
2983 */
2985 // For small sizes no decimal places necessary
2991 // For MB and bigger two decimal places are smarter
2998 }
3001 }
3004 }
3008 }
3010 /**
3011 * Get the conversion rule title, if any.
3012 */
3015 }
3016 }