'iranian-calendar-m10', 'iranian-calendar-m11', 'iranian-calendar-m12'
);
+ static public $mHebrewCalendarMonthMsgs = array(
+ 'hebrew-calendar-m1', 'hebrew-calendar-m2', 'hebrew-calendar-m3',
+ 'hebrew-calendar-m4', 'hebrew-calendar-m5', 'hebrew-calendar-m6',
+ 'hebrew-calendar-m7', 'hebrew-calendar-m8', 'hebrew-calendar-m9',
+ 'hebrew-calendar-m10', 'hebrew-calendar-m11', 'hebrew-calendar-m12',
+ 'hebrew-calendar-m6a', 'hebrew-calendar-m6b'
+ );
+
+ static public $mHebrewCalendarMonthGenMsgs = array(
+ 'hebrew-calendar-m1-gen', 'hebrew-calendar-m2-gen', 'hebrew-calendar-m3-gen',
+ 'hebrew-calendar-m4-gen', 'hebrew-calendar-m5-gen', 'hebrew-calendar-m6-gen',
+ 'hebrew-calendar-m7-gen', 'hebrew-calendar-m8-gen', 'hebrew-calendar-m9-gen',
+ 'hebrew-calendar-m10-gen', 'hebrew-calendar-m11-gen', 'hebrew-calendar-m12-gen',
+ 'hebrew-calendar-m6a-gen', 'hebrew-calendar-m6b-gen'
+ );
+
/**
* Create a language object for a given language code
*/
* @return array
*/
function getDefaultUserOptions() {
+ trigger_error( 'Use of ' . __METHOD__ . ' is deprecated', E_USER_NOTICE );
return User::getDefaultOptions();
}
* If $customisedOnly is true, only returns codes with a messages file
*/
public static function getLanguageNames( $customisedOnly = false ) {
- global $wgLanguageNames;
+ global $wgLanguageNames, $wgExtraLanguageNames;
+ $allNames = $wgExtraLanguageNames + $wgLanguageNames;
if ( !$customisedOnly ) {
- return $wgLanguageNames;
+ return $allNames;
}
global $IP;
$m = array();
if( preg_match( '/Messages([A-Z][a-z_]+)\.php$/', $file, $m ) ) {
$code = str_replace( '_', '-', strtolower( $m[1] ) );
- if ( isset( $wgLanguageNames[$code] ) ) {
- $names[$code] = $wgLanguageNames[$code];
+ if ( isset( $allNames[$code] ) ) {
+ $names[$code] = $allNames[$code];
}
}
}
}
function getLanguageName( $code ) {
- global $wgLanguageNames;
- if ( ! array_key_exists( $code, $wgLanguageNames ) ) {
+ $names = self::getLanguageNames();
+ if ( !array_key_exists( $code, $names ) ) {
return '';
}
- return $wgLanguageNames[$code];
+ return $names[$code];
}
function getMonthName( $key ) {
return $this->getMessageFromDB( self::$mIranianCalendarMonthMsgs[$key-1] );
}
+ function getHebrewCalendarMonthName( $key ) {
+ return $this->getMessageFromDB( self::$mHebrewCalendarMonthMsgs[$key-1] );
+ }
+
+ function getHebrewCalendarMonthNameGen( $key ) {
+ return $this->getMessageFromDB( self::$mHebrewCalendarMonthGenMsgs[$key-1] );
+ }
+
/**
* Used by date() and time() to adjust the time output.
* xn Do not translate digits of the next numeric format character
* xN Toggle raw digit (xn) flag, stays set until explicitly unset
* xr Use roman numerals for the next numeric format character
+ * xh Use hebrew numerals for the next numeric format character
* xx Literal x
* xg Genitive month name
*
* xin n (month number) in Iranian calendar
* xiY Y (full year) in Iranian calendar
*
+ * xjj j (day number) in Hebrew calendar
+ * xjF F (month name) in Hebrew calendar
+ * xjt t (days in month) in Hebrew calendar
+ * xjx xg (genitive month name) in Hebrew calendar
+ * xjn n (month number) in Hebrew calendar
+ * xjY Y (full year) in Hebrew calendar
+ *
+ * xkY Y (full year) in Thai solar calendar. Months and days are
+ * identical to the Gregorian calendar
+ *
* Characters enclosed in double quotes will be considered literal (with
* the quotes themselves removed). Unmatched quotes will be considered
* literal quotes. Example:
$s = '';
$raw = false;
$roman = false;
+ $hebrewNum = false;
$unix = false;
$rawToggle = false;
$iranian = false;
+ $hebrew = false;
+ $thai = false;
for ( $p = 0; $p < strlen( $format ); $p++ ) {
$num = false;
$code = $format[$p];
$code .= $format[++$p];
}
- if ( $code === 'xi' && $p < strlen( $format ) - 1 ) {
+ if ( ( $code === 'xi' || $code == 'xj' || $code == 'xk' ) && $p < strlen( $format ) - 1 ) {
$code .= $format[++$p];
}
case 'xr':
$roman = true;
break;
+ case 'xh':
+ $hebrewNum = true;
+ break;
case 'xg':
$s .= $this->getMonthNameGen( substr( $ts, 4, 2 ) );
break;
+ case 'xjx':
+ if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
+ $s .= $this->getHebrewCalendarMonthNameGen( $hebrew[1] );
+ break;
case 'd':
$num = substr( $ts, 6, 2 );
break;
if ( !$iranian ) $iranian = self::tsToIranian( $ts );
$num = $iranian[2];
break;
+ case 'xjj':
+ if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
+ $num = $hebrew[2];
+ break;
case 'l':
if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
$s .= $this->getWeekdayName( gmdate( 'w', $unix ) + 1 );
if ( !$iranian ) $iranian = self::tsToIranian( $ts );
$s .= $this->getIranianCalendarMonthName( $iranian[1] );
break;
+ case 'xjF':
+ if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
+ $s .= $this->getHebrewCalendarMonthName( $hebrew[1] );
+ break;
case 'm':
$num = substr( $ts, 4, 2 );
break;
if ( !$iranian ) $iranian = self::tsToIranian( $ts );
$num = $iranian[1];
break;
+ case 'xjn':
+ if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
+ $num = $hebrew[1];
+ break;
case 't':
if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
$num = gmdate( 't', $unix );
break;
+ case 'xjt':
+ if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
+ $num = $hebrew[3];
+ break;
case 'L':
if ( !$unix ) $unix = wfTimestamp( TS_UNIX, $ts );
$num = gmdate( 'L', $unix );
if ( !$iranian ) $iranian = self::tsToIranian( $ts );
$num = $iranian[0];
break;
+ case 'xjY':
+ if ( !$hebrew ) $hebrew = self::tsToHebrew( $ts );
+ $num = $hebrew[0];
+ break;
+ case 'xkY':
+ if ( !$thai ) $thai = self::tsToThai( $ts );
+ $num = $thai[0];
+ break;
case 'y':
$num = substr( $ts, 2, 2 );
break;
} elseif ( $roman ) {
$s .= self::romanNumeral( $num );
$roman = false;
+ } elseif( $hebrewNum ) {
+ $s .= self::hebrewNumeral( $num );
+ $hebrewNum = false;
} else {
$s .= $this->formatNum( $num, true );
}
return array($jy, $jm, $jd);
}
+ /**
+ * Converting Gregorian dates to Hebrew dates.
+ *
+ * Based on a JavaScript code by Abu Mami and Yisrael Hersch
+ * (abu-mami@kaluach.net, http://www.kaluach.net), who permitted
+ * to translate the relevant functions into PHP and release them under
+ * GNU GPL.
+ */
+ private static function tsToHebrew( $ts ) {
+ # Parse date
+ $year = substr( $ts, 0, 4 );
+ $month = substr( $ts, 4, 2 );
+ $day = substr( $ts, 6, 2 );
+
+ # Calculate Hebrew year
+ $hebrewYear = $year + 3760;
+
+ # Month number when September = 1, August = 12
+ $month += 4;
+ if( $month > 12 ) {
+ # Next year
+ $month -= 12;
+ $year++;
+ $hebrewYear++;
+ }
+
+ # Calculate day of year from 1 September
+ $dayOfYear = $day;
+ for( $i = 1; $i < $month; $i++ ) {
+ if( $i == 6 ) {
+ # February
+ $dayOfYear += 28;
+ # Check if the year is leap
+ if( $year % 400 == 0 || ( $year % 4 == 0 && $year % 100 > 0 ) ) {
+ $dayOfYear++;
+ }
+ } elseif( $i == 8 || $i == 10 || $i == 1 || $i == 3 ) {
+ $dayOfYear += 30;
+ } else {
+ $dayOfYear += 31;
+ }
+ }
+
+ # Calculate the start of the Hebrew year
+ $start = self::hebrewYearStart( $hebrewYear );
+
+ # Calculate next year's start
+ if( $dayOfYear <= $start ) {
+ # Day is before the start of the year - it is the previous year
+ # Next year's start
+ $nextStart = $start;
+ # Previous year
+ $year--;
+ $hebrewYear--;
+ # Add days since previous year's 1 September
+ $dayOfYear += 365;
+ if( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
+ # Leap year
+ $dayOfYear++;
+ }
+ # Start of the new (previous) year
+ $start = self::hebrewYearStart( $hebrewYear );
+ } else {
+ # Next year's start
+ $nextStart = self::hebrewYearStart( $hebrewYear + 1 );
+ }
+
+ # Calculate Hebrew day of year
+ $hebrewDayOfYear = $dayOfYear - $start;
+
+ # Difference between year's days
+ $diff = $nextStart - $start;
+ # Add 12 (or 13 for leap years) days to ignore the difference between
+ # Hebrew and Gregorian year (353 at least vs. 365/6) - now the
+ # difference is only about the year type
+ if( ( $year % 400 == 0 ) || ( $year % 100 != 0 && $year % 4 == 0 ) ) {
+ $diff += 13;
+ } else {
+ $diff += 12;
+ }
+
+ # Check the year pattern, and is leap year
+ # 0 means an incomplete year, 1 means a regular year, 2 means a complete year
+ # This is mod 30, to work on both leap years (which add 30 days of Adar I)
+ # and non-leap years
+ $yearPattern = $diff % 30;
+ # Check if leap year
+ $isLeap = $diff >= 30;
+
+ # Calculate day in the month from number of day in the Hebrew year
+ # Don't check Adar - if the day is not in Adar, we will stop before;
+ # if it is in Adar, we will use it to check if it is Adar I or Adar II
+ $hebrewDay = $hebrewDayOfYear;
+ $hebrewMonth = 1;
+ $days = 0;
+ while( $hebrewMonth <= 12 ) {
+ # Calculate days in this month
+ if( $isLeap && $hebrewMonth == 6 ) {
+ # Adar in a leap year
+ if( $isLeap ) {
+ # Leap year - has Adar I, with 30 days, and Adar II, with 29 days
+ $days = 30;
+ if( $hebrewDay <= $days ) {
+ # Day in Adar I
+ $hebrewMonth = 13;
+ } else {
+ # Subtract the days of Adar I
+ $hebrewDay -= $days;
+ # Try Adar II
+ $days = 29;
+ if( $hebrewDay <= $days ) {
+ # Day in Adar II
+ $hebrewMonth = 14;
+ }
+ }
+ }
+ } elseif( $hebrewMonth == 2 && $yearPattern == 2 ) {
+ # Cheshvan in a complete year (otherwise as the rule below)
+ $days = 30;
+ } elseif( $hebrewMonth == 3 && $yearPattern == 0 ) {
+ # Kislev in an incomplete year (otherwise as the rule below)
+ $days = 29;
+ } else {
+ # Odd months have 30 days, even have 29
+ $days = 30 - ( $hebrewMonth - 1 ) % 2;
+ }
+ if( $hebrewDay <= $days ) {
+ # In the current month
+ break;
+ } else {
+ # Subtract the days of the current month
+ $hebrewDay -= $days;
+ # Try in the next month
+ $hebrewMonth++;
+ }
+ }
+
+ return array( $hebrewYear, $hebrewMonth, $hebrewDay, $days );
+ }
+
+ /**
+ * This calculates the Hebrew year start, as days since 1 September.
+ * Based on Carl Friedrich Gauss algorithm for finding Easter date.
+ * Used for Hebrew date.
+ */
+ private static function hebrewYearStart( $year ) {
+ $a = intval( ( 12 * ( $year - 1 ) + 17 ) % 19 );
+ $b = intval( ( $year - 1 ) % 4 );
+ $m = 32.044093161144 + 1.5542417966212 * $a + $b / 4.0 - 0.0031777940220923 * ( $year - 1 );
+ if( $m < 0 ) {
+ $m--;
+ }
+ $Mar = intval( $m );
+ if( $m < 0 ) {
+ $m++;
+ }
+ $m -= $Mar;
+
+ $c = intval( ( $Mar + 3 * ( $year - 1 ) + 5 * $b + 5 ) % 7);
+ if( $c == 0 && $a > 11 && $m >= 0.89772376543210 ) {
+ $Mar++;
+ } else if( $c == 1 && $a > 6 && $m >= 0.63287037037037 ) {
+ $Mar += 2;
+ } else if( $c == 2 || $c == 4 || $c == 6 ) {
+ $Mar++;
+ }
+
+ $Mar += intval( ( $year - 3761 ) / 100 ) - intval( ( $year - 3761 ) / 400 ) - 24;
+ return $Mar;
+ }
+
+ /**
+ * Algorithm to convert Gregorian dates to Thai solar dates.
+ *
+ * Link: http://en.wikipedia.org/wiki/Thai_solar_calendar
+ *
+ * @param string $ts 14-character timestamp
+ * @return array converted year, month, day
+ */
+ private static function tsToThai( $ts ) {
+ $gy = substr( $ts, 0, 4 );
+ $gm = substr( $ts, 4, 2 );
+ $gd = substr( $ts, 6, 2 );
+
+ # Add 543 years to the Gregorian calendar
+ # Months and days are identical
+ $gy_thai = $gy + 543;
+
+ return array( $gy_thai, $gm, $gd );
+ }
+
+
/**
* Roman number formatting up to 3000
*/
return $s;
}
+ /**
+ * Hebrew Gematria number formatting up to 9999
+ */
+ static function hebrewNumeral( $num ) {
+ static $table = array(
+ array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' ),
+ array( '', 'י', 'כ', 'ל', 'מ', 'נ', 'ס', 'ע', 'פ', 'צ', 'ק' ),
+ array( '', 'ק', 'ר', 'ש', 'ת', 'תק', 'תר', 'תש', 'תת', 'תתק', 'תתר' ),
+ array( '', 'א', 'ב', 'ג', 'ד', 'ה', 'ו', 'ז', 'ח', 'ט', 'י' )
+ );
+
+ $num = intval( $num );
+ if ( $num > 9999 || $num <= 0 ) {
+ return $num;
+ }
+
+ $s = '';
+ for ( $pow10 = 1000, $i = 3; $i >= 0; $pow10 /= 10, $i-- ) {
+ if ( $num >= $pow10 ) {
+ if ( $num == 15 || $num == 16 ) {
+ $s .= $table[0][9] . $table[0][$num - 9];
+ $num = 0;
+ } else {
+ $s .= $table[$i][intval( ( $num / $pow10 ) )];
+ if( $pow10 == 1000 ) {
+ $s .= "'";
+ }
+ }
+ }
+ $num = $num % $pow10;
+ }
+ if( strlen( $s ) == 2 ) {
+ $str = $s . "'";
+ } else {
+ $str = substr( $s, 0, strlen( $s ) - 2 ) . '"';
+ $str .= substr( $s, strlen( $s ) - 2, 2 );
+ }
+ $start = substr( $str, 0, strlen( $str ) - 2 );
+ $end = substr( $str, strlen( $str ) - 2 );
+ switch( $end ) {
+ case 'כ':
+ $str = $start . 'ך';
+ break;
+ case 'מ':
+ $str = $start . 'ם';
+ break;
+ case 'נ':
+ $str = $start . 'ן';
+ break;
+ case 'פ':
+ $str = $start . 'ף';
+ break;
+ case 'צ':
+ $str = $start . 'ץ';
+ break;
+ }
+ return $str;
+ }
+
/**
* This is meant to be used by time(), date(), and timeanddate() to get
* the date preference they're supposed to use, it should be used in
}
function ucfirst( $str ) {
- return self::uc( $str, true );
+ if ( empty($str) ) return $str;
+ if ( ord($str[0]) < 128 ) return ucfirst($str);
+ else return self::uc($str,true); // fall back to more complex logic in case of multibyte strings
}
function uc( $str, $first = false ) {
}
function lcfirst( $str ) {
- return self::lc( $str, true );
+ if ( empty($str) ) return $str;
+ if ( is_string( $str ) && ord($str[0]) < 128 ) {
+ // editing string in place = cool
+ $str[0]=strtolower($str[0]);
+ return $str;
+ }
+ else return self::lc( $str, true );
}
function lc( $str, $first = false ) {
if( !is_array( $rawEntry ) ) {
error_log( "\"$rawEntry\" is not a valid magic thingie for \"$mw->mId\"" );
+ } else {
+ $mw->mCaseSensitive = $rawEntry[0];
+ $mw->mSynonyms = array_slice( $rawEntry, 1 );
}
- $mw->mCaseSensitive = $rawEntry[0];
- $mw->mSynonyms = array_slice( $rawEntry, 1 );
}
/**
*/
function convertGrammar( $word, $case ) {
global $wgGrammarForms;
- if ( isset($wgGrammarForms['en'][$case][$word]) ) {
- return $wgGrammarForms['en'][$case][$word];
+ if ( isset($wgGrammarForms[$this->getCode()][$case][$word]) ) {
+ return $wgGrammarForms[$this->getCode()][$case][$word];
}
return $word;
}
*
* Example: {{plural:{{NUMBEROFARTICLES}}|article|articles}}
*
- * @param integer $count
- * @param string $wordform1
- * @param string $wordform2
- * @param string $wordform3 (optional)
- * @param string $wordform4 (optional)
- * @param string $wordform5 (optional)
- * @return string
+ * @param integer $count Non-localized number
+ * @param array $forms Different plural forms
+ * @return string Correct form of plural for $count in this language
*/
- function convertPlural( $count, $w1, $w2, $w3, $w4, $w5) {
- return ( $count == '1' || $count == '-1' ) ? $w1 : $w2;
+ function convertPlural( $count, $forms ) {
+ if ( !count($forms) ) { return ''; }
+ $forms = $this->preConvertPlural( $forms, 2 );
+
+ return ( abs($count) == 1 ) ? $forms[0] : $forms[1];
+ }
+
+ /**
+ * Checks that convertPlural was given an array and pads it to requested
+ * amound of forms by copying the last one.
+ *
+ * @param integer $count How many forms should there be at least
+ * @param array $forms Array of forms given to convertPlural
+ * @return array Padded array of forms or an exception if not an array
+ */
+ protected function preConvertPlural( /* Array */ $forms, $count ) {
+ while ( count($forms) < $count ) {
+ $forms[] = $forms[count($forms)-1];
+ }
+ return $forms;
}
/**
*/
static function loadLocalisation( $code, $disableCache = false ) {
static $recursionGuard = array();
- global $wgMemc;
+ global $wgMemc, $wgCheckSerialized;
if ( !$code ) {
throw new MWException( "Invalid language code requested" );
# Try the serialized directory
$cache = wfGetPrecompiledData( self::getFileName( "Messages", $code, '.ser' ) );
if ( $cache ) {
- self::$mLocalisationCache[$code] = $cache;
- wfDebug( "Language::loadLocalisation(): got localisation for $code from precompiled data file\n" );
- wfProfileOut( __METHOD__ );
- return self::$mLocalisationCache[$code]['deps'];
+ if ( $wgCheckSerialized && self::isLocalisationOutOfDate( $cache ) ) {
+ $cache = false;
+ wfDebug( "Language::loadLocalisation(): precompiled data file for $code is out of date\n" );
+ } else {
+ self::$mLocalisationCache[$code] = $cache;
+ wfDebug( "Language::loadLocalisation(): got localisation for $code from precompiled data file\n" );
+ wfProfileOut( __METHOD__ );
+ return self::$mLocalisationCache[$code]['deps'];
+ }
}
# Try the global cache
$memcKey = wfMemcKey('localisation', $code );
$cache = $wgMemc->get( $memcKey );
if ( $cache ) {
- # Check file modification times
- foreach ( $cache['deps'] as $file => $mtime ) {
- if ( !file_exists( $file ) || filemtime( $file ) > $mtime ) {
- break;
- }
- }
if ( self::isLocalisationOutOfDate( $cache ) ) {
$wgMemc->delete( $memcKey );
$cache = false;
- wfDebug( "Language::loadLocalisation(): localisation cache for $code had expired due to update of $file\n" );
+ wfDebug( "Language::loadLocalisation(): localisation cache for $code had expired\n" );
} else {
self::$mLocalisationCache[$code] = $cache;
wfDebug( "Language::loadLocalisation(): got localisation for $code from cache\n" );
# Replace spaces with underscores in namespace names
$cache['namespaceNames'] = str_replace( ' ', '_', $cache['namespaceNames'] );
+
+ # And do the same for specialpage aliases. $page is an array.
+ foreach ( $cache['specialPageAliases'] as &$page ) {
+ $page = str_replace( ' ', '_', $page );
+ }
+ # Decouple the reference to prevent accidental damage
+ unset($page);
# Save to both caches
self::$mLocalisationCache[$code] = $cache;
dépôts / lhc / web / wiklou.git / blobdiff