dépôts / lhc / web / wiklou.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
* (bug 5477) Searches for words less than 4 characters now work without
[lhc/web/wiklou.git] / languages / Language.php
1 <?php
2 /**
3 * @defgroup Language Language
4 *
5 * @file
6 * @ingroup Language
7 */
8
9 if( !defined( 'MEDIAWIKI' ) ) {
10 echo "This file is part of MediaWiki, it is not a valid entry point.\n";
11 exit( 1 );
12 }
13
14 # Read language names
15 global $wgLanguageNames;
16 require_once( dirname(__FILE__) . '/Names.php' ) ;
17
18 global $wgInputEncoding, $wgOutputEncoding;
19
20 /**
21 * These are always UTF-8, they exist only for backwards compatibility
22 */
23 $wgInputEncoding = "UTF-8";
24 $wgOutputEncoding = "UTF-8";
25
26 if( function_exists( 'mb_strtoupper' ) ) {
27 mb_internal_encoding('UTF-8');
28 }
29
30 /**
31 * a fake language converter
32 *
33 * @ingroup Language
34 */
35 class FakeConverter {
36 var $mLang;
37 function FakeConverter($langobj) {$this->mLang = $langobj;}
38 function convert($t, $i) {return $t;}
39 function parserConvert($t, $p) {return $t;}
40 function getVariants() { return array( $this->mLang->getCode() ); }
41 function getPreferredVariant() {return $this->mLang->getCode(); }
42 function findVariantLink(&$l, &$n, $forTemplate = false) {}
43 function getExtraHashOptions() {return '';}
44 function getParsedTitle() {return '';}
45 function markNoConversion($text, $noParse=false) {return $text;}
46 function convertCategoryKey( $key ) {return $key; }
47 function convertLinkToAllVariants($text){ return array( $this->mLang->getCode() => $text); }
48 function armourMath($text){ return $text; }
49 }
50
51 /**
52 * Internationalisation code
53 * @ingroup Language
54 */
55 class Language {
56 var $mConverter, $mVariants, $mCode, $mLoaded = false;
57 var $mMagicExtensions = array(), $mMagicHookDone = false;
58
59 static public $mLocalisationKeys = array( 'fallback', 'namespaceNames',
60 'skinNames', 'mathNames',
61 'bookstoreList', 'magicWords', 'messages', 'rtl', 'digitTransformTable',
62 'separatorTransformTable', 'fallback8bitEncoding', 'linkPrefixExtension',
63 'defaultUserOptionOverrides', 'linkTrail', 'namespaceAliases',
64 'dateFormats', 'datePreferences', 'datePreferenceMigrationMap',
65 'defaultDateFormat', 'extraUserToggles', 'specialPageAliases',
66 'imageFiles'
67 );
68
69 static public $mMergeableMapKeys = array( 'messages', 'namespaceNames', 'mathNames',
70 'dateFormats', 'defaultUserOptionOverrides', 'magicWords', 'imageFiles' );
71
72 static public $mMergeableListKeys = array( 'extraUserToggles' );
73
74 static public $mMergeableAliasListKeys = array( 'specialPageAliases' );
75
76 static public $mLocalisationCache = array();
77 static public $mLangObjCache = array();
78
79 static public $mWeekdayMsgs = array(
80 'sunday', 'monday', 'tuesday', 'wednesday', 'thursday',
81 'friday', 'saturday'
82 );
83
84 static public $mWeekdayAbbrevMsgs = array(
85 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'
86 );
87
88 static public $mMonthMsgs = array(
89 'january', 'february', 'march', 'april', 'may_long', 'june',
90 'july', 'august', 'september', 'october', 'november',
91 'december'
92 );
93 static public $mMonthGenMsgs = array(
94 'january-gen', 'february-gen', 'march-gen', 'april-gen', 'may-gen', 'june-gen',
95 'july-gen', 'august-gen', 'september-gen', 'october-gen', 'november-gen',
96 'december-gen'
97 );
98 static public $mMonthAbbrevMsgs = array(
99 'jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug',
100 'sep', 'oct', 'nov', 'dec'
101 );
102
103 static public $mIranianCalendarMonthMsgs = array(
104 'iranian-calendar-m1', 'iranian-calendar-m2', 'iranian-calendar-m3',
105 'iranian-calendar-m4', 'iranian-calendar-m5', 'iranian-calendar-m6',
106 'iranian-calendar-m7', 'iranian-calendar-m8', 'iranian-calendar-m9',
107 'iranian-calendar-m10', 'iranian-calendar-m11', 'iranian-calendar-m12'
108 );
109
110 static public $mHebrewCalendarMonthMsgs = array(
111 'hebrew-calendar-m1', 'hebrew-calendar-m2', 'hebrew-calendar-m3',
112 'hebrew-calendar-m4', 'hebrew-calendar-m5', 'hebrew-calendar-m6',
113 'hebrew-calendar-m7', 'hebrew-calendar-m8', 'hebrew-calendar-m9',
114 'hebrew-calendar-m10', 'hebrew-calendar-m11', 'hebrew-calendar-m12',
115 'hebrew-calendar-m6a', 'hebrew-calendar-m6b'
116 );
117
118 static public $mHebrewCalendarMonthGenMsgs = array(
119 'hebrew-calendar-m1-gen', 'hebrew-calendar-m2-gen', 'hebrew-calendar-m3-gen',
120 'hebrew-calendar-m4-gen', 'hebrew-calendar-m5-gen', 'hebrew-calendar-m6-gen',
121 'hebrew-calendar-m7-gen', 'hebrew-calendar-m8-gen', 'hebrew-calendar-m9-gen',
122 'hebrew-calendar-m10-gen', 'hebrew-calendar-m11-gen', 'hebrew-calendar-m12-gen',
123 'hebrew-calendar-m6a-gen', 'hebrew-calendar-m6b-gen'
124 );
125
126 static public $mHijriCalendarMonthMsgs = array(
127 'hijri-calendar-m1', 'hijri-calendar-m2', 'hijri-calendar-m3',
128 'hijri-calendar-m4', 'hijri-calendar-m5', 'hijri-calendar-m6',
129 'hijri-calendar-m7', 'hijri-calendar-m8', 'hijri-calendar-m9',
130 'hijri-calendar-m10', 'hijri-calendar-m11', 'hijri-calendar-m12'
131 );
132
133 /**
134 * Get a cached language object for a given language code
135 */
136 static function factory( $code ) {
137 if ( !isset( self::$mLangObjCache[$code] ) ) {
138 self::$mLangObjCache[$code] = self::newFromCode( $code );
139 }
140 return self::$mLangObjCache[$code];
141 }
142
143 /**
144 * Create a language object for a given language code
145 */
146 protected static function newFromCode( $code ) {
147 global $IP;
148 static $recursionLevel = 0;
149 if ( $code == 'en' ) {
150 $class = 'Language';
151 } else {
152 $class = 'Language' . str_replace( '-', '_', ucfirst( $code ) );
153 // Preload base classes to work around APC/PHP5 bug
154 if ( file_exists( "$IP/languages/classes/$class.deps.php" ) ) {
155 include_once("$IP/languages/classes/$class.deps.php");
156 }
157 if ( file_exists( "$IP/languages/classes/$class.php" ) ) {
158 include_once("$IP/languages/classes/$class.php");
159 }
160 }
161
162 if ( $recursionLevel > 5 ) {
163 throw new MWException( "Language fallback loop detected when creating class $class\n" );
164 }
165
166 if( ! class_exists( $class ) ) {
167 $fallback = Language::getFallbackFor( $code );
168 ++$recursionLevel;
169 $lang = Language::newFromCode( $fallback );
170 --$recursionLevel;
171 $lang->setCode( $code );
172 } else {
173 $lang = new $class;
174 }
175 return $lang;
176 }
177
178 function __construct() {
179 $this->mConverter = new FakeConverter($this);
180 // Set the code to the name of the descendant
181 if ( get_class( $this ) == 'Language' ) {
182 $this->mCode = 'en';
183 } else {
184 $this->mCode = str_replace( '_', '-', strtolower( substr( get_class( $this ), 8 ) ) );
185 }
186 }
187
188 /**
189 * Reduce memory usage
190 */
191 function __destruct() {
192 foreach ( $this as $name => $value ) {
193 unset( $this->$name );
194 }
195 }
196
197 /**
198 * Hook which will be called if this is the content language.
199 * Descendants can use this to register hook functions or modify globals
200 */
201 function initContLang() {}
202
203 /**
204 * @deprecated Use User::getDefaultOptions()
205 * @return array
206 */
207 function getDefaultUserOptions() {
208 wfDeprecated( __METHOD__ );
209 return User::getDefaultOptions();
210 }
211
212 function getFallbackLanguageCode() {
213 return self::getFallbackFor( $this->mCode );
214 }
215
216 /**
217 * Exports $wgBookstoreListEn
218 * @return array
219 */
220 function getBookstoreList() {
221 $this->load();
222 return $this->bookstoreList;
223 }
224
225 /**
226 * @return array
227 */
228 function getNamespaces() {
229 $this->load();
230 return $this->namespaceNames;
231 }
232
233 /**
234 * A convenience function that returns the same thing as
235 * getNamespaces() except with the array values changed to ' '
236 * where it found '_', useful for producing output to be displayed
237 * e.g. in <select> forms.
238 *
239 * @return array
240 */
241 function getFormattedNamespaces() {
242 $ns = $this->getNamespaces();
243 foreach($ns as $k => $v) {
244 $ns[$k] = strtr($v, '_', ' ');
245 }
246 return $ns;
247 }
248
249 /**
250 * Get a namespace value by key
251 * <code>
252 * $mw_ns = $wgContLang->getNsText( NS_MEDIAWIKI );
253 * echo $mw_ns; // prints 'MediaWiki'
254 * </code>
255 *
256 * @param $index Int: the array key of the namespace to return
257 * @return mixed, string if the namespace value exists, otherwise false
258 */
259 function getNsText( $index ) {
260 $ns = $this->getNamespaces();
261 return isset( $ns[$index] ) ? $ns[$index] : false;
262 }
263
264 /**
265 * A convenience function that returns the same thing as
266 * getNsText() except with '_' changed to ' ', useful for
267 * producing output.
268 *
269 * @return array
270 */
271 function getFormattedNsText( $index ) {
272 $ns = $this->getNsText( $index );
273 return strtr($ns, '_', ' ');
274 }
275
276 /**
277 * Get a namespace key by value, case insensitive.
278 * Only matches namespace names for the current language, not the
279 * canonical ones defined in Namespace.php.
280 *
281 * @param $text String
282 * @return mixed An integer if $text is a valid value otherwise false
283 */
284 function getLocalNsIndex( $text ) {
285 $this->load();
286 $lctext = $this->lc($text);
287 return isset( $this->mNamespaceIds[$lctext] ) ? $this->mNamespaceIds[$lctext] : false;
288 }
289
290 /**
291 * Get a namespace key by value, case insensitive. Canonical namespace
292 * names override custom ones defined for the current language.
293 *
294 * @param $text String
295 * @return mixed An integer if $text is a valid value otherwise false
296 */
297 function getNsIndex( $text ) {
298 $this->load();
299 $lctext = $this->lc($text);
300 if( ( $ns = MWNamespace::getCanonicalIndex( $lctext ) ) !== null ) return $ns;
301 return isset( $this->mNamespaceIds[$lctext] ) ? $this->mNamespaceIds[$lctext] : false;
302 }
303
304 /**
305 * short names for language variants used for language conversion links.
306 *
307 * @param $code String
308 * @return string
309 */
310 function getVariantname( $code ) {
311 return $this->getMessageFromDB( "variantname-$code" );
312 }
313
314 function specialPage( $name ) {
315 $aliases = $this->getSpecialPageAliases();
316 if ( isset( $aliases[$name][0] ) ) {
317 $name = $aliases[$name][0];
318 }
319 return $this->getNsText(NS_SPECIAL) . ':' . $name;
320 }
321
322 function getQuickbarSettings() {
323 return array(
324 $this->getMessage( 'qbsettings-none' ),
325 $this->getMessage( 'qbsettings-fixedleft' ),
326 $this->getMessage( 'qbsettings-fixedright' ),
327 $this->getMessage( 'qbsettings-floatingleft' ),
328 $this->getMessage( 'qbsettings-floatingright' )
329 );
330 }
331
332 function getSkinNames() {
333 $this->load();
334 return $this->skinNames;
335 }
336
337 function getMathNames() {
338 $this->load();
339 return $this->mathNames;
340 }
341
342 function getDatePreferences() {
343 $this->load();
344 return $this->datePreferences;
345 }
346
347 function getDateFormats() {
348 $this->load();
349 return $this->dateFormats;
350 }
351
352 function getDefaultDateFormat() {
353 $this->load();
354 return $this->defaultDateFormat;
355 }
356
357 function getDatePreferenceMigrationMap() {
358 $this->load();
359 return $this->datePreferenceMigrationMap;
360 }
361
362 function getImageFile( $image ) {
363 $this->load();
364 return $this->imageFiles[$image];
365 }
366
367 function getDefaultUserOptionOverrides() {
368 $this->load();
369 # XXX - apparently some languageas get empty arrays, didn't get to it yet -- midom
370 if (is_array($this->defaultUserOptionOverrides)) {
371 return $this->defaultUserOptionOverrides;
372 } else {
373 return array();
374 }
375 }
376
377 function getExtraUserToggles() {
378 $this->load();
379 return $this->extraUserToggles;
380 }
381
382 function getUserToggle( $tog ) {
383 return $this->getMessageFromDB( "tog-$tog" );
384 }
385
386 /**
387 * Get language names, indexed by code.
388 * If $customisedOnly is true, only returns codes with a messages file
389 */
390 public static function getLanguageNames( $customisedOnly = false ) {
391 global $wgLanguageNames, $wgExtraLanguageNames;
392 $allNames = $wgExtraLanguageNames + $wgLanguageNames;
393 if ( !$customisedOnly ) {
394 return $allNames;
395 }
396
397 global $IP;
398 $names = array();
399 $dir = opendir( "$IP/languages/messages" );
400 while( false !== ( $file = readdir( $dir ) ) ) {
401 $m = array();
402 if( preg_match( '/Messages([A-Z][a-z_]+)\.php$/', $file, $m ) ) {
403 $code = str_replace( '_', '-', strtolower( $m[1] ) );
404 if ( isset( $allNames[$code] ) ) {
405 $names[$code] = $allNames[$code];
406 }
407 }
408 }
409 closedir( $dir );
410 return $names;
411 }
412
413 /**
414 * Get a message from the MediaWiki namespace.
415 *
416 * @param $msg String: message name
417 * @return string
418 */
419 function getMessageFromDB( $msg ) {
420 return wfMsgExt( $msg, array( 'parsemag', 'language' => $this ) );
421 }
422
423 function getLanguageName( $code ) {
424 $names = self::getLanguageNames();
425 if ( !array_key_exists( $code, $names ) ) {
426 return '';
427 }
428 return $names[$code];
429 }
430
431 function getMonthName( $key ) {
432 return $this->getMessageFromDB( self::$mMonthMsgs[$key-1] );
433 }
434
435 function getMonthNameGen( $key ) {
436 return $this->getMessageFromDB( self::$mMonthGenMsgs[$key-1] );
437 }
438
439 function getMonthAbbreviation( $key ) {
440 return $this->getMessageFromDB( self::$mMonthAbbrevMsgs[$key-1] );
441 }
442
443 function getWeekdayName( $key ) {
444 return $this->getMessageFromDB( self::$mWeekdayMsgs[$key-1] );
445 }
446
447 function getWeekdayAbbreviation( $key ) {
448 return $this->getMessageFromDB( self::$mWeekdayAbbrevMsgs[$key-1] );
449 }
450
451 function getIranianCalendarMonthName( $key ) {
452 return $this->getMessageFromDB( self::$mIranianCalendarMonthMsgs[$key-1] );
453 }
454
455 function getHebrewCalendarMonthName( $key ) {
456 return $this->getMessageFromDB( self::$mHebrewCalendarMonthMsgs[$key-1] );
457 }
458
459 function getHebrewCalendarMonthNameGen( $key ) {
460 return $this->getMessageFromDB( self::$mHebrewCalendarMonthGenMsgs[$key-1] );
461 }
462
463 function getHijriCalendarMonthName( $key ) {
464 return $this->getMessageFromDB( self::$mHijriCalendarMonthMsgs[$key-1] );
465 }
466
467 /**
468 * Used by date() and time() to adjust the time output.
469 *
470 * @param $ts Int the time in date('YmdHis') format
471 * @param $tz Mixed: adjust the time by this amount (default false, mean we
472 * get user timecorrection setting)
473 * @return int
474 */
475 function userAdjust( $ts, $tz = false ) {
476 global $wgUser, $wgLocalTZoffset;
477
478 if (!$tz) {
479 $tz = $wgUser->getOption( 'timecorrection' );
480 }
481
482 # minutes and hours differences:
483 $minDiff = 0;
484 $hrDiff = 0;
485
486 if ( $tz === '' ) {
487 # Global offset in minutes.
488 if( isset($wgLocalTZoffset) ) {
489 if( $wgLocalTZoffset >= 0 ) {
490 $hrDiff = floor($wgLocalTZoffset / 60);
491 } else {
492 $hrDiff = ceil($wgLocalTZoffset / 60);
493 }
494 $minDiff = $wgLocalTZoffset % 60;
495 }
496 } elseif ( strpos( $tz, ':' ) !== false ) {
497 $tzArray = explode( ':', $tz );
498 $hrDiff = intval($tzArray[0]);
499 $minDiff = intval($hrDiff < 0 ? -$tzArray[1] : $tzArray[1]);
500 } else {
501 $hrDiff = intval( $tz );
502 }
503
504 # No difference ? Return time unchanged
505 if ( 0 == $hrDiff && 0 == $minDiff ) { return $ts; }
506
507 wfSuppressWarnings(); // E_STRICT system time bitching
508 # Generate an adjusted date
509 $t = mktime( (
510 (int)substr( $ts, 8, 2) ) + $hrDiff, # Hours
511 (int)substr( $ts, 10, 2 ) + $minDiff, # Minutes
512 (int)substr( $ts, 12, 2 ), # Seconds
513 (int)substr( $ts, 4, 2 ), # Month
514 (int)substr( $ts, 6, 2 ), # Day
515 (int)substr( $ts, 0, 4 ) ); #Year
516
517 $date = date( 'YmdHis', $t );
518 wfRestoreWarnings();
519
520 return $date;
521 }
522
523 /**
524 * This is a workalike of PHP's date() function, but with better
525 * internationalisation, a reduced set of format characters, and a better
526 * escaping format.
527 *
528 * Supported format characters are dDjlNwzWFmMntLYyaAgGhHiscrU. See the
529 * PHP manual for definitions. There are a number of extensions, which
530 * start with "x":
531 *
532 * xn Do not translate digits of the next numeric format character
533 * xN Toggle raw digit (xn) flag, stays set until explicitly unset
534 * xr Use roman numerals for the next numeric format character
535 * xh Use hebrew numerals for the next numeric format character
536 * xx Literal x
537 * xg Genitive month name
538 *
539 * xij j (day number) in Iranian calendar
540 * xiF F (month name) in Iranian calendar
541 * xin n (month number) in Iranian calendar
542 * xiY Y (full year) in Iranian calendar
543 *
544 * xjj j (day number) in Hebrew calendar
545 * xjF F (month name) in Hebrew calendar
546 * xjt t (days in month) in Hebrew calendar
547 * xjx xg (genitive month name) in Hebrew calendar
548 * xjn n (month number) in Hebrew calendar
549 * xjY Y (full year) in Hebrew calendar
550 *
551 * xmj j (day number) in Hijri calendar
552 * xmF F (month name) in Hijri calendar
553 * xmn n (month number) in Hijri calendar
554 * xmY Y (full year) in Hijri calendar
555 *
556 * xkY Y (full year) in Thai solar calendar. Months and days are
557 * identical to the Gregorian calendar
558 *
559 * Characters enclosed in double quotes will be considered literal (with
560 * the quotes themselves removed). Unmatched quotes will be considered
561 * literal quotes. Example:
562 *
563 * "The month is" F => The month is January
564 * i's" => 20'11"
565 *
566 * Backslash escaping is also supported.
567 *
568 * Input timestamp is assumed to be pre-normalized to the desired local
569 * time zone, if any.
570 *
571 * @param $format String
572 * @param $ts String: 14-character timestamp
573 * YYYYMMDDHHMMSS
574 * 01234567890123
575 */
576 function sprintfDate( $format, $ts ) {
577 $s = '';
578 $raw = false;
579 $roman = false;
580 $hebrewNum = false;
581 $unix = false;
582 $rawToggle = false;
583 $iranian = false;
584 $hebrew = false;
585 $hijri = false;
586 $thai = false;
587 for ( $p = 0; $p < strlen( $format ); $p++ ) {
588 $num = false;
589 $code = $format[$p];
590 if ( $code == 'x' && $p < strlen( $format ) - 1 ) {
591 $code .= $format[++$p];
592 }
593
594 if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' || $code == 'xm' ) && $p < strlen( $format ) - 1 ) {
595 $code .= $format[++$p];
596 }
597
598 switch ( $code ) {
599 case 'xx':
600 $s .= 'x';
601 break;
602 case 'xn':
603 $raw = true;
604 break;
605 case 'xN':
606 $rawToggle = !$rawToggle;
607 break;
608 case 'xr':
609 $roman = true;
610 break;
611 case 'xh':
612 $hebrewNum = true;
613 break;
614 case 'xg':
615 $s .= $this->getMonthNameGen( substr( $ts, 4, 2 ) );
616 break;
617 case 'xjx':
618 if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
619 $s .= $this->getHebrewCalendarMonthNameGen( $hebrew[1] );
620 break;
621 case 'd':
622 $num = substr( $ts, 6, 2 );
623 break;
624 case 'D':
625 if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
626 $s .= $this->getWeekdayAbbreviation( gmdate( 'w', $unix ) + 1 );
627 break;
628 case 'j':
629 $num = intval( substr( $ts, 6, 2 ) );
630 break;
631 case 'xij':
632 if ( !$iranian ) $iranian = self::tsToIranian( $ts );
633 $num = $iranian[2];
634 break;
635 case 'xmj':
636 if ( !$hijri ) $hijri = self::tsToHijri( $ts );
637 $num = $hijri[2];
638 break;
639 case 'xjj':
640 if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
641 $num = $hebrew[2];
642 break;
643 case 'l':
644 if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
645 $s .= $this->getWeekdayName( gmdate( 'w', $unix ) + 1 );
646 break;
647 case 'N':
648 if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
649 $w = gmdate( 'w', $unix );
650 $num = $w ? $w : 7;
651 break;
652 case 'w':
653 if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
654 $num = gmdate( 'w', $unix );
655 break;
656 case 'z':
657 if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
658 $num = gmdate( 'z', $unix );
659 break;
660 case 'W':
661 if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
662 $num = gmdate( 'W', $unix );
663 break;
664 case 'F':
665 $s .= $this->getMonthName( substr( $ts, 4, 2 ) );
666 break;
667 case 'xiF':
668 if ( !$iranian ) $iranian = self::tsToIranian( $ts );
669 $s .= $this->getIranianCalendarMonthName( $iranian[1] );
670 break;
671 case 'xmF':
672 if ( !$hijri ) $hijri = self::tsToHijri( $ts );
673 $s .= $this->getHijriCalendarMonthName( $hijri[1] );
674 break;
675 case 'xjF':
676 if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
677 $s .= $this->getHebrewCalendarMonthName( $hebrew[1] );
678 break;
679 case 'm':
680 $num = substr( $ts, 4, 2 );
681 break;
682 case 'M':
683 $s .= $this->getMonthAbbreviation( substr( $ts, 4, 2 ) );
684 break;
685 case 'n':
686 $num = intval( substr( $ts, 4, 2 ) );
687 break;
688 case 'xin':
689 if ( !$iranian ) $iranian = self::tsToIranian( $ts );
690 $num = $iranian[1];
691 break;
692 case 'xmn':
693 if ( !$hijri ) $hijri = self::tsToHijri ( $ts );
694 $num = $hijri[1];
695 break;
696 case 'xjn':
697 if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
698 $num = $hebrew[1];
699 break;
700 case 't':
701 if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
702 $num = gmdate( 't', $unix );
703 break;
704 case 'xjt':
705 if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
706 $num = $hebrew[3];
707 break;
708 case 'L':
709 if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
710 $num = gmdate( 'L', $unix );
711 break;
712 case 'Y':
713 $num = substr( $ts, 0, 4 );
714 break;
715 case 'xiY':
716 if ( !$iranian ) $iranian = self::tsToIranian( $ts );
717 $num = $iranian[0];
718 break;
719 case 'xmY':
720 if ( !$hijri ) $hijri = self::tsToHijri( $ts );
721 $num = $hijri[0];
722 break;
723 case 'xjY':
724 if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
725 $num = $hebrew[0];
726 break;
727 case 'xkY':
728 if ( !$thai ) $thai = self::tsToThai( $ts );
729 $num = $thai[0];
730 break;
731 case 'y':
732 $num = substr( $ts, 2, 2 );
733 break;
734 case 'a':
735 $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'am' : 'pm';
736 break;
737 case 'A':
738 $s .= intval( substr( $ts, 8, 2 ) ) < 12 ? 'AM' : 'PM';
739 break;
740 case 'g':
741 $h = substr( $ts, 8, 2 );
742 $num = $h % 12 ? $h % 12 : 12;
743 break;
744 case 'G':
745 $num = intval( substr( $ts, 8, 2 ) );
746 break;
747 case 'h':
748 $h = substr( $ts, 8, 2 );
749 $num = sprintf( '%02d', $h % 12 ? $h % 12 : 12 );
750 break;
751 case 'H':
752 $num = substr( $ts, 8, 2 );
753 break;
754 case 'i':
755 $num = substr( $ts, 10, 2 );
756 break;
757 case 's':
758 $num = substr( $ts, 12, 2 );
759 break;
760 case 'c':
761 if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
762 $s .= gmdate( 'c', $unix );
763 break;
764 case 'r':
765 if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
766 $s .= gmdate( 'r', $unix );
767 break;
768 case 'U':
769 if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
770 $num = $unix;
771 break;
772 case '\\':
773 # Backslash escaping
774 if ( $p < strlen( $format ) - 1 ) {
775 $s .= $format[++$p];
776 } else {
777 $s .= '\\';
778 }
779 break;
780 case '"':
781 # Quoted literal
782 if ( $p < strlen( $format ) - 1 ) {
783 $endQuote = strpos( $format, '"', $p + 1 );
784 if ( $endQuote === false ) {
785 # No terminating quote, assume literal "
786 $s .= '"';
787 } else {
788 $s .= substr( $format, $p + 1, $endQuote - $p - 1 );
789 $p = $endQuote;
790 }
791 } else {
792 # Quote at end of string, assume literal "
793 $s .= '"';
794 }
795 break;
796 default:
797 $s .= $format[$p];
798 }
799 if ( $num !== false ) {
800 if ( $rawToggle || $raw ) {
801 $s .= $num;
802 $raw = false;
803 } elseif ( $roman ) {
804 $s .= self::romanNumeral( $num );
805 $roman = false;
806 } elseif( $hebrewNum ) {
807 $s .= self::hebrewNumeral( $num );
808 $hebrewNum = false;
809 } else {
810 $s .= $this->formatNum( $num, true );
811 }
812 $num = false;
813 }
814 }
815 return $s;
816 }
817
818 private static $GREG_DAYS = array( 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 );
819 private static $IRANIAN_DAYS = array( 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29 );
820 /**
821 * Algorithm by Roozbeh Pournader and Mohammad Toossi to convert
822 * Gregorian dates to Iranian dates. Originally written in C, it
823 * is released under the terms of GNU Lesser General Public
824 * License. Conversion to PHP was performed by Niklas Laxström.
825 *
826 * Link: http://www.farsiweb.info/jalali/jalali.c
827 */
828 private static function tsToIranian( $ts ) {
829 $gy = substr( $ts, 0, 4 ) -1600;
830 $gm = substr( $ts, 4, 2 ) -1;
831 $gd = substr( $ts, 6, 2 ) -1;
832
833 # Days passed from the beginning (including leap years)
834 $gDayNo = 365*$gy
835 + floor(($gy+3) / 4)
836 - floor(($gy+99) / 100)
837 + floor(($gy+399) / 400);
838
839
840 // Add days of the past months of this year
841 for( $i = 0; $i < $gm; $i++ ) {
842 $gDayNo += self::$GREG_DAYS[$i];
843 }
844
845 // Leap years
846 if ( $gm > 1 && (($gy%4===0 && $gy%100!==0 || ($gy%400==0)))) {
847 $gDayNo++;
848 }
849
850 // Days passed in current month
851 $gDayNo += $gd;
852
853 $jDayNo = $gDayNo - 79;
854
855 $jNp = floor($jDayNo / 12053);
856 $jDayNo %= 12053;
857
858 $jy = 979 + 33*$jNp + 4*floor($jDayNo/1461);
859 $jDayNo %= 1461;
860
861 if ( $jDayNo >= 366 ) {
862 $jy += floor(($jDayNo-1)/365);
863 $jDayNo = floor(($jDayNo-1)%365);
864 }
865
866 for ( $i = 0; $i < 11 && $jDayNo >= self::$IRANIAN_DAYS[$i]; $i++ ) {
867 $jDayNo -= self::$IRANIAN_DAYS[$i];
868 }
869
870 $jm= $i+1;
871 $jd= $jDayNo+1;
872
873 return array($jy, $jm, $jd);
874 }
875 /**
876 * Converting Gregorian dates to Hijri dates.
877 *
878 * Based on a PHP-Nuke block by Sharjeel which is released under GNU/GPL license
879 *
880 * @link http://phpnuke.org/modules.php?name=News&file=article&sid=8234&mode=thread&order=0&thold=0
881 */
882 private static function tsToHijri ( $ts ) {
883 $year = substr( $ts, 0, 4 );
884 $month = substr( $ts, 4, 2 );
885 $day = substr( $ts, 6, 2 );
886
887 $zyr = $year;
888 $zd=$day;
889 $zm=$month;
890 $zy=$zyr;
891
892
893
894 if (($zy>1582)||(($zy==1582)&&($zm>10))||(($zy==1582)&&($zm==10)&&($zd>14)))
895 {
896
897
898 $zjd=(int)((1461*($zy + 4800 + (int)( ($zm-14) /12) ))/4) + (int)((367*($zm-2-12*((int)(($zm-14)/12))))/12)-(int)((3*(int)(( ($zy+4900+(int)(($zm-14)/12))/100)))/4)+$zd-32075;
899 }
900 else
901 {
902 $zjd = 367*$zy-(int)((7*($zy+5001+(int)(($zm-9)/7)))/4)+(int)((275*$zm)/9)+$zd+1729777;
903 }
904
905 $zl=$zjd-1948440+10632;
906 $zn=(int)(($zl-1)/10631);
907 $zl=$zl-10631*$zn+354;
908 $zj=((int)((10985-$zl)/5316))*((int)((50*$zl)/17719))+((int)($zl/5670))*((int)((43*$zl)/15238));
909 $zl=$zl-((int)((30-$zj)/15))*((int)((17719*$zj)/50))-((int)($zj/16))*((int)((15238*$zj)/43))+29;
910 $zm=(int)((24*$zl)/709);
911 $zd=$zl-(int)((709*$zm)/24);
912 $zy=30*$zn+$zj-30;
913
914 return array ($zy, $zm, $zd);
915 }
916
917 /**
918 * Converting Gregorian dates to Hebrew dates.
919 *
920 * Based on a JavaScript code by Abu Mami and Yisrael Hersch
921 * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
922 * to translate the relevant functions into PHP and release them under
923 * GNU GPL.
924 *
925 * The months are counted from Tishrei = 1. In a leap year, Adar I is 13
926 * and Adar II is 14. In a non-leap year, Adar is 6.
927 */
928 private static function tsToHebrew( $ts ) {
929 # Parse date
930 $year = substr( $ts, 0, 4 );
931 $month = substr( $ts, 4, 2 );
932 $day = substr( $ts, 6, 2 );
933
934 # Calculate Hebrew year
935 $hebrewYear = $year + 3760;
936
937 # Month number when September = 1, August = 12
938 $month += 4;
939 if( $month > 12 ) {
940 # Next year
941 $month -= 12;
942 $year++;
943 $hebrewYear++;
944 }
945
946 # Calculate day of year from 1 September
947 $dayOfYear = $day;
948 for( $i = 1; $i < $month; $i++ ) {
949 if( $i == 6 ) {
950 # February
951 $dayOfYear += 28;
952 # Check if the year is leap
953 if( $year % 400 == 0 || ( $year % 4 == 0 && $year % 100 > 0 ) ) {
954 $dayOfYear++;
955 }
956 } elseif( $i == 8 || $i == 10 || $i == 1 || $i == 3 ) {
957 $dayOfYear += 30;
958 } else {
959 $dayOfYear += 31;
960 }
961 }
962
963 # Calculate the start of the Hebrew year
964 $start = self::hebrewYearStart( $hebrewYear );
965
966 # Calculate next year's start
967 if( $dayOfYear <= $start ) {
968 # Day is before the start of the year - it is the previous year
969 # Next year's start
970 $nextStart = $start;
971 # Previous year
972 $year--;
973 $hebrewYear--;
974 # Add days since previous year's 1 September
975 $dayOfYear += 365;
976 if( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
977 # Leap year
978 $dayOfYear++;
979 }
980 # Start of the new (previous) year
981 $start = self::hebrewYearStart( $hebrewYear );
982 } else {
983 # Next year's start
984 $nextStart = self::hebrewYearStart( $hebrewYear + 1 );
985 }
986
987 # Calculate Hebrew day of year
988 $hebrewDayOfYear = $dayOfYear - $start;
989
990 # Difference between year's days
991 $diff = $nextStart - $start;
992 # Add 12 (or 13 for leap years) days to ignore the difference between
993 # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
994 # difference is only about the year type
995 if( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
996 $diff += 13;
997 } else {
998 $diff += 12;
999 }
1000
1001 # Check the year pattern, and is leap year
1002 # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
1003 # This is mod 30, to work on both leap years (which add 30 days of Adar I)
1004 # and non-leap years
1005 $yearPattern = $diff % 30;
1006 # Check if leap year
1007 $isLeap = $diff >= 30;
1008
1009 # Calculate day in the month from number of day in the Hebrew year
1010 # Don't check Adar - if the day is not in Adar, we will stop before;
1011 # if it is in Adar, we will use it to check if it is Adar I or Adar II
1012 $hebrewDay = $hebrewDayOfYear;
1013 $hebrewMonth = 1;
1014 $days = 0;
1015 while( $hebrewMonth <= 12 ) {
1016 # Calculate days in this month
1017 if( $isLeap && $hebrewMonth == 6 ) {
1018 # Adar in a leap year
1019 if( $isLeap ) {
1020 # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
1021 $days = 30;
1022 if( $hebrewDay <= $days ) {
1023 # Day in Adar I
1024 $hebrewMonth = 13;
1025 } else {
1026 # Subtract the days of Adar I
1027 $hebrewDay -= $days;
1028 # Try Adar II
1029 $days = 29;
1030 if( $hebrewDay <= $days ) {
1031 # Day in Adar II
1032 $hebrewMonth = 14;
1033 }
1034 }
1035 }
1036 } elseif( $hebrewMonth == 2 && $yearPattern == 2 ) {
1037 # Cheshvan in a complete year (otherwise as the rule below)
1038 $days = 30;
1039 } elseif( $hebrewMonth == 3 && $yearPattern == 0 ) {
1040 # Kislev in an incomplete year (otherwise as the rule below)
1041 $days = 29;
1042 } else {
1043 # Odd months have 30 days, even have 29
1044 $days = 30 - ( $hebrewMonth - 1 ) % 2;
1045 }
1046 if( $hebrewDay <= $days ) {
1047 # In the current month
1048 break;
1049 } else {
1050 # Subtract the days of the current month
1051 $hebrewDay -= $days;
1052 # Try in the next month
1053 $hebrewMonth++;
1054 }
1055 }
1056
1057 return array( $hebrewYear, $hebrewMonth, $hebrewDay, $days );
1058 }
1059
1060 /**
1061 * This calculates the Hebrew year start, as days since 1 September.
1062 * Based on Carl Friedrich Gauss algorithm for finding Easter date.
1063 * Used for Hebrew date.
1064 */
1065 private static function hebrewYearStart( $year ) {
1066 $a = intval( ( 12 * ( $year - 1 ) + 17 ) % 19 );
1067 $b = intval( ( $year - 1 ) % 4 );
1068 $m = 32.044093161144 + 1.5542417966212 * $a + $b / 4.0 - 0.0031777940220923 * ( $year - 1 );
1069 if( $m < 0 ) {
1070 $m--;
1071 }
1072 $Mar = intval( $m );
1073 if( $m < 0 ) {
1074 $m++;
1075 }
1076 $m -= $Mar;
1077
1078 $c = intval( ( $Mar + 3 * ( $year - 1 ) + 5 * $b + 5 ) % 7);
1079 if( $c == 0 && $a > 11 && $m >= 0.89772376543210 ) {
1080 $Mar++;
1081 } else if( $c == 1 && $a > 6 && $m >= 0.63287037037037 ) {
1082 $Mar += 2;
1083 } else if( $c == 2 || $c == 4 || $c == 6 ) {
1084 $Mar++;
1085 }
1086
1087 $Mar += intval( ( $year - 3761 ) / 100 ) - intval( ( $year - 3761 ) / 400 ) - 24;
1088 return $Mar;
1089 }
1090
1091 /**
1092 * Algorithm to convert Gregorian dates to Thai solar dates.
1093 *
1094 * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
1095 *
1096 * @param $ts String: 14-character timestamp
1097 * @return array converted year, month, day
1098 */
1099 private static function tsToThai( $ts ) {
1100 $gy = substr( $ts, 0, 4 );
1101 $gm = substr( $ts, 4, 2 );
1102 $gd = substr( $ts, 6, 2 );
1103
1104 # Add 543 years to the Gregorian calendar
1105 # Months and days are identical
1106 $gy_thai = $gy + 543;
1107
1108 return array( $gy_thai, $gm, $gd );
1109 }
1110
1111
1112 /**
1113 * Roman number formatting up to 3000
1114 */
1115 static function romanNumeral( $num ) {
1116 static $table = array(
1117 array( '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X' ),
1118 array( '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC', 'C' ),
1119 array( '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM', 'M' ),
1120 array( '', 'M', 'MM', 'MMM' )
1121 );
1122
1123 $num = intval( $num );
1124 if ( $num > 3000 || $num <= 0 ) {
1125 return $num;
1126 }
1127
1128 $s = '';
1129 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1130 if ( $num >= $pow10 ) {
1131 $s .= $table[$i][floor($num / $pow10)];
1132 }
1133 $num = $num % $pow10;
1134 }
1135 return $s;
1136 }
1137
1138 /**
1139 * Hebrew Gematria number formatting up to 9999
1140 */
1141 static function hebrewNumeral( $num ) {
1142 static $table = array(
1143 array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' ),
1144 array( '', 'י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ', 'ק' ),
1145 array( '', 'ק', 'ר', 'ש', 'ת', 'תק', 'תר', 'תש', 'תת', 'תתק', 'תתר' ),
1146 array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' )
1147 );
1148
1149 $num = intval( $num );
1150 if ( $num > 9999 || $num <= 0 ) {
1151 return $num;
1152 }
1153
1154 $s = '';
1155 for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
1156 if ( $num >= $pow10 ) {
1157 if ( $num == 15 || $num == 16 ) {
1158 $s .= $table[0][9] . $table[0][$num - 9];
1159 $num = 0;
1160 } else {
1161 $s .= $table[$i][intval( ( $num / $pow10 ) )];
1162 if( $pow10 == 1000 ) {
1163 $s .= "'";
1164 }
1165 }
1166 }
1167 $num = $num % $pow10;
1168 }
1169 if( strlen( $s ) == 2 ) {
1170 $str = $s . "'";
1171 } else {
1172 $str = substr( $s, 0, strlen( $s ) - 2 ) . '"';
1173 $str .= substr( $s, strlen( $s ) - 2, 2 );
1174 }
1175 $start = substr( $str, 0, strlen( $str ) - 2 );
1176 $end = substr( $str, strlen( $str ) - 2 );
1177 switch( $end ) {
1178 case 'כ':
1179 $str = $start . 'ך';
1180 break;
1181 case 'מ':
1182 $str = $start . 'ם';
1183 break;
1184 case 'נ':
1185 $str = $start . 'ן';
1186 break;
1187 case 'פ':
1188 $str = $start . 'ף';
1189 break;
1190 case 'צ':
1191 $str = $start . 'ץ';
1192 break;
1193 }
1194 return $str;
1195 }
1196
1197 /**
1198 * This is meant to be used by time(), date(), and timeanddate() to get
1199 * the date preference they're supposed to use, it should be used in
1200 * all children.
1201 *
1202 *<code>
1203 * function timeanddate([...], $format = true) {
1204 * $datePreference = $this->dateFormat($format);
1205 * [...]
1206 * }
1207 *</code>
1208 *
1209 * @param $usePrefs Mixed: if true, the user's preference is used
1210 * if false, the site/language default is used
1211 * if int/string, assumed to be a format.
1212 * @return string
1213 */
1214 function dateFormat( $usePrefs = true ) {
1215 global $wgUser;
1216
1217 if( is_bool( $usePrefs ) ) {
1218 if( $usePrefs ) {
1219 $datePreference = $wgUser->getDatePreference();
1220 } else {
1221 $options = User::getDefaultOptions();
1222 $datePreference = (string)$options['date'];
1223 }
1224 } else {
1225 $datePreference = (string)$usePrefs;
1226 }
1227
1228 // return int
1229 if( $datePreference == '' ) {
1230 return 'default';
1231 }
1232
1233 return $datePreference;
1234 }
1235
1236 /**
1237 * @param $ts Mixed: the time format which needs to be turned into a
1238 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1239 * @param $adj Bool: whether to adjust the time output according to the
1240 * user configured offset ($timecorrection)
1241 * @param $format Mixed: true to use user's date format preference
1242 * @param $timecorrection String: the time offset as returned by
1243 * validateTimeZone() in Special:Preferences
1244 * @return string
1245 */
1246 function date( $ts, $adj = false, $format = true, $timecorrection = false ) {
1247 $this->load();
1248 if ( $adj ) {
1249 $ts = $this->userAdjust( $ts, $timecorrection );
1250 }
1251
1252 $pref = $this->dateFormat( $format );
1253 if( $pref == 'default' || !isset( $this->dateFormats["$pref date"] ) ) {
1254 $pref = $this->defaultDateFormat;
1255 }
1256 return $this->sprintfDate( $this->dateFormats["$pref date"], $ts );
1257 }
1258
1259 /**
1260 * @param $ts Mixed: the time format which needs to be turned into a
1261 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1262 * @param $adj Bool: whether to adjust the time output according to the
1263 * user configured offset ($timecorrection)
1264 * @param $format Mixed: true to use user's date format preference
1265 * @param $timecorrection String: the time offset as returned by
1266 * validateTimeZone() in Special:Preferences
1267 * @return string
1268 */
1269 function time( $ts, $adj = false, $format = true, $timecorrection = false ) {
1270 $this->load();
1271 if ( $adj ) {
1272 $ts = $this->userAdjust( $ts, $timecorrection );
1273 }
1274
1275 $pref = $this->dateFormat( $format );
1276 if( $pref == 'default' || !isset( $this->dateFormats["$pref time"] ) ) {
1277 $pref = $this->defaultDateFormat;
1278 }
1279 return $this->sprintfDate( $this->dateFormats["$pref time"], $ts );
1280 }
1281
1282 /**
1283 * @param $ts Mixed: the time format which needs to be turned into a
1284 * date('YmdHis') format with wfTimestamp(TS_MW,$ts)
1285 * @param $adj Bool: whether to adjust the time output according to the
1286 * user configured offset ($timecorrection)
1287 * @param $format Mixed: what format to return, if it's false output the
1288 * default one (default true)
1289 * @param $timecorrection String: the time offset as returned by
1290 * validateTimeZone() in Special:Preferences
1291 * @return string
1292 */
1293 function timeanddate( $ts, $adj = false, $format = true, $timecorrection = false) {
1294 $this->load();
1295
1296 $ts = wfTimestamp( TS_MW, $ts );
1297
1298 if ( $adj ) {
1299 $ts = $this->userAdjust( $ts, $timecorrection );
1300 }
1301
1302 $pref = $this->dateFormat( $format );
1303 if( $pref == 'default' || !isset( $this->dateFormats["$pref both"] ) ) {
1304 $pref = $this->defaultDateFormat;
1305 }
1306
1307 return $this->sprintfDate( $this->dateFormats["$pref both"], $ts );
1308 }
1309
1310 function getMessage( $key ) {
1311 $this->load();
1312 return isset( $this->messages[$key] ) ? $this->messages[$key] : null;
1313 }
1314
1315 function getAllMessages() {
1316 $this->load();
1317 return $this->messages;
1318 }
1319
1320 function iconv( $in, $out, $string ) {
1321 # For most languages, this is a wrapper for iconv
1322 return iconv( $in, $out . '//IGNORE', $string );
1323 }
1324
1325 // callback functions for uc(), lc(), ucwords(), ucwordbreaks()
1326 function ucwordbreaksCallbackAscii($matches){
1327 return $this->ucfirst($matches[1]);
1328 }
1329
1330 function ucwordbreaksCallbackMB($matches){
1331 return mb_strtoupper($matches[0]);
1332 }
1333
1334 function ucCallback($matches){
1335 list( $wikiUpperChars ) = self::getCaseMaps();
1336 return strtr( $matches[1], $wikiUpperChars );
1337 }
1338
1339 function lcCallback($matches){
1340 list( , $wikiLowerChars ) = self::getCaseMaps();
1341 return strtr( $matches[1], $wikiLowerChars );
1342 }
1343
1344 function ucwordsCallbackMB($matches){
1345 return mb_strtoupper($matches[0]);
1346 }
1347
1348 function ucwordsCallbackWiki($matches){
1349 list( $wikiUpperChars ) = self::getCaseMaps();
1350 return strtr( $matches[0], $wikiUpperChars );
1351 }
1352
1353 function ucfirst( $str ) {
1354 if ( empty($str) ) return $str;
1355 if ( ord($str[0]) < 128 ) return ucfirst($str);
1356 else return self::uc($str,true); // fall back to more complex logic in case of multibyte strings
1357 }
1358
1359 function uc( $str, $first = false ) {
1360 if ( function_exists( 'mb_strtoupper' ) ) {
1361 if ( $first ) {
1362 if ( self::isMultibyte( $str ) ) {
1363 return mb_strtoupper( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1364 } else {
1365 return ucfirst( $str );
1366 }
1367 } else {
1368 return self::isMultibyte( $str ) ? mb_strtoupper( $str ) : strtoupper( $str );
1369 }
1370 } else {
1371 if ( self::isMultibyte( $str ) ) {
1372 list( $wikiUpperChars ) = $this->getCaseMaps();
1373 $x = $first ? '^' : '';
1374 return preg_replace_callback(
1375 "/$x([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1376 array($this,"ucCallback"),
1377 $str
1378 );
1379 } else {
1380 return $first ? ucfirst( $str ) : strtoupper( $str );
1381 }
1382 }
1383 }
1384
1385 function lcfirst( $str ) {
1386 if ( empty($str) ) return $str;
1387 if ( is_string( $str ) && ord($str[0]) < 128 ) {
1388 // editing string in place = cool
1389 $str[0]=strtolower($str[0]);
1390 return $str;
1391 }
1392 else return self::lc( $str, true );
1393 }
1394
1395 function lc( $str, $first = false ) {
1396 if ( function_exists( 'mb_strtolower' ) )
1397 if ( $first )
1398 if ( self::isMultibyte( $str ) )
1399 return mb_strtolower( mb_substr( $str, 0, 1 ) ) . mb_substr( $str, 1 );
1400 else
1401 return strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 );
1402 else
1403 return self::isMultibyte( $str ) ? mb_strtolower( $str ) : strtolower( $str );
1404 else
1405 if ( self::isMultibyte( $str ) ) {
1406 list( , $wikiLowerChars ) = self::getCaseMaps();
1407 $x = $first ? '^' : '';
1408 return preg_replace_callback(
1409 "/$x([A-Z]|[\\xc0-\\xff][\\x80-\\xbf]*)/",
1410 array($this,"lcCallback"),
1411 $str
1412 );
1413 } else
1414 return $first ? strtolower( substr( $str, 0, 1 ) ) . substr( $str, 1 ) : strtolower( $str );
1415 }
1416
1417 function isMultibyte( $str ) {
1418 return (bool)preg_match( '/[\x80-\xff]/', $str );
1419 }
1420
1421 function ucwords($str) {
1422 if ( self::isMultibyte( $str ) ) {
1423 $str = self::lc($str);
1424
1425 // regexp to find first letter in each word (i.e. after each space)
1426 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)| ([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1427
1428 // function to use to capitalize a single char
1429 if ( function_exists( 'mb_strtoupper' ) )
1430 return preg_replace_callback(
1431 $replaceRegexp,
1432 array($this,"ucwordsCallbackMB"),
1433 $str
1434 );
1435 else
1436 return preg_replace_callback(
1437 $replaceRegexp,
1438 array($this,"ucwordsCallbackWiki"),
1439 $str
1440 );
1441 }
1442 else
1443 return ucwords( strtolower( $str ) );
1444 }
1445
1446 # capitalize words at word breaks
1447 function ucwordbreaks($str){
1448 if (self::isMultibyte( $str ) ) {
1449 $str = self::lc($str);
1450
1451 // since \b doesn't work for UTF-8, we explicitely define word break chars
1452 $breaks= "[ \-\(\)\}\{\.,\?!]";
1453
1454 // find first letter after word break
1455 $replaceRegexp = "/^([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)|$breaks([a-z]|[\\xc0-\\xff][\\x80-\\xbf]*)/";
1456
1457 if ( function_exists( 'mb_strtoupper' ) )
1458 return preg_replace_callback(
1459 $replaceRegexp,
1460 array($this,"ucwordbreaksCallbackMB"),
1461 $str
1462 );
1463 else
1464 return preg_replace_callback(
1465 $replaceRegexp,
1466 array($this,"ucwordsCallbackWiki"),
1467 $str
1468 );
1469 }
1470 else
1471 return preg_replace_callback(
1472 '/\b([\w\x80-\xff]+)\b/',
1473 array($this,"ucwordbreaksCallbackAscii"),
1474 $str );
1475 }
1476
1477 /**
1478 * Return a case-folded representation of $s
1479 *
1480 * This is a representation such that caseFold($s1)==caseFold($s2) if $s1
1481 * and $s2 are the same except for the case of their characters. It is not
1482 * necessary for the value returned to make sense when displayed.
1483 *
1484 * Do *not* perform any other normalisation in this function. If a caller
1485 * uses this function when it should be using a more general normalisation
1486 * function, then fix the caller.
1487 */
1488 function caseFold( $s ) {
1489 return $this->uc( $s );
1490 }
1491
1492 function checkTitleEncoding( $s ) {
1493 if( is_array( $s ) ) {
1494 wfDebugDieBacktrace( 'Given array to checkTitleEncoding.' );
1495 }
1496 # Check for non-UTF-8 URLs
1497 $ishigh = preg_match( '/[\x80-\xff]/', $s);
1498 if(!$ishigh) return $s;
1499
1500 $isutf8 = preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1501 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})+$/', $s );
1502 if( $isutf8 ) return $s;
1503
1504 return $this->iconv( $this->fallback8bitEncoding(), "utf-8", $s );
1505 }
1506
1507 function fallback8bitEncoding() {
1508 $this->load();
1509 return $this->fallback8bitEncoding;
1510 }
1511
1512 /**
1513 * Some languages have special punctuation to strip out
1514 * or characters which need to be converted for MySQL's
1515 * indexing to grok it correctly. Make such changes here.
1516 *
1517 * @param $string String
1518 * @return String
1519 */
1520 function stripForSearch( $string ) {
1521 global $wgDBtype;
1522 if ( $wgDBtype != 'mysql' ) {
1523 return $string;
1524 }
1525
1526
1527 wfProfileIn( __METHOD__ );
1528
1529 // MySQL fulltext index doesn't grok utf-8, so we
1530 // need to fold cases and convert to hex
1531 $out = preg_replace_callback(
1532 "/([\\xc0-\\xff][\\x80-\\xbf]*)/",
1533 array( $this, 'stripForSearchCallback' ),
1534 $this->lc( $string ) );
1535
1536 // And to add insult to injury, the default indexing
1537 // ignores short words... Pad them so we can pass them
1538 // through without reconfiguring the server...
1539 $minLength = $this->minSearchLength();
1540 if( $minLength > 1 ) {
1541 $n = $minLength-1;
1542 $out = preg_replace(
1543 "/\b(\w{1,$n})\b/",
1544 "$1U800",
1545 $out );
1546 }
1547
1548 wfProfileOut( __METHOD__ );
1549 return $out;
1550 }
1551
1552 /**
1553 * Armor a case-folded UTF-8 string to get through MySQL's
1554 * fulltext search without being mucked up by funny charset
1555 * settings or anything else of the sort.
1556 */
1557 protected function stripForSearchCallback( $matches ) {
1558 return 'U8' . bin2hex( $matches[1] );
1559 }
1560
1561 /**
1562 * Check MySQL server's ft_min_word_len setting so we know
1563 * if we need to pad short words...
1564 */
1565 protected function minSearchLength() {
1566 if( !isset( $this->minSearchLength ) ) {
1567 $sql = "show global variables like 'ft\\_min\\_word\\_len'";
1568 $dbr = wfGetDB( DB_SLAVE );
1569 $result = $dbr->query( $sql );
1570 $row = $result->fetchObject();
1571 $result->free();
1572
1573 if( $row && $row->Variable_name == 'ft_min_word_len' ) {
1574 $this->minSearchLength = intval( $row->Value );
1575 } else {
1576 $this->minSearchLength = 0;
1577 }
1578 }
1579 return $this->minSearchLength;
1580 }
1581
1582 function convertForSearchResult( $termsArray ) {
1583 # some languages, e.g. Chinese, need to do a conversion
1584 # in order for search results to be displayed correctly
1585 return $termsArray;
1586 }
1587
1588 /**
1589 * Get the first character of a string.
1590 *
1591 * @param $s string
1592 * @return string
1593 */
1594 function firstChar( $s ) {
1595 $matches = array();
1596 preg_match( '/^([\x00-\x7f]|[\xc0-\xdf][\x80-\xbf]|' .
1597 '[\xe0-\xef][\x80-\xbf]{2}|[\xf0-\xf7][\x80-\xbf]{3})/', $s, $matches);
1598
1599 if ( isset( $matches[1] ) ) {
1600 if ( strlen( $matches[1] ) != 3 ) {
1601 return $matches[1];
1602 }
1603
1604 // Break down Hangul syllables to grab the first jamo
1605 $code = utf8ToCodepoint( $matches[1] );
1606 if ( $code < 0xac00 || 0xd7a4 <= $code) {
1607 return $matches[1];
1608 } elseif ( $code < 0xb098 ) {
1609 return "\xe3\x84\xb1";
1610 } elseif ( $code < 0xb2e4 ) {
1611 return "\xe3\x84\xb4";
1612 } elseif ( $code < 0xb77c ) {
1613 return "\xe3\x84\xb7";
1614 } elseif ( $code < 0xb9c8 ) {
1615 return "\xe3\x84\xb9";
1616 } elseif ( $code < 0xbc14 ) {
1617 return "\xe3\x85\x81";
1618 } elseif ( $code < 0xc0ac ) {
1619 return "\xe3\x85\x82";
1620 } elseif ( $code < 0xc544 ) {
1621 return "\xe3\x85\x85";
1622 } elseif ( $code < 0xc790 ) {
1623 return "\xe3\x85\x87";
1624 } elseif ( $code < 0xcc28 ) {
1625 return "\xe3\x85\x88";
1626 } elseif ( $code < 0xce74 ) {
1627 return "\xe3\x85\x8a";
1628 } elseif ( $code < 0xd0c0 ) {
1629 return "\xe3\x85\x8b";
1630 } elseif ( $code < 0xd30c ) {
1631 return "\xe3\x85\x8c";
1632 } elseif ( $code < 0xd558 ) {
1633 return "\xe3\x85\x8d";
1634 } else {
1635 return "\xe3\x85\x8e";
1636 }
1637 } else {
1638 return "";
1639 }
1640 }
1641
1642 function initEncoding() {
1643 # Some languages may have an alternate char encoding option
1644 # (Esperanto X-coding, Japanese furigana conversion, etc)
1645 # If this language is used as the primary content language,
1646 # an override to the defaults can be set here on startup.
1647 }
1648
1649 function recodeForEdit( $s ) {
1650 # For some languages we'll want to explicitly specify
1651 # which characters make it into the edit box raw
1652 # or are converted in some way or another.
1653 # Note that if wgOutputEncoding is different from
1654 # wgInputEncoding, this text will be further converted
1655 # to wgOutputEncoding.
1656 global $wgEditEncoding;
1657 if( $wgEditEncoding == '' or
1658 $wgEditEncoding == 'UTF-8' ) {
1659 return $s;
1660 } else {
1661 return $this->iconv( 'UTF-8', $wgEditEncoding, $s );
1662 }
1663 }
1664
1665 function recodeInput( $s ) {
1666 # Take the previous into account.
1667 global $wgEditEncoding;
1668 if($wgEditEncoding != "") {
1669 $enc = $wgEditEncoding;
1670 } else {
1671 $enc = 'UTF-8';
1672 }
1673 if( $enc == 'UTF-8' ) {
1674 return $s;
1675 } else {
1676 return $this->iconv( $enc, 'UTF-8', $s );
1677 }
1678 }
1679
1680 /**
1681 * For right-to-left language support
1682 *
1683 * @return bool
1684 */
1685 function isRTL() {
1686 $this->load();
1687 return $this->rtl;
1688 }
1689
1690 /**
1691 * A hidden direction mark (LRM or RLM), depending on the language direction
1692 *
1693 * @return string
1694 */
1695 function getDirMark() {
1696 return $this->isRTL() ? "\xE2\x80\x8F" : "\xE2\x80\x8E";
1697 }
1698
1699 /**
1700 * An arrow, depending on the language direction
1701 *
1702 * @return string
1703 */
1704 function getArrow() {
1705 return $this->isRTL() ? '←' : '→';
1706 }
1707
1708 /**
1709 * To allow "foo[[bar]]" to extend the link over the whole word "foobar"
1710 *
1711 * @return bool
1712 */
1713 function linkPrefixExtension() {
1714 $this->load();
1715 return $this->linkPrefixExtension;
1716 }
1717
1718 function &getMagicWords() {
1719 $this->load();
1720 return $this->magicWords;
1721 }
1722
1723 # Fill a MagicWord object with data from here
1724 function getMagic( &$mw ) {
1725 if ( !$this->mMagicHookDone ) {
1726 $this->mMagicHookDone = true;
1727 wfRunHooks( 'LanguageGetMagic', array( &$this->mMagicExtensions, $this->getCode() ) );
1728 }
1729 if ( isset( $this->mMagicExtensions[$mw->mId] ) ) {
1730 $rawEntry = $this->mMagicExtensions[$mw->mId];
1731 } else {
1732 $magicWords =& $this->getMagicWords();
1733 if ( isset( $magicWords[$mw->mId] ) ) {
1734 $rawEntry = $magicWords[$mw->mId];
1735 } else {
1736 # Fall back to English if local list is incomplete
1737 $magicWords =& Language::getMagicWords();
1738 if ( !isset($magicWords[$mw->mId]) ) {
1739 throw new MWException("Magic word '{$mw->mId}' not found" );
1740 }
1741 $rawEntry = $magicWords[$mw->mId];
1742 }
1743 }
1744
1745 if( !is_array( $rawEntry ) ) {
1746 error_log( "\"$rawEntry\" is not a valid magic thingie for \"$mw->mId\"" );
1747 } else {
1748 $mw->mCaseSensitive = $rawEntry[0];
1749 $mw->mSynonyms = array_slice( $rawEntry, 1 );
1750 }
1751 }
1752
1753 /**
1754 * Add magic words to the extension array
1755 */
1756 function addMagicWordsByLang( $newWords ) {
1757 $code = $this->getCode();
1758 $fallbackChain = array();
1759 while ( $code && !in_array( $code, $fallbackChain ) ) {
1760 $fallbackChain[] = $code;
1761 $code = self::getFallbackFor( $code );
1762 }
1763 if ( !in_array( 'en', $fallbackChain ) ) {
1764 $fallbackChain[] = 'en';
1765 }
1766 $fallbackChain = array_reverse( $fallbackChain );
1767 foreach ( $fallbackChain as $code ) {
1768 if ( isset( $newWords[$code] ) ) {
1769 $this->mMagicExtensions = $newWords[$code] + $this->mMagicExtensions;
1770 }
1771 }
1772 }
1773
1774 /**
1775 * Get special page names, as an associative array
1776 * case folded alias => real name
1777 */
1778 function getSpecialPageAliases() {
1779 $this->load();
1780
1781 // Cache aliases because it may be slow to load them
1782 if ( !isset( $this->mExtendedSpecialPageAliases ) ) {
1783
1784 // Initialise array
1785 $this->mExtendedSpecialPageAliases = $this->specialPageAliases;
1786
1787 global $wgExtensionAliasesFiles;
1788 foreach ( $wgExtensionAliasesFiles as $file ) {
1789
1790 // Fail fast
1791 if ( !file_exists($file) )
1792 throw new MWException( "Aliases file does not exist: $file" );
1793
1794 $aliases = array();
1795 require($file);
1796
1797 // Check the availability of aliases
1798 if ( !isset($aliases['en']) )
1799 throw new MWException( "Malformed aliases file: $file" );
1800
1801 // Merge all aliases in fallback chain
1802 $code = $this->getCode();
1803 do {
1804 if ( !isset($aliases[$code]) ) continue;
1805
1806 $aliases[$code] = $this->fixSpecialPageAliases( $aliases[$code] );
1807 /* Merge the aliases, THIS will break if there is special page name
1808 * which looks like a numerical key, thanks to PHP...
1809 * See the array_merge_recursive manual entry */
1810 $this->mExtendedSpecialPageAliases = array_merge_recursive(
1811 $this->mExtendedSpecialPageAliases, $aliases[$code] );
1812
1813 } while ( $code = self::getFallbackFor( $code ) );
1814 }
1815
1816 wfRunHooks( 'LanguageGetSpecialPageAliases',
1817 array( &$this->mExtendedSpecialPageAliases, $this->getCode() ) );
1818 }
1819
1820 return $this->mExtendedSpecialPageAliases;
1821 }
1822
1823 /**
1824 * Function to fix special page aliases. Will convert the first letter to
1825 * upper case and spaces to underscores. Can be given a full aliases array,
1826 * in which case it will recursively fix all aliases.
1827 */
1828 public function fixSpecialPageAliases( $mixed ) {
1829 // Work recursively until in string level
1830 if ( is_array($mixed) ) {
1831 $callback = array( $this, 'fixSpecialPageAliases' );
1832 return array_map( $callback, $mixed );
1833 }
1834 return str_replace( ' ', '_', $this->ucfirst( $mixed ) );
1835 }
1836
1837 /**
1838 * Italic is unsuitable for some languages
1839 *
1840 * @param $text String: the text to be emphasized.
1841 * @return string
1842 */
1843 function emphasize( $text ) {
1844 return "<em>$text</em>";
1845 }
1846
1847 /**
1848 * Normally we output all numbers in plain en_US style, that is
1849 * 293,291.235 for twohundredninetythreethousand-twohundredninetyone
1850 * point twohundredthirtyfive. However this is not sutable for all
1851 * languages, some such as Pakaran want ੨੯੩,੨੯੫.੨੩੫ and others such as
1852 * Icelandic just want to use commas instead of dots, and dots instead
1853 * of commas like "293.291,235".
1854 *
1855 * An example of this function being called:
1856 * <code>
1857 * wfMsg( 'message', $wgLang->formatNum( $num ) )
1858 * </code>
1859 *
1860 * See LanguageGu.php for the Gujarati implementation and
1861 * $separatorTransformTable on MessageIs.php for
1862 * the , => . and . => , implementation.
1863 *
1864 * @todo check if it's viable to use localeconv() for the decimal
1865 * separator thing.
1866 * @param $number Mixed: the string to be formatted, should be an integer
1867 * or a floating point number.
1868 * @param $nocommafy Bool: set to true for special numbers like dates
1869 * @return string
1870 */
1871 function formatNum( $number, $nocommafy = false ) {
1872 global $wgTranslateNumerals;
1873 if (!$nocommafy) {
1874 $number = $this->commafy($number);
1875 $s = $this->separatorTransformTable();
1876 if (!is_null($s)) { $number = strtr($number, $s); }
1877 }
1878
1879 if ($wgTranslateNumerals) {
1880 $s = $this->digitTransformTable();
1881 if (!is_null($s)) { $number = strtr($number, $s); }
1882 }
1883
1884 return $number;
1885 }
1886
1887 function parseFormattedNumber( $number ) {
1888 $s = $this->digitTransformTable();
1889 if (!is_null($s)) { $number = strtr($number, array_flip($s)); }
1890
1891 $s = $this->separatorTransformTable();
1892 if (!is_null($s)) { $number = strtr($number, array_flip($s)); }
1893
1894 $number = strtr( $number, array (',' => '') );
1895 return $number;
1896 }
1897
1898 /**
1899 * Adds commas to a given number
1900 *
1901 * @param $_ mixed
1902 * @return string
1903 */
1904 function commafy($_) {
1905 return strrev((string)preg_replace('/(\d{3})(?=\d)(?!\d*\.)/','$1,',strrev($_)));
1906 }
1907
1908 function digitTransformTable() {
1909 $this->load();
1910 return $this->digitTransformTable;
1911 }
1912
1913 function separatorTransformTable() {
1914 $this->load();
1915 return $this->separatorTransformTable;
1916 }
1917
1918
1919 /**
1920 * For the credit list in includes/Credits.php (action=credits)
1921 *
1922 * @param $l Array
1923 * @return string
1924 */
1925 function listToText( $l ) {
1926 $s = '';
1927 $m = count($l) - 1;
1928 for ($i = $m; $i >= 0; $i--) {
1929 if ($i == $m) {
1930 $s = $l[$i];
1931 } else if ($i == $m - 1) {
1932 $s = $l[$i] . $this->getMessageFromDB( 'and' ) . $this->getMessageFromDB( 'word-separator' ) . $s;
1933 } else {
1934 $s = $l[$i] . $this->getMessageFromDB( 'comma-separator' ) . $s;
1935 }
1936 }
1937 return $s;
1938 }
1939
1940 /**
1941 * Take a list of strings and build a locale-friendly comma-separated
1942 * list, using the local comma-separator message.
1943 * @param $list array of strings to put in a comma list
1944 * @return string
1945 */
1946 function commaList( $list, $forContent = false ) {
1947 return implode(
1948 $list,
1949 wfMsgExt( 'comma-separator', array( 'escapenoentities', 'language' => $this ) ) );
1950 }
1951
1952 /**
1953 * Same as commaList, but separate it with the pipe instead.
1954 * @param $list array of strings to put in a pipe list
1955 * @return string
1956 */
1957 function pipeList( $list ) {
1958 return implode(
1959 $list,
1960 wfMsgExt( 'pipe-separator', array( 'escapenoentities', 'language' => $this ) ) );
1961 }
1962
1963 /**
1964 * Truncate a string to a specified length in bytes, appending an optional
1965 * string (e.g. for ellipses)
1966 *
1967 * The database offers limited byte lengths for some columns in the database;
1968 * multi-byte character sets mean we need to ensure that only whole characters
1969 * are included, otherwise broken characters can be passed to the user
1970 *
1971 * If $length is negative, the string will be truncated from the beginning
1972 *
1973 * @param $string String to truncate
1974 * @param $length Int: maximum length (excluding ellipses)
1975 * @param $ellipsis String to append to the truncated text
1976 * @return string
1977 */
1978 function truncate( $string, $length, $ellipsis = "" ) {
1979 if( $length == 0 ) {
1980 return $ellipsis;
1981 }
1982 if ( strlen( $string ) <= abs( $length ) ) {
1983 return $string;
1984 }
1985 if( $length > 0 ) {
1986 $string = substr( $string, 0, $length );
1987 $char = ord( $string[strlen( $string ) - 1] );
1988 $m = array();
1989 if ($char >= 0xc0) {
1990 # We got the first byte only of a multibyte char; remove it.
1991 $string = substr( $string, 0, -1 );
1992 } elseif( $char >= 0x80 &&
1993 preg_match( '/^(.*)(?:[\xe0-\xef][\x80-\xbf]|' .
1994 '[\xf0-\xf7][\x80-\xbf]{1,2})$/', $string, $m ) ) {
1995 # We chopped in the middle of a character; remove it
1996 $string = $m[1];
1997 }
1998 return $string . $ellipsis;
1999 } else {
2000 $string = substr( $string, $length );
2001 $char = ord( $string[0] );
2002 if( $char >= 0x80 && $char < 0xc0 ) {
2003 # We chopped in the middle of a character; remove the whole thing
2004 $string = preg_replace( '/^[\x80-\xbf]+/', '', $string );
2005 }
2006 return $ellipsis . $string;
2007 }
2008 }
2009
2010 /**
2011 * Grammatical transformations, needed for inflected languages
2012 * Invoked by putting {{grammar:case|word}} in a message
2013 *
2014 * @param $word string
2015 * @param $case string
2016 * @return string
2017 */
2018 function convertGrammar( $word, $case ) {
2019 global $wgGrammarForms;
2020 if ( isset($wgGrammarForms[$this->getCode()][$case][$word]) ) {
2021 return $wgGrammarForms[$this->getCode()][$case][$word];
2022 }
2023 return $word;
2024 }
2025
2026 /**
2027 * Plural form transformations, needed for some languages.
2028 * For example, there are 3 form of plural in Russian and Polish,
2029 * depending on "count mod 10". See [[w:Plural]]
2030 * For English it is pretty simple.
2031 *
2032 * Invoked by putting {{plural:count|wordform1|wordform2}}
2033 * or {{plural:count|wordform1|wordform2|wordform3}}
2034 *
2035 * Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
2036 *
2037 * @param $count Integer: non-localized number
2038 * @param $forms Array: different plural forms
2039 * @return string Correct form of plural for $count in this language
2040 */
2041 function convertPlural( $count, $forms ) {
2042 if ( !count($forms) ) { return ''; }
2043 $forms = $this->preConvertPlural( $forms, 2 );
2044
2045 return ( $count == 1 ) ? $forms[0] : $forms[1];
2046 }
2047
2048 /**
2049 * Checks that convertPlural was given an array and pads it to requested
2050 * amound of forms by copying the last one.
2051 *
2052 * @param $count Integer: How many forms should there be at least
2053 * @param $forms Array of forms given to convertPlural
2054 * @return array Padded array of forms or an exception if not an array
2055 */
2056 protected function preConvertPlural( /* Array */ $forms, $count ) {
2057 while ( count($forms) < $count ) {
2058 $forms[] = $forms[count($forms)-1];
2059 }
2060 return $forms;
2061 }
2062
2063 /**
2064 * For translaing of expiry times
2065 * @param $str String: the validated block time in English
2066 * @return Somehow translated block time
2067 * @see LanguageFi.php for example implementation
2068 */
2069 function translateBlockExpiry( $str ) {
2070
2071 $scBlockExpiryOptions = $this->getMessageFromDB( 'ipboptions' );
2072
2073 if ( $scBlockExpiryOptions == '-') {
2074 return $str;
2075 }
2076
2077 foreach (explode(',', $scBlockExpiryOptions) as $option) {
2078 if ( strpos($option, ":") === false )
2079 continue;
2080 list($show, $value) = explode(":", $option);
2081 if ( strcmp ( $str, $value) == 0 ) {
2082 return htmlspecialchars( trim( $show ) );
2083 }
2084 }
2085
2086 return $str;
2087 }
2088
2089 /**
2090 * languages like Chinese need to be segmented in order for the diff
2091 * to be of any use
2092 *
2093 * @param $text String
2094 * @return String
2095 */
2096 function segmentForDiff( $text ) {
2097 return $text;
2098 }
2099
2100 /**
2101 * and unsegment to show the result
2102 *
2103 * @param $text String
2104 * @return String
2105 */
2106 function unsegmentForDiff( $text ) {
2107 return $text;
2108 }
2109
2110 # convert text to different variants of a language.
2111 function convert( $text, $isTitle = false) {
2112 return $this->mConverter->convert($text, $isTitle);
2113 }
2114
2115 # Convert text from within Parser
2116 function parserConvert( $text, &$parser ) {
2117 return $this->mConverter->parserConvert( $text, $parser );
2118 }
2119
2120 # Check if this is a language with variants
2121 function hasVariants(){
2122 return sizeof($this->getVariants())>1;
2123 }
2124
2125 # Put custom tags (e.g. -{ }-) around math to prevent conversion
2126 function armourMath($text){
2127 return $this->mConverter->armourMath($text);
2128 }
2129
2130
2131 /**
2132 * Perform output conversion on a string, and encode for safe HTML output.
2133 * @param $text String
2134 * @param $isTitle Bool -- wtf?
2135 * @return string
2136 * @todo this should get integrated somewhere sane
2137 */
2138 function convertHtml( $text, $isTitle = false ) {
2139 return htmlspecialchars( $this->convert( $text, $isTitle ) );
2140 }
2141
2142 function convertCategoryKey( $key ) {
2143 return $this->mConverter->convertCategoryKey( $key );
2144 }
2145
2146 /**
2147 * get the list of variants supported by this langauge
2148 * see sample implementation in LanguageZh.php
2149 *
2150 * @return array an array of language codes
2151 */
2152 function getVariants() {
2153 return $this->mConverter->getVariants();
2154 }
2155
2156
2157 function getPreferredVariant( $fromUser = true ) {
2158 return $this->mConverter->getPreferredVariant( $fromUser );
2159 }
2160
2161 /**
2162 * if a language supports multiple variants, it is
2163 * possible that non-existing link in one variant
2164 * actually exists in another variant. this function
2165 * tries to find it. See e.g. LanguageZh.php
2166 *
2167 * @param $link String: the name of the link
2168 * @param $nt Mixed: the title object of the link
2169 * @return null the input parameters may be modified upon return
2170 */
2171 function findVariantLink( &$link, &$nt, $forTemplate = false ) {
2172 $this->mConverter->findVariantLink($link, $nt, $forTemplate );
2173 }
2174
2175 /**
2176 * If a language supports multiple variants, converts text
2177 * into an array of all possible variants of the text:
2178 * 'variant' => text in that variant
2179 */
2180
2181 function convertLinkToAllVariants($text){
2182 return $this->mConverter->convertLinkToAllVariants($text);
2183 }
2184
2185
2186 /**
2187 * returns language specific options used by User::getPageRenderHash()
2188 * for example, the preferred language variant
2189 *
2190 * @return string
2191 */
2192 function getExtraHashOptions() {
2193 return $this->mConverter->getExtraHashOptions();
2194 }
2195
2196 /**
2197 * for languages that support multiple variants, the title of an
2198 * article may be displayed differently in different variants. this
2199 * function returns the apporiate title defined in the body of the article.
2200 *
2201 * @return string
2202 */
2203 function getParsedTitle() {
2204 return $this->mConverter->getParsedTitle();
2205 }
2206
2207 /**
2208 * Enclose a string with the "no conversion" tag. This is used by
2209 * various functions in the Parser
2210 *
2211 * @param $text String: text to be tagged for no conversion
2212 * @param $noParse
2213 * @return string the tagged text
2214 */
2215 function markNoConversion( $text, $noParse=false ) {
2216 return $this->mConverter->markNoConversion( $text, $noParse );
2217 }
2218
2219 /**
2220 * A regular expression to match legal word-trailing characters
2221 * which should be merged onto a link of the form [[foo]]bar.
2222 *
2223 * @return string
2224 */
2225 function linkTrail() {
2226 $this->load();
2227 return $this->linkTrail;
2228 }
2229
2230 function getLangObj() {
2231 return $this;
2232 }
2233
2234 /**
2235 * Get the RFC 3066 code for this language object
2236 */
2237 function getCode() {
2238 return $this->mCode;
2239 }
2240
2241 function setCode( $code ) {
2242 $this->mCode = $code;
2243 }
2244
2245 static function getFileName( $prefix = 'Language', $code, $suffix = '.php' ) {
2246 return $prefix . str_replace( '-', '_', ucfirst( $code ) ) . $suffix;
2247 }
2248
2249 static function getMessagesFileName( $code ) {
2250 global $IP;
2251 return self::getFileName( "$IP/languages/messages/Messages", $code, '.php' );
2252 }
2253
2254 static function getClassFileName( $code ) {
2255 global $IP;
2256 return self::getFileName( "$IP/languages/classes/Language", $code, '.php' );
2257 }
2258
2259 static function getLocalisationArray( $code, $disableCache = false ) {
2260 self::loadLocalisation( $code, $disableCache );
2261 return self::$mLocalisationCache[$code];
2262 }
2263
2264 /**
2265 * Load localisation data for a given code into the static cache
2266 *
2267 * @return array Dependencies, map of filenames to mtimes
2268 */
2269 static function loadLocalisation( $code, $disableCache = false ) {
2270 static $recursionGuard = array();
2271 global $wgMemc, $wgCheckSerialized;
2272
2273 if ( !$code ) {
2274 throw new MWException( "Invalid language code requested" );
2275 }
2276
2277 if ( !$disableCache ) {
2278 # Try the per-process cache
2279 if ( isset( self::$mLocalisationCache[$code] ) ) {
2280 return self::$mLocalisationCache[$code]['deps'];
2281 }
2282
2283 wfProfileIn( __METHOD__ );
2284
2285 # Try the serialized directory
2286 $cache = wfGetPrecompiledData( self::getFileName( "Messages", $code, '.ser' ) );
2287 if ( $cache ) {
2288 if ( $wgCheckSerialized && self::isLocalisationOutOfDate( $cache ) ) {
2289 $cache = false;
2290 wfDebug( "Language::loadLocalisation(): precompiled data file for $code is out of date\n" );
2291 } else {
2292 self::$mLocalisationCache[$code] = $cache;
2293 wfDebug( "Language::loadLocalisation(): got localisation for $code from precompiled data file\n" );
2294 wfProfileOut( __METHOD__ );
2295 return self::$mLocalisationCache[$code]['deps'];
2296 }
2297 }
2298
2299 # Try the global cache
2300 $memcKey = wfMemcKey('localisation', $code );
2301 $fbMemcKey = wfMemcKey('fallback', $cache['fallback'] );
2302 $cache = $wgMemc->get( $memcKey );
2303 if ( $cache ) {
2304 if ( self::isLocalisationOutOfDate( $cache ) ) {
2305 $wgMemc->delete( $memcKey );
2306 $wgMemc->delete( $fbMemcKey );
2307 $cache = false;
2308 wfDebug( "Language::loadLocalisation(): localisation cache for $code had expired\n" );
2309 } else {
2310 self::$mLocalisationCache[$code] = $cache;
2311 wfDebug( "Language::loadLocalisation(): got localisation for $code from cache\n" );
2312 wfProfileOut( __METHOD__ );
2313 return $cache['deps'];
2314 }
2315 }
2316 } else {
2317 wfProfileIn( __METHOD__ );
2318 }
2319
2320 # Default fallback, may be overridden when the messages file is included
2321 if ( $code != 'en' ) {
2322 $fallback = 'en';
2323 } else {
2324 $fallback = false;
2325 }
2326
2327 # Load the primary localisation from the source file
2328 $filename = self::getMessagesFileName( $code );
2329 if ( !file_exists( $filename ) ) {
2330 wfDebug( "Language::loadLocalisation(): no localisation file for $code, using implicit fallback to en\n" );
2331 $cache = compact( self::$mLocalisationKeys ); // Set correct fallback
2332 $deps = array();
2333 } else {
2334 $deps = array( $filename => filemtime( $filename ) );
2335 require( $filename );
2336 $cache = compact( self::$mLocalisationKeys );
2337 wfDebug( "Language::loadLocalisation(): got localisation for $code from source\n" );
2338 }
2339
2340 if ( !empty( $fallback ) ) {
2341 # Load the fallback localisation, with a circular reference guard
2342 if ( isset( $recursionGuard[$code] ) ) {
2343 throw new MWException( "Error: Circular fallback reference in language code $code" );
2344 }
2345 $recursionGuard[$code] = true;
2346 $newDeps = self::loadLocalisation( $fallback, $disableCache );
2347 unset( $recursionGuard[$code] );
2348
2349 $secondary = self::$mLocalisationCache[$fallback];
2350 $deps = array_merge( $deps, $newDeps );
2351
2352 # Merge the fallback localisation with the current localisation
2353 foreach ( self::$mLocalisationKeys as $key ) {
2354 if ( isset( $cache[$key] ) ) {
2355 if ( isset( $secondary[$key] ) ) {
2356 if ( in_array( $key, self::$mMergeableMapKeys ) ) {
2357 $cache[$key] = $cache[$key] + $secondary[$key];
2358 } elseif ( in_array( $key, self::$mMergeableListKeys ) ) {
2359 $cache[$key] = array_merge( $secondary[$key], $cache[$key] );
2360 } elseif ( in_array( $key, self::$mMergeableAliasListKeys ) ) {
2361 $cache[$key] = array_merge_recursive( $cache[$key], $secondary[$key] );
2362 }
2363 }
2364 } else {
2365 $cache[$key] = $secondary[$key];
2366 }
2367 }
2368
2369 # Merge bookstore lists if requested
2370 if ( !empty( $cache['bookstoreList']['inherit'] ) ) {
2371 $cache['bookstoreList'] = array_merge( $cache['bookstoreList'], $secondary['bookstoreList'] );
2372 }
2373 if ( isset( $cache['bookstoreList']['inherit'] ) ) {
2374 unset( $cache['bookstoreList']['inherit'] );
2375 }
2376 }
2377
2378 # Add dependencies to the cache entry
2379 $cache['deps'] = $deps;
2380
2381 # Replace spaces with underscores in namespace names
2382 $cache['namespaceNames'] = str_replace( ' ', '_', $cache['namespaceNames'] );
2383
2384 # And do the same for specialpage aliases. $page is an array.
2385 foreach ( $cache['specialPageAliases'] as &$page ) {
2386 $page = str_replace( ' ', '_', $page );
2387 }
2388 # Decouple the reference to prevent accidental damage
2389 unset($page);
2390
2391 # Save to both caches
2392 self::$mLocalisationCache[$code] = $cache;
2393 if ( !$disableCache ) {
2394 $wgMemc->set( $memcKey, $cache );
2395 $wgMemc->set( $fbMemcKey, (string) $cache['fallback'] );
2396 }
2397
2398 wfProfileOut( __METHOD__ );
2399 return $deps;
2400 }
2401
2402 /**
2403 * Test if a given localisation cache is out of date with respect to the
2404 * source Messages files. This is done automatically for the global cache
2405 * in $wgMemc, but is only done on certain occasions for the serialized
2406 * data file.
2407 *
2408 * @param $cache mixed Either a language code or a cache array
2409 */
2410 static function isLocalisationOutOfDate( $cache ) {
2411 if ( !is_array( $cache ) ) {
2412 self::loadLocalisation( $cache );
2413 $cache = self::$mLocalisationCache[$cache];
2414 }
2415 $expired = false;
2416 foreach ( $cache['deps'] as $file => $mtime ) {
2417 if ( !file_exists( $file ) || filemtime( $file ) > $mtime ) {
2418 $expired = true;
2419 break;
2420 }
2421 }
2422 return $expired;
2423 }
2424
2425 /**
2426 * Get the fallback for a given language
2427 */
2428 static function getFallbackFor( $code ) {
2429 // Shortcut
2430 if ( $code === 'en' ) return false;
2431
2432 // Local cache
2433 static $cache = array();
2434 // Quick return
2435 if ( isset($cache[$code]) ) return $cache[$code];
2436
2437 // Try memcache
2438 global $wgMemc;
2439 $memcKey = wfMemcKey( 'fallback', $code );
2440 $fbcode = $wgMemc->get( $memcKey );
2441
2442 if ( is_string($fbcode) ) {
2443 // False is stored as a string to detect failures in memcache properly
2444 if ( $fbcode === '' ) $fbcode = false;
2445
2446 // Update local cache and return
2447 $cache[$code] = $fbcode;
2448 return $fbcode;
2449 }
2450
2451 // Nothing in caches, load and and update both caches
2452 self::loadLocalisation( $code );
2453 $fbcode = self::$mLocalisationCache[$code]['fallback'];
2454
2455 $cache[$code] = $fbcode;
2456 $wgMemc->set( $memcKey, (string) $fbcode );
2457
2458 return $fbcode;
2459 }
2460
2461 /**
2462 * Get all messages for a given language
2463 */
2464 static function getMessagesFor( $code ) {
2465 self::loadLocalisation( $code );
2466 return self::$mLocalisationCache[$code]['messages'];
2467 }
2468
2469 /**
2470 * Get a message for a given language
2471 */
2472 static function getMessageFor( $key, $code ) {
2473 self::loadLocalisation( $code );
2474 return isset( self::$mLocalisationCache[$code]['messages'][$key] ) ? self::$mLocalisationCache[$code]['messages'][$key] : null;
2475 }
2476
2477 /**
2478 * Load localisation data for this object
2479 */
2480 function load() {
2481 if ( !$this->mLoaded ) {
2482 self::loadLocalisation( $this->getCode() );
2483 $cache =& self::$mLocalisationCache[$this->getCode()];
2484 foreach ( self::$mLocalisationKeys as $key ) {
2485 $this->$key = $cache[$key];
2486 }
2487 $this->mLoaded = true;
2488
2489 $this->fixUpSettings();
2490 }
2491 }
2492
2493 /**
2494 * Do any necessary post-cache-load settings adjustment
2495 */
2496 function fixUpSettings() {
2497 global $wgExtraNamespaces, $wgMetaNamespace, $wgMetaNamespaceTalk,
2498 $wgNamespaceAliases, $wgAmericanDates;
2499 wfProfileIn( __METHOD__ );
2500 if ( $wgExtraNamespaces ) {
2501 $this->namespaceNames = $wgExtraNamespaces + $this->namespaceNames;
2502 }
2503
2504 $this->namespaceNames[NS_PROJECT] = $wgMetaNamespace;
2505 if ( $wgMetaNamespaceTalk ) {
2506 $this->namespaceNames[NS_PROJECT_TALK] = $wgMetaNamespaceTalk;
2507 } else {
2508 $talk = $this->namespaceNames[NS_PROJECT_TALK];
2509 $talk = str_replace( '$1', $wgMetaNamespace, $talk );
2510
2511 # Allow grammar transformations
2512 # Allowing full message-style parsing would make simple requests
2513 # such as action=raw much more expensive than they need to be.
2514 # This will hopefully cover most cases.
2515 $talk = preg_replace_callback( '/{{grammar:(.*?)\|(.*?)}}/i',
2516 array( &$this, 'replaceGrammarInNamespace' ), $talk );
2517 $talk = str_replace( ' ', '_', $talk );
2518 $this->namespaceNames[NS_PROJECT_TALK] = $talk;
2519 }
2520
2521 # The above mixing may leave namespaces out of canonical order.
2522 # Re-order by namespace ID number...
2523 ksort( $this->namespaceNames );
2524
2525 # Put namespace names and aliases into a hashtable.
2526 # If this is too slow, then we should arrange it so that it is done
2527 # before caching. The catch is that at pre-cache time, the above
2528 # class-specific fixup hasn't been done.
2529 $this->mNamespaceIds = array();
2530 foreach ( $this->namespaceNames as $index => $name ) {
2531 $this->mNamespaceIds[$this->lc($name)] = $index;
2532 }
2533 if ( $this->namespaceAliases ) {
2534 foreach ( $this->namespaceAliases as $name => $index ) {
2535 $this->mNamespaceIds[$this->lc($name)] = $index;
2536 }
2537 }
2538 if ( $wgNamespaceAliases ) {
2539 foreach ( $wgNamespaceAliases as $name => $index ) {
2540 $this->mNamespaceIds[$this->lc($name)] = $index;
2541 }
2542 }
2543
2544 if ( $this->defaultDateFormat == 'dmy or mdy' ) {
2545 $this->defaultDateFormat = $wgAmericanDates ? 'mdy' : 'dmy';
2546 }
2547 wfProfileOut( __METHOD__ );
2548 }
2549
2550 function replaceGrammarInNamespace( $m ) {
2551 return $this->convertGrammar( trim( $m[2] ), trim( $m[1] ) );
2552 }
2553
2554 static function getCaseMaps() {
2555 static $wikiUpperChars, $wikiLowerChars;
2556 if ( isset( $wikiUpperChars ) ) {
2557 return array( $wikiUpperChars, $wikiLowerChars );
2558 }
2559
2560 wfProfileIn( __METHOD__ );
2561 $arr = wfGetPrecompiledData( 'Utf8Case.ser' );
2562 if ( $arr === false ) {
2563 throw new MWException(
2564 "Utf8Case.ser is missing, please run \"make\" in the serialized directory\n" );
2565 }
2566 extract( $arr );
2567 wfProfileOut( __METHOD__ );
2568 return array( $wikiUpperChars, $wikiLowerChars );
2569 }
2570
2571 function formatTimePeriod( $seconds ) {
2572 if ( $seconds < 10 ) {
2573 return $this->formatNum( sprintf( "%.1f", $seconds ) ) . wfMsg( 'seconds-abbrev' );
2574 } elseif ( $seconds < 60 ) {
2575 return $this->formatNum( round( $seconds ) ) . wfMsg( 'seconds-abbrev' );
2576 } elseif ( $seconds < 3600 ) {
2577 return $this->formatNum( floor( $seconds / 60 ) ) . wfMsg( 'minutes-abbrev' ) .
2578 $this->formatNum( round( fmod( $seconds, 60 ) ) ) . wfMsg( 'seconds-abbrev' );
2579 } else {
2580 $hours = floor( $seconds / 3600 );
2581 $minutes = floor( ( $seconds - $hours * 3600 ) / 60 );
2582 $secondsPart = round( $seconds - $hours * 3600 - $minutes * 60 );
2583 return $this->formatNum( $hours ) . wfMsg( 'hours-abbrev' ) .
2584 $this->formatNum( $minutes ) . wfMsg( 'minutes-abbrev' ) .
2585 $this->formatNum( $secondsPart ) . wfMsg( 'seconds-abbrev' );
2586 }
2587 }
2588
2589 function formatBitrate( $bps ) {
2590 $units = array( 'bps', 'kbps', 'Mbps', 'Gbps' );
2591 if ( $bps <= 0 ) {
2592 return $this->formatNum( $bps ) . $units[0];
2593 }
2594 $unitIndex = floor( log10( $bps ) / 3 );
2595 $mantissa = $bps / pow( 1000, $unitIndex );
2596 if ( $mantissa < 10 ) {
2597 $mantissa = round( $mantissa, 1 );
2598 } else {
2599 $mantissa = round( $mantissa );
2600 }
2601 return $this->formatNum( $mantissa ) . $units[$unitIndex];
2602 }
2603
2604 /**
2605 * Format a size in bytes for output, using an appropriate
2606 * unit (B, KB, MB or GB) according to the magnitude in question
2607 *
2608 * @param $size Size to format
2609 * @return string Plain text (not HTML)
2610 */
2611 function formatSize( $size ) {
2612 // For small sizes no decimal places necessary
2613 $round = 0;
2614 if( $size > 1024 ) {
2615 $size = $size / 1024;
2616 if( $size > 1024 ) {
2617 $size = $size / 1024;
2618 // For MB and bigger two decimal places are smarter
2619 $round = 2;
2620 if( $size > 1024 ) {
2621 $size = $size / 1024;
2622 $msg = 'size-gigabytes';
2623 } else {
2624 $msg = 'size-megabytes';
2625 }
2626 } else {
2627 $msg = 'size-kilobytes';
2628 }
2629 } else {
2630 $msg = 'size-bytes';
2631 }
2632 $size = round( $size, $round );
2633 $text = $this->getMessageFromDB( $msg );
2634 return str_replace( '$1', $this->formatNum( $size ), $text );
2635 }
2636 }
Wiklou, le Wiki du Wiklou