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