X-Git-Url: https://git.heureux-cyclage.org/?a=blobdiff_plain;f=includes%2FMessageCache.php;h=e5eb7057ebb50d84110bcd8b7beb0029252cd1fb;hb=ae57ab1eec9f9051fc0e6786e8eff9d01988be19;hp=5b24aaf527ef2670f71f5f509f6354ad02767423;hpb=87afc79d3bb98c4287d17a74b09fbd8ccd63373a;p=lhc%2Fweb%2Fwiklou.git

diff --git a/includes/MessageCache.php b/includes/MessageCache.php
index 5b24aaf527..e5eb7057eb 100644
--- a/includes/MessageCache.php
+++ b/includes/MessageCache.php
@@ -18,32 +18,28 @@ define( 'MSG_CACHE_VERSION', 1 );
  * @ingroup Cache
  */
 class MessageCache {
-	var $mCache, $mUseCache, $mDisable, $mExpiry;
-	var $mMemcKey, $mKeys, $mParserOptions, $mParser;
-	var $mExtensionMessages = array();
-	var $mInitialised = false;
-	var $mAllMessagesLoaded; // Extension messages
+	// Holds loaded messages that are defined in MediaWiki namespace.
+	var $mCache;
 
-	function __construct( &$memCached, $useDB, $expiry, $memcPrefix) {
-		wfProfileIn( __METHOD__ );
+	var $mUseCache, $mDisable, $mExpiry;
+	var $mKeys, $mParserOptions, $mParser;
+
+	// Variable for tracking which variables are loaded
+	var $mLoadedLanguages = array();
 
+	function __construct( &$memCached, $useDB, $expiry, /*ignored*/ $memcPrefix ) {
 		$this->mUseCache = !is_null( $memCached );
 		$this->mMemc = &$memCached;
 		$this->mDisable = !$useDB;
 		$this->mExpiry = $expiry;
 		$this->mDisableTransform = false;
-		$this->mMemcKey = $memcPrefix.':messages';
 		$this->mKeys = false; # initialised on demand
-		$this->mInitialised = true;
 		$this->mParser = null;
-
-		wfProfileOut( __METHOD__ );
 	}
 
 
 	/**
 	 * ParserOptions is lazy initialised.
-	 * Access should probably be protected.
 	 */
 	function getParserOptions() {
 		if ( !$this->mParserOptions ) {
@@ -62,10 +58,9 @@ class MessageCache {
 	 * @return false on failure.
 	 */
 	function loadFromLocal( $hash, $code ) {
-		global $wgLocalMessageCache, $wgLocalMessageCacheSerialized;
+		global $wgCacheDirectory, $wgLocalMessageCacheSerialized;
 
-		$filename = "$wgLocalMessageCache/messages-" . wfWikiID();
-		if ( $code ) $filename .= '-' . $code;
+		$filename = "$wgCacheDirectory/messages-" . wfWikiID() . "-$code";
 
 		# Check file existence
 		wfSuppressWarnings();
@@ -85,7 +80,7 @@ class MessageCache {
 					$serialized .= fread( $file, 100000 );
 				}
 				fclose( $file );
-				return $this->setCache( unserialize( $serialized ) );
+				return $this->setCache( unserialize( $serialized ), $code );
 			} else {
 				fclose( $file );
 				return false; // Wrong hash
@@ -97,24 +92,25 @@ class MessageCache {
 				return false; // Wrong hash
 			}
 
+			# Require overwrites the member variable or just shadows it?
 			require( $filename );
-			return $this->setCache( $this->mCache );
+			return $this->setCache( $this->mCache, $code );
 		}
 	}
 
 	/**
-	 * Save the cache to a local file
+	 * Save the cache to a local file.
 	 */
-	function saveToLocal( $serialized, $hash, $code  ) {
-		global $wgLocalMessageCache;
-
-		$filename = "$wgLocalMessageCache/messages-" . wfWikiID();
-		if ( $code ) $filename .= '-' . $code;
+	function saveToLocal( $serialized, $hash, $code ) {
+		global $wgCacheDirectory;
 
-		# Make sure the directories exist
-		$this->createCacheDir( $wgLocalMessageCache );
+		$filename = "$wgCacheDirectory/messages-" . wfWikiID() . "-$code";
+		wfMkdirParents( $wgCacheDirectory ); // might fail
 
+		wfSuppressWarnings();
 		$file = fopen( $filename, 'w' );
+		wfRestoreWarnings();
+
 		if ( !$file ) {
 			wfDebug( "Unable to open local cache file for writing\n" );
 			return;
@@ -126,16 +122,21 @@ class MessageCache {
 	}
 
 	function saveToScript( $array, $hash, $code ) {
-		global $wgLocalMessageCache;
+		global $wgCacheDirectory;
 
-		$filename = "$wgLocalMessageCache/messages-" . wfWikiID();
-		if ( $code ) $filename .= '-' . $code;
+		$filename = "$wgCacheDirectory/messages-" . wfWikiID() . "-$code";
 		$tempFilename = $filename . '.tmp';
+  		wfMkdirParents( $wgCacheDirectory ); // might fail
 
-		# Make sure the directories exist
-		$this->createCacheDir( $wgLocalMessageCache );
-
+		wfSuppressWarnings();
 		$file = fopen( $tempFilename, 'w');
+		wfRestoreWarnings();
+
+		if ( !$file ) {
+			wfDebug( "Unable to open local cache file for writing\n" );
+			return;
+		}
+
 		fwrite($file,"<?php\n//$hash\n\n \$this->mCache = array(");
 
 		foreach ($array as $key => $message) {
@@ -149,17 +150,6 @@ class MessageCache {
 		rename($tempFilename, $filename);
 	}
 
-	/**
-	 * Creates directory with correct permissions.
-	 *
-	 * @param $path String: path that is created if it does not exist.
-	 */
-	protected function createCacheDir( $path ) {
-		$oldUmask = umask( 0 );
-		wfMkdirParents( $path, 0777 );
-		umask( $oldUmask );
-	}
-
 	function escapeForScript($string) {
 		$string = str_replace( '\\', '\\\\', $string );
 		$string = str_replace( '\'', '\\\'', $string );
@@ -169,13 +159,9 @@ class MessageCache {
 	/**
 	 * Set the cache to $cache, if it is valid. Otherwise set the cache to false.
 	 */
-	function setCache( $cache ) {
+	function setCache( $cache, $code ) {
 		if ( isset( $cache['VERSION'] ) && $cache['VERSION'] == MSG_CACHE_VERSION ) {
-			if ( $this->mCache ) {
-				$this->mCache = $cache + $this->mCache;
-			} else {
-				$this->mCache = $cache;
-			}
+			$this->mCache[$code] = $cache;
 			return true;
 		} else {
 			return false;
@@ -184,7 +170,7 @@ class MessageCache {
 
 	/**
 	 * Loads messages from caches or from database in this order:
-	 * (1) local message cache (if $wgLocalMessageCache is enabled)
+	 * (1) local message cache (if $wgUseLocalMessageCache is enabled)
 	 * (2) memcached
 	 * (3) from the database.
 	 *
@@ -198,35 +184,24 @@ class MessageCache {
 	 * or false if populating empty cache fails. Also returns true if MessageCache
 	 * is disabled.
 	 *
-	 * @param $code Mixed: if evaluates to false, messages for all languages is
-	 *              loaded and stored in cache as one object. If code is provided
-	 *              and $wgPerLanguageCaching is true, messages are loaded per
-	 *              language and stored individually in caches 1 to 2.
+	 * @param $code String: language to which load messages
 	 */
 	function load( $code = false ) {
-		global $wgLocalMessageCache, $wgPerLanguageCaching;
+		global $wgUseLocalMessageCache;
 
 		if ( !$this->mUseCache ) {
 			return true;
 		}
 
-		# Keep track of loaded messages. Either array of loaded codes as keys,
-		# or just true if all languages are loaded.
-		static $loaded = false;
-
-		if ( !$wgPerLanguageCaching ) {
-			// Disable language separation for normal use case
-			$code = false;
-		} elseif( !is_string( $code ) ) {
-			# This isn't really nice, so at least make a note about it
+		if( !is_string( $code ) ) {
+			# This isn't really nice, so at least make a note about it and try to
+			# fall back
 			wfDebug( __METHOD__ . " called without providing a language code\n" );
+			$code = 'en';
 		}
 
 		# Don't do double loading...
-		if ( $loaded === true || ($code && isset($loaded[$code])) ) return true;
-
-		# Adjust cache key if we are handling only single language
-		$cacheKey = wfMemcKeyLang( $this->mMemcKey, $code );
+		if ( isset($this->mLoadedLanguages[$code]) ) return true;
 
 		# 8 lines of code just to say (once) that message cache is disabled
 		if ( $this->mDisable ) {
@@ -242,13 +217,16 @@ class MessageCache {
 		wfProfileIn( __METHOD__ );
 		$success = false; # Keep track of success
 		$where = array(); # Debug info, delayed to avoid spamming debug log too much
+		$cacheKey = wfMemcKey( 'messages', $code ); # Key in memc for messages
+
 
 		# (1) local cache
 		# Hash of the contents is stored in memcache, to detect if local cache goes
 		# out of date (due to update in other thread?)
-		if ( $wgLocalMessageCache !== false ) {
+		if ( $wgUseLocalMessageCache ) {
 			wfProfileIn( __METHOD__ . '-fromlocal' );
-			$hash = $this->mMemc->get( "$cacheKey-hash" );
+
+			$hash = $this->mMemc->get( wfMemcKey( 'messages', $code, 'hash' ) );
 			if ( $hash ) {
 				$success = $this->loadFromLocal( $hash, $code );
 				if ( $success ) $where[] = 'got from local cache';
@@ -261,10 +239,10 @@ class MessageCache {
 		if ( !$success ) {
 			wfProfileIn( __METHOD__ . '-fromcache' );
 			$cache = $this->mMemc->get( $cacheKey );
-			$success = $this->setCache( $cache );
+			$success = $this->setCache( $cache, $code );
 			if ( $success ) {
 				$where[] = 'got from global cache';
-				$this->saveToCaches( $cache, $cacheKey, false, $code );
+				$this->saveToCaches( $cache, false, $code );
 			}
 			wfProfileOut( __METHOD__ . '-fromcache' );
 		}
@@ -274,16 +252,26 @@ class MessageCache {
 		# Nothing in caches... so we need create one and store it in caches
 		if ( !$success ) {
 			$where[] = 'cache is empty';
-			$this->lock($cacheKey);
-			wfProfileIn( __METHOD__ . '-load' );
 			$where[] = 'loading from database';
-			# We want to store messages of particular language here, not everything
-			# from mCache.
-			$cache = $this->loadFromDB( $code );
-			$success = $this->setCache( $cache );
-			wfProfileOut( __METHOD__ . '-load' );
+
+			$this->lock($cacheKey);
+
+			# Limit the concurrency of loadFromDB to a single process 
+			# This prevents the site from going down when the cache expires
+			$statusKey = wfMemcKey( 'messages', $code, 'status' );
+			$success = $this->mMemc->add( $statusKey, 'loading', MSG_LOAD_TIMEOUT );
 			if ( $success ) {
-				$this->saveToCaches( $cache, $cacheKey, true, $code );
+				$cache = $this->loadFromDB( $code );
+				$success = $this->setCache( $cache, $code );
+			}
+			if ( $success ) {
+				$success = $this->saveToCaches( $cache, true, $code );
+				if ( $success ) {
+					$this->mMemc->delete( $statusKey );
+				} else {
+					$this->mMemc->set( $statusKey, 'error', 60*5 );
+					wfDebug( "MemCached set error in MessageCache: restart memcached server!\n" );
+				}
 			}
 			$this->unlock($cacheKey);
 		}
@@ -299,11 +287,7 @@ class MessageCache {
 			# All good, just record the success
 			$info = implode( ', ', $where );
 			wfDebug( __METHOD__ . ": Loading $code... $info\n" );
-			if ( $code ) {
-				$loaded[$code] = true;
-			} else {
-				$loaded = true;
-			}
+			$this->mLoadedLanguages[$code] = true;
 		}
 		wfProfileOut( __METHOD__ );
 		return $success;
@@ -330,16 +314,15 @@ class MessageCache {
 		);
 
 		if ( $code ) {
-			# Should $code be escaped?
 			# Is this fast enough. Should not matter if the filtering is done in the
 			# database or in code.
 			if ( $code !== $wgContLanguageCode ) {
 				# Messages for particular language
-				$conds[] = "page_title like '%%/$code'";
+				$conds[] = 'page_title' . $dbr->buildLike( $dbr->anyString(), "/$code" );
 			} else {
 				# Effectively disallows use of '/' character in NS_MEDIAWIKI for uses
 				# other than language code.
-				$conds[] = "page_title not like '%%/%%'";
+				$conds[] = 'page_title NOT' . $dbr->buildLike( $dbr->anyString(), '/', $dbr->anyString() );
 			}
 		}
 
@@ -362,7 +345,7 @@ class MessageCache {
 
 		$res = $dbr->select( array( 'page', 'revision', 'text' ),
 			array( 'page_title', 'old_text', 'old_flags' ),
-			$smallConds, __METHOD__ );
+			$smallConds, __METHOD__. "($code)" );
 
 		for ( $row = $dbr->fetchObject( $res ); $row; $row = $dbr->fetchObject( $res ) ) {
 			$cache[$row->page_title] = ' ' . Revision::getRevisionText( $row );
@@ -381,46 +364,55 @@ class MessageCache {
 	 * @param $text Mixed: new contents of the page.
 	 */
 	public function replace( $title, $text ) {
-		global $wgMaxMsgCacheEntrySize, $wgPerLanguageCaching;
-
-		list( $message, $code ) = $this->figureMessage( $title );
+		global $wgMaxMsgCacheEntrySize;
+		wfProfileIn( __METHOD__ );
 
-		# TODO: Should we define the sidebar key name somewhere?
-		$sidebarKey = wfMemcKeyLang( 'sidebar' , $code );
 
-		# Load only messages for affected language, if possible
-		if ( !$wgPerLanguageCaching ) $code = false;
-		$cacheKey = wfMemcKeyLang( $this->mMemcKey, $code );
+		list( , $code ) = $this->figureMessage( $title );
 
-		wfProfileIn( __METHOD__ );
+		$cacheKey = wfMemcKey( 'messages', $code );
+		$this->load($code);
 		$this->lock($cacheKey);
 
-		$cache = $this->mMemc->get( $cacheKey );
-		if ( is_array( $cache ) ) {
+		if ( is_array($this->mCache[$code]) ) {
+			$titleKey = wfMemcKey( 'messages', 'individual', $title );
+
 			if ( $text === false ) {
 				# Article was deleted
-				unset( $this->mCache[$title] );
-				$this->mMemc->delete( "$this->mMemcKey:{$title}" );
+				unset( $this->mCache[$code][$title] );
+				$this->mMemc->delete( $titleKey );
+
 			} elseif ( strlen( $text ) > $wgMaxMsgCacheEntrySize ) {
-				$cache[$title] = $this->mCache[$title] = '!TOO BIG';
-				$this->mMemc->set( "$this->mMemcKey:{$title}", ' '.$text, $this->mExpiry );
+				# Check for size
+				$this->mCache[$code][$title] = '!TOO BIG';
+				$this->mMemc->set( $titleKey, ' ' . $text, $this->mExpiry );
+
 			} else {
-				$cache[$title] = $this->mCache[$title] = ' ' . $text;
-				$this->mMemc->delete( "$this->mMemcKey:{$title}" );
+				$this->mCache[$code][$title] = ' ' . $text;
+				$this->mMemc->delete( $titleKey );
 			}
 
-			# Update per-request cache
-			$success = $this->setCache( $cache, $cacheKey );
-			if ( $success ) {
-				# And then all caches
-				$this->saveToCaches( $cache, $cacheKey, true, $code );
-			}
+			# Update caches
+			$this->saveToCaches( $this->mCache[$code], true, $code );
 		}
 		$this->unlock($cacheKey);
 
 		// Also delete cached sidebar... just in case it is affected
 		global $parserMemc;
-		$parserMemc->delete( $sidebarKey );
+		$codes = array( $code );
+		if ( $code === 'en'  ) {
+			// Delete all sidebars, like for example on action=purge on the
+			// sidebar messages
+			$codes = array_keys( Language::getLanguageNames() );
+		}
+
+		foreach ( $codes as $code ) {
+			$sidebarKey = wfMemcKey( 'sidebar', $code );
+			$parserMemc->delete( $sidebarKey );
+		}
+
+		wfRunHooks( "MessageCacheReplace", array( $title, $text ) );
+
 		wfProfileOut( __METHOD__ );
 	}
 
@@ -433,30 +425,23 @@ class MessageCache {
 	 * @param $code String: Language code.
 	 * @return False on somekind of error.
 	 */
-	protected function saveToCaches( $cache, $cacheKey, $memc = true, $code = false ) {
+	protected function saveToCaches( $cache, $memc = true, $code = false ) {
 		wfProfileIn( __METHOD__ );
-		global $wgLocalMessageCache, $wgLocalMessageCacheSerialized;
+		global $wgUseLocalMessageCache, $wgLocalMessageCacheSerialized;
 
-		$success = $this->mMemc->add( $cacheKey.'-status', "loading", MSG_LOAD_TIMEOUT );
-		if ( !$success ) return true; # Other process should be updating them now
+		$cacheKey = wfMemcKey( 'messages', $code );
 
-		$i = 0;
 		if ( $memc ) {
-			# Save in memcached
-			# Keep trying if it fails, this is kind of important
-
-			for ($i=0; $i<20 &&
-							!$this->mMemc->set( $cacheKey, $cache, $this->mExpiry );
-					$i++ ) {
-				usleep(mt_rand(500000,1500000));
-			}
+			$success = $this->mMemc->set( $cacheKey, $cache, $this->mExpiry );
+		} else {
+			$success = true;
 		}
 
 		# Save to local cache
-		if ( $wgLocalMessageCache !== false ) {
+		if ( $wgUseLocalMessageCache ) {
 			$serialized = serialize( $cache );
 			$hash = md5( $serialized );
-			$this->mMemc->set( "$cacheKey-hash", $hash, $this->mExpiry );
+			$this->mMemc->set( wfMemcKey( 'messages', $code, 'hash' ), $hash, $this->mExpiry );
 			if ($wgLocalMessageCacheSerialized) {
 				$this->saveToLocal( $serialized, $hash, $code );
 			} else {
@@ -464,14 +449,6 @@ class MessageCache {
 			}
 		}
 
-		if ( $i == 20 ) {
-			$this->mMemc->set( $cacheKey.'-status', 'error', 60*5 );
-			wfDebug( "MemCached set error in MessageCache: restart memcached server!\n" );
-			$success = false;
-		} else {
-			$this->mMemc->delete( $cacheKey.'-status' );
-			$success = true;
-		}
 		wfProfileOut( __METHOD__ );
 		return $success;
 	}
@@ -485,7 +462,7 @@ class MessageCache {
 			return true;
 		}
 
-		$lockKey = $key . 'lock';
+		$lockKey = $key . ':lock';
 		for ($i=0; $i < MSG_WAIT_TIMEOUT && !$this->mMemc->add( $lockKey, 1, MSG_LOCK_TIMEOUT ); $i++ ) {
 			sleep(1);
 		}
@@ -498,7 +475,7 @@ class MessageCache {
 			return;
 		}
 
-		$lockKey = $key . 'lock';
+		$lockKey = $key . ':lock';
 		$this->mMemc->delete( $lockKey );
 	}
 
@@ -516,62 +493,40 @@ class MessageCache {
 	 *                         functionality), or if it is a true boolean then
 	 *                         use the wikis content language (also as a
 	 *                         fallback).
-	 * @param bool $isFullKey Specifies whether $key is a two part key "lang/msg".
+	 * @param bool $isFullKey Specifies whether $key is a two part key "msg/lang".
 	 */
 	function get( $key, $useDB = true, $langcode = true, $isFullKey = false ) {
-		global $wgContLanguageCode, $wgContLang, $wgLang;
-
-		# Identify which language to get or create a language object for.
-		if( $langcode === $wgContLang->getCode() || $langcode === true ) {
-			# $langcode is the language code of the wikis content language object.
-			# or it is a boolean and value is true
-			$lang =& $wgContLang;
-		} elseif( $langcode === $wgLang->getCode() || $langcode === false ) {
-			# $langcode is the language code of user language object.
-			# or it was a boolean and value is false
-			$lang =& $wgLang;
-		} else {
-			$validCodes = array_keys( Language::getLanguageNames() );
-			if( in_array( $langcode, $validCodes ) ) {
-				# $langcode corresponds to a valid language.
-				$lang = Language::factory( $langcode );
-			} else {
-				# $langcode is a string, but not a valid language code; use content language.
-				$lang =& $wgContLang;
-				wfDebug( 'Invalid language code passed to MessageCache::get, falling back to content language.' );
-			}
+		global $wgContLanguageCode, $wgContLang;
+
+		if ( strval( $key ) === '' ) {
+			# Shortcut: the empty key is always missing
+			return '&lt;&gt;';
 		}
 
+		$lang = wfGetLangObj( $langcode );
 		$langcode = $lang->getCode();
 
-		# If uninitialised, someone is trying to call this halfway through Setup.php
-		if( !$this->mInitialised ) {
-			return '&lt;' . htmlspecialchars($key) . '&gt;';
-		}
-
 		$message = false;
 
-		# Normalise title-case input
-		$lckey = $wgContLang->lcfirst( $key );
-		$lckey = str_replace( ' ', '_', $lckey );
+		# Normalise title-case input (with some inlining)
+		$lckey = str_replace( ' ', '_', $key );
+		if ( ord( $key ) < 128 ) {
+			$lckey[0] = strtolower( $lckey[0] );
+			$uckey = ucfirst( $lckey );
+		} else {
+			$lckey = $wgContLang->lcfirst( $lckey );
+			$uckey = $wgContLang->ucfirst( $lckey );
+		}
 
 		# Try the MediaWiki namespace
 		if( !$this->mDisable && $useDB ) {
-			$title = $wgContLang->ucfirst( $lckey );
-			if(!$isFullKey && ($langcode != $wgContLanguageCode) ) {
+			$title = $uckey;
+			if(!$isFullKey && ( $langcode != $wgContLanguageCode ) ) {
 				$title .= '/' . $langcode;
 			}
 			$message = $this->getMsgFromNamespace( $title, $langcode );
 		}
 
-		# Try the extension array
-		if ( $message === false && isset( $this->mExtensionMessages[$langcode][$lckey] ) ) {
-			$message = $this->mExtensionMessages[$langcode][$lckey];
-		}
-		if ( $message === false && isset( $this->mExtensionMessages['en'][$lckey] ) ) {
-			$message = $this->mExtensionMessages['en'][$lckey];
-		}
-
 		# Try the array in the language object
 		if ( $message === false ) {
 			$message = $lang->getMessage( $lckey );
@@ -581,19 +536,15 @@ class MessageCache {
 		}
 
 		# Try the array of another language
-		$pos = strrpos( $lckey, '/' );
-		if( $message === false && $pos !== false) {
-			$mkey = substr( $lckey, 0, $pos );
-			$code = substr( $lckey, $pos+1 );
-			if ( $code ) {
-				$validCodes = array_keys( Language::getLanguageNames() );
-				if ( in_array( $code, $validCodes ) ) {
-					$message = Language::getMessageFor( $mkey, $code );
-					if ( is_null( $message ) ) {
-						$message = false;
-					}
-				} else {
-					wfDebug( __METHOD__ . ": Invalid code $code for $mkey/$code, not trying messages array\n" );
+		if( $message === false ) {
+			$parts = explode( '/', $lckey );
+			# We may get calls for things that are http-urls from sidebar
+			# Let's not load nonexistent languages for those
+			# They usually have more than one slash.
+			if ( count( $parts ) == 2 && $parts[1] !== '' ) {
+				$message = Language::getMessageFor( $parts[0], $parts[1] );
+				if ( is_null( $message ) ) {
+					$message = false;
 				}
 			}
 		}
@@ -602,13 +553,23 @@ class MessageCache {
 		if( ($message === false || $message === '-' ) &&
 			!$this->mDisable && $useDB &&
 			!$isFullKey && ($langcode != $wgContLanguageCode) ) {
-			$message = $this->getMsgFromNamespace( $wgContLang->ucfirst( $lckey ), $wgContLanguageCode );
+			$message = $this->getMsgFromNamespace( $uckey, $wgContLanguageCode );
 		}
 
 		# Final fallback
 		if( $message === false ) {
 			return '&lt;' . htmlspecialchars($key) . '&gt;';
 		}
+
+		# Fix whitespace
+		$message = strtr( $message, 
+			array(
+				# Fix for trailing whitespace, removed by textarea
+				'&#32;' => ' ',
+				# Fix for NBSP, converted to space by firefox
+				'&nbsp;' => "\xc2\xa0",
+			) );
+
 		return $message;
 	}
 
@@ -620,17 +581,13 @@ class MessageCache {
 	 * @param $code String: code denoting the language to try.
 	 */
 	function getMsgFromNamespace( $title, $code ) {
-		$message = false;
 		$type = false;
+		$message = false;
 
 		if ( $this->mUseCache ) {
-			if ( !isset($this->mCache[$title]) ) {
-				# Delay loading as far as possible, and only load messages for requested
-				# language.
-				$this->load( $code );
-			}
-			if (isset( $this->mCache[$title] ) ) {
-				$entry = $this->mCache[$title];
+			$this->load( $code );
+			if (isset( $this->mCache[$code][$title] ) ) {
+				$entry = $this->mCache[$code][$title];
 				$type = substr( $entry, 0, 1 );
 				if ( $type == ' ' ) {
 					return substr( $entry, 1 );
@@ -645,28 +602,28 @@ class MessageCache {
 		}
 
 		# If there is no cache entry and no placeholder, it doesn't exist
-		if ( $type != '!' && $message === false ) {
+		if ( $type !== '!' ) {
 			return false;
 		}
 
-		$memcKey = $this->mMemcKey . ':' . $title;
+		$titleKey = wfMemcKey( 'messages', 'individual', $title );
 
 		# Try the individual message cache
 		if ( $this->mUseCache ) {
-			$entry = $this->mMemc->get( $memcKey );
+			$entry = $this->mMemc->get( $titleKey );
 			if ( $entry ) {
 				$type = substr( $entry, 0, 1 );
 
-				if ( $type == ' ' ) {
+				if ( $type === ' ' ) {
 					# Ok!
 					$message = substr( $entry, 1 );
-					$this->mCache[$title] = $entry;
+					$this->mCache[$code][$title] = $entry;
 					return $message;
-				} elseif ( $entry == '!NONEXISTENT' ) {
+				} elseif ( $entry === '!NONEXISTENT' ) {
 					return false;
 				} else {
 					# Corrupt/obsolete entry, delete it
-					$this->mMemc->delete( $memcKey );
+					$this->mMemc->delete( $titleKey );
 				}
 
 			}
@@ -677,32 +634,43 @@ class MessageCache {
 		if( $revision ) {
 			$message = $revision->getText();
 			if ($this->mUseCache) {
-				$this->mCache[$title] = ' ' . $message;
-				$this->mMemc->set( $memcKey, $message, $this->mExpiry );
+				$this->mCache[$code][$title] = ' ' . $message;
+				$this->mMemc->set( $titleKey, $message, $this->mExpiry );
 			}
 		} else {
 			# Negative caching
 			# Use some special text instead of false, because false gets converted to '' somewhere
-			$this->mMemc->set( $memcKey, '!NONEXISTENT', $this->mExpiry );
-			$this->mCache[$title] = false;
+			$this->mMemc->set( $titleKey, '!NONEXISTENT', $this->mExpiry );
+			$this->mCache[$code][$title] = false;
 		}
 		return $message;
 	}
 
-	function transform( $message, $interface = false ) {
-		global $wgParser;
+	function transform( $message, $interface = false, $language = null ) {
+		// Avoid creating parser if nothing to transform
+		if( strpos( $message, '{{' ) === false ) {
+			return $message;
+		}
+
+		global $wgParser, $wgParserConf;
 		if ( !$this->mParser && isset( $wgParser ) ) {
 			# Do some initialisation so that we don't have to do it twice
 			$wgParser->firstCallInit();
 			# Clone it and store it
-			$this->mParser = clone $wgParser;
+			$class = $wgParserConf['class'];
+			if ( $class == 'Parser_DiffTest' ) {
+				# Uncloneable
+				$this->mParser = new $class( $wgParserConf );
+			} else {
+				$this->mParser = clone $wgParser;
+			}
+			#wfDebug( __METHOD__ . ": following contents triggered transform: $message\n" );
 		}
 		if ( $this->mParser ) {
-			if( strpos( $message, '{{' ) !== false ) {
-				$popts = $this->getParserOptions();
-				$popts->setInterfaceMessage( $interface );
-				$message = $this->mParser->transformMsg( $message, $popts );
-			}
+			$popts = $this->getParserOptions();
+			$popts->setInterfaceMessage( $interface );
+			$popts->setTargetLanguage( $language );
+			$message = $this->mParser->transformMsg( $message, $popts );
 		}
 		return $message;
 	}
@@ -726,161 +694,91 @@ class MessageCache {
 	}
 
 	/**
+	 * Clear all stored messages. Mainly used after a mass rebuild.
+	 */
+	function clear() {
+		if( $this->mUseCache ) {
+			$langs = Language::getLanguageNames( false );
+			foreach ( array_keys($langs) as $code ) {
+				# Global cache
+				$this->mMemc->delete( wfMemcKey( 'messages', $code ) );
+				# Invalidate all local caches
+				$this->mMemc->delete( wfMemcKey( 'messages', $code, 'hash' ) );
+			}
+		}
+	}
+
+ 	/**
 	 * Add a message to the cache
+	 * @deprecated Use $wgExtensionMessagesFiles
 	 *
 	 * @param mixed $key
 	 * @param mixed $value
 	 * @param string $lang The messages language, English by default
 	 */
 	function addMessage( $key, $value, $lang = 'en' ) {
-		$this->mExtensionMessages[$lang][$key] = $value;
+		wfDeprecated( __METHOD__ );
+		$lc = Language::getLocalisationCache();
+		$lc->addLegacyMessages( array( $lang => array( $key => $value ) ) );
 	}
 
 	/**
 	 * Add an associative array of message to the cache
+	 * @deprecated Use $wgExtensionMessagesFiles
 	 *
 	 * @param array $messages An associative array of key => values to be added
 	 * @param string $lang The messages language, English by default
 	 */
 	function addMessages( $messages, $lang = 'en' ) {
-		wfProfileIn( __METHOD__ );
-		if ( !is_array( $messages ) ) {
-			throw new MWException( __METHOD__.': Invalid message array' );
-		}
-		if ( isset( $this->mExtensionMessages[$lang] ) ) {
-			$this->mExtensionMessages[$lang] = $messages + $this->mExtensionMessages[$lang];
-		} else {
-			$this->mExtensionMessages[$lang] = $messages;
-		}
-		wfProfileOut( __METHOD__ );
+		wfDeprecated( __METHOD__ );
+		$lc = Language::getLocalisationCache();
+		$lc->addLegacyMessages( array( $lang => $messages ) );
 	}
 
 	/**
 	 * Add a 2-D array of messages by lang. Useful for extensions.
+	 * @deprecated Use $wgExtensionMessagesFiles
 	 *
 	 * @param array $messages The array to be added
 	 */
 	function addMessagesByLang( $messages ) {
-		wfProfileIn( __METHOD__ );
-		foreach ( $messages as $key => $value ) {
-			$this->addMessages( $value, $key );
-		}
-		wfProfileOut( __METHOD__ );
+		wfDeprecated( __METHOD__ );
+		$lc = Language::getLocalisationCache();
+		$lc->addLegacyMessages( $messages );
 	}
 
 	/**
-	 * Get the extension messages for a specific language. Only English, interface
-	 * and content language are guaranteed to be loaded.
-	 *
-	 * @param string $lang The messages language, English by default
+	 * Set a hook for addMessagesByLang()
 	 */
-	function getExtensionMessagesFor( $lang = 'en' ) {
-		wfProfileIn( __METHOD__ );
-		$messages = array();
-		if ( isset( $this->mExtensionMessages[$lang] ) ) {
-			$messages = $this->mExtensionMessages[$lang];
-		}
-		if ( $lang != 'en' ) {
-			$messages = $messages + $this->mExtensionMessages['en'];
-		}
-		wfProfileOut( __METHOD__ );
-		return $messages;
+	function setExtensionMessagesHook( $callback ) {
+		$this->mAddMessagesHook = $callback;
 	}
 
 	/**
-	 * Clear all stored messages. Mainly used after a mass rebuild.
+	 * @deprecated
 	 */
-	function clear() {
-		global $wgLocalMessageCache;
-		if( $this->mUseCache ) {
-			# Global cache
-			$this->mMemc->delete( $this->mMemcKey );
-			# Invalidate all local caches
-			$this->mMemc->delete( "{$this->mMemcKey}-hash" );
-		}
-	}
-
-	function loadAllMessages() {
-		global $wgExtensionMessagesFiles;
-		if ( $this->mAllMessagesLoaded ) {
-			return;
-		}
-		$this->mAllMessagesLoaded = true;
-
-		# Some extensions will load their messages when you load their class file
-		wfLoadAllExtensions();
-		# Others will respond to this hook
-		wfRunHooks( 'LoadAllMessages' );
-		# Some register their messages in $wgExtensionMessagesFiles
-		foreach ( $wgExtensionMessagesFiles as $name => $file ) {
-			wfLoadExtensionMessages( $name );
-		}
-		# Still others will respond to neither, they are EVIL. We sometimes need to know!
+	function loadAllMessages( $lang = false ) {
 	}
 
 	/**
-	 * Load messages from a given file
-	 * 
-	 * @param string $filename Filename of file to load.
-	 * @param string $langcode Language to load messages for, or false for 
-     *                         default behvaiour (en, content language and user
-     *                         language).
+	 * @deprecated
 	 */
 	function loadMessagesFile( $filename, $langcode = false ) {
-		global $wgLang, $wgContLang;
-		$messages = $magicWords = false;
-		require( $filename );
-
-		$validCodes = Language::getLanguageNames();
-		if( is_string( $langcode ) && array_key_exists( $langcode, $validCodes ) ) {
-			# Load messages for given language code.
-			$this->processMessagesArray( $messages, $langcode );
-		} elseif( is_string( $langcode ) && !array_key_exists( $langcode, $validCodes ) ) {
-			wfDebug( "Invalid language '$langcode' code passed to MessageCache::loadMessagesFile()" );
-		} else {
-			# Load only languages that are usually used, and merge all
-			# fallbacks, except English.
-			$langs = array_unique( array( 'en', $wgContLang->getCode(), $wgLang->getCode() ) );
-			foreach( $langs as $code ) {
-				$this->processMessagesArray( $messages, $code );
-			}
-		}
-
-		if ( $magicWords !== false ) {
-			global $wgContLang;
-			$wgContLang->addMagicWordsByLang( $magicWords );
-		}
-	}
-
-	/**
-	 * Process an array of messages, loading it into the message cache.
-	 *
-	 * @param array $messages Messages array.
-	 * @param string $langcode Language code to process.
-	 */
-	function processMessagesArray( $messages, $langcode ) {
-		$fallbackCode = $langcode;
-		$mergedMessages = array();
-		do {
-			if ( isset($messages[$fallbackCode]) ) {
-				$mergedMessages += $messages[$fallbackCode];
-			}
-			$fallbackCode = Language::getFallbackfor( $fallbackCode );
-		} while( $fallbackCode && $fallbackCode !== 'en' );
-		
-		if ( !empty($mergedMessages) )
-			$this->addMessages( $mergedMessages, $langcode );
 	}
 
 	public function figureMessage( $key ) {
 		global $wgContLanguageCode;
-		$pieces = explode('/', $key, 2);
+		$pieces = explode( '/', $key );
+		if( count( $pieces ) < 2 )
+			return array( $key, $wgContLanguageCode );
 
-		$key = $pieces[0];
+		$lang = array_pop( $pieces );
+		$validCodes = Language::getLanguageNames();
+		if( !array_key_exists( $lang, $validCodes ) )
+			return array( $key, $wgContLanguageCode );
 
-		# Language the user is translating to
-		$langCode = isset($pieces[1]) ? $pieces[1] : $wgContLanguageCode;
-		return array( $key, $langCode );
+		$message = implode( '/', $pieces );
+		return array( $message, $lang );
 	}
 
 }