6 if( !defined( 'MEDIAWIKI' ) ) {
7 echo "This file is part of MediaWiki, it is not a valid entry point.\n";
12 # In general you should not make customizations in these language files
13 # directly, but should use the MediaWiki: special namespace to customize
14 # user interface messages through the wiki.
15 # See http://meta.wikipedia.org/wiki/MediaWiki_namespace
17 # NOTE TO TRANSLATORS: Do not copy this whole file when making translations!
18 # A lot of common constants and a base class with inheritable methods are
19 # defined here, which should not be redefined. See the other LanguageXx.php
24 global $wgLanguageNames;
25 require_once( dirname(__FILE__
) . '/Names.php' ) ;
27 global $wgInputEncoding, $wgOutputEncoding;
30 * These are always UTF-8, they exist only for backwards compatibility
32 $wgInputEncoding = "UTF-8";
33 $wgOutputEncoding = "UTF-8";
35 if( function_exists( 'mb_strtoupper' ) ) {
36 mb_internal_encoding('UTF-8');
39 /* a fake language converter */
42 function FakeConverter($langobj) {$this->mLang
= $langobj;}
43 function convert($t, $i) {return $t;}
44 function parserConvert($t, $p) {return $t;}
45 function getVariants() { return array( $this->mLang
->getCode() ); }
46 function getPreferredVariant() {return $this->mLang
->getCode(); }
47 function findVariantLink(&$l, &$n) {}
48 function getExtraHashOptions() {return '';}
49 function getParsedTitle() {return '';}
50 function markNoConversion($text, $noParse=false) {return $text;}
51 function convertCategoryKey( $key ) {return $key; }
52 function convertLinkToAllVariants($text){ return array( $this->mLang
->getCode() => $text); }
53 function armourMath($text){ return $text; }
56 #--------------------------------------------------------------------------
57 # Internationalisation code
58 #--------------------------------------------------------------------------
61 var $mConverter, $mVariants, $mCode, $mLoaded = false;
63 static public $mLocalisationKeys = array( 'fallback', 'namespaceNames',
64 'skinNames', 'mathNames',
65 'bookstoreList', 'magicWords', 'messages', 'rtl', 'digitTransformTable',
66 'separatorTransformTable', 'fallback8bitEncoding', 'linkPrefixExtension',
67 'defaultUserOptionOverrides', 'linkTrail', 'namespaceAliases',
68 'dateFormats', 'datePreferences', 'datePreferenceMigrationMap',
69 'defaultDateFormat', 'extraUserToggles', 'specialPageAliases' );
71 static public $mMergeableMapKeys = array( 'messages', 'namespaceNames', 'mathNames',
72 'dateFormats', 'defaultUserOptionOverrides', 'magicWords' );
74 static public $mMergeableListKeys = array( 'extraUserToggles' );
76 static public $mMergeableAliasListKeys = array( 'specialPageAliases' );
78 static public $mLocalisationCache = array();
80 static public $mWeekdayMsgs = array(
81 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
85 static public $mWeekdayAbbrevMsgs = array(
86 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'
89 static public $mMonthMsgs = array(
90 'january', 'february', 'march', 'april', 'may_long', 'june',
91 'july', 'august', 'september', 'october', 'november',
94 static public $mMonthGenMsgs = array(
95 'january-gen', 'february-gen', 'march-gen', 'april-gen', 'may-gen', 'june-gen',
96 'july-gen', 'august-gen', 'september-gen', 'october-gen', 'november-gen',
99 static public $mMonthAbbrevMsgs = array(
100 'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
101 'sep', 'oct', 'nov', 'dec'
105 * Create a language object for a given language code
107 static function factory( $code ) {
109 static $recursionLevel = 0;
111 if ( $code == 'en' ) {
114 $class = 'Language' . str_replace( '-', '_', ucfirst( $code ) );
115 // Preload base classes to work around APC/PHP5 bug
116 if ( file_exists( "$IP/languages/classes/$class.deps.php" ) ) {
117 include_once("$IP/languages/classes/$class.deps.php");
119 if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
120 include_once("$IP/languages/classes/$class.php");
124 if ( $recursionLevel > 5 ) {
125 throw new MWException( "Language fallback loop detected when creating class $class\n" );
128 if( ! class_exists( $class ) ) {
129 $fallback = Language
::getFallbackFor( $code );
131 $lang = Language
::factory( $fallback );
133 $lang->setCode( $code );
141 function __construct() {
142 $this->mConverter
= new FakeConverter($this);
143 // Set the code to the name of the descendant
144 if ( get_class( $this ) == 'Language' ) {
147 $this->mCode
= str_replace( '_', '-', strtolower( substr( get_class( $this ), 8 ) ) );
152 * Hook which will be called if this is the content language.
153 * Descendants can use this to register hook functions or modify globals
155 function initContLang() {}
161 function getDefaultUserOptions() {
162 return User
::getDefaultOptions();
165 function getFallbackLanguageCode() {
167 return $this->fallback
;
171 * Exports $wgBookstoreListEn
174 function getBookstoreList() {
176 return $this->bookstoreList
;
182 function getNamespaces() {
184 return $this->namespaceNames
;
188 * A convenience function that returns the same thing as
189 * getNamespaces() except with the array values changed to ' '
190 * where it found '_', useful for producing output to be displayed
191 * e.g. in <select> forms.
195 function getFormattedNamespaces() {
196 $ns = $this->getNamespaces();
197 foreach($ns as $k => $v) {
198 $ns[$k] = strtr($v, '_', ' ');
204 * Get a namespace value by key
206 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
207 * echo $mw_ns; // prints 'MediaWiki'
210 * @param int $index the array key of the namespace to return
211 * @return mixed, string if the namespace value exists, otherwise false
213 function getNsText( $index ) {
214 $ns = $this->getNamespaces();
215 return isset( $ns[$index] ) ?
$ns[$index] : false;
219 * A convenience function that returns the same thing as
220 * getNsText() except with '_' changed to ' ', useful for
225 function getFormattedNsText( $index ) {
226 $ns = $this->getNsText( $index );
227 return strtr($ns, '_', ' ');
231 * Get a namespace key by value, case insensetive.
233 * @param string $text
234 * @return mixed An integer if $text is a valid value otherwise false
236 function getNsIndex( $text ) {
238 $lctext = $this->lc($text);
239 return isset( $this->mNamespaceIds
[$lctext] ) ?
$this->mNamespaceIds
[$lctext] : false;
243 * short names for language variants used for language conversion links.
245 * @param string $code
248 function getVariantname( $code ) {
249 return $this->getMessageFromDB( "variantname-$code" );
252 function specialPage( $name ) {
253 $aliases = $this->getSpecialPageAliases();
254 if ( isset( $aliases[$name][0] ) ) {
255 $name = $aliases[$name][0];
257 return $this->getNsText(NS_SPECIAL
) . ':' . $name;
260 function getQuickbarSettings() {
262 $this->getMessage( 'qbsettings-none' ),
263 $this->getMessage( 'qbsettings-fixedleft' ),
264 $this->getMessage( 'qbsettings-fixedright' ),
265 $this->getMessage( 'qbsettings-floatingleft' ),
266 $this->getMessage( 'qbsettings-floatingright' )
270 function getSkinNames() {
272 return $this->skinNames
;
275 function getMathNames() {
277 return $this->mathNames
;
280 function getDatePreferences() {
282 return $this->datePreferences
;
285 function getDateFormats() {
287 return $this->dateFormats
;
290 function getDefaultDateFormat() {
292 return $this->defaultDateFormat
;
295 function getDatePreferenceMigrationMap() {
297 return $this->datePreferenceMigrationMap
;
300 function getDefaultUserOptionOverrides() {
302 return $this->defaultUserOptionOverrides
;
305 function getExtraUserToggles() {
307 return $this->extraUserToggles
;
310 function getUserToggle( $tog ) {
311 return $this->getMessageFromDB( "tog-$tog" );
315 * Get language names, indexed by code.
316 * If $customisedOnly is true, only returns codes with a messages file
318 public static function getLanguageNames( $customisedOnly = false ) {
319 global $wgLanguageNames;
320 if ( !$customisedOnly ) {
321 return $wgLanguageNames;
325 $messageFiles = glob( "$IP/languages/messages/Messages*.php" );
327 foreach ( $messageFiles as $file ) {
329 if( preg_match( '/Messages([A-Z][a-z_]+)\.php$/', $file, $m ) ) {
330 $code = str_replace( '_', '-', strtolower( $m[1] ) );
331 if ( isset( $wgLanguageNames[$code] ) ) {
332 $names[$code] = $wgLanguageNames[$code];
340 * Ugly hack to get a message maybe from the MediaWiki namespace, if this
341 * language object is the content or user language.
343 function getMessageFromDB( $msg ) {
344 global $wgContLang, $wgLang;
345 if ( $wgContLang->getCode() == $this->getCode() ) {
347 return wfMsgForContent( $msg );
348 } elseif ( $wgLang->getCode() == $this->getCode() ) {
350 return wfMsg( $msg );
352 # Neither, get from localisation
353 return $this->getMessage( $msg );
357 function getLanguageName( $code ) {
358 global $wgLanguageNames;
359 if ( ! array_key_exists( $code, $wgLanguageNames ) ) {
362 return $wgLanguageNames[$code];
365 function getMonthName( $key ) {
366 return $this->getMessageFromDB( self
::$mMonthMsgs[$key-1] );
369 function getMonthNameGen( $key ) {
370 return $this->getMessageFromDB( self
::$mMonthGenMsgs[$key-1] );
373 function getMonthAbbreviation( $key ) {
374 return $this->getMessageFromDB( self
::$mMonthAbbrevMsgs[$key-1] );
377 function getWeekdayName( $key ) {
378 return $this->getMessageFromDB( self
::$mWeekdayMsgs[$key-1] );
381 function getWeekdayAbbreviation( $key ) {
382 return $this->getMessageFromDB( self
::$mWeekdayAbbrevMsgs[$key-1] );
386 * Used by date() and time() to adjust the time output.
388 * @param int $ts the time in date('YmdHis') format
389 * @param mixed $tz adjust the time by this amount (default false,
390 * mean we get user timecorrection setting)
393 function userAdjust( $ts, $tz = false ) {
394 global $wgUser, $wgLocalTZoffset, $wgDBtimezone;
397 $tz = $wgUser->getOption( 'timecorrection' );
400 # minutes and hours differences:
405 # Global offset in minutes.
406 if( isset($wgLocalTZoffset) ) {
407 $hrDiff = $wgLocalTZoffset %
60;
408 $minDiff = $wgLocalTZoffset - ($hrDiff * 60);
410 } elseif ( strpos( $tz, ':' ) !== false ) {
411 $tzArray = explode( ':', $tz );
412 $hrDiff = intval($tzArray[0]);
413 $minDiff = intval($hrDiff < 0 ?
-$tzArray[1] : $tzArray[1]);
415 $hrDiff = intval( $tz );
418 # Account for databases that use timestamp with time zone
419 if ( isset($wgDBtimezone) and $tz ) {
420 $hrDiff -= $wgDBtimezone;
423 # No difference ? Return time unchanged
424 if ( 0 == $hrDiff && 0 == $minDiff ) { return $ts; }
426 # Generate an adjusted date
428 (int)substr( $ts, 8, 2) ) +
$hrDiff, # Hours
429 (int)substr( $ts, 10, 2 ) +
$minDiff, # Minutes
430 (int)substr( $ts, 12, 2 ), # Seconds
431 (int)substr( $ts, 4, 2 ), # Month
432 (int)substr( $ts, 6, 2 ), # Day
433 (int)substr( $ts, 0, 4 ) ); #Year
434 return date( 'YmdHis', $t );
438 * This is a workalike of PHP's date() function, but with better
439 * internationalisation, a reduced set of format characters, and a better
442 * Supported format characters are dDjlNwzWFmMntLYyaAgGhHiscrU. See the
443 * PHP manual for definitions. There are a number of extensions, which
446 * xn Do not translate digits of the next numeric format character
447 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
448 * xr Use roman numerals for the next numeric format character
450 * xg Genitive month name
452 * Characters enclosed in double quotes will be considered literal (with
453 * the quotes themselves removed). Unmatched quotes will be considered
454 * literal quotes. Example:
456 * "The month is" F => The month is January
459 * Backslash escaping is also supported.
461 * @param string $format
462 * @param string $ts 14-character timestamp
466 function sprintfDate( $format, $ts ) {
472 for ( $p = 0; $p < strlen( $format ); $p++
) {
475 if ( $code == 'x' && $p < strlen( $format ) - 1 ) {
476 $code .= $format[++
$p];
487 $rawToggle = !$rawToggle;
493 $s .= $this->getMonthNameGen( substr( $ts, 4, 2 ) );
496 $num = substr( $ts, 6, 2 );
499 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
500 $s .= $this->getWeekdayAbbreviation( date( 'w', $unix ) +
1 );
503 $num = intval( substr( $ts, 6, 2 ) );
506 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
507 $s .= $this->getWeekdayName( date( 'w', $unix ) +
1 );
510 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
511 $w = date( 'w', $unix );
515 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
516 $num = date( 'w', $unix );
519 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
520 $num = date( 'z', $unix );
523 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
524 $num = date( 'W', $unix );
527 $s .= $this->getMonthName( substr( $ts, 4, 2 ) );
530 $num = substr( $ts, 4, 2 );
533 $s .= $this->getMonthAbbreviation( substr( $ts, 4, 2 ) );
536 $num = intval( substr( $ts, 4, 2 ) );
539 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
540 $num = date( 't', $unix );
543 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
544 $num = date( 'L', $unix );
547 $num = substr( $ts, 0, 4 );
550 $num = substr( $ts, 2, 2 );
553 $s .= intval( substr( $ts, 8, 2 ) ) < 12 ?
'am' : 'pm';
556 $s .= intval( substr( $ts, 8, 2 ) ) < 12 ?
'AM' : 'PM';
559 $h = substr( $ts, 8, 2 );
560 $num = $h %
12 ?
$h %
12 : 12;
563 $num = intval( substr( $ts, 8, 2 ) );
566 $h = substr( $ts, 8, 2 );
567 $num = sprintf( '%02d', $h %
12 ?
$h %
12 : 12 );
570 $num = substr( $ts, 8, 2 );
573 $num = substr( $ts, 10, 2 );
576 $num = substr( $ts, 12, 2 );
579 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
580 $s .= date( 'c', $unix );
583 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
584 $s .= date( 'r', $unix );
587 if ( !$unix ) $unix = wfTimestamp( TS_UNIX
, $ts );
592 if ( $p < strlen( $format ) - 1 ) {
600 if ( $p < strlen( $format ) - 1 ) {
601 $endQuote = strpos( $format, '"', $p +
1 );
602 if ( $endQuote === false ) {
603 # No terminating quote, assume literal "
606 $s .= substr( $format, $p +
1, $endQuote - $p - 1 );
610 # Quote at end of string, assume literal "
617 if ( $num !== false ) {
618 if ( $rawToggle ||
$raw ) {
621 } elseif ( $roman ) {
622 $s .= self
::romanNumeral( $num );
625 $s .= $this->formatNum( $num, true );
634 * Roman number formatting up to 3000
636 static function romanNumeral( $num ) {
637 static $table = array(
638 array( '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X' ),
639 array( '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', 'C' ),
640 array( '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', 'M' ),
641 array( '', 'M', 'MM', 'MMM' )
644 $num = intval( $num );
645 if ( $num > 3000 ||
$num <= 0 ) {
650 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
651 if ( $num >= $pow10 ) {
652 $s .= $table[$i][floor($num / $pow10)];
654 $num = $num %
$pow10;
660 * This is meant to be used by time(), date(), and timeanddate() to get
661 * the date preference they're supposed to use, it should be used in
665 * function timeanddate([...], $format = true) {
666 * $datePreference = $this->dateFormat($format);
671 * @param mixed $usePrefs: if true, the user's preference is used
672 * if false, the site/language default is used
673 * if int/string, assumed to be a format.
676 function dateFormat( $usePrefs = true ) {
679 if( is_bool( $usePrefs ) ) {
681 $datePreference = $wgUser->getDatePreference();
683 $options = User
::getDefaultOptions();
684 $datePreference = (string)$options['date'];
687 $datePreference = (string)$usePrefs;
691 if( $datePreference == '' ) {
695 return $datePreference;
700 * @param mixed $ts the time format which needs to be turned into a
701 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
702 * @param bool $adj whether to adjust the time output according to the
703 * user configured offset ($timecorrection)
704 * @param mixed $format true to use user's date format preference
705 * @param string $timecorrection the time offset as returned by
706 * validateTimeZone() in Special:Preferences
709 function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
712 $ts = $this->userAdjust( $ts, $timecorrection );
715 $pref = $this->dateFormat( $format );
716 if( $pref == 'default' ||
!isset( $this->dateFormats
["$pref date"] ) ) {
717 $pref = $this->defaultDateFormat
;
719 return $this->sprintfDate( $this->dateFormats
["$pref date"], $ts );
724 * @param mixed $ts the time format which needs to be turned into a
725 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
726 * @param bool $adj whether to adjust the time output according to the
727 * user configured offset ($timecorrection)
728 * @param mixed $format true to use user's date format preference
729 * @param string $timecorrection the time offset as returned by
730 * validateTimeZone() in Special:Preferences
733 function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
736 $ts = $this->userAdjust( $ts, $timecorrection );
739 $pref = $this->dateFormat( $format );
740 if( $pref == 'default' ||
!isset( $this->dateFormats
["$pref time"] ) ) {
741 $pref = $this->defaultDateFormat
;
743 return $this->sprintfDate( $this->dateFormats
["$pref time"], $ts );
748 * @param mixed $ts the time format which needs to be turned into a
749 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
750 * @param bool $adj whether to adjust the time output according to the
751 * user configured offset ($timecorrection)
753 * @param mixed $format what format to return, if it's false output the
754 * default one (default true)
755 * @param string $timecorrection the time offset as returned by
756 * validateTimeZone() in Special:Preferences
759 function timeanddate( $ts, $adj = false, $format = true, $timecorrection = false) {
762 ## Account for non-integer timestamps
763 if (substr($ts,4,1) === '-') {
764 $ts = preg_replace('/\D/', '', $ts);
768 $ts = $this->userAdjust( $ts, $timecorrection );
771 $pref = $this->dateFormat( $format );
772 if( $pref == 'default' ||
!isset( $this->dateFormats
["$pref both"] ) ) {
773 $pref = $this->defaultDateFormat
;
776 return $this->sprintfDate( $this->dateFormats
["$pref both"], $ts );
779 function getMessage( $key ) {
781 return isset( $this->messages
[$key] ) ?
$this->messages
[$key] : null;
784 function getAllMessages() {
786 return $this->messages
;
789 function iconv( $in, $out, $string ) {
790 # For most languages, this is a wrapper for iconv
791 return iconv( $in, $out . '//IGNORE', $string );
794 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
795 function ucwordbreaksCallbackAscii($matches){
796 return $this->ucfirst($matches[1]);
799 function ucwordbreaksCallbackMB($matches){
800 return mb_strtoupper($matches[0]);
803 function ucCallback($matches){
804 list( $wikiUpperChars ) = self
::getCaseMaps();
805 return strtr( $matches[1], $wikiUpperChars );
808 function lcCallback($matches){
809 list( , $wikiLowerChars ) = self
::getCaseMaps();
810 return strtr( $matches[1], $wikiLowerChars );
813 function ucwordsCallbackMB($matches){
814 return mb_strtoupper($matches[0]);
817 function ucwordsCallbackWiki($matches){
818 list( $wikiUpperChars ) = self
::getCaseMaps();
819 return strtr( $matches[0], $wikiUpperChars );
822 function ucfirst( $str ) {
823 return self
::uc( $str, true );
826 function uc( $str, $first = false ) {
827 if ( function_exists( 'mb_strtoupper' ) ) {
829 if ( self
::isMultibyte( $str ) ) {
830 return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
832 return ucfirst( $str );
835 return self
::isMultibyte( $str ) ?
mb_strtoupper( $str ) : strtoupper( $str );
838 if ( self
::isMultibyte( $str ) ) {
839 list( $wikiUpperChars ) = $this->getCaseMaps();
840 $x = $first ?
'^' : '';
841 return preg_replace_callback(
842 "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
843 array($this,"ucCallback"),
847 return $first ?
ucfirst( $str ) : strtoupper( $str );
852 function lcfirst( $str ) {
853 return self
::lc( $str, true );
856 function lc( $str, $first = false ) {
857 if ( function_exists( 'mb_strtolower' ) )
859 if ( self
::isMultibyte( $str ) )
860 return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
862 return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
864 return self
::isMultibyte( $str ) ?
mb_strtolower( $str ) : strtolower( $str );
866 if ( self
::isMultibyte( $str ) ) {
867 list( , $wikiLowerChars ) = self
::getCaseMaps();
868 $x = $first ?
'^' : '';
869 return preg_replace_callback(
870 "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
871 array($this,"lcCallback"),
875 return $first ?
strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
878 function isMultibyte( $str ) {
879 return (bool)preg_match( '/[\x80-\xff]/', $str );
882 function ucwords($str) {
883 if ( self
::isMultibyte( $str ) ) {
884 $str = self
::lc($str);
886 // regexp to find first letter in each word (i.e. after each space)
887 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
889 // function to use to capitalize a single char
890 if ( function_exists( 'mb_strtoupper' ) )
891 return preg_replace_callback(
893 array($this,"ucwordsCallbackMB"),
897 return preg_replace_callback(
899 array($this,"ucwordsCallbackWiki"),
904 return ucwords( strtolower( $str ) );
907 # capitalize words at word breaks
908 function ucwordbreaks($str){
909 if (self
::isMultibyte( $str ) ) {
910 $str = self
::lc($str);
912 // since \b doesn't work for UTF-8, we explicitely define word break chars
913 $breaks= "[ \-\(\)\}\{\.,\?!]";
915 // find first letter after word break
916 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
918 if ( function_exists( 'mb_strtoupper' ) )
919 return preg_replace_callback(
921 array($this,"ucwordbreaksCallbackMB"),
925 return preg_replace_callback(
927 array($this,"ucwordsCallbackWiki"),
932 return preg_replace_callback(
933 '/\b([\w\x80-\xff]+)\b/',
934 array($this,"ucwordbreaksCallbackAscii"),
939 * Return a case-folded representation of $s
941 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
942 * and $s2 are the same except for the case of their characters. It is not
943 * necessary for the value returned to make sense when displayed.
945 * Do *not* perform any other normalisation in this function. If a caller
946 * uses this function when it should be using a more general normalisation
947 * function, then fix the caller.
949 function caseFold( $s ) {
950 return $this->uc( $s );
953 function checkTitleEncoding( $s ) {
954 if( is_array( $s ) ) {
955 wfDebugDieBacktrace( 'Given array to checkTitleEncoding.' );
957 # Check for non-UTF-8 URLs
958 $ishigh = preg_match( '/[\x80-\xff]/', $s);
959 if(!$ishigh) return $s;
961 $isutf8 = preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
962 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
963 if( $isutf8 ) return $s;
965 return $this->iconv( $this->fallback8bitEncoding(), "utf-8", $s );
968 function fallback8bitEncoding() {
970 return $this->fallback8bitEncoding
;
974 * Some languages have special punctuation to strip out
975 * or characters which need to be converted for MySQL's
976 * indexing to grok it correctly. Make such changes here.
981 function stripForSearch( $string ) {
983 if ( $wgDBtype != 'mysql' ) {
987 # MySQL fulltext index doesn't grok utf-8, so we
988 # need to fold cases and convert to hex
990 wfProfileIn( __METHOD__
);
991 if( function_exists( 'mb_strtolower' ) ) {
993 "/([\\xc0-\\xff][\\x80-\\xbf]*)/e",
994 "'U8' . bin2hex( \"$1\" )",
995 mb_strtolower( $string ) );
997 list( , $wikiLowerChars ) = self
::getCaseMaps();
999 "/([\\xc0-\\xff][\\x80-\\xbf]*)/e",
1000 "'U8' . bin2hex( strtr( \"\$1\", \$wikiLowerChars ) )",
1003 wfProfileOut( __METHOD__
);
1007 function convertForSearchResult( $termsArray ) {
1008 # some languages, e.g. Chinese, need to do a conversion
1009 # in order for search results to be displayed correctly
1014 * Get the first character of a string.
1019 function firstChar( $s ) {
1021 preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1022 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/', $s, $matches);
1024 return isset( $matches[1] ) ?
$matches[1] : "";
1027 function initEncoding() {
1028 # Some languages may have an alternate char encoding option
1029 # (Esperanto X-coding, Japanese furigana conversion, etc)
1030 # If this language is used as the primary content language,
1031 # an override to the defaults can be set here on startup.
1034 function recodeForEdit( $s ) {
1035 # For some languages we'll want to explicitly specify
1036 # which characters make it into the edit box raw
1037 # or are converted in some way or another.
1038 # Note that if wgOutputEncoding is different from
1039 # wgInputEncoding, this text will be further converted
1040 # to wgOutputEncoding.
1041 global $wgEditEncoding;
1042 if( $wgEditEncoding == '' or
1043 $wgEditEncoding == 'UTF-8' ) {
1046 return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
1050 function recodeInput( $s ) {
1051 # Take the previous into account.
1052 global $wgEditEncoding;
1053 if($wgEditEncoding != "") {
1054 $enc = $wgEditEncoding;
1058 if( $enc == 'UTF-8' ) {
1061 return $this->iconv( $enc, 'UTF-8', $s );
1066 * For right-to-left language support
1076 * A hidden direction mark (LRM or RLM), depending on the language direction
1080 function getDirMark() {
1081 return $this->isRTL() ?
"\xE2\x80\x8F" : "\xE2\x80\x8E";
1085 * An arrow, depending on the language direction
1089 function getArrow() {
1090 return $this->isRTL() ?
'←' : '→';
1094 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
1098 function linkPrefixExtension() {
1100 return $this->linkPrefixExtension
;
1103 function &getMagicWords() {
1105 return $this->magicWords
;
1108 # Fill a MagicWord object with data from here
1109 function getMagic( &$mw ) {
1110 if ( !isset( $this->mMagicExtensions
) ) {
1111 $this->mMagicExtensions
= array();
1112 wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions
, $this->getCode() ) );
1114 if ( isset( $this->mMagicExtensions
[$mw->mId
] ) ) {
1115 $rawEntry = $this->mMagicExtensions
[$mw->mId
];
1117 $magicWords =& $this->getMagicWords();
1118 if ( isset( $magicWords[$mw->mId
] ) ) {
1119 $rawEntry = $magicWords[$mw->mId
];
1121 # Fall back to English if local list is incomplete
1122 $magicWords =& Language
::getMagicWords();
1123 $rawEntry = $magicWords[$mw->mId
];
1127 if( !is_array( $rawEntry ) ) {
1128 error_log( "\"$rawEntry\" is not a valid magic thingie for \"$mw->mId\"" );
1130 $mw->mCaseSensitive
= $rawEntry[0];
1131 $mw->mSynonyms
= array_slice( $rawEntry, 1 );
1135 * Get special page names, as an associative array
1136 * case folded alias => real name
1138 function getSpecialPageAliases() {
1140 if ( !isset( $this->mExtendedSpecialPageAliases
) ) {
1141 $this->mExtendedSpecialPageAliases
= $this->specialPageAliases
;
1142 wfRunHooks( 'LangugeGetSpecialPageAliases',
1143 array( &$this->mExtendedSpecialPageAliases
, $this->getCode() ) );
1145 return $this->mExtendedSpecialPageAliases
;
1149 * Italic is unsuitable for some languages
1153 * @param string $text The text to be emphasized.
1156 function emphasize( $text ) {
1157 return "<em>$text</em>";
1161 * Normally we output all numbers in plain en_US style, that is
1162 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
1163 * point twohundredthirtyfive. However this is not sutable for all
1164 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
1165 * Icelandic just want to use commas instead of dots, and dots instead
1166 * of commas like "293.291,235".
1168 * An example of this function being called:
1170 * wfMsg( 'message', $wgLang->formatNum( $num ) )
1173 * See LanguageGu.php for the Gujarati implementation and
1174 * LanguageIs.php for the , => . and . => , implementation.
1176 * @todo check if it's viable to use localeconv() for the decimal
1179 * @param mixed $number the string to be formatted, should be an integer or
1180 * a floating point number.
1181 * @param bool $nocommafy Set to true for special numbers like dates
1184 function formatNum( $number, $nocommafy = false ) {
1185 global $wgTranslateNumerals;
1187 $number = $this->commafy($number);
1188 $s = $this->separatorTransformTable();
1189 if (!is_null($s)) { $number = strtr($number, $s); }
1192 if ($wgTranslateNumerals) {
1193 $s = $this->digitTransformTable();
1194 if (!is_null($s)) { $number = strtr($number, $s); }
1200 function parseFormattedNumber( $number ) {
1201 $s = $this->digitTransformTable();
1202 if (!is_null($s)) { $number = strtr($number, array_flip($s)); }
1204 $s = $this->separatorTransformTable();
1205 if (!is_null($s)) { $number = strtr($number, array_flip($s)); }
1207 $number = strtr( $number, array (',' => '') );
1212 * Adds commas to a given number
1217 function commafy($_) {
1218 return strrev((string)preg_replace('/(\d{3})(?=\d)(?!\d*\.)/','$1,',strrev($_)));
1221 function digitTransformTable() {
1223 return $this->digitTransformTable
;
1226 function separatorTransformTable() {
1228 return $this->separatorTransformTable
;
1233 * For the credit list in includes/Credits.php (action=credits)
1238 function listToText( $l ) {
1241 for ($i = $m; $i >= 0; $i--) {
1244 } else if ($i == $m - 1) {
1245 $s = $l[$i] . ' ' . $this->getMessageFromDB( 'and' ) . ' ' . $s;
1247 $s = $l[$i] . ', ' . $s;
1253 # Crop a string from the beginning or end to a certain number of bytes.
1254 # (Bytes are used because our storage has limited byte lengths for some
1255 # columns in the database.) Multibyte charsets will need to make sure that
1256 # only whole characters are included!
1258 # $length does not include the optional ellipsis.
1259 # If $length is negative, snip from the beginning
1260 function truncate( $string, $length, $ellipsis = "" ) {
1261 if( $length == 0 ) {
1264 if ( strlen( $string ) <= abs( $length ) ) {
1268 $string = substr( $string, 0, $length );
1269 $char = ord( $string[strlen( $string ) - 1] );
1271 if ($char >= 0xc0) {
1272 # We got the first byte only of a multibyte char; remove it.
1273 $string = substr( $string, 0, -1 );
1274 } elseif( $char >= 0x80 &&
1275 preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
1276 '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
1277 # We chopped in the middle of a character; remove it
1280 return $string . $ellipsis;
1282 $string = substr( $string, $length );
1283 $char = ord( $string[0] );
1284 if( $char >= 0x80 && $char < 0xc0 ) {
1285 # We chopped in the middle of a character; remove the whole thing
1286 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
1288 return $ellipsis . $string;
1293 * Grammatical transformations, needed for inflected languages
1294 * Invoked by putting {{grammar:case|word}} in a message
1296 * @param string $word
1297 * @param string $case
1300 function convertGrammar( $word, $case ) {
1301 global $wgGrammarForms;
1302 if ( isset($wgGrammarForms['en'][$case][$word]) ) {
1303 return $wgGrammarForms['en'][$case][$word];
1309 * Plural form transformations, needed for some languages.
1310 * For example, where are 3 form of plural in Russian and Polish,
1311 * depending on "count mod 10". See [[w:Plural]]
1312 * For English it is pretty simple.
1314 * Invoked by putting {{plural:count|wordform1|wordform2}}
1315 * or {{plural:count|wordform1|wordform2|wordform3}}
1317 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
1319 * @param integer $count
1320 * @param string $wordform1
1321 * @param string $wordform2
1322 * @param string $wordform3 (optional)
1323 * @param string $wordform4 (optional)
1324 * @param string $wordform5 (optional)
1327 function convertPlural( $count, $w1, $w2, $w3, $w4, $w5) {
1328 return ( $count == '1' ||
$count == '-1' ) ?
$w1 : $w2;
1332 * For translaing of expiry times
1333 * @param string The validated block time in English
1334 * @param $forContent, avoid html?
1335 * @return Somehow translated block time
1336 * @see LanguageFi.php for example implementation
1338 function translateBlockExpiry( $str, $forContent=false ) {
1340 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
1342 if ( $scBlockExpiryOptions == '-') {
1346 foreach (explode(',', $scBlockExpiryOptions) as $option) {
1347 if ( strpos($option, ":") === false )
1349 list($show, $value) = explode(":", $option);
1350 if ( strcmp ( $str, $value) == 0 ) {
1352 return htmlspecialchars($str) . htmlspecialchars( trim( $show ) );
1354 return '<span title="' . htmlspecialchars($str). '">' . htmlspecialchars( trim( $show ) ) . '</span>';
1362 * languages like Chinese need to be segmented in order for the diff
1365 * @param string $text
1368 function segmentForDiff( $text ) {
1373 * and unsegment to show the result
1375 * @param string $text
1378 function unsegmentForDiff( $text ) {
1382 # convert text to different variants of a language.
1383 function convert( $text, $isTitle = false) {
1384 return $this->mConverter
->convert($text, $isTitle);
1387 # Convert text from within Parser
1388 function parserConvert( $text, &$parser ) {
1389 return $this->mConverter
->parserConvert( $text, $parser );
1392 # Check if this is a language with variants
1393 function hasVariants(){
1394 return sizeof($this->getVariants())>1;
1397 # Put custom tags (e.g. -{ }-) around math to prevent conversion
1398 function armourMath($text){
1399 return $this->mConverter
->armourMath($text);
1404 * Perform output conversion on a string, and encode for safe HTML output.
1405 * @param string $text
1406 * @param bool $isTitle -- wtf?
1408 * @todo this should get integrated somewhere sane
1410 function convertHtml( $text, $isTitle = false ) {
1411 return htmlspecialchars( $this->convert( $text, $isTitle ) );
1414 function convertCategoryKey( $key ) {
1415 return $this->mConverter
->convertCategoryKey( $key );
1419 * get the list of variants supported by this langauge
1420 * see sample implementation in LanguageZh.php
1422 * @return array an array of language codes
1424 function getVariants() {
1425 return $this->mConverter
->getVariants();
1429 function getPreferredVariant( $fromUser = true ) {
1430 return $this->mConverter
->getPreferredVariant( $fromUser );
1434 * if a language supports multiple variants, it is
1435 * possible that non-existing link in one variant
1436 * actually exists in another variant. this function
1437 * tries to find it. See e.g. LanguageZh.php
1439 * @param string $link the name of the link
1440 * @param mixed $nt the title object of the link
1441 * @return null the input parameters may be modified upon return
1443 function findVariantLink( &$link, &$nt ) {
1444 $this->mConverter
->findVariantLink($link, $nt);
1448 * If a language supports multiple variants, converts text
1449 * into an array of all possible variants of the text:
1450 * 'variant' => text in that variant
1453 function convertLinkToAllVariants($text){
1454 return $this->mConverter
->convertLinkToAllVariants($text);
1459 * returns language specific options used by User::getPageRenderHash()
1460 * for example, the preferred language variant
1465 function getExtraHashOptions() {
1466 return $this->mConverter
->getExtraHashOptions();
1470 * for languages that support multiple variants, the title of an
1471 * article may be displayed differently in different variants. this
1472 * function returns the apporiate title defined in the body of the article.
1476 function getParsedTitle() {
1477 return $this->mConverter
->getParsedTitle();
1481 * Enclose a string with the "no conversion" tag. This is used by
1482 * various functions in the Parser
1484 * @param string $text text to be tagged for no conversion
1485 * @return string the tagged text
1487 function markNoConversion( $text, $noParse=false ) {
1488 return $this->mConverter
->markNoConversion( $text, $noParse );
1492 * A regular expression to match legal word-trailing characters
1493 * which should be merged onto a link of the form [[foo]]bar.
1498 function linkTrail() {
1500 return $this->linkTrail
;
1503 function getLangObj() {
1508 * Get the RFC 3066 code for this language object
1510 function getCode() {
1511 return $this->mCode
;
1514 function setCode( $code ) {
1515 $this->mCode
= $code;
1518 static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
1519 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
1522 static function getMessagesFileName( $code ) {
1524 return self
::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
1527 static function getClassFileName( $code ) {
1529 return self
::getFileName( "$IP/languages/classes/Language", $code, '.php' );
1532 static function getLocalisationArray( $code, $disableCache = false ) {
1533 self
::loadLocalisation( $code, $disableCache );
1534 return self
::$mLocalisationCache[$code];
1538 * Load localisation data for a given code into the static cache
1540 * @return array Dependencies, map of filenames to mtimes
1542 static function loadLocalisation( $code, $disableCache = false ) {
1543 static $recursionGuard = array();
1547 throw new MWException( "Invalid language code requested" );
1550 if ( !$disableCache ) {
1551 # Try the per-process cache
1552 if ( isset( self
::$mLocalisationCache[$code] ) ) {
1553 return self
::$mLocalisationCache[$code]['deps'];
1556 wfProfileIn( __METHOD__
);
1558 # Try the serialized directory
1559 $cache = wfGetPrecompiledData( self
::getFileName( "Messages", $code, '.ser' ) );
1561 self
::$mLocalisationCache[$code] = $cache;
1562 wfDebug( "Language::loadLocalisation(): got localisation for $code from precompiled data file\n" );
1563 wfProfileOut( __METHOD__
);
1564 return self
::$mLocalisationCache[$code]['deps'];
1567 # Try the global cache
1568 $memcKey = wfMemcKey('localisation', $code );
1569 $cache = $wgMemc->get( $memcKey );
1571 # Check file modification times
1572 foreach ( $cache['deps'] as $file => $mtime ) {
1573 if ( !file_exists( $file ) ||
filemtime( $file ) > $mtime ) {
1577 if ( self
::isLocalisationOutOfDate( $cache ) ) {
1578 $wgMemc->delete( $memcKey );
1580 wfDebug( "Language::loadLocalisation(): localisation cache for $code had expired due to update of $file\n" );
1582 self
::$mLocalisationCache[$code] = $cache;
1583 wfDebug( "Language::loadLocalisation(): got localisation for $code from cache\n" );
1584 wfProfileOut( __METHOD__
);
1585 return $cache['deps'];
1589 wfProfileIn( __METHOD__
);
1592 # Default fallback, may be overridden when the messages file is included
1593 if ( $code != 'en' ) {
1599 # Load the primary localisation from the source file
1600 $filename = self
::getMessagesFileName( $code );
1601 if ( !file_exists( $filename ) ) {
1602 wfDebug( "Language::loadLocalisation(): no localisation file for $code, using implicit fallback to en\n" );
1606 $deps = array( $filename => filemtime( $filename ) );
1607 require( $filename );
1608 $cache = compact( self
::$mLocalisationKeys );
1609 wfDebug( "Language::loadLocalisation(): got localisation for $code from source\n" );
1612 if ( !empty( $fallback ) ) {
1613 # Load the fallback localisation, with a circular reference guard
1614 if ( isset( $recursionGuard[$code] ) ) {
1615 throw new MWException( "Error: Circular fallback reference in language code $code" );
1617 $recursionGuard[$code] = true;
1618 $newDeps = self
::loadLocalisation( $fallback, $disableCache );
1619 unset( $recursionGuard[$code] );
1621 $secondary = self
::$mLocalisationCache[$fallback];
1622 $deps = array_merge( $deps, $newDeps );
1624 # Merge the fallback localisation with the current localisation
1625 foreach ( self
::$mLocalisationKeys as $key ) {
1626 if ( isset( $cache[$key] ) ) {
1627 if ( isset( $secondary[$key] ) ) {
1628 if ( in_array( $key, self
::$mMergeableMapKeys ) ) {
1629 $cache[$key] = $cache[$key] +
$secondary[$key];
1630 } elseif ( in_array( $key, self
::$mMergeableListKeys ) ) {
1631 $cache[$key] = array_merge( $secondary[$key], $cache[$key] );
1632 } elseif ( in_array( $key, self
::$mMergeableAliasListKeys ) ) {
1633 $cache[$key] = array_merge_recursive( $cache[$key], $secondary[$key] );
1637 $cache[$key] = $secondary[$key];
1641 # Merge bookstore lists if requested
1642 if ( !empty( $cache['bookstoreList']['inherit'] ) ) {
1643 $cache['bookstoreList'] = array_merge( $cache['bookstoreList'], $secondary['bookstoreList'] );
1645 if ( isset( $cache['bookstoreList']['inherit'] ) ) {
1646 unset( $cache['bookstoreList']['inherit'] );
1650 # Add dependencies to the cache entry
1651 $cache['deps'] = $deps;
1653 # Replace spaces with underscores in namespace names
1654 $cache['namespaceNames'] = str_replace( ' ', '_', $cache['namespaceNames'] );
1656 # Save to both caches
1657 self
::$mLocalisationCache[$code] = $cache;
1658 if ( !$disableCache ) {
1659 $wgMemc->set( $memcKey, $cache );
1662 wfProfileOut( __METHOD__
);
1667 * Test if a given localisation cache is out of date with respect to the
1668 * source Messages files. This is done automatically for the global cache
1669 * in $wgMemc, but is only done on certain occasions for the serialized
1672 * @param $cache mixed Either a language code or a cache array
1674 static function isLocalisationOutOfDate( $cache ) {
1675 if ( !is_array( $cache ) ) {
1676 self
::loadLocalisation( $cache );
1677 $cache = self
::$mLocalisationCache[$cache];
1680 foreach ( $cache['deps'] as $file => $mtime ) {
1681 if ( !file_exists( $file ) ||
filemtime( $file ) > $mtime ) {
1690 * Get the fallback for a given language
1692 static function getFallbackFor( $code ) {
1693 self
::loadLocalisation( $code );
1694 return self
::$mLocalisationCache[$code]['fallback'];
1698 * Get all messages for a given language
1700 static function getMessagesFor( $code ) {
1701 self
::loadLocalisation( $code );
1702 return self
::$mLocalisationCache[$code]['messages'];
1706 * Get a message for a given language
1708 static function getMessageFor( $key, $code ) {
1709 self
::loadLocalisation( $code );
1710 return isset( self
::$mLocalisationCache[$code]['messages'][$key] ) ? self
::$mLocalisationCache[$code]['messages'][$key] : null;
1714 * Load localisation data for this object
1717 if ( !$this->mLoaded
) {
1718 self
::loadLocalisation( $this->getCode() );
1719 $cache =& self
::$mLocalisationCache[$this->getCode()];
1720 foreach ( self
::$mLocalisationKeys as $key ) {
1721 $this->$key = $cache[$key];
1723 $this->mLoaded
= true;
1725 $this->fixUpSettings();
1730 * Do any necessary post-cache-load settings adjustment
1732 function fixUpSettings() {
1733 global $wgExtraNamespaces, $wgMetaNamespace, $wgMetaNamespaceTalk,
1734 $wgNamespaceAliases, $wgAmericanDates;
1735 wfProfileIn( __METHOD__
);
1736 if ( $wgExtraNamespaces ) {
1737 $this->namespaceNames
= $wgExtraNamespaces +
$this->namespaceNames
;
1740 $this->namespaceNames
[NS_PROJECT
] = $wgMetaNamespace;
1741 if ( $wgMetaNamespaceTalk ) {
1742 $this->namespaceNames
[NS_PROJECT_TALK
] = $wgMetaNamespaceTalk;
1744 $talk = $this->namespaceNames
[NS_PROJECT_TALK
];
1745 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
1747 # Allow grammar transformations
1748 # Allowing full message-style parsing would make simple requests
1749 # such as action=raw much more expensive than they need to be.
1750 # This will hopefully cover most cases.
1751 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
1752 array( &$this, 'replaceGrammarInNamespace' ), $talk );
1753 $talk = str_replace( ' ', '_', $talk );
1754 $this->namespaceNames
[NS_PROJECT_TALK
] = $talk;
1757 # The above mixing may leave namespaces out of canonical order.
1758 # Re-order by namespace ID number...
1759 ksort( $this->namespaceNames
);
1761 # Put namespace names and aliases into a hashtable.
1762 # If this is too slow, then we should arrange it so that it is done
1763 # before caching. The catch is that at pre-cache time, the above
1764 # class-specific fixup hasn't been done.
1765 $this->mNamespaceIds
= array();
1766 foreach ( $this->namespaceNames
as $index => $name ) {
1767 $this->mNamespaceIds
[$this->lc($name)] = $index;
1769 if ( $this->namespaceAliases
) {
1770 foreach ( $this->namespaceAliases
as $name => $index ) {
1771 $this->mNamespaceIds
[$this->lc($name)] = $index;
1774 if ( $wgNamespaceAliases ) {
1775 foreach ( $wgNamespaceAliases as $name => $index ) {
1776 $this->mNamespaceIds
[$this->lc($name)] = $index;
1780 if ( $this->defaultDateFormat
== 'dmy or mdy' ) {
1781 $this->defaultDateFormat
= $wgAmericanDates ?
'mdy' : 'dmy';
1783 wfProfileOut( __METHOD__
);
1786 function replaceGrammarInNamespace( $m ) {
1787 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
1790 static function getCaseMaps() {
1791 static $wikiUpperChars, $wikiLowerChars;
1792 if ( isset( $wikiUpperChars ) ) {
1793 return array( $wikiUpperChars, $wikiLowerChars );
1796 wfProfileIn( __METHOD__
);
1797 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
1798 if ( $arr === false ) {
1799 throw new MWException(
1800 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
1803 wfProfileOut( __METHOD__
);
1804 return array( $wikiUpperChars, $wikiLowerChars );