MSVC 2010 does not have <mutex> or <thread> either, adding the Std* files back

Source/Core/Common/Common.vcxproj

@@ -242,6 +242,8 @@
     <ClInclude Include="Src\Setup.h" />
     <ClInclude Include="Src\stdafx.h" />
     <ClInclude Include="Src\StdConditionVariable.h" />
+    <ClInclude Include="Src\StdMutex.h" />
+    <ClInclude Include="Src\StdThread.h" />
     <ClInclude Include="Src\StringUtil.h" />
     <ClInclude Include="Src\SymbolDB.h" />
     <ClInclude Include="Src\SysConf.h" />

Source/Core/Common/Common.vcxproj.filters

@@ -85,7 +85,7 @@
     <ClInclude Include="Src\SDCardUtil.h" />
     <ClInclude Include="Src\Setup.h" />
     <ClInclude Include="Src\stdafx.h" />
-    <ClInclude Include="Src\StdConditionVariable.h" />
+    <ClInclude Include="Src\StdThread.h" />
     <ClInclude Include="Src\StringUtil.h" />
     <ClInclude Include="Src\SymbolDB.h" />
     <ClInclude Include="Src\SysConf.h" />
@@ -119,6 +119,8 @@
     <ClInclude Include="Src\Crypto\tools.h">
       <Filter>Crypto</Filter>
     </ClInclude>
+    <ClInclude Include="Src\StdMutex.h" />
+    <ClInclude Include="Src\StdConditionVariable.h" />
     <ClInclude Include="Src\x64ABI.h" />
   </ItemGroup>
   <ItemGroup>

Source/Core/Common/Src/StdConditionVariable.h

@@ -5,12 +5,16 @@
 #define GCC_VER(x,y,z)	((x) * 10000 + (y) * 100 + (z))
 #define GCC_VERSION GCC_VER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
 
+#ifndef __has_include
+#define __has_include(s) 0
+#endif
+
 #if GCC_VERSION >= GCC_VER(4,4,0) && __GXX_EXPERIMENTAL_CXX0X__ && !ANDROID
 
 // GCC 4.4 provides <condition_variable>
 #include <condition_variable>
 
-#elif defined(__has_include) && __has_include(<condition_variable>)
+#elif __has_include(<condition_variable>)
 
 // clang and libc++ provide <condition_variable> on OSX. However, the version
 // of libc++ bundled with OSX 10.7 and 10.8 is buggy: it uses _ as a variable.

Source/Core/Common/Src/StdMutex.h

@@ -0,0 +1,365 @@
+
+#ifndef MUTEX_H_
+#define MUTEX_H_
+
+#define GCC_VER(x,y,z)	((x) * 10000 + (y) * 100 + (z))
+#define GCC_VERSION GCC_VER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+
+#ifndef __has_include
+#define __has_include(s) 0
+#endif
+
+#if GCC_VERSION >= GCC_VER(4,4,0) && __GXX_EXPERIMENTAL_CXX0X__ && !ANDROID
+// GCC 4.4 provides <mutex>
+#include <mutex>
+#elif __has_include(<mutex>)
+// Clang + libc++
+#include <mutex>
+#else
+
+// partial <mutex> implementation for win32/pthread
+
+#include <algorithm>
+
+#if defined(_WIN32)
+// WIN32
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+
+#else
+// POSIX
+#include <pthread.h>
+
+#endif
+
+#if (_MSC_VER >= 1600) || (GCC_VERSION >= GCC_VER(4,3,0) && __GXX_EXPERIMENTAL_CXX0X__)
+#define USE_RVALUE_REFERENCES
+#endif
+
+#if defined(_WIN32) && defined(_M_X64)
+#define USE_SRWLOCKS
+#endif
+
+namespace std
+{
+
+class recursive_mutex
+{
+#ifdef _WIN32
+	typedef CRITICAL_SECTION native_type;
+#else
+	typedef pthread_mutex_t native_type;
+#endif
+
+public:
+	typedef native_type* native_handle_type;
+
+	recursive_mutex(const recursive_mutex&) /*= delete*/;
+	recursive_mutex& operator=(const recursive_mutex&) /*= delete*/;
+
+	recursive_mutex()
+	{
+#ifdef _WIN32
+		InitializeCriticalSection(&m_handle);
+#else
+		pthread_mutexattr_t attr;
+		pthread_mutexattr_init(&attr);
+		pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+		pthread_mutex_init(&m_handle, &attr);
+#endif
+	}
+
+	~recursive_mutex()
+	{
+#ifdef _WIN32
+		DeleteCriticalSection(&m_handle);
+#else
+		pthread_mutex_destroy(&m_handle);
+#endif
+	}
+
+	void lock()
+	{
+#ifdef _WIN32
+		EnterCriticalSection(&m_handle);
+#else
+		pthread_mutex_lock(&m_handle);
+#endif
+	}
+
+	void unlock()
+	{
+#ifdef _WIN32
+		LeaveCriticalSection(&m_handle);
+#else
+		pthread_mutex_unlock(&m_handle);
+#endif
+	}
+
+	bool try_lock()
+	{
+#ifdef _WIN32
+		return (0 != TryEnterCriticalSection(&m_handle));
+#else
+		return !pthread_mutex_trylock(&m_handle);
+#endif	
+	}
+
+	native_handle_type native_handle()
+	{
+		return &m_handle;
+	}
+
+private:
+	native_type m_handle;
+};
+
+#if !defined(_WIN32) || defined(USE_SRWLOCKS)
+
+class mutex
+{
+#ifdef _WIN32
+	typedef SRWLOCK native_type;
+#else
+	typedef pthread_mutex_t native_type;
+#endif
+
+public:
+	typedef native_type* native_handle_type;
+
+	mutex(const mutex&) /*= delete*/;
+	mutex& operator=(const mutex&) /*= delete*/;
+
+	mutex()
+	{
+#ifdef _WIN32
+		InitializeSRWLock(&m_handle);
+#else
+		pthread_mutex_init(&m_handle, NULL);
+#endif
+	}
+
+	~mutex()
+	{
+#ifdef _WIN32
+#else
+		pthread_mutex_destroy(&m_handle);
+#endif
+	}
+
+	void lock()
+	{
+#ifdef _WIN32
+		AcquireSRWLockExclusive(&m_handle);
+#else
+		pthread_mutex_lock(&m_handle);
+#endif
+	}
+
+	void unlock()
+	{
+#ifdef _WIN32
+		ReleaseSRWLockExclusive(&m_handle);
+#else
+		pthread_mutex_unlock(&m_handle);
+#endif
+	}
+
+	bool try_lock()
+	{
+#ifdef _WIN32
+		// XXX TryAcquireSRWLockExclusive requires Windows 7!
+		// return (0 != TryAcquireSRWLockExclusive(&m_handle));
+		return false;
+#else
+		return !pthread_mutex_trylock(&m_handle);
+#endif
+	}
+
+	native_handle_type native_handle()
+	{
+		return &m_handle;
+	}
+
+private:
+	native_type m_handle;
+};
+
+#else
+typedef recursive_mutex mutex;	// just use CriticalSections
+
+#endif
+
+enum defer_lock_t { defer_lock };
+enum try_to_lock_t { try_to_lock };
+enum adopt_lock_t { adopt_lock };
+
+template <class Mutex>
+class lock_guard
+{
+public:
+	typedef Mutex mutex_type;
+
+	explicit lock_guard(mutex_type& m)
+		: pm(m)
+	{
+		m.lock();
+	}
+
+	lock_guard(mutex_type& m, adopt_lock_t)
+		: pm(m)
+	{
+	}
+
+	~lock_guard()
+	{
+		pm.unlock();
+	}
+
+	lock_guard(lock_guard const&) /*= delete*/;
+	lock_guard& operator=(lock_guard const&) /*= delete*/;
+
+private:
+	mutex_type& pm;
+};
+
+template <class Mutex>
+class unique_lock
+{
+public:
+	typedef Mutex mutex_type;
+
+	unique_lock()
+		: pm(NULL), owns(false)
+	{}
+
+	/*explicit*/ unique_lock(mutex_type& m)
+		: pm(&m), owns(true)
+	{
+		m.lock();
+	}
+
+	unique_lock(mutex_type& m, defer_lock_t)
+		: pm(&m), owns(false)
+	{}
+
+	unique_lock(mutex_type& m, try_to_lock_t)
+		: pm(&m), owns(m.try_lock())
+	{}
+
+	unique_lock(mutex_type& m, adopt_lock_t)
+		: pm(&m), owns(true)
+	{}
+
+	//template <class Clock, class Duration>
+	//unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
+
+	//template <class Rep, class Period>
+	//unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
+
+	~unique_lock()
+	{
+		if (owns_lock())
+			mutex()->unlock();
+	}
+
+#ifdef USE_RVALUE_REFERENCES
+	unique_lock& operator=(const unique_lock&) /*= delete*/;
+
+	unique_lock& operator=(unique_lock&& other)
+	{
+#else
+	unique_lock& operator=(const unique_lock& u)
+	{
+		// ugly const_cast to get around lack of rvalue references
+		unique_lock& other = const_cast<unique_lock&>(u);
+#endif
+		swap(other);
+		return *this;
+	}
+	
+#ifdef USE_RVALUE_REFERENCES
+	unique_lock(const unique_lock&) /*= delete*/;
+	
+	unique_lock(unique_lock&& other)
+		: pm(NULL), owns(false)
+	{
+#else
+	unique_lock(const unique_lock& u)
+		: pm(NULL), owns(false)
+	{
+		// ugly const_cast to get around lack of rvalue references
+		unique_lock& other = const_cast<unique_lock&>(u);	
+#endif
+		swap(other);
+	}
+
+	void lock()
+	{
+		mutex()->lock();
+		owns = true;
+	}
+
+	bool try_lock()
+	{
+		owns = mutex()->try_lock();
+		return owns;
+	}
+
+	//template <class Rep, class Period>
+	//bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
+	//template <class Clock, class Duration>
+	//bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
+	
+	void unlock()
+	{
+		mutex()->unlock();
+		owns = false;
+	}
+
+	void swap(unique_lock& u)
+	{
+		std::swap(pm, u.pm);
+		std::swap(owns, u.owns);
+	}
+
+	mutex_type* release()
+	{
+		auto const ret = mutex();
+
+		pm = NULL;
+		owns = false;
+
+		return ret;
+	}
+
+	bool owns_lock() const
+	{
+		return owns;
+	}
+
+	//explicit operator bool () const
+	//{
+	//	return owns_lock();
+	//}
+
+	mutex_type* mutex() const
+	{
+		return pm;
+	}
+
+private:
+	mutex_type* pm;
+	bool owns;
+};
+
+template <class Mutex>
+void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y)
+{
+	x.swap(y);
+}
+
+}
+
+#endif
+#endif

Source/Core/Common/Src/StdThread.h

@@ -0,0 +1,317 @@
+
+#ifndef STD_THREAD_H_
+#define STD_THREAD_H_
+
+#define GCC_VER(x,y,z)	((x) * 10000 + (y) * 100 + (z))
+#define GCC_VERSION GCC_VER(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+
+#ifndef __has_include
+#define __has_include(s) 0
+#endif
+
+#if GCC_VERSION >= GCC_VER(4,4,0) && __GXX_EXPERIMENTAL_CXX0X__ && !ANDROID
+// GCC 4.4 provides <thread>
+#ifndef _GLIBCXX_USE_SCHED_YIELD
+#define _GLIBCXX_USE_SCHED_YIELD
+#endif
+#include <thread>
+#elif __has_include(<thread>)
+// Clang + libc++
+#include <thread>
+#else
+
+// partial std::thread implementation for win32/pthread
+
+#include <algorithm>
+
+#if (_MSC_VER >= 1600) || (GCC_VERSION >= GCC_VER(4,3,0) && __GXX_EXPERIMENTAL_CXX0X__)
+#define USE_RVALUE_REFERENCES
+#endif
+
+#ifdef __APPLE__
+#import <Foundation/NSAutoreleasePool.h>
+#endif
+
+#if defined(_WIN32)
+// WIN32
+
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+
+#if defined(_MSC_VER) && defined(_MT)
+// When linking with LIBCMT (the multithreaded C library), Microsoft recommends
+// using _beginthreadex instead of CreateThread.
+#define USE_BEGINTHREADEX
+#include <process.h>
+#endif
+
+#ifdef USE_BEGINTHREADEX
+#define THREAD_ID unsigned
+#define THREAD_RETURN unsigned __stdcall
+#else
+#define THREAD_ID DWORD
+#define THREAD_RETURN DWORD WINAPI
+#endif
+#define THREAD_HANDLE HANDLE
+
+#else
+// PTHREAD
+
+#include <unistd.h>
+
+#ifndef _POSIX_THREADS
+#error unsupported platform (no pthreads?)
+#endif
+
+#include <pthread.h>
+
+#define THREAD_ID pthread_t
+#define THREAD_HANDLE pthread_t
+#define THREAD_RETURN void*
+
+#endif
+
+namespace std
+{
+
+class thread
+{
+public:
+	typedef THREAD_HANDLE native_handle_type;
+
+	class id
+	{
+		friend class thread;
+	public:
+		id() : m_thread(0) {}
+		id(THREAD_ID _id) : m_thread(_id) {}
+
+		bool operator==(const id& rhs) const
+		{
+			return m_thread == rhs.m_thread;
+		}
+
+		bool operator!=(const id& rhs) const
+		{
+			return !(*this == rhs);
+		}
+
+		bool operator<(const id& rhs) const
+		{
+			return m_thread < rhs.m_thread;
+		}
+
+	private:
+		THREAD_ID m_thread;
+	};
+
+	// no variadic template support in msvc
+	//template <typename C, typename... A>
+	//thread(C&& func, A&&... args);
+
+	template <typename C>
+	thread(C func)
+	{
+		StartThread(new Func<C>(func));
+	}
+
+	template <typename C, typename A>
+	thread(C func, A arg)
+	{
+		StartThread(new FuncArg<C, A>(func, arg));
+	}
+
+	thread() /*= default;*/ {}
+
+#ifdef USE_RVALUE_REFERENCES
+	thread(const thread&) /*= delete*/;
+
+	thread(thread&& other)
+	{
+#else
+	thread(const thread& t)
+	{
+		// ugly const_cast to get around lack of rvalue references
+		thread& other = const_cast<thread&>(t);
+#endif
+		swap(other);
+	}
+
+#ifdef USE_RVALUE_REFERENCES
+	thread& operator=(const thread&) /*= delete*/;
+
+	thread& operator=(thread&& other)
+	{
+#else
+	thread& operator=(const thread& t)
+	{
+		// ugly const_cast to get around lack of rvalue references
+		thread& other = const_cast<thread&>(t);
+#endif
+		if (joinable())
+			detach();
+		swap(other);
+		return *this;
+	}
+
+	~thread()
+	{
+		if (joinable())
+			detach();
+	}
+
+	bool joinable() const
+	{
+		return m_id != id();
+	}
+
+	id get_id() const
+	{
+		return m_id;
+	}
+
+	native_handle_type native_handle()
+	{
+#ifdef _WIN32
+		return m_handle;
+#else
+		return m_id.m_thread;
+#endif
+	}
+
+	void join()
+	{
+#ifdef _WIN32
+		WaitForSingleObject(m_handle, INFINITE);
+		detach();
+#else
+		pthread_join(m_id.m_thread, NULL);
+		m_id = id();
+#endif
+	}
+
+	void detach()
+	{
+#ifdef _WIN32
+		CloseHandle(m_handle);
+#else
+		pthread_detach(m_id.m_thread);
+#endif
+		m_id = id();
+	}
+
+	void swap(thread& other)
+	{
+		std::swap(m_id, other.m_id);
+#ifdef _WIN32
+		std::swap(m_handle, other.m_handle);
+#endif
+	}
+	
+	static unsigned hardware_concurrency()
+	{
+#ifdef _WIN32
+		SYSTEM_INFO sysinfo;
+		GetSystemInfo(&sysinfo);
+		return static_cast<unsigned>(sysinfo.dwNumberOfProcessors);
+#else
+		return 0;
+#endif
+	}
+
+private:
+	id m_id;
+	
+#ifdef _WIN32
+	native_handle_type m_handle;
+#endif
+
+	template <typename F>
+	void StartThread(F* param)
+	{
+#ifdef USE_BEGINTHREADEX
+		m_handle = (HANDLE)_beginthreadex(NULL, 0, &RunAndDelete<F>, param, 0, &m_id.m_thread);
+#elif defined(_WIN32)
+		m_handle = CreateThread(NULL, 0, &RunAndDelete<F>, param, 0, &m_id.m_thread);
+#else
+		pthread_attr_t attr;
+		pthread_attr_init(&attr);
+		pthread_attr_setstacksize(&attr, 1024 * 1024);
+		if (pthread_create(&m_id.m_thread, &attr, &RunAndDelete<F>, param))
+			m_id = id();
+#endif
+	}
+	
+	template <typename C>
+	class Func
+	{
+	public:
+		Func(C _func) : func(_func) {}
+
+		void Run() { func(); }
+
+	private:
+		C const func;
+	};
+
+	template <typename C, typename A>
+	class FuncArg
+	{
+	public:
+		FuncArg(C _func, A _arg) : func(_func), arg(_arg) {}
+
+		void Run() { func(arg); }
+
+	private:
+		C const func;
+		A arg;
+	};
+
+	template <typename F>
+	static THREAD_RETURN RunAndDelete(void* param)
+	{
+#ifdef __APPLE__
+		NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+#endif
+		static_cast<F*>(param)->Run();
+		delete static_cast<F*>(param);
+#ifdef __APPLE__
+		[pool release];
+#endif
+		return 0;
+	}
+};
+
+namespace this_thread
+{
+
+inline void yield()
+{
+#ifdef _WIN32
+	SwitchToThread();
+#else
+	sleep(0);
+#endif
+}
+
+inline thread::id get_id()
+{
+#ifdef _WIN32
+	return GetCurrentThreadId();
+#else
+	return pthread_self();
+#endif
+}
+
+}	// namespace this_thread
+
+}	// namespace std
+
+#undef USE_RVALUE_REFERENCES
+#undef USE_BEGINTHREADEX
+#undef THREAD_ID
+#undef THREAD_RETURN
+#undef THREAD_HANDLE
+
+#endif
+#endif

Source/Core/Common/Src/Thread.h

@@ -18,16 +18,9 @@
 #ifndef _THREAD_H_
 #define _THREAD_H_
 
-// <condition_variable> has a bug in some versions of libc++: it uses _ as a variable.
-// This conflicts with gettext's use of _ as a macro.
-#undef _
-
 #include "StdConditionVariable.h"
-#include <mutex>
-#include <thread>
-
-// Restore _
-#define _(s) wxGetTranslation((s))
+#include "StdMutex.h"
+#include "StdThread.h"
 
 // Don't include common.h here as it will break LogManager
 #include "CommonTypes.h"