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