| blob | 1acc15012c4f8753fa72f021f7ebc85cb99d1f36 |
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 {
163 }
166 // It's not possible to customise this code with class files, so
167 // just return a Language object. This is to support uselang= hacks.
171 }
177 // Preload base classes to work around APC/PHP5 bug
180 }
183 }
184 }
188 }
198 }
200 }
202 /**
203 * Returns true if a language code string is of a valid form, whether or
204 * not it exists. This includes codes which are used solely for
205 * customisation via the MediaWiki namespace.
206 */
208 return
211 }
213 /**
214 * Returns true if a language code is of a valid form for the purposes of
215 * internal customisation of MediaWiki, via Messages*.php.
216 */
219 }
221 /**
222 * Get the LocalisationCache instance
223 *
224 * @return LocalisationCache
225 */
231 }
233 }
237 // Set the code to the name of the descendant
242 }
244 }
246 /**
247 * Reduce memory usage
248 */
252 }
253 }
255 /**
256 * Hook which will be called if this is the content language.
257 * Descendants can use this to register hook functions or modify globals
258 */
261 /**
262 * @deprecated Use User::getDefaultOptions()
263 * @return array
264 */
268 }
275 }
276 }
278 /**
279 * Exports $wgBookstoreListEn
280 * @return array
281 */
284 }
286 /**
287 * @return array
288 */
305 }
307 # Sometimes a language will be localised but not actually exist on this wiki.
311 }
312 }
314 # The above mixing may leave namespaces out of canonical order.
315 # Re-order by namespace ID number...
317 }
319 }
321 /**
322 * A convenience function that returns the same thing as
323 * getNamespaces() except with the array values changed to ' '
324 * where it found '_', useful for producing output to be displayed
325 * e.g. in <select> forms.
326 *
327 * @return array
328 */
333 }
335 }
337 /**
338 * Get a namespace value by key
339 * <code>
340 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
341 * echo $mw_ns; // prints 'MediaWiki'
342 * </code>
343 *
344 * @param $index Int: the array key of the namespace to return
345 * @return mixed, string if the namespace value exists, otherwise false
346 */
350 }
352 /**
353 * A convenience function that returns the same thing as
354 * getNsText() except with '_' changed to ' ', useful for
355 * producing output.
356 *
357 * @return array
358 */
362 }
364 /**
365 * Returns gender-dependent namespace alias if available.
366 * @param $index Int: namespace index
367 * @param $gender String: gender key (male, female... )
368 * @return String
369 * @since 1.18
370 */
374 }
376 /**
377 * Whether this language makes distinguishes genders for example in
378 * namespaces.
379 * @return bool
380 * @since 1.18
381 */
385 }
387 /**
388 * Get a namespace key by value, case insensitive.
389 * Only matches namespace names for the current language, not the
390 * canonical ones defined in Namespace.php.
391 *
392 * @param $text String
393 * @return mixed An integer if $text is a valid value otherwise false
394 */
399 }
412 }
413 }
414 }
420 }
421 }
424 }
426 }
431 # Put namespace names and aliases into a hashtable.
432 # If this is too slow, then we should arrange it so that it is done
433 # before caching. The catch is that at pre-cache time, the above
434 # class-specific fixup hasn't been done.
438 }
441 }
445 }
446 }
447 }
449 }
452 /**
453 * Get a namespace key by value, case insensitive. Canonical namespace
454 * names override custom ones defined for the current language.
455 *
456 * @param $text String
457 * @return mixed An integer if $text is a valid value otherwise false
458 */
463 }
466 }
468 /**
469 * short names for language variants used for language conversion links.
470 *
471 * @param $code String
472 * @return string
473 */
476 }
482 }
484 }
493 );
494 }
498 }
502 }
506 }
515 }
516 }
520 }
524 }
528 }
532 }
536 }
538 /**
539 * Get language names, indexed by code.
540 * If $customisedOnly is true, only returns codes with a messages file
541 */
547 }
556 }
557 }
560 }
562 /**
563 * Get translated language names. This is done on best effort and
564 * by default this is exactly the same as Language::getLanguageNames.
565 * The CLDR extension provides translated names.
566 * @param $code String Language code.
567 * @return Array language code => language name
568 * @since 1.18.0
569 */
576 }
579 }
581 /**
582 * Get a message from the MediaWiki namespace.
583 *
584 * @param $msg String: message name
585 * @return string
586 */
589 }
595 }
597 }
601 }
605 }
609 }
613 }
617 }
621 }
625 }
629 }
633 }
635 /**
636 * Used by date() and time() to adjust the time output.
637 *
638 * @param $ts Int the time in date('YmdHis') format
639 * @param $tz Mixed: adjust the time by this amount (default false, mean we
640 * get user timecorrection setting)
641 * @return int
642 */
648 }
658 }
659 # Unrecognized timezone, default to 'Offset' with the stored offset.
661 }
665 # Global offset in minutes.
668 }
679 }
682 }
683 }
685 # No difference ? Return time unchanged
688 }
691 # Generate an adjusted date; take advantage of the fact that mktime
692 # will normalize out-of-range values so we don't have to split $minDiff
693 # into hours and minutes.
706 }
708 /**
709 * This is a workalike of PHP's date() function, but with better
710 * internationalisation, a reduced set of format characters, and a better
711 * escaping format.
712 *
713 * Supported format characters are dDjlNwzWFmMntLoYyaAgGhHiscrU. See the
714 * PHP manual for definitions. There are a number of extensions, which
715 * start with "x":
716 *
717 * xn Do not translate digits of the next numeric format character
718 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
719 * xr Use roman numerals for the next numeric format character
720 * xh Use hebrew numerals for the next numeric format character
721 * xx Literal x
722 * xg Genitive month name
723 *
724 * xij j (day number) in Iranian calendar
725 * xiF F (month name) in Iranian calendar
726 * xin n (month number) in Iranian calendar
727 * xiY Y (full year) in Iranian calendar
728 *
729 * xjj j (day number) in Hebrew calendar
730 * xjF F (month name) in Hebrew calendar
731 * xjt t (days in month) in Hebrew calendar
732 * xjx xg (genitive month name) in Hebrew calendar
733 * xjn n (month number) in Hebrew calendar
734 * xjY Y (full year) in Hebrew calendar
735 *
736 * xmj j (day number) in Hijri calendar
737 * xmF F (month name) in Hijri calendar
738 * xmn n (month number) in Hijri calendar
739 * xmY Y (full year) in Hijri calendar
740 *
741 * xkY Y (full year) in Thai solar calendar. Months and days are
742 * identical to the Gregorian calendar
743 * xoY Y (full year) in Minguo calendar or Juche year.
744 * Months and days are identical to the
745 * Gregorian calendar
746 * xtY Y (full year) in Japanese nengo. Months and days are
747 * identical to the Gregorian calendar
748 *
749 * Characters enclosed in double quotes will be considered literal (with
750 * the quotes themselves removed). Unmatched quotes will be considered
751 * literal quotes. Example:
752 *
753 * "The month is" F => The month is January
754 * i's" => 20'11"
755 *
756 * Backslash escaping is also supported.
757 *
758 * Input timestamp is assumed to be pre-normalized to the desired local
759 * time zone, if any.
760 *
761 * @param $format String
762 * @param $ts String: 14-character timestamp
763 * YYYYMMDDHHMMSS
764 * 01234567890123
765 * @todo handling of "o" format character for Iranian, Hebrew, Hijri & Thai?
766 */
785 }
787 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' || $code == 'xo' || $code == 'xt' ) && $p < strlen( $format ) - 1 ) {
789 }
827 }
833 }
839 }
845 }
851 }
858 }
864 }
870 }
879 }
885 }
891 }
906 }
912 }
918 }
924 }
930 }
936 }
942 }
951 }
957 }
963 }
969 }
975 }
981 }
1016 }
1022 }
1028 }
1032 # Backslash escaping
1037 }
1040 # Quoted literal
1044 # No terminating quote, assume literal "
1049 }
1051 # Quote at end of string, assume literal "
1053 }
1057 }
1070 }
1071 }
1072 }
1074 }
1078 /**
1079 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
1080 * Gregorian dates to Iranian dates. Originally written in C, it
1081 * is released under the terms of GNU Lesser General Public
1082 * License. Conversion to PHP was performed by Niklas Laxström.
1083 *
1084 * Link: http://www.farsiweb.info/jalali/jalali.c
1085 */
1091 # Days passed from the beginning (including leap years)
1098 // Add days of the past months of this year
1101 }
1103 // Leap years
1106 }
1108 // Days passed in current month
1122 }
1126 }
1132 }
1134 /**
1135 * Converting Gregorian dates to Hijri dates.
1136 *
1137 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
1138 *
1139 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
1140 */
1154 )
1155 {
1163 }
1168 $zj = ( (int)( ( 10985 - $zl ) / 5316 ) ) * ( (int)( ( 50 * $zl ) / 17719 ) ) + ( (int)( $zl / 5670 ) ) * ( (int)( ( 43 * $zl ) / 15238 ) );
1169 $zl = $zl - ( (int)( ( 30 - $zj ) / 15 ) ) * ( (int)( ( 17719 * $zj ) / 50 ) ) - ( (int)( $zj / 16 ) ) * ( (int)( ( 15238 * $zj ) / 43 ) ) + 29;
1175 }
1177 /**
1178 * Converting Gregorian dates to Hebrew dates.
1179 *
1180 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
1181 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
1182 * to translate the relevant functions into PHP and release them under
1183 * GNU GPL.
1184 *
1185 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
1186 * and Adar II is 14. In a non-leap year, Adar is 6.
1187 */
1189 # Parse date
1194 # Calculate Hebrew year
1197 # Month number when September = 1, August = 12
1200 # Next year
1204 }
1206 # Calculate day of year from 1 September
1210 # February
1212 # Check if the year is leap
1215 }
1220 }
1221 }
1223 # Calculate the start of the Hebrew year
1226 # Calculate next year's start
1228 # Day is before the start of the year - it is the previous year
1229 # Next year's start
1231 # Previous year
1234 # Add days since previous year's 1 September
1237 # Leap year
1239 }
1240 # Start of the new (previous) year
1243 # Next year's start
1245 }
1247 # Calculate Hebrew day of year
1250 # Difference between year's days
1252 # Add 12 (or 13 for leap years) days to ignore the difference between
1253 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
1254 # difference is only about the year type
1259 }
1261 # Check the year pattern, and is leap year
1262 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1263 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1264 # and non-leap years
1266 # Check if leap year
1269 # Calculate day in the month from number of day in the Hebrew year
1270 # Don't check Adar - if the day is not in Adar, we will stop before;
1271 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1276 # Calculate days in this month
1278 # Adar in a leap year
1280 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1283 # Day in Adar I
1286 # Subtract the days of Adar I
1288 # Try Adar II
1291 # Day in Adar II
1293 }
1294 }
1295 }
1297 # Cheshvan in a complete year (otherwise as the rule below)
1300 # Kislev in an incomplete year (otherwise as the rule below)
1303 # Odd months have 30 days, even have 29
1305 }
1307 # In the current month
1310 # Subtract the days of the current month
1312 # Try in the next month
1314 }
1315 }
1318 }
1320 /**
1321 * This calculates the Hebrew year start, as days since 1 September.
1322 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1323 * Used for Hebrew date.
1324 */
1331 }
1335 }
1345 }
1349 }
1351 /**
1352 * Algorithm to convert Gregorian dates to Thai solar dates,
1353 * Minguo dates or Minguo dates.
1354 *
1355 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1356 * http://en.wikipedia.org/wiki/Minguo_calendar
1357 * http://en.wikipedia.org/wiki/Japanese_era_name
1358 *
1359 * @param $ts String: 14-character timestamp
1360 * @param $cName String: calender name
1361 * @return Array: converted year, month, day
1362 */
1369 # Thai solar dates
1370 # Add 543 years to the Gregorian calendar
1371 # Months and days are identical
1374 # Minguo dates
1375 # Deduct 1911 years from the Gregorian calendar
1376 # Months and days are identical
1379 # Nengō dates up to Meiji period
1380 # Deduct years from the Gregorian calendar
1381 # depending on the nengo periods
1382 # Months and days are identical
1383 if ( ( $gy < 1912 ) || ( ( $gy == 1912 ) && ( $gm < 7 ) ) || ( ( $gy == 1912 ) && ( $gm == 7 ) && ( $gd < 31 ) ) ) {
1384 # Meiji period
1389 }
1397 )
1398 {
1399 # Taishō period
1404 }
1410 )
1411 {
1412 # Shōwa period
1417 }
1420 # Heisei period
1425 }
1427 }
1430 }
1433 }
1435 /**
1436 * Roman number formatting up to 3000
1437 */
1444 );
1449 }
1455 }
1457 }
1459 }
1461 /**
1462 * Hebrew Gematria number formatting up to 9999
1463 */
1470 );
1475 }
1487 }
1488 }
1489 }
1491 }
1497 }
1516 }
1518 }
1520 /**
1521 * This is meant to be used by time(), date(), and timeanddate() to get
1522 * the date preference they're supposed to use, it should be used in
1523 * all children.
1524 *
1525 *<code>
1526 * function timeanddate([...], $format = true) {
1527 * $datePreference = $this->dateFormat($format);
1528 * [...]
1529 * }
1530 *</code>
1531 *
1532 * @param $usePrefs Mixed: if true, the user's preference is used
1533 * if false, the site/language default is used
1534 * if int/string, assumed to be a format.
1535 * @return string
1536 */
1545 }
1548 }
1550 // return int
1553 }
1556 }
1558 /**
1559 * Get a format string for a given type and preference
1560 * @param $type May be date, time or both
1561 * @param $pref The format name as it appears in Messages*.php
1562 */
1573 }
1574 }
1576 }
1578 }
1580 /**
1581 * @param $ts Mixed: the time format which needs to be turned into a
1582 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1583 * @param $adj Bool: whether to adjust the time output according to the
1584 * user configured offset ($timecorrection)
1585 * @param $format Mixed: true to use user's date format preference
1586 * @param $timecorrection String: the time offset as returned by
1587 * validateTimeZone() in Special:Preferences
1588 * @return string
1589 */
1594 }
1597 }
1599 /**
1600 * @param $ts Mixed: the time format which needs to be turned into a
1601 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1602 * @param $adj Bool: whether to adjust the time output according to the
1603 * user configured offset ($timecorrection)
1604 * @param $format Mixed: true to use user's date format preference
1605 * @param $timecorrection String: the time offset as returned by
1606 * validateTimeZone() in Special:Preferences
1607 * @return string
1608 */
1613 }
1616 }
1618 /**
1619 * @param $ts Mixed: the time format which needs to be turned into a
1620 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1621 * @param $adj Bool: whether to adjust the time output according to the
1622 * user configured offset ($timecorrection)
1623 * @param $format Mixed: what format to return, if it's false output the
1624 * default one (default true)
1625 * @param $timecorrection String: the time offset as returned by
1626 * validateTimeZone() in Special:Preferences
1627 * @return string
1628 */
1633 }
1636 }
1640 }
1644 }
1647 # This is a wrapper for iconv in all languages except esperanto,
1648 # which does some nasty x-conversions beforehand
1650 # Even with //IGNORE iconv can whine about illegal characters in
1651 # *input* string. We just ignore those too.
1652 # REF: http://bugs.php.net/bug.php?id=37166
1653 # REF: https://bugzilla.wikimedia.org/show_bug.cgi?id=16885
1658 }
1660 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1663 }
1667 }
1672 }
1677 }
1681 }
1686 }
1688 /**
1689 * Make a string's first character uppercase
1690 */
1698 // fall back to more complex logic in case of multibyte strings
1700 }
1701 }
1703 /**
1704 * Convert a string to uppercase
1705 */
1713 }
1716 }
1723 $str
1724 );
1727 }
1728 }
1729 }
1742 }
1743 }
1752 }
1755 }
1762 $str
1763 );
1766 }
1767 }
1768 }
1772 }
1778 // regexp to find first letter in each word (i.e. after each space)
1779 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1781 // function to use to capitalize a single char
1786 $str
1787 );
1792 $str
1793 );
1794 }
1797 }
1798 }
1800 # capitalize words at word breaks
1805 // since \b doesn't work for UTF-8, we explicitely define word break chars
1808 // find first letter after word break
1809 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1815 $str
1816 );
1821 $str
1822 );
1823 }
1828 $str
1829 );
1830 }
1831 }
1833 /**
1834 * Return a case-folded representation of $s
1835 *
1836 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1837 * and $s2 are the same except for the case of their characters. It is not
1838 * necessary for the value returned to make sense when displayed.
1839 *
1840 * Do *not* perform any other normalisation in this function. If a caller
1841 * uses this function when it should be using a more general normalisation
1842 * function, then fix the caller.
1843 */
1846 }
1851 }
1852 # Check for non-UTF-8 URLs
1856 }
1862 }
1865 }
1869 }
1871 /**
1872 * Most writing systems use whitespace to break up words.
1873 * Some languages such as Chinese don't conventionally do this,
1874 * which requires special handling when breaking up words for
1875 * searching etc.
1876 */
1879 }
1881 /**
1882 * Some languages such as Chinese require word segmentation,
1883 * Specify such segmentation when overridden in derived class.
1884 *
1885 * @param $string String
1886 * @return String
1887 */
1890 }
1892 /**
1893 * Some languages have special punctuation need to be normalized.
1894 * Make such changes here.
1895 *
1896 * @param $string String
1897 * @return String
1898 */
1901 }
1903 /**
1904 * convert double-width roman characters to single-width.
1905 * range: ff00-ff5f ~= 0020-007f
1906 */
1916 }
1920 }
1926 }
1929 # some languages, e.g. Chinese, need to do a conversion
1930 # in order for search results to be displayed correctly
1932 }
1934 /**
1935 * Get the first character of a string.
1936 *
1937 * @param $s string
1938 * @return string
1939 */
1946 $matches
1947 );
1952 }
1954 // Break down Hangul syllables to grab the first jamo
1986 }
1989 }
1990 }
1993 # Some languages may have an alternate char encoding option
1994 # (Esperanto X-coding, Japanese furigana conversion, etc)
1995 # If this language is used as the primary content language,
1996 # an override to the defaults can be set here on startup.
1997 }
2000 # For some languages we'll want to explicitly specify
2001 # which characters make it into the edit box raw
2002 # or are converted in some way or another.
2003 # Note that if wgOutputEncoding is different from
2004 # wgInputEncoding, this text will be further converted
2005 # to wgOutputEncoding.
2011 }
2012 }
2015 # Take the previous into account.
2021 }
2026 }
2027 }
2029 /**
2030 * Convert a UTF-8 string to normal form C. In Malayalam and Arabic, this
2031 * also cleans up certain backwards-compatible sequences, converting them
2032 * to the modern Unicode equivalent.
2033 *
2034 * This is language-specific for performance reasons only.
2035 */
2042 }
2045 }
2047 /**
2048 * Transform a string using serialized data stored in the given file (which
2049 * must be in the serialized subdirectory of $IP). The file contains pairs
2050 * mapping source characters to destination characters.
2051 *
2052 * The data is cached in process memory. This will go faster if you have the
2053 * FastStringSearch extension.
2054 */
2060 }
2062 }
2064 }
2066 /**
2067 * For right-to-left language support
2068 *
2069 * @return bool
2070 */
2073 }
2075 /**
2076 * Return the correct HTML 'dir' attribute value for this language.
2077 * @return String
2078 */
2081 }
2083 /**
2084 * Return 'left' or 'right' as appropriate alignment for line-start
2085 * for this language's text direction.
2086 *
2087 * Should be equivalent to CSS3 'start' text-align value....
2088 *
2089 * @return String
2090 */
2093 }
2095 /**
2096 * Return 'right' or 'left' as appropriate alignment for line-end
2097 * for this language's text direction.
2098 *
2099 * Should be equivalent to CSS3 'end' text-align value....
2100 *
2101 * @return String
2102 */
2105 }
2107 /**
2108 * A hidden direction mark (LRM or RLM), depending on the language direction
2109 *
2110 * @return string
2111 */
2114 }
2118 }
2120 /**
2121 * An arrow, depending on the language direction
2122 *
2123 * @return string
2124 */
2127 }
2129 /**
2130 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
2131 *
2132 * @return bool
2133 */
2136 }
2140 }
2145 }
2150 }
2152 # Fill a MagicWord object with data from here
2164 }
2165 }
2172 }
2173 }
2175 /**
2176 * Add magic words to the extension array
2177 */
2184 }
2187 }
2192 }
2193 }
2194 }
2196 /**
2197 * Get special page names, as an associative array
2198 * case folded alias => real name
2199 */
2201 // Cache aliases because it may be slow to load them
2203 // Initialise array
2208 }
2211 }
2213 /**
2214 * Italic is unsuitable for some languages
2215 *
2216 * @param $text String: the text to be emphasized.
2217 * @return string
2218 */
2221 }
2223 /**
2224 * Normally we output all numbers in plain en_US style, that is
2225 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
2226 * point twohundredthirtyfive. However this is not sutable for all
2227 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
2228 * Icelandic just want to use commas instead of dots, and dots instead
2229 * of commas like "293.291,235".
2230 *
2231 * An example of this function being called:
2232 * <code>
2233 * wfMsg( 'message', $wgLang->formatNum( $num ) )
2234 * </code>
2235 *
2236 * See LanguageGu.php for the Gujarati implementation and
2237 * $separatorTransformTable on MessageIs.php for
2238 * the , => . and . => , implementation.
2239 *
2240 * @todo check if it's viable to use localeconv() for the decimal
2241 * separator thing.
2242 * @param $number Mixed: the string to be formatted, should be an integer
2243 * or a floating point number.
2244 * @param $nocommafy Bool: set to true for special numbers like dates
2245 * @return string
2246 */
2254 }
2255 }
2261 }
2262 }
2265 }
2271 }
2276 }
2280 }
2282 /**
2283 * Adds commas to a given number
2284 *
2285 * @param $_ mixed
2286 * @return string
2287 */
2290 }
2294 }
2298 }
2300 /**
2301 * Take a list of strings and build a locale-friendly comma-separated
2302 * list, using the local comma-separator message.
2303 * The last two strings are chained with an "and".
2304 *
2305 * @param $l Array
2306 * @return string
2307 */
2312 return $l[0] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $l[1];
2318 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
2321 }
2322 }
2324 }
2325 }
2327 /**
2328 * Take a list of strings and build a locale-friendly comma-separated
2329 * list, using the local comma-separator message.
2330 * @param $list array of strings to put in a comma list
2331 * @return string
2332 */
2339 )
2340 );
2341 }
2343 /**
2344 * Take a list of strings and build a locale-friendly semicolon-separated
2345 * list, using the local semicolon-separator message.
2346 * @param $list array of strings to put in a semicolon list
2347 * @return string
2348 */
2355 )
2356 );
2357 }
2359 /**
2360 * Same as commaList, but separate it with the pipe instead.
2361 * @param $list array of strings to put in a pipe list
2362 * @return string
2363 */
2370 )
2371 );
2372 }
2374 /**
2375 * Truncate a string to a specified length in bytes, appending an optional
2376 * string (e.g. for ellipses)
2377 *
2378 * The database offers limited byte lengths for some columns in the database;
2379 * multi-byte character sets mean we need to ensure that only whole characters
2380 * are included, otherwise broken characters can be passed to the user
2381 *
2382 * If $length is negative, the string will be truncated from the beginning
2383 *
2384 * @param $string String to truncate
2385 * @param $length Int: maximum length (including ellipses)
2386 * @param $ellipsis String to append to the truncated text
2387 * @param $adjustLength Boolean: Subtract length of ellipsis from $length.
2388 * $adjustLength was introduced in 1.18, before that behaved as if false.
2389 * @return string
2390 */
2392 # Use the localized ellipsis character
2395 }
2396 # Check if there is no need to truncate
2401 }
2403 # If ellipsis length is >= $length then we can't apply $adjustLength
2406 # Otherwise, truncate and add ellipsis...
2419 }
2420 }
2421 # Do not truncate if the ellipsis makes the string longer/equal (bug 22181).
2422 # This check is *not* redundant if $adjustLength, due to the single case where
2423 # LEN($ellipsis) > ABS($limit arg); $stringOriginal could be shorter than $string.
2428 }
2429 }
2431 /**
2432 * Remove bytes that represent an incomplete Unicode character
2433 * at the end of string (e.g. bytes of the char are missing)
2434 *
2435 * @param $string String
2436 * @return string
2437 */
2443 # We got the first byte only of a multibyte char; remove it.
2448 {
2449 # We chopped in the middle of a character; remove it
2451 }
2452 }
2454 }
2456 /**
2457 * Remove bytes that represent an incomplete Unicode character
2458 * at the start of string (e.g. bytes of the char are missing)
2459 *
2460 * @param $string String
2461 * @return string
2462 */
2467 # We chopped in the middle of a character; remove the whole thing
2469 }
2470 }
2472 }
2474 /*
2475 * Truncate a string of valid HTML to a specified length in bytes,
2476 * appending an optional string (e.g. for ellipses), and return valid HTML
2477 *
2478 * This is only intended for styled/linked text, such as HTML with
2479 * tags like <span> and <a>, were the tags are self-contained (valid HTML).
2480 * Also, this will not detect things like "display:none" CSS.
2481 *
2482 * Note: since 1.18 you do not need to leave extra room in $length for ellipses.
2483 *
2484 * @param string $text HTML string to truncate
2485 * @param int $length (zero/positive) Maximum length (including ellipses)
2486 * @param string $ellipsis String to append to the truncated text
2487 * @returns string
2488 */
2490 # Use the localized ellipsis character
2493 }
2494 # Check if there is clearly no need to truncate
2499 }
2513 # Consider truncation once the display length has reached the maximim.
2514 # Check that we're not in the middle of a bracket/entity...
2518 # Save where we are; we will truncate here unless there turn out to
2519 # be so few remaining characters that truncation is not necessary.
2523 # String in fact does need truncation, the truncation point was OK.
2528 }
2529 }
2532 # Read the next char...
2550 }
2556 // Name found (e.g. "<a href=..."), add on tag attributes...
2558 }
2564 }
2570 // Add the next $max display text chars after this in one swoop...
2575 }
2576 }
2577 }
2578 }
2581 }
2582 // Close the last tag if left unclosed by bad HTML
2586 }
2588 }
2590 // truncateHtml() helper function
2591 // like strcspn() but adds the skipped chars to $ret
2597 }
2602 }
2604 }
2606 /*
2607 * truncateHtml() helper function
2608 * (a) push or pop $tag from $openTags as needed
2609 * (b) clear $tag value
2610 * @param String &$tag Current HTML tag name we are looking at
2611 * @param int $tagType (0-open tag, 1-close tag)
2612 * @param char $lastCh Character before the '>' that ended this tag
2613 * @param array &$openTags Open tag stack (not accounting for $tag)
2614 */
2623 }
2624 }
2626 }
2627 }
2629 /**
2630 * Grammatical transformations, needed for inflected languages
2631 * Invoked by putting {{grammar:case|word}} in a message
2632 *
2633 * @param $word string
2634 * @param $case string
2635 * @return string
2636 */
2641 }
2643 }
2645 /**
2646 * Provides an alternative text depending on specified gender.
2647 * Usage {{gender:username|masculine|feminine|neutral}}.
2648 * username is optional, in which case the gender of current user is used,
2649 * but only in (some) interface messages; otherwise default gender is used.
2650 * If second or third parameter are not specified, masculine is used.
2651 * These details may be overriden per language.
2652 */
2656 }
2660 }
2663 }
2665 }
2667 /**
2668 * Plural form transformations, needed for some languages.
2669 * For example, there are 3 form of plural in Russian and Polish,
2670 * depending on "count mod 10". See [[w:Plural]]
2671 * For English it is pretty simple.
2672 *
2673 * Invoked by putting {{plural:count|wordform1|wordform2}}
2674 * or {{plural:count|wordform1|wordform2|wordform3}}
2675 *
2676 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2677 *
2678 * @param $count Integer: non-localized number
2679 * @param $forms Array: different plural forms
2680 * @return string Correct form of plural for $count in this language
2681 */
2685 }
2689 }
2691 /**
2692 * Checks that convertPlural was given an array and pads it to requested
2693 * amound of forms by copying the last one.
2694 *
2695 * @param $count Integer: How many forms should there be at least
2696 * @param $forms Array of forms given to convertPlural
2697 * @return array Padded array of forms or an exception if not an array
2698 */
2702 }
2704 }
2706 /**
2707 * Maybe translate block durations. Note that this function is somewhat misnamed: it
2708 * deals with translating the *duration* ("1 week", "4 days", etc), not the expiry time
2709 * (which is an absolute timestamp).
2710 * @param $str String: the validated block duration in English
2711 * @return Somehow translated block duration
2712 * @see LanguageFi.php for example implementation
2713 */
2718 }
2719 }
2721 }
2723 /**
2724 * languages like Chinese need to be segmented in order for the diff
2725 * to be of any use
2726 *
2727 * @param $text String
2728 * @return String
2729 */
2732 }
2734 /**
2735 * and unsegment to show the result
2736 *
2737 * @param $text String
2738 * @return String
2739 */
2742 }
2744 # convert text to all supported variants
2747 }
2749 # convert text to different variants of a language.
2752 }
2754 # Convert a Title object to a string in the preferred variant
2757 }
2759 # Check if this is a language with variants
2762 }
2764 # Put custom tags (e.g. -{ }-) around math to prevent conversion
2767 }
2769 /**
2770 * Perform output conversion on a string, and encode for safe HTML output.
2771 * @param $text String text to be converted
2772 * @param $isTitle Bool whether this conversion is for the article title
2773 * @return string
2774 * @todo this should get integrated somewhere sane
2775 */
2778 }
2782 }
2784 /**
2785 * Get the list of variants supported by this language
2786 * see sample implementation in LanguageZh.php
2787 *
2788 * @return array an array of language codes
2789 */
2792 }
2796 }
2800 }
2804 }
2806 /**
2807 * If a language supports multiple variants, it is
2808 * possible that non-existing link in one variant
2809 * actually exists in another variant. this function
2810 * tries to find it. See e.g. LanguageZh.php
2811 *
2812 * @param $link String: the name of the link
2813 * @param $nt Mixed: the title object of the link
2814 * @param $ignoreOtherCond Boolean: to disable other conditions when
2815 * we need to transclude a template or update a category's link
2816 * @return null the input parameters may be modified upon return
2817 */
2820 }
2822 /**
2823 * If a language supports multiple variants, converts text
2824 * into an array of all possible variants of the text:
2825 * 'variant' => text in that variant
2826 *
2827 * @deprecated Use autoConvertToAllVariants()
2828 */
2831 }
2833 /**
2834 * returns language specific options used by User::getPageRenderHash()
2835 * for example, the preferred language variant
2836 *
2837 * @return string
2838 */
2841 }
2843 /**
2844 * For languages that support multiple variants, the title of an
2845 * article may be displayed differently in different variants. this
2846 * function returns the apporiate title defined in the body of the article.
2847 *
2848 * @return string
2849 */
2852 }
2854 /**
2855 * Enclose a string with the "no conversion" tag. This is used by
2856 * various functions in the Parser
2857 *
2858 * @param $text String: text to be tagged for no conversion
2859 * @param $noParse
2860 * @return string the tagged text
2861 */
2864 }
2866 /**
2867 * A regular expression to match legal word-trailing characters
2868 * which should be merged onto a link of the form [[foo]]bar.
2869 *
2870 * @return string
2871 */
2874 }
2878 }
2880 /**
2881 * Get the RFC 3066 code for this language object
2882 */
2885 }
2889 }
2891 /**
2892 * Get the name of a file for a certain language code
2893 * @param $prefix string Prepend this to the filename
2894 * @param $code string Language code
2895 * @param $suffix string Append this to the filename
2896 * @return string $prefix . $mangledCode . $suffix
2897 */
2899 // Protect against path traversal
2902 {
2904 }
2907 }
2909 /**
2910 * Get the language code from a file name. Inverse of getFileName()
2911 * @param $filename string $prefix . $languageCode . $suffix
2912 * @param $prefix string Prefix before the language code
2913 * @param $suffix string Suffix after the language code
2914 * @return Language code, or false if $prefix or $suffix isn't found
2915 */
2922 }
2924 }
2929 }
2934 }
2936 /**
2937 * Get the fallback for a given language
2938 */
2941 // Shortcut
2945 }
2946 }
2948 /**
2949 * Get all messages for a given language
2950 * WARNING: this may take a long time
2951 */
2954 }
2956 /**
2957 * Get a message for a given language
2958 */
2961 }
2966 }
2971 # Allow grammar transformations
2972 # Allowing full message-style parsing would make simple requests
2973 # such as action=raw much more expensive than they need to be.
2974 # This will hopefully cover most cases.
2978 }
2982 }
2988 }
2995 }
3000 }
3002 /**
3003 * Decode an expiry (block, protection, etc) which has come from the DB
3004 *
3005 * @param $expiry String: Database expiry String
3006 * @param $format Bool|Int true to process using language functions, or TS_ constant
3007 * to return the expiry in a given timestamp
3008 * @return String
3009 */
3015 }
3019 ? $infinityMsg
3025 }
3026 }
3028 /**
3029 * @todo Document
3030 * @param $seconds String
3031 * @return string
3032 */
3035 return $this->formatNum( sprintf( "%.1f", round( $seconds * 10 ) / 10 ) ) . $this->getMessageFromDB( 'seconds-abbrev' );
3044 }
3054 }
3058 }
3062 }
3063 }
3069 }
3076 }
3078 }
3080 /**
3081 * Format a size in bytes for output, using an appropriate
3082 * unit (B, KB, MB or GB) according to the magnitude in question
3083 *
3084 * @param $size Size to format
3085 * @return string Plain text (not HTML)
3086 */
3088 // For small sizes no decimal places necessary
3094 // For MB and bigger two decimal places are smarter
3101 }
3104 }
3107 }
3111 }
3113 /**
3114 * Get the conversion rule title, if any.
3115 */
3118 }
3119 }