diff --git a/Source/Core/Common/Common.vcxproj b/Source/Core/Common/Common.vcxproj
index e8e45187b7..822fafe74b 100644
--- a/Source/Core/Common/Common.vcxproj
+++ b/Source/Core/Common/Common.vcxproj
@@ -242,6 +242,8 @@
+
+
@@ -259,4 +261,4 @@
-
+
\ No newline at end of file
diff --git a/Source/Core/Common/Common.vcxproj.filters b/Source/Core/Common/Common.vcxproj.filters
index 878ead5d27..d427b70cdd 100644
--- a/Source/Core/Common/Common.vcxproj.filters
+++ b/Source/Core/Common/Common.vcxproj.filters
@@ -85,7 +85,7 @@
-
+
@@ -119,6 +119,8 @@
Crypto
+
+
@@ -132,4 +134,4 @@
{f078f36e-a0ff-4cd0-95f8-476100d68e68}
-
+
\ No newline at end of file
diff --git a/Source/Core/Common/Src/StdConditionVariable.h b/Source/Core/Common/Src/StdConditionVariable.h
index 9a045a650b..952f9e00a2 100644
--- a/Source/Core/Common/Src/StdConditionVariable.h
+++ b/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
#include
-#elif defined(__has_include) && __has_include()
+#elif __has_include()
// clang and libc++ provide on OSX. However, the version
// of libc++ bundled with OSX 10.7 and 10.8 is buggy: it uses _ as a variable.
diff --git a/Source/Core/Common/Src/StdMutex.h b/Source/Core/Common/Src/StdMutex.h
new file mode 100644
index 0000000000..a20c7f744a
--- /dev/null
+++ b/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
+#include
+#elif __has_include()
+// Clang + libc++
+#include
+#else
+
+// partial implementation for win32/pthread
+
+#include
+
+#if defined(_WIN32)
+// WIN32
+#define WIN32_LEAN_AND_MEAN
+#include
+
+#else
+// POSIX
+#include
+
+#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 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 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
+ //unique_lock(mutex_type& m, const chrono::time_point& abs_time);
+
+ //template
+ //unique_lock(mutex_type& m, const chrono::duration& 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(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(u);
+#endif
+ swap(other);
+ }
+
+ void lock()
+ {
+ mutex()->lock();
+ owns = true;
+ }
+
+ bool try_lock()
+ {
+ owns = mutex()->try_lock();
+ return owns;
+ }
+
+ //template
+ //bool try_lock_for(const chrono::duration& rel_time);
+ //template
+ //bool try_lock_until(const chrono::time_point& 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
+void swap(unique_lock& x, unique_lock& y)
+{
+ x.swap(y);
+}
+
+}
+
+#endif
+#endif
diff --git a/Source/Core/Common/Src/StdThread.h b/Source/Core/Common/Src/StdThread.h
new file mode 100644
index 0000000000..19dfd60c37
--- /dev/null
+++ b/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
+#ifndef _GLIBCXX_USE_SCHED_YIELD
+#define _GLIBCXX_USE_SCHED_YIELD
+#endif
+#include
+#elif __has_include()
+// Clang + libc++
+#include
+#else
+
+// partial std::thread implementation for win32/pthread
+
+#include
+
+#if (_MSC_VER >= 1600) || (GCC_VERSION >= GCC_VER(4,3,0) && __GXX_EXPERIMENTAL_CXX0X__)
+#define USE_RVALUE_REFERENCES
+#endif
+
+#ifdef __APPLE__
+#import
+#endif
+
+#if defined(_WIN32)
+// WIN32
+
+#define WIN32_LEAN_AND_MEAN
+#include
+
+#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
+#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
+
+#ifndef _POSIX_THREADS
+#error unsupported platform (no pthreads?)
+#endif
+
+#include
+
+#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
+ //thread(C&& func, A&&... args);
+
+ template
+ thread(C func)
+ {
+ StartThread(new Func(func));
+ }
+
+ template
+ thread(C func, A arg)
+ {
+ StartThread(new FuncArg(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(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(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(sysinfo.dwNumberOfProcessors);
+#else
+ return 0;
+#endif
+ }
+
+private:
+ id m_id;
+
+#ifdef _WIN32
+ native_handle_type m_handle;
+#endif
+
+ template
+ void StartThread(F* param)
+ {
+#ifdef USE_BEGINTHREADEX
+ m_handle = (HANDLE)_beginthreadex(NULL, 0, &RunAndDelete, param, 0, &m_id.m_thread);
+#elif defined(_WIN32)
+ m_handle = CreateThread(NULL, 0, &RunAndDelete, 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, param))
+ m_id = id();
+#endif
+ }
+
+ template
+ class Func
+ {
+ public:
+ Func(C _func) : func(_func) {}
+
+ void Run() { func(); }
+
+ private:
+ C const func;
+ };
+
+ template
+ class FuncArg
+ {
+ public:
+ FuncArg(C _func, A _arg) : func(_func), arg(_arg) {}
+
+ void Run() { func(arg); }
+
+ private:
+ C const func;
+ A arg;
+ };
+
+ template
+ static THREAD_RETURN RunAndDelete(void* param)
+ {
+#ifdef __APPLE__
+ NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+#endif
+ static_cast(param)->Run();
+ delete static_cast(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
diff --git a/Source/Core/Common/Src/Thread.h b/Source/Core/Common/Src/Thread.h
index 1eb671f223..e35e73dbe9 100644
--- a/Source/Core/Common/Src/Thread.h
+++ b/Source/Core/Common/Src/Thread.h
@@ -18,16 +18,9 @@
#ifndef _THREAD_H_
#define _THREAD_H_
-// 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
-#include
-
-// 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"