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